ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/hopm/releases/1.0.4/ltmain.sh
Revision: 5052
Committed: Mon Dec 22 11:56:03 2014 UTC (9 years, 3 months ago) by michael
Content type: text/x-sh
Original Path: hopm/trunk/ltmain.sh
File size: 196719 byte(s)
Log Message:
- Initial import of bopm 3.1.3

File Contents

# User Rev Content
1 michael 5052 # ltmain.sh - Provide generalized library-building support services.
2     # NOTE: Changing this file will not affect anything until you rerun configure.
3     #
4     # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
5     # Free Software Foundation, Inc.
6     # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
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 of the License, or
11     # (at your option) any later version.
12     #
13     # This program is distributed in the hope that it will be useful, but
14     # WITHOUT ANY WARRANTY; without even the implied warranty of
15     # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16     # 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, write to the Free Software
20     # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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     basename="s,^.*/,,g"
28    
29     # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
30     # is ksh but when the shell is invoked as "sh" and the current value of
31     # the _XPG environment variable is not equal to 1 (one), the special
32     # positional parameter $0, within a function call, is the name of the
33     # function.
34     progpath="$0"
35    
36     # The name of this program:
37     progname=`echo "$progpath" | $SED $basename`
38     modename="$progname"
39    
40     # Global variables:
41     EXIT_SUCCESS=0
42     EXIT_FAILURE=1
43    
44     PROGRAM=ltmain.sh
45     PACKAGE=libtool
46     VERSION="1.5.22 Debian 1.5.22-4"
47     TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
48    
49     # See if we are running on zsh, and set the options which allow our
50     # commands through without removal of \ escapes.
51     if test -n "${ZSH_VERSION+set}" ; then
52     setopt NO_GLOB_SUBST
53     fi
54    
55     # Check that we have a working $echo.
56     if test "X$1" = X--no-reexec; then
57     # Discard the --no-reexec flag, and continue.
58     shift
59     elif test "X$1" = X--fallback-echo; then
60     # Avoid inline document here, it may be left over
61     :
62     elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
63     # Yippee, $echo works!
64     :
65     else
66     # Restart under the correct shell, and then maybe $echo will work.
67     exec $SHELL "$progpath" --no-reexec ${1+"$@"}
68     fi
69    
70     if test "X$1" = X--fallback-echo; then
71     # used as fallback echo
72     shift
73     cat <<EOF
74     $*
75     EOF
76     exit $EXIT_SUCCESS
77     fi
78    
79     default_mode=
80     help="Try \`$progname --help' for more information."
81     magic="%%%MAGIC variable%%%"
82     mkdir="mkdir"
83     mv="mv -f"
84     rm="rm -f"
85    
86     # Sed substitution that helps us do robust quoting. It backslashifies
87     # metacharacters that are still active within double-quoted strings.
88     Xsed="${SED}"' -e 1s/^X//'
89     sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
90     # test EBCDIC or ASCII
91     case `echo X|tr X '\101'` in
92     A) # ASCII based system
93     # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
94     SP2NL='tr \040 \012'
95     NL2SP='tr \015\012 \040\040'
96     ;;
97     *) # EBCDIC based system
98     SP2NL='tr \100 \n'
99     NL2SP='tr \r\n \100\100'
100     ;;
101     esac
102    
103     # NLS nuisances.
104     # Only set LANG and LC_ALL to C if already set.
105     # These must not be set unconditionally because not all systems understand
106     # e.g. LANG=C (notably SCO).
107     # We save the old values to restore during execute mode.
108     if test "${LC_ALL+set}" = set; then
109     save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
110     fi
111     if test "${LANG+set}" = set; then
112     save_LANG="$LANG"; LANG=C; export LANG
113     fi
114    
115     # Make sure IFS has a sensible default
116     lt_nl='
117     '
118     IFS=" $lt_nl"
119    
120     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
121     $echo "$modename: not configured to build any kind of library" 1>&2
122     $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
123     exit $EXIT_FAILURE
124     fi
125    
126     # Global variables.
127     mode=$default_mode
128     nonopt=
129     prev=
130     prevopt=
131     run=
132     show="$echo"
133     show_help=
134     execute_dlfiles=
135     duplicate_deps=no
136     preserve_args=
137     lo2o="s/\\.lo\$/.${objext}/"
138     o2lo="s/\\.${objext}\$/.lo/"
139    
140     #####################################
141     # Shell function definitions:
142     # This seems to be the best place for them
143    
144     # func_mktempdir [string]
145     # Make a temporary directory that won't clash with other running
146     # libtool processes, and avoids race conditions if possible. If
147     # given, STRING is the basename for that directory.
148     func_mktempdir ()
149     {
150     my_template="${TMPDIR-/tmp}/${1-$progname}"
151    
152     if test "$run" = ":"; then
153     # Return a directory name, but don't create it in dry-run mode
154     my_tmpdir="${my_template}-$$"
155     else
156    
157     # If mktemp works, use that first and foremost
158     my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
159    
160     if test ! -d "$my_tmpdir"; then
161     # Failing that, at least try and use $RANDOM to avoid a race
162     my_tmpdir="${my_template}-${RANDOM-0}$$"
163    
164     save_mktempdir_umask=`umask`
165     umask 0077
166     $mkdir "$my_tmpdir"
167     umask $save_mktempdir_umask
168     fi
169    
170     # If we're not in dry-run mode, bomb out on failure
171     test -d "$my_tmpdir" || {
172     $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
173     exit $EXIT_FAILURE
174     }
175     fi
176    
177     $echo "X$my_tmpdir" | $Xsed
178     }
179    
180    
181     # func_win32_libid arg
182     # return the library type of file 'arg'
183     #
184     # Need a lot of goo to handle *both* DLLs and import libs
185     # Has to be a shell function in order to 'eat' the argument
186     # that is supplied when $file_magic_command is called.
187     func_win32_libid ()
188     {
189     win32_libid_type="unknown"
190     win32_fileres=`file -L $1 2>/dev/null`
191     case $win32_fileres in
192     *ar\ archive\ import\ library*) # definitely import
193     win32_libid_type="x86 archive import"
194     ;;
195     *ar\ archive*) # could be an import, or static
196     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
197     $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
198     win32_nmres=`eval $NM -f posix -A $1 | \
199     $SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`
200     case $win32_nmres in
201     import*) win32_libid_type="x86 archive import";;
202     *) win32_libid_type="x86 archive static";;
203     esac
204     fi
205     ;;
206     *DLL*)
207     win32_libid_type="x86 DLL"
208     ;;
209     *executable*) # but shell scripts are "executable" too...
210     case $win32_fileres in
211     *MS\ Windows\ PE\ Intel*)
212     win32_libid_type="x86 DLL"
213     ;;
214     esac
215     ;;
216     esac
217     $echo $win32_libid_type
218     }
219    
220    
221     # func_infer_tag arg
222     # Infer tagged configuration to use if any are available and
223     # if one wasn't chosen via the "--tag" command line option.
224     # Only attempt this if the compiler in the base compile
225     # command doesn't match the default compiler.
226     # arg is usually of the form 'gcc ...'
227     func_infer_tag ()
228     {
229     if test -n "$available_tags" && test -z "$tagname"; then
230     CC_quoted=
231     for arg in $CC; do
232     case $arg in
233     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
234     arg="\"$arg\""
235     ;;
236     esac
237     CC_quoted="$CC_quoted $arg"
238     done
239     case $@ in
240     # Blanks in the command may have been stripped by the calling shell,
241     # but not from the CC environment variable when configure was run.
242     " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
243     # Blanks at the start of $base_compile will cause this to fail
244     # if we don't check for them as well.
245     *)
246     for z in $available_tags; do
247     if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
248     # Evaluate the configuration.
249     eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
250     CC_quoted=
251     for arg in $CC; do
252     # Double-quote args containing other shell metacharacters.
253     case $arg in
254     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
255     arg="\"$arg\""
256     ;;
257     esac
258     CC_quoted="$CC_quoted $arg"
259     done
260     case "$@ " in
261     " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
262     # The compiler in the base compile command matches
263     # the one in the tagged configuration.
264     # Assume this is the tagged configuration we want.
265     tagname=$z
266     break
267     ;;
268     esac
269     fi
270     done
271     # If $tagname still isn't set, then no tagged configuration
272     # was found and let the user know that the "--tag" command
273     # line option must be used.
274     if test -z "$tagname"; then
275     $echo "$modename: unable to infer tagged configuration"
276     $echo "$modename: specify a tag with \`--tag'" 1>&2
277     exit $EXIT_FAILURE
278     # else
279     # $echo "$modename: using $tagname tagged configuration"
280     fi
281     ;;
282     esac
283     fi
284     }
285    
286    
287     # func_extract_an_archive dir oldlib
288     func_extract_an_archive ()
289     {
290     f_ex_an_ar_dir="$1"; shift
291     f_ex_an_ar_oldlib="$1"
292    
293     $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
294     $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
295     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
296     :
297     else
298     $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
299     exit $EXIT_FAILURE
300     fi
301     }
302    
303     # func_extract_archives gentop oldlib ...
304     func_extract_archives ()
305     {
306     my_gentop="$1"; shift
307     my_oldlibs=${1+"$@"}
308     my_oldobjs=""
309     my_xlib=""
310     my_xabs=""
311     my_xdir=""
312     my_status=""
313    
314     $show "${rm}r $my_gentop"
315     $run ${rm}r "$my_gentop"
316     $show "$mkdir $my_gentop"
317     $run $mkdir "$my_gentop"
318     my_status=$?
319     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
320     exit $my_status
321     fi
322    
323     for my_xlib in $my_oldlibs; do
324     # Extract the objects.
325     case $my_xlib in
326     [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
327     *) my_xabs=`pwd`"/$my_xlib" ;;
328     esac
329     my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
330     my_xdir="$my_gentop/$my_xlib"
331    
332     $show "${rm}r $my_xdir"
333     $run ${rm}r "$my_xdir"
334     $show "$mkdir $my_xdir"
335     $run $mkdir "$my_xdir"
336     exit_status=$?
337     if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
338     exit $exit_status
339     fi
340     case $host in
341     *-darwin*)
342     $show "Extracting $my_xabs"
343     # Do not bother doing anything if just a dry run
344     if test -z "$run"; then
345     darwin_orig_dir=`pwd`
346     cd $my_xdir || exit $?
347     darwin_archive=$my_xabs
348     darwin_curdir=`pwd`
349     darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
350     darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
351     if test -n "$darwin_arches"; then
352     darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
353     darwin_arch=
354     $show "$darwin_base_archive has multiple architectures $darwin_arches"
355     for darwin_arch in $darwin_arches ; do
356     mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
357     lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
358     cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
359     func_extract_an_archive "`pwd`" "${darwin_base_archive}"
360     cd "$darwin_curdir"
361     $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
362     done # $darwin_arches
363     ## Okay now we have a bunch of thin objects, gotta fatten them up :)
364     darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
365     darwin_file=
366     darwin_files=
367     for darwin_file in $darwin_filelist; do
368     darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
369     lipo -create -output "$darwin_file" $darwin_files
370     done # $darwin_filelist
371     ${rm}r unfat-$$
372     cd "$darwin_orig_dir"
373     else
374     cd "$darwin_orig_dir"
375     func_extract_an_archive "$my_xdir" "$my_xabs"
376     fi # $darwin_arches
377     fi # $run
378     ;;
379     *)
380     func_extract_an_archive "$my_xdir" "$my_xabs"
381     ;;
382     esac
383     my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
384     done
385     func_extract_archives_result="$my_oldobjs"
386     }
387     # End of Shell function definitions
388     #####################################
389    
390     # Darwin sucks
391     eval std_shrext=\"$shrext_cmds\"
392    
393     disable_libs=no
394    
395     # Parse our command line options once, thoroughly.
396     while test "$#" -gt 0
397     do
398     arg="$1"
399     shift
400    
401     case $arg in
402     -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
403     *) optarg= ;;
404     esac
405    
406     # If the previous option needs an argument, assign it.
407     if test -n "$prev"; then
408     case $prev in
409     execute_dlfiles)
410     execute_dlfiles="$execute_dlfiles $arg"
411     ;;
412     tag)
413     tagname="$arg"
414     preserve_args="${preserve_args}=$arg"
415    
416     # Check whether tagname contains only valid characters
417     case $tagname in
418     *[!-_A-Za-z0-9,/]*)
419     $echo "$progname: invalid tag name: $tagname" 1>&2
420     exit $EXIT_FAILURE
421     ;;
422     esac
423    
424     case $tagname in
425     CC)
426     # Don't test for the "default" C tag, as we know, it's there, but
427     # not specially marked.
428     ;;
429     *)
430     if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
431     taglist="$taglist $tagname"
432     # Evaluate the configuration.
433     eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
434     else
435     $echo "$progname: ignoring unknown tag $tagname" 1>&2
436     fi
437     ;;
438     esac
439     ;;
440     *)
441     eval "$prev=\$arg"
442     ;;
443     esac
444    
445     prev=
446     prevopt=
447     continue
448     fi
449    
450     # Have we seen a non-optional argument yet?
451     case $arg in
452     --help)
453     show_help=yes
454     ;;
455    
456     --version)
457     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
458     $echo
459     $echo "Copyright (C) 2005 Free Software Foundation, Inc."
460     $echo "This is free software; see the source for copying conditions. There is NO"
461     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
462     exit $?
463     ;;
464    
465     --config)
466     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
467     # Now print the configurations for the tags.
468     for tagname in $taglist; do
469     ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
470     done
471     exit $?
472     ;;
473    
474     --debug)
475     $echo "$progname: enabling shell trace mode"
476     set -x
477     preserve_args="$preserve_args $arg"
478     ;;
479    
480     --dry-run | -n)
481     run=:
482     ;;
483    
484     --features)
485     $echo "host: $host"
486     if test "$build_libtool_libs" = yes; then
487     $echo "enable shared libraries"
488     else
489     $echo "disable shared libraries"
490     fi
491     if test "$build_old_libs" = yes; then
492     $echo "enable static libraries"
493     else
494     $echo "disable static libraries"
495     fi
496     exit $?
497     ;;
498    
499     --finish) mode="finish" ;;
500    
501     --mode) prevopt="--mode" prev=mode ;;
502     --mode=*) mode="$optarg" ;;
503    
504     --preserve-dup-deps) duplicate_deps="yes" ;;
505    
506     --quiet | --silent)
507     show=:
508     preserve_args="$preserve_args $arg"
509     ;;
510    
511     --tag)
512     prevopt="--tag"
513     prev=tag
514     preserve_args="$preserve_args --tag"
515     ;;
516     --tag=*)
517     set tag "$optarg" ${1+"$@"}
518     shift
519     prev=tag
520     preserve_args="$preserve_args --tag"
521     ;;
522    
523     -dlopen)
524     prevopt="-dlopen"
525     prev=execute_dlfiles
526     ;;
527    
528     -*)
529     $echo "$modename: unrecognized option \`$arg'" 1>&2
530     $echo "$help" 1>&2
531     exit $EXIT_FAILURE
532     ;;
533    
534     *)
535     nonopt="$arg"
536     break
537     ;;
538     esac
539     done
540    
541     if test -n "$prevopt"; then
542     $echo "$modename: option \`$prevopt' requires an argument" 1>&2
543     $echo "$help" 1>&2
544     exit $EXIT_FAILURE
545     fi
546    
547     case $disable_libs in
548     no)
549     ;;
550     shared)
551     build_libtool_libs=no
552     build_old_libs=yes
553     ;;
554     static)
555     build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
556     ;;
557     esac
558    
559     # If this variable is set in any of the actions, the command in it
560     # will be execed at the end. This prevents here-documents from being
561     # left over by shells.
562     exec_cmd=
563    
564     if test -z "$show_help"; then
565    
566     # Infer the operation mode.
567     if test -z "$mode"; then
568     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
569     $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
570     case $nonopt in
571     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
572     mode=link
573     for arg
574     do
575     case $arg in
576     -c)
577     mode=compile
578     break
579     ;;
580     esac
581     done
582     ;;
583     *db | *dbx | *strace | *truss)
584     mode=execute
585     ;;
586     *install*|cp|mv)
587     mode=install
588     ;;
589     *rm)
590     mode=uninstall
591     ;;
592     *)
593     # If we have no mode, but dlfiles were specified, then do execute mode.
594     test -n "$execute_dlfiles" && mode=execute
595    
596     # Just use the default operation mode.
597     if test -z "$mode"; then
598     if test -n "$nonopt"; then
599     $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
600     else
601     $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
602     fi
603     fi
604     ;;
605     esac
606     fi
607    
608     # Only execute mode is allowed to have -dlopen flags.
609     if test -n "$execute_dlfiles" && test "$mode" != execute; then
610     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
611     $echo "$help" 1>&2
612     exit $EXIT_FAILURE
613     fi
614    
615     # Change the help message to a mode-specific one.
616     generic_help="$help"
617     help="Try \`$modename --help --mode=$mode' for more information."
618    
619     # These modes are in order of execution frequency so that they run quickly.
620     case $mode in
621     # libtool compile mode
622     compile)
623     modename="$modename: compile"
624     # Get the compilation command and the source file.
625     base_compile=
626     srcfile="$nonopt" # always keep a non-empty value in "srcfile"
627     suppress_opt=yes
628     suppress_output=
629     arg_mode=normal
630     libobj=
631     later=
632    
633     for arg
634     do
635     case $arg_mode in
636     arg )
637     # do not "continue". Instead, add this to base_compile
638     lastarg="$arg"
639     arg_mode=normal
640     ;;
641    
642     target )
643     libobj="$arg"
644     arg_mode=normal
645     continue
646     ;;
647    
648     normal )
649     # Accept any command-line options.
650     case $arg in
651     -o)
652     if test -n "$libobj" ; then
653     $echo "$modename: you cannot specify \`-o' more than once" 1>&2
654     exit $EXIT_FAILURE
655     fi
656     arg_mode=target
657     continue
658     ;;
659    
660     -static | -prefer-pic | -prefer-non-pic)
661     later="$later $arg"
662     continue
663     ;;
664    
665     -no-suppress)
666     suppress_opt=no
667     continue
668     ;;
669    
670     -Xcompiler)
671     arg_mode=arg # the next one goes into the "base_compile" arg list
672     continue # The current "srcfile" will either be retained or
673     ;; # replaced later. I would guess that would be a bug.
674    
675     -Wc,*)
676     args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
677     lastarg=
678     save_ifs="$IFS"; IFS=','
679     for arg in $args; do
680     IFS="$save_ifs"
681    
682     # Double-quote args containing other shell metacharacters.
683     # Many Bourne shells cannot handle close brackets correctly
684     # in scan sets, so we specify it separately.
685     case $arg in
686     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
687     arg="\"$arg\""
688     ;;
689     esac
690     lastarg="$lastarg $arg"
691     done
692     IFS="$save_ifs"
693     lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
694    
695     # Add the arguments to base_compile.
696     base_compile="$base_compile $lastarg"
697     continue
698     ;;
699    
700     * )
701     # Accept the current argument as the source file.
702     # The previous "srcfile" becomes the current argument.
703     #
704     lastarg="$srcfile"
705     srcfile="$arg"
706     ;;
707     esac # case $arg
708     ;;
709     esac # case $arg_mode
710    
711     # Aesthetically quote the previous argument.
712     lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
713    
714     case $lastarg in
715     # Double-quote args containing other shell metacharacters.
716     # Many Bourne shells cannot handle close brackets correctly
717     # in scan sets, and some SunOS ksh mistreat backslash-escaping
718     # in scan sets (worked around with variable expansion),
719     # and furthermore cannot handle '|' '&' '(' ')' in scan sets
720     # at all, so we specify them separately.
721     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
722     lastarg="\"$lastarg\""
723     ;;
724     esac
725    
726     base_compile="$base_compile $lastarg"
727     done # for arg
728    
729     case $arg_mode in
730     arg)
731     $echo "$modename: you must specify an argument for -Xcompile"
732     exit $EXIT_FAILURE
733     ;;
734     target)
735     $echo "$modename: you must specify a target with \`-o'" 1>&2
736     exit $EXIT_FAILURE
737     ;;
738     *)
739     # Get the name of the library object.
740     [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
741     ;;
742     esac
743    
744     # Recognize several different file suffixes.
745     # If the user specifies -o file.o, it is replaced with file.lo
746     xform='[cCFSifmso]'
747     case $libobj in
748     *.ada) xform=ada ;;
749     *.adb) xform=adb ;;
750     *.ads) xform=ads ;;
751     *.asm) xform=asm ;;
752     *.c++) xform=c++ ;;
753     *.cc) xform=cc ;;
754     *.ii) xform=ii ;;
755     *.class) xform=class ;;
756     *.cpp) xform=cpp ;;
757     *.cxx) xform=cxx ;;
758     *.f90) xform=f90 ;;
759     *.for) xform=for ;;
760     *.java) xform=java ;;
761     esac
762    
763     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
764    
765     case $libobj in
766     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
767     *)
768     $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
769     exit $EXIT_FAILURE
770     ;;
771     esac
772    
773     func_infer_tag $base_compile
774    
775     for arg in $later; do
776     case $arg in
777     -static)
778     build_old_libs=yes
779     continue
780     ;;
781    
782     -prefer-pic)
783     pic_mode=yes
784     continue
785     ;;
786    
787     -prefer-non-pic)
788     pic_mode=no
789     continue
790     ;;
791     esac
792     done
793    
794     qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
795     case $qlibobj in
796     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
797     qlibobj="\"$qlibobj\"" ;;
798     esac
799     test "X$libobj" != "X$qlibobj" \
800     && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' &()|`$[]' \
801     && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
802     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
803     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
804     if test "X$xdir" = "X$obj"; then
805     xdir=
806     else
807     xdir=$xdir/
808     fi
809     lobj=${xdir}$objdir/$objname
810    
811     if test -z "$base_compile"; then
812     $echo "$modename: you must specify a compilation command" 1>&2
813     $echo "$help" 1>&2
814     exit $EXIT_FAILURE
815     fi
816    
817     # Delete any leftover library objects.
818     if test "$build_old_libs" = yes; then
819     removelist="$obj $lobj $libobj ${libobj}T"
820     else
821     removelist="$lobj $libobj ${libobj}T"
822     fi
823    
824     $run $rm $removelist
825     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
826    
827     # On Cygwin there's no "real" PIC flag so we must build both object types
828     case $host_os in
829     cygwin* | mingw* | pw32* | os2*)
830     pic_mode=default
831     ;;
832     esac
833     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
834     # non-PIC code in shared libraries is not supported
835     pic_mode=default
836     fi
837    
838     # Calculate the filename of the output object if compiler does
839     # not support -o with -c
840     if test "$compiler_c_o" = no; then
841     output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
842     lockfile="$output_obj.lock"
843     removelist="$removelist $output_obj $lockfile"
844     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
845     else
846     output_obj=
847     need_locks=no
848     lockfile=
849     fi
850    
851     # Lock this critical section if it is needed
852     # We use this script file to make the link, it avoids creating a new file
853     if test "$need_locks" = yes; then
854     until $run ln "$progpath" "$lockfile" 2>/dev/null; do
855     $show "Waiting for $lockfile to be removed"
856     sleep 2
857     done
858     elif test "$need_locks" = warn; then
859     if test -f "$lockfile"; then
860     $echo "\
861     *** ERROR, $lockfile exists and contains:
862     `cat $lockfile 2>/dev/null`
863    
864     This indicates that another process is trying to use the same
865     temporary object file, and libtool could not work around it because
866     your compiler does not support \`-c' and \`-o' together. If you
867     repeat this compilation, it may succeed, by chance, but you had better
868     avoid parallel builds (make -j) in this platform, or get a better
869     compiler."
870    
871     $run $rm $removelist
872     exit $EXIT_FAILURE
873     fi
874     $echo "$srcfile" > "$lockfile"
875     fi
876    
877     if test -n "$fix_srcfile_path"; then
878     eval srcfile=\"$fix_srcfile_path\"
879     fi
880     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
881     case $qsrcfile in
882     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
883     qsrcfile="\"$qsrcfile\"" ;;
884     esac
885    
886     $run $rm "$libobj" "${libobj}T"
887    
888     # Create a libtool object file (analogous to a ".la" file),
889     # but don't create it if we're doing a dry run.
890     test -z "$run" && cat > ${libobj}T <<EOF
891     # $libobj - a libtool object file
892     # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
893     #
894     # Please DO NOT delete this file!
895     # It is necessary for linking the library.
896    
897     # Name of the PIC object.
898     EOF
899    
900     # Only build a PIC object if we are building libtool libraries.
901     if test "$build_libtool_libs" = yes; then
902     # Without this assignment, base_compile gets emptied.
903     fbsd_hideous_sh_bug=$base_compile
904    
905     if test "$pic_mode" != no; then
906     command="$base_compile $qsrcfile $pic_flag"
907     else
908     # Don't build PIC code
909     command="$base_compile $qsrcfile"
910     fi
911    
912     if test ! -d "${xdir}$objdir"; then
913     $show "$mkdir ${xdir}$objdir"
914     $run $mkdir ${xdir}$objdir
915     exit_status=$?
916     if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
917     exit $exit_status
918     fi
919     fi
920    
921     if test -z "$output_obj"; then
922     # Place PIC objects in $objdir
923     command="$command -o $lobj"
924     fi
925    
926     $run $rm "$lobj" "$output_obj"
927    
928     $show "$command"
929     if $run eval "$command"; then :
930     else
931     test -n "$output_obj" && $run $rm $removelist
932     exit $EXIT_FAILURE
933     fi
934    
935     if test "$need_locks" = warn &&
936     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
937     $echo "\
938     *** ERROR, $lockfile contains:
939     `cat $lockfile 2>/dev/null`
940    
941     but it should contain:
942     $srcfile
943    
944     This indicates that another process is trying to use the same
945     temporary object file, and libtool could not work around it because
946     your compiler does not support \`-c' and \`-o' together. If you
947     repeat this compilation, it may succeed, by chance, but you had better
948     avoid parallel builds (make -j) in this platform, or get a better
949     compiler."
950    
951     $run $rm $removelist
952     exit $EXIT_FAILURE
953     fi
954    
955     # Just move the object if needed, then go on to compile the next one
956     if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
957     $show "$mv $output_obj $lobj"
958     if $run $mv $output_obj $lobj; then :
959     else
960     error=$?
961     $run $rm $removelist
962     exit $error
963     fi
964     fi
965    
966     # Append the name of the PIC object to the libtool object file.
967     test -z "$run" && cat >> ${libobj}T <<EOF
968     pic_object='$objdir/$objname'
969    
970     EOF
971    
972     # Allow error messages only from the first compilation.
973     if test "$suppress_opt" = yes; then
974     suppress_output=' >/dev/null 2>&1'
975     fi
976     else
977     # No PIC object so indicate it doesn't exist in the libtool
978     # object file.
979     test -z "$run" && cat >> ${libobj}T <<EOF
980     pic_object=none
981    
982     EOF
983     fi
984    
985     # Only build a position-dependent object if we build old libraries.
986     if test "$build_old_libs" = yes; then
987     if test "$pic_mode" != yes; then
988     # Don't build PIC code
989     command="$base_compile $qsrcfile"
990     else
991     command="$base_compile $qsrcfile $pic_flag"
992     fi
993     if test "$compiler_c_o" = yes; then
994     command="$command -o $obj"
995     fi
996    
997     # Suppress compiler output if we already did a PIC compilation.
998     command="$command$suppress_output"
999     $run $rm "$obj" "$output_obj"
1000     $show "$command"
1001     if $run eval "$command"; then :
1002     else
1003     $run $rm $removelist
1004     exit $EXIT_FAILURE
1005     fi
1006    
1007     if test "$need_locks" = warn &&
1008     test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1009     $echo "\
1010     *** ERROR, $lockfile contains:
1011     `cat $lockfile 2>/dev/null`
1012    
1013     but it should contain:
1014     $srcfile
1015    
1016     This indicates that another process is trying to use the same
1017     temporary object file, and libtool could not work around it because
1018     your compiler does not support \`-c' and \`-o' together. If you
1019     repeat this compilation, it may succeed, by chance, but you had better
1020     avoid parallel builds (make -j) in this platform, or get a better
1021     compiler."
1022    
1023     $run $rm $removelist
1024     exit $EXIT_FAILURE
1025     fi
1026    
1027     # Just move the object if needed
1028     if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1029     $show "$mv $output_obj $obj"
1030     if $run $mv $output_obj $obj; then :
1031     else
1032     error=$?
1033     $run $rm $removelist
1034     exit $error
1035     fi
1036     fi
1037    
1038     # Append the name of the non-PIC object the libtool object file.
1039     # Only append if the libtool object file exists.
1040     test -z "$run" && cat >> ${libobj}T <<EOF
1041     # Name of the non-PIC object.
1042     non_pic_object='$objname'
1043    
1044     EOF
1045     else
1046     # Append the name of the non-PIC object the libtool object file.
1047     # Only append if the libtool object file exists.
1048     test -z "$run" && cat >> ${libobj}T <<EOF
1049     # Name of the non-PIC object.
1050     non_pic_object=none
1051    
1052     EOF
1053     fi
1054    
1055     $run $mv "${libobj}T" "${libobj}"
1056    
1057     # Unlock the critical section if it was locked
1058     if test "$need_locks" != no; then
1059     $run $rm "$lockfile"
1060     fi
1061    
1062     exit $EXIT_SUCCESS
1063     ;;
1064    
1065     # libtool link mode
1066     link | relink)
1067     modename="$modename: link"
1068     case $host in
1069     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1070     # It is impossible to link a dll without this setting, and
1071     # we shouldn't force the makefile maintainer to figure out
1072     # which system we are compiling for in order to pass an extra
1073     # flag for every libtool invocation.
1074     # allow_undefined=no
1075    
1076     # FIXME: Unfortunately, there are problems with the above when trying
1077     # to make a dll which has undefined symbols, in which case not
1078     # even a static library is built. For now, we need to specify
1079     # -no-undefined on the libtool link line when we can be certain
1080     # that all symbols are satisfied, otherwise we get a static library.
1081     allow_undefined=yes
1082     ;;
1083     *)
1084     allow_undefined=yes
1085     ;;
1086     esac
1087     libtool_args="$nonopt"
1088     base_compile="$nonopt $@"
1089     compile_command="$nonopt"
1090     finalize_command="$nonopt"
1091    
1092     compile_rpath=
1093     finalize_rpath=
1094     compile_shlibpath=
1095     finalize_shlibpath=
1096     convenience=
1097     old_convenience=
1098     deplibs=
1099     old_deplibs=
1100     compiler_flags=
1101     linker_flags=
1102     dllsearchpath=
1103     lib_search_path=`pwd`
1104     inst_prefix_dir=
1105    
1106     avoid_version=no
1107     dlfiles=
1108     dlprefiles=
1109     dlself=no
1110     export_dynamic=no
1111     export_symbols=
1112     export_symbols_regex=
1113     generated=
1114     libobjs=
1115     ltlibs=
1116     module=no
1117     no_install=no
1118     objs=
1119     non_pic_objects=
1120     notinst_path= # paths that contain not-installed libtool libraries
1121     precious_files_regex=
1122     prefer_static_libs=no
1123     preload=no
1124     prev=
1125     prevarg=
1126     release=
1127     rpath=
1128     xrpath=
1129     perm_rpath=
1130     temp_rpath=
1131     thread_safe=no
1132     vinfo=
1133     vinfo_number=no
1134    
1135     func_infer_tag $base_compile
1136    
1137     # We need to know -static, to get the right output filenames.
1138     for arg
1139     do
1140     case $arg in
1141     -all-static | -static)
1142     if test "X$arg" = "X-all-static"; then
1143     if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1144     $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1145     fi
1146     if test -n "$link_static_flag"; then
1147     dlopen_self=$dlopen_self_static
1148     fi
1149     prefer_static_libs=yes
1150     else
1151     if test -z "$pic_flag" && test -n "$link_static_flag"; then
1152     dlopen_self=$dlopen_self_static
1153     fi
1154     prefer_static_libs=built
1155     fi
1156     build_libtool_libs=no
1157     build_old_libs=yes
1158     break
1159     ;;
1160     esac
1161     done
1162    
1163     # See if our shared archives depend on static archives.
1164     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1165    
1166     # Go through the arguments, transforming them on the way.
1167     while test "$#" -gt 0; do
1168     arg="$1"
1169     shift
1170     case $arg in
1171     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1172     qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1173     ;;
1174     *) qarg=$arg ;;
1175     esac
1176     libtool_args="$libtool_args $qarg"
1177    
1178     # If the previous option needs an argument, assign it.
1179     if test -n "$prev"; then
1180     case $prev in
1181     output)
1182     compile_command="$compile_command @OUTPUT@"
1183     finalize_command="$finalize_command @OUTPUT@"
1184     ;;
1185     esac
1186    
1187     case $prev in
1188     dlfiles|dlprefiles)
1189     if test "$preload" = no; then
1190     # Add the symbol object into the linking commands.
1191     compile_command="$compile_command @SYMFILE@"
1192     finalize_command="$finalize_command @SYMFILE@"
1193     preload=yes
1194     fi
1195     case $arg in
1196     *.la | *.lo) ;; # We handle these cases below.
1197     force)
1198     if test "$dlself" = no; then
1199     dlself=needless
1200     export_dynamic=yes
1201     fi
1202     prev=
1203     continue
1204     ;;
1205     self)
1206     if test "$prev" = dlprefiles; then
1207     dlself=yes
1208     elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1209     dlself=yes
1210     else
1211     dlself=needless
1212     export_dynamic=yes
1213     fi
1214     prev=
1215     continue
1216     ;;
1217     *)
1218     if test "$prev" = dlfiles; then
1219     dlfiles="$dlfiles $arg"
1220     else
1221     dlprefiles="$dlprefiles $arg"
1222     fi
1223     prev=
1224     continue
1225     ;;
1226     esac
1227     ;;
1228     expsyms)
1229     export_symbols="$arg"
1230     if test ! -f "$arg"; then
1231     $echo "$modename: symbol file \`$arg' does not exist"
1232     exit $EXIT_FAILURE
1233     fi
1234     prev=
1235     continue
1236     ;;
1237     expsyms_regex)
1238     export_symbols_regex="$arg"
1239     prev=
1240     continue
1241     ;;
1242     inst_prefix)
1243     inst_prefix_dir="$arg"
1244     prev=
1245     continue
1246     ;;
1247     precious_regex)
1248     precious_files_regex="$arg"
1249     prev=
1250     continue
1251     ;;
1252     release)
1253     release="-$arg"
1254     prev=
1255     continue
1256     ;;
1257     objectlist)
1258     if test -f "$arg"; then
1259     save_arg=$arg
1260     moreargs=
1261     for fil in `cat $save_arg`
1262     do
1263     # moreargs="$moreargs $fil"
1264     arg=$fil
1265     # A libtool-controlled object.
1266    
1267     # Check to see that this really is a libtool object.
1268     if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1269     pic_object=
1270     non_pic_object=
1271    
1272     # Read the .lo file
1273     # If there is no directory component, then add one.
1274     case $arg in
1275     */* | *\\*) . $arg ;;
1276     *) . ./$arg ;;
1277     esac
1278    
1279     if test -z "$pic_object" || \
1280     test -z "$non_pic_object" ||
1281     test "$pic_object" = none && \
1282     test "$non_pic_object" = none; then
1283     $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1284     exit $EXIT_FAILURE
1285     fi
1286    
1287     # Extract subdirectory from the argument.
1288     xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1289     if test "X$xdir" = "X$arg"; then
1290     xdir=
1291     else
1292     xdir="$xdir/"
1293     fi
1294    
1295     if test "$pic_object" != none; then
1296     # Prepend the subdirectory the object is found in.
1297     pic_object="$xdir$pic_object"
1298    
1299     if test "$prev" = dlfiles; then
1300     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1301     dlfiles="$dlfiles $pic_object"
1302     prev=
1303     continue
1304     else
1305     # If libtool objects are unsupported, then we need to preload.
1306     prev=dlprefiles
1307     fi
1308     fi
1309    
1310     # CHECK ME: I think I busted this. -Ossama
1311     if test "$prev" = dlprefiles; then
1312     # Preload the old-style object.
1313     dlprefiles="$dlprefiles $pic_object"
1314     prev=
1315     fi
1316    
1317     # A PIC object.
1318     libobjs="$libobjs $pic_object"
1319     arg="$pic_object"
1320     fi
1321    
1322     # Non-PIC object.
1323     if test "$non_pic_object" != none; then
1324     # Prepend the subdirectory the object is found in.
1325     non_pic_object="$xdir$non_pic_object"
1326    
1327     # A standard non-PIC object
1328     non_pic_objects="$non_pic_objects $non_pic_object"
1329     if test -z "$pic_object" || test "$pic_object" = none ; then
1330     arg="$non_pic_object"
1331     fi
1332     else
1333     # If the PIC object exists, use it instead.
1334     # $xdir was prepended to $pic_object above.
1335     non_pic_object="$pic_object"
1336     non_pic_objects="$non_pic_objects $non_pic_object"
1337     fi
1338     else
1339     # Only an error if not doing a dry-run.
1340     if test -z "$run"; then
1341     $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1342     exit $EXIT_FAILURE
1343     else
1344     # Dry-run case.
1345    
1346     # Extract subdirectory from the argument.
1347     xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1348     if test "X$xdir" = "X$arg"; then
1349     xdir=
1350     else
1351     xdir="$xdir/"
1352     fi
1353    
1354     pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1355     non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1356     libobjs="$libobjs $pic_object"
1357     non_pic_objects="$non_pic_objects $non_pic_object"
1358     fi
1359     fi
1360     done
1361     else
1362     $echo "$modename: link input file \`$save_arg' does not exist"
1363     exit $EXIT_FAILURE
1364     fi
1365     arg=$save_arg
1366     prev=
1367     continue
1368     ;;
1369     rpath | xrpath)
1370     # We need an absolute path.
1371     case $arg in
1372     [\\/]* | [A-Za-z]:[\\/]*) ;;
1373     *)
1374     $echo "$modename: only absolute run-paths are allowed" 1>&2
1375     exit $EXIT_FAILURE
1376     ;;
1377     esac
1378     if test "$prev" = rpath; then
1379     case "$rpath " in
1380     *" $arg "*) ;;
1381     *) rpath="$rpath $arg" ;;
1382     esac
1383     else
1384     case "$xrpath " in
1385     *" $arg "*) ;;
1386     *) xrpath="$xrpath $arg" ;;
1387     esac
1388     fi
1389     prev=
1390     continue
1391     ;;
1392     xcompiler)
1393     compiler_flags="$compiler_flags $qarg"
1394     prev=
1395     compile_command="$compile_command $qarg"
1396     finalize_command="$finalize_command $qarg"
1397     continue
1398     ;;
1399     xlinker)
1400     linker_flags="$linker_flags $qarg"
1401     compiler_flags="$compiler_flags $wl$qarg"
1402     prev=
1403     compile_command="$compile_command $wl$qarg"
1404     finalize_command="$finalize_command $wl$qarg"
1405     continue
1406     ;;
1407     xcclinker)
1408     linker_flags="$linker_flags $qarg"
1409     compiler_flags="$compiler_flags $qarg"
1410     prev=
1411     compile_command="$compile_command $qarg"
1412     finalize_command="$finalize_command $qarg"
1413     continue
1414     ;;
1415     shrext)
1416     shrext_cmds="$arg"
1417     prev=
1418     continue
1419     ;;
1420     darwin_framework|darwin_framework_skip)
1421     test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
1422     compile_command="$compile_command $arg"
1423     finalize_command="$finalize_command $arg"
1424     prev=
1425     continue
1426     ;;
1427     *)
1428     eval "$prev=\"\$arg\""
1429     prev=
1430     continue
1431     ;;
1432     esac
1433     fi # test -n "$prev"
1434    
1435     prevarg="$arg"
1436    
1437     case $arg in
1438     -all-static)
1439     if test -n "$link_static_flag"; then
1440     compile_command="$compile_command $link_static_flag"
1441     finalize_command="$finalize_command $link_static_flag"
1442     fi
1443     continue
1444     ;;
1445    
1446     -allow-undefined)
1447     # FIXME: remove this flag sometime in the future.
1448     $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1449     continue
1450     ;;
1451    
1452     -avoid-version)
1453     avoid_version=yes
1454     continue
1455     ;;
1456    
1457     -dlopen)
1458     prev=dlfiles
1459     continue
1460     ;;
1461    
1462     -dlpreopen)
1463     prev=dlprefiles
1464     continue
1465     ;;
1466    
1467     -export-dynamic)
1468     export_dynamic=yes
1469     continue
1470     ;;
1471    
1472     -export-symbols | -export-symbols-regex)
1473     if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1474     $echo "$modename: more than one -exported-symbols argument is not allowed"
1475     exit $EXIT_FAILURE
1476     fi
1477     if test "X$arg" = "X-export-symbols"; then
1478     prev=expsyms
1479     else
1480     prev=expsyms_regex
1481     fi
1482     continue
1483     ;;
1484    
1485     -framework|-arch|-isysroot)
1486     case " $CC " in
1487     *" ${arg} ${1} "* | *" ${arg} ${1} "*)
1488     prev=darwin_framework_skip ;;
1489     *) compiler_flags="$compiler_flags $arg"
1490     prev=darwin_framework ;;
1491     esac
1492     compile_command="$compile_command $arg"
1493     finalize_command="$finalize_command $arg"
1494     continue
1495     ;;
1496    
1497     -inst-prefix-dir)
1498     prev=inst_prefix
1499     continue
1500     ;;
1501    
1502     # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1503     # so, if we see these flags be careful not to treat them like -L
1504     -L[A-Z][A-Z]*:*)
1505     case $with_gcc/$host in
1506     no/*-*-irix* | /*-*-irix*)
1507     compile_command="$compile_command $arg"
1508     finalize_command="$finalize_command $arg"
1509     ;;
1510     esac
1511     continue
1512     ;;
1513    
1514     -L*)
1515     dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1516     # We need an absolute path.
1517     case $dir in
1518     [\\/]* | [A-Za-z]:[\\/]*) ;;
1519     *)
1520     absdir=`cd "$dir" && pwd`
1521     if test -z "$absdir"; then
1522     $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1523     absdir="$dir"
1524     notinst_path="$notinst_path $dir"
1525     fi
1526     dir="$absdir"
1527     ;;
1528     esac
1529     case "$deplibs " in
1530     *" -L$dir "*) ;;
1531     *)
1532     deplibs="$deplibs -L$dir"
1533     lib_search_path="$lib_search_path $dir"
1534     ;;
1535     esac
1536     case $host in
1537     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1538     testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
1539     case :$dllsearchpath: in
1540     *":$dir:"*) ;;
1541     *) dllsearchpath="$dllsearchpath:$dir";;
1542     esac
1543     case :$dllsearchpath: in
1544     *":$testbindir:"*) ;;
1545     *) dllsearchpath="$dllsearchpath:$testbindir";;
1546     esac
1547     ;;
1548     esac
1549     continue
1550     ;;
1551    
1552     -l*)
1553     if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1554     case $host in
1555     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
1556     # These systems don't actually have a C or math library (as such)
1557     continue
1558     ;;
1559     *-*-os2*)
1560     # These systems don't actually have a C library (as such)
1561     test "X$arg" = "X-lc" && continue
1562     ;;
1563     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1564     # Do not include libc due to us having libc/libc_r.
1565     test "X$arg" = "X-lc" && continue
1566     ;;
1567     *-*-rhapsody* | *-*-darwin1.[012])
1568     # Rhapsody C and math libraries are in the System framework
1569     deplibs="$deplibs -framework System"
1570     continue
1571     ;;
1572     *-*-sco3.2v5* | *-*-sco5v6*)
1573     # Causes problems with __ctype
1574     test "X$arg" = "X-lc" && continue
1575     ;;
1576     *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
1577     # Compiler inserts libc in the correct place for threads to work
1578     test "X$arg" = "X-lc" && continue
1579     ;;
1580     esac
1581     elif test "X$arg" = "X-lc_r"; then
1582     case $host in
1583     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1584     # Do not include libc_r directly, use -pthread flag.
1585     continue
1586     ;;
1587     esac
1588     fi
1589     deplibs="$deplibs $arg"
1590     continue
1591     ;;
1592    
1593     # Tru64 UNIX uses -model [arg] to determine the layout of C++
1594     # classes, name mangling, and exception handling.
1595     -model)
1596     compile_command="$compile_command $arg"
1597     compiler_flags="$compiler_flags $arg"
1598     finalize_command="$finalize_command $arg"
1599     prev=xcompiler
1600     continue
1601     ;;
1602    
1603     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1604     compiler_flags="$compiler_flags $arg"
1605     compile_command="$compile_command $arg"
1606     finalize_command="$finalize_command $arg"
1607     continue
1608     ;;
1609    
1610     -module)
1611     module=yes
1612     continue
1613     ;;
1614    
1615     # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1616     # -r[0-9][0-9]* specifies the processor on the SGI compiler
1617     # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1618     # +DA*, +DD* enable 64-bit mode on the HP compiler
1619     # -q* pass through compiler args for the IBM compiler
1620     # -m* pass through architecture-specific compiler args for GCC
1621     # -m*, -t[45]*, -txscale* pass through architecture-specific
1622     # compiler args for GCC
1623     # -pg pass through profiling flag for GCC
1624     # @file GCC response files
1625     -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*|-pg| \
1626     -t[45]*|-txscale*|@*)
1627    
1628     # Unknown arguments in both finalize_command and compile_command need
1629     # to be aesthetically quoted because they are evaled later.
1630     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1631     case $arg in
1632     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1633     arg="\"$arg\""
1634     ;;
1635     esac
1636     compile_command="$compile_command $arg"
1637     finalize_command="$finalize_command $arg"
1638     compiler_flags="$compiler_flags $arg"
1639     continue
1640     ;;
1641    
1642     -shrext)
1643     prev=shrext
1644     continue
1645     ;;
1646    
1647     -no-fast-install)
1648     fast_install=no
1649     continue
1650     ;;
1651    
1652     -no-install)
1653     case $host in
1654     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1655     # The PATH hackery in wrapper scripts is required on Windows
1656     # in order for the loader to find any dlls it needs.
1657     $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1658     $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1659     fast_install=no
1660     ;;
1661     *) no_install=yes ;;
1662     esac
1663     continue
1664     ;;
1665    
1666     -no-undefined)
1667     allow_undefined=no
1668     continue
1669     ;;
1670    
1671     -objectlist)
1672     prev=objectlist
1673     continue
1674     ;;
1675    
1676     -o) prev=output ;;
1677    
1678     -precious-files-regex)
1679     prev=precious_regex
1680     continue
1681     ;;
1682    
1683     -release)
1684     prev=release
1685     continue
1686     ;;
1687    
1688     -rpath)
1689     prev=rpath
1690     continue
1691     ;;
1692    
1693     -R)
1694     prev=xrpath
1695     continue
1696     ;;
1697    
1698     -R*)
1699     dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1700     # We need an absolute path.
1701     case $dir in
1702     [\\/]* | [A-Za-z]:[\\/]*) ;;
1703     *)
1704     $echo "$modename: only absolute run-paths are allowed" 1>&2
1705     exit $EXIT_FAILURE
1706     ;;
1707     esac
1708     case "$xrpath " in
1709     *" $dir "*) ;;
1710     *) xrpath="$xrpath $dir" ;;
1711     esac
1712     continue
1713     ;;
1714    
1715     -static)
1716     # The effects of -static are defined in a previous loop.
1717     # We used to do the same as -all-static on platforms that
1718     # didn't have a PIC flag, but the assumption that the effects
1719     # would be equivalent was wrong. It would break on at least
1720     # Digital Unix and AIX.
1721     continue
1722     ;;
1723    
1724     -thread-safe)
1725     thread_safe=yes
1726     continue
1727     ;;
1728    
1729     -version-info)
1730     prev=vinfo
1731     continue
1732     ;;
1733     -version-number)
1734     prev=vinfo
1735     vinfo_number=yes
1736     continue
1737     ;;
1738    
1739     -Wc,*)
1740     args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1741     arg=
1742     save_ifs="$IFS"; IFS=','
1743     for flag in $args; do
1744     IFS="$save_ifs"
1745     case $flag in
1746     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1747     flag="\"$flag\""
1748     ;;
1749     esac
1750     arg="$arg $wl$flag"
1751     compiler_flags="$compiler_flags $flag"
1752     done
1753     IFS="$save_ifs"
1754     arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1755     ;;
1756    
1757     -Wl,*)
1758     args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1759     arg=
1760     save_ifs="$IFS"; IFS=','
1761     for flag in $args; do
1762     IFS="$save_ifs"
1763     case $flag in
1764     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1765     flag="\"$flag\""
1766     ;;
1767     esac
1768     arg="$arg $wl$flag"
1769     compiler_flags="$compiler_flags $wl$flag"
1770     linker_flags="$linker_flags $flag"
1771     done
1772     IFS="$save_ifs"
1773     arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1774     ;;
1775    
1776     -Xcompiler)
1777     prev=xcompiler
1778     continue
1779     ;;
1780    
1781     -Xlinker)
1782     prev=xlinker
1783     continue
1784     ;;
1785    
1786     -XCClinker)
1787     prev=xcclinker
1788     continue
1789     ;;
1790    
1791     # Some other compiler flag.
1792     -* | +*)
1793     # Unknown arguments in both finalize_command and compile_command need
1794     # to be aesthetically quoted because they are evaled later.
1795     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1796     case $arg in
1797     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1798     arg="\"$arg\""
1799     ;;
1800     esac
1801     ;;
1802    
1803     *.$objext)
1804     # A standard object.
1805     objs="$objs $arg"
1806     ;;
1807    
1808     *.lo)
1809     # A libtool-controlled object.
1810    
1811     # Check to see that this really is a libtool object.
1812     if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1813     pic_object=
1814     non_pic_object=
1815    
1816     # Read the .lo file
1817     # If there is no directory component, then add one.
1818     case $arg in
1819     */* | *\\*) . $arg ;;
1820     *) . ./$arg ;;
1821     esac
1822    
1823     if test -z "$pic_object" || \
1824     test -z "$non_pic_object" ||
1825     test "$pic_object" = none && \
1826     test "$non_pic_object" = none; then
1827     $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1828     exit $EXIT_FAILURE
1829     fi
1830    
1831     # Extract subdirectory from the argument.
1832     xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1833     if test "X$xdir" = "X$arg"; then
1834     xdir=
1835     else
1836     xdir="$xdir/"
1837     fi
1838    
1839     if test "$pic_object" != none; then
1840     # Prepend the subdirectory the object is found in.
1841     pic_object="$xdir$pic_object"
1842    
1843     if test "$prev" = dlfiles; then
1844     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1845     dlfiles="$dlfiles $pic_object"
1846     prev=
1847     continue
1848     else
1849     # If libtool objects are unsupported, then we need to preload.
1850     prev=dlprefiles
1851     fi
1852     fi
1853    
1854     # CHECK ME: I think I busted this. -Ossama
1855     if test "$prev" = dlprefiles; then
1856     # Preload the old-style object.
1857     dlprefiles="$dlprefiles $pic_object"
1858     prev=
1859     fi
1860    
1861     # A PIC object.
1862     libobjs="$libobjs $pic_object"
1863     arg="$pic_object"
1864     fi
1865    
1866     # Non-PIC object.
1867     if test "$non_pic_object" != none; then
1868     # Prepend the subdirectory the object is found in.
1869     non_pic_object="$xdir$non_pic_object"
1870    
1871     # A standard non-PIC object
1872     non_pic_objects="$non_pic_objects $non_pic_object"
1873     if test -z "$pic_object" || test "$pic_object" = none ; then
1874     arg="$non_pic_object"
1875     fi
1876     else
1877     # If the PIC object exists, use it instead.
1878     # $xdir was prepended to $pic_object above.
1879     non_pic_object="$pic_object"
1880     non_pic_objects="$non_pic_objects $non_pic_object"
1881     fi
1882     else
1883     # Only an error if not doing a dry-run.
1884     if test -z "$run"; then
1885     $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1886     exit $EXIT_FAILURE
1887     else
1888     # Dry-run case.
1889    
1890     # Extract subdirectory from the argument.
1891     xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1892     if test "X$xdir" = "X$arg"; then
1893     xdir=
1894     else
1895     xdir="$xdir/"
1896     fi
1897    
1898     pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1899     non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1900     libobjs="$libobjs $pic_object"
1901     non_pic_objects="$non_pic_objects $non_pic_object"
1902     fi
1903     fi
1904     ;;
1905    
1906     *.$libext)
1907     # An archive.
1908     deplibs="$deplibs $arg"
1909     old_deplibs="$old_deplibs $arg"
1910     continue
1911     ;;
1912    
1913     *.la)
1914     # A libtool-controlled library.
1915    
1916     if test "$prev" = dlfiles; then
1917     # This library was specified with -dlopen.
1918     dlfiles="$dlfiles $arg"
1919     prev=
1920     elif test "$prev" = dlprefiles; then
1921     # The library was specified with -dlpreopen.
1922     dlprefiles="$dlprefiles $arg"
1923     prev=
1924     else
1925     deplibs="$deplibs $arg"
1926     fi
1927     continue
1928     ;;
1929    
1930     # Some other compiler argument.
1931     *)
1932     # Unknown arguments in both finalize_command and compile_command need
1933     # to be aesthetically quoted because they are evaled later.
1934     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1935     case $arg in
1936     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1937     arg="\"$arg\""
1938     ;;
1939     esac
1940     ;;
1941     esac # arg
1942    
1943     # Now actually substitute the argument into the commands.
1944     if test -n "$arg"; then
1945     compile_command="$compile_command $arg"
1946     finalize_command="$finalize_command $arg"
1947     fi
1948     done # argument parsing loop
1949    
1950     if test -n "$prev"; then
1951     $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1952     $echo "$help" 1>&2
1953     exit $EXIT_FAILURE
1954     fi
1955    
1956     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1957     eval arg=\"$export_dynamic_flag_spec\"
1958     compile_command="$compile_command $arg"
1959     finalize_command="$finalize_command $arg"
1960     fi
1961    
1962     oldlibs=
1963     # calculate the name of the file, without its directory
1964     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1965     libobjs_save="$libobjs"
1966    
1967     if test -n "$shlibpath_var"; then
1968     # get the directories listed in $shlibpath_var
1969     eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1970     else
1971     shlib_search_path=
1972     fi
1973     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1974     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1975    
1976     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1977     if test "X$output_objdir" = "X$output"; then
1978     output_objdir="$objdir"
1979     else
1980     output_objdir="$output_objdir/$objdir"
1981     fi
1982     # Create the object directory.
1983     if test ! -d "$output_objdir"; then
1984     $show "$mkdir $output_objdir"
1985     $run $mkdir $output_objdir
1986     exit_status=$?
1987     if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
1988     exit $exit_status
1989     fi
1990     fi
1991    
1992     # Determine the type of output
1993     case $output in
1994     "")
1995     $echo "$modename: you must specify an output file" 1>&2
1996     $echo "$help" 1>&2
1997     exit $EXIT_FAILURE
1998     ;;
1999     *.$libext) linkmode=oldlib ;;
2000     *.lo | *.$objext) linkmode=obj ;;
2001     *.la) linkmode=lib ;;
2002     *) linkmode=prog ;; # Anything else should be a program.
2003     esac
2004    
2005     case $host in
2006     *cygwin* | *mingw* | *pw32*)
2007     # don't eliminate duplications in $postdeps and $predeps
2008     duplicate_compiler_generated_deps=yes
2009     ;;
2010     *)
2011     duplicate_compiler_generated_deps=$duplicate_deps
2012     ;;
2013     esac
2014     specialdeplibs=
2015    
2016     libs=
2017     # Find all interdependent deplibs by searching for libraries
2018     # that are linked more than once (e.g. -la -lb -la)
2019     for deplib in $deplibs; do
2020     if test "X$duplicate_deps" = "Xyes" ; then
2021     case "$libs " in
2022     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2023     esac
2024     fi
2025     libs="$libs $deplib"
2026     done
2027    
2028     if test "$linkmode" = lib; then
2029     libs="$predeps $libs $compiler_lib_search_path $postdeps"
2030    
2031     # Compute libraries that are listed more than once in $predeps
2032     # $postdeps and mark them as special (i.e., whose duplicates are
2033     # not to be eliminated).
2034     pre_post_deps=
2035     if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
2036     for pre_post_dep in $predeps $postdeps; do
2037     case "$pre_post_deps " in
2038     *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
2039     esac
2040     pre_post_deps="$pre_post_deps $pre_post_dep"
2041     done
2042     fi
2043     pre_post_deps=
2044     fi
2045    
2046     deplibs=
2047     newdependency_libs=
2048     newlib_search_path=
2049     need_relink=no # whether we're linking any uninstalled libtool libraries
2050     notinst_deplibs= # not-installed libtool libraries
2051     case $linkmode in
2052     lib)
2053     passes="conv link"
2054     for file in $dlfiles $dlprefiles; do
2055     case $file in
2056     *.la) ;;
2057     *)
2058     $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2059     exit $EXIT_FAILURE
2060     ;;
2061     esac
2062     done
2063     ;;
2064     prog)
2065     compile_deplibs=
2066     finalize_deplibs=
2067     alldeplibs=no
2068     newdlfiles=
2069     newdlprefiles=
2070     passes="conv scan dlopen dlpreopen link"
2071     ;;
2072     *) passes="conv"
2073     ;;
2074     esac
2075     for pass in $passes; do
2076     if test "$linkmode,$pass" = "lib,link" ||
2077     test "$linkmode,$pass" = "prog,scan"; then
2078     libs="$deplibs"
2079     deplibs=
2080     fi
2081     if test "$linkmode" = prog; then
2082     case $pass in
2083     dlopen) libs="$dlfiles" ;;
2084     dlpreopen) libs="$dlprefiles" ;;
2085     link)
2086     libs="$deplibs %DEPLIBS%"
2087     test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
2088     ;;
2089     esac
2090     fi
2091     if test "$pass" = dlopen; then
2092     # Collect dlpreopened libraries
2093     save_deplibs="$deplibs"
2094     deplibs=
2095     fi
2096     for deplib in $libs; do
2097     lib=
2098     found=no
2099     case $deplib in
2100     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
2101     if test "$linkmode,$pass" = "prog,link"; then
2102     compile_deplibs="$deplib $compile_deplibs"
2103     finalize_deplibs="$deplib $finalize_deplibs"
2104     else
2105     compiler_flags="$compiler_flags $deplib"
2106     fi
2107     continue
2108     ;;
2109     -l*)
2110     if test "$linkmode" != lib && test "$linkmode" != prog; then
2111     $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2112     continue
2113     fi
2114     name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2115     for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
2116     for search_ext in .la $std_shrext .so .a; do
2117     # Search the libtool library
2118     lib="$searchdir/lib${name}${search_ext}"
2119     if test -f "$lib"; then
2120     if test "$search_ext" = ".la"; then
2121     found=yes
2122     else
2123     found=no
2124     fi
2125     break 2
2126     fi
2127     done
2128     done
2129     if test "$found" != yes; then
2130     # deplib doesn't seem to be a libtool library
2131     if test "$linkmode,$pass" = "prog,link"; then
2132     compile_deplibs="$deplib $compile_deplibs"
2133     finalize_deplibs="$deplib $finalize_deplibs"
2134     else
2135     deplibs="$deplib $deplibs"
2136     test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2137     fi
2138     continue
2139     else # deplib is a libtool library
2140     # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2141     # We need to do some special things here, and not later.
2142     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2143     case " $predeps $postdeps " in
2144     *" $deplib "*)
2145     if (${SED} -e '2q' $lib |
2146     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2147     library_names=
2148     old_library=
2149     case $lib in
2150     */* | *\\*) . $lib ;;
2151     *) . ./$lib ;;
2152     esac
2153     for l in $old_library $library_names; do
2154     ll="$l"
2155     done
2156     if test "X$ll" = "X$old_library" ; then # only static version available
2157     found=no
2158     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2159     test "X$ladir" = "X$lib" && ladir="."
2160     lib=$ladir/$old_library
2161     if test "$linkmode,$pass" = "prog,link"; then
2162     compile_deplibs="$deplib $compile_deplibs"
2163     finalize_deplibs="$deplib $finalize_deplibs"
2164     else
2165     deplibs="$deplib $deplibs"
2166     test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2167     fi
2168     continue
2169     fi
2170     fi
2171     ;;
2172     *) ;;
2173     esac
2174     fi
2175     fi
2176     ;; # -l
2177     -L*)
2178     case $linkmode in
2179     lib)
2180     deplibs="$deplib $deplibs"
2181     test "$pass" = conv && continue
2182     newdependency_libs="$deplib $newdependency_libs"
2183     newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2184     ;;
2185     prog)
2186     if test "$pass" = conv; then
2187     deplibs="$deplib $deplibs"
2188     continue
2189     fi
2190     if test "$pass" = scan; then
2191     deplibs="$deplib $deplibs"
2192     else
2193     compile_deplibs="$deplib $compile_deplibs"
2194     finalize_deplibs="$deplib $finalize_deplibs"
2195     fi
2196     newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2197     ;;
2198     *)
2199     $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2200     ;;
2201     esac # linkmode
2202     continue
2203     ;; # -L
2204     -R*)
2205     if test "$pass" = link; then
2206     dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2207     # Make sure the xrpath contains only unique directories.
2208     case "$xrpath " in
2209     *" $dir "*) ;;
2210     *) xrpath="$xrpath $dir" ;;
2211     esac
2212     fi
2213     deplibs="$deplib $deplibs"
2214     continue
2215     ;;
2216     *.la) lib="$deplib" ;;
2217     *.$libext)
2218     if test "$pass" = conv; then
2219     deplibs="$deplib $deplibs"
2220     continue
2221     fi
2222     case $linkmode in
2223     lib)
2224     valid_a_lib=no
2225     case $deplibs_check_method in
2226     match_pattern*)
2227     set dummy $deplibs_check_method
2228     match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2229     if eval $echo \"$deplib\" 2>/dev/null \
2230     | $SED 10q \
2231     | $EGREP "$match_pattern_regex" > /dev/null; then
2232     valid_a_lib=yes
2233     fi
2234     ;;
2235     pass_all)
2236     valid_a_lib=yes
2237     ;;
2238     esac
2239     if test "$valid_a_lib" != yes; then
2240     $echo
2241     $echo "*** Warning: Trying to link with static lib archive $deplib."
2242     $echo "*** I have the capability to make that library automatically link in when"
2243     $echo "*** you link to this library. But I can only do this if you have a"
2244     $echo "*** shared version of the library, which you do not appear to have"
2245     $echo "*** because the file extensions .$libext of this argument makes me believe"
2246     $echo "*** that it is just a static archive that I should not used here."
2247     else
2248     $echo
2249     $echo "*** Warning: Linking the shared library $output against the"
2250     $echo "*** static library $deplib is not portable!"
2251     deplibs="$deplib $deplibs"
2252     fi
2253     continue
2254     ;;
2255     prog)
2256     if test "$pass" != link; then
2257     deplibs="$deplib $deplibs"
2258     else
2259     compile_deplibs="$deplib $compile_deplibs"
2260     finalize_deplibs="$deplib $finalize_deplibs"
2261     fi
2262     continue
2263     ;;
2264     esac # linkmode
2265     ;; # *.$libext
2266     *.lo | *.$objext)
2267     if test "$pass" = conv; then
2268     deplibs="$deplib $deplibs"
2269     elif test "$linkmode" = prog; then
2270     if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2271     # If there is no dlopen support or we're linking statically,
2272     # we need to preload.
2273     newdlprefiles="$newdlprefiles $deplib"
2274     compile_deplibs="$deplib $compile_deplibs"
2275     finalize_deplibs="$deplib $finalize_deplibs"
2276     else
2277     newdlfiles="$newdlfiles $deplib"
2278     fi
2279     fi
2280     continue
2281     ;;
2282     %DEPLIBS%)
2283     alldeplibs=yes
2284     continue
2285     ;;
2286     esac # case $deplib
2287     if test "$found" = yes || test -f "$lib"; then :
2288     else
2289     $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2290     exit $EXIT_FAILURE
2291     fi
2292    
2293     # Check to see that this really is a libtool archive.
2294     if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2295     else
2296     $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2297     exit $EXIT_FAILURE
2298     fi
2299    
2300     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2301     test "X$ladir" = "X$lib" && ladir="."
2302    
2303     dlname=
2304     dlopen=
2305     dlpreopen=
2306     libdir=
2307     library_names=
2308     old_library=
2309     # If the library was installed with an old release of libtool,
2310     # it will not redefine variables installed, or shouldnotlink
2311     installed=yes
2312     shouldnotlink=no
2313     avoidtemprpath=
2314    
2315    
2316     # Read the .la file
2317     case $lib in
2318     */* | *\\*) . $lib ;;
2319     *) . ./$lib ;;
2320     esac
2321    
2322     if test "$linkmode,$pass" = "lib,link" ||
2323     test "$linkmode,$pass" = "prog,scan" ||
2324     { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2325     test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2326     test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2327     fi
2328    
2329     if test "$pass" = conv; then
2330     # Only check for convenience libraries
2331     deplibs="$lib $deplibs"
2332     if test -z "$libdir"; then
2333     if test -z "$old_library"; then
2334     $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2335     exit $EXIT_FAILURE
2336     fi
2337     # It is a libtool convenience library, so add in its objects.
2338     convenience="$convenience $ladir/$objdir/$old_library"
2339     old_convenience="$old_convenience $ladir/$objdir/$old_library"
2340     tmp_libs=
2341     for deplib in $dependency_libs; do
2342     deplibs="$deplib $deplibs"
2343     if test "X$duplicate_deps" = "Xyes" ; then
2344     case "$tmp_libs " in
2345     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2346     esac
2347     fi
2348     tmp_libs="$tmp_libs $deplib"
2349     done
2350     elif test "$linkmode" != prog && test "$linkmode" != lib; then
2351     $echo "$modename: \`$lib' is not a convenience library" 1>&2
2352     exit $EXIT_FAILURE
2353     fi
2354     continue
2355     fi # $pass = conv
2356    
2357    
2358     # Get the name of the library we link against.
2359     linklib=
2360     for l in $old_library $library_names; do
2361     linklib="$l"
2362     done
2363     if test -z "$linklib"; then
2364     $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2365     exit $EXIT_FAILURE
2366     fi
2367    
2368     # This library was specified with -dlopen.
2369     if test "$pass" = dlopen; then
2370     if test -z "$libdir"; then
2371     $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2372     exit $EXIT_FAILURE
2373     fi
2374     if test -z "$dlname" ||
2375     test "$dlopen_support" != yes ||
2376     test "$build_libtool_libs" = no; then
2377     # If there is no dlname, no dlopen support or we're linking
2378     # statically, we need to preload. We also need to preload any
2379     # dependent libraries so libltdl's deplib preloader doesn't
2380     # bomb out in the load deplibs phase.
2381     dlprefiles="$dlprefiles $lib $dependency_libs"
2382     else
2383     newdlfiles="$newdlfiles $lib"
2384     fi
2385     continue
2386     fi # $pass = dlopen
2387    
2388     # We need an absolute path.
2389     case $ladir in
2390     [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2391     *)
2392     abs_ladir=`cd "$ladir" && pwd`
2393     if test -z "$abs_ladir"; then
2394     $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2395     $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2396     abs_ladir="$ladir"
2397     fi
2398     ;;
2399     esac
2400     laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2401    
2402     # Find the relevant object directory and library name.
2403     if test "X$installed" = Xyes; then
2404     if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2405     $echo "$modename: warning: library \`$lib' was moved." 1>&2
2406     dir="$ladir"
2407     absdir="$abs_ladir"
2408     libdir="$abs_ladir"
2409     else
2410     dir="$libdir"
2411     absdir="$libdir"
2412     fi
2413     test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2414     else
2415     if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2416     dir="$ladir"
2417     absdir="$abs_ladir"
2418     # Remove this search path later
2419     notinst_path="$notinst_path $abs_ladir"
2420     else
2421     dir="$ladir/$objdir"
2422     absdir="$abs_ladir/$objdir"
2423     # Remove this search path later
2424     notinst_path="$notinst_path $abs_ladir"
2425     fi
2426     fi # $installed = yes
2427     name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2428    
2429     # This library was specified with -dlpreopen.
2430     if test "$pass" = dlpreopen; then
2431     if test -z "$libdir"; then
2432     $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2433     exit $EXIT_FAILURE
2434     fi
2435     # Prefer using a static library (so that no silly _DYNAMIC symbols
2436     # are required to link).
2437     if test -n "$old_library"; then
2438     newdlprefiles="$newdlprefiles $dir/$old_library"
2439     # Otherwise, use the dlname, so that lt_dlopen finds it.
2440     elif test -n "$dlname"; then
2441     newdlprefiles="$newdlprefiles $dir/$dlname"
2442     else
2443     newdlprefiles="$newdlprefiles $dir/$linklib"
2444     fi
2445     fi # $pass = dlpreopen
2446    
2447     if test -z "$libdir"; then
2448     # Link the convenience library
2449     if test "$linkmode" = lib; then
2450     deplibs="$dir/$old_library $deplibs"
2451     elif test "$linkmode,$pass" = "prog,link"; then
2452     compile_deplibs="$dir/$old_library $compile_deplibs"
2453     finalize_deplibs="$dir/$old_library $finalize_deplibs"
2454     else
2455     deplibs="$lib $deplibs" # used for prog,scan pass
2456     fi
2457     continue
2458     fi
2459    
2460    
2461     if test "$linkmode" = prog && test "$pass" != link; then
2462     newlib_search_path="$newlib_search_path $ladir"
2463     deplibs="$lib $deplibs"
2464    
2465     linkalldeplibs=no
2466     if test "$link_all_deplibs" != no || test -z "$library_names" ||
2467     test "$build_libtool_libs" = no; then
2468     linkalldeplibs=yes
2469     fi
2470    
2471     tmp_libs=
2472     for deplib in $dependency_libs; do
2473     case $deplib in
2474     -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2475     esac
2476     # Need to link against all dependency_libs?
2477     if test "$linkalldeplibs" = yes; then
2478     deplibs="$deplib $deplibs"
2479     else
2480     # Need to hardcode shared library paths
2481     # or/and link against static libraries
2482     newdependency_libs="$deplib $newdependency_libs"
2483     fi
2484     if test "X$duplicate_deps" = "Xyes" ; then
2485     case "$tmp_libs " in
2486     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2487     esac
2488     fi
2489     tmp_libs="$tmp_libs $deplib"
2490     done # for deplib
2491     continue
2492     fi # $linkmode = prog...
2493    
2494     if test "$linkmode,$pass" = "prog,link"; then
2495     if test -n "$library_names" &&
2496     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2497     # We need to hardcode the library path
2498     if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2499     # Make sure the rpath contains only unique directories.
2500     case "$temp_rpath " in
2501     *" $dir "*) ;;
2502     *" $absdir "*) ;;
2503     *) temp_rpath="$temp_rpath $absdir" ;;
2504     esac
2505     fi
2506    
2507     # Hardcode the library path.
2508     # Skip directories that are in the system default run-time
2509     # search path.
2510     case " $sys_lib_dlsearch_path " in
2511     *" $absdir "*) ;;
2512     *)
2513     case "$compile_rpath " in
2514     *" $absdir "*) ;;
2515     *) compile_rpath="$compile_rpath $absdir"
2516     esac
2517     ;;
2518     esac
2519     case " $sys_lib_dlsearch_path " in
2520     *" $libdir "*) ;;
2521     *)
2522     case "$finalize_rpath " in
2523     *" $libdir "*) ;;
2524     *) finalize_rpath="$finalize_rpath $libdir"
2525     esac
2526     ;;
2527     esac
2528     fi # $linkmode,$pass = prog,link...
2529    
2530     if test "$alldeplibs" = yes &&
2531     { test "$deplibs_check_method" = pass_all ||
2532     { test "$build_libtool_libs" = yes &&
2533     test -n "$library_names"; }; }; then
2534     # We only need to search for static libraries
2535     continue
2536     fi
2537     fi
2538    
2539     link_static=no # Whether the deplib will be linked statically
2540     use_static_libs=$prefer_static_libs
2541     if test "$use_static_libs" = built && test "$installed" = yes ; then
2542     use_static_libs=no
2543     fi
2544     if test -n "$library_names" &&
2545     { test "$use_static_libs" = no || test -z "$old_library"; }; then
2546     if test "$installed" = no; then
2547     notinst_deplibs="$notinst_deplibs $lib"
2548     need_relink=yes
2549     fi
2550     # This is a shared library
2551    
2552     # Warn about portability, can't link against -module's on
2553     # some systems (darwin)
2554     if test "$shouldnotlink" = yes && test "$pass" = link ; then
2555     $echo
2556     if test "$linkmode" = prog; then
2557     $echo "*** Warning: Linking the executable $output against the loadable module"
2558     else
2559     $echo "*** Warning: Linking the shared library $output against the loadable module"
2560     fi
2561     $echo "*** $linklib is not portable!"
2562     fi
2563     if test "$linkmode" = lib &&
2564     test "$hardcode_into_libs" = yes; then
2565     # Hardcode the library path.
2566     # Skip directories that are in the system default run-time
2567     # search path.
2568     case " $sys_lib_dlsearch_path " in
2569     *" $absdir "*) ;;
2570     *)
2571     case "$compile_rpath " in
2572     *" $absdir "*) ;;
2573     *) compile_rpath="$compile_rpath $absdir"
2574     esac
2575     ;;
2576     esac
2577     case " $sys_lib_dlsearch_path " in
2578     *" $libdir "*) ;;
2579     *)
2580     case "$finalize_rpath " in
2581     *" $libdir "*) ;;
2582     *) finalize_rpath="$finalize_rpath $libdir"
2583     esac
2584     ;;
2585     esac
2586     fi
2587    
2588     if test -n "$old_archive_from_expsyms_cmds"; then
2589     # figure out the soname
2590     set dummy $library_names
2591     realname="$2"
2592     shift; shift
2593     libname=`eval \\$echo \"$libname_spec\"`
2594     # use dlname if we got it. it's perfectly good, no?
2595     if test -n "$dlname"; then
2596     soname="$dlname"
2597     elif test -n "$soname_spec"; then
2598     # bleh windows
2599     case $host in
2600     *cygwin* | mingw*)
2601     major=`expr $current - $age`
2602     versuffix="-$major"
2603     ;;
2604     esac
2605     eval soname=\"$soname_spec\"
2606     else
2607     soname="$realname"
2608     fi
2609    
2610     # Make a new name for the extract_expsyms_cmds to use
2611     soroot="$soname"
2612     soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2613     newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2614    
2615     # If the library has no export list, then create one now
2616     if test -f "$output_objdir/$soname-def"; then :
2617     else
2618     $show "extracting exported symbol list from \`$soname'"
2619     save_ifs="$IFS"; IFS='~'
2620     cmds=$extract_expsyms_cmds
2621     for cmd in $cmds; do
2622     IFS="$save_ifs"
2623     eval cmd=\"$cmd\"
2624     $show "$cmd"
2625     $run eval "$cmd" || exit $?
2626     done
2627     IFS="$save_ifs"
2628     fi
2629    
2630     # Create $newlib
2631     if test -f "$output_objdir/$newlib"; then :; else
2632     $show "generating import library for \`$soname'"
2633     save_ifs="$IFS"; IFS='~'
2634     cmds=$old_archive_from_expsyms_cmds
2635     for cmd in $cmds; do
2636     IFS="$save_ifs"
2637     eval cmd=\"$cmd\"
2638     $show "$cmd"
2639     $run eval "$cmd" || exit $?
2640     done
2641     IFS="$save_ifs"
2642     fi
2643     # make sure the library variables are pointing to the new library
2644     dir=$output_objdir
2645     linklib=$newlib
2646     fi # test -n "$old_archive_from_expsyms_cmds"
2647    
2648     if test "$linkmode" = prog || test "$mode" != relink; then
2649     add_shlibpath=
2650     add_dir=
2651     add=
2652     lib_linked=yes
2653     case $hardcode_action in
2654     immediate | unsupported)
2655     if test "$hardcode_direct" = no; then
2656     add="$dir/$linklib"
2657     case $host in
2658     *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
2659     *-*-sysv4*uw2*) add_dir="-L$dir" ;;
2660     *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2661     *-*-unixware7*) add_dir="-L$dir" ;;
2662     *-*-darwin* )
2663     # if the lib is a module then we can not link against
2664     # it, someone is ignoring the new warnings I added
2665     if /usr/bin/file -L $add 2> /dev/null |
2666     $EGREP ": [^:]* bundle" >/dev/null ; then
2667     $echo "** Warning, lib $linklib is a module, not a shared library"
2668     if test -z "$old_library" ; then
2669     $echo
2670     $echo "** And there doesn't seem to be a static archive available"
2671     $echo "** The link will probably fail, sorry"
2672     else
2673     add="$dir/$old_library"
2674     fi
2675     fi
2676     esac
2677     elif test "$hardcode_minus_L" = no; then
2678     case $host in
2679     *-*-sunos*) add_shlibpath="$dir" ;;
2680     esac
2681     add_dir="-L$dir"
2682     add="-l$name"
2683     elif test "$hardcode_shlibpath_var" = no; then
2684     add_shlibpath="$dir"
2685     add="-l$name"
2686     else
2687     lib_linked=no
2688     fi
2689     ;;
2690     relink)
2691     if test "$hardcode_direct" = yes; then
2692     add="$dir/$linklib"
2693     elif test "$hardcode_minus_L" = yes; then
2694     add_dir="-L$dir"
2695     # Try looking first in the location we're being installed to.
2696     if test -n "$inst_prefix_dir"; then
2697     case $libdir in
2698     [\\/]*)
2699     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2700     ;;
2701     esac
2702     fi
2703     add="-l$name"
2704     elif test "$hardcode_shlibpath_var" = yes; then
2705     add_shlibpath="$dir"
2706     add="-l$name"
2707     else
2708     lib_linked=no
2709     fi
2710     ;;
2711     *) lib_linked=no ;;
2712     esac
2713    
2714     if test "$lib_linked" != yes; then
2715     $echo "$modename: configuration error: unsupported hardcode properties"
2716     exit $EXIT_FAILURE
2717     fi
2718    
2719     if test -n "$add_shlibpath"; then
2720     case :$compile_shlibpath: in
2721     *":$add_shlibpath:"*) ;;
2722     *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2723     esac
2724     fi
2725     if test "$linkmode" = prog; then
2726     test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2727     test -n "$add" && compile_deplibs="$add $compile_deplibs"
2728     else
2729     test -n "$add_dir" && deplibs="$add_dir $deplibs"
2730     test -n "$add" && deplibs="$add $deplibs"
2731     if test "$hardcode_direct" != yes && \
2732     test "$hardcode_minus_L" != yes && \
2733     test "$hardcode_shlibpath_var" = yes; then
2734     case :$finalize_shlibpath: in
2735     *":$libdir:"*) ;;
2736     *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2737     esac
2738     fi
2739     fi
2740     fi
2741    
2742     if test "$linkmode" = prog || test "$mode" = relink; then
2743     add_shlibpath=
2744     add_dir=
2745     add=
2746     # Finalize command for both is simple: just hardcode it.
2747     if test "$hardcode_direct" = yes; then
2748     add="$libdir/$linklib"
2749     elif test "$hardcode_minus_L" = yes; then
2750     add_dir="-L$libdir"
2751     add="-l$name"
2752     elif test "$hardcode_shlibpath_var" = yes; then
2753     case :$finalize_shlibpath: in
2754     *":$libdir:"*) ;;
2755     *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2756     esac
2757     add="-l$name"
2758     elif test "$hardcode_automatic" = yes; then
2759     if test -n "$inst_prefix_dir" &&
2760     test -f "$inst_prefix_dir$libdir/$linklib" ; then
2761     add="$inst_prefix_dir$libdir/$linklib"
2762     else
2763     add="$libdir/$linklib"
2764     fi
2765     else
2766     # We cannot seem to hardcode it, guess we'll fake it.
2767     add_dir="-L$libdir"
2768     # Try looking first in the location we're being installed to.
2769     if test -n "$inst_prefix_dir"; then
2770     case $libdir in
2771     [\\/]*)
2772     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2773     ;;
2774     esac
2775     fi
2776     add="-l$name"
2777     fi
2778    
2779     if test "$linkmode" = prog; then
2780     test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2781     test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2782     else
2783     test -n "$add_dir" && deplibs="$add_dir $deplibs"
2784     test -n "$add" && deplibs="$add $deplibs"
2785     fi
2786     fi
2787     elif test "$linkmode" = prog; then
2788     # Here we assume that one of hardcode_direct or hardcode_minus_L
2789     # is not unsupported. This is valid on all known static and
2790     # shared platforms.
2791     if test "$hardcode_direct" != unsupported; then
2792     test -n "$old_library" && linklib="$old_library"
2793     compile_deplibs="$dir/$linklib $compile_deplibs"
2794     finalize_deplibs="$dir/$linklib $finalize_deplibs"
2795     else
2796     compile_deplibs="-l$name -L$dir $compile_deplibs"
2797     finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2798     fi
2799     elif test "$build_libtool_libs" = yes; then
2800     # Not a shared library
2801     if test "$deplibs_check_method" != pass_all; then
2802     # We're trying link a shared library against a static one
2803     # but the system doesn't support it.
2804    
2805     # Just print a warning and add the library to dependency_libs so
2806     # that the program can be linked against the static library.
2807     $echo
2808     $echo "*** Warning: This system can not link to static lib archive $lib."
2809     $echo "*** I have the capability to make that library automatically link in when"
2810     $echo "*** you link to this library. But I can only do this if you have a"
2811     $echo "*** shared version of the library, which you do not appear to have."
2812     if test "$module" = yes; then
2813     $echo "*** But as you try to build a module library, libtool will still create "
2814     $echo "*** a static module, that should work as long as the dlopening application"
2815     $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2816     if test -z "$global_symbol_pipe"; then
2817     $echo
2818     $echo "*** However, this would only work if libtool was able to extract symbol"
2819     $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2820     $echo "*** not find such a program. So, this module is probably useless."
2821     $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2822     fi
2823     if test "$build_old_libs" = no; then
2824     build_libtool_libs=module
2825     build_old_libs=yes
2826     else
2827     build_libtool_libs=no
2828     fi
2829     fi
2830     else
2831     deplibs="$dir/$old_library $deplibs"
2832     link_static=yes
2833     fi
2834     fi # link shared/static library?
2835    
2836     if test "$linkmode" = lib; then
2837     if test -n "$dependency_libs" &&
2838     { test "$hardcode_into_libs" != yes ||
2839     test "$build_old_libs" = yes ||
2840     test "$link_static" = yes; }; then
2841     # Extract -R from dependency_libs
2842     temp_deplibs=
2843     for libdir in $dependency_libs; do
2844     case $libdir in
2845     -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2846     case " $xrpath " in
2847     *" $temp_xrpath "*) ;;
2848     *) xrpath="$xrpath $temp_xrpath";;
2849     esac;;
2850     *) temp_deplibs="$temp_deplibs $libdir";;
2851     esac
2852     done
2853     dependency_libs="$temp_deplibs"
2854     fi
2855    
2856     newlib_search_path="$newlib_search_path $absdir"
2857     # Link against this library
2858     test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2859     # ... and its dependency_libs
2860     tmp_libs=
2861     for deplib in $dependency_libs; do
2862     newdependency_libs="$deplib $newdependency_libs"
2863     if test "X$duplicate_deps" = "Xyes" ; then
2864     case "$tmp_libs " in
2865     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2866     esac
2867     fi
2868     tmp_libs="$tmp_libs $deplib"
2869     done
2870    
2871     if test "$link_all_deplibs" != no; then
2872     # Add the search paths of all dependency libraries
2873     for deplib in $dependency_libs; do
2874     case $deplib in
2875     -L*) path="$deplib" ;;
2876     *.la)
2877     dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2878     test "X$dir" = "X$deplib" && dir="."
2879     # We need an absolute path.
2880     case $dir in
2881     [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2882     *)
2883     absdir=`cd "$dir" && pwd`
2884     if test -z "$absdir"; then
2885     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2886     absdir="$dir"
2887     fi
2888     ;;
2889     esac
2890     if grep "^installed=no" $deplib > /dev/null; then
2891     path="$absdir/$objdir"
2892     else
2893     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2894     if test -z "$libdir"; then
2895     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2896     exit $EXIT_FAILURE
2897     fi
2898     if test "$absdir" != "$libdir"; then
2899     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2900     fi
2901     path="$absdir"
2902     fi
2903     depdepl=
2904     case $host in
2905     *-*-darwin*)
2906     # we do not want to link against static libs,
2907     # but need to link against shared
2908     eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2909     if test -n "$deplibrary_names" ; then
2910     for tmp in $deplibrary_names ; do
2911     depdepl=$tmp
2912     done
2913     if test -f "$path/$depdepl" ; then
2914     depdepl="$path/$depdepl"
2915     fi
2916     # do not add paths which are already there
2917     case " $newlib_search_path " in
2918     *" $path "*) ;;
2919     *) newlib_search_path="$newlib_search_path $path";;
2920     esac
2921     fi
2922     path=""
2923     ;;
2924     *)
2925     path="-L$path"
2926     ;;
2927     esac
2928     ;;
2929     -l*)
2930     case $host in
2931     *-*-darwin*)
2932     # Again, we only want to link against shared libraries
2933     eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2934     for tmp in $newlib_search_path ; do
2935     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2936     eval depdepl="$tmp/lib$tmp_libs.dylib"
2937     break
2938     fi
2939     done
2940     path=""
2941     ;;
2942     *) continue ;;
2943     esac
2944     ;;
2945     *) continue ;;
2946     esac
2947     case " $deplibs " in
2948     *" $path "*) ;;
2949     *) deplibs="$path $deplibs" ;;
2950     esac
2951     case " $deplibs " in
2952     *" $depdepl "*) ;;
2953     *) deplibs="$depdepl $deplibs" ;;
2954     esac
2955     done
2956     fi # link_all_deplibs != no
2957     fi # linkmode = lib
2958     done # for deplib in $libs
2959     dependency_libs="$newdependency_libs"
2960     if test "$pass" = dlpreopen; then
2961     # Link the dlpreopened libraries before other libraries
2962     for deplib in $save_deplibs; do
2963     deplibs="$deplib $deplibs"
2964     done
2965     fi
2966     if test "$pass" != dlopen; then
2967     if test "$pass" != conv; then
2968     # Make sure lib_search_path contains only unique directories.
2969     lib_search_path=
2970     for dir in $newlib_search_path; do
2971     case "$lib_search_path " in
2972     *" $dir "*) ;;
2973     *) lib_search_path="$lib_search_path $dir" ;;
2974     esac
2975     done
2976     newlib_search_path=
2977     fi
2978    
2979     if test "$linkmode,$pass" != "prog,link"; then
2980     vars="deplibs"
2981     else
2982     vars="compile_deplibs finalize_deplibs"
2983     fi
2984     for var in $vars dependency_libs; do
2985     # Add libraries to $var in reverse order
2986     eval tmp_libs=\"\$$var\"
2987     new_libs=
2988     for deplib in $tmp_libs; do
2989     # FIXME: Pedantically, this is the right thing to do, so
2990     # that some nasty dependency loop isn't accidentally
2991     # broken:
2992     #new_libs="$deplib $new_libs"
2993     # Pragmatically, this seems to cause very few problems in
2994     # practice:
2995     case $deplib in
2996     -L*) new_libs="$deplib $new_libs" ;;
2997     -R*) ;;
2998     *)
2999     # And here is the reason: when a library appears more
3000     # than once as an explicit dependence of a library, or
3001     # is implicitly linked in more than once by the
3002     # compiler, it is considered special, and multiple
3003     # occurrences thereof are not removed. Compare this
3004     # with having the same library being listed as a
3005     # dependency of multiple other libraries: in this case,
3006     # we know (pedantically, we assume) the library does not
3007     # need to be listed more than once, so we keep only the
3008     # last copy. This is not always right, but it is rare
3009     # enough that we require users that really mean to play
3010     # such unportable linking tricks to link the library
3011     # using -Wl,-lname, so that libtool does not consider it
3012     # for duplicate removal.
3013     case " $specialdeplibs " in
3014     *" $deplib "*) new_libs="$deplib $new_libs" ;;
3015     *)
3016     case " $new_libs " in
3017     *" $deplib "*) ;;
3018     *) new_libs="$deplib $new_libs" ;;
3019     esac
3020     ;;
3021     esac
3022     ;;
3023     esac
3024     done
3025     tmp_libs=
3026     for deplib in $new_libs; do
3027     case $deplib in
3028     -L*)
3029     case " $tmp_libs " in
3030     *" $deplib "*) ;;
3031     *) tmp_libs="$tmp_libs $deplib" ;;
3032     esac
3033     ;;
3034     *) tmp_libs="$tmp_libs $deplib" ;;
3035     esac
3036     done
3037     eval $var=\"$tmp_libs\"
3038     done # for var
3039     fi
3040     # Last step: remove runtime libs from dependency_libs
3041     # (they stay in deplibs)
3042     tmp_libs=
3043     for i in $dependency_libs ; do
3044     case " $predeps $postdeps $compiler_lib_search_path " in
3045     *" $i "*)
3046     i=""
3047     ;;
3048     esac
3049     if test -n "$i" ; then
3050     tmp_libs="$tmp_libs $i"
3051     fi
3052     done
3053     dependency_libs=$tmp_libs
3054     done # for pass
3055     if test "$linkmode" = prog; then
3056     dlfiles="$newdlfiles"
3057     dlprefiles="$newdlprefiles"
3058     fi
3059    
3060     case $linkmode in
3061     oldlib)
3062     if test -n "$deplibs"; then
3063     $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
3064     fi
3065    
3066     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3067     $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3068     fi
3069    
3070     if test -n "$rpath"; then
3071     $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3072     fi
3073    
3074     if test -n "$xrpath"; then
3075     $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3076     fi
3077    
3078     if test -n "$vinfo"; then
3079     $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3080     fi
3081    
3082     if test -n "$release"; then
3083     $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3084     fi
3085    
3086     if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3087     $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3088     fi
3089    
3090     # Now set the variables for building old libraries.
3091     build_libtool_libs=no
3092     oldlibs="$output"
3093     objs="$objs$old_deplibs"
3094     ;;
3095    
3096     lib)
3097     # Make sure we only generate libraries of the form `libNAME.la'.
3098     case $outputname in
3099     lib*)
3100     name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3101     eval shared_ext=\"$shrext_cmds\"
3102     eval libname=\"$libname_spec\"
3103     ;;
3104     *)
3105     if test "$module" = no; then
3106     $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3107     $echo "$help" 1>&2
3108     exit $EXIT_FAILURE
3109     fi
3110     if test "$need_lib_prefix" != no; then
3111     # Add the "lib" prefix for modules if required
3112     name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3113     eval shared_ext=\"$shrext_cmds\"
3114     eval libname=\"$libname_spec\"
3115     else
3116     libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3117     fi
3118     ;;
3119     esac
3120    
3121     if test -n "$objs"; then
3122     if test "$deplibs_check_method" != pass_all; then
3123     $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3124     exit $EXIT_FAILURE
3125     else
3126     $echo
3127     $echo "*** Warning: Linking the shared library $output against the non-libtool"
3128     $echo "*** objects $objs is not portable!"
3129     libobjs="$libobjs $objs"
3130     fi
3131     fi
3132    
3133     if test "$dlself" != no; then
3134     $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3135     fi
3136    
3137     set dummy $rpath
3138     if test "$#" -gt 2; then
3139     $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3140     fi
3141     install_libdir="$2"
3142    
3143     oldlibs=
3144     if test -z "$rpath"; then
3145     if test "$build_libtool_libs" = yes; then
3146     # Building a libtool convenience library.
3147     # Some compilers have problems with a `.al' extension so
3148     # convenience libraries should have the same extension an
3149     # archive normally would.
3150     oldlibs="$output_objdir/$libname.$libext $oldlibs"
3151     build_libtool_libs=convenience
3152     build_old_libs=yes
3153     fi
3154    
3155     if test -n "$vinfo"; then
3156     $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3157     fi
3158    
3159     if test -n "$release"; then
3160     $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3161     fi
3162     else
3163    
3164     # Parse the version information argument.
3165     save_ifs="$IFS"; IFS=':'
3166     set dummy $vinfo 0 0 0
3167     IFS="$save_ifs"
3168    
3169     if test -n "$8"; then
3170     $echo "$modename: too many parameters to \`-version-info'" 1>&2
3171     $echo "$help" 1>&2
3172     exit $EXIT_FAILURE
3173     fi
3174    
3175     # convert absolute version numbers to libtool ages
3176     # this retains compatibility with .la files and attempts
3177     # to make the code below a bit more comprehensible
3178    
3179     case $vinfo_number in
3180     yes)
3181     number_major="$2"
3182     number_minor="$3"
3183     number_revision="$4"
3184     #
3185     # There are really only two kinds -- those that
3186     # use the current revision as the major version
3187     # and those that subtract age and use age as
3188     # a minor version. But, then there is irix
3189     # which has an extra 1 added just for fun
3190     #
3191     case $version_type in
3192     darwin|linux|osf|windows)
3193     current=`expr $number_major + $number_minor`
3194     age="$number_minor"
3195     revision="$number_revision"
3196     ;;
3197     freebsd-aout|freebsd-elf|sunos)
3198     current="$number_major"
3199     revision="$number_minor"
3200     age="0"
3201     ;;
3202     irix|nonstopux)
3203     current=`expr $number_major + $number_minor - 1`
3204     age="$number_minor"
3205     revision="$number_minor"
3206     ;;
3207     *)
3208     $echo "$modename: unknown library version type \`$version_type'" 1>&2
3209     $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
3210     exit $EXIT_FAILURE
3211     ;;
3212     esac
3213     ;;
3214     no)
3215     current="$2"
3216     revision="$3"
3217     age="$4"
3218     ;;
3219     esac
3220    
3221     # Check that each of the things are valid numbers.
3222     case $current in
3223     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
3224     *)
3225     $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3226     $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3227     exit $EXIT_FAILURE
3228     ;;
3229     esac
3230    
3231     case $revision in
3232     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
3233     *)
3234     $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3235     $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3236     exit $EXIT_FAILURE
3237     ;;
3238     esac
3239    
3240     case $age in
3241     0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
3242     *)
3243     $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3244     $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3245     exit $EXIT_FAILURE
3246     ;;
3247     esac
3248    
3249     if test "$age" -gt "$current"; then
3250     $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3251     $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3252     exit $EXIT_FAILURE
3253     fi
3254    
3255     # Calculate the version variables.
3256     major=
3257     versuffix=
3258     verstring=
3259     case $version_type in
3260     none) ;;
3261    
3262     darwin)
3263     # Like Linux, but with the current version available in
3264     # verstring for coding it into the library header
3265     major=.`expr $current - $age`
3266     versuffix="$major.$age.$revision"
3267     # Darwin ld doesn't like 0 for these options...
3268     minor_current=`expr $current + 1`
3269     verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3270     ;;
3271    
3272     freebsd-aout)
3273     major=".$current"
3274     versuffix=".$current.$revision";
3275     ;;
3276    
3277     freebsd-elf)
3278     major=".$current"
3279     versuffix=".$current";
3280     ;;
3281    
3282     irix | nonstopux)
3283     major=`expr $current - $age + 1`
3284    
3285     case $version_type in
3286     nonstopux) verstring_prefix=nonstopux ;;
3287     *) verstring_prefix=sgi ;;
3288     esac
3289     verstring="$verstring_prefix$major.$revision"
3290    
3291     # Add in all the interfaces that we are compatible with.
3292     loop=$revision
3293     while test "$loop" -ne 0; do
3294     iface=`expr $revision - $loop`
3295     loop=`expr $loop - 1`
3296     verstring="$verstring_prefix$major.$iface:$verstring"
3297     done
3298    
3299     # Before this point, $major must not contain `.'.
3300     major=.$major
3301     versuffix="$major.$revision"
3302     ;;
3303    
3304     linux)
3305     major=.`expr $current - $age`
3306     versuffix="$major.$age.$revision"
3307     ;;
3308    
3309     osf)
3310     major=.`expr $current - $age`
3311     versuffix=".$current.$age.$revision"
3312     verstring="$current.$age.$revision"
3313    
3314     # Add in all the interfaces that we are compatible with.
3315     loop=$age
3316     while test "$loop" -ne 0; do
3317     iface=`expr $current - $loop`
3318     loop=`expr $loop - 1`
3319     verstring="$verstring:${iface}.0"
3320     done
3321    
3322     # Make executables depend on our current version.
3323     verstring="$verstring:${current}.0"
3324     ;;
3325    
3326     sunos)
3327     major=".$current"
3328     versuffix=".$current.$revision"
3329     ;;
3330    
3331     windows)
3332     # Use '-' rather than '.', since we only want one
3333     # extension on DOS 8.3 filesystems.
3334     major=`expr $current - $age`
3335     versuffix="-$major"
3336     ;;
3337    
3338     *)
3339     $echo "$modename: unknown library version type \`$version_type'" 1>&2
3340     $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
3341     exit $EXIT_FAILURE
3342     ;;
3343     esac
3344    
3345     # Clear the version info if we defaulted, and they specified a release.
3346     if test -z "$vinfo" && test -n "$release"; then
3347     major=
3348     case $version_type in
3349     darwin)
3350     # we can't check for "0.0" in archive_cmds due to quoting
3351     # problems, so we reset it completely
3352     verstring=
3353     ;;
3354     *)
3355     verstring="0.0"
3356     ;;
3357     esac
3358     if test "$need_version" = no; then
3359     versuffix=
3360     else
3361     versuffix=".0.0"
3362     fi
3363     fi
3364    
3365     # Remove version info from name if versioning should be avoided
3366     if test "$avoid_version" = yes && test "$need_version" = no; then
3367     major=
3368     versuffix=
3369     verstring=""
3370     fi
3371    
3372     # Check to see if the archive will have undefined symbols.
3373     if test "$allow_undefined" = yes; then
3374     if test "$allow_undefined_flag" = unsupported; then
3375     $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3376     build_libtool_libs=no
3377     build_old_libs=yes
3378     fi
3379     else
3380     # Don't allow undefined symbols.
3381     allow_undefined_flag="$no_undefined_flag"
3382     fi
3383     fi
3384    
3385     if test "$mode" != relink; then
3386     # Remove our outputs, but don't remove object files since they
3387     # may have been created when compiling PIC objects.
3388     removelist=
3389     tempremovelist=`$echo "$output_objdir/*"`
3390     for p in $tempremovelist; do
3391     case $p in
3392     *.$objext)
3393     ;;
3394     $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3395     if test "X$precious_files_regex" != "X"; then
3396     if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3397     then
3398     continue
3399     fi
3400     fi
3401     removelist="$removelist $p"
3402     ;;
3403     *) ;;
3404     esac
3405     done
3406     if test -n "$removelist"; then
3407     $show "${rm}r $removelist"
3408     $run ${rm}r $removelist
3409     fi
3410     fi
3411    
3412     # Now set the variables for building old libraries.
3413     if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3414     oldlibs="$oldlibs $output_objdir/$libname.$libext"
3415    
3416     # Transform .lo files to .o files.
3417     oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3418     fi
3419    
3420     # Eliminate all temporary directories.
3421     for path in $notinst_path; do
3422     lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3423     deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3424     dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
3425     done
3426    
3427     if test -n "$xrpath"; then
3428     # If the user specified any rpath flags, then add them.
3429     temp_xrpath=
3430     for libdir in $xrpath; do
3431     temp_xrpath="$temp_xrpath -R$libdir"
3432     case "$finalize_rpath " in
3433     *" $libdir "*) ;;
3434     *) finalize_rpath="$finalize_rpath $libdir" ;;
3435     esac
3436     done
3437     if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3438     dependency_libs="$temp_xrpath $dependency_libs"
3439     fi
3440     fi
3441    
3442     # Make sure dlfiles contains only unique files that won't be dlpreopened
3443     old_dlfiles="$dlfiles"
3444     dlfiles=
3445     for lib in $old_dlfiles; do
3446     case " $dlprefiles $dlfiles " in
3447     *" $lib "*) ;;
3448     *) dlfiles="$dlfiles $lib" ;;
3449     esac
3450     done
3451    
3452     # Make sure dlprefiles contains only unique files
3453     old_dlprefiles="$dlprefiles"
3454     dlprefiles=
3455     for lib in $old_dlprefiles; do
3456     case "$dlprefiles " in
3457     *" $lib "*) ;;
3458     *) dlprefiles="$dlprefiles $lib" ;;
3459     esac
3460     done
3461    
3462     if test "$build_libtool_libs" = yes; then
3463     if test -n "$rpath"; then
3464     case $host in
3465     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3466     # these systems don't actually have a c library (as such)!
3467     ;;
3468     *-*-rhapsody* | *-*-darwin1.[012])
3469     # Rhapsody C library is in the System framework
3470     deplibs="$deplibs -framework System"
3471     ;;
3472     *-*-netbsd*)
3473     # Don't link with libc until the a.out ld.so is fixed.
3474     ;;
3475     *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3476     # Do not include libc due to us having libc/libc_r.
3477     ;;
3478     *-*-sco3.2v5* | *-*-sco5v6*)
3479     # Causes problems with __ctype
3480     ;;
3481     *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3482     # Compiler inserts libc in the correct place for threads to work
3483     ;;
3484     *)
3485     # Add libc to deplibs on all other systems if necessary.
3486     if test "$build_libtool_need_lc" = "yes"; then
3487     deplibs="$deplibs -lc"
3488     fi
3489     ;;
3490     esac
3491     fi
3492    
3493     # Transform deplibs into only deplibs that can be linked in shared.
3494     name_save=$name
3495     libname_save=$libname
3496     release_save=$release
3497     versuffix_save=$versuffix
3498     major_save=$major
3499     # I'm not sure if I'm treating the release correctly. I think
3500     # release should show up in the -l (ie -lgmp5) so we don't want to
3501     # add it in twice. Is that correct?
3502     release=""
3503     versuffix=""
3504     major=""
3505     newdeplibs=
3506     droppeddeps=no
3507     case $deplibs_check_method in
3508     pass_all)
3509     # Don't check for shared/static. Everything works.
3510     # This might be a little naive. We might want to check
3511     # whether the library exists or not. But this is on
3512     # osf3 & osf4 and I'm not really sure... Just
3513     # implementing what was already the behavior.
3514     newdeplibs=$deplibs
3515     ;;
3516     test_compile)
3517     # This code stresses the "libraries are programs" paradigm to its
3518     # limits. Maybe even breaks it. We compile a program, linking it
3519     # against the deplibs as a proxy for the library. Then we can check
3520     # whether they linked in statically or dynamically with ldd.
3521     $rm conftest.c
3522     cat > conftest.c <<EOF
3523     int main() { return 0; }
3524     EOF
3525     $rm conftest
3526     $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
3527     if test "$?" -eq 0 ; then
3528     ldd_output=`ldd conftest`
3529     for i in $deplibs; do
3530     name=`expr $i : '-l\(.*\)'`
3531     # If $name is empty we are operating on a -L argument.
3532     if test "$name" != "" && test "$name" -ne "0"; then
3533     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3534     case " $predeps $postdeps " in
3535     *" $i "*)
3536     newdeplibs="$newdeplibs $i"
3537     i=""
3538     ;;
3539     esac
3540     fi
3541     if test -n "$i" ; then
3542     libname=`eval \\$echo \"$libname_spec\"`
3543     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3544     set dummy $deplib_matches
3545     deplib_match=$2
3546     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3547     newdeplibs="$newdeplibs $i"
3548     else
3549     droppeddeps=yes
3550     $echo
3551     $echo "*** Warning: dynamic linker does not accept needed library $i."
3552     $echo "*** I have the capability to make that library automatically link in when"
3553     $echo "*** you link to this library. But I can only do this if you have a"
3554     $echo "*** shared version of the library, which I believe you do not have"
3555     $echo "*** because a test_compile did reveal that the linker did not use it for"
3556     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3557     fi
3558     fi
3559     else
3560     newdeplibs="$newdeplibs $i"
3561     fi
3562     done
3563     else
3564     # Error occurred in the first compile. Let's try to salvage
3565     # the situation: Compile a separate program for each library.
3566     for i in $deplibs; do
3567     name=`expr $i : '-l\(.*\)'`
3568     # If $name is empty we are operating on a -L argument.
3569     if test "$name" != "" && test "$name" != "0"; then
3570     $rm conftest
3571     $LTCC $LTCFLAGS -o conftest conftest.c $i
3572     # Did it work?
3573     if test "$?" -eq 0 ; then
3574     ldd_output=`ldd conftest`
3575     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3576     case " $predeps $postdeps " in
3577     *" $i "*)
3578     newdeplibs="$newdeplibs $i"
3579     i=""
3580     ;;
3581     esac
3582     fi
3583     if test -n "$i" ; then
3584     libname=`eval \\$echo \"$libname_spec\"`
3585     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3586     set dummy $deplib_matches
3587     deplib_match=$2
3588     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3589     newdeplibs="$newdeplibs $i"
3590     else
3591     droppeddeps=yes
3592     $echo
3593     $echo "*** Warning: dynamic linker does not accept needed library $i."
3594     $echo "*** I have the capability to make that library automatically link in when"
3595     $echo "*** you link to this library. But I can only do this if you have a"
3596     $echo "*** shared version of the library, which you do not appear to have"
3597     $echo "*** because a test_compile did reveal that the linker did not use this one"
3598     $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3599     fi
3600     fi
3601     else
3602     droppeddeps=yes
3603     $echo
3604     $echo "*** Warning! Library $i is needed by this library but I was not able to"
3605     $echo "*** make it link in! You will probably need to install it or some"
3606     $echo "*** library that it depends on before this library will be fully"
3607     $echo "*** functional. Installing it before continuing would be even better."
3608     fi
3609     else
3610     newdeplibs="$newdeplibs $i"
3611     fi
3612     done
3613     fi
3614     ;;
3615     file_magic*)
3616     set dummy $deplibs_check_method
3617     file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3618     for a_deplib in $deplibs; do
3619     name=`expr $a_deplib : '-l\(.*\)'`
3620     # If $name is empty we are operating on a -L argument.
3621     if test "$name" != "" && test "$name" != "0"; then
3622     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3623     case " $predeps $postdeps " in
3624     *" $a_deplib "*)
3625     newdeplibs="$newdeplibs $a_deplib"
3626     a_deplib=""
3627     ;;
3628     esac
3629     fi
3630     if test -n "$a_deplib" ; then
3631     libname=`eval \\$echo \"$libname_spec\"`
3632     for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3633     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3634     for potent_lib in $potential_libs; do
3635     # Follow soft links.
3636     if ls -lLd "$potent_lib" 2>/dev/null \
3637     | grep " -> " >/dev/null; then
3638     continue
3639     fi
3640     # The statement above tries to avoid entering an
3641     # endless loop below, in case of cyclic links.
3642     # We might still enter an endless loop, since a link
3643     # loop can be closed while we follow links,
3644     # but so what?
3645     potlib="$potent_lib"
3646     while test -h "$potlib" 2>/dev/null; do
3647     potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3648     case $potliblink in
3649     [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3650     *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3651     esac
3652     done
3653     if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3654     | ${SED} 10q \
3655     | $EGREP "$file_magic_regex" > /dev/null; then
3656     newdeplibs="$newdeplibs $a_deplib"
3657     a_deplib=""
3658     break 2
3659     fi
3660     done
3661     done
3662     fi
3663     if test -n "$a_deplib" ; then
3664     droppeddeps=yes
3665     $echo
3666     $echo "*** Warning: linker path does not have real file for library $a_deplib."
3667     $echo "*** I have the capability to make that library automatically link in when"
3668     $echo "*** you link to this library. But I can only do this if you have a"
3669     $echo "*** shared version of the library, which you do not appear to have"
3670     $echo "*** because I did check the linker path looking for a file starting"
3671     if test -z "$potlib" ; then
3672     $echo "*** with $libname but no candidates were found. (...for file magic test)"
3673     else
3674     $echo "*** with $libname and none of the candidates passed a file format test"
3675     $echo "*** using a file magic. Last file checked: $potlib"
3676     fi
3677     fi
3678     else
3679     # Add a -L argument.
3680     newdeplibs="$newdeplibs $a_deplib"
3681     fi
3682     done # Gone through all deplibs.
3683     ;;
3684     match_pattern*)
3685     set dummy $deplibs_check_method
3686     match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3687     for a_deplib in $deplibs; do
3688     name=`expr $a_deplib : '-l\(.*\)'`
3689     # If $name is empty we are operating on a -L argument.
3690     if test -n "$name" && test "$name" != "0"; then
3691     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3692     case " $predeps $postdeps " in
3693     *" $a_deplib "*)
3694     newdeplibs="$newdeplibs $a_deplib"
3695     a_deplib=""
3696     ;;
3697     esac
3698     fi
3699     if test -n "$a_deplib" ; then
3700     libname=`eval \\$echo \"$libname_spec\"`
3701     for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3702     potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3703     for potent_lib in $potential_libs; do
3704     potlib="$potent_lib" # see symlink-check above in file_magic test
3705     if eval $echo \"$potent_lib\" 2>/dev/null \
3706     | ${SED} 10q \
3707     | $EGREP "$match_pattern_regex" > /dev/null; then
3708     newdeplibs="$newdeplibs $a_deplib"
3709     a_deplib=""
3710     break 2
3711     fi
3712     done
3713     done
3714     fi
3715     if test -n "$a_deplib" ; then
3716     droppeddeps=yes
3717     $echo
3718     $echo "*** Warning: linker path does not have real file for library $a_deplib."
3719     $echo "*** I have the capability to make that library automatically link in when"
3720     $echo "*** you link to this library. But I can only do this if you have a"
3721     $echo "*** shared version of the library, which you do not appear to have"
3722     $echo "*** because I did check the linker path looking for a file starting"
3723     if test -z "$potlib" ; then
3724     $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3725     else
3726     $echo "*** with $libname and none of the candidates passed a file format test"
3727     $echo "*** using a regex pattern. Last file checked: $potlib"
3728     fi
3729     fi
3730     else
3731     # Add a -L argument.
3732     newdeplibs="$newdeplibs $a_deplib"
3733     fi
3734     done # Gone through all deplibs.
3735     ;;
3736     none | unknown | *)
3737     newdeplibs=""
3738     tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3739     -e 's/ -[LR][^ ]*//g'`
3740     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3741     for i in $predeps $postdeps ; do
3742     # can't use Xsed below, because $i might contain '/'
3743     tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3744     done
3745     fi
3746     if $echo "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' \
3747     | grep . >/dev/null; then
3748     $echo
3749     if test "X$deplibs_check_method" = "Xnone"; then
3750     $echo "*** Warning: inter-library dependencies are not supported in this platform."
3751     else
3752     $echo "*** Warning: inter-library dependencies are not known to be supported."
3753     fi
3754     $echo "*** All declared inter-library dependencies are being dropped."
3755     droppeddeps=yes
3756     fi
3757     ;;
3758     esac
3759     versuffix=$versuffix_save
3760     major=$major_save
3761     release=$release_save
3762     libname=$libname_save
3763     name=$name_save
3764    
3765     case $host in
3766     *-*-rhapsody* | *-*-darwin1.[012])
3767     # On Rhapsody replace the C library is the System framework
3768     newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3769     ;;
3770     esac
3771    
3772     if test "$droppeddeps" = yes; then
3773     if test "$module" = yes; then
3774     $echo
3775     $echo "*** Warning: libtool could not satisfy all declared inter-library"
3776     $echo "*** dependencies of module $libname. Therefore, libtool will create"
3777     $echo "*** a static module, that should work as long as the dlopening"
3778     $echo "*** application is linked with the -dlopen flag."
3779     if test -z "$global_symbol_pipe"; then
3780     $echo
3781     $echo "*** However, this would only work if libtool was able to extract symbol"
3782     $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3783     $echo "*** not find such a program. So, this module is probably useless."
3784     $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3785     fi
3786     if test "$build_old_libs" = no; then
3787     oldlibs="$output_objdir/$libname.$libext"
3788     build_libtool_libs=module
3789     build_old_libs=yes
3790     else
3791     build_libtool_libs=no
3792     fi
3793     else
3794     $echo "*** The inter-library dependencies that have been dropped here will be"
3795     $echo "*** automatically added whenever a program is linked with this library"
3796     $echo "*** or is declared to -dlopen it."
3797    
3798     if test "$allow_undefined" = no; then
3799     $echo
3800     $echo "*** Since this library must not contain undefined symbols,"
3801     $echo "*** because either the platform does not support them or"
3802     $echo "*** it was explicitly requested with -no-undefined,"
3803     $echo "*** libtool will only create a static version of it."
3804     if test "$build_old_libs" = no; then
3805     oldlibs="$output_objdir/$libname.$libext"
3806     build_libtool_libs=module
3807     build_old_libs=yes
3808     else
3809     build_libtool_libs=no
3810     fi
3811     fi
3812     fi
3813     fi
3814     # Done checking deplibs!
3815     deplibs=$newdeplibs
3816     fi
3817    
3818    
3819     # move library search paths that coincide with paths to not yet
3820     # installed libraries to the beginning of the library search list
3821     new_libs=
3822     for path in $notinst_path; do
3823     case " $new_libs " in
3824     *" -L$path/$objdir "*) ;;
3825     *)
3826     case " $deplibs " in
3827     *" -L$path/$objdir "*)
3828     new_libs="$new_libs -L$path/$objdir" ;;
3829     esac
3830     ;;
3831     esac
3832     done
3833     for deplib in $deplibs; do
3834     case $deplib in
3835     -L*)
3836     case " $new_libs " in
3837     *" $deplib "*) ;;
3838     *) new_libs="$new_libs $deplib" ;;
3839     esac
3840     ;;
3841     *) new_libs="$new_libs $deplib" ;;
3842     esac
3843     done
3844     deplibs="$new_libs"
3845    
3846    
3847     # All the library-specific variables (install_libdir is set above).
3848     library_names=
3849     old_library=
3850     dlname=
3851    
3852     # Test again, we may have decided not to build it any more
3853     if test "$build_libtool_libs" = yes; then
3854     if test "$hardcode_into_libs" = yes; then
3855     # Hardcode the library paths
3856     hardcode_libdirs=
3857     dep_rpath=
3858     rpath="$finalize_rpath"
3859     test "$mode" != relink && rpath="$compile_rpath$rpath"
3860     for libdir in $rpath; do
3861     if test -n "$hardcode_libdir_flag_spec"; then
3862     if test -n "$hardcode_libdir_separator"; then
3863     if test -z "$hardcode_libdirs"; then
3864     hardcode_libdirs="$libdir"
3865     else
3866     # Just accumulate the unique libdirs.
3867     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3868     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3869     ;;
3870     *)
3871     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3872     ;;
3873     esac
3874     fi
3875     else
3876     eval flag=\"$hardcode_libdir_flag_spec\"
3877     dep_rpath="$dep_rpath $flag"
3878     fi
3879     elif test -n "$runpath_var"; then
3880     case "$perm_rpath " in
3881     *" $libdir "*) ;;
3882     *) perm_rpath="$perm_rpath $libdir" ;;
3883     esac
3884     fi
3885     done
3886     # Substitute the hardcoded libdirs into the rpath.
3887     if test -n "$hardcode_libdir_separator" &&
3888     test -n "$hardcode_libdirs"; then
3889     libdir="$hardcode_libdirs"
3890     if test -n "$hardcode_libdir_flag_spec_ld"; then
3891     eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3892     else
3893     eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3894     fi
3895     fi
3896     if test -n "$runpath_var" && test -n "$perm_rpath"; then
3897     # We should set the runpath_var.
3898     rpath=
3899     for dir in $perm_rpath; do
3900     rpath="$rpath$dir:"
3901     done
3902     eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3903     fi
3904     test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3905     fi
3906    
3907     shlibpath="$finalize_shlibpath"
3908     test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3909     if test -n "$shlibpath"; then
3910     eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3911     fi
3912    
3913     # Get the real and link names of the library.
3914     eval shared_ext=\"$shrext_cmds\"
3915     eval library_names=\"$library_names_spec\"
3916     set dummy $library_names
3917     realname="$2"
3918     shift; shift
3919    
3920     if test -n "$soname_spec"; then
3921     eval soname=\"$soname_spec\"
3922     else
3923     soname="$realname"
3924     fi
3925     if test -z "$dlname"; then
3926     dlname=$soname
3927     fi
3928    
3929     lib="$output_objdir/$realname"
3930     linknames=
3931     for link
3932     do
3933     linknames="$linknames $link"
3934     done
3935    
3936     # Use standard objects if they are pic
3937     test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3938    
3939     # Prepare the list of exported symbols
3940     if test -z "$export_symbols"; then
3941     if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3942     $show "generating symbol list for \`$libname.la'"
3943     export_symbols="$output_objdir/$libname.exp"
3944     $run $rm $export_symbols
3945     cmds=$export_symbols_cmds
3946     save_ifs="$IFS"; IFS='~'
3947     for cmd in $cmds; do
3948     IFS="$save_ifs"
3949     eval cmd=\"$cmd\"
3950     if len=`expr "X$cmd" : ".*"` &&
3951     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3952     $show "$cmd"
3953     $run eval "$cmd" || exit $?
3954     skipped_export=false
3955     else
3956     # The command line is too long to execute in one step.
3957     $show "using reloadable object file for export list..."
3958     skipped_export=:
3959     # Break out early, otherwise skipped_export may be
3960     # set to false by a later but shorter cmd.
3961     break
3962     fi
3963     done
3964     IFS="$save_ifs"
3965     if test -n "$export_symbols_regex"; then
3966     $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3967     $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3968     $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3969     $run eval '$mv "${export_symbols}T" "$export_symbols"'
3970     fi
3971     fi
3972     fi
3973    
3974     if test -n "$export_symbols" && test -n "$include_expsyms"; then
3975     $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3976     fi
3977    
3978     tmp_deplibs=
3979     for test_deplib in $deplibs; do
3980     case " $convenience " in
3981     *" $test_deplib "*) ;;
3982     *)
3983     tmp_deplibs="$tmp_deplibs $test_deplib"
3984     ;;
3985     esac
3986     done
3987     deplibs="$tmp_deplibs"
3988    
3989     if test -n "$convenience"; then
3990     if test -n "$whole_archive_flag_spec"; then
3991     save_libobjs=$libobjs
3992     eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3993     else
3994     gentop="$output_objdir/${outputname}x"
3995     generated="$generated $gentop"
3996    
3997     func_extract_archives $gentop $convenience
3998     libobjs="$libobjs $func_extract_archives_result"
3999     fi
4000     fi
4001    
4002     if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
4003     eval flag=\"$thread_safe_flag_spec\"
4004     linker_flags="$linker_flags $flag"
4005     fi
4006    
4007     # Make a backup of the uninstalled library when relinking
4008     if test "$mode" = relink; then
4009     $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
4010     fi
4011    
4012     # Do each of the archive commands.
4013     if test "$module" = yes && test -n "$module_cmds" ; then
4014     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4015     eval test_cmds=\"$module_expsym_cmds\"
4016     cmds=$module_expsym_cmds
4017     else
4018     eval test_cmds=\"$module_cmds\"
4019     cmds=$module_cmds
4020     fi
4021     else
4022     if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4023     eval test_cmds=\"$archive_expsym_cmds\"
4024     cmds=$archive_expsym_cmds
4025     else
4026     eval test_cmds=\"$archive_cmds\"
4027     cmds=$archive_cmds
4028     fi
4029     fi
4030    
4031     if test "X$skipped_export" != "X:" &&
4032     len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4033     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4034     :
4035     else
4036     # The command line is too long to link in one step, link piecewise.
4037     $echo "creating reloadable object files..."
4038    
4039     # Save the value of $output and $libobjs because we want to
4040     # use them later. If we have whole_archive_flag_spec, we
4041     # want to use save_libobjs as it was before
4042     # whole_archive_flag_spec was expanded, because we can't
4043     # assume the linker understands whole_archive_flag_spec.
4044     # This may have to be revisited, in case too many
4045     # convenience libraries get linked in and end up exceeding
4046     # the spec.
4047     if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
4048     save_libobjs=$libobjs
4049     fi
4050     save_output=$output
4051     output_la=`$echo "X$output" | $Xsed -e "$basename"`
4052    
4053     # Clear the reloadable object creation command queue and
4054     # initialize k to one.
4055     test_cmds=
4056     concat_cmds=
4057     objlist=
4058     delfiles=
4059     last_robj=
4060     k=1
4061     output=$output_objdir/$output_la-${k}.$objext
4062     # Loop over the list of objects to be linked.
4063     for obj in $save_libobjs
4064     do
4065     eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4066     if test "X$objlist" = X ||
4067     { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4068     test "$len" -le "$max_cmd_len"; }; then
4069     objlist="$objlist $obj"
4070     else
4071     # The command $test_cmds is almost too long, add a
4072     # command to the queue.
4073     if test "$k" -eq 1 ; then
4074     # The first file doesn't have a previous command to add.
4075     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4076     else
4077     # All subsequent reloadable object files will link in
4078     # the last one created.
4079     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4080     fi
4081     last_robj=$output_objdir/$output_la-${k}.$objext
4082     k=`expr $k + 1`
4083     output=$output_objdir/$output_la-${k}.$objext
4084     objlist=$obj
4085     len=1
4086     fi
4087     done
4088     # Handle the remaining objects by creating one last
4089     # reloadable object file. All subsequent reloadable object
4090     # files will link in the last one created.
4091     test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4092     eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4093    
4094     if ${skipped_export-false}; then
4095     $show "generating symbol list for \`$libname.la'"
4096     export_symbols="$output_objdir/$libname.exp"
4097     $run $rm $export_symbols
4098     libobjs=$output
4099     # Append the command to create the export file.
4100     eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4101     fi
4102    
4103     # Set up a command to remove the reloadable object files
4104     # after they are used.
4105     i=0
4106     while test "$i" -lt "$k"
4107     do
4108     i=`expr $i + 1`
4109     delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4110     done
4111    
4112     $echo "creating a temporary reloadable object file: $output"
4113    
4114     # Loop through the commands generated above and execute them.
4115     save_ifs="$IFS"; IFS='~'
4116     for cmd in $concat_cmds; do
4117     IFS="$save_ifs"
4118     $show "$cmd"
4119     $run eval "$cmd" || exit $?
4120     done
4121     IFS="$save_ifs"
4122    
4123     libobjs=$output
4124     # Restore the value of output.
4125     output=$save_output
4126    
4127     if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4128     eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4129     fi
4130     # Expand the library linking commands again to reset the
4131     # value of $libobjs for piecewise linking.
4132    
4133     # Do each of the archive commands.
4134     if test "$module" = yes && test -n "$module_cmds" ; then
4135     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4136     cmds=$module_expsym_cmds
4137     else
4138     cmds=$module_cmds
4139     fi
4140     else
4141     if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4142     cmds=$archive_expsym_cmds
4143     else
4144     cmds=$archive_cmds
4145     fi
4146     fi
4147    
4148     # Append the command to remove the reloadable object files
4149     # to the just-reset $cmds.
4150     eval cmds=\"\$cmds~\$rm $delfiles\"
4151     fi
4152     save_ifs="$IFS"; IFS='~'
4153     for cmd in $cmds; do
4154     IFS="$save_ifs"
4155     eval cmd=\"$cmd\"
4156     $show "$cmd"
4157     $run eval "$cmd" || {
4158     lt_exit=$?
4159    
4160     # Restore the uninstalled library and exit
4161     if test "$mode" = relink; then
4162     $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
4163     fi
4164    
4165     exit $lt_exit
4166     }
4167     done
4168     IFS="$save_ifs"
4169    
4170     # Restore the uninstalled library and exit
4171     if test "$mode" = relink; then
4172     $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
4173    
4174     if test -n "$convenience"; then
4175     if test -z "$whole_archive_flag_spec"; then
4176     $show "${rm}r $gentop"
4177     $run ${rm}r "$gentop"
4178     fi
4179     fi
4180    
4181     exit $EXIT_SUCCESS
4182     fi
4183    
4184     # Create links to the real library.
4185     for linkname in $linknames; do
4186     if test "$realname" != "$linkname"; then
4187     $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4188     $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
4189     fi
4190     done
4191    
4192     # If -module or -export-dynamic was specified, set the dlname.
4193     if test "$module" = yes || test "$export_dynamic" = yes; then
4194     # On all known operating systems, these are identical.
4195     dlname="$soname"
4196     fi
4197     fi
4198     ;;
4199    
4200     obj)
4201     if test -n "$deplibs"; then
4202     $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4203     fi
4204    
4205     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4206     $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4207     fi
4208    
4209     if test -n "$rpath"; then
4210     $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4211     fi
4212    
4213     if test -n "$xrpath"; then
4214     $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4215     fi
4216    
4217     if test -n "$vinfo"; then
4218     $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4219     fi
4220    
4221     if test -n "$release"; then
4222     $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4223     fi
4224    
4225     case $output in
4226     *.lo)
4227     if test -n "$objs$old_deplibs"; then
4228     $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4229     exit $EXIT_FAILURE
4230     fi
4231     libobj="$output"
4232     obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4233     ;;
4234     *)
4235     libobj=
4236     obj="$output"
4237     ;;
4238     esac
4239    
4240     # Delete the old objects.
4241     $run $rm $obj $libobj
4242    
4243     # Objects from convenience libraries. This assumes
4244     # single-version convenience libraries. Whenever we create
4245     # different ones for PIC/non-PIC, this we'll have to duplicate
4246     # the extraction.
4247     reload_conv_objs=
4248     gentop=
4249     # reload_cmds runs $LD directly, so let us get rid of
4250     # -Wl from whole_archive_flag_spec
4251     wl=
4252    
4253     if test -n "$convenience"; then
4254     if test -n "$whole_archive_flag_spec"; then
4255     eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
4256     else
4257     gentop="$output_objdir/${obj}x"
4258     generated="$generated $gentop"
4259    
4260     func_extract_archives $gentop $convenience
4261     reload_conv_objs="$reload_objs $func_extract_archives_result"
4262     fi
4263     fi
4264    
4265     # Create the old-style object.
4266     reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4267    
4268     output="$obj"
4269     cmds=$reload_cmds
4270     save_ifs="$IFS"; IFS='~'
4271     for cmd in $cmds; do
4272     IFS="$save_ifs"
4273     eval cmd=\"$cmd\"
4274     $show "$cmd"
4275     $run eval "$cmd" || exit $?
4276     done
4277     IFS="$save_ifs"
4278    
4279     # Exit if we aren't doing a library object file.
4280     if test -z "$libobj"; then
4281     if test -n "$gentop"; then
4282     $show "${rm}r $gentop"
4283     $run ${rm}r $gentop
4284     fi
4285    
4286     exit $EXIT_SUCCESS
4287     fi
4288    
4289     if test "$build_libtool_libs" != yes; then
4290     if test -n "$gentop"; then
4291     $show "${rm}r $gentop"
4292     $run ${rm}r $gentop
4293     fi
4294    
4295     # Create an invalid libtool object if no PIC, so that we don't
4296     # accidentally link it into a program.
4297     # $show "echo timestamp > $libobj"
4298     # $run eval "echo timestamp > $libobj" || exit $?
4299     exit $EXIT_SUCCESS
4300     fi
4301    
4302     if test -n "$pic_flag" || test "$pic_mode" != default; then
4303     # Only do commands if we really have different PIC objects.
4304     reload_objs="$libobjs $reload_conv_objs"
4305     output="$libobj"
4306     cmds=$reload_cmds
4307     save_ifs="$IFS"; IFS='~'
4308     for cmd in $cmds; do
4309     IFS="$save_ifs"
4310     eval cmd=\"$cmd\"
4311     $show "$cmd"
4312     $run eval "$cmd" || exit $?
4313     done
4314     IFS="$save_ifs"
4315     fi
4316    
4317     if test -n "$gentop"; then
4318     $show "${rm}r $gentop"
4319     $run ${rm}r $gentop
4320     fi
4321    
4322     exit $EXIT_SUCCESS
4323     ;;
4324    
4325     prog)
4326     case $host in
4327     *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4328     esac
4329     if test -n "$vinfo"; then
4330     $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4331     fi
4332    
4333     if test -n "$release"; then
4334     $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4335     fi
4336    
4337     if test "$preload" = yes; then
4338     if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4339     test "$dlopen_self_static" = unknown; then
4340     $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4341     fi
4342     fi
4343    
4344     case $host in
4345     *-*-rhapsody* | *-*-darwin1.[012])
4346     # On Rhapsody replace the C library is the System framework
4347     compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4348     finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4349     ;;
4350     esac
4351    
4352     case $host in
4353     *darwin*)
4354     # Don't allow lazy linking, it breaks C++ global constructors
4355     if test "$tagname" = CXX ; then
4356     compile_command="$compile_command ${wl}-bind_at_load"
4357     finalize_command="$finalize_command ${wl}-bind_at_load"
4358     fi
4359     ;;
4360     esac
4361    
4362    
4363     # move library search paths that coincide with paths to not yet
4364     # installed libraries to the beginning of the library search list
4365     new_libs=
4366     for path in $notinst_path; do
4367     case " $new_libs " in
4368     *" -L$path/$objdir "*) ;;
4369     *)
4370     case " $compile_deplibs " in
4371     *" -L$path/$objdir "*)
4372     new_libs="$new_libs -L$path/$objdir" ;;
4373     esac
4374     ;;
4375     esac
4376     done
4377     for deplib in $compile_deplibs; do
4378     case $deplib in
4379     -L*)
4380     case " $new_libs " in
4381     *" $deplib "*) ;;
4382     *) new_libs="$new_libs $deplib" ;;
4383     esac
4384     ;;
4385     *) new_libs="$new_libs $deplib" ;;
4386     esac
4387     done
4388     compile_deplibs="$new_libs"
4389    
4390    
4391     compile_command="$compile_command $compile_deplibs"
4392     finalize_command="$finalize_command $finalize_deplibs"
4393    
4394     if test -n "$rpath$xrpath"; then
4395     # If the user specified any rpath flags, then add them.
4396     for libdir in $rpath $xrpath; do
4397     # This is the magic to use -rpath.
4398     case "$finalize_rpath " in
4399     *" $libdir "*) ;;
4400     *) finalize_rpath="$finalize_rpath $libdir" ;;
4401     esac
4402     done
4403     fi
4404    
4405     # Now hardcode the library paths
4406     rpath=
4407     hardcode_libdirs=
4408     for libdir in $compile_rpath $finalize_rpath; do
4409     if test -n "$hardcode_libdir_flag_spec"; then
4410     if test -n "$hardcode_libdir_separator"; then
4411     if test -z "$hardcode_libdirs"; then
4412     hardcode_libdirs="$libdir"
4413     else
4414     # Just accumulate the unique libdirs.
4415     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4416     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4417     ;;
4418     *)
4419     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4420     ;;
4421     esac
4422     fi
4423     else
4424     eval flag=\"$hardcode_libdir_flag_spec\"
4425     rpath="$rpath $flag"
4426     fi
4427     elif test -n "$runpath_var"; then
4428     case "$perm_rpath " in
4429     *" $libdir "*) ;;
4430     *) perm_rpath="$perm_rpath $libdir" ;;
4431     esac
4432     fi
4433     case $host in
4434     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4435     testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
4436     case :$dllsearchpath: in
4437     *":$libdir:"*) ;;
4438     *) dllsearchpath="$dllsearchpath:$libdir";;
4439     esac
4440     case :$dllsearchpath: in
4441     *":$testbindir:"*) ;;
4442     *) dllsearchpath="$dllsearchpath:$testbindir";;
4443     esac
4444     ;;
4445     esac
4446     done
4447     # Substitute the hardcoded libdirs into the rpath.
4448     if test -n "$hardcode_libdir_separator" &&
4449     test -n "$hardcode_libdirs"; then
4450     libdir="$hardcode_libdirs"
4451     eval rpath=\" $hardcode_libdir_flag_spec\"
4452     fi
4453     compile_rpath="$rpath"
4454    
4455     rpath=
4456     hardcode_libdirs=
4457     for libdir in $finalize_rpath; do
4458     if test -n "$hardcode_libdir_flag_spec"; then
4459     if test -n "$hardcode_libdir_separator"; then
4460     if test -z "$hardcode_libdirs"; then
4461     hardcode_libdirs="$libdir"
4462     else
4463     # Just accumulate the unique libdirs.
4464     case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4465     *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4466     ;;
4467     *)
4468     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4469     ;;
4470     esac
4471     fi
4472     else
4473     eval flag=\"$hardcode_libdir_flag_spec\"
4474     rpath="$rpath $flag"
4475     fi
4476     elif test -n "$runpath_var"; then
4477     case "$finalize_perm_rpath " in
4478     *" $libdir "*) ;;
4479     *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4480     esac
4481     fi
4482     done
4483     # Substitute the hardcoded libdirs into the rpath.
4484     if test -n "$hardcode_libdir_separator" &&
4485     test -n "$hardcode_libdirs"; then
4486     libdir="$hardcode_libdirs"
4487     eval rpath=\" $hardcode_libdir_flag_spec\"
4488     fi
4489     finalize_rpath="$rpath"
4490    
4491     if test -n "$libobjs" && test "$build_old_libs" = yes; then
4492     # Transform all the library objects into standard objects.
4493     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4494     finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4495     fi
4496    
4497     dlsyms=
4498     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4499     if test -n "$NM" && test -n "$global_symbol_pipe"; then
4500     dlsyms="${outputname}S.c"
4501     else
4502     $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4503     fi
4504     fi
4505    
4506     if test -n "$dlsyms"; then
4507     case $dlsyms in
4508     "") ;;
4509     *.c)
4510     # Discover the nlist of each of the dlfiles.
4511     nlist="$output_objdir/${outputname}.nm"
4512    
4513     $show "$rm $nlist ${nlist}S ${nlist}T"
4514     $run $rm "$nlist" "${nlist}S" "${nlist}T"
4515    
4516     # Parse the name list into a source file.
4517     $show "creating $output_objdir/$dlsyms"
4518    
4519     test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4520     /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4521     /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4522    
4523     #ifdef __cplusplus
4524     extern \"C\" {
4525     #endif
4526    
4527     /* Prevent the only kind of declaration conflicts we can make. */
4528     #define lt_preloaded_symbols some_other_symbol
4529    
4530     /* External symbol declarations for the compiler. */\
4531     "
4532    
4533     if test "$dlself" = yes; then
4534     $show "generating symbol list for \`$output'"
4535    
4536     test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4537    
4538     # Add our own program objects to the symbol list.
4539     progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4540     for arg in $progfiles; do
4541     $show "extracting global C symbols from \`$arg'"
4542     $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4543     done
4544    
4545     if test -n "$exclude_expsyms"; then
4546     $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4547     $run eval '$mv "$nlist"T "$nlist"'
4548     fi
4549    
4550     if test -n "$export_symbols_regex"; then
4551     $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4552     $run eval '$mv "$nlist"T "$nlist"'
4553     fi
4554    
4555     # Prepare the list of exported symbols
4556     if test -z "$export_symbols"; then
4557     export_symbols="$output_objdir/$outputname.exp"
4558     $run $rm $export_symbols
4559     $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4560     case $host in
4561     *cygwin* | *mingw* )
4562     $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4563     $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4564     ;;
4565     esac
4566     else
4567     $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4568     $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4569     $run eval 'mv "$nlist"T "$nlist"'
4570     case $host in
4571     *cygwin* | *mingw* )
4572     $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4573     $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4574     ;;
4575     esac
4576     fi
4577     fi
4578    
4579     for arg in $dlprefiles; do
4580     $show "extracting global C symbols from \`$arg'"
4581     name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4582     $run eval '$echo ": $name " >> "$nlist"'
4583     $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4584     done
4585    
4586     if test -z "$run"; then
4587     # Make sure we have at least an empty file.
4588     test -f "$nlist" || : > "$nlist"
4589    
4590     if test -n "$exclude_expsyms"; then
4591     $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4592     $mv "$nlist"T "$nlist"
4593     fi
4594    
4595     # Try sorting and uniquifying the output.
4596     if grep -v "^: " < "$nlist" |
4597     if sort -k 3 </dev/null >/dev/null 2>&1; then
4598     sort -k 3
4599     else
4600     sort +2
4601     fi |
4602     uniq > "$nlist"S; then
4603     :
4604     else
4605     grep -v "^: " < "$nlist" > "$nlist"S
4606     fi
4607    
4608     if test -f "$nlist"S; then
4609     eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4610     else
4611     $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4612     fi
4613    
4614     $echo >> "$output_objdir/$dlsyms" "\
4615    
4616     #undef lt_preloaded_symbols
4617    
4618     #if defined (__STDC__) && __STDC__
4619     # define lt_ptr void *
4620     #else
4621     # define lt_ptr char *
4622     # define const
4623     #endif
4624    
4625     /* The mapping between symbol names and symbols. */
4626     "
4627    
4628     case $host in
4629     *cygwin* | *mingw* )
4630     $echo >> "$output_objdir/$dlsyms" "\
4631     /* DATA imports from DLLs on WIN32 can't be const, because
4632     runtime relocations are performed -- see ld's documentation
4633     on pseudo-relocs */
4634     struct {
4635     "
4636     ;;
4637     * )
4638     $echo >> "$output_objdir/$dlsyms" "\
4639     const struct {
4640     "
4641     ;;
4642     esac
4643    
4644    
4645     $echo >> "$output_objdir/$dlsyms" "\
4646     const char *name;
4647     lt_ptr address;
4648     }
4649     lt_preloaded_symbols[] =
4650     {\
4651     "
4652    
4653     eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4654    
4655     $echo >> "$output_objdir/$dlsyms" "\
4656     {0, (lt_ptr) 0}
4657     };
4658    
4659     /* This works around a problem in FreeBSD linker */
4660     #ifdef FREEBSD_WORKAROUND
4661     static const void *lt_preloaded_setup() {
4662     return lt_preloaded_symbols;
4663     }
4664     #endif
4665    
4666     #ifdef __cplusplus
4667     }
4668     #endif\
4669     "
4670     fi
4671    
4672     pic_flag_for_symtable=
4673     case $host in
4674     # compiling the symbol table file with pic_flag works around
4675     # a FreeBSD bug that causes programs to crash when -lm is
4676     # linked before any other PIC object. But we must not use
4677     # pic_flag when linking with -static. The problem exists in
4678     # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4679     *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4680     case "$compile_command " in
4681     *" -static "*) ;;
4682     *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4683     esac;;
4684     *-*-hpux*)
4685     case "$compile_command " in
4686     *" -static "*) ;;
4687     *) pic_flag_for_symtable=" $pic_flag";;
4688     esac
4689     esac
4690    
4691     # Now compile the dynamic symbol file.
4692     $show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4693     $run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4694    
4695     # Clean up the generated files.
4696     $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4697     $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4698    
4699     # Transform the symbol file into the correct name.
4700     case $host in
4701     *cygwin* | *mingw* )
4702     if test -f "$output_objdir/${outputname}.def" ; then
4703     compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4704     finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
4705     else
4706     compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4707     finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4708     fi
4709     ;;
4710     * )
4711     compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4712     finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4713     ;;
4714     esac
4715     ;;
4716     *)
4717     $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4718     exit $EXIT_FAILURE
4719     ;;
4720     esac
4721     else
4722     # We keep going just in case the user didn't refer to
4723     # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
4724     # really was required.
4725    
4726     # Nullify the symbol file.
4727     compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4728     finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4729     fi
4730    
4731     if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4732     # Replace the output file specification.
4733     compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4734     link_command="$compile_command$compile_rpath"
4735    
4736     # We have no uninstalled library dependencies, so finalize right now.
4737     $show "$link_command"
4738     $run eval "$link_command"
4739     exit_status=$?
4740    
4741     # Delete the generated files.
4742     if test -n "$dlsyms"; then
4743     $show "$rm $output_objdir/${outputname}S.${objext}"
4744     $run $rm "$output_objdir/${outputname}S.${objext}"
4745     fi
4746    
4747     exit $exit_status
4748     fi
4749    
4750     if test -n "$shlibpath_var"; then
4751     # We should set the shlibpath_var
4752     rpath=
4753     for dir in $temp_rpath; do
4754     case $dir in
4755     [\\/]* | [A-Za-z]:[\\/]*)
4756     # Absolute path.
4757     rpath="$rpath$dir:"
4758     ;;
4759     *)
4760     # Relative path: add a thisdir entry.
4761     rpath="$rpath\$thisdir/$dir:"
4762     ;;
4763     esac
4764     done
4765     temp_rpath="$rpath"
4766     fi
4767    
4768     if test -n "$compile_shlibpath$finalize_shlibpath"; then
4769     compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4770     fi
4771     if test -n "$finalize_shlibpath"; then
4772     finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4773     fi
4774    
4775     compile_var=
4776     finalize_var=
4777     if test -n "$runpath_var"; then
4778     if test -n "$perm_rpath"; then
4779     # We should set the runpath_var.
4780     rpath=
4781     for dir in $perm_rpath; do
4782     rpath="$rpath$dir:"
4783     done
4784     compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4785     fi
4786     if test -n "$finalize_perm_rpath"; then
4787     # We should set the runpath_var.
4788     rpath=
4789     for dir in $finalize_perm_rpath; do
4790     rpath="$rpath$dir:"
4791     done
4792     finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4793     fi
4794     fi
4795    
4796     if test "$no_install" = yes; then
4797     # We don't need to create a wrapper script.
4798     link_command="$compile_var$compile_command$compile_rpath"
4799     # Replace the output file specification.
4800     link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4801     # Delete the old output file.
4802     $run $rm $output
4803     # Link the executable and exit
4804     $show "$link_command"
4805     $run eval "$link_command" || exit $?
4806     exit $EXIT_SUCCESS
4807     fi
4808    
4809     if test "$hardcode_action" = relink; then
4810     # Fast installation is not supported
4811     link_command="$compile_var$compile_command$compile_rpath"
4812     relink_command="$finalize_var$finalize_command$finalize_rpath"
4813    
4814     $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4815     $echo "$modename: \`$output' will be relinked during installation" 1>&2
4816     else
4817     if test "$fast_install" != no; then
4818     link_command="$finalize_var$compile_command$finalize_rpath"
4819     if test "$fast_install" = yes; then
4820     relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4821     else
4822     # fast_install is set to needless
4823     relink_command=
4824     fi
4825     else
4826     link_command="$compile_var$compile_command$compile_rpath"
4827     relink_command="$finalize_var$finalize_command$finalize_rpath"
4828     fi
4829     fi
4830    
4831     # Replace the output file specification.
4832     link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4833    
4834     # Delete the old output files.
4835     $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4836    
4837     $show "$link_command"
4838     $run eval "$link_command" || exit $?
4839    
4840     # Now create the wrapper script.
4841     $show "creating $output"
4842    
4843     # Quote the relink command for shipping.
4844     if test -n "$relink_command"; then
4845     # Preserve any variables that may affect compiler behavior
4846     for var in $variables_saved_for_relink; do
4847     if eval test -z \"\${$var+set}\"; then
4848     relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4849     elif eval var_value=\$$var; test -z "$var_value"; then
4850     relink_command="$var=; export $var; $relink_command"
4851     else
4852     var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4853     relink_command="$var=\"$var_value\"; export $var; $relink_command"
4854     fi
4855     done
4856     relink_command="(cd `pwd`; $relink_command)"
4857     relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4858     fi
4859    
4860     # Quote $echo for shipping.
4861     if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4862     case $progpath in
4863     [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4864     *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4865     esac
4866     qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4867     else
4868     qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4869     fi
4870    
4871     # Only actually do things if our run command is non-null.
4872     if test -z "$run"; then
4873     # win32 will think the script is a binary if it has
4874     # a .exe suffix, so we strip it off here.
4875     case $output in
4876     *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4877     esac
4878     # test for cygwin because mv fails w/o .exe extensions
4879     case $host in
4880     *cygwin*)
4881     exeext=.exe
4882     outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4883     *) exeext= ;;
4884     esac
4885     case $host in
4886     *cygwin* | *mingw* )
4887     output_name=`basename $output`
4888     output_path=`dirname $output`
4889     cwrappersource="$output_path/$objdir/lt-$output_name.c"
4890     cwrapper="$output_path/$output_name.exe"
4891     $rm $cwrappersource $cwrapper
4892     trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4893    
4894     cat > $cwrappersource <<EOF
4895    
4896     /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4897     Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4898    
4899     The $output program cannot be directly executed until all the libtool
4900     libraries that it depends on are installed.
4901    
4902     This wrapper executable should never be moved out of the build directory.
4903     If it is, it will not operate correctly.
4904    
4905     Currently, it simply execs the wrapper *script* "/bin/sh $output",
4906     but could eventually absorb all of the scripts functionality and
4907     exec $objdir/$outputname directly.
4908     */
4909     EOF
4910     cat >> $cwrappersource<<"EOF"
4911     #include <stdio.h>
4912     #include <stdlib.h>
4913     #include <unistd.h>
4914     #include <malloc.h>
4915     #include <stdarg.h>
4916     #include <assert.h>
4917     #include <string.h>
4918     #include <ctype.h>
4919     #include <sys/stat.h>
4920    
4921     #if defined(PATH_MAX)
4922     # define LT_PATHMAX PATH_MAX
4923     #elif defined(MAXPATHLEN)
4924     # define LT_PATHMAX MAXPATHLEN
4925     #else
4926     # define LT_PATHMAX 1024
4927     #endif
4928    
4929     #ifndef DIR_SEPARATOR
4930     # define DIR_SEPARATOR '/'
4931     # define PATH_SEPARATOR ':'
4932     #endif
4933    
4934     #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4935     defined (__OS2__)
4936     # define HAVE_DOS_BASED_FILE_SYSTEM
4937     # ifndef DIR_SEPARATOR_2
4938     # define DIR_SEPARATOR_2 '\\'
4939     # endif
4940     # ifndef PATH_SEPARATOR_2
4941     # define PATH_SEPARATOR_2 ';'
4942     # endif
4943     #endif
4944    
4945     #ifndef DIR_SEPARATOR_2
4946     # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4947     #else /* DIR_SEPARATOR_2 */
4948     # define IS_DIR_SEPARATOR(ch) \
4949     (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4950     #endif /* DIR_SEPARATOR_2 */
4951    
4952     #ifndef PATH_SEPARATOR_2
4953     # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4954     #else /* PATH_SEPARATOR_2 */
4955     # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4956     #endif /* PATH_SEPARATOR_2 */
4957    
4958     #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4959     #define XFREE(stale) do { \
4960     if (stale) { free ((void *) stale); stale = 0; } \
4961     } while (0)
4962    
4963     /* -DDEBUG is fairly common in CFLAGS. */
4964     #undef DEBUG
4965     #if defined DEBUGWRAPPER
4966     # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
4967     #else
4968     # define DEBUG(format, ...)
4969     #endif
4970    
4971     const char *program_name = NULL;
4972    
4973     void * xmalloc (size_t num);
4974     char * xstrdup (const char *string);
4975     const char * base_name (const char *name);
4976     char * find_executable(const char *wrapper);
4977     int check_executable(const char *path);
4978     char * strendzap(char *str, const char *pat);
4979     void lt_fatal (const char *message, ...);
4980    
4981     int
4982     main (int argc, char *argv[])
4983     {
4984     char **newargz;
4985     int i;
4986    
4987     program_name = (char *) xstrdup (base_name (argv[0]));
4988     DEBUG("(main) argv[0] : %s\n",argv[0]);
4989     DEBUG("(main) program_name : %s\n",program_name);
4990     newargz = XMALLOC(char *, argc+2);
4991     EOF
4992    
4993     cat >> $cwrappersource <<EOF
4994     newargz[0] = (char *) xstrdup("$SHELL");
4995     EOF
4996    
4997     cat >> $cwrappersource <<"EOF"
4998     newargz[1] = find_executable(argv[0]);
4999     if (newargz[1] == NULL)
5000     lt_fatal("Couldn't find %s", argv[0]);
5001     DEBUG("(main) found exe at : %s\n",newargz[1]);
5002     /* we know the script has the same name, without the .exe */
5003     /* so make sure newargz[1] doesn't end in .exe */
5004     strendzap(newargz[1],".exe");
5005     for (i = 1; i < argc; i++)
5006     newargz[i+1] = xstrdup(argv[i]);
5007     newargz[argc+1] = NULL;
5008    
5009     for (i=0; i<argc+1; i++)
5010     {
5011     DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
5012     ;
5013     }
5014    
5015     EOF
5016    
5017     case $host_os in
5018     mingw*)
5019     cat >> $cwrappersource <<EOF
5020     execv("$SHELL",(char const **)newargz);
5021     EOF
5022     ;;
5023     *)
5024     cat >> $cwrappersource <<EOF
5025     execv("$SHELL",newargz);
5026     EOF
5027     ;;
5028     esac
5029    
5030     cat >> $cwrappersource <<"EOF"
5031     return 127;
5032     }
5033    
5034     void *
5035     xmalloc (size_t num)
5036     {
5037     void * p = (void *) malloc (num);
5038     if (!p)
5039     lt_fatal ("Memory exhausted");
5040    
5041     return p;
5042     }
5043    
5044     char *
5045     xstrdup (const char *string)
5046     {
5047     return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5048     ;
5049     }
5050    
5051     const char *
5052     base_name (const char *name)
5053     {
5054     const char *base;
5055    
5056     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5057     /* Skip over the disk name in MSDOS pathnames. */
5058     if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5059     name += 2;
5060     #endif
5061    
5062     for (base = name; *name; name++)
5063     if (IS_DIR_SEPARATOR (*name))
5064     base = name + 1;
5065     return base;
5066     }
5067    
5068     int
5069     check_executable(const char * path)
5070     {
5071     struct stat st;
5072    
5073     DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5074     if ((!path) || (!*path))
5075     return 0;
5076    
5077     if ((stat (path, &st) >= 0) &&
5078     (
5079     /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5080     #if defined (S_IXOTH)
5081     ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5082     #endif
5083     #if defined (S_IXGRP)
5084     ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5085     #endif
5086     ((st.st_mode & S_IXUSR) == S_IXUSR))
5087     )
5088     return 1;
5089     else
5090     return 0;
5091     }
5092    
5093     /* Searches for the full path of the wrapper. Returns
5094     newly allocated full path name if found, NULL otherwise */
5095     char *
5096     find_executable (const char* wrapper)
5097     {
5098     int has_slash = 0;
5099     const char* p;
5100     const char* p_next;
5101     /* static buffer for getcwd */
5102     char tmp[LT_PATHMAX + 1];
5103     int tmp_len;
5104     char* concat_name;
5105    
5106     DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5107    
5108     if ((wrapper == NULL) || (*wrapper == '\0'))
5109     return NULL;
5110    
5111     /* Absolute path? */
5112     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5113     if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5114     {
5115     concat_name = xstrdup (wrapper);
5116     if (check_executable(concat_name))
5117     return concat_name;
5118     XFREE(concat_name);
5119     }
5120     else
5121     {
5122     #endif
5123     if (IS_DIR_SEPARATOR (wrapper[0]))
5124     {
5125     concat_name = xstrdup (wrapper);
5126     if (check_executable(concat_name))
5127     return concat_name;
5128     XFREE(concat_name);
5129     }
5130     #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5131     }
5132     #endif
5133    
5134     for (p = wrapper; *p; p++)
5135     if (*p == '/')
5136     {
5137     has_slash = 1;
5138     break;
5139     }
5140     if (!has_slash)
5141     {
5142     /* no slashes; search PATH */
5143     const char* path = getenv ("PATH");
5144     if (path != NULL)
5145     {
5146     for (p = path; *p; p = p_next)
5147     {
5148     const char* q;
5149     size_t p_len;
5150     for (q = p; *q; q++)
5151     if (IS_PATH_SEPARATOR(*q))
5152     break;
5153     p_len = q - p;
5154     p_next = (*q == '\0' ? q : q + 1);
5155     if (p_len == 0)
5156     {
5157     /* empty path: current directory */
5158     if (getcwd (tmp, LT_PATHMAX) == NULL)
5159     lt_fatal ("getcwd failed");
5160     tmp_len = strlen(tmp);
5161     concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5162     memcpy (concat_name, tmp, tmp_len);
5163     concat_name[tmp_len] = '/';
5164     strcpy (concat_name + tmp_len + 1, wrapper);
5165     }
5166     else
5167     {
5168     concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5169     memcpy (concat_name, p, p_len);
5170     concat_name[p_len] = '/';
5171     strcpy (concat_name + p_len + 1, wrapper);
5172     }
5173     if (check_executable(concat_name))
5174     return concat_name;
5175     XFREE(concat_name);
5176     }
5177     }
5178     /* not found in PATH; assume curdir */
5179     }
5180     /* Relative path | not found in path: prepend cwd */
5181     if (getcwd (tmp, LT_PATHMAX) == NULL)
5182     lt_fatal ("getcwd failed");
5183     tmp_len = strlen(tmp);
5184     concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5185     memcpy (concat_name, tmp, tmp_len);
5186     concat_name[tmp_len] = '/';
5187     strcpy (concat_name + tmp_len + 1, wrapper);
5188    
5189     if (check_executable(concat_name))
5190     return concat_name;
5191     XFREE(concat_name);
5192     return NULL;
5193     }
5194    
5195     char *
5196     strendzap(char *str, const char *pat)
5197     {
5198     size_t len, patlen;
5199    
5200     assert(str != NULL);
5201     assert(pat != NULL);
5202    
5203     len = strlen(str);
5204     patlen = strlen(pat);
5205    
5206     if (patlen <= len)
5207     {
5208     str += len - patlen;
5209     if (strcmp(str, pat) == 0)
5210     *str = '\0';
5211     }
5212     return str;
5213     }
5214    
5215     static void
5216     lt_error_core (int exit_status, const char * mode,
5217     const char * message, va_list ap)
5218     {
5219     fprintf (stderr, "%s: %s: ", program_name, mode);
5220     vfprintf (stderr, message, ap);
5221     fprintf (stderr, ".\n");
5222    
5223     if (exit_status >= 0)
5224     exit (exit_status);
5225     }
5226    
5227     void
5228     lt_fatal (const char *message, ...)
5229     {
5230     va_list ap;
5231     va_start (ap, message);
5232     lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5233     va_end (ap);
5234     }
5235     EOF
5236     # we should really use a build-platform specific compiler
5237     # here, but OTOH, the wrappers (shell script and this C one)
5238     # are only useful if you want to execute the "real" binary.
5239     # Since the "real" binary is built for $host, then this
5240     # wrapper might as well be built for $host, too.
5241     $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5242     ;;
5243     esac
5244     $rm $output
5245     trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5246    
5247     $echo > $output "\
5248     #! $SHELL
5249    
5250     # $output - temporary wrapper script for $objdir/$outputname
5251     # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5252     #
5253     # The $output program cannot be directly executed until all the libtool
5254     # libraries that it depends on are installed.
5255     #
5256     # This wrapper script should never be moved out of the build directory.
5257     # If it is, it will not operate correctly.
5258    
5259     # Sed substitution that helps us do robust quoting. It backslashifies
5260     # metacharacters that are still active within double-quoted strings.
5261     Xsed='${SED} -e 1s/^X//'
5262     sed_quote_subst='$sed_quote_subst'
5263    
5264     # The HP-UX ksh and POSIX shell print the target directory to stdout
5265     # if CDPATH is set.
5266     (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5267    
5268     relink_command=\"$relink_command\"
5269    
5270     # This environment variable determines our operation mode.
5271     if test \"\$libtool_install_magic\" = \"$magic\"; then
5272     # install mode needs the following variable:
5273     notinst_deplibs='$notinst_deplibs'
5274     else
5275     # When we are sourced in execute mode, \$file and \$echo are already set.
5276     if test \"\$libtool_execute_magic\" != \"$magic\"; then
5277     echo=\"$qecho\"
5278     file=\"\$0\"
5279     # Make sure echo works.
5280     if test \"X\$1\" = X--no-reexec; then
5281     # Discard the --no-reexec flag, and continue.
5282     shift
5283     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5284     # Yippee, \$echo works!
5285     :
5286     else
5287     # Restart under the correct shell, and then maybe \$echo will work.
5288     exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5289     fi
5290     fi\
5291     "
5292     $echo >> $output "\
5293    
5294     # Find the directory that this script lives in.
5295     thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5296     test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5297    
5298     # Follow symbolic links until we get to the real thisdir.
5299     file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5300     while test -n \"\$file\"; do
5301     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5302    
5303     # If there was a directory component, then change thisdir.
5304     if test \"x\$destdir\" != \"x\$file\"; then
5305     case \"\$destdir\" in
5306     [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5307     *) thisdir=\"\$thisdir/\$destdir\" ;;
5308     esac
5309     fi
5310    
5311     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5312     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5313     done
5314    
5315     # Try to get the absolute directory name.
5316     absdir=\`cd \"\$thisdir\" && pwd\`
5317     test -n \"\$absdir\" && thisdir=\"\$absdir\"
5318     "
5319    
5320     if test "$fast_install" = yes; then
5321     $echo >> $output "\
5322     program=lt-'$outputname'$exeext
5323     progdir=\"\$thisdir/$objdir\"
5324    
5325     if test ! -f \"\$progdir/\$program\" || \\
5326     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5327     test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5328    
5329     file=\"\$\$-\$program\"
5330    
5331     if test ! -d \"\$progdir\"; then
5332     $mkdir \"\$progdir\"
5333     else
5334     $rm \"\$progdir/\$file\"
5335     fi"
5336    
5337     $echo >> $output "\
5338    
5339     # relink executable if necessary
5340     if test -n \"\$relink_command\"; then
5341     if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5342     else
5343     $echo \"\$relink_command_output\" >&2
5344     $rm \"\$progdir/\$file\"
5345     exit $EXIT_FAILURE
5346     fi
5347     fi
5348    
5349     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5350     { $rm \"\$progdir/\$program\";
5351     $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5352     $rm \"\$progdir/\$file\"
5353     fi"
5354     else
5355     $echo >> $output "\
5356     program='$outputname'
5357     progdir=\"\$thisdir/$objdir\"
5358     "
5359     fi
5360    
5361     $echo >> $output "\
5362    
5363     if test -f \"\$progdir/\$program\"; then"
5364    
5365     # Export our shlibpath_var if we have one.
5366     if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5367     $echo >> $output "\
5368     # Add our own library path to $shlibpath_var
5369     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5370    
5371     # Some systems cannot cope with colon-terminated $shlibpath_var
5372     # The second colon is a workaround for a bug in BeOS R4 sed
5373     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5374    
5375     export $shlibpath_var
5376     "
5377     fi
5378    
5379     # fixup the dll searchpath if we need to.
5380     if test -n "$dllsearchpath"; then
5381     $echo >> $output "\
5382     # Add the dll search path components to the executable PATH
5383     PATH=$dllsearchpath:\$PATH
5384     "
5385     fi
5386    
5387     $echo >> $output "\
5388     if test \"\$libtool_execute_magic\" != \"$magic\"; then
5389     # Run the actual program with our arguments.
5390     "
5391     case $host in
5392     # Backslashes separate directories on plain windows
5393     *-*-mingw | *-*-os2*)
5394     $echo >> $output "\
5395     exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5396     "
5397     ;;
5398    
5399     *)
5400     $echo >> $output "\
5401     exec \"\$progdir/\$program\" \${1+\"\$@\"}
5402     "
5403     ;;
5404     esac
5405     $echo >> $output "\
5406     \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
5407     exit $EXIT_FAILURE
5408     fi
5409     else
5410     # The program doesn't exist.
5411     \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5412     \$echo \"This script is just a wrapper for \$program.\" 1>&2
5413     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5414     exit $EXIT_FAILURE
5415     fi
5416     fi\
5417     "
5418     chmod +x $output
5419     fi
5420     exit $EXIT_SUCCESS
5421     ;;
5422     esac
5423    
5424     # See if we need to build an old-fashioned archive.
5425     for oldlib in $oldlibs; do
5426    
5427     if test "$build_libtool_libs" = convenience; then
5428     oldobjs="$libobjs_save"
5429     addlibs="$convenience"
5430     build_libtool_libs=no
5431     else
5432     if test "$build_libtool_libs" = module; then
5433     oldobjs="$libobjs_save"
5434     build_libtool_libs=no
5435     else
5436     oldobjs="$old_deplibs $non_pic_objects"
5437     fi
5438     addlibs="$old_convenience"
5439     fi
5440    
5441     if test -n "$addlibs"; then
5442     gentop="$output_objdir/${outputname}x"
5443     generated="$generated $gentop"
5444    
5445     func_extract_archives $gentop $addlibs
5446     oldobjs="$oldobjs $func_extract_archives_result"
5447     fi
5448    
5449     # Do each command in the archive commands.
5450     if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5451     cmds=$old_archive_from_new_cmds
5452     else
5453     # POSIX demands no paths to be encoded in archives. We have
5454     # to avoid creating archives with duplicate basenames if we
5455     # might have to extract them afterwards, e.g., when creating a
5456     # static archive out of a convenience library, or when linking
5457     # the entirety of a libtool archive into another (currently
5458     # not supported by libtool).
5459     if (for obj in $oldobjs
5460     do
5461     $echo "X$obj" | $Xsed -e 's%^.*/%%'
5462     done | sort | sort -uc >/dev/null 2>&1); then
5463     :
5464     else
5465     $echo "copying selected object files to avoid basename conflicts..."
5466    
5467     if test -z "$gentop"; then
5468     gentop="$output_objdir/${outputname}x"
5469     generated="$generated $gentop"
5470    
5471     $show "${rm}r $gentop"
5472     $run ${rm}r "$gentop"
5473     $show "$mkdir $gentop"
5474     $run $mkdir "$gentop"
5475     exit_status=$?
5476     if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5477     exit $exit_status
5478     fi
5479     fi
5480    
5481     save_oldobjs=$oldobjs
5482     oldobjs=
5483     counter=1
5484     for obj in $save_oldobjs
5485     do
5486     objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
5487     case " $oldobjs " in
5488     " ") oldobjs=$obj ;;
5489     *[\ /]"$objbase "*)
5490     while :; do
5491     # Make sure we don't pick an alternate name that also
5492     # overlaps.
5493     newobj=lt$counter-$objbase
5494     counter=`expr $counter + 1`
5495     case " $oldobjs " in
5496     *[\ /]"$newobj "*) ;;
5497     *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5498     esac
5499     done
5500     $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5501     $run ln "$obj" "$gentop/$newobj" ||
5502     $run cp "$obj" "$gentop/$newobj"
5503     oldobjs="$oldobjs $gentop/$newobj"
5504     ;;
5505     *) oldobjs="$oldobjs $obj" ;;
5506     esac
5507     done
5508     fi
5509    
5510     eval cmds=\"$old_archive_cmds\"
5511    
5512     if len=`expr "X$cmds" : ".*"` &&
5513     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5514     cmds=$old_archive_cmds
5515     else
5516     # the command line is too long to link in one step, link in parts
5517     $echo "using piecewise archive linking..."
5518     save_RANLIB=$RANLIB
5519     RANLIB=:
5520     objlist=
5521     concat_cmds=
5522     save_oldobjs=$oldobjs
5523    
5524     # Is there a better way of finding the last object in the list?
5525     for obj in $save_oldobjs
5526     do
5527     last_oldobj=$obj
5528     done
5529     for obj in $save_oldobjs
5530     do
5531     oldobjs="$objlist $obj"
5532     objlist="$objlist $obj"
5533     eval test_cmds=\"$old_archive_cmds\"
5534     if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5535     test "$len" -le "$max_cmd_len"; then
5536     :
5537     else
5538     # the above command should be used before it gets too long
5539     oldobjs=$objlist
5540     if test "$obj" = "$last_oldobj" ; then
5541     RANLIB=$save_RANLIB
5542     fi
5543     test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5544     eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5545     objlist=
5546     fi
5547     done
5548     RANLIB=$save_RANLIB
5549     oldobjs=$objlist
5550     if test "X$oldobjs" = "X" ; then
5551     eval cmds=\"\$concat_cmds\"
5552     else
5553     eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5554     fi
5555     fi
5556     fi
5557     save_ifs="$IFS"; IFS='~'
5558     for cmd in $cmds; do
5559     eval cmd=\"$cmd\"
5560     IFS="$save_ifs"
5561     $show "$cmd"
5562     $run eval "$cmd" || exit $?
5563     done
5564     IFS="$save_ifs"
5565     done
5566    
5567     if test -n "$generated"; then
5568     $show "${rm}r$generated"
5569     $run ${rm}r$generated
5570     fi
5571    
5572     # Now create the libtool archive.
5573     case $output in
5574     *.la)
5575     old_library=
5576     test "$build_old_libs" = yes && old_library="$libname.$libext"
5577     $show "creating $output"
5578    
5579     # Preserve any variables that may affect compiler behavior
5580     for var in $variables_saved_for_relink; do
5581     if eval test -z \"\${$var+set}\"; then
5582     relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5583     elif eval var_value=\$$var; test -z "$var_value"; then
5584     relink_command="$var=; export $var; $relink_command"
5585     else
5586     var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5587     relink_command="$var=\"$var_value\"; export $var; $relink_command"
5588     fi
5589     done
5590     # Quote the link command for shipping.
5591     relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5592     relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5593     if test "$hardcode_automatic" = yes ; then
5594     relink_command=
5595     fi
5596    
5597    
5598     # Only create the output if not a dry run.
5599     if test -z "$run"; then
5600     for installed in no yes; do
5601     if test "$installed" = yes; then
5602     if test -z "$install_libdir"; then
5603     break
5604     fi
5605     output="$output_objdir/$outputname"i
5606     # Replace all uninstalled libtool libraries with the installed ones
5607     newdependency_libs=
5608     for deplib in $dependency_libs; do
5609     case $deplib in
5610     *.la)
5611     name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5612     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5613     if test -z "$libdir"; then
5614     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5615     exit $EXIT_FAILURE
5616     fi
5617     newdependency_libs="$newdependency_libs $libdir/$name"
5618     ;;
5619     *) newdependency_libs="$newdependency_libs $deplib" ;;
5620     esac
5621     done
5622     dependency_libs="$newdependency_libs"
5623     newdlfiles=
5624     for lib in $dlfiles; do
5625     name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5626     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5627     if test -z "$libdir"; then
5628     $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5629     exit $EXIT_FAILURE
5630     fi
5631     newdlfiles="$newdlfiles $libdir/$name"
5632     done
5633     dlfiles="$newdlfiles"
5634     newdlprefiles=
5635     for lib in $dlprefiles; do
5636     name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5637     eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5638     if test -z "$libdir"; then
5639     $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5640     exit $EXIT_FAILURE
5641     fi
5642     newdlprefiles="$newdlprefiles $libdir/$name"
5643     done
5644     dlprefiles="$newdlprefiles"
5645     else
5646     newdlfiles=
5647     for lib in $dlfiles; do
5648     case $lib in
5649     [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5650     *) abs=`pwd`"/$lib" ;;
5651     esac
5652     newdlfiles="$newdlfiles $abs"
5653     done
5654     dlfiles="$newdlfiles"
5655     newdlprefiles=
5656     for lib in $dlprefiles; do
5657     case $lib in
5658     [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5659     *) abs=`pwd`"/$lib" ;;
5660     esac
5661     newdlprefiles="$newdlprefiles $abs"
5662     done
5663     dlprefiles="$newdlprefiles"
5664     fi
5665     $rm $output
5666     # place dlname in correct position for cygwin
5667     tdlname=$dlname
5668     case $host,$output,$installed,$module,$dlname in
5669     *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5670     esac
5671     $echo > $output "\
5672     # $outputname - a libtool library file
5673     # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5674     #
5675     # Please DO NOT delete this file!
5676     # It is necessary for linking the library.
5677    
5678     # The name that we can dlopen(3).
5679     dlname='$tdlname'
5680    
5681     # Names of this library.
5682     library_names='$library_names'
5683    
5684     # The name of the static archive.
5685     old_library='$old_library'
5686    
5687     # Libraries that this one depends upon.
5688     dependency_libs='$dependency_libs'
5689    
5690     # Version information for $libname.
5691     current=$current
5692     age=$age
5693     revision=$revision
5694    
5695     # Is this an already installed library?
5696     installed=$installed
5697    
5698     # Should we warn about portability when linking against -modules?
5699     shouldnotlink=$module
5700    
5701     # Files to dlopen/dlpreopen
5702     dlopen='$dlfiles'
5703     dlpreopen='$dlprefiles'
5704    
5705     # Directory that this library needs to be installed in:
5706     libdir='$install_libdir'"
5707     if test "$installed" = no && test "$need_relink" = yes; then
5708     $echo >> $output "\
5709     relink_command=\"$relink_command\""
5710     fi
5711     done
5712     fi
5713    
5714     # Do a symbolic link so that the libtool archive can be found in
5715     # LD_LIBRARY_PATH before the program is installed.
5716     $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5717     $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5718     ;;
5719     esac
5720     exit $EXIT_SUCCESS
5721     ;;
5722    
5723     # libtool install mode
5724     install)
5725     modename="$modename: install"
5726    
5727     # There may be an optional sh(1) argument at the beginning of
5728     # install_prog (especially on Windows NT).
5729     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5730     # Allow the use of GNU shtool's install command.
5731     $echo "X$nonopt" | grep shtool > /dev/null; then
5732     # Aesthetically quote it.
5733     arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5734     case $arg in
5735     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5736     arg="\"$arg\""
5737     ;;
5738     esac
5739     install_prog="$arg "
5740     arg="$1"
5741     shift
5742     else
5743     install_prog=
5744     arg=$nonopt
5745     fi
5746    
5747     # The real first argument should be the name of the installation program.
5748     # Aesthetically quote it.
5749     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5750     case $arg in
5751     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5752     arg="\"$arg\""
5753     ;;
5754     esac
5755     install_prog="$install_prog$arg"
5756    
5757     # We need to accept at least all the BSD install flags.
5758     dest=
5759     files=
5760     opts=
5761     prev=
5762     install_type=
5763     isdir=no
5764     stripme=
5765     for arg
5766     do
5767     if test -n "$dest"; then
5768     files="$files $dest"
5769     dest=$arg
5770     continue
5771     fi
5772    
5773     case $arg in
5774     -d) isdir=yes ;;
5775     -f)
5776     case " $install_prog " in
5777     *[\\\ /]cp\ *) ;;
5778     *) prev=$arg ;;
5779     esac
5780     ;;
5781     -g | -m | -o) prev=$arg ;;
5782     -s)
5783     stripme=" -s"
5784     continue
5785     ;;
5786     -*)
5787     ;;
5788     *)
5789     # If the previous option needed an argument, then skip it.
5790     if test -n "$prev"; then
5791     prev=
5792     else
5793     dest=$arg
5794     continue
5795     fi
5796     ;;
5797     esac
5798    
5799     # Aesthetically quote the argument.
5800     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5801     case $arg in
5802     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
5803     arg="\"$arg\""
5804     ;;
5805     esac
5806     install_prog="$install_prog $arg"
5807     done
5808    
5809     if test -z "$install_prog"; then
5810     $echo "$modename: you must specify an install program" 1>&2
5811     $echo "$help" 1>&2
5812     exit $EXIT_FAILURE
5813     fi
5814    
5815     if test -n "$prev"; then
5816     $echo "$modename: the \`$prev' option requires an argument" 1>&2
5817     $echo "$help" 1>&2
5818     exit $EXIT_FAILURE
5819     fi
5820    
5821     if test -z "$files"; then
5822     if test -z "$dest"; then
5823     $echo "$modename: no file or destination specified" 1>&2
5824     else
5825     $echo "$modename: you must specify a destination" 1>&2
5826     fi
5827     $echo "$help" 1>&2
5828     exit $EXIT_FAILURE
5829     fi
5830    
5831     # Strip any trailing slash from the destination.
5832     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5833    
5834     # Check to see that the destination is a directory.
5835     test -d "$dest" && isdir=yes
5836     if test "$isdir" = yes; then
5837     destdir="$dest"
5838     destname=
5839     else
5840     destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5841     test "X$destdir" = "X$dest" && destdir=.
5842     destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5843    
5844     # Not a directory, so check to see that there is only one file specified.
5845     set dummy $files
5846     if test "$#" -gt 2; then
5847     $echo "$modename: \`$dest' is not a directory" 1>&2
5848     $echo "$help" 1>&2
5849     exit $EXIT_FAILURE
5850     fi
5851     fi
5852     case $destdir in
5853     [\\/]* | [A-Za-z]:[\\/]*) ;;
5854     *)
5855     for file in $files; do
5856     case $file in
5857     *.lo) ;;
5858     *)
5859     $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5860     $echo "$help" 1>&2
5861     exit $EXIT_FAILURE
5862     ;;
5863     esac
5864     done
5865     ;;
5866     esac
5867    
5868     # This variable tells wrapper scripts just to set variables rather
5869     # than running their programs.
5870     libtool_install_magic="$magic"
5871    
5872     staticlibs=
5873     future_libdirs=
5874     current_libdirs=
5875     for file in $files; do
5876    
5877     # Do each installation.
5878     case $file in
5879     *.$libext)
5880     # Do the static libraries later.
5881     staticlibs="$staticlibs $file"
5882     ;;
5883    
5884     *.la)
5885     # Check to see that this really is a libtool archive.
5886     if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5887     else
5888     $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5889     $echo "$help" 1>&2
5890     exit $EXIT_FAILURE
5891     fi
5892    
5893     library_names=
5894     old_library=
5895     relink_command=
5896     # If there is no directory component, then add one.
5897     case $file in
5898     */* | *\\*) . $file ;;
5899     *) . ./$file ;;
5900     esac
5901    
5902     # Add the libdir to current_libdirs if it is the destination.
5903     if test "X$destdir" = "X$libdir"; then
5904     case "$current_libdirs " in
5905     *" $libdir "*) ;;
5906     *) current_libdirs="$current_libdirs $libdir" ;;
5907     esac
5908     else
5909     # Note the libdir as a future libdir.
5910     case "$future_libdirs " in
5911     *" $libdir "*) ;;
5912     *) future_libdirs="$future_libdirs $libdir" ;;
5913     esac
5914     fi
5915    
5916     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5917     test "X$dir" = "X$file/" && dir=
5918     dir="$dir$objdir"
5919    
5920     if test -n "$relink_command"; then
5921     # Determine the prefix the user has applied to our future dir.
5922     inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5923    
5924     # Don't allow the user to place us outside of our expected
5925     # location b/c this prevents finding dependent libraries that
5926     # are installed to the same prefix.
5927     # At present, this check doesn't affect windows .dll's that
5928     # are installed into $libdir/../bin (currently, that works fine)
5929     # but it's something to keep an eye on.
5930     if test "$inst_prefix_dir" = "$destdir"; then
5931     $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5932     exit $EXIT_FAILURE
5933     fi
5934    
5935     if test -n "$inst_prefix_dir"; then
5936     # Stick the inst_prefix_dir data into the link command.
5937     relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5938     else
5939     relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5940     fi
5941    
5942     $echo "$modename: warning: relinking \`$file'" 1>&2
5943     $show "$relink_command"
5944     if $run eval "$relink_command"; then :
5945     else
5946     $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5947     exit $EXIT_FAILURE
5948     fi
5949     fi
5950    
5951     # See the names of the shared library.
5952     set dummy $library_names
5953     if test -n "$2"; then
5954     realname="$2"
5955     shift
5956     shift
5957    
5958     srcname="$realname"
5959     test -n "$relink_command" && srcname="$realname"T
5960    
5961     # Install the shared library and build the symlinks.
5962     $show "$install_prog $dir/$srcname $destdir/$realname"
5963     $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5964     if test -n "$stripme" && test -n "$striplib"; then
5965     $show "$striplib $destdir/$realname"
5966     $run eval "$striplib $destdir/$realname" || exit $?
5967     fi
5968    
5969     if test "$#" -gt 0; then
5970     # Delete the old symlinks, and create new ones.
5971     # Try `ln -sf' first, because the `ln' binary might depend on
5972     # the symlink we replace! Solaris /bin/ln does not understand -f,
5973     # so we also need to try rm && ln -s.
5974     for linkname
5975     do
5976     if test "$linkname" != "$realname"; then
5977     $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5978     $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5979     fi
5980     done
5981     fi
5982    
5983     # Do each command in the postinstall commands.
5984     lib="$destdir/$realname"
5985     cmds=$postinstall_cmds
5986     save_ifs="$IFS"; IFS='~'
5987     for cmd in $cmds; do
5988     IFS="$save_ifs"
5989     eval cmd=\"$cmd\"
5990     $show "$cmd"
5991     $run eval "$cmd" || {
5992     lt_exit=$?
5993    
5994     # Restore the uninstalled library and exit
5995     if test "$mode" = relink; then
5996     $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
5997     fi
5998    
5999     exit $lt_exit
6000     }
6001     done
6002     IFS="$save_ifs"
6003     fi
6004    
6005     # Install the pseudo-library for information purposes.
6006     name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6007     instname="$dir/$name"i
6008     $show "$install_prog $instname $destdir/$name"
6009     $run eval "$install_prog $instname $destdir/$name" || exit $?
6010    
6011     # Maybe install the static library, too.
6012     test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6013     ;;
6014    
6015     *.lo)
6016     # Install (i.e. copy) a libtool object.
6017    
6018     # Figure out destination file name, if it wasn't already specified.
6019     if test -n "$destname"; then
6020     destfile="$destdir/$destname"
6021     else
6022     destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6023     destfile="$destdir/$destfile"
6024     fi
6025    
6026     # Deduce the name of the destination old-style object file.
6027     case $destfile in
6028     *.lo)
6029     staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6030     ;;
6031     *.$objext)
6032     staticdest="$destfile"
6033     destfile=
6034     ;;
6035     *)
6036     $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6037     $echo "$help" 1>&2
6038     exit $EXIT_FAILURE
6039     ;;
6040     esac
6041    
6042     # Install the libtool object if requested.
6043     if test -n "$destfile"; then
6044     $show "$install_prog $file $destfile"
6045     $run eval "$install_prog $file $destfile" || exit $?
6046     fi
6047    
6048     # Install the old object if enabled.
6049     if test "$build_old_libs" = yes; then
6050     # Deduce the name of the old-style object file.
6051     staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6052    
6053     $show "$install_prog $staticobj $staticdest"
6054     $run eval "$install_prog \$staticobj \$staticdest" || exit $?
6055     fi
6056     exit $EXIT_SUCCESS
6057     ;;
6058    
6059     *)
6060     # Figure out destination file name, if it wasn't already specified.
6061     if test -n "$destname"; then
6062     destfile="$destdir/$destname"
6063     else
6064     destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6065     destfile="$destdir/$destfile"
6066     fi
6067    
6068     # If the file is missing, and there is a .exe on the end, strip it
6069     # because it is most likely a libtool script we actually want to
6070     # install
6071     stripped_ext=""
6072     case $file in
6073     *.exe)
6074     if test ! -f "$file"; then
6075     file=`$echo $file|${SED} 's,.exe$,,'`
6076     stripped_ext=".exe"
6077     fi
6078     ;;
6079     esac
6080    
6081     # Do a test to see if this is really a libtool program.
6082     case $host in
6083     *cygwin*|*mingw*)
6084     wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6085     ;;
6086     *)
6087     wrapper=$file
6088     ;;
6089     esac
6090     if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6091     notinst_deplibs=
6092     relink_command=
6093    
6094     # Note that it is not necessary on cygwin/mingw to append a dot to
6095     # foo even if both foo and FILE.exe exist: automatic-append-.exe
6096     # behavior happens only for exec(3), not for open(2)! Also, sourcing
6097     # `FILE.' does not work on cygwin managed mounts.
6098     #
6099     # If there is no directory component, then add one.
6100     case $wrapper in
6101     */* | *\\*) . ${wrapper} ;;
6102     *) . ./${wrapper} ;;
6103     esac
6104    
6105     # Check the variables that should have been set.
6106     if test -z "$notinst_deplibs"; then
6107     $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6108     exit $EXIT_FAILURE
6109     fi
6110    
6111     finalize=yes
6112     for lib in $notinst_deplibs; do
6113     # Check to see that each library is installed.
6114     libdir=
6115     if test -f "$lib"; then
6116     # If there is no directory component, then add one.
6117     case $lib in
6118     */* | *\\*) . $lib ;;
6119     *) . ./$lib ;;
6120     esac
6121     fi
6122     libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6123     if test -n "$libdir" && test ! -f "$libfile"; then
6124     $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6125     finalize=no
6126     fi
6127     done
6128    
6129     relink_command=
6130     # Note that it is not necessary on cygwin/mingw to append a dot to
6131     # foo even if both foo and FILE.exe exist: automatic-append-.exe
6132     # behavior happens only for exec(3), not for open(2)! Also, sourcing
6133     # `FILE.' does not work on cygwin managed mounts.
6134     #
6135     # If there is no directory component, then add one.
6136     case $wrapper in
6137     */* | *\\*) . ${wrapper} ;;
6138     *) . ./${wrapper} ;;
6139     esac
6140    
6141     outputname=
6142     if test "$fast_install" = no && test -n "$relink_command"; then
6143     if test "$finalize" = yes && test -z "$run"; then
6144     tmpdir=`func_mktempdir`
6145     file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6146     outputname="$tmpdir/$file"
6147     # Replace the output file specification.
6148     relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
6149    
6150     $show "$relink_command"
6151     if $run eval "$relink_command"; then :
6152     else
6153     $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6154     ${rm}r "$tmpdir"
6155     continue
6156     fi
6157     file="$outputname"
6158     else
6159     $echo "$modename: warning: cannot relink \`$file'" 1>&2
6160     fi
6161     else
6162     # Install the binary that we compiled earlier.
6163     file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6164     fi
6165     fi
6166    
6167     # remove .exe since cygwin /usr/bin/install will append another
6168     # one anyway
6169     case $install_prog,$host in
6170     */usr/bin/install*,*cygwin*)
6171     case $file:$destfile in
6172     *.exe:*.exe)
6173     # this is ok
6174     ;;
6175     *.exe:*)
6176     destfile=$destfile.exe
6177     ;;
6178     *:*.exe)
6179     destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6180     ;;
6181     esac
6182     ;;
6183     esac
6184     $show "$install_prog$stripme $file $destfile"
6185     $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6186     test -n "$outputname" && ${rm}r "$tmpdir"
6187     ;;
6188     esac
6189     done
6190    
6191     for file in $staticlibs; do
6192     name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6193    
6194     # Set up the ranlib parameters.
6195     oldlib="$destdir/$name"
6196    
6197     $show "$install_prog $file $oldlib"
6198     $run eval "$install_prog \$file \$oldlib" || exit $?
6199    
6200     if test -n "$stripme" && test -n "$old_striplib"; then
6201     $show "$old_striplib $oldlib"
6202     $run eval "$old_striplib $oldlib" || exit $?
6203     fi
6204    
6205     # Do each command in the postinstall commands.
6206     cmds=$old_postinstall_cmds
6207     save_ifs="$IFS"; IFS='~'
6208     for cmd in $cmds; do
6209     IFS="$save_ifs"
6210     eval cmd=\"$cmd\"
6211     $show "$cmd"
6212     $run eval "$cmd" || exit $?
6213     done
6214     IFS="$save_ifs"
6215     done
6216    
6217     if test -n "$future_libdirs"; then
6218     $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6219     fi
6220    
6221     if test -n "$current_libdirs"; then
6222     # Maybe just do a dry run.
6223     test -n "$run" && current_libdirs=" -n$current_libdirs"
6224     exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6225     else
6226     exit $EXIT_SUCCESS
6227     fi
6228     ;;
6229    
6230     # libtool finish mode
6231     finish)
6232     modename="$modename: finish"
6233     libdirs="$nonopt"
6234     admincmds=
6235    
6236     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6237     for dir
6238     do
6239     libdirs="$libdirs $dir"
6240     done
6241    
6242     for libdir in $libdirs; do
6243     if test -n "$finish_cmds"; then
6244     # Do each command in the finish commands.
6245     cmds=$finish_cmds
6246     save_ifs="$IFS"; IFS='~'
6247     for cmd in $cmds; do
6248     IFS="$save_ifs"
6249     eval cmd=\"$cmd\"
6250     $show "$cmd"
6251     $run eval "$cmd" || admincmds="$admincmds
6252     $cmd"
6253     done
6254     IFS="$save_ifs"
6255     fi
6256     if test -n "$finish_eval"; then
6257     # Do the single finish_eval.
6258     eval cmds=\"$finish_eval\"
6259     $run eval "$cmds" || admincmds="$admincmds
6260     $cmds"
6261     fi
6262     done
6263     fi
6264    
6265     # Exit here if they wanted silent mode.
6266     test "$show" = : && exit $EXIT_SUCCESS
6267    
6268     $echo "X----------------------------------------------------------------------" | $Xsed
6269     $echo "Libraries have been installed in:"
6270     for libdir in $libdirs; do
6271     $echo " $libdir"
6272     done
6273     $echo
6274     $echo "If you ever happen to want to link against installed libraries"
6275     $echo "in a given directory, LIBDIR, you must either use libtool, and"
6276     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6277     $echo "flag during linking and do at least one of the following:"
6278     if test -n "$shlibpath_var"; then
6279     $echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
6280     $echo " during execution"
6281     fi
6282     if test -n "$runpath_var"; then
6283     $echo " - add LIBDIR to the \`$runpath_var' environment variable"
6284     $echo " during linking"
6285     fi
6286     if test -n "$hardcode_libdir_flag_spec"; then
6287     libdir=LIBDIR
6288     eval flag=\"$hardcode_libdir_flag_spec\"
6289    
6290     $echo " - use the \`$flag' linker flag"
6291     fi
6292     if test -n "$admincmds"; then
6293     $echo " - have your system administrator run these commands:$admincmds"
6294     fi
6295     if test -f /etc/ld.so.conf; then
6296     $echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6297     fi
6298     $echo
6299     $echo "See any operating system documentation about shared libraries for"
6300     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
6301     $echo "X----------------------------------------------------------------------" | $Xsed
6302     exit $EXIT_SUCCESS
6303     ;;
6304    
6305     # libtool execute mode
6306     execute)
6307     modename="$modename: execute"
6308    
6309     # The first argument is the command name.
6310     cmd="$nonopt"
6311     if test -z "$cmd"; then
6312     $echo "$modename: you must specify a COMMAND" 1>&2
6313     $echo "$help"
6314     exit $EXIT_FAILURE
6315     fi
6316    
6317     # Handle -dlopen flags immediately.
6318     for file in $execute_dlfiles; do
6319     if test ! -f "$file"; then
6320     $echo "$modename: \`$file' is not a file" 1>&2
6321     $echo "$help" 1>&2
6322     exit $EXIT_FAILURE
6323     fi
6324    
6325     dir=
6326     case $file in
6327     *.la)
6328     # Check to see that this really is a libtool archive.
6329     if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6330     else
6331     $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6332     $echo "$help" 1>&2
6333     exit $EXIT_FAILURE
6334     fi
6335    
6336     # Read the libtool library.
6337     dlname=
6338     library_names=
6339    
6340     # If there is no directory component, then add one.
6341     case $file in
6342     */* | *\\*) . $file ;;
6343     *) . ./$file ;;
6344     esac
6345    
6346     # Skip this library if it cannot be dlopened.
6347     if test -z "$dlname"; then
6348     # Warn if it was a shared library.
6349     test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6350     continue
6351     fi
6352    
6353     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6354     test "X$dir" = "X$file" && dir=.
6355    
6356     if test -f "$dir/$objdir/$dlname"; then
6357     dir="$dir/$objdir"
6358     else
6359     $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6360     exit $EXIT_FAILURE
6361     fi
6362     ;;
6363    
6364     *.lo)
6365     # Just add the directory containing the .lo file.
6366     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6367     test "X$dir" = "X$file" && dir=.
6368     ;;
6369    
6370     *)
6371     $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6372     continue
6373     ;;
6374     esac
6375    
6376     # Get the absolute pathname.
6377     absdir=`cd "$dir" && pwd`
6378     test -n "$absdir" && dir="$absdir"
6379    
6380     # Now add the directory to shlibpath_var.
6381     if eval "test -z \"\$$shlibpath_var\""; then
6382     eval "$shlibpath_var=\"\$dir\""
6383     else
6384     eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6385     fi
6386     done
6387    
6388     # This variable tells wrapper scripts just to set shlibpath_var
6389     # rather than running their programs.
6390     libtool_execute_magic="$magic"
6391    
6392     # Check if any of the arguments is a wrapper script.
6393     args=
6394     for file
6395     do
6396     case $file in
6397     -*) ;;
6398     *)
6399     # Do a test to see if this is really a libtool program.
6400     if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6401     # If there is no directory component, then add one.
6402     case $file in
6403     */* | *\\*) . $file ;;
6404     *) . ./$file ;;
6405     esac
6406    
6407     # Transform arg to wrapped name.
6408     file="$progdir/$program"
6409     fi
6410     ;;
6411     esac
6412     # Quote arguments (to preserve shell metacharacters).
6413     file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6414     args="$args \"$file\""
6415     done
6416    
6417     if test -z "$run"; then
6418     if test -n "$shlibpath_var"; then
6419     # Export the shlibpath_var.
6420     eval "export $shlibpath_var"
6421     fi
6422    
6423     # Restore saved environment variables
6424     if test "${save_LC_ALL+set}" = set; then
6425     LC_ALL="$save_LC_ALL"; export LC_ALL
6426     fi
6427     if test "${save_LANG+set}" = set; then
6428     LANG="$save_LANG"; export LANG
6429     fi
6430    
6431     # Now prepare to actually exec the command.
6432     exec_cmd="\$cmd$args"
6433     else
6434     # Display what would be done.
6435     if test -n "$shlibpath_var"; then
6436     eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6437     $echo "export $shlibpath_var"
6438     fi
6439     $echo "$cmd$args"
6440     exit $EXIT_SUCCESS
6441     fi
6442     ;;
6443    
6444     # libtool clean and uninstall mode
6445     clean | uninstall)
6446     modename="$modename: $mode"
6447     rm="$nonopt"
6448     files=
6449     rmforce=
6450     exit_status=0
6451    
6452     # This variable tells wrapper scripts just to set variables rather
6453     # than running their programs.
6454     libtool_install_magic="$magic"
6455    
6456     for arg
6457     do
6458     case $arg in
6459     -f) rm="$rm $arg"; rmforce=yes ;;
6460     -*) rm="$rm $arg" ;;
6461     *) files="$files $arg" ;;
6462     esac
6463     done
6464    
6465     if test -z "$rm"; then
6466     $echo "$modename: you must specify an RM program" 1>&2
6467     $echo "$help" 1>&2
6468     exit $EXIT_FAILURE
6469     fi
6470    
6471     rmdirs=
6472    
6473     origobjdir="$objdir"
6474     for file in $files; do
6475     dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6476     if test "X$dir" = "X$file"; then
6477     dir=.
6478     objdir="$origobjdir"
6479     else
6480     objdir="$dir/$origobjdir"
6481     fi
6482     name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6483     test "$mode" = uninstall && objdir="$dir"
6484    
6485     # Remember objdir for removal later, being careful to avoid duplicates
6486     if test "$mode" = clean; then
6487     case " $rmdirs " in
6488     *" $objdir "*) ;;
6489     *) rmdirs="$rmdirs $objdir" ;;
6490     esac
6491     fi
6492    
6493     # Don't error if the file doesn't exist and rm -f was used.
6494     if (test -L "$file") >/dev/null 2>&1 \
6495     || (test -h "$file") >/dev/null 2>&1 \
6496     || test -f "$file"; then
6497     :
6498     elif test -d "$file"; then
6499     exit_status=1
6500     continue
6501     elif test "$rmforce" = yes; then
6502     continue
6503     fi
6504    
6505     rmfiles="$file"
6506    
6507     case $name in
6508     *.la)
6509     # Possibly a libtool archive, so verify it.
6510     if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6511     . $dir/$name
6512    
6513     # Delete the libtool libraries and symlinks.
6514     for n in $library_names; do
6515     rmfiles="$rmfiles $objdir/$n"
6516     done
6517     test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6518    
6519     case "$mode" in
6520     clean)
6521     case " $library_names " in
6522     # " " in the beginning catches empty $dlname
6523     *" $dlname "*) ;;
6524     *) rmfiles="$rmfiles $objdir/$dlname" ;;
6525     esac
6526     test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
6527     ;;
6528     uninstall)
6529     if test -n "$library_names"; then
6530     # Do each command in the postuninstall commands.
6531     cmds=$postuninstall_cmds
6532     save_ifs="$IFS"; IFS='~'
6533     for cmd in $cmds; do
6534     IFS="$save_ifs"
6535     eval cmd=\"$cmd\"
6536     $show "$cmd"
6537     $run eval "$cmd"
6538     if test "$?" -ne 0 && test "$rmforce" != yes; then
6539     exit_status=1
6540     fi
6541     done
6542     IFS="$save_ifs"
6543     fi
6544    
6545     if test -n "$old_library"; then
6546     # Do each command in the old_postuninstall commands.
6547     cmds=$old_postuninstall_cmds
6548     save_ifs="$IFS"; IFS='~'
6549     for cmd in $cmds; do
6550     IFS="$save_ifs"
6551     eval cmd=\"$cmd\"
6552     $show "$cmd"
6553     $run eval "$cmd"
6554     if test "$?" -ne 0 && test "$rmforce" != yes; then
6555     exit_status=1
6556     fi
6557     done
6558     IFS="$save_ifs"
6559     fi
6560     # FIXME: should reinstall the best remaining shared library.
6561     ;;
6562     esac
6563     fi
6564     ;;
6565    
6566     *.lo)
6567     # Possibly a libtool object, so verify it.
6568     if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6569    
6570     # Read the .lo file
6571     . $dir/$name
6572    
6573     # Add PIC object to the list of files to remove.
6574     if test -n "$pic_object" \
6575     && test "$pic_object" != none; then
6576     rmfiles="$rmfiles $dir/$pic_object"
6577     fi
6578    
6579     # Add non-PIC object to the list of files to remove.
6580     if test -n "$non_pic_object" \
6581     && test "$non_pic_object" != none; then
6582     rmfiles="$rmfiles $dir/$non_pic_object"
6583     fi
6584     fi
6585     ;;
6586    
6587     *)
6588     if test "$mode" = clean ; then
6589     noexename=$name
6590     case $file in
6591     *.exe)
6592     file=`$echo $file|${SED} 's,.exe$,,'`
6593     noexename=`$echo $name|${SED} 's,.exe$,,'`
6594     # $file with .exe has already been added to rmfiles,
6595     # add $file without .exe
6596     rmfiles="$rmfiles $file"
6597     ;;
6598     esac
6599     # Do a test to see if this is a libtool program.
6600     if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6601     relink_command=
6602     . $dir/$noexename
6603    
6604     # note $name still contains .exe if it was in $file originally
6605     # as does the version of $file that was added into $rmfiles
6606     rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
6607     if test "$fast_install" = yes && test -n "$relink_command"; then
6608     rmfiles="$rmfiles $objdir/lt-$name"
6609     fi
6610     if test "X$noexename" != "X$name" ; then
6611     rmfiles="$rmfiles $objdir/lt-${noexename}.c"
6612     fi
6613     fi
6614     fi
6615     ;;
6616     esac
6617     $show "$rm $rmfiles"
6618     $run $rm $rmfiles || exit_status=1
6619     done
6620     objdir="$origobjdir"
6621    
6622     # Try to remove the ${objdir}s in the directories where we deleted files
6623     for dir in $rmdirs; do
6624     if test -d "$dir"; then
6625     $show "rmdir $dir"
6626     $run rmdir $dir >/dev/null 2>&1
6627     fi
6628     done
6629    
6630     exit $exit_status
6631     ;;
6632    
6633     "")
6634     $echo "$modename: you must specify a MODE" 1>&2
6635     $echo "$generic_help" 1>&2
6636     exit $EXIT_FAILURE
6637     ;;
6638     esac
6639    
6640     if test -z "$exec_cmd"; then
6641     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6642     $echo "$generic_help" 1>&2
6643     exit $EXIT_FAILURE
6644     fi
6645     fi # test -z "$show_help"
6646    
6647     if test -n "$exec_cmd"; then
6648     eval exec $exec_cmd
6649     exit $EXIT_FAILURE
6650     fi
6651    
6652     # We need to display help for each of the modes.
6653     case $mode in
6654     "") $echo \
6655     "Usage: $modename [OPTION]... [MODE-ARG]...
6656    
6657     Provide generalized library-building support services.
6658    
6659     --config show all configuration variables
6660     --debug enable verbose shell tracing
6661     -n, --dry-run display commands without modifying any files
6662     --features display basic configuration information and exit
6663     --finish same as \`--mode=finish'
6664     --help display this help message and exit
6665     --mode=MODE use operation mode MODE [default=inferred from MODE-ARGS]
6666     --quiet same as \`--silent'
6667     --silent don't print informational messages
6668     --tag=TAG use configuration variables from tag TAG
6669     --version print version information
6670    
6671     MODE must be one of the following:
6672    
6673     clean remove files from the build directory
6674     compile compile a source file into a libtool object
6675     execute automatically set library path, then run a program
6676     finish complete the installation of libtool libraries
6677     install install libraries or executables
6678     link create a library or an executable
6679     uninstall remove libraries from an installed directory
6680    
6681     MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for
6682     a more detailed description of MODE.
6683    
6684     Report bugs to <bug-libtool@gnu.org>."
6685     exit $EXIT_SUCCESS
6686     ;;
6687    
6688     clean)
6689     $echo \
6690     "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6691    
6692     Remove files from the build directory.
6693    
6694     RM is the name of the program to use to delete files associated with each FILE
6695     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
6696     to RM.
6697    
6698     If FILE is a libtool library, object or program, all the files associated
6699     with it are deleted. Otherwise, only FILE itself is deleted using RM."
6700     ;;
6701    
6702     compile)
6703     $echo \
6704     "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6705    
6706     Compile a source file into a libtool library object.
6707    
6708     This mode accepts the following additional options:
6709    
6710     -o OUTPUT-FILE set the output file name to OUTPUT-FILE
6711     -prefer-pic try to building PIC objects only
6712     -prefer-non-pic try to building non-PIC objects only
6713     -static always build a \`.o' file suitable for static linking
6714    
6715     COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6716     from the given SOURCEFILE.
6717    
6718     The output file name is determined by removing the directory component from
6719     SOURCEFILE, then substituting the C source code suffix \`.c' with the
6720     library object suffix, \`.lo'."
6721     ;;
6722    
6723     execute)
6724     $echo \
6725     "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6726    
6727     Automatically set library path, then run a program.
6728    
6729     This mode accepts the following additional options:
6730    
6731     -dlopen FILE add the directory containing FILE to the library path
6732    
6733     This mode sets the library path environment variable according to \`-dlopen'
6734     flags.
6735    
6736     If any of the ARGS are libtool executable wrappers, then they are translated
6737     into their corresponding uninstalled binary, and any of their required library
6738     directories are added to the library path.
6739    
6740     Then, COMMAND is executed, with ARGS as arguments."
6741     ;;
6742    
6743     finish)
6744     $echo \
6745     "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6746    
6747     Complete the installation of libtool libraries.
6748    
6749     Each LIBDIR is a directory that contains libtool libraries.
6750    
6751     The commands that this mode executes may require superuser privileges. Use
6752     the \`--dry-run' option if you just want to see what would be executed."
6753     ;;
6754    
6755     install)
6756     $echo \
6757     "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6758    
6759     Install executables or libraries.
6760    
6761     INSTALL-COMMAND is the installation command. The first component should be
6762     either the \`install' or \`cp' program.
6763    
6764     The rest of the components are interpreted as arguments to that command (only
6765     BSD-compatible install options are recognized)."
6766     ;;
6767    
6768     link)
6769     $echo \
6770     "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6771    
6772     Link object files or libraries together to form another library, or to
6773     create an executable program.
6774    
6775     LINK-COMMAND is a command using the C compiler that you would use to create
6776     a program from several object files.
6777    
6778     The following components of LINK-COMMAND are treated specially:
6779    
6780     -all-static do not do any dynamic linking at all
6781     -avoid-version do not add a version suffix if possible
6782     -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
6783     -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
6784     -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6785     -export-symbols SYMFILE
6786     try to export only the symbols listed in SYMFILE
6787     -export-symbols-regex REGEX
6788     try to export only the symbols matching REGEX
6789     -LLIBDIR search LIBDIR for required installed libraries
6790     -lNAME OUTPUT-FILE requires the installed library libNAME
6791     -module build a library that can dlopened
6792     -no-fast-install disable the fast-install mode
6793     -no-install link a not-installable executable
6794     -no-undefined declare that a library does not refer to external symbols
6795     -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
6796     -objectlist FILE Use a list of object files found in FILE to specify objects
6797     -precious-files-regex REGEX
6798     don't remove output files matching REGEX
6799     -release RELEASE specify package release information
6800     -rpath LIBDIR the created library will eventually be installed in LIBDIR
6801     -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
6802     -static do not do any dynamic linking of libtool libraries
6803     -version-info CURRENT[:REVISION[:AGE]]
6804     specify library version info [each variable defaults to 0]
6805    
6806     All other options (arguments beginning with \`-') are ignored.
6807    
6808     Every other argument is treated as a filename. Files ending in \`.la' are
6809     treated as uninstalled libtool libraries, other files are standard or library
6810     object files.
6811    
6812     If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6813     only library objects (\`.lo' files) may be specified, and \`-rpath' is
6814     required, except when creating a convenience library.
6815    
6816     If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6817     using \`ar' and \`ranlib', or on Windows using \`lib'.
6818    
6819     If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6820     is created, otherwise an executable program is created."
6821     ;;
6822    
6823     uninstall)
6824     $echo \
6825     "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6826    
6827     Remove libraries from an installation directory.
6828    
6829     RM is the name of the program to use to delete files associated with each FILE
6830     (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
6831     to RM.
6832    
6833     If FILE is a libtool library, all the files associated with it are deleted.
6834     Otherwise, only FILE itself is deleted using RM."
6835     ;;
6836    
6837     *)
6838     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6839     $echo "$help" 1>&2
6840     exit $EXIT_FAILURE
6841     ;;
6842     esac
6843    
6844     $echo
6845     $echo "Try \`$modename --help' for more information about other modes."
6846    
6847     exit $?
6848    
6849     # The TAGs below are defined such that we never get into a situation
6850     # in which we disable both kinds of libraries. Given conflicting
6851     # choices, we go for a static library, that is the most portable,
6852     # since we can't tell whether shared libraries were disabled because
6853     # the user asked for that or because the platform doesn't support
6854     # them. This is particularly important on AIX, because we don't
6855     # support having both static and shared libraries enabled at the same
6856     # time on that platform, so we default to a shared-only configuration.
6857     # If a disable-shared tag is given, we'll fallback to a static-only
6858     # configuration. But we'll never go from static-only to shared-only.
6859    
6860     # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6861     disable_libs=shared
6862     # ### END LIBTOOL TAG CONFIG: disable-shared
6863    
6864     # ### BEGIN LIBTOOL TAG CONFIG: disable-static
6865     disable_libs=static
6866     # ### END LIBTOOL TAG CONFIG: disable-static
6867    
6868     # Local Variables:
6869     # mode:shell-script
6870     # sh-indentation:2
6871     # End: