/[rtmk]/rtmk/config/ltmain.sh
ViewVC logotype

Diff of /rtmk/config/ltmain.sh

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by jrydberg, Fri Dec 7 02:05:57 2001 UTC revision 1.2 by jrydberg, Sat Jan 5 00:08:30 2002 UTC
# Line 0  Line 1 
1    # 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
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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    # Check that we have a working $echo.
28    if test "X$1" = X--no-reexec; then
29      # Discard the --no-reexec flag, and continue.
30      shift
31    elif test "X$1" = X--fallback-echo; then
32      # Avoid inline document here, it may be left over
33      :
34    elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
35      # Yippee, $echo works!
36      :
37    else
38      # Restart under the correct shell, and then maybe $echo will work.
39      exec $SHELL "$0" --no-reexec ${1+"$@"}
40    fi
41    
42    if test "X$1" = X--fallback-echo; then
43      # used as fallback echo
44      shift
45      cat <<EOF
46    $*
47    EOF
48      exit 0
49    fi
50    
51    # The name of this program.
52    progname=`$echo "$0" | sed 's%^.*/%%'`
53    modename="$progname"
54    
55    # Constants.
56    PROGRAM=ltmain.sh
57    PACKAGE=libtool
58    VERSION=1.4
59    TIMESTAMP=" (1.920 2001/04/24 23:26:18)"
60    
61    default_mode=
62    help="Try \`$progname --help' for more information."
63    magic="%%%MAGIC variable%%%"
64    mkdir="mkdir"
65    mv="mv -f"
66    rm="rm -f"
67    
68    # Sed substitution that helps us do robust quoting.  It backslashifies
69    # metacharacters that are still active within double-quoted strings.
70    Xsed='sed -e 1s/^X//'
71    sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
72    SP2NL='tr \040 \012'
73    NL2SP='tr \015\012 \040\040'
74    
75    # NLS nuisances.
76    # Only set LANG and LC_ALL to C if already set.
77    # These must not be set unconditionally because not all systems understand
78    # e.g. LANG=C (notably SCO).
79    # We save the old values to restore during execute mode.
80    if test "${LC_ALL+set}" = set; then
81      save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
82    fi
83    if test "${LANG+set}" = set; then
84      save_LANG="$LANG"; LANG=C; export LANG
85    fi
86    
87    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
88      echo "$modename: not configured to build any kind of library" 1>&2
89      echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
90      exit 1
91    fi
92    
93    # Global variables.
94    mode=$default_mode
95    nonopt=
96    prev=
97    prevopt=
98    run=
99    show="$echo"
100    show_help=
101    execute_dlfiles=
102    lo2o="s/\\.lo\$/.${objext}/"
103    o2lo="s/\\.${objext}\$/.lo/"
104    
105    # Parse our command line options once, thoroughly.
106    while test $# -gt 0
107    do
108      arg="$1"
109      shift
110    
111      case $arg in
112      -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
113      *) optarg= ;;
114      esac
115    
116      # If the previous option needs an argument, assign it.
117      if test -n "$prev"; then
118        case $prev in
119        execute_dlfiles)
120          execute_dlfiles="$execute_dlfiles $arg"
121          ;;
122        *)
123          eval "$prev=\$arg"
124          ;;
125        esac
126    
127        prev=
128        prevopt=
129        continue
130      fi
131    
132      # Have we seen a non-optional argument yet?
133      case $arg in
134      --help)
135        show_help=yes
136        ;;
137    
138      --version)
139        echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
140        exit 0
141        ;;
142    
143      --config)
144        sed -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
145        exit 0
146        ;;
147    
148      --debug)
149        echo "$progname: enabling shell trace mode"
150        set -x
151        ;;
152    
153      --dry-run | -n)
154        run=:
155        ;;
156    
157      --features)
158        echo "host: $host"
159        if test "$build_libtool_libs" = yes; then
160          echo "enable shared libraries"
161        else
162          echo "disable shared libraries"
163        fi
164        if test "$build_old_libs" = yes; then
165          echo "enable static libraries"
166        else
167          echo "disable static libraries"
168        fi
169        exit 0
170        ;;
171    
172      --finish) mode="finish" ;;
173    
174      --mode) prevopt="--mode" prev=mode ;;
175      --mode=*) mode="$optarg" ;;
176    
177      --quiet | --silent)
178        show=:
179        ;;
180    
181      -dlopen)
182        prevopt="-dlopen"
183        prev=execute_dlfiles
184        ;;
185    
186      -*)
187        $echo "$modename: unrecognized option \`$arg'" 1>&2
188        $echo "$help" 1>&2
189        exit 1
190        ;;
191    
192      *)
193        nonopt="$arg"
194        break
195        ;;
196      esac
197    done
198    
199    if test -n "$prevopt"; then
200      $echo "$modename: option \`$prevopt' requires an argument" 1>&2
201      $echo "$help" 1>&2
202      exit 1
203    fi
204    
205    if test -z "$show_help"; then
206    
207      # Infer the operation mode.
208      if test -z "$mode"; then
209        case $nonopt in
210        *cc | *++ | gcc* | *-gcc*)
211          mode=link
212          for arg
213          do
214            case $arg in
215            -c)
216               mode=compile
217               break
218               ;;
219            esac
220          done
221          ;;
222        *db | *dbx | *strace | *truss)
223          mode=execute
224          ;;
225        *install*|cp|mv)
226          mode=install
227          ;;
228        *rm)
229          mode=uninstall
230          ;;
231        *)
232          # If we have no mode, but dlfiles were specified, then do execute mode.
233          test -n "$execute_dlfiles" && mode=execute
234    
235          # Just use the default operation mode.
236          if test -z "$mode"; then
237            if test -n "$nonopt"; then
238              $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
239            else
240              $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
241            fi
242          fi
243          ;;
244        esac
245      fi
246    
247      # Only execute mode is allowed to have -dlopen flags.
248      if test -n "$execute_dlfiles" && test "$mode" != execute; then
249        $echo "$modename: unrecognized option \`-dlopen'" 1>&2
250        $echo "$help" 1>&2
251        exit 1
252      fi
253    
254      # Change the help message to a mode-specific one.
255      generic_help="$help"
256      help="Try \`$modename --help --mode=$mode' for more information."
257    
258      # These modes are in order of execution frequency so that they run quickly.
259      case $mode in
260      # libtool compile mode
261      compile)
262        modename="$modename: compile"
263        # Get the compilation command and the source file.
264        base_compile=
265        prev=
266        lastarg=
267        srcfile="$nonopt"
268        suppress_output=
269    
270        user_target=no
271        for arg
272        do
273          case $prev in
274          "") ;;
275          xcompiler)
276            # Aesthetically quote the previous argument.
277            prev=
278            lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
279    
280            case $arg in
281            # Double-quote args containing other shell metacharacters.
282            # Many Bourne shells cannot handle close brackets correctly
283            # in scan sets, so we specify it separately.
284            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
285              arg="\"$arg\""
286              ;;
287            esac
288    
289            # Add the previous argument to base_compile.
290            if test -z "$base_compile"; then
291              base_compile="$lastarg"
292            else
293              base_compile="$base_compile $lastarg"
294            fi
295            continue
296            ;;
297          esac
298    
299          # Accept any command-line options.
300          case $arg in
301          -o)
302            if test "$user_target" != "no"; then
303              $echo "$modename: you cannot specify \`-o' more than once" 1>&2
304              exit 1
305            fi
306            user_target=next
307            ;;
308    
309          -static)
310            build_old_libs=yes
311            continue
312            ;;
313    
314          -prefer-pic)
315            pic_mode=yes
316            continue
317            ;;
318    
319          -prefer-non-pic)
320            pic_mode=no
321            continue
322            ;;
323    
324          -Xcompiler)
325            prev=xcompiler
326            continue
327            ;;
328    
329          -Wc,*)
330            args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
331            lastarg=
332            IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
333            for arg in $args; do
334              IFS="$save_ifs"
335    
336              # Double-quote args containing other shell metacharacters.
337              # Many Bourne shells cannot handle close brackets correctly
338              # in scan sets, so we specify it separately.
339              case $arg in
340                *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
341                arg="\"$arg\""
342                ;;
343              esac
344              lastarg="$lastarg $arg"
345            done
346            IFS="$save_ifs"
347            lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
348    
349            # Add the arguments to base_compile.
350            if test -z "$base_compile"; then
351              base_compile="$lastarg"
352            else
353              base_compile="$base_compile $lastarg"
354            fi
355            continue
356            ;;
357          esac
358    
359          case $user_target in
360          next)
361            # The next one is the -o target name
362            user_target=yes
363            continue
364            ;;
365          yes)
366            # We got the output file
367            user_target=set
368            libobj="$arg"
369            continue
370            ;;
371          esac
372    
373          # Accept the current argument as the source file.
374          lastarg="$srcfile"
375          srcfile="$arg"
376    
377          # Aesthetically quote the previous argument.
378    
379          # Backslashify any backslashes, double quotes, and dollar signs.
380          # These are the only characters that are still specially
381          # interpreted inside of double-quoted scrings.
382          lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
383    
384          # Double-quote args containing other shell metacharacters.
385          # Many Bourne shells cannot handle close brackets correctly
386          # in scan sets, so we specify it separately.
387          case $lastarg in
388          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
389            lastarg="\"$lastarg\""
390            ;;
391          esac
392    
393          # Add the previous argument to base_compile.
394          if test -z "$base_compile"; then
395            base_compile="$lastarg"
396          else
397            base_compile="$base_compile $lastarg"
398          fi
399        done
400    
401        case $user_target in
402        set)
403          ;;
404        no)
405          # Get the name of the library object.
406          libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
407          ;;
408        *)
409          $echo "$modename: you must specify a target with \`-o'" 1>&2
410          exit 1
411          ;;
412        esac
413    
414        # Recognize several different file suffixes.
415        # If the user specifies -o file.o, it is replaced with file.lo
416        xform='[cCFSfmso]'
417        case $libobj in
418        *.ada) xform=ada ;;
419        *.adb) xform=adb ;;
420        *.ads) xform=ads ;;
421        *.asm) xform=asm ;;
422        *.c++) xform=c++ ;;
423        *.cc) xform=cc ;;
424        *.cpp) xform=cpp ;;
425        *.cxx) xform=cxx ;;
426        *.f90) xform=f90 ;;
427        *.for) xform=for ;;
428        esac
429    
430        libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
431    
432        case $libobj in
433        *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
434        *)
435          $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
436          exit 1
437          ;;
438        esac
439    
440        if test -z "$base_compile"; then
441          $echo "$modename: you must specify a compilation command" 1>&2
442          $echo "$help" 1>&2
443          exit 1
444        fi
445    
446        # Delete any leftover library objects.
447        if test "$build_old_libs" = yes; then
448          removelist="$obj $libobj"
449        else
450          removelist="$libobj"
451        fi
452    
453        $run $rm $removelist
454        trap "$run $rm $removelist; exit 1" 1 2 15
455    
456        # On Cygwin there's no "real" PIC flag so we must build both object types
457        case $host_os in
458        cygwin* | mingw* | pw32* | os2*)
459          pic_mode=default
460          ;;
461        esac
462        if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
463          # non-PIC code in shared libraries is not supported
464          pic_mode=default
465        fi
466    
467        # Calculate the filename of the output object if compiler does
468        # not support -o with -c
469        if test "$compiler_c_o" = no; then
470          output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
471          lockfile="$output_obj.lock"
472          removelist="$removelist $output_obj $lockfile"
473          trap "$run $rm $removelist; exit 1" 1 2 15
474        else
475          need_locks=no
476          lockfile=
477        fi
478    
479        # Lock this critical section if it is needed
480        # We use this script file to make the link, it avoids creating a new file
481        if test "$need_locks" = yes; then
482          until $run ln "$0" "$lockfile" 2>/dev/null; do
483            $show "Waiting for $lockfile to be removed"
484            sleep 2
485          done
486        elif test "$need_locks" = warn; then
487          if test -f "$lockfile"; then
488            echo "\
489    *** ERROR, $lockfile exists and contains:
490    `cat $lockfile 2>/dev/null`
491    
492    This indicates that another process is trying to use the same
493    temporary object file, and libtool could not work around it because
494    your compiler does not support \`-c' and \`-o' together.  If you
495    repeat this compilation, it may succeed, by chance, but you had better
496    avoid parallel builds (make -j) in this platform, or get a better
497    compiler."
498    
499            $run $rm $removelist
500            exit 1
501          fi
502          echo $srcfile > "$lockfile"
503        fi
504    
505        if test -n "$fix_srcfile_path"; then
506          eval srcfile=\"$fix_srcfile_path\"
507        fi
508    
509        # Only build a PIC object if we are building libtool libraries.
510        if test "$build_libtool_libs" = yes; then
511          # Without this assignment, base_compile gets emptied.
512          fbsd_hideous_sh_bug=$base_compile
513    
514          if test "$pic_mode" != no; then
515            # All platforms use -DPIC, to notify preprocessed assembler code.
516            command="$base_compile $srcfile $pic_flag -DPIC"
517          else
518            # Don't build PIC code
519            command="$base_compile $srcfile"
520          fi
521          if test "$build_old_libs" = yes; then
522            lo_libobj="$libobj"
523            dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
524            if test "X$dir" = "X$libobj"; then
525              dir="$objdir"
526            else
527              dir="$dir/$objdir"
528            fi
529            libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
530    
531            if test -d "$dir"; then
532              $show "$rm $libobj"
533              $run $rm $libobj
534            else
535              $show "$mkdir $dir"
536              $run $mkdir $dir
537              status=$?
538              if test $status -ne 0 && test ! -d $dir; then
539                exit $status
540              fi
541            fi
542          fi
543          if test "$compiler_o_lo" = yes; then
544            output_obj="$libobj"
545            command="$command -o $output_obj"
546          elif test "$compiler_c_o" = yes; then
547            output_obj="$obj"
548            command="$command -o $output_obj"
549          fi
550    
551          $run $rm "$output_obj"
552          $show "$command"
553          if $run eval "$command"; then :
554          else
555            test -n "$output_obj" && $run $rm $removelist
556            exit 1
557          fi
558    
559          if test "$need_locks" = warn &&
560             test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
561            echo "\
562    *** ERROR, $lockfile contains:
563    `cat $lockfile 2>/dev/null`
564    
565    but it should contain:
566    $srcfile
567    
568    This indicates that another process is trying to use the same
569    temporary object file, and libtool could not work around it because
570    your compiler does not support \`-c' and \`-o' together.  If you
571    repeat this compilation, it may succeed, by chance, but you had better
572    avoid parallel builds (make -j) in this platform, or get a better
573    compiler."
574    
575            $run $rm $removelist
576            exit 1
577          fi
578    
579          # Just move the object if needed, then go on to compile the next one
580          if test x"$output_obj" != x"$libobj"; then
581            $show "$mv $output_obj $libobj"
582            if $run $mv $output_obj $libobj; then :
583            else
584              error=$?
585              $run $rm $removelist
586              exit $error
587            fi
588          fi
589    
590          # If we have no pic_flag, then copy the object into place and finish.
591          if (test -z "$pic_flag" || test "$pic_mode" != default) &&
592             test "$build_old_libs" = yes; then
593            # Rename the .lo from within objdir to obj
594            if test -f $obj; then
595              $show $rm $obj
596              $run $rm $obj
597            fi
598    
599            $show "$mv $libobj $obj"
600            if $run $mv $libobj $obj; then :
601            else
602              error=$?
603              $run $rm $removelist
604              exit $error
605            fi
606    
607            xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
608            if test "X$xdir" = "X$obj"; then
609              xdir="."
610            else
611              xdir="$xdir"
612            fi
613            baseobj=`$echo "X$obj" | $Xsed -e "s%.*/%%"`
614            libobj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
615            # Now arrange that obj and lo_libobj become the same file
616            $show "(cd $xdir && $LN_S $baseobj $libobj)"
617            if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then
618              exit 0
619            else
620              error=$?
621              $run $rm $removelist
622              exit $error
623            fi
624          fi
625    
626          # Allow error messages only from the first compilation.
627          suppress_output=' >/dev/null 2>&1'
628        fi
629    
630        # Only build a position-dependent object if we build old libraries.
631        if test "$build_old_libs" = yes; then
632          if test "$pic_mode" != yes; then
633            # Don't build PIC code
634            command="$base_compile $srcfile"
635          else
636            # All platforms use -DPIC, to notify preprocessed assembler code.
637            command="$base_compile $srcfile $pic_flag -DPIC"
638          fi
639          if test "$compiler_c_o" = yes; then
640            command="$command -o $obj"
641            output_obj="$obj"
642          fi
643    
644          # Suppress compiler output if we already did a PIC compilation.
645          command="$command$suppress_output"
646          $run $rm "$output_obj"
647          $show "$command"
648          if $run eval "$command"; then :
649          else
650            $run $rm $removelist
651            exit 1
652          fi
653    
654          if test "$need_locks" = warn &&
655             test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
656            echo "\
657    *** ERROR, $lockfile contains:
658    `cat $lockfile 2>/dev/null`
659    
660    but it should contain:
661    $srcfile
662    
663    This indicates that another process is trying to use the same
664    temporary object file, and libtool could not work around it because
665    your compiler does not support \`-c' and \`-o' together.  If you
666    repeat this compilation, it may succeed, by chance, but you had better
667    avoid parallel builds (make -j) in this platform, or get a better
668    compiler."
669    
670            $run $rm $removelist
671            exit 1
672          fi
673    
674          # Just move the object if needed
675          if test x"$output_obj" != x"$obj"; then
676            $show "$mv $output_obj $obj"
677            if $run $mv $output_obj $obj; then :
678            else
679              error=$?
680              $run $rm $removelist
681              exit $error
682            fi
683          fi
684    
685          # Create an invalid libtool object if no PIC, so that we do not
686          # accidentally link it into a program.
687          if test "$build_libtool_libs" != yes; then
688            $show "echo timestamp > $libobj"
689            $run eval "echo timestamp > \$libobj" || exit $?
690          else
691            # Move the .lo from within objdir
692            $show "$mv $libobj $lo_libobj"
693            if $run $mv $libobj $lo_libobj; then :
694            else
695              error=$?
696              $run $rm $removelist
697              exit $error
698            fi
699          fi
700        fi
701    
702        # Unlock the critical section if it was locked
703        if test "$need_locks" != no; then
704          $run $rm "$lockfile"
705        fi
706    
707        exit 0
708        ;;
709    
710      # libtool link mode
711      link | relink)
712        modename="$modename: link"
713        case $host in
714        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
715          # It is impossible to link a dll without this setting, and
716          # we shouldn't force the makefile maintainer to figure out
717          # which system we are compiling for in order to pass an extra
718          # flag for every libtool invokation.
719          # allow_undefined=no
720    
721          # FIXME: Unfortunately, there are problems with the above when trying
722          # to make a dll which has undefined symbols, in which case not
723          # even a static library is built.  For now, we need to specify
724          # -no-undefined on the libtool link line when we can be certain
725          # that all symbols are satisfied, otherwise we get a static library.
726          allow_undefined=yes
727          ;;
728        *)
729          allow_undefined=yes
730          ;;
731        esac
732        libtool_args="$nonopt"
733        compile_command="$nonopt"
734        finalize_command="$nonopt"
735    
736        compile_rpath=
737        finalize_rpath=
738        compile_shlibpath=
739        finalize_shlibpath=
740        convenience=
741        old_convenience=
742        deplibs=
743        old_deplibs=
744        compiler_flags=
745        linker_flags=
746        dllsearchpath=
747        lib_search_path=`pwd`
748    
749        avoid_version=no
750        dlfiles=
751        dlprefiles=
752        dlself=no
753        export_dynamic=no
754        export_symbols=
755        export_symbols_regex=
756        generated=
757        libobjs=
758        ltlibs=
759        module=no
760        no_install=no
761        objs=
762        prefer_static_libs=no
763        preload=no
764        prev=
765        prevarg=
766        release=
767        rpath=
768        xrpath=
769        perm_rpath=
770        temp_rpath=
771        thread_safe=no
772        vinfo=
773    
774        # We need to know -static, to get the right output filenames.
775        for arg
776        do
777          case $arg in
778          -all-static | -static)
779            if test "X$arg" = "X-all-static"; then
780              if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
781                $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
782              fi
783              if test -n "$link_static_flag"; then
784                dlopen_self=$dlopen_self_static
785              fi
786            else
787              if test -z "$pic_flag" && test -n "$link_static_flag"; then
788                dlopen_self=$dlopen_self_static
789              fi
790            fi
791            build_libtool_libs=no
792            build_old_libs=yes
793            prefer_static_libs=yes
794            break
795            ;;
796          esac
797        done
798    
799        # See if our shared archives depend on static archives.
800        test -n "$old_archive_from_new_cmds" && build_old_libs=yes
801    
802        # Go through the arguments, transforming them on the way.
803        while test $# -gt 0; do
804          arg="$1"
805          shift
806          case $arg in
807          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
808            qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
809            ;;
810          *) qarg=$arg ;;
811          esac
812          libtool_args="$libtool_args $qarg"
813    
814          # If the previous option needs an argument, assign it.
815          if test -n "$prev"; then
816            case $prev in
817            output)
818              compile_command="$compile_command @OUTPUT@"
819              finalize_command="$finalize_command @OUTPUT@"
820              ;;
821            esac
822    
823            case $prev in
824            dlfiles|dlprefiles)
825              if test "$preload" = no; then
826                # Add the symbol object into the linking commands.
827                compile_command="$compile_command @SYMFILE@"
828                finalize_command="$finalize_command @SYMFILE@"
829                preload=yes
830              fi
831              case $arg in
832              *.la | *.lo) ;;  # We handle these cases below.
833              force)
834                if test "$dlself" = no; then
835                  dlself=needless
836                  export_dynamic=yes
837                fi
838                prev=
839                continue
840                ;;
841              self)
842                if test "$prev" = dlprefiles; then
843                  dlself=yes
844                elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
845                  dlself=yes
846                else
847                  dlself=needless
848                  export_dynamic=yes
849                fi
850                prev=
851                continue
852                ;;
853              *)
854                if test "$prev" = dlfiles; then
855                  dlfiles="$dlfiles $arg"
856                else
857                  dlprefiles="$dlprefiles $arg"
858                fi
859                prev=
860                continue
861                ;;
862              esac
863              ;;
864            expsyms)
865              export_symbols="$arg"
866              if test ! -f "$arg"; then
867                $echo "$modename: symbol file \`$arg' does not exist"
868                exit 1
869              fi
870              prev=
871              continue
872              ;;
873            expsyms_regex)
874              export_symbols_regex="$arg"
875              prev=
876              continue
877              ;;
878            release)
879              release="-$arg"
880              prev=
881              continue
882              ;;
883            rpath | xrpath)
884              # We need an absolute path.
885              case $arg in
886              [\\/]* | [A-Za-z]:[\\/]*) ;;
887              *)
888                $echo "$modename: only absolute run-paths are allowed" 1>&2
889                exit 1
890                ;;
891              esac
892              if test "$prev" = rpath; then
893                case "$rpath " in
894                *" $arg "*) ;;
895                *) rpath="$rpath $arg" ;;
896                esac
897              else
898                case "$xrpath " in
899                *" $arg "*) ;;
900                *) xrpath="$xrpath $arg" ;;
901                esac
902              fi
903              prev=
904              continue
905              ;;
906            xcompiler)
907              compiler_flags="$compiler_flags $qarg"
908              prev=
909              compile_command="$compile_command $qarg"
910              finalize_command="$finalize_command $qarg"
911              continue
912              ;;
913            xlinker)
914              linker_flags="$linker_flags $qarg"
915              compiler_flags="$compiler_flags $wl$qarg"
916              prev=
917              compile_command="$compile_command $wl$qarg"
918              finalize_command="$finalize_command $wl$qarg"
919              continue
920              ;;
921            *)
922              eval "$prev=\"\$arg\""
923              prev=
924              continue
925              ;;
926            esac
927          fi # test -n $prev
928    
929          prevarg="$arg"
930    
931          case $arg in
932          -all-static)
933            if test -n "$link_static_flag"; then
934              compile_command="$compile_command $link_static_flag"
935              finalize_command="$finalize_command $link_static_flag"
936            fi
937            continue
938            ;;
939    
940          -allow-undefined)
941            # FIXME: remove this flag sometime in the future.
942            $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
943            continue
944            ;;
945    
946          -avoid-version)
947            avoid_version=yes
948            continue
949            ;;
950    
951          -dlopen)
952            prev=dlfiles
953            continue
954            ;;
955    
956          -dlpreopen)
957            prev=dlprefiles
958            continue
959            ;;
960    
961          -export-dynamic)
962            export_dynamic=yes
963            continue
964            ;;
965    
966          -export-symbols | -export-symbols-regex)
967            if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
968              $echo "$modename: more than one -exported-symbols argument is not allowed"
969              exit 1
970            fi
971            if test "X$arg" = "X-export-symbols"; then
972              prev=expsyms
973            else
974              prev=expsyms_regex
975            fi
976            continue
977            ;;
978    
979          # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
980          # so, if we see these flags be careful not to treat them like -L
981          -L[A-Z][A-Z]*:*)
982            case $with_gcc/$host in
983            no/*-*-irix*)
984              compile_command="$compile_command $arg"
985              finalize_command="$finalize_command $arg"
986              ;;
987            esac
988            continue
989            ;;
990    
991          -L*)
992            dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
993            # We need an absolute path.
994            case $dir in
995            [\\/]* | [A-Za-z]:[\\/]*) ;;
996            *)
997              absdir=`cd "$dir" && pwd`
998              if test -z "$absdir"; then
999                $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1000                exit 1
1001              fi
1002              dir="$absdir"
1003              ;;
1004            esac
1005            case "$deplibs " in
1006            *" -L$dir "*) ;;
1007            *)
1008              deplibs="$deplibs -L$dir"
1009              lib_search_path="$lib_search_path $dir"
1010              ;;
1011            esac
1012            case $host in
1013            *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1014              case :$dllsearchpath: in
1015              *":$dir:"*) ;;
1016              *) dllsearchpath="$dllsearchpath:$dir";;
1017              esac
1018              ;;
1019            esac
1020            continue
1021            ;;
1022    
1023          -l*)
1024            if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1025              case $host in
1026              *-*-cygwin* | *-*-pw32* | *-*-beos*)
1027                # These systems don't actually have a C or math library (as such)
1028                continue
1029                ;;
1030              *-*-mingw* | *-*-os2*)
1031                # These systems don't actually have a C library (as such)
1032                test "X$arg" = "X-lc" && continue
1033                ;;
1034              esac
1035            fi
1036            deplibs="$deplibs $arg"
1037            continue
1038            ;;
1039    
1040          -module)
1041            module=yes
1042            continue
1043            ;;
1044    
1045          -no-fast-install)
1046            fast_install=no
1047            continue
1048            ;;
1049    
1050          -no-install)
1051            case $host in
1052            *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1053              # The PATH hackery in wrapper scripts is required on Windows
1054              # in order for the loader to find any dlls it needs.
1055              $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1056              $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1057              fast_install=no
1058              ;;
1059            *) no_install=yes ;;
1060            esac
1061            continue
1062            ;;
1063    
1064          -no-undefined)
1065            allow_undefined=no
1066            continue
1067            ;;
1068    
1069          -o) prev=output ;;
1070    
1071          -release)
1072            prev=release
1073            continue
1074            ;;
1075    
1076          -rpath)
1077            prev=rpath
1078            continue
1079            ;;
1080    
1081          -R)
1082            prev=xrpath
1083            continue
1084            ;;
1085    
1086          -R*)
1087            dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1088            # We need an absolute path.
1089            case $dir in
1090            [\\/]* | [A-Za-z]:[\\/]*) ;;
1091            *)
1092              $echo "$modename: only absolute run-paths are allowed" 1>&2
1093              exit 1
1094              ;;
1095            esac
1096            case "$xrpath " in
1097            *" $dir "*) ;;
1098            *) xrpath="$xrpath $dir" ;;
1099            esac
1100            continue
1101            ;;
1102    
1103          -static)
1104            # The effects of -static are defined in a previous loop.
1105            # We used to do the same as -all-static on platforms that
1106            # didn't have a PIC flag, but the assumption that the effects
1107            # would be equivalent was wrong.  It would break on at least
1108            # Digital Unix and AIX.
1109            continue
1110            ;;
1111    
1112          -thread-safe)
1113            thread_safe=yes
1114            continue
1115            ;;
1116    
1117          -version-info)
1118            prev=vinfo
1119            continue
1120            ;;
1121    
1122          -Wc,*)
1123            args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1124            arg=
1125            IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1126            for flag in $args; do
1127              IFS="$save_ifs"
1128              case $flag in
1129                *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1130                flag="\"$flag\""
1131                ;;
1132              esac
1133              arg="$arg $wl$flag"
1134              compiler_flags="$compiler_flags $flag"
1135            done
1136            IFS="$save_ifs"
1137            arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1138            ;;
1139    
1140          -Wl,*)
1141            args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1142            arg=
1143            IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1144            for flag in $args; do
1145              IFS="$save_ifs"
1146              case $flag in
1147                *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1148                flag="\"$flag\""
1149                ;;
1150              esac
1151              arg="$arg $wl$flag"
1152              compiler_flags="$compiler_flags $wl$flag"
1153              linker_flags="$linker_flags $flag"
1154            done
1155            IFS="$save_ifs"
1156            arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1157            ;;
1158    
1159          -Xcompiler)
1160            prev=xcompiler
1161            continue
1162            ;;
1163    
1164          -Xlinker)
1165            prev=xlinker
1166            continue
1167            ;;
1168    
1169          # Some other compiler flag.
1170          -* | +*)
1171            # Unknown arguments in both finalize_command and compile_command need
1172            # to be aesthetically quoted because they are evaled later.
1173            arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1174            case $arg in
1175            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1176              arg="\"$arg\""
1177              ;;
1178            esac
1179            ;;
1180    
1181          *.lo | *.$objext)
1182            # A library or standard object.
1183            if test "$prev" = dlfiles; then
1184              # This file was specified with -dlopen.
1185              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1186                dlfiles="$dlfiles $arg"
1187                prev=
1188                continue
1189              else
1190                # If libtool objects are unsupported, then we need to preload.
1191                prev=dlprefiles
1192              fi
1193            fi
1194    
1195            if test "$prev" = dlprefiles; then
1196              # Preload the old-style object.
1197              dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
1198              prev=
1199            else
1200              case $arg in
1201              *.lo) libobjs="$libobjs $arg" ;;
1202              *) objs="$objs $arg" ;;
1203              esac
1204            fi
1205            ;;
1206    
1207          *.$libext)
1208            # An archive.
1209            deplibs="$deplibs $arg"
1210            old_deplibs="$old_deplibs $arg"
1211            continue
1212            ;;
1213    
1214          *.la)
1215            # A libtool-controlled library.
1216    
1217            if test "$prev" = dlfiles; then
1218              # This library was specified with -dlopen.
1219              dlfiles="$dlfiles $arg"
1220              prev=
1221            elif test "$prev" = dlprefiles; then
1222              # The library was specified with -dlpreopen.
1223              dlprefiles="$dlprefiles $arg"
1224              prev=
1225            else
1226              deplibs="$deplibs $arg"
1227            fi
1228            continue
1229            ;;
1230    
1231          # Some other compiler argument.
1232          *)
1233            # Unknown arguments in both finalize_command and compile_command need
1234            # to be aesthetically quoted because they are evaled later.
1235            arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1236            case $arg in
1237            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1238              arg="\"$arg\""
1239              ;;
1240            esac
1241            ;;
1242          esac # arg
1243    
1244          # Now actually substitute the argument into the commands.
1245          if test -n "$arg"; then
1246            compile_command="$compile_command $arg"
1247            finalize_command="$finalize_command $arg"
1248          fi
1249        done # argument parsing loop
1250    
1251        if test -n "$prev"; then
1252          $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1253          $echo "$help" 1>&2
1254          exit 1
1255        fi
1256    
1257        if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1258          eval arg=\"$export_dynamic_flag_spec\"
1259          compile_command="$compile_command $arg"
1260          finalize_command="$finalize_command $arg"
1261        fi
1262    
1263        # calculate the name of the file, without its directory
1264        outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1265        libobjs_save="$libobjs"
1266    
1267        if test -n "$shlibpath_var"; then
1268          # get the directories listed in $shlibpath_var
1269          eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1270        else
1271          shlib_search_path=
1272        fi
1273        eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1274        eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1275    
1276        output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1277        if test "X$output_objdir" = "X$output"; then
1278          output_objdir="$objdir"
1279        else
1280          output_objdir="$output_objdir/$objdir"
1281        fi
1282        # Create the object directory.
1283        if test ! -d $output_objdir; then
1284          $show "$mkdir $output_objdir"
1285          $run $mkdir $output_objdir
1286          status=$?
1287          if test $status -ne 0 && test ! -d $output_objdir; then
1288            exit $status
1289          fi
1290        fi
1291    
1292        # Determine the type of output
1293        case $output in
1294        "")
1295          $echo "$modename: you must specify an output file" 1>&2
1296          $echo "$help" 1>&2
1297          exit 1
1298          ;;
1299        *.$libext) linkmode=oldlib ;;
1300        *.lo | *.$objext) linkmode=obj ;;
1301        *.la) linkmode=lib ;;
1302        *) linkmode=prog ;; # Anything else should be a program.
1303        esac
1304    
1305        specialdeplibs=
1306        libs=
1307        # Find all interdependent deplibs by searching for libraries
1308        # that are linked more than once (e.g. -la -lb -la)
1309        for deplib in $deplibs; do
1310          case "$libs " in
1311          *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1312          esac
1313          libs="$libs $deplib"
1314        done
1315        deplibs=
1316        newdependency_libs=
1317        newlib_search_path=
1318        need_relink=no # whether we're linking any uninstalled libtool libraries
1319        notinst_deplibs= # not-installed libtool libraries
1320        notinst_path= # paths that contain not-installed libtool libraries
1321        case $linkmode in
1322        lib)
1323            passes="conv link"
1324            for file in $dlfiles $dlprefiles; do
1325              case $file in
1326              *.la) ;;
1327              *)
1328                $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1329                exit 1
1330                ;;
1331              esac
1332            done
1333            ;;
1334        prog)
1335            compile_deplibs=
1336            finalize_deplibs=
1337            alldeplibs=no
1338            newdlfiles=
1339            newdlprefiles=
1340            passes="conv scan dlopen dlpreopen link"
1341            ;;
1342        *)  passes="conv"
1343            ;;
1344        esac
1345        for pass in $passes; do
1346          if test "$linkmode" = prog; then
1347            # Determine which files to process
1348            case $pass in
1349            dlopen)
1350              libs="$dlfiles"
1351              save_deplibs="$deplibs" # Collect dlpreopened libraries
1352              deplibs=
1353              ;;
1354            dlpreopen) libs="$dlprefiles" ;;
1355            link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1356            esac
1357          fi
1358          for deplib in $libs; do
1359            lib=
1360            found=no
1361            case $deplib in
1362            -l*)
1363              if test "$linkmode" = oldlib && test "$linkmode" = obj; then
1364                $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1365                continue
1366              fi
1367              if test "$pass" = conv; then
1368                deplibs="$deplib $deplibs"
1369                continue
1370              fi
1371              name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1372              for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1373                # Search the libtool library
1374                lib="$searchdir/lib${name}.la"
1375                if test -f "$lib"; then
1376                  found=yes
1377                  break
1378                fi
1379              done
1380              if test "$found" != yes; then
1381                # deplib doesn't seem to be a libtool library
1382                if test "$linkmode,$pass" = "prog,link"; then
1383                  compile_deplibs="$deplib $compile_deplibs"
1384                  finalize_deplibs="$deplib $finalize_deplibs"
1385                else
1386                  deplibs="$deplib $deplibs"
1387                  test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1388                fi
1389                continue
1390              fi
1391              ;; # -l
1392            -L*)
1393              case $linkmode in
1394              lib)
1395                deplibs="$deplib $deplibs"
1396                test "$pass" = conv && continue
1397                newdependency_libs="$deplib $newdependency_libs"
1398                newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1399                ;;
1400              prog)
1401                if test "$pass" = conv; then
1402                  deplibs="$deplib $deplibs"
1403                  continue
1404                fi
1405                if test "$pass" = scan; then
1406                  deplibs="$deplib $deplibs"
1407                  newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1408                else
1409                  compile_deplibs="$deplib $compile_deplibs"
1410                  finalize_deplibs="$deplib $finalize_deplibs"
1411                fi
1412                ;;
1413              *)
1414                $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1415                ;;
1416              esac # linkmode
1417              continue
1418              ;; # -L
1419            -R*)
1420              if test "$pass" = link; then
1421                dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1422                # Make sure the xrpath contains only unique directories.
1423                case "$xrpath " in
1424                *" $dir "*) ;;
1425                *) xrpath="$xrpath $dir" ;;
1426                esac
1427              fi
1428              deplibs="$deplib $deplibs"
1429              continue
1430              ;;
1431            *.la) lib="$deplib" ;;
1432            *.$libext)
1433              if test "$pass" = conv; then
1434                deplibs="$deplib $deplibs"
1435                continue
1436              fi
1437              case $linkmode in
1438              lib)
1439                if test "$deplibs_check_method" != pass_all; then
1440                  echo
1441                  echo "*** Warning: This library needs some functionality provided by $deplib."
1442                  echo "*** I have the capability to make that library automatically link in when"
1443                  echo "*** you link to this library.  But I can only do this if you have a"
1444                  echo "*** shared version of the library, which you do not appear to have."
1445                else
1446                  echo
1447                  echo "*** Warning: Linking the shared library $output against the"
1448                  echo "*** static library $deplib is not portable!"
1449                  deplibs="$deplib $deplibs"
1450                fi
1451                continue
1452                ;;
1453              prog)
1454                if test "$pass" != link; then
1455                  deplibs="$deplib $deplibs"
1456                else
1457                  compile_deplibs="$deplib $compile_deplibs"
1458                  finalize_deplibs="$deplib $finalize_deplibs"
1459                fi
1460                continue
1461                ;;
1462              esac # linkmode
1463              ;; # *.$libext
1464            *.lo | *.$objext)
1465              if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1466                # If there is no dlopen support or we're linking statically,
1467                # we need to preload.
1468                newdlprefiles="$newdlprefiles $deplib"
1469                compile_deplibs="$deplib $compile_deplibs"
1470                finalize_deplibs="$deplib $finalize_deplibs"
1471              else
1472                newdlfiles="$newdlfiles $deplib"
1473              fi
1474              continue
1475              ;;
1476            %DEPLIBS%)
1477              alldeplibs=yes
1478              continue
1479              ;;
1480            esac # case $deplib
1481            if test $found = yes || test -f "$lib"; then :
1482            else
1483              $echo "$modename: cannot find the library \`$lib'" 1>&2
1484              exit 1
1485            fi
1486    
1487            # Check to see that this really is a libtool archive.
1488            if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1489            else
1490              $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1491              exit 1
1492            fi
1493    
1494            ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1495            test "X$ladir" = "X$lib" && ladir="."
1496    
1497            dlname=
1498            dlopen=
1499            dlpreopen=
1500            libdir=
1501            library_names=
1502            old_library=
1503            # If the library was installed with an old release of libtool,
1504            # it will not redefine variable installed.
1505            installed=yes
1506    
1507            # Read the .la file
1508            case $lib in
1509            */* | *\\*) . $lib ;;
1510            *) . ./$lib ;;
1511            esac
1512    
1513            if test "$linkmode,$pass" = "lib,link" ||
1514               test "$linkmode,$pass" = "prog,scan" ||
1515               { test "$linkmode" = oldlib && test "$linkmode" = obj; }; then
1516               # Add dl[pre]opened files of deplib
1517              test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1518              test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1519            fi
1520    
1521            if test "$pass" = conv; then
1522              # Only check for convenience libraries
1523              deplibs="$lib $deplibs"
1524              if test -z "$libdir"; then
1525                if test -z "$old_library"; then
1526                  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1527                  exit 1
1528                fi
1529                # It is a libtool convenience library, so add in its objects.
1530                convenience="$convenience $ladir/$objdir/$old_library"
1531                old_convenience="$old_convenience $ladir/$objdir/$old_library"
1532                tmp_libs=
1533                for deplib in $dependency_libs; do
1534                  deplibs="$deplib $deplibs"
1535                  case "$tmp_libs " in
1536                  *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1537                  esac
1538                  tmp_libs="$tmp_libs $deplib"
1539                done
1540              elif test "$linkmode" != prog && test "$linkmode" != lib; then
1541                $echo "$modename: \`$lib' is not a convenience library" 1>&2
1542                exit 1
1543              fi
1544              continue
1545            fi # $pass = conv
1546    
1547            # Get the name of the library we link against.
1548            linklib=
1549            for l in $old_library $library_names; do
1550              linklib="$l"
1551            done
1552            if test -z "$linklib"; then
1553              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1554              exit 1
1555            fi
1556    
1557            # This library was specified with -dlopen.
1558            if test "$pass" = dlopen; then
1559              if test -z "$libdir"; then
1560                $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1561                exit 1
1562              fi
1563              if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1564                # If there is no dlname, no dlopen support or we're linking
1565                # statically, we need to preload.
1566                dlprefiles="$dlprefiles $lib"
1567              else
1568                newdlfiles="$newdlfiles $lib"
1569              fi
1570              continue
1571            fi # $pass = dlopen
1572    
1573            # We need an absolute path.
1574            case $ladir in
1575            [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1576            *)
1577              abs_ladir=`cd "$ladir" && pwd`
1578              if test -z "$abs_ladir"; then
1579                $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1580                $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1581                abs_ladir="$ladir"
1582              fi
1583              ;;
1584            esac
1585            laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1586    
1587            # Find the relevant object directory and library name.
1588            if test "X$installed" = Xyes; then
1589              if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1590                $echo "$modename: warning: library \`$lib' was moved." 1>&2
1591                dir="$ladir"
1592                absdir="$abs_ladir"
1593                libdir="$abs_ladir"
1594              else
1595                dir="$libdir"
1596                absdir="$libdir"
1597              fi
1598            else
1599              dir="$ladir/$objdir"
1600              absdir="$abs_ladir/$objdir"
1601              # Remove this search path later
1602              notinst_path="$notinst_path $abs_ladir"
1603            fi # $installed = yes
1604            name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1605    
1606            # This library was specified with -dlpreopen.
1607            if test "$pass" = dlpreopen; then
1608              if test -z "$libdir"; then
1609                $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1610                exit 1
1611              fi
1612              # Prefer using a static library (so that no silly _DYNAMIC symbols
1613              # are required to link).
1614              if test -n "$old_library"; then
1615                newdlprefiles="$newdlprefiles $dir/$old_library"
1616              # Otherwise, use the dlname, so that lt_dlopen finds it.
1617              elif test -n "$dlname"; then
1618                newdlprefiles="$newdlprefiles $dir/$dlname"
1619              else
1620                newdlprefiles="$newdlprefiles $dir/$linklib"
1621              fi
1622            fi # $pass = dlpreopen
1623    
1624            if test -z "$libdir"; then
1625              # Link the convenience library
1626              if test "$linkmode" = lib; then
1627                deplibs="$dir/$old_library $deplibs"
1628              elif test "$linkmode,$pass" = "prog,link"; then
1629                compile_deplibs="$dir/$old_library $compile_deplibs"
1630                finalize_deplibs="$dir/$old_library $finalize_deplibs"
1631              else
1632                deplibs="$lib $deplibs"
1633              fi
1634              continue
1635            fi
1636    
1637            if test "$linkmode" = prog && test "$pass" != link; then
1638              newlib_search_path="$newlib_search_path $ladir"
1639              deplibs="$lib $deplibs"
1640    
1641              linkalldeplibs=no
1642              if test "$link_all_deplibs" != no || test -z "$library_names" ||
1643                 test "$build_libtool_libs" = no; then
1644                linkalldeplibs=yes
1645              fi
1646    
1647              tmp_libs=
1648              for deplib in $dependency_libs; do
1649                case $deplib in
1650                -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
1651                esac
1652                # Need to link against all dependency_libs?
1653                if test $linkalldeplibs = yes; then
1654                  deplibs="$deplib $deplibs"
1655                else
1656                  # Need to hardcode shared library paths
1657                  # or/and link against static libraries
1658                  newdependency_libs="$deplib $newdependency_libs"
1659                fi
1660                case "$tmp_libs " in
1661                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1662                esac
1663                tmp_libs="$tmp_libs $deplib"
1664              done # for deplib
1665              continue
1666            fi # $linkmode = prog...
1667    
1668            link_static=no # Whether the deplib will be linked statically
1669            if test -n "$library_names" &&
1670               { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
1671              # Link against this shared library
1672    
1673              if test "$linkmode,$pass" = "prog,link" ||
1674               { test "$linkmode" = lib && test "$hardcode_into_libs" = yes; }; then
1675                # Hardcode the library path.
1676                # Skip directories that are in the system default run-time
1677                # search path.
1678                case " $sys_lib_dlsearch_path " in
1679                *" $absdir "*) ;;
1680                *)
1681                  case "$compile_rpath " in
1682                  *" $absdir "*) ;;
1683                  *) compile_rpath="$compile_rpath $absdir"
1684                  esac
1685                  ;;
1686                esac
1687                case " $sys_lib_dlsearch_path " in
1688                *" $libdir "*) ;;
1689                *)
1690                  case "$finalize_rpath " in
1691                  *" $libdir "*) ;;
1692                  *) finalize_rpath="$finalize_rpath $libdir"
1693                  esac
1694                  ;;
1695                esac
1696                if test "$linkmode" = prog; then
1697                  # We need to hardcode the library path
1698                  if test -n "$shlibpath_var"; then
1699                    # Make sure the rpath contains only unique directories.
1700                    case "$temp_rpath " in
1701                    *" $dir "*) ;;
1702                    *" $absdir "*) ;;
1703                    *) temp_rpath="$temp_rpath $dir" ;;
1704                    esac
1705                  fi
1706                fi
1707              fi # $linkmode,$pass = prog,link...
1708    
1709              if test "$alldeplibs" = yes &&
1710                 { test "$deplibs_check_method" = pass_all ||
1711                   { test "$build_libtool_libs" = yes &&
1712                     test -n "$library_names"; }; }; then
1713                # We only need to search for static libraries
1714                continue
1715              fi
1716    
1717              if test "$installed" = no; then
1718                notinst_deplibs="$notinst_deplibs $lib"
1719                need_relink=yes
1720              fi
1721    
1722              if test -n "$old_archive_from_expsyms_cmds"; then
1723                # figure out the soname
1724                set dummy $library_names
1725                realname="$2"
1726                shift; shift
1727                libname=`eval \\$echo \"$libname_spec\"`
1728                # use dlname if we got it. it's perfectly good, no?
1729                if test -n "$dlname"; then
1730                  soname="$dlname"
1731                elif test -n "$soname_spec"; then
1732                  # bleh windows
1733                  case $host in
1734                  *cygwin*)
1735                    major=`expr $current - $age`
1736                    versuffix="-$major"
1737                    ;;
1738                  esac
1739                  eval soname=\"$soname_spec\"
1740                else
1741                  soname="$realname"
1742                fi
1743    
1744                # Make a new name for the extract_expsyms_cmds to use
1745                soroot="$soname"
1746                soname=`echo $soroot | sed -e 's/^.*\///'`
1747                newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
1748    
1749                # If the library has no export list, then create one now
1750                if test -f "$output_objdir/$soname-def"; then :
1751                else
1752                  $show "extracting exported symbol list from \`$soname'"
1753                  IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
1754                  eval cmds=\"$extract_expsyms_cmds\"
1755                  for cmd in $cmds; do
1756                    IFS="$save_ifs"
1757                    $show "$cmd"
1758                    $run eval "$cmd" || exit $?
1759                  done
1760                  IFS="$save_ifs"
1761                fi
1762    
1763                # Create $newlib
1764                if test -f "$output_objdir/$newlib"; then :; else
1765                  $show "generating import library for \`$soname'"
1766                  IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
1767                  eval cmds=\"$old_archive_from_expsyms_cmds\"
1768                  for cmd in $cmds; do
1769                    IFS="$save_ifs"
1770                    $show "$cmd"
1771                    $run eval "$cmd" || exit $?
1772                  done
1773                  IFS="$save_ifs"
1774                fi
1775                # make sure the library variables are pointing to the new library
1776                dir=$output_objdir
1777                linklib=$newlib
1778              fi # test -n $old_archive_from_expsyms_cmds
1779    
1780              if test "$linkmode" = prog || test "$mode" != relink; then
1781                add_shlibpath=
1782                add_dir=
1783                add=
1784                lib_linked=yes
1785                case $hardcode_action in
1786                immediate | unsupported)
1787                  if test "$hardcode_direct" = no; then
1788                    add="$dir/$linklib"
1789                  elif test "$hardcode_minus_L" = no; then
1790                    case $host in
1791                    *-*-sunos*) add_shlibpath="$dir" ;;
1792                    esac
1793                    add_dir="-L$dir"
1794                    add="-l$name"
1795                  elif test "$hardcode_shlibpath_var" = no; then
1796                    add_shlibpath="$dir"
1797                    add="-l$name"
1798                  else
1799                    lib_linked=no
1800                  fi
1801                  ;;
1802                relink)
1803                  if test "$hardcode_direct" = yes; then
1804                    add="$dir/$linklib"
1805                  elif test "$hardcode_minus_L" = yes; then
1806                    add_dir="-L$dir"
1807                    add="-l$name"
1808                  elif test "$hardcode_shlibpath_var" = yes; then
1809                    add_shlibpath="$dir"
1810                    add="-l$name"
1811                  else
1812                    lib_linked=no
1813                  fi
1814                  ;;
1815                *) lib_linked=no ;;
1816                esac
1817    
1818                if test "$lib_linked" != yes; then
1819                  $echo "$modename: configuration error: unsupported hardcode properties"
1820                  exit 1
1821                fi
1822    
1823                if test -n "$add_shlibpath"; then
1824                  case :$compile_shlibpath: in
1825                  *":$add_shlibpath:"*) ;;
1826                  *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
1827                  esac
1828                fi
1829                if test "$linkmode" = prog; then
1830                  test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
1831                  test -n "$add" && compile_deplibs="$add $compile_deplibs"
1832                else
1833                  test -n "$add_dir" && deplibs="$add_dir $deplibs"
1834                  test -n "$add" && deplibs="$add $deplibs"
1835                  if test "$hardcode_direct" != yes && \
1836                     test "$hardcode_minus_L" != yes && \
1837                     test "$hardcode_shlibpath_var" = yes; then
1838                    case :$finalize_shlibpath: in
1839                    *":$libdir:"*) ;;
1840                    *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
1841                    esac
1842                  fi
1843                fi
1844              fi
1845    
1846              if test "$linkmode" = prog || test "$mode" = relink; then
1847                add_shlibpath=
1848                add_dir=
1849                add=
1850                # Finalize command for both is simple: just hardcode it.
1851                if test "$hardcode_direct" = yes; then
1852                  add="$libdir/$linklib"
1853                elif test "$hardcode_minus_L" = yes; then
1854                  add_dir="-L$libdir"
1855                  add="-l$name"
1856                elif test "$hardcode_shlibpath_var" = yes; then
1857                  case :$finalize_shlibpath: in
1858                  *":$libdir:"*) ;;
1859                  *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
1860                  esac
1861                  add="-l$name"
1862                else
1863                  # We cannot seem to hardcode it, guess we'll fake it.
1864                  add_dir="-L$libdir"
1865                  add="-l$name"
1866                fi
1867    
1868                if test "$linkmode" = prog; then
1869                  test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
1870                  test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
1871                else
1872                  test -n "$add_dir" && deplibs="$add_dir $deplibs"
1873                  test -n "$add" && deplibs="$add $deplibs"
1874                fi
1875              fi
1876            elif test "$linkmode" = prog; then
1877              if test "$alldeplibs" = yes &&
1878                 { test "$deplibs_check_method" = pass_all ||
1879                   { test "$build_libtool_libs" = yes &&
1880                     test -n "$library_names"; }; }; then
1881                # We only need to search for static libraries
1882                continue
1883              fi
1884    
1885              # Try to link the static library
1886              # Here we assume that one of hardcode_direct or hardcode_minus_L
1887              # is not unsupported.  This is valid on all known static and
1888              # shared platforms.
1889              if test "$hardcode_direct" != unsupported; then
1890                test -n "$old_library" && linklib="$old_library"
1891                compile_deplibs="$dir/$linklib $compile_deplibs"
1892                finalize_deplibs="$dir/$linklib $finalize_deplibs"
1893              else
1894                compile_deplibs="-l$name -L$dir $compile_deplibs"
1895                finalize_deplibs="-l$name -L$dir $finalize_deplibs"
1896              fi
1897            elif test "$build_libtool_libs" = yes; then
1898              # Not a shared library
1899              if test "$deplibs_check_method" != pass_all; then
1900                # We're trying link a shared library against a static one
1901                # but the system doesn't support it.
1902    
1903                # Just print a warning and add the library to dependency_libs so
1904                # that the program can be linked against the static library.
1905                echo
1906                echo "*** Warning: This library needs some functionality provided by $lib."
1907                echo "*** I have the capability to make that library automatically link in when"
1908                echo "*** you link to this library.  But I can only do this if you have a"
1909                echo "*** shared version of the library, which you do not appear to have."
1910                if test "$module" = yes; then
1911                  echo "*** Therefore, libtool will create a static module, that should work "
1912                  echo "*** as long as the dlopening application is linked with the -dlopen flag."
1913                  if test -z "$global_symbol_pipe"; then
1914                    echo
1915                    echo "*** However, this would only work if libtool was able to extract symbol"
1916                    echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
1917                    echo "*** not find such a program.  So, this module is probably useless."
1918                    echo "*** \`nm' from GNU binutils and a full rebuild may help."
1919                  fi
1920                  if test "$build_old_libs" = no; then
1921                    build_libtool_libs=module
1922                    build_old_libs=yes
1923                  else
1924                    build_libtool_libs=no
1925                  fi
1926                fi
1927              else
1928                convenience="$convenience $dir/$old_library"
1929                old_convenience="$old_convenience $dir/$old_library"
1930                deplibs="$dir/$old_library $deplibs"
1931                link_static=yes
1932              fi
1933            fi # link shared/static library?
1934    
1935            if test "$linkmode" = lib; then
1936              if test -n "$dependency_libs" &&
1937                 { test "$hardcode_into_libs" != yes || test $build_old_libs = yes ||
1938                   test $link_static = yes; }; then
1939                # Extract -R from dependency_libs
1940                temp_deplibs=
1941                for libdir in $dependency_libs; do
1942                  case $libdir in
1943                  -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
1944                       case " $xrpath " in
1945                       *" $temp_xrpath "*) ;;
1946                       *) xrpath="$xrpath $temp_xrpath";;
1947                       esac;;
1948                  *) temp_deplibs="$temp_deplibs $libdir";;
1949                  esac
1950                done
1951                dependency_libs="$temp_deplibs"
1952              fi
1953    
1954              newlib_search_path="$newlib_search_path $absdir"
1955              # Link against this library
1956              test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
1957              # ... and its dependency_libs
1958              tmp_libs=
1959              for deplib in $dependency_libs; do
1960                newdependency_libs="$deplib $newdependency_libs"
1961                case "$tmp_libs " in
1962                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1963                esac
1964                tmp_libs="$tmp_libs $deplib"
1965              done
1966    
1967              if test "$link_all_deplibs" != no; then
1968                # Add the search paths of all dependency libraries
1969                for deplib in $dependency_libs; do
1970                  case $deplib in
1971                  -L*) path="$deplib" ;;
1972                  *.la)
1973                    dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
1974                    test "X$dir" = "X$deplib" && dir="."
1975                    # We need an absolute path.
1976                    case $dir in
1977                    [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
1978                    *)
1979                      absdir=`cd "$dir" && pwd`
1980                      if test -z "$absdir"; then
1981                        $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
1982                        absdir="$dir"
1983                      fi
1984                      ;;
1985                    esac
1986                    if grep "^installed=no" $deplib > /dev/null; then
1987                      path="-L$absdir/$objdir"
1988                    else
1989                      eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
1990                      if test -z "$libdir"; then
1991                        $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
1992                        exit 1
1993                      fi
1994                      if test "$absdir" != "$libdir"; then
1995                        $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
1996                      fi
1997                      path="-L$absdir"
1998                    fi
1999                    ;;
2000                  *) continue ;;
2001                  esac
2002                  case " $deplibs " in
2003                  *" $path "*) ;;
2004                  *) deplibs="$deplibs $path" ;;
2005                  esac
2006                done
2007              fi # link_all_deplibs != no
2008            fi # linkmode = lib
2009          done # for deplib in $libs
2010          if test "$pass" = dlpreopen; then
2011            # Link the dlpreopened libraries before other libraries
2012            for deplib in $save_deplibs; do
2013              deplibs="$deplib $deplibs"
2014            done
2015          fi
2016          if test "$pass" != dlopen; then
2017            test "$pass" != scan && dependency_libs="$newdependency_libs"
2018            if test "$pass" != conv; then
2019              # Make sure lib_search_path contains only unique directories.
2020              lib_search_path=
2021              for dir in $newlib_search_path; do
2022                case "$lib_search_path " in
2023                *" $dir "*) ;;
2024                *) lib_search_path="$lib_search_path $dir" ;;
2025                esac
2026              done
2027              newlib_search_path=
2028            fi
2029    
2030            if test "$linkmode,$pass" != "prog,link"; then
2031              vars="deplibs"
2032            else
2033              vars="compile_deplibs finalize_deplibs"
2034            fi
2035            for var in $vars dependency_libs; do
2036              # Add libraries to $var in reverse order
2037              eval tmp_libs=\"\$$var\"
2038              new_libs=
2039              for deplib in $tmp_libs; do
2040                case $deplib in
2041                -L*) new_libs="$deplib $new_libs" ;;
2042                *)
2043                  case " $specialdeplibs " in
2044                  *" $deplib "*) new_libs="$deplib $new_libs" ;;
2045                  *)
2046                    case " $new_libs " in
2047                    *" $deplib "*) ;;
2048                    *) new_libs="$deplib $new_libs" ;;
2049                    esac
2050                    ;;
2051                  esac
2052                  ;;
2053                esac
2054              done
2055              tmp_libs=
2056              for deplib in $new_libs; do
2057                case $deplib in
2058                -L*)
2059                  case " $tmp_libs " in
2060                  *" $deplib "*) ;;
2061                  *) tmp_libs="$tmp_libs $deplib" ;;
2062                  esac
2063                  ;;
2064                *) tmp_libs="$tmp_libs $deplib" ;;
2065                esac
2066              done
2067              eval $var=\"$tmp_libs\"
2068            done # for var
2069          fi
2070          if test "$pass" = "conv" &&
2071           { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2072            libs="$deplibs" # reset libs
2073            deplibs=
2074          fi
2075        done # for pass
2076        if test "$linkmode" = prog; then
2077          dlfiles="$newdlfiles"
2078          dlprefiles="$newdlprefiles"
2079        fi
2080    
2081        case $linkmode in
2082        oldlib)
2083          if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2084            $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2085          fi
2086    
2087          if test -n "$rpath"; then
2088            $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2089          fi
2090    
2091          if test -n "$xrpath"; then
2092            $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2093          fi
2094    
2095          if test -n "$vinfo"; then
2096            $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2097          fi
2098    
2099          if test -n "$release"; then
2100            $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2101          fi
2102    
2103          if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2104            $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2105          fi
2106    
2107          # Now set the variables for building old libraries.
2108          build_libtool_libs=no
2109          oldlibs="$output"
2110          objs="$objs$old_deplibs"
2111          ;;
2112    
2113        lib)
2114          # Make sure we only generate libraries of the form `libNAME.la'.
2115          case $outputname in
2116          lib*)
2117            name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2118            eval libname=\"$libname_spec\"
2119            ;;
2120          *)
2121            if test "$module" = no; then
2122              $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2123              $echo "$help" 1>&2
2124              exit 1
2125            fi
2126            if test "$need_lib_prefix" != no; then
2127              # Add the "lib" prefix for modules if required
2128              name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2129              eval libname=\"$libname_spec\"
2130            else
2131              libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2132            fi
2133            ;;
2134          esac
2135    
2136          if test -n "$objs"; then
2137            if test "$deplibs_check_method" != pass_all; then
2138              $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2139              exit 1
2140            else
2141              echo
2142              echo "*** Warning: Linking the shared library $output against the non-libtool"
2143              echo "*** objects $objs is not portable!"
2144              libobjs="$libobjs $objs"
2145            fi
2146          fi
2147    
2148          if test "$dlself" != no; then
2149            $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2150          fi
2151    
2152          set dummy $rpath
2153          if test $# -gt 2; then
2154            $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2155          fi
2156          install_libdir="$2"
2157    
2158          oldlibs=
2159          if test -z "$rpath"; then
2160            if test "$build_libtool_libs" = yes; then
2161              # Building a libtool convenience library.
2162              libext=al
2163              oldlibs="$output_objdir/$libname.$libext $oldlibs"
2164              build_libtool_libs=convenience
2165              build_old_libs=yes
2166            fi
2167    
2168            if test -n "$vinfo"; then
2169              $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2170            fi
2171    
2172            if test -n "$release"; then
2173              $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2174            fi
2175          else
2176    
2177            # Parse the version information argument.
2178            IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2179            set dummy $vinfo 0 0 0
2180            IFS="$save_ifs"
2181    
2182            if test -n "$8"; then
2183              $echo "$modename: too many parameters to \`-version-info'" 1>&2
2184              $echo "$help" 1>&2
2185              exit 1
2186            fi
2187    
2188            current="$2"
2189            revision="$3"
2190            age="$4"
2191    
2192            # Check that each of the things are valid numbers.
2193            case $current in
2194            0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2195            *)
2196              $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2197              $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2198              exit 1
2199              ;;
2200            esac
2201    
2202            case $revision in
2203            0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2204            *)
2205              $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2206              $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2207              exit 1
2208              ;;
2209            esac
2210    
2211            case $age in
2212            0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2213            *)
2214              $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2215              $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2216              exit 1
2217              ;;
2218            esac
2219    
2220            if test $age -gt $current; then
2221              $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2222              $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2223              exit 1
2224            fi
2225    
2226            # Calculate the version variables.
2227            major=
2228            versuffix=
2229            verstring=
2230            case $version_type in
2231            none) ;;
2232    
2233            darwin)
2234              # Like Linux, but with the current version available in
2235              # verstring for coding it into the library header
2236              major=.`expr $current - $age`
2237              versuffix="$major.$age.$revision"
2238              # Darwin ld doesn't like 0 for these options...
2239              minor_current=`expr $current + 1`
2240              verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2241              ;;
2242    
2243            freebsd-aout)
2244              major=".$current"
2245              versuffix=".$current.$revision";
2246              ;;
2247    
2248            freebsd-elf)
2249              major=".$current"
2250              versuffix=".$current";
2251              ;;
2252    
2253            irix)
2254              major=`expr $current - $age + 1`
2255              verstring="sgi$major.$revision"
2256    
2257              # Add in all the interfaces that we are compatible with.
2258              loop=$revision
2259              while test $loop != 0; do
2260                iface=`expr $revision - $loop`
2261                loop=`expr $loop - 1`
2262                verstring="sgi$major.$iface:$verstring"
2263              done
2264    
2265              # Before this point, $major must not contain `.'.
2266              major=.$major
2267              versuffix="$major.$revision"
2268              ;;
2269    
2270            linux)
2271              major=.`expr $current - $age`
2272              versuffix="$major.$age.$revision"
2273              ;;
2274    
2275            osf)
2276              major=`expr $current - $age`
2277              versuffix=".$current.$age.$revision"
2278              verstring="$current.$age.$revision"
2279    
2280              # Add in all the interfaces that we are compatible with.
2281              loop=$age
2282              while test $loop != 0; do
2283                iface=`expr $current - $loop`
2284                loop=`expr $loop - 1`
2285                verstring="$verstring:${iface}.0"
2286              done
2287    
2288              # Make executables depend on our current version.
2289              verstring="$verstring:${current}.0"
2290              ;;
2291    
2292            sunos)
2293              major=".$current"
2294              versuffix=".$current.$revision"
2295              ;;
2296    
2297            windows)
2298              # Use '-' rather than '.', since we only want one
2299              # extension on DOS 8.3 filesystems.
2300              major=`expr $current - $age`
2301              versuffix="-$major"
2302              ;;
2303    
2304            *)
2305              $echo "$modename: unknown library version type \`$version_type'" 1>&2
2306              echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2307              exit 1
2308              ;;
2309            esac
2310    
2311            # Clear the version info if we defaulted, and they specified a release.
2312            if test -z "$vinfo" && test -n "$release"; then
2313              major=
2314              verstring="0.0"
2315              if test "$need_version" = no; then
2316                versuffix=
2317              else
2318                versuffix=".0.0"
2319              fi
2320            fi
2321    
2322            # Remove version info from name if versioning should be avoided
2323            if test "$avoid_version" = yes && test "$need_version" = no; then
2324              major=
2325              versuffix=
2326              verstring=""
2327            fi
2328    
2329            # Check to see if the archive will have undefined symbols.
2330            if test "$allow_undefined" = yes; then
2331              if test "$allow_undefined_flag" = unsupported; then
2332                $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2333                build_libtool_libs=no
2334                build_old_libs=yes
2335              fi
2336            else
2337              # Don't allow undefined symbols.
2338              allow_undefined_flag="$no_undefined_flag"
2339            fi
2340          fi
2341    
2342          if test "$mode" != relink; then
2343            # Remove our outputs.
2344            $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
2345            $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
2346          fi
2347    
2348          # Now set the variables for building old libraries.
2349          if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2350            oldlibs="$oldlibs $output_objdir/$libname.$libext"
2351    
2352            # Transform .lo files to .o files.
2353            oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2354          fi
2355    
2356          # Eliminate all temporary directories.
2357          for path in $notinst_path; do
2358            lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2359            deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2360            dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2361          done
2362    
2363          if test -n "$xrpath"; then
2364            # If the user specified any rpath flags, then add them.
2365            temp_xrpath=
2366            for libdir in $xrpath; do
2367              temp_xrpath="$temp_xrpath -R$libdir"
2368              case "$finalize_rpath " in
2369              *" $libdir "*) ;;
2370              *) finalize_rpath="$finalize_rpath $libdir" ;;
2371              esac
2372            done
2373            if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2374              dependency_libs="$temp_xrpath $dependency_libs"
2375            fi
2376          fi
2377    
2378          # Make sure dlfiles contains only unique files that won't be dlpreopened
2379          old_dlfiles="$dlfiles"
2380          dlfiles=
2381          for lib in $old_dlfiles; do
2382            case " $dlprefiles $dlfiles " in
2383            *" $lib "*) ;;
2384            *) dlfiles="$dlfiles $lib" ;;
2385            esac
2386          done
2387    
2388          # Make sure dlprefiles contains only unique files
2389          old_dlprefiles="$dlprefiles"
2390          dlprefiles=
2391          for lib in $old_dlprefiles; do
2392            case "$dlprefiles " in
2393            *" $lib "*) ;;
2394            *) dlprefiles="$dlprefiles $lib" ;;
2395            esac
2396          done
2397    
2398          if test "$build_libtool_libs" = yes; then
2399            if test -n "$rpath"; then
2400              case $host in
2401              *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2402                # these systems don't actually have a c library (as such)!
2403                ;;
2404              *-*-rhapsody* | *-*-darwin1.[012])
2405                # Rhapsody C library is in the System framework
2406                deplibs="$deplibs -framework System"
2407                ;;
2408              *-*-netbsd*)
2409                # Don't link with libc until the a.out ld.so is fixed.
2410                ;;
2411              *)
2412                # Add libc to deplibs on all other systems if necessary.
2413                if test "$build_libtool_need_lc" = "yes"; then
2414                  deplibs="$deplibs -lc"
2415                fi
2416                ;;
2417              esac
2418            fi
2419    
2420            # Transform deplibs into only deplibs that can be linked in shared.
2421            name_save=$name
2422            libname_save=$libname
2423            release_save=$release
2424            versuffix_save=$versuffix
2425            major_save=$major
2426            # I'm not sure if I'm treating the release correctly.  I think
2427            # release should show up in the -l (ie -lgmp5) so we don't want to
2428            # add it in twice.  Is that correct?
2429            release=""
2430            versuffix=""
2431            major=""
2432            newdeplibs=
2433            droppeddeps=no
2434            case $deplibs_check_method in
2435            pass_all)
2436              # Don't check for shared/static.  Everything works.
2437              # This might be a little naive.  We might want to check
2438              # whether the library exists or not.  But this is on
2439              # osf3 & osf4 and I'm not really sure... Just
2440              # implementing what was already the behaviour.
2441              newdeplibs=$deplibs
2442              ;;
2443            test_compile)
2444              # This code stresses the "libraries are programs" paradigm to its
2445              # limits. Maybe even breaks it.  We compile a program, linking it
2446              # against the deplibs as a proxy for the library.  Then we can check
2447              # whether they linked in statically or dynamically with ldd.
2448              $rm conftest.c
2449              cat > conftest.c <<EOF
2450              int main() { return 0; }
2451    EOF
2452              $rm conftest
2453              $CC -o conftest conftest.c $deplibs
2454              if test $? -eq 0 ; then
2455                ldd_output=`ldd conftest`
2456                for i in $deplibs; do
2457                  name="`expr $i : '-l\(.*\)'`"
2458                  # If $name is empty we are operating on a -L argument.
2459                  if test -n "$name" && test "$name" != "0"; then
2460                    libname=`eval \\$echo \"$libname_spec\"`
2461                    deplib_matches=`eval \\$echo \"$library_names_spec\"`
2462                    set dummy $deplib_matches
2463                    deplib_match=$2
2464                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2465                      newdeplibs="$newdeplibs $i"
2466                    else
2467                      droppeddeps=yes
2468                      echo
2469                      echo "*** Warning: This library needs some functionality provided by $i."
2470                      echo "*** I have the capability to make that library automatically link in when"
2471                      echo "*** you link to this library.  But I can only do this if you have a"
2472                      echo "*** shared version of the library, which you do not appear to have."
2473                    fi
2474                  else
2475                    newdeplibs="$newdeplibs $i"
2476                  fi
2477                done
2478              else
2479                # Error occured in the first compile.  Let's try to salvage the situation:
2480                # Compile a seperate program for each library.
2481                for i in $deplibs; do
2482                  name="`expr $i : '-l\(.*\)'`"
2483                 # If $name is empty we are operating on a -L argument.
2484                  if test -n "$name" && test "$name" != "0"; then
2485                    $rm conftest
2486                    $CC -o conftest conftest.c $i
2487                    # Did it work?
2488                    if test $? -eq 0 ; then
2489                      ldd_output=`ldd conftest`
2490                      libname=`eval \\$echo \"$libname_spec\"`
2491                      deplib_matches=`eval \\$echo \"$library_names_spec\"`
2492                      set dummy $deplib_matches
2493                      deplib_match=$2
2494                      if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2495                        newdeplibs="$newdeplibs $i"
2496                      else
2497                        droppeddeps=yes
2498                        echo
2499                        echo "*** Warning: This library needs some functionality provided by $i."
2500                        echo "*** I have the capability to make that library automatically link in when"
2501                        echo "*** you link to this library.  But I can only do this if you have a"
2502                        echo "*** shared version of the library, which you do not appear to have."
2503                      fi
2504                    else
2505                      droppeddeps=yes
2506                      echo
2507                      echo "*** Warning!  Library $i is needed by this library but I was not able to"
2508                      echo "***  make it link in!  You will probably need to install it or some"
2509                      echo "*** library that it depends on before this library will be fully"
2510                      echo "*** functional.  Installing it before continuing would be even better."
2511                    fi
2512                  else
2513                    newdeplibs="$newdeplibs $i"
2514                  fi
2515                done
2516              fi
2517              ;;
2518            file_magic*)
2519              set dummy $deplibs_check_method
2520              file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2521              for a_deplib in $deplibs; do
2522                name="`expr $a_deplib : '-l\(.*\)'`"
2523                # If $name is empty we are operating on a -L argument.
2524                if test -n "$name" && test "$name" != "0"; then
2525                  libname=`eval \\$echo \"$libname_spec\"`
2526                  for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2527                        potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2528                        for potent_lib in $potential_libs; do
2529                          # Follow soft links.
2530                          if ls -lLd "$potent_lib" 2>/dev/null \
2531                             | grep " -> " >/dev/null; then
2532                            continue
2533                          fi
2534                          # The statement above tries to avoid entering an
2535                          # endless loop below, in case of cyclic links.
2536                          # We might still enter an endless loop, since a link
2537                          # loop can be closed while we follow links,
2538                          # but so what?
2539                          potlib="$potent_lib"
2540                          while test -h "$potlib" 2>/dev/null; do
2541                            potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2542                            case $potliblink in
2543                            [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2544                            *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2545                            esac
2546                          done
2547                          if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2548                             | sed 10q \
2549                             | egrep "$file_magic_regex" > /dev/null; then
2550                            newdeplibs="$newdeplibs $a_deplib"
2551                            a_deplib=""
2552                            break 2
2553                          fi
2554                        done
2555                  done
2556                  if test -n "$a_deplib" ; then
2557                    droppeddeps=yes
2558                    echo
2559                    echo "*** Warning: This library needs some functionality provided by $a_deplib."
2560                    echo "*** I have the capability to make that library automatically link in when"
2561                    echo "*** you link to this library.  But I can only do this if you have a"
2562                    echo "*** shared version of the library, which you do not appear to have."
2563                  fi
2564                else
2565                  # Add a -L argument.
2566                  newdeplibs="$newdeplibs $a_deplib"
2567                fi
2568              done # Gone through all deplibs.
2569              ;;
2570            match_pattern*)
2571              set dummy $deplibs_check_method
2572              match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2573              for a_deplib in $deplibs; do
2574                name="`expr $a_deplib : '-l\(.*\)'`"
2575                # If $name is empty we are operating on a -L argument.
2576                if test -n "$name" && test "$name" != "0"; then
2577                  libname=`eval \\$echo \"$libname_spec\"`
2578                  for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2579                    potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2580                    for potent_lib in $potential_libs; do
2581                      if eval echo \"$potent_lib\" 2>/dev/null \
2582                          | sed 10q \
2583                          | egrep "$match_pattern_regex" > /dev/null; then
2584                        newdeplibs="$newdeplibs $a_deplib"
2585                        a_deplib=""
2586                        break 2
2587                      fi
2588                    done
2589                  done
2590                  if test -n "$a_deplib" ; then
2591                    droppeddeps=yes
2592                    echo
2593                    echo "*** Warning: This library needs some functionality provided by $a_deplib."
2594                    echo "*** I have the capability to make that library automatically link in when"
2595                    echo "*** you link to this library.  But I can only do this if you have a"
2596                    echo "*** shared version of the library, which you do not appear to have."
2597                  fi
2598                else
2599                  # Add a -L argument.
2600                  newdeplibs="$newdeplibs $a_deplib"
2601                fi
2602              done # Gone through all deplibs.
2603              ;;
2604            none | unknown | *)
2605              newdeplibs=""
2606              if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2607                   -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2608                 grep . >/dev/null; then
2609                echo
2610                if test "X$deplibs_check_method" = "Xnone"; then
2611                  echo "*** Warning: inter-library dependencies are not supported in this platform."
2612                else
2613                  echo "*** Warning: inter-library dependencies are not known to be supported."
2614                fi
2615                echo "*** All declared inter-library dependencies are being dropped."
2616                droppeddeps=yes
2617              fi
2618              ;;
2619            esac
2620            versuffix=$versuffix_save
2621            major=$major_save
2622            release=$release_save
2623            libname=$libname_save
2624            name=$name_save
2625    
2626            case $host in
2627            *-*-rhapsody* | *-*-darwin1.[012])
2628              # On Rhapsody replace the C library is the System framework
2629              newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
2630              ;;
2631            esac
2632    
2633            if test "$droppeddeps" = yes; then
2634              if test "$module" = yes; then
2635                echo
2636                echo "*** Warning: libtool could not satisfy all declared inter-library"
2637                echo "*** dependencies of module $libname.  Therefore, libtool will create"
2638                echo "*** a static module, that should work as long as the dlopening"
2639                echo "*** application is linked with the -dlopen flag."
2640                if test -z "$global_symbol_pipe"; then
2641                  echo
2642                  echo "*** However, this would only work if libtool was able to extract symbol"
2643                  echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2644                  echo "*** not find such a program.  So, this module is probably useless."
2645                  echo "*** \`nm' from GNU binutils and a full rebuild may help."
2646                fi
2647                if test "$build_old_libs" = no; then
2648                  oldlibs="$output_objdir/$libname.$libext"
2649                  build_libtool_libs=module
2650                  build_old_libs=yes
2651                else
2652                  build_libtool_libs=no
2653                fi
2654              else
2655                echo "*** The inter-library dependencies that have been dropped here will be"
2656                echo "*** automatically added whenever a program is linked with this library"
2657                echo "*** or is declared to -dlopen it."
2658    
2659                if test $allow_undefined = no; then
2660                  echo
2661                  echo "*** Since this library must not contain undefined symbols,"
2662                  echo "*** because either the platform does not support them or"
2663                  echo "*** it was explicitly requested with -no-undefined,"
2664                  echo "*** libtool will only create a static version of it."
2665                  if test "$build_old_libs" = no; then
2666                    oldlibs="$output_objdir/$libname.$libext"
2667                    build_libtool_libs=module
2668                    build_old_libs=yes
2669                  else
2670                    build_libtool_libs=no
2671                  fi
2672                fi
2673              fi
2674            fi
2675            # Done checking deplibs!
2676            deplibs=$newdeplibs
2677          fi
2678    
2679          # All the library-specific variables (install_libdir is set above).
2680          library_names=
2681          old_library=
2682          dlname=
2683    
2684          # Test again, we may have decided not to build it any more
2685          if test "$build_libtool_libs" = yes; then
2686            if test "$hardcode_into_libs" = yes; then
2687              # Hardcode the library paths
2688              hardcode_libdirs=
2689              dep_rpath=
2690              rpath="$finalize_rpath"
2691              test "$mode" != relink && rpath="$compile_rpath$rpath"
2692              for libdir in $rpath; do
2693                if test -n "$hardcode_libdir_flag_spec"; then
2694                  if test -n "$hardcode_libdir_separator"; then
2695                    if test -z "$hardcode_libdirs"; then
2696                      hardcode_libdirs="$libdir"
2697                    else
2698                      # Just accumulate the unique libdirs.
2699                      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
2700                      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
2701                        ;;
2702                      *)
2703                        hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
2704                        ;;
2705                      esac
2706                    fi
2707                  else
2708                    eval flag=\"$hardcode_libdir_flag_spec\"
2709                    dep_rpath="$dep_rpath $flag"
2710                  fi
2711                elif test -n "$runpath_var"; then
2712                  case "$perm_rpath " in
2713                  *" $libdir "*) ;;
2714                  *) perm_rpath="$perm_rpath $libdir" ;;
2715                  esac
2716                fi
2717              done
2718              # Substitute the hardcoded libdirs into the rpath.
2719              if test -n "$hardcode_libdir_separator" &&
2720                 test -n "$hardcode_libdirs"; then
2721                libdir="$hardcode_libdirs"
2722                eval dep_rpath=\"$hardcode_libdir_flag_spec\"
2723              fi
2724              if test -n "$runpath_var" && test -n "$perm_rpath"; then
2725                # We should set the runpath_var.
2726                rpath=
2727                for dir in $perm_rpath; do
2728                  rpath="$rpath$dir:"
2729                done
2730                eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
2731              fi
2732              test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
2733            fi
2734    
2735            shlibpath="$finalize_shlibpath"
2736            test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
2737            if test -n "$shlibpath"; then
2738              eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
2739            fi
2740    
2741            # Get the real and link names of the library.
2742            eval library_names=\"$library_names_spec\"
2743            set dummy $library_names
2744            realname="$2"
2745            shift; shift
2746    
2747            if test -n "$soname_spec"; then
2748              eval soname=\"$soname_spec\"
2749            else
2750              soname="$realname"
2751            fi
2752            test -z "$dlname" && dlname=$soname
2753    
2754            lib="$output_objdir/$realname"
2755            for link
2756            do
2757              linknames="$linknames $link"
2758            done
2759    
2760            # Ensure that we have .o objects for linkers which dislike .lo
2761            # (e.g. aix) in case we are running --disable-static
2762            for obj in $libobjs; do
2763              xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
2764              if test "X$xdir" = "X$obj"; then
2765                xdir="."
2766              else
2767                xdir="$xdir"
2768              fi
2769              baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
2770              oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
2771              if test ! -f $xdir/$oldobj; then
2772                $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
2773                $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
2774              fi
2775            done
2776    
2777            # Use standard objects if they are pic
2778            test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2779    
2780            # Prepare the list of exported symbols
2781            if test -z "$export_symbols"; then
2782              if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
2783                $show "generating symbol list for \`$libname.la'"
2784                export_symbols="$output_objdir/$libname.exp"
2785                $run $rm $export_symbols
2786                eval cmds=\"$export_symbols_cmds\"
2787                IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
2788                for cmd in $cmds; do
2789                  IFS="$save_ifs"
2790                  $show "$cmd"
2791                  $run eval "$cmd" || exit $?
2792                done
2793                IFS="$save_ifs"
2794                if test -n "$export_symbols_regex"; then
2795                  $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
2796                  $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
2797                  $show "$mv \"${export_symbols}T\" \"$export_symbols\""
2798                  $run eval '$mv "${export_symbols}T" "$export_symbols"'
2799                fi
2800              fi
2801            fi
2802    
2803            if test -n "$export_symbols" && test -n "$include_expsyms"; then
2804              $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
2805            fi
2806    
2807            if test -n "$convenience"; then
2808              if test -n "$whole_archive_flag_spec"; then
2809                eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
2810              else
2811                gentop="$output_objdir/${outputname}x"
2812                $show "${rm}r $gentop"
2813                $run ${rm}r "$gentop"
2814                $show "mkdir $gentop"
2815                $run mkdir "$gentop"
2816                status=$?
2817                if test $status -ne 0 && test ! -d "$gentop"; then
2818                  exit $status
2819                fi
2820                generated="$generated $gentop"
2821    
2822                for xlib in $convenience; do
2823                  # Extract the objects.
2824                  case $xlib in
2825                  [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
2826                  *) xabs=`pwd`"/$xlib" ;;
2827                  esac
2828                  xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
2829                  xdir="$gentop/$xlib"
2830    
2831                  $show "${rm}r $xdir"
2832                  $run ${rm}r "$xdir"
2833                  $show "mkdir $xdir"
2834                  $run mkdir "$xdir"
2835                  status=$?
2836                  if test $status -ne 0 && test ! -d "$xdir"; then
2837                    exit $status
2838                  fi
2839                  $show "(cd $xdir && $AR x $xabs)"
2840                  $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
2841    
2842                  libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
2843                done
2844              fi
2845            fi
2846    
2847            if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
2848              eval flag=\"$thread_safe_flag_spec\"
2849              linker_flags="$linker_flags $flag"
2850            fi
2851    
2852            # Make a backup of the uninstalled library when relinking
2853            if test "$mode" = relink; then
2854              $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
2855            fi
2856    
2857            # Do each of the archive commands.
2858            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
2859              eval cmds=\"$archive_expsym_cmds\"
2860            else
2861              eval cmds=\"$archive_cmds\"
2862            fi
2863            IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
2864            for cmd in $cmds; do
2865              IFS="$save_ifs"
2866              $show "$cmd"
2867              $run eval "$cmd" || exit $?
2868            done
2869            IFS="$save_ifs"
2870    
2871            # Restore the uninstalled library and exit
2872            if test "$mode" = relink; then
2873              $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
2874              exit 0
2875            fi
2876    
2877            # Create links to the real library.
2878            for linkname in $linknames; do
2879              if test "$realname" != "$linkname"; then
2880                $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
2881                $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
2882              fi
2883            done
2884    
2885            # If -module or -export-dynamic was specified, set the dlname.
2886            if test "$module" = yes || test "$export_dynamic" = yes; then
2887              # On all known operating systems, these are identical.
2888              dlname="$soname"
2889            fi
2890          fi
2891          ;;
2892    
2893        obj)
2894          if test -n "$deplibs"; then
2895            $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
2896          fi
2897    
2898          if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2899            $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
2900          fi
2901    
2902          if test -n "$rpath"; then
2903            $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
2904          fi
2905    
2906          if test -n "$xrpath"; then
2907            $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
2908          fi
2909    
2910          if test -n "$vinfo"; then
2911            $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
2912          fi
2913    
2914          if test -n "$release"; then
2915            $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
2916          fi
2917    
2918          case $output in
2919          *.lo)
2920            if test -n "$objs$old_deplibs"; then
2921              $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
2922              exit 1
2923            fi
2924            libobj="$output"
2925            obj=`$echo "X$output" | $Xsed -e "$lo2o"`
2926            ;;
2927          *)
2928            libobj=
2929            obj="$output"
2930            ;;
2931          esac
2932    
2933          # Delete the old objects.
2934          $run $rm $obj $libobj
2935    
2936          # Objects from convenience libraries.  This assumes
2937          # single-version convenience libraries.  Whenever we create
2938          # different ones for PIC/non-PIC, this we'll have to duplicate
2939          # the extraction.
2940          reload_conv_objs=
2941          gentop=
2942          # reload_cmds runs $LD directly, so let us get rid of
2943          # -Wl from whole_archive_flag_spec
2944          wl=
2945    
2946          if test -n "$convenience"; then
2947            if test -n "$whole_archive_flag_spec"; then
2948              eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
2949            else
2950              gentop="$output_objdir/${obj}x"
2951              $show "${rm}r $gentop"
2952              $run ${rm}r "$gentop"
2953              $show "mkdir $gentop"
2954              $run mkdir "$gentop"
2955              status=$?
2956              if test $status -ne 0 && test ! -d "$gentop"; then
2957                exit $status
2958              fi
2959              generated="$generated $gentop"
2960    
2961              for xlib in $convenience; do
2962                # Extract the objects.
2963                case $xlib in
2964                [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
2965                *) xabs=`pwd`"/$xlib" ;;
2966                esac
2967                xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
2968                xdir="$gentop/$xlib"
2969    
2970                $show "${rm}r $xdir"
2971                $run ${rm}r "$xdir"
2972                $show "mkdir $xdir"
2973                $run mkdir "$xdir"
2974                status=$?
2975                if test $status -ne 0 && test ! -d "$xdir"; then
2976                  exit $status
2977                fi
2978                $show "(cd $xdir && $AR x $xabs)"
2979                $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
2980    
2981                reload_conv_objs="$reload_objs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
2982              done
2983            fi
2984          fi
2985    
2986          # Create the old-style object.
2987          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
2988    
2989          output="$obj"
2990          eval cmds=\"$reload_cmds\"
2991          IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2992          for cmd in $cmds; do
2993            IFS="$save_ifs"
2994            $show "$cmd"
2995            $run eval "$cmd" || exit $?
2996          done
2997          IFS="$save_ifs"
2998    
2999          # Exit if we aren't doing a library object file.
3000          if test -z "$libobj"; then
3001            if test -n "$gentop"; then
3002              $show "${rm}r $gentop"
3003              $run ${rm}r $gentop
3004            fi
3005    
3006            exit 0
3007          fi
3008    
3009          if test "$build_libtool_libs" != yes; then
3010            if test -n "$gentop"; then
3011              $show "${rm}r $gentop"
3012              $run ${rm}r $gentop
3013            fi
3014    
3015            # Create an invalid libtool object if no PIC, so that we don't
3016            # accidentally link it into a program.
3017            $show "echo timestamp > $libobj"
3018            $run eval "echo timestamp > $libobj" || exit $?
3019            exit 0
3020          fi
3021    
3022          if test -n "$pic_flag" || test "$pic_mode" != default; then
3023            # Only do commands if we really have different PIC objects.
3024            reload_objs="$libobjs $reload_conv_objs"
3025            output="$libobj"
3026            eval cmds=\"$reload_cmds\"
3027            IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3028            for cmd in $cmds; do
3029              IFS="$save_ifs"
3030              $show "$cmd"
3031              $run eval "$cmd" || exit $?
3032            done
3033            IFS="$save_ifs"
3034          else
3035            # Just create a symlink.
3036            $show $rm $libobj
3037            $run $rm $libobj
3038            xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
3039            if test "X$xdir" = "X$libobj"; then
3040              xdir="."
3041            else
3042              xdir="$xdir"
3043            fi
3044            baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
3045            oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3046            $show "(cd $xdir && $LN_S $oldobj $baseobj)"
3047            $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
3048          fi
3049    
3050          if test -n "$gentop"; then
3051            $show "${rm}r $gentop"
3052            $run ${rm}r $gentop
3053          fi
3054    
3055          exit 0
3056          ;;
3057    
3058        prog)
3059          case $host in
3060            *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
3061          esac
3062          if test -n "$vinfo"; then
3063            $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
3064          fi
3065    
3066          if test -n "$release"; then
3067            $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
3068          fi
3069    
3070          if test "$preload" = yes; then
3071            if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
3072               test "$dlopen_self_static" = unknown; then
3073              $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
3074            fi
3075          fi
3076    
3077          case $host in
3078          *-*-rhapsody* | *-*-darwin1.[012])
3079            # On Rhapsody replace the C library is the System framework
3080            compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3081            finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3082            ;;
3083          esac
3084    
3085          compile_command="$compile_command $compile_deplibs"
3086          finalize_command="$finalize_command $finalize_deplibs"
3087    
3088          if test -n "$rpath$xrpath"; then
3089            # If the user specified any rpath flags, then add them.
3090            for libdir in $rpath $xrpath; do
3091              # This is the magic to use -rpath.
3092              case "$finalize_rpath " in
3093              *" $libdir "*) ;;
3094              *) finalize_rpath="$finalize_rpath $libdir" ;;
3095              esac
3096            done
3097          fi
3098    
3099          # Now hardcode the library paths
3100          rpath=
3101          hardcode_libdirs=
3102          for libdir in $compile_rpath $finalize_rpath; do
3103            if test -n "$hardcode_libdir_flag_spec"; then
3104              if test -n "$hardcode_libdir_separator"; then
3105                if test -z "$hardcode_libdirs"; then
3106                  hardcode_libdirs="$libdir"
3107                else
3108                  # Just accumulate the unique libdirs.
3109                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3110                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3111                    ;;
3112                  *)
3113                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3114                    ;;
3115                  esac
3116                fi
3117              else
3118                eval flag=\"$hardcode_libdir_flag_spec\"
3119                rpath="$rpath $flag"
3120              fi
3121            elif test -n "$runpath_var"; then
3122              case "$perm_rpath " in
3123              *" $libdir "*) ;;
3124              *) perm_rpath="$perm_rpath $libdir" ;;
3125              esac
3126            fi
3127            case $host in
3128            *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3129              case :$dllsearchpath: in
3130              *":$libdir:"*) ;;
3131              *) dllsearchpath="$dllsearchpath:$libdir";;
3132              esac
3133              ;;
3134            esac
3135          done
3136          # Substitute the hardcoded libdirs into the rpath.
3137          if test -n "$hardcode_libdir_separator" &&
3138             test -n "$hardcode_libdirs"; then
3139            libdir="$hardcode_libdirs"
3140            eval rpath=\" $hardcode_libdir_flag_spec\"
3141          fi
3142          compile_rpath="$rpath"
3143    
3144          rpath=
3145          hardcode_libdirs=
3146          for libdir in $finalize_rpath; do
3147            if test -n "$hardcode_libdir_flag_spec"; then
3148              if test -n "$hardcode_libdir_separator"; then
3149                if test -z "$hardcode_libdirs"; then
3150                  hardcode_libdirs="$libdir"
3151                else
3152                  # Just accumulate the unique libdirs.
3153                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3154                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3155                    ;;
3156                  *)
3157                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3158                    ;;
3159                  esac
3160                fi
3161              else
3162                eval flag=\"$hardcode_libdir_flag_spec\"
3163                rpath="$rpath $flag"
3164              fi
3165            elif test -n "$runpath_var"; then
3166              case "$finalize_perm_rpath " in
3167              *" $libdir "*) ;;
3168              *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
3169              esac
3170            fi
3171          done
3172          # Substitute the hardcoded libdirs into the rpath.
3173          if test -n "$hardcode_libdir_separator" &&
3174             test -n "$hardcode_libdirs"; then
3175            libdir="$hardcode_libdirs"
3176            eval rpath=\" $hardcode_libdir_flag_spec\"
3177          fi
3178          finalize_rpath="$rpath"
3179    
3180          if test -n "$libobjs" && test "$build_old_libs" = yes; then
3181            # Transform all the library objects into standard objects.
3182            compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3183            finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3184          fi
3185    
3186          dlsyms=
3187          if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3188            if test -n "$NM" && test -n "$global_symbol_pipe"; then
3189              dlsyms="${outputname}S.c"
3190            else
3191              $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
3192            fi
3193          fi
3194    
3195          if test -n "$dlsyms"; then
3196            case $dlsyms in
3197            "") ;;
3198            *.c)
3199              # Discover the nlist of each of the dlfiles.
3200              nlist="$output_objdir/${outputname}.nm"
3201    
3202              $show "$rm $nlist ${nlist}S ${nlist}T"
3203              $run $rm "$nlist" "${nlist}S" "${nlist}T"
3204    
3205              # Parse the name list into a source file.
3206              $show "creating $output_objdir/$dlsyms"
3207    
3208              test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
3209    /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
3210    /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
3211    
3212    #ifdef __cplusplus
3213    extern \"C\" {
3214    #endif
3215    
3216    /* Prevent the only kind of declaration conflicts we can make. */
3217    #define lt_preloaded_symbols some_other_symbol
3218    
3219    /* External symbol declarations for the compiler. */\
3220    "
3221    
3222              if test "$dlself" = yes; then
3223                $show "generating symbol list for \`$output'"
3224    
3225                test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
3226    
3227                # Add our own program objects to the symbol list.
3228                progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3229                for arg in $progfiles; do
3230                  $show "extracting global C symbols from \`$arg'"
3231                  $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3232                done
3233    
3234                if test -n "$exclude_expsyms"; then
3235                  $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3236                  $run eval '$mv "$nlist"T "$nlist"'
3237                fi
3238    
3239                if test -n "$export_symbols_regex"; then
3240                  $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3241                  $run eval '$mv "$nlist"T "$nlist"'
3242                fi
3243    
3244                # Prepare the list of exported symbols
3245                if test -z "$export_symbols"; then
3246                  export_symbols="$output_objdir/$output.exp"
3247                  $run $rm $export_symbols
3248                  $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3249                else
3250                  $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
3251                  $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
3252                  $run eval 'mv "$nlist"T "$nlist"'
3253                fi
3254              fi
3255    
3256              for arg in $dlprefiles; do
3257                $show "extracting global C symbols from \`$arg'"
3258                name=`echo "$arg" | sed -e 's%^.*/%%'`
3259                $run eval 'echo ": $name " >> "$nlist"'
3260                $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3261              done
3262    
3263              if test -z "$run"; then
3264                # Make sure we have at least an empty file.
3265                test -f "$nlist" || : > "$nlist"
3266    
3267                if test -n "$exclude_expsyms"; then
3268                  egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3269                  $mv "$nlist"T "$nlist"
3270                fi
3271    
3272                # Try sorting and uniquifying the output.
3273                if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
3274                  :
3275                else
3276                  grep -v "^: " < "$nlist" > "$nlist"S
3277                fi
3278    
3279                if test -f "$nlist"S; then
3280                  eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
3281                else
3282                  echo '/* NONE */' >> "$output_objdir/$dlsyms"
3283                fi
3284    
3285                $echo >> "$output_objdir/$dlsyms" "\
3286    
3287    #undef lt_preloaded_symbols
3288    
3289    #if defined (__STDC__) && __STDC__
3290    # define lt_ptr_t void *
3291    #else
3292    # define lt_ptr_t char *
3293    # define const
3294    #endif
3295    
3296    /* The mapping between symbol names and symbols. */
3297    const struct {
3298      const char *name;
3299      lt_ptr_t address;
3300    }
3301    lt_preloaded_symbols[] =
3302    {\
3303    "
3304    
3305                sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
3306                    -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
3307                      < "$nlist" >> "$output_objdir/$dlsyms"
3308    
3309                $echo >> "$output_objdir/$dlsyms" "\
3310      {0, (lt_ptr_t) 0}
3311    };
3312    
3313    /* This works around a problem in FreeBSD linker */
3314    #ifdef FREEBSD_WORKAROUND
3315    static const void *lt_preloaded_setup() {
3316      return lt_preloaded_symbols;
3317    }
3318    #endif
3319    
3320    #ifdef __cplusplus
3321    }
3322    #endif\
3323    "
3324              fi
3325    
3326              pic_flag_for_symtable=
3327              case $host in
3328              # compiling the symbol table file with pic_flag works around
3329              # a FreeBSD bug that causes programs to crash when -lm is
3330              # linked before any other PIC object.  But we must not use
3331              # pic_flag when linking with -static.  The problem exists in
3332              # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3333              *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3334                case "$compile_command " in
3335                *" -static "*) ;;
3336                *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
3337                esac;;
3338              *-*-hpux*)
3339                case "$compile_command " in
3340                *" -static "*) ;;
3341                *) pic_flag_for_symtable=" $pic_flag -DPIC";;
3342                esac
3343              esac
3344    
3345              # Now compile the dynamic symbol file.
3346              $show "(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
3347              $run eval '(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
3348    
3349              # Clean up the generated files.
3350              $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
3351              $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
3352    
3353              # Transform the symbol file into the correct name.
3354              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3355              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3356              ;;
3357            *)
3358              $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
3359              exit 1
3360              ;;
3361            esac
3362          else
3363            # We keep going just in case the user didn't refer to
3364            # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3365            # really was required.
3366    
3367            # Nullify the symbol file.
3368            compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3369            finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3370          fi
3371    
3372          if test $need_relink = no || test "$build_libtool_libs" != yes; then
3373            # Replace the output file specification.
3374            compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3375            link_command="$compile_command$compile_rpath"
3376    
3377            # We have no uninstalled library dependencies, so finalize right now.
3378            $show "$link_command"
3379            $run eval "$link_command"
3380            status=$?
3381    
3382            # Delete the generated files.
3383            if test -n "$dlsyms"; then
3384              $show "$rm $output_objdir/${outputname}S.${objext}"
3385              $run $rm "$output_objdir/${outputname}S.${objext}"
3386            fi
3387    
3388            exit $status
3389          fi
3390    
3391          if test -n "$shlibpath_var"; then
3392            # We should set the shlibpath_var
3393            rpath=
3394            for dir in $temp_rpath; do
3395              case $dir in
3396              [\\/]* | [A-Za-z]:[\\/]*)
3397                # Absolute path.
3398                rpath="$rpath$dir:"
3399                ;;
3400              *)
3401                # Relative path: add a thisdir entry.
3402                rpath="$rpath\$thisdir/$dir:"
3403                ;;
3404              esac
3405            done
3406            temp_rpath="$rpath"
3407          fi
3408    
3409          if test -n "$compile_shlibpath$finalize_shlibpath"; then
3410            compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
3411          fi
3412          if test -n "$finalize_shlibpath"; then
3413            finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
3414          fi
3415    
3416          compile_var=
3417          finalize_var=
3418          if test -n "$runpath_var"; then
3419            if test -n "$perm_rpath"; then
3420              # We should set the runpath_var.
3421              rpath=
3422              for dir in $perm_rpath; do
3423                rpath="$rpath$dir:"
3424              done
3425              compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
3426            fi
3427            if test -n "$finalize_perm_rpath"; then
3428              # We should set the runpath_var.
3429              rpath=
3430              for dir in $finalize_perm_rpath; do
3431                rpath="$rpath$dir:"
3432              done
3433              finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
3434            fi
3435          fi
3436    
3437          if test "$no_install" = yes; then
3438            # We don't need to create a wrapper script.
3439            link_command="$compile_var$compile_command$compile_rpath"
3440            # Replace the output file specification.
3441            link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3442            # Delete the old output file.
3443            $run $rm $output
3444            # Link the executable and exit
3445            $show "$link_command"
3446            $run eval "$link_command" || exit $?
3447            exit 0
3448          fi
3449    
3450          if test "$hardcode_action" = relink; then
3451            # Fast installation is not supported
3452            link_command="$compile_var$compile_command$compile_rpath"
3453            relink_command="$finalize_var$finalize_command$finalize_rpath"
3454    
3455            $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
3456            $echo "$modename: \`$output' will be relinked during installation" 1>&2
3457          else
3458            if test "$fast_install" != no; then
3459              link_command="$finalize_var$compile_command$finalize_rpath"
3460              if test "$fast_install" = yes; then
3461                relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
3462              else
3463                # fast_install is set to needless
3464                relink_command=
3465              fi
3466            else
3467              link_command="$compile_var$compile_command$compile_rpath"
3468              relink_command="$finalize_var$finalize_command$finalize_rpath"
3469            fi
3470          fi
3471    
3472          # Replace the output file specification.
3473          link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
3474    
3475          # Delete the old output files.
3476          $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
3477    
3478          $show "$link_command"
3479          $run eval "$link_command" || exit $?
3480    
3481          # Now create the wrapper script.
3482          $show "creating $output"
3483    
3484          # Quote the relink command for shipping.
3485          if test -n "$relink_command"; then
3486            # Preserve any variables that may affect compiler behavior
3487            for var in $variables_saved_for_relink; do
3488              if eval test -z \"\${$var+set}\"; then
3489                relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3490              elif eval var_value=\$$var; test -z "$var_value"; then
3491                relink_command="$var=; export $var; $relink_command"
3492              else
3493                var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3494                relink_command="$var=\"$var_value\"; export $var; $relink_command"
3495              fi
3496            done
3497            relink_command="cd `pwd`; $relink_command"
3498            relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3499          fi
3500    
3501          # Quote $echo for shipping.
3502          if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
3503            case $0 in
3504            [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
3505            *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
3506            esac
3507            qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
3508          else
3509            qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
3510          fi
3511    
3512          # Only actually do things if our run command is non-null.
3513          if test -z "$run"; then
3514            # win32 will think the script is a binary if it has
3515            # a .exe suffix, so we strip it off here.
3516            case $output in
3517              *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
3518            esac
3519            # test for cygwin because mv fails w/o .exe extensions
3520            case $host in
3521              *cygwin*) exeext=.exe ;;
3522              *) exeext= ;;
3523            esac
3524            $rm $output
3525            trap "$rm $output; exit 1" 1 2 15
3526    
3527            $echo > $output "\
3528    #! $SHELL
3529    
3530    # $output - temporary wrapper script for $objdir/$outputname
3531    # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3532    #
3533    # The $output program cannot be directly executed until all the libtool
3534    # libraries that it depends on are installed.
3535    #
3536    # This wrapper script should never be moved out of the build directory.
3537    # If it is, it will not operate correctly.
3538    
3539    # Sed substitution that helps us do robust quoting.  It backslashifies
3540    # metacharacters that are still active within double-quoted strings.
3541    Xsed='sed -e 1s/^X//'
3542    sed_quote_subst='$sed_quote_subst'
3543    
3544    # The HP-UX ksh and POSIX shell print the target directory to stdout
3545    # if CDPATH is set.
3546    if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
3547    
3548    relink_command=\"$relink_command\"
3549    
3550    # This environment variable determines our operation mode.
3551    if test \"\$libtool_install_magic\" = \"$magic\"; then
3552      # install mode needs the following variable:
3553      notinst_deplibs='$notinst_deplibs'
3554    else
3555      # When we are sourced in execute mode, \$file and \$echo are already set.
3556      if test \"\$libtool_execute_magic\" != \"$magic\"; then
3557        echo=\"$qecho\"
3558        file=\"\$0\"
3559        # Make sure echo works.
3560        if test \"X\$1\" = X--no-reexec; then
3561          # Discard the --no-reexec flag, and continue.
3562          shift
3563        elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
3564          # Yippee, \$echo works!
3565          :
3566        else
3567          # Restart under the correct shell, and then maybe \$echo will work.
3568          exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3569        fi
3570      fi\
3571    "
3572            $echo >> $output "\
3573    
3574      # Find the directory that this script lives in.
3575      thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3576      test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3577    
3578      # Follow symbolic links until we get to the real thisdir.
3579      file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
3580      while test -n \"\$file\"; do
3581        destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3582    
3583        # If there was a directory component, then change thisdir.
3584        if test \"x\$destdir\" != \"x\$file\"; then
3585          case \"\$destdir\" in
3586          [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3587          *) thisdir=\"\$thisdir/\$destdir\" ;;
3588          esac
3589        fi
3590    
3591        file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3592        file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
3593      done
3594    
3595      # Try to get the absolute directory name.
3596      absdir=\`cd \"\$thisdir\" && pwd\`
3597      test -n \"\$absdir\" && thisdir=\"\$absdir\"
3598    "
3599    
3600            if test "$fast_install" = yes; then
3601              echo >> $output "\
3602      program=lt-'$outputname'$exeext
3603      progdir=\"\$thisdir/$objdir\"
3604    
3605      if test ! -f \"\$progdir/\$program\" || \\
3606         { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
3607           test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3608    
3609        file=\"\$\$-\$program\"
3610    
3611        if test ! -d \"\$progdir\"; then
3612          $mkdir \"\$progdir\"
3613        else
3614          $rm \"\$progdir/\$file\"
3615        fi"
3616    
3617              echo >> $output "\
3618    
3619        # relink executable if necessary
3620        if test -n \"\$relink_command\"; then
3621          if (eval \$relink_command); then :
3622          else
3623            $rm \"\$progdir/\$file\"
3624            exit 1
3625          fi
3626        fi
3627    
3628        $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3629        { $rm \"\$progdir/\$program\";
3630          $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3631        $rm \"\$progdir/\$file\"
3632      fi"
3633            else
3634              echo >> $output "\
3635      program='$outputname'
3636      progdir=\"\$thisdir/$objdir\"
3637    "
3638            fi
3639    
3640            echo >> $output "\
3641    
3642      if test -f \"\$progdir/\$program\"; then"
3643    
3644            # Export our shlibpath_var if we have one.
3645            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3646              $echo >> $output "\
3647        # Add our own library path to $shlibpath_var
3648        $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3649    
3650        # Some systems cannot cope with colon-terminated $shlibpath_var
3651        # The second colon is a workaround for a bug in BeOS R4 sed
3652        $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3653    
3654        export $shlibpath_var
3655    "
3656            fi
3657    
3658            # fixup the dll searchpath if we need to.
3659            if test -n "$dllsearchpath"; then
3660              $echo >> $output "\
3661        # Add the dll search path components to the executable PATH
3662        PATH=$dllsearchpath:\$PATH
3663    "
3664            fi
3665    
3666            $echo >> $output "\
3667        if test \"\$libtool_execute_magic\" != \"$magic\"; then
3668          # Run the actual program with our arguments.
3669    "
3670            case $host in
3671            # win32 systems need to use the prog path for dll
3672            # lookup to work
3673            *-*-cygwin* | *-*-pw32*)
3674              $echo >> $output "\
3675          exec \$progdir/\$program \${1+\"\$@\"}
3676    "
3677              ;;
3678    
3679            # Backslashes separate directories on plain windows
3680            *-*-mingw | *-*-os2*)
3681              $echo >> $output "\
3682          exec \$progdir\\\\\$program \${1+\"\$@\"}
3683    "
3684              ;;
3685    
3686            *)
3687              $echo >> $output "\
3688          # Export the path to the program.
3689          PATH=\"\$progdir:\$PATH\"
3690          export PATH
3691    
3692          exec \$program \${1+\"\$@\"}
3693    "
3694              ;;
3695            esac
3696            $echo >> $output "\
3697          \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
3698          exit 1
3699        fi
3700      else
3701        # The program doesn't exist.
3702        \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
3703        \$echo \"This script is just a wrapper for \$program.\" 1>&2
3704        echo \"See the $PACKAGE documentation for more information.\" 1>&2
3705        exit 1
3706      fi
3707    fi\
3708    "
3709            chmod +x $output
3710          fi
3711          exit 0
3712          ;;
3713        esac
3714    
3715        # See if we need to build an old-fashioned archive.
3716        for oldlib in $oldlibs; do
3717    
3718          if test "$build_libtool_libs" = convenience; then
3719            oldobjs="$libobjs_save"
3720            addlibs="$convenience"
3721            build_libtool_libs=no
3722          else
3723            if test "$build_libtool_libs" = module; then
3724              oldobjs="$libobjs_save"
3725              build_libtool_libs=no
3726            else
3727              oldobjs="$objs$old_deplibs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
3728            fi
3729            addlibs="$old_convenience"
3730          fi
3731    
3732          if test -n "$addlibs"; then
3733            gentop="$output_objdir/${outputname}x"
3734            $show "${rm}r $gentop"
3735            $run ${rm}r "$gentop"
3736            $show "mkdir $gentop"
3737            $run mkdir "$gentop"
3738            status=$?
3739            if test $status -ne 0 && test ! -d "$gentop"; then
3740              exit $status
3741            fi
3742            generated="$generated $gentop"
3743    
3744            # Add in members from convenience archives.
3745            for xlib in $addlibs; do
3746              # Extract the objects.
3747              case $xlib in
3748              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3749              *) xabs=`pwd`"/$xlib" ;;
3750              esac
3751              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3752              xdir="$gentop/$xlib"
3753    
3754              $show "${rm}r $xdir"
3755              $run ${rm}r "$xdir"
3756              $show "mkdir $xdir"
3757              $run mkdir "$xdir"
3758              status=$?
3759              if test $status -ne 0 && test ! -d "$xdir"; then
3760                exit $status
3761              fi
3762              $show "(cd $xdir && $AR x $xabs)"
3763              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3764    
3765              oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
3766            done
3767          fi
3768    
3769          # Do each command in the archive commands.
3770          if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
3771            eval cmds=\"$old_archive_from_new_cmds\"
3772          else
3773            # Ensure that we have .o objects in place in case we decided
3774            # not to build a shared library, and have fallen back to building
3775            # static libs even though --disable-static was passed!
3776            for oldobj in $oldobjs; do
3777              if test ! -f $oldobj; then
3778                xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
3779                if test "X$xdir" = "X$oldobj"; then
3780                  xdir="."
3781                else
3782                  xdir="$xdir"
3783                fi
3784                baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
3785                obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
3786                $show "(cd $xdir && ${LN_S} $obj $baseobj)"
3787                $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
3788              fi
3789            done
3790    
3791            eval cmds=\"$old_archive_cmds\"
3792          fi
3793          IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3794          for cmd in $cmds; do
3795            IFS="$save_ifs"
3796            $show "$cmd"
3797            $run eval "$cmd" || exit $?
3798          done
3799          IFS="$save_ifs"
3800        done
3801    
3802        if test -n "$generated"; then
3803          $show "${rm}r$generated"
3804          $run ${rm}r$generated
3805        fi
3806    
3807        # Now create the libtool archive.
3808        case $output in
3809        *.la)
3810          old_library=
3811          test "$build_old_libs" = yes && old_library="$libname.$libext"
3812          $show "creating $output"
3813    
3814          # Preserve any variables that may affect compiler behavior
3815          for var in $variables_saved_for_relink; do
3816            if eval test -z \"\${$var+set}\"; then
3817              relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3818            elif eval var_value=\$$var; test -z "$var_value"; then
3819              relink_command="$var=; export $var; $relink_command"
3820            else
3821              var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3822              relink_command="$var=\"$var_value\"; export $var; $relink_command"
3823            fi
3824          done
3825          # Quote the link command for shipping.
3826          relink_command="cd `pwd`; $SHELL $0 --mode=relink $libtool_args"
3827          relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3828    
3829          # Only create the output if not a dry run.
3830          if test -z "$run"; then
3831            for installed in no yes; do
3832              if test "$installed" = yes; then
3833                if test -z "$install_libdir"; then
3834                  break
3835                fi
3836                output="$output_objdir/$outputname"i
3837                # Replace all uninstalled libtool libraries with the installed ones
3838                newdependency_libs=
3839                for deplib in $dependency_libs; do
3840                  case $deplib in
3841                  *.la)
3842                    name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
3843                    eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
3844                    if test -z "$libdir"; then
3845                      $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
3846                      exit 1
3847                    fi
3848                    newdependency_libs="$newdependency_libs $libdir/$name"
3849                    ;;
3850                  *) newdependency_libs="$newdependency_libs $deplib" ;;
3851                  esac
3852                done
3853                dependency_libs="$newdependency_libs"
3854                newdlfiles=
3855                for lib in $dlfiles; do
3856                  name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
3857                  eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
3858                  if test -z "$libdir"; then
3859                    $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
3860                    exit 1
3861                  fi
3862                  newdlfiles="$newdlfiles $libdir/$name"
3863                done
3864                dlfiles="$newdlfiles"
3865                newdlprefiles=
3866                for lib in $dlprefiles; do
3867                  name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
3868                  eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
3869                  if test -z "$libdir"; then
3870                    $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
3871                    exit 1
3872                  fi
3873                  newdlprefiles="$newdlprefiles $libdir/$name"
3874                done
3875                dlprefiles="$newdlprefiles"
3876              fi
3877              $rm $output
3878              # place dlname in correct position for cygwin
3879              tdlname=$dlname
3880              case $host,$output,$installed,$module,$dlname in
3881                *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
3882              esac
3883              $echo > $output "\
3884    # $outputname - a libtool library file
3885    # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3886    #
3887    # Please DO NOT delete this file!
3888    # It is necessary for linking the library.
3889    
3890    # The name that we can dlopen(3).
3891    dlname='$tdlname'
3892    
3893    # Names of this library.
3894    library_names='$library_names'
3895    
3896    # The name of the static archive.
3897    old_library='$old_library'
3898    
3899    # Libraries that this one depends upon.
3900    dependency_libs='$dependency_libs'
3901    
3902    # Version information for $libname.
3903    current=$current
3904    age=$age
3905    revision=$revision
3906    
3907    # Is this an already installed library?
3908    installed=$installed
3909    
3910    # Files to dlopen/dlpreopen
3911    dlopen='$dlfiles'
3912    dlpreopen='$dlprefiles'
3913    
3914    # Directory that this library needs to be installed in:
3915    libdir='$install_libdir'"
3916              if test "$installed" = no && test $need_relink = yes; then
3917                $echo >> $output "\
3918    relink_command=\"$relink_command\""
3919              fi
3920            done
3921          fi
3922    
3923          # Do a symbolic link so that the libtool archive can be found in
3924          # LD_LIBRARY_PATH before the program is installed.
3925          $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
3926          $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
3927          ;;
3928        esac
3929        exit 0
3930        ;;
3931    
3932      # libtool install mode
3933      install)
3934        modename="$modename: install"
3935    
3936        # There may be an optional sh(1) argument at the beginning of
3937        # install_prog (especially on Windows NT).
3938        if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
3939           # Allow the use of GNU shtool's install command.
3940           $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
3941          # Aesthetically quote it.
3942          arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
3943          case $arg in
3944          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
3945            arg="\"$arg\""
3946            ;;
3947          esac
3948          install_prog="$arg "
3949          arg="$1"
3950          shift
3951        else
3952          install_prog=
3953          arg="$nonopt"
3954        fi
3955    
3956        # The real first argument should be the name of the installation program.
3957        # Aesthetically quote it.
3958        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
3959        case $arg in
3960        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
3961          arg="\"$arg\""
3962          ;;
3963        esac
3964        install_prog="$install_prog$arg"
3965    
3966        # We need to accept at least all the BSD install flags.
3967        dest=
3968        files=
3969        opts=
3970        prev=
3971        install_type=
3972        isdir=no
3973        stripme=
3974        for arg
3975        do
3976          if test -n "$dest"; then
3977            files="$files $dest"
3978            dest="$arg"
3979            continue
3980          fi
3981    
3982          case $arg in
3983          -d) isdir=yes ;;
3984          -f) prev="-f" ;;
3985          -g) prev="-g" ;;
3986          -m) prev="-m" ;;
3987          -o) prev="-o" ;;
3988          -s)
3989            stripme=" -s"
3990            continue
3991            ;;
3992          -*) ;;
3993    
3994          *)
3995            # If the previous option needed an argument, then skip it.
3996            if test -n "$prev"; then
3997              prev=
3998            else
3999              dest="$arg"
4000              continue
4001            fi
4002            ;;
4003          esac
4004    
4005          # Aesthetically quote the argument.
4006          arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4007          case $arg in
4008          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4009            arg="\"$arg\""
4010            ;;
4011          esac
4012          install_prog="$install_prog $arg"
4013        done
4014    
4015        if test -z "$install_prog"; then
4016          $echo "$modename: you must specify an install program" 1>&2
4017          $echo "$help" 1>&2
4018          exit 1
4019        fi
4020    
4021        if test -n "$prev"; then
4022          $echo "$modename: the \`$prev' option requires an argument" 1>&2
4023          $echo "$help" 1>&2
4024          exit 1
4025        fi
4026    
4027        if test -z "$files"; then
4028          if test -z "$dest"; then
4029            $echo "$modename: no file or destination specified" 1>&2
4030          else
4031            $echo "$modename: you must specify a destination" 1>&2
4032          fi
4033          $echo "$help" 1>&2
4034          exit 1
4035        fi
4036    
4037        # Strip any trailing slash from the destination.
4038        dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
4039    
4040        # Check to see that the destination is a directory.
4041        test -d "$dest" && isdir=yes
4042        if test "$isdir" = yes; then
4043          destdir="$dest"
4044          destname=
4045        else
4046          destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
4047          test "X$destdir" = "X$dest" && destdir=.
4048          destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
4049    
4050          # Not a directory, so check to see that there is only one file specified.
4051          set dummy $files
4052          if test $# -gt 2; then
4053            $echo "$modename: \`$dest' is not a directory" 1>&2
4054            $echo "$help" 1>&2
4055            exit 1
4056          fi
4057        fi
4058        case $destdir in
4059        [\\/]* | [A-Za-z]:[\\/]*) ;;
4060        *)
4061          for file in $files; do
4062            case $file in
4063            *.lo) ;;
4064            *)
4065              $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
4066              $echo "$help" 1>&2
4067              exit 1
4068              ;;
4069            esac
4070          done
4071          ;;
4072        esac
4073    
4074        # This variable tells wrapper scripts just to set variables rather
4075        # than running their programs.
4076        libtool_install_magic="$magic"
4077    
4078        staticlibs=
4079        future_libdirs=
4080        current_libdirs=
4081        for file in $files; do
4082    
4083          # Do each installation.
4084          case $file in
4085          *.$libext)
4086            # Do the static libraries later.
4087            staticlibs="$staticlibs $file"
4088            ;;
4089    
4090          *.la)
4091            # Check to see that this really is a libtool archive.
4092            if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4093            else
4094              $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
4095              $echo "$help" 1>&2
4096              exit 1
4097            fi
4098    
4099            library_names=
4100            old_library=
4101            relink_command=
4102            # If there is no directory component, then add one.
4103            case $file in
4104            */* | *\\*) . $file ;;
4105            *) . ./$file ;;
4106            esac
4107    
4108            # Add the libdir to current_libdirs if it is the destination.
4109            if test "X$destdir" = "X$libdir"; then
4110              case "$current_libdirs " in
4111              *" $libdir "*) ;;
4112              *) current_libdirs="$current_libdirs $libdir" ;;
4113              esac
4114            else
4115              # Note the libdir as a future libdir.
4116              case "$future_libdirs " in
4117              *" $libdir "*) ;;
4118              *) future_libdirs="$future_libdirs $libdir" ;;
4119              esac
4120            fi
4121    
4122            dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
4123            test "X$dir" = "X$file/" && dir=
4124            dir="$dir$objdir"
4125    
4126            if test -n "$relink_command"; then
4127              $echo "$modename: warning: relinking \`$file'" 1>&2
4128              $show "$relink_command"
4129              if $run eval "$relink_command"; then :
4130              else
4131                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4132                continue
4133              fi
4134            fi
4135    
4136            # See the names of the shared library.
4137            set dummy $library_names
4138            if test -n "$2"; then
4139              realname="$2"
4140              shift
4141              shift
4142    
4143              srcname="$realname"
4144              test -n "$relink_command" && srcname="$realname"T
4145    
4146              # Install the shared library and build the symlinks.
4147              $show "$install_prog $dir/$srcname $destdir/$realname"
4148              $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
4149              if test -n "$stripme" && test -n "$striplib"; then
4150                $show "$striplib $destdir/$realname"
4151                $run eval "$striplib $destdir/$realname" || exit $?
4152              fi
4153    
4154              if test $# -gt 0; then
4155                # Delete the old symlinks, and create new ones.
4156                for linkname
4157                do
4158                  if test "$linkname" != "$realname"; then
4159                    $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4160                    $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4161                  fi
4162                done
4163              fi
4164    
4165              # Do each command in the postinstall commands.
4166              lib="$destdir/$realname"
4167              eval cmds=\"$postinstall_cmds\"
4168              IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4169              for cmd in $cmds; do
4170                IFS="$save_ifs"
4171                $show "$cmd"
4172                $run eval "$cmd" || exit $?
4173              done
4174              IFS="$save_ifs"
4175            fi
4176    
4177            # Install the pseudo-library for information purposes.
4178            name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4179            instname="$dir/$name"i
4180            $show "$install_prog $instname $destdir/$name"
4181            $run eval "$install_prog $instname $destdir/$name" || exit $?
4182    
4183            # Maybe install the static library, too.
4184            test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
4185            ;;
4186    
4187          *.lo)
4188            # Install (i.e. copy) a libtool object.
4189    
4190            # Figure out destination file name, if it wasn't already specified.
4191            if test -n "$destname"; then
4192              destfile="$destdir/$destname"
4193            else
4194              destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4195              destfile="$destdir/$destfile"
4196            fi
4197    
4198            # Deduce the name of the destination old-style object file.
4199            case $destfile in
4200            *.lo)
4201              staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
4202              ;;
4203            *.$objext)
4204              staticdest="$destfile"
4205              destfile=
4206              ;;
4207            *)
4208              $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
4209              $echo "$help" 1>&2
4210              exit 1
4211              ;;
4212            esac
4213    
4214            # Install the libtool object if requested.
4215            if test -n "$destfile"; then
4216              $show "$install_prog $file $destfile"
4217              $run eval "$install_prog $file $destfile" || exit $?
4218            fi
4219    
4220            # Install the old object if enabled.
4221            if test "$build_old_libs" = yes; then
4222              # Deduce the name of the old-style object file.
4223              staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
4224    
4225              $show "$install_prog $staticobj $staticdest"
4226              $run eval "$install_prog \$staticobj \$staticdest" || exit $?
4227            fi
4228            exit 0
4229            ;;
4230    
4231          *)
4232            # Figure out destination file name, if it wasn't already specified.
4233            if test -n "$destname"; then
4234              destfile="$destdir/$destname"
4235            else
4236              destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4237              destfile="$destdir/$destfile"
4238            fi
4239    
4240            # Do a test to see if this is really a libtool program.
4241            if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4242              notinst_deplibs=
4243              relink_command=
4244    
4245              # If there is no directory component, then add one.
4246              case $file in
4247              */* | *\\*) . $file ;;
4248              *) . ./$file ;;
4249              esac
4250    
4251              # Check the variables that should have been set.
4252              if test -z "$notinst_deplibs"; then
4253                $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
4254                exit 1
4255              fi
4256    
4257              finalize=yes
4258              for lib in $notinst_deplibs; do
4259                # Check to see that each library is installed.
4260                libdir=
4261                if test -f "$lib"; then
4262                  # If there is no directory component, then add one.
4263                  case $lib in
4264                  */* | *\\*) . $lib ;;
4265                  *) . ./$lib ;;
4266                  esac
4267                fi
4268                libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
4269                if test -n "$libdir" && test ! -f "$libfile"; then
4270                  $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
4271                  finalize=no
4272                fi
4273              done
4274    
4275              relink_command=
4276              # If there is no directory component, then add one.
4277              case $file in
4278              */* | *\\*) . $file ;;
4279              *) . ./$file ;;
4280              esac
4281    
4282              outputname=
4283              if test "$fast_install" = no && test -n "$relink_command"; then
4284                if test "$finalize" = yes && test -z "$run"; then
4285                  tmpdir="/tmp"
4286                  test -n "$TMPDIR" && tmpdir="$TMPDIR"
4287                  tmpdir="$tmpdir/libtool-$$"
4288                  if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
4289                  else
4290                    $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
4291                    continue
4292                  fi
4293                  file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4294                  outputname="$tmpdir/$file"
4295                  # Replace the output file specification.
4296                  relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
4297    
4298                  $show "$relink_command"
4299                  if $run eval "$relink_command"; then :
4300                  else
4301                    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4302                    ${rm}r "$tmpdir"
4303                    continue
4304                  fi
4305                  file="$outputname"
4306                else
4307                  $echo "$modename: warning: cannot relink \`$file'" 1>&2
4308                fi
4309              else
4310                # Install the binary that we compiled earlier.
4311                file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
4312              fi
4313            fi
4314    
4315            # remove .exe since cygwin /usr/bin/install will append another
4316            # one anyways
4317            case $install_prog,$host in
4318            /usr/bin/install*,*cygwin*)
4319              case $file:$destfile in
4320              *.exe:*.exe)
4321                # this is ok
4322                ;;
4323              *.exe:*)
4324                destfile=$destfile.exe
4325                ;;
4326              *:*.exe)
4327                destfile=`echo $destfile | sed -e 's,.exe$,,'`
4328                ;;
4329              esac
4330              ;;
4331            esac
4332            $show "$install_prog$stripme $file $destfile"
4333            $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
4334            test -n "$outputname" && ${rm}r "$tmpdir"
4335            ;;
4336          esac
4337        done
4338    
4339        for file in $staticlibs; do
4340          name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4341    
4342          # Set up the ranlib parameters.
4343          oldlib="$destdir/$name"
4344    
4345          $show "$install_prog $file $oldlib"
4346          $run eval "$install_prog \$file \$oldlib" || exit $?
4347    
4348          if test -n "$stripme" && test -n "$striplib"; then
4349            $show "$old_striplib $oldlib"
4350            $run eval "$old_striplib $oldlib" || exit $?
4351          fi
4352    
4353          # Do each command in the postinstall commands.
4354          eval cmds=\"$old_postinstall_cmds\"
4355          IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4356          for cmd in $cmds; do
4357            IFS="$save_ifs"
4358            $show "$cmd"
4359            $run eval "$cmd" || exit $?
4360          done
4361          IFS="$save_ifs"
4362        done
4363    
4364        if test -n "$future_libdirs"; then
4365          $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
4366        fi
4367    
4368        if test -n "$current_libdirs"; then
4369          # Maybe just do a dry run.
4370          test -n "$run" && current_libdirs=" -n$current_libdirs"
4371          exec $SHELL $0 --finish$current_libdirs
4372          exit 1
4373        fi
4374    
4375        exit 0
4376        ;;
4377    
4378      # libtool finish mode
4379      finish)
4380        modename="$modename: finish"
4381        libdirs="$nonopt"
4382        admincmds=
4383    
4384        if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4385          for dir
4386          do
4387            libdirs="$libdirs $dir"
4388          done
4389    
4390          for libdir in $libdirs; do
4391            if test -n "$finish_cmds"; then
4392              # Do each command in the finish commands.
4393              eval cmds=\"$finish_cmds\"
4394              IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4395              for cmd in $cmds; do
4396                IFS="$save_ifs"
4397                $show "$cmd"
4398                $run eval "$cmd" || admincmds="$admincmds
4399           $cmd"
4400              done
4401              IFS="$save_ifs"
4402            fi
4403            if test -n "$finish_eval"; then
4404              # Do the single finish_eval.
4405              eval cmds=\"$finish_eval\"
4406              $run eval "$cmds" || admincmds="$admincmds
4407           $cmds"
4408            fi
4409          done
4410        fi
4411    
4412        # Exit here if they wanted silent mode.
4413        test "$show" = ":" && exit 0
4414    
4415        echo "----------------------------------------------------------------------"
4416        echo "Libraries have been installed in:"
4417        for libdir in $libdirs; do
4418          echo "   $libdir"
4419        done
4420        echo
4421        echo "If you ever happen to want to link against installed libraries"
4422        echo "in a given directory, LIBDIR, you must either use libtool, and"
4423        echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
4424        echo "flag during linking and do at least one of the following:"
4425        if test -n "$shlibpath_var"; then
4426          echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
4427          echo "     during execution"
4428        fi
4429        if test -n "$runpath_var"; then
4430          echo "   - add LIBDIR to the \`$runpath_var' environment variable"
4431          echo "     during linking"
4432        fi
4433        if test -n "$hardcode_libdir_flag_spec"; then
4434          libdir=LIBDIR
4435          eval flag=\"$hardcode_libdir_flag_spec\"
4436    
4437          echo "   - use the \`$flag' linker flag"
4438        fi
4439        if test -n "$admincmds"; then
4440          echo "   - have your system administrator run these commands:$admincmds"
4441        fi
4442        if test -f /etc/ld.so.conf; then
4443          echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
4444        fi
4445        echo
4446        echo "See any operating system documentation about shared libraries for"
4447        echo "more information, such as the ld(1) and ld.so(8) manual pages."
4448        echo "----------------------------------------------------------------------"
4449        exit 0
4450        ;;
4451    
4452      # libtool execute mode
4453      execute)
4454        modename="$modename: execute"
4455    
4456        # The first argument is the command name.
4457        cmd="$nonopt"
4458        if test -z "$cmd"; then
4459          $echo "$modename: you must specify a COMMAND" 1>&2
4460          $echo "$help"
4461          exit 1
4462        fi
4463    
4464        # Handle -dlopen flags immediately.
4465        for file in $execute_dlfiles; do
4466          if test ! -f "$file"; then
4467            $echo "$modename: \`$file' is not a file" 1>&2
4468            $echo "$help" 1>&2
4469            exit 1
4470          fi
4471    
4472          dir=
4473          case $file in
4474          *.la)
4475            # Check to see that this really is a libtool archive.
4476            if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4477            else
4478              $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4479              $echo "$help" 1>&2
4480              exit 1
4481            fi
4482    
4483            # Read the libtool library.
4484            dlname=
4485            library_names=
4486    
4487            # If there is no directory component, then add one.
4488            case $file in
4489            */* | *\\*) . $file ;;
4490            *) . ./$file ;;
4491            esac
4492    
4493            # Skip this library if it cannot be dlopened.
4494            if test -z "$dlname"; then
4495              # Warn if it was a shared library.
4496              test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
4497              continue
4498            fi
4499    
4500            dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4501            test "X$dir" = "X$file" && dir=.
4502    
4503            if test -f "$dir/$objdir/$dlname"; then
4504              dir="$dir/$objdir"
4505            else
4506              $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
4507              exit 1
4508            fi
4509            ;;
4510    
4511          *.lo)
4512            # Just add the directory containing the .lo file.
4513            dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4514            test "X$dir" = "X$file" && dir=.
4515            ;;
4516    
4517          *)
4518            $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
4519            continue
4520            ;;
4521          esac
4522    
4523          # Get the absolute pathname.
4524          absdir=`cd "$dir" && pwd`
4525          test -n "$absdir" && dir="$absdir"
4526    
4527          # Now add the directory to shlibpath_var.
4528          if eval "test -z \"\$$shlibpath_var\""; then
4529            eval "$shlibpath_var=\"\$dir\""
4530          else
4531            eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
4532          fi
4533        done
4534    
4535        # This variable tells wrapper scripts just to set shlibpath_var
4536        # rather than running their programs.
4537        libtool_execute_magic="$magic"
4538    
4539        # Check if any of the arguments is a wrapper script.
4540        args=
4541        for file
4542        do
4543          case $file in
4544          -*) ;;
4545          *)
4546            # Do a test to see if this is really a libtool program.
4547            if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4548              # If there is no directory component, then add one.
4549              case $file in
4550              */* | *\\*) . $file ;;
4551              *) . ./$file ;;
4552              esac
4553    
4554              # Transform arg to wrapped name.
4555              file="$progdir/$program"
4556            fi
4557            ;;
4558          esac
4559          # Quote arguments (to preserve shell metacharacters).
4560          file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
4561          args="$args \"$file\""
4562        done
4563    
4564        if test -z "$run"; then
4565          if test -n "$shlibpath_var"; then
4566            # Export the shlibpath_var.
4567            eval "export $shlibpath_var"
4568          fi
4569    
4570          # Restore saved enviroment variables
4571          if test "${save_LC_ALL+set}" = set; then
4572            LC_ALL="$save_LC_ALL"; export LC_ALL
4573          fi
4574          if test "${save_LANG+set}" = set; then
4575            LANG="$save_LANG"; export LANG
4576          fi
4577    
4578          # Now actually exec the command.
4579          eval "exec \$cmd$args"
4580    
4581          $echo "$modename: cannot exec \$cmd$args"
4582          exit 1
4583        else
4584          # Display what would be done.
4585          if test -n "$shlibpath_var"; then
4586            eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
4587            $echo "export $shlibpath_var"
4588          fi
4589          $echo "$cmd$args"
4590          exit 0
4591        fi
4592        ;;
4593    
4594      # libtool clean and uninstall mode
4595      clean | uninstall)
4596        modename="$modename: $mode"
4597        rm="$nonopt"
4598        files=
4599        rmforce=
4600        exit_status=0
4601    
4602        # This variable tells wrapper scripts just to set variables rather
4603        # than running their programs.
4604        libtool_install_magic="$magic"
4605    
4606        for arg
4607        do
4608          case $arg in
4609          -f) rm="$rm $arg"; rmforce=yes ;;
4610          -*) rm="$rm $arg" ;;
4611          *) files="$files $arg" ;;
4612          esac
4613        done
4614    
4615        if test -z "$rm"; then
4616          $echo "$modename: you must specify an RM program" 1>&2
4617          $echo "$help" 1>&2
4618          exit 1
4619        fi
4620    
4621        rmdirs=
4622    
4623        for file in $files; do
4624          dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4625          if test "X$dir" = "X$file"; then
4626            dir=.
4627            objdir="$objdir"
4628          else
4629            objdir="$dir/$objdir"
4630          fi
4631          name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4632          test $mode = uninstall && objdir="$dir"
4633    
4634          # Remember objdir for removal later, being careful to avoid duplicates
4635          if test $mode = clean; then
4636            case " $rmdirs " in
4637              *" $objdir "*) ;;
4638              *) rmdirs="$rmdirs $objdir" ;;
4639            esac
4640          fi
4641    
4642          # Don't error if the file doesn't exist and rm -f was used.
4643          if (test -L "$file") >/dev/null 2>&1 \
4644            || (test -h "$file") >/dev/null 2>&1 \
4645            || test -f "$file"; then
4646            :
4647          elif test -d "$file"; then
4648            exit_status=1
4649            continue
4650          elif test "$rmforce" = yes; then
4651            continue
4652          fi
4653    
4654          rmfiles="$file"
4655    
4656          case $name in
4657          *.la)
4658            # Possibly a libtool archive, so verify it.
4659            if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4660              . $dir/$name
4661    
4662              # Delete the libtool libraries and symlinks.
4663              for n in $library_names; do
4664                rmfiles="$rmfiles $objdir/$n"
4665              done
4666              test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
4667              test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
4668    
4669              if test $mode = uninstall; then
4670                if test -n "$library_names"; then
4671                  # Do each command in the postuninstall commands.
4672                  eval cmds=\"$postuninstall_cmds\"
4673                  IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4674                  for cmd in $cmds; do
4675                    IFS="$save_ifs"
4676                    $show "$cmd"
4677                    $run eval "$cmd"
4678                    if test $? != 0 && test "$rmforce" != yes; then
4679                      exit_status=1
4680                    fi
4681                  done
4682                  IFS="$save_ifs"
4683                fi
4684    
4685                if test -n "$old_library"; then
4686                  # Do each command in the old_postuninstall commands.
4687                  eval cmds=\"$old_postuninstall_cmds\"
4688                  IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4689                  for cmd in $cmds; do
4690                    IFS="$save_ifs"
4691                    $show "$cmd"
4692                    $run eval "$cmd"
4693                    if test $? != 0 && test "$rmforce" != yes; then
4694                      exit_status=1
4695                    fi
4696                  done
4697                  IFS="$save_ifs"
4698                fi
4699                # FIXME: should reinstall the best remaining shared library.
4700              fi
4701            fi
4702            ;;
4703    
4704          *.lo)
4705            if test "$build_old_libs" = yes; then
4706              oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
4707              rmfiles="$rmfiles $dir/$oldobj"
4708            fi
4709            ;;
4710    
4711          *)
4712            # Do a test to see if this is a libtool program.
4713            if test $mode = clean &&
4714               (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4715              relink_command=
4716              . $dir/$file
4717    
4718              rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
4719              if test "$fast_install" = yes && test -n "$relink_command"; then
4720                rmfiles="$rmfiles $objdir/lt-$name"
4721              fi
4722            fi
4723            ;;
4724          esac
4725          $show "$rm $rmfiles"
4726          $run $rm $rmfiles || exit_status=1
4727        done
4728    
4729        # Try to remove the ${objdir}s in the directories where we deleted files
4730        for dir in $rmdirs; do
4731          if test -d "$dir"; then
4732            $show "rmdir $dir"
4733            $run rmdir $dir >/dev/null 2>&1
4734          fi
4735        done
4736    
4737        exit $exit_status
4738        ;;
4739    
4740      "")
4741        $echo "$modename: you must specify a MODE" 1>&2
4742        $echo "$generic_help" 1>&2
4743        exit 1
4744        ;;
4745      esac
4746    
4747      $echo "$modename: invalid operation mode \`$mode'" 1>&2
4748      $echo "$generic_help" 1>&2
4749      exit 1
4750    fi # test -z "$show_help"
4751    
4752    # We need to display help for each of the modes.
4753    case $mode in
4754    "") $echo \
4755    "Usage: $modename [OPTION]... [MODE-ARG]...
4756    
4757    Provide generalized library-building support services.
4758    
4759        --config          show all configuration variables
4760        --debug           enable verbose shell tracing
4761    -n, --dry-run         display commands without modifying any files
4762        --features        display basic configuration information and exit
4763        --finish          same as \`--mode=finish'
4764        --help            display this help message and exit
4765        --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
4766        --quiet           same as \`--silent'
4767        --silent          don't print informational messages
4768        --version         print version information
4769    
4770    MODE must be one of the following:
4771    
4772          clean           remove files from the build directory
4773          compile         compile a source file into a libtool object
4774          execute         automatically set library path, then run a program
4775          finish          complete the installation of libtool libraries
4776          install         install libraries or executables
4777          link            create a library or an executable
4778          uninstall       remove libraries from an installed directory
4779    
4780    MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
4781    a more detailed description of MODE."
4782      exit 0
4783      ;;
4784    
4785    clean)
4786      $echo \
4787    "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
4788    
4789    Remove files from the build directory.
4790    
4791    RM is the name of the program to use to delete files associated with each FILE
4792    (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
4793    to RM.
4794    
4795    If FILE is a libtool library, object or program, all the files associated
4796    with it are deleted. Otherwise, only FILE itself is deleted using RM."
4797      ;;
4798    
4799    compile)
4800      $echo \
4801    "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
4802    
4803    Compile a source file into a libtool library object.
4804    
4805    This mode accepts the following additional options:
4806    
4807      -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
4808      -prefer-pic       try to building PIC objects only
4809      -prefer-non-pic   try to building non-PIC objects only
4810      -static           always build a \`.o' file suitable for static linking
4811    
4812    COMPILE-COMMAND is a command to be used in creating a \`standard' object file
4813    from the given SOURCEFILE.
4814    
4815    The output file name is determined by removing the directory component from
4816    SOURCEFILE, then substituting the C source code suffix \`.c' with the
4817    library object suffix, \`.lo'."
4818      ;;
4819    
4820    execute)
4821      $echo \
4822    "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
4823    
4824    Automatically set library path, then run a program.
4825    
4826    This mode accepts the following additional options:
4827    
4828      -dlopen FILE      add the directory containing FILE to the library path
4829    
4830    This mode sets the library path environment variable according to \`-dlopen'
4831    flags.
4832    
4833    If any of the ARGS are libtool executable wrappers, then they are translated
4834    into their corresponding uninstalled binary, and any of their required library
4835    directories are added to the library path.
4836    
4837    Then, COMMAND is executed, with ARGS as arguments."
4838      ;;
4839    
4840    finish)
4841      $echo \
4842    "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
4843    
4844    Complete the installation of libtool libraries.
4845    
4846    Each LIBDIR is a directory that contains libtool libraries.
4847    
4848    The commands that this mode executes may require superuser privileges.  Use
4849    the \`--dry-run' option if you just want to see what would be executed."
4850      ;;
4851    
4852    install)
4853      $echo \
4854    "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
4855    
4856    Install executables or libraries.
4857    
4858    INSTALL-COMMAND is the installation command.  The first component should be
4859    either the \`install' or \`cp' program.
4860    
4861    The rest of the components are interpreted as arguments to that command (only
4862    BSD-compatible install options are recognized)."
4863      ;;
4864    
4865    link)
4866      $echo \
4867    "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
4868    
4869    Link object files or libraries together to form another library, or to
4870    create an executable program.
4871    
4872    LINK-COMMAND is a command using the C compiler that you would use to create
4873    a program from several object files.
4874    
4875    The following components of LINK-COMMAND are treated specially:
4876    
4877      -all-static       do not do any dynamic linking at all
4878      -avoid-version    do not add a version suffix if possible
4879      -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
4880      -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
4881      -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
4882      -export-symbols SYMFILE
4883                        try to export only the symbols listed in SYMFILE
4884      -export-symbols-regex REGEX
4885                        try to export only the symbols matching REGEX
4886      -LLIBDIR          search LIBDIR for required installed libraries
4887      -lNAME            OUTPUT-FILE requires the installed library libNAME
4888      -module           build a library that can dlopened
4889      -no-fast-install  disable the fast-install mode
4890      -no-install       link a not-installable executable
4891      -no-undefined     declare that a library does not refer to external symbols
4892      -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
4893      -release RELEASE  specify package release information
4894      -rpath LIBDIR     the created library will eventually be installed in LIBDIR
4895      -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
4896      -static           do not do any dynamic linking of libtool libraries
4897      -version-info CURRENT[:REVISION[:AGE]]
4898                        specify library version info [each variable defaults to 0]
4899    
4900    All other options (arguments beginning with \`-') are ignored.
4901    
4902    Every other argument is treated as a filename.  Files ending in \`.la' are
4903    treated as uninstalled libtool libraries, other files are standard or library
4904    object files.
4905    
4906    If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
4907    only library objects (\`.lo' files) may be specified, and \`-rpath' is
4908    required, except when creating a convenience library.
4909    
4910    If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
4911    using \`ar' and \`ranlib', or on Windows using \`lib'.
4912    
4913    If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
4914    is created, otherwise an executable program is created."
4915      ;;
4916    
4917    uninstall)
4918      $echo \
4919    "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
4920    
4921    Remove libraries from an installation directory.
4922    
4923    RM is the name of the program to use to delete files associated with each FILE
4924    (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
4925    to RM.
4926    
4927    If FILE is a libtool library, all the files associated with it are deleted.
4928    Otherwise, only FILE itself is deleted using RM."
4929      ;;
4930    
4931    *)
4932      $echo "$modename: invalid operation mode \`$mode'" 1>&2
4933      $echo "$help" 1>&2
4934      exit 1
4935      ;;
4936    esac
4937    
4938    echo
4939    $echo "Try \`$modename --help' for more information about other modes."
4940    
4941    exit 0
4942    
4943    # Local Variables:
4944    # mode:shell-script
4945    # sh-indentation:2
4946    # End:

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26