ltmain.sh
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:182k
源码类别:

网格计算

开发平台:

Java

  1. # Check to see if the archive will have undefined symbols.
  2. if test "$allow_undefined" = yes; then
  3.   if test "$allow_undefined_flag" = unsupported; then
  4.     $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
  5.     build_libtool_libs=no
  6.     build_old_libs=yes
  7.   fi
  8. else
  9.   # Don't allow undefined symbols.
  10.   allow_undefined_flag="$no_undefined_flag"
  11. fi
  12.       fi
  13.       if test "$mode" != relink; then
  14. # Remove our outputs, but don't remove object files since they
  15. # may have been created when compiling PIC objects.
  16. removelist=
  17. tempremovelist=`$echo "$output_objdir/*"`
  18. for p in $tempremovelist; do
  19.   case $p in
  20.     *.$objext)
  21.        ;;
  22.     $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
  23.        if test "X$precious_files_regex" != "X"; then
  24.          if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
  25.          then
  26.    continue
  27.  fi
  28.        fi
  29.        removelist="$removelist $p"
  30.        ;;
  31.     *) ;;
  32.   esac
  33. done
  34. if test -n "$removelist"; then
  35.   $show "${rm}r $removelist"
  36.   $run ${rm}r $removelist
  37. fi
  38.       fi
  39.       # Now set the variables for building old libraries.
  40.       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
  41. oldlibs="$oldlibs $output_objdir/$libname.$libext"
  42. # Transform .lo files to .o files.
  43. oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/.'${libext}'$/d' -e "$lo2o" | $NL2SP`
  44.       fi
  45.       # Eliminate all temporary directories.
  46.       for path in $notinst_path; do
  47. lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
  48. deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
  49. dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
  50.       done
  51.       if test -n "$xrpath"; then
  52. # If the user specified any rpath flags, then add them.
  53. temp_xrpath=
  54. for libdir in $xrpath; do
  55.   temp_xrpath="$temp_xrpath -R$libdir"
  56.   case "$finalize_rpath " in
  57.   *" $libdir "*) ;;
  58.   *) finalize_rpath="$finalize_rpath $libdir" ;;
  59.   esac
  60. done
  61. if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
  62.   dependency_libs="$temp_xrpath $dependency_libs"
  63. fi
  64.       fi
  65.       # Make sure dlfiles contains only unique files that won't be dlpreopened
  66.       old_dlfiles="$dlfiles"
  67.       dlfiles=
  68.       for lib in $old_dlfiles; do
  69. case " $dlprefiles $dlfiles " in
  70. *" $lib "*) ;;
  71. *) dlfiles="$dlfiles $lib" ;;
  72. esac
  73.       done
  74.       # Make sure dlprefiles contains only unique files
  75.       old_dlprefiles="$dlprefiles"
  76.       dlprefiles=
  77.       for lib in $old_dlprefiles; do
  78. case "$dlprefiles " in
  79. *" $lib "*) ;;
  80. *) dlprefiles="$dlprefiles $lib" ;;
  81. esac
  82.       done
  83.       if test "$build_libtool_libs" = yes; then
  84. if test -n "$rpath"; then
  85.   case $host in
  86.   *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
  87.     # these systems don't actually have a c library (as such)!
  88.     ;;
  89.   *-*-rhapsody* | *-*-darwin1.[012])
  90.     # Rhapsody C library is in the System framework
  91.     deplibs="$deplibs -framework System"
  92.     ;;
  93.   *-*-netbsd*)
  94.     # Don't link with libc until the a.out ld.so is fixed.
  95.     ;;
  96.   *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
  97.     # Do not include libc due to us having libc/libc_r.
  98.     test "X$arg" = "X-lc" && continue
  99.     ;;
  100.     *)
  101.     # Add libc to deplibs on all other systems if necessary.
  102.     if test "$build_libtool_need_lc" = "yes"; then
  103.       deplibs="$deplibs -lc"
  104.     fi
  105.     ;;
  106.   esac
  107. fi
  108. # Transform deplibs into only deplibs that can be linked in shared.
  109. name_save=$name
  110. libname_save=$libname
  111. release_save=$release
  112. versuffix_save=$versuffix
  113. major_save=$major
  114. # I'm not sure if I'm treating the release correctly.  I think
  115. # release should show up in the -l (ie -lgmp5) so we don't want to
  116. # add it in twice.  Is that correct?
  117. release=""
  118. versuffix=""
  119. major=""
  120. newdeplibs=
  121. droppeddeps=no
  122. case $deplibs_check_method in
  123. pass_all)
  124.   # Don't check for shared/static.  Everything works.
  125.   # This might be a little naive.  We might want to check
  126.   # whether the library exists or not.  But this is on
  127.   # osf3 & osf4 and I'm not really sure... Just
  128.   # implementing what was already the behavior.
  129.   newdeplibs=$deplibs
  130.   ;;
  131. test_compile)
  132.   # This code stresses the "libraries are programs" paradigm to its
  133.   # limits. Maybe even breaks it.  We compile a program, linking it
  134.   # against the deplibs as a proxy for the library.  Then we can check
  135.   # whether they linked in statically or dynamically with ldd.
  136.   $rm conftest.c
  137.   cat > conftest.c <<EOF
  138.   int main() { return 0; }
  139. EOF
  140.   $rm conftest
  141.   $LTCC -o conftest conftest.c $deplibs
  142.   if test "$?" -eq 0 ; then
  143.     ldd_output=`ldd conftest`
  144.     for i in $deplibs; do
  145.       name=`expr $i : '-l(.*)'`
  146.       # If $name is empty we are operating on a -L argument.
  147.               if test "$name" != "" && test "$name" -ne "0"; then
  148. if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  149.   case " $predeps $postdeps " in
  150.   *" $i "*)
  151.     newdeplibs="$newdeplibs $i"
  152.     i=""
  153.     ;;
  154.   esac
  155.         fi
  156. if test -n "$i" ; then
  157.   libname=`eval \$echo "$libname_spec"`
  158.   deplib_matches=`eval \$echo "$library_names_spec"`
  159.   set dummy $deplib_matches
  160.   deplib_match=$2
  161.   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  162.     newdeplibs="$newdeplibs $i"
  163.   else
  164.     droppeddeps=yes
  165.     $echo
  166.     $echo "*** Warning: dynamic linker does not accept needed library $i."
  167.     $echo "*** I have the capability to make that library automatically link in when"
  168.     $echo "*** you link to this library.  But I can only do this if you have a"
  169.     $echo "*** shared version of the library, which I believe you do not have"
  170.     $echo "*** because a test_compile did reveal that the linker did not use it for"
  171.     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
  172.   fi
  173. fi
  174.       else
  175. newdeplibs="$newdeplibs $i"
  176.       fi
  177.     done
  178.   else
  179.     # Error occurred in the first compile.  Let's try to salvage
  180.     # the situation: Compile a separate program for each library.
  181.     for i in $deplibs; do
  182.       name=`expr $i : '-l(.*)'`
  183.       # If $name is empty we are operating on a -L argument.
  184.               if test "$name" != "" && test "$name" != "0"; then
  185. $rm conftest
  186. $LTCC -o conftest conftest.c $i
  187. # Did it work?
  188. if test "$?" -eq 0 ; then
  189.   ldd_output=`ldd conftest`
  190.   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  191.     case " $predeps $postdeps " in
  192.     *" $i "*)
  193.       newdeplibs="$newdeplibs $i"
  194.       i=""
  195.       ;;
  196.     esac
  197.   fi
  198.   if test -n "$i" ; then
  199.     libname=`eval \$echo "$libname_spec"`
  200.     deplib_matches=`eval \$echo "$library_names_spec"`
  201.     set dummy $deplib_matches
  202.     deplib_match=$2
  203.     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  204.       newdeplibs="$newdeplibs $i"
  205.     else
  206.       droppeddeps=yes
  207.       $echo
  208.       $echo "*** Warning: dynamic linker does not accept needed library $i."
  209.       $echo "*** I have the capability to make that library automatically link in when"
  210.       $echo "*** you link to this library.  But I can only do this if you have a"
  211.       $echo "*** shared version of the library, which you do not appear to have"
  212.       $echo "*** because a test_compile did reveal that the linker did not use this one"
  213.       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
  214.     fi
  215.   fi
  216. else
  217.   droppeddeps=yes
  218.   $echo
  219.   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
  220.   $echo "***  make it link in!  You will probably need to install it or some"
  221.   $echo "*** library that it depends on before this library will be fully"
  222.   $echo "*** functional.  Installing it before continuing would be even better."
  223. fi
  224.       else
  225. newdeplibs="$newdeplibs $i"
  226.       fi
  227.     done
  228.   fi
  229.   ;;
  230. file_magic*)
  231.   set dummy $deplibs_check_method
  232.   file_magic_regex=`expr "$deplibs_check_method" : "$2 (.*)"`
  233.   for a_deplib in $deplibs; do
  234.     name=`expr $a_deplib : '-l(.*)'`
  235.     # If $name is empty we are operating on a -L argument.
  236.             if test "$name" != "" && test  "$name" != "0"; then
  237.       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  238. case " $predeps $postdeps " in
  239. *" $a_deplib "*)
  240.   newdeplibs="$newdeplibs $a_deplib"
  241.   a_deplib=""
  242.   ;;
  243. esac
  244.       fi
  245.       if test -n "$a_deplib" ; then
  246. libname=`eval \$echo "$libname_spec"`
  247. for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  248.   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  249.   for potent_lib in $potential_libs; do
  250.       # Follow soft links.
  251.       if ls -lLd "$potent_lib" 2>/dev/null 
  252.  | grep " -> " >/dev/null; then
  253. continue
  254.       fi
  255.       # The statement above tries to avoid entering an
  256.       # endless loop below, in case of cyclic links.
  257.       # We might still enter an endless loop, since a link
  258.       # loop can be closed while we follow links,
  259.       # but so what?
  260.       potlib="$potent_lib"
  261.       while test -h "$potlib" 2>/dev/null; do
  262. potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
  263. case $potliblink in
  264. [\/]* | [A-Za-z]:[\/]*) potlib="$potliblink";;
  265. *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
  266. esac
  267.       done
  268.       if eval $file_magic_cmd "$potlib" 2>/dev/null 
  269.  | ${SED} 10q 
  270.  | $EGREP "$file_magic_regex" > /dev/null; then
  271. newdeplibs="$newdeplibs $a_deplib"
  272. a_deplib=""
  273. break 2
  274.       fi
  275.   done
  276. done
  277.       fi
  278.       if test -n "$a_deplib" ; then
  279. droppeddeps=yes
  280. $echo
  281. $echo "*** Warning: linker path does not have real file for library $a_deplib."
  282. $echo "*** I have the capability to make that library automatically link in when"
  283. $echo "*** you link to this library.  But I can only do this if you have a"
  284. $echo "*** shared version of the library, which you do not appear to have"
  285. $echo "*** because I did check the linker path looking for a file starting"
  286. if test -z "$potlib" ; then
  287.   $echo "*** with $libname but no candidates were found. (...for file magic test)"
  288. else
  289.   $echo "*** with $libname and none of the candidates passed a file format test"
  290.   $echo "*** using a file magic. Last file checked: $potlib"
  291. fi
  292.       fi
  293.     else
  294.       # Add a -L argument.
  295.       newdeplibs="$newdeplibs $a_deplib"
  296.     fi
  297.   done # Gone through all deplibs.
  298.   ;;
  299. match_pattern*)
  300.   set dummy $deplibs_check_method
  301.   match_pattern_regex=`expr "$deplibs_check_method" : "$2 (.*)"`
  302.   for a_deplib in $deplibs; do
  303.     name=`expr $a_deplib : '-l(.*)'`
  304.     # If $name is empty we are operating on a -L argument.
  305.     if test -n "$name" && test "$name" != "0"; then
  306.       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  307. case " $predeps $postdeps " in
  308. *" $a_deplib "*)
  309.   newdeplibs="$newdeplibs $a_deplib"
  310.   a_deplib=""
  311.   ;;
  312. esac
  313.       fi
  314.       if test -n "$a_deplib" ; then
  315. libname=`eval \$echo "$libname_spec"`
  316. for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  317.   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  318.   for potent_lib in $potential_libs; do
  319.     potlib="$potent_lib" # see symlink-check above in file_magic test
  320.     if eval $echo "$potent_lib" 2>/dev/null 
  321.         | ${SED} 10q 
  322.         | $EGREP "$match_pattern_regex" > /dev/null; then
  323.       newdeplibs="$newdeplibs $a_deplib"
  324.       a_deplib=""
  325.       break 2
  326.     fi
  327.   done
  328. done
  329.       fi
  330.       if test -n "$a_deplib" ; then
  331. droppeddeps=yes
  332. $echo
  333. $echo "*** Warning: linker path does not have real file for library $a_deplib."
  334. $echo "*** I have the capability to make that library automatically link in when"
  335. $echo "*** you link to this library.  But I can only do this if you have a"
  336. $echo "*** shared version of the library, which you do not appear to have"
  337. $echo "*** because I did check the linker path looking for a file starting"
  338. if test -z "$potlib" ; then
  339.   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
  340. else
  341.   $echo "*** with $libname and none of the candidates passed a file format test"
  342.   $echo "*** using a regex pattern. Last file checked: $potlib"
  343. fi
  344.       fi
  345.     else
  346.       # Add a -L argument.
  347.       newdeplibs="$newdeplibs $a_deplib"
  348.     fi
  349.   done # Gone through all deplibs.
  350.   ;;
  351. none | unknown | *)
  352.   newdeplibs=""
  353.   tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' 
  354.     -e 's/ -[LR][^ ]*//g'`
  355.   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  356.     for i in $predeps $postdeps ; do
  357.       # can't use Xsed below, because $i might contain '/'
  358.       tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
  359.     done
  360.   fi
  361.   if $echo "X $tmp_deplibs" | $Xsed -e 's/[  ]//g' 
  362.     | grep . >/dev/null; then
  363.     $echo
  364.     if test "X$deplibs_check_method" = "Xnone"; then
  365.       $echo "*** Warning: inter-library dependencies are not supported in this platform."
  366.     else
  367.       $echo "*** Warning: inter-library dependencies are not known to be supported."
  368.     fi
  369.     $echo "*** All declared inter-library dependencies are being dropped."
  370.     droppeddeps=yes
  371.   fi
  372.   ;;
  373. esac
  374. versuffix=$versuffix_save
  375. major=$major_save
  376. release=$release_save
  377. libname=$libname_save
  378. name=$name_save
  379. case $host in
  380. *-*-rhapsody* | *-*-darwin1.[012])
  381.   # On Rhapsody replace the C library is the System framework
  382.   newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
  383.   ;;
  384. esac
  385. if test "$droppeddeps" = yes; then
  386.   if test "$module" = yes; then
  387.     $echo
  388.     $echo "*** Warning: libtool could not satisfy all declared inter-library"
  389.     $echo "*** dependencies of module $libname.  Therefore, libtool will create"
  390.     $echo "*** a static module, that should work as long as the dlopening"
  391.     $echo "*** application is linked with the -dlopen flag."
  392.     if test -z "$global_symbol_pipe"; then
  393.       $echo
  394.       $echo "*** However, this would only work if libtool was able to extract symbol"
  395.       $echo "*** lists from a program, using `nm' or equivalent, but libtool could"
  396.       $echo "*** not find such a program.  So, this module is probably useless."
  397.       $echo "*** `nm' from GNU binutils and a full rebuild may help."
  398.     fi
  399.     if test "$build_old_libs" = no; then
  400.       oldlibs="$output_objdir/$libname.$libext"
  401.       build_libtool_libs=module
  402.       build_old_libs=yes
  403.     else
  404.       build_libtool_libs=no
  405.     fi
  406.   else
  407.     $echo "*** The inter-library dependencies that have been dropped here will be"
  408.     $echo "*** automatically added whenever a program is linked with this library"
  409.     $echo "*** or is declared to -dlopen it."
  410.     if test "$allow_undefined" = no; then
  411.       $echo
  412.       $echo "*** Since this library must not contain undefined symbols,"
  413.       $echo "*** because either the platform does not support them or"
  414.       $echo "*** it was explicitly requested with -no-undefined,"
  415.       $echo "*** libtool will only create a static version of it."
  416.       if test "$build_old_libs" = no; then
  417. oldlibs="$output_objdir/$libname.$libext"
  418. build_libtool_libs=module
  419. build_old_libs=yes
  420.       else
  421. build_libtool_libs=no
  422.       fi
  423.     fi
  424.   fi
  425. fi
  426. # Done checking deplibs!
  427. deplibs=$newdeplibs
  428.       fi
  429.       # All the library-specific variables (install_libdir is set above).
  430.       library_names=
  431.       old_library=
  432.       dlname=
  433.       # Test again, we may have decided not to build it any more
  434.       if test "$build_libtool_libs" = yes; then
  435. if test "$hardcode_into_libs" = yes; then
  436.   # Hardcode the library paths
  437.   hardcode_libdirs=
  438.   dep_rpath=
  439.   rpath="$finalize_rpath"
  440.   test "$mode" != relink && rpath="$compile_rpath$rpath"
  441.   for libdir in $rpath; do
  442.     if test -n "$hardcode_libdir_flag_spec"; then
  443.       if test -n "$hardcode_libdir_separator"; then
  444. if test -z "$hardcode_libdirs"; then
  445.   hardcode_libdirs="$libdir"
  446. else
  447.   # Just accumulate the unique libdirs.
  448.   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  449.   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  450.     ;;
  451.   *)
  452.     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  453.     ;;
  454.   esac
  455. fi
  456.       else
  457. eval flag="$hardcode_libdir_flag_spec"
  458. dep_rpath="$dep_rpath $flag"
  459.       fi
  460.     elif test -n "$runpath_var"; then
  461.       case "$perm_rpath " in
  462.       *" $libdir "*) ;;
  463.       *) perm_rpath="$perm_rpath $libdir" ;;
  464.       esac
  465.     fi
  466.   done
  467.   # Substitute the hardcoded libdirs into the rpath.
  468.   if test -n "$hardcode_libdir_separator" &&
  469.      test -n "$hardcode_libdirs"; then
  470.     libdir="$hardcode_libdirs"
  471.     if test -n "$hardcode_libdir_flag_spec_ld"; then
  472.       eval dep_rpath="$hardcode_libdir_flag_spec_ld"
  473.     else
  474.       eval dep_rpath="$hardcode_libdir_flag_spec"
  475.     fi
  476.   fi
  477.   if test -n "$runpath_var" && test -n "$perm_rpath"; then
  478.     # We should set the runpath_var.
  479.     rpath=
  480.     for dir in $perm_rpath; do
  481.       rpath="$rpath$dir:"
  482.     done
  483.     eval "$runpath_var='$rpath$$runpath_var'; export $runpath_var"
  484.   fi
  485.   test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
  486. fi
  487. shlibpath="$finalize_shlibpath"
  488. test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
  489. if test -n "$shlibpath"; then
  490.   eval "$shlibpath_var='$shlibpath$$shlibpath_var'; export $shlibpath_var"
  491. fi
  492. # Get the real and link names of the library.
  493. eval shared_ext="$shrext_cmds"
  494. eval library_names="$library_names_spec"
  495. set dummy $library_names
  496. realname="$2"
  497. shift; shift
  498. if test -n "$soname_spec"; then
  499.   eval soname="$soname_spec"
  500. else
  501.   soname="$realname"
  502. fi
  503. if test -z "$dlname"; then
  504.   dlname=$soname
  505. fi
  506. lib="$output_objdir/$realname"
  507. for link
  508. do
  509.   linknames="$linknames $link"
  510. done
  511. # Use standard objects if they are pic
  512. test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  513. # Prepare the list of exported symbols
  514. if test -z "$export_symbols"; then
  515.   if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
  516.     $show "generating symbol list for `$libname.la'"
  517.     export_symbols="$output_objdir/$libname.exp"
  518.     $run $rm $export_symbols
  519.     cmds=$export_symbols_cmds
  520.     save_ifs="$IFS"; IFS='~'
  521.     for cmd in $cmds; do
  522.       IFS="$save_ifs"
  523.       eval cmd="$cmd"
  524.       if len=`expr "X$cmd" : ".*"` &&
  525.        test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  526.         $show "$cmd"
  527.         $run eval "$cmd" || exit $?
  528.         skipped_export=false
  529.       else
  530.         # The command line is too long to execute in one step.
  531.         $show "using reloadable object file for export list..."
  532.         skipped_export=:
  533. # Break out early, otherwise skipped_export may be
  534. # set to false by a later but shorter cmd.
  535. break
  536.       fi
  537.     done
  538.     IFS="$save_ifs"
  539.     if test -n "$export_symbols_regex"; then
  540.       $show "$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T""
  541.       $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  542.       $show "$mv "${export_symbols}T" "$export_symbols""
  543.       $run eval '$mv "${export_symbols}T" "$export_symbols"'
  544.     fi
  545.   fi
  546. fi
  547. if test -n "$export_symbols" && test -n "$include_expsyms"; then
  548.   $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
  549. fi
  550. tmp_deplibs=
  551. for test_deplib in $deplibs; do
  552. case " $convenience " in
  553. *" $test_deplib "*) ;;
  554. *)
  555. tmp_deplibs="$tmp_deplibs $test_deplib"
  556. ;;
  557. esac
  558. done
  559. deplibs="$tmp_deplibs"
  560. if test -n "$convenience"; then
  561.   if test -n "$whole_archive_flag_spec"; then
  562.     save_libobjs=$libobjs
  563.     eval libobjs="$libobjs $whole_archive_flag_spec"
  564.   else
  565.     gentop="$output_objdir/${outputname}x"
  566.     generated="$generated $gentop"
  567.     func_extract_archives $gentop $convenience
  568.     libobjs="$libobjs $func_extract_archives_result"
  569.   fi
  570. fi
  571. if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
  572.   eval flag="$thread_safe_flag_spec"
  573.   linker_flags="$linker_flags $flag"
  574. fi
  575. # Make a backup of the uninstalled library when relinking
  576. if test "$mode" = relink; then
  577.   $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
  578. fi
  579. # Do each of the archive commands.
  580. if test "$module" = yes && test -n "$module_cmds" ; then
  581.   if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  582.     eval test_cmds="$module_expsym_cmds"
  583.     cmds=$module_expsym_cmds
  584.   else
  585.     eval test_cmds="$module_cmds"
  586.     cmds=$module_cmds
  587.   fi
  588. else
  589. if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  590.   eval test_cmds="$archive_expsym_cmds"
  591.   cmds=$archive_expsym_cmds
  592. else
  593.   eval test_cmds="$archive_cmds"
  594.   cmds=$archive_cmds
  595.   fi
  596. fi
  597. if test "X$skipped_export" != "X:" &&
  598.    len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  599.    test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  600.   :
  601. else
  602.   # The command line is too long to link in one step, link piecewise.
  603.   $echo "creating reloadable object files..."
  604.   # Save the value of $output and $libobjs because we want to
  605.   # use them later.  If we have whole_archive_flag_spec, we
  606.   # want to use save_libobjs as it was before
  607.   # whole_archive_flag_spec was expanded, because we can't
  608.   # assume the linker understands whole_archive_flag_spec.
  609.   # This may have to be revisited, in case too many
  610.   # convenience libraries get linked in and end up exceeding
  611.   # the spec.
  612.   if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
  613.     save_libobjs=$libobjs
  614.   fi
  615.   save_output=$output
  616.   output_la=`$echo "X$output" | $Xsed -e "$basename"`
  617.   # Clear the reloadable object creation command queue and
  618.   # initialize k to one.
  619.   test_cmds=
  620.   concat_cmds=
  621.   objlist=
  622.   delfiles=
  623.   last_robj=
  624.   k=1
  625.   output=$output_objdir/$output_la-${k}.$objext
  626.   # Loop over the list of objects to be linked.
  627.   for obj in $save_libobjs
  628.   do
  629.     eval test_cmds="$reload_cmds $objlist $last_robj"
  630.     if test "X$objlist" = X ||
  631.        { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  632.  test "$len" -le "$max_cmd_len"; }; then
  633.       objlist="$objlist $obj"
  634.     else
  635.       # The command $test_cmds is almost too long, add a
  636.       # command to the queue.
  637.       if test "$k" -eq 1 ; then
  638. # The first file doesn't have a previous command to add.
  639. eval concat_cmds="$reload_cmds $objlist $last_robj"
  640.       else
  641. # All subsequent reloadable object files will link in
  642. # the last one created.
  643. eval concat_cmds="$concat_cmds~$reload_cmds $objlist $last_robj"
  644.       fi
  645.       last_robj=$output_objdir/$output_la-${k}.$objext
  646.       k=`expr $k + 1`
  647.       output=$output_objdir/$output_la-${k}.$objext
  648.       objlist=$obj
  649.       len=1
  650.     fi
  651.   done
  652.   # Handle the remaining objects by creating one last
  653.   # reloadable object file.  All subsequent reloadable object
  654.   # files will link in the last one created.
  655.   test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  656.   eval concat_cmds="${concat_cmds}$reload_cmds $objlist $last_robj"
  657.   if ${skipped_export-false}; then
  658.     $show "generating symbol list for `$libname.la'"
  659.     export_symbols="$output_objdir/$libname.exp"
  660.     $run $rm $export_symbols
  661.     libobjs=$output
  662.     # Append the command to create the export file.
  663.     eval concat_cmds="$concat_cmds~$export_symbols_cmds"
  664.           fi
  665.   # Set up a command to remove the reloadable object files
  666.   # after they are used.
  667.   i=0
  668.   while test "$i" -lt "$k"
  669.   do
  670.     i=`expr $i + 1`
  671.     delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
  672.   done
  673.   $echo "creating a temporary reloadable object file: $output"
  674.   # Loop through the commands generated above and execute them.
  675.   save_ifs="$IFS"; IFS='~'
  676.   for cmd in $concat_cmds; do
  677.     IFS="$save_ifs"
  678.     $show "$cmd"
  679.     $run eval "$cmd" || exit $?
  680.   done
  681.   IFS="$save_ifs"
  682.   libobjs=$output
  683.   # Restore the value of output.
  684.   output=$save_output
  685.   if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
  686.     eval libobjs="$libobjs $whole_archive_flag_spec"
  687.   fi
  688.   # Expand the library linking commands again to reset the
  689.   # value of $libobjs for piecewise linking.
  690.   # Do each of the archive commands.
  691.   if test "$module" = yes && test -n "$module_cmds" ; then
  692.     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  693.       cmds=$module_expsym_cmds
  694.     else
  695.       cmds=$module_cmds
  696.     fi
  697.   else
  698.   if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  699.     cmds=$archive_expsym_cmds
  700.   else
  701.     cmds=$archive_cmds
  702.     fi
  703.   fi
  704.   # Append the command to remove the reloadable object files
  705.   # to the just-reset $cmds.
  706.   eval cmds="$cmds~$rm $delfiles"
  707. fi
  708. save_ifs="$IFS"; IFS='~'
  709. for cmd in $cmds; do
  710.   IFS="$save_ifs"
  711.   eval cmd="$cmd"
  712.   $show "$cmd"
  713.   $run eval "$cmd" || {
  714.     lt_exit=$?
  715.     # Restore the uninstalled library and exit
  716.     if test "$mode" = relink; then
  717.       $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
  718.     fi
  719.     exit $lt_exit
  720.   }
  721. done
  722. IFS="$save_ifs"
  723. # Restore the uninstalled library and exit
  724. if test "$mode" = relink; then
  725.   $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
  726.   if test -n "$convenience"; then
  727.     if test -z "$whole_archive_flag_spec"; then
  728.       $show "${rm}r $gentop"
  729.       $run ${rm}r "$gentop"
  730.     fi
  731.   fi
  732.   exit $EXIT_SUCCESS
  733. fi
  734. # Create links to the real library.
  735. for linkname in $linknames; do
  736.   if test "$realname" != "$linkname"; then
  737.     $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
  738.     $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
  739.   fi
  740. done
  741. # If -module or -export-dynamic was specified, set the dlname.
  742. if test "$module" = yes || test "$export_dynamic" = yes; then
  743.   # On all known operating systems, these are identical.
  744.   dlname="$soname"
  745. fi
  746.       fi
  747.       ;;
  748.     obj)
  749.       if test -n "$deplibs"; then
  750. $echo "$modename: warning: `-l' and `-L' are ignored for objects" 1>&2
  751.       fi
  752.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  753. $echo "$modename: warning: `-dlopen' is ignored for objects" 1>&2
  754.       fi
  755.       if test -n "$rpath"; then
  756. $echo "$modename: warning: `-rpath' is ignored for objects" 1>&2
  757.       fi
  758.       if test -n "$xrpath"; then
  759. $echo "$modename: warning: `-R' is ignored for objects" 1>&2
  760.       fi
  761.       if test -n "$vinfo"; then
  762. $echo "$modename: warning: `-version-info' is ignored for objects" 1>&2
  763.       fi
  764.       if test -n "$release"; then
  765. $echo "$modename: warning: `-release' is ignored for objects" 1>&2
  766.       fi
  767.       case $output in
  768.       *.lo)
  769. if test -n "$objs$old_deplibs"; then
  770.   $echo "$modename: cannot build library object `$output' from non-libtool objects" 1>&2
  771.   exit $EXIT_FAILURE
  772. fi
  773. libobj="$output"
  774. obj=`$echo "X$output" | $Xsed -e "$lo2o"`
  775. ;;
  776.       *)
  777. libobj=
  778. obj="$output"
  779. ;;
  780.       esac
  781.       # Delete the old objects.
  782.       $run $rm $obj $libobj
  783.       # Objects from convenience libraries.  This assumes
  784.       # single-version convenience libraries.  Whenever we create
  785.       # different ones for PIC/non-PIC, this we'll have to duplicate
  786.       # the extraction.
  787.       reload_conv_objs=
  788.       gentop=
  789.       # reload_cmds runs $LD directly, so let us get rid of
  790.       # -Wl from whole_archive_flag_spec
  791.       wl=
  792.       if test -n "$convenience"; then
  793. if test -n "$whole_archive_flag_spec"; then
  794.   eval reload_conv_objs="$reload_objs $whole_archive_flag_spec"
  795. else
  796.   gentop="$output_objdir/${obj}x"
  797.   generated="$generated $gentop"
  798.   func_extract_archives $gentop $convenience
  799.   reload_conv_objs="$reload_objs $func_extract_archives_result"
  800. fi
  801.       fi
  802.       # Create the old-style object.
  803.       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
  804.       output="$obj"
  805.       cmds=$reload_cmds
  806.       save_ifs="$IFS"; IFS='~'
  807.       for cmd in $cmds; do
  808. IFS="$save_ifs"
  809. eval cmd="$cmd"
  810. $show "$cmd"
  811. $run eval "$cmd" || exit $?
  812.       done
  813.       IFS="$save_ifs"
  814.       # Exit if we aren't doing a library object file.
  815.       if test -z "$libobj"; then
  816. if test -n "$gentop"; then
  817.   $show "${rm}r $gentop"
  818.   $run ${rm}r $gentop
  819. fi
  820. exit $EXIT_SUCCESS
  821.       fi
  822.       if test "$build_libtool_libs" != yes; then
  823. if test -n "$gentop"; then
  824.   $show "${rm}r $gentop"
  825.   $run ${rm}r $gentop
  826. fi
  827. # Create an invalid libtool object if no PIC, so that we don't
  828. # accidentally link it into a program.
  829. # $show "echo timestamp > $libobj"
  830. # $run eval "echo timestamp > $libobj" || exit $?
  831. exit $EXIT_SUCCESS
  832.       fi
  833.       if test -n "$pic_flag" || test "$pic_mode" != default; then
  834. # Only do commands if we really have different PIC objects.
  835. reload_objs="$libobjs $reload_conv_objs"
  836. output="$libobj"
  837. cmds=$reload_cmds
  838. save_ifs="$IFS"; IFS='~'
  839. for cmd in $cmds; do
  840.   IFS="$save_ifs"
  841.   eval cmd="$cmd"
  842.   $show "$cmd"
  843.   $run eval "$cmd" || exit $?
  844. done
  845. IFS="$save_ifs"
  846.       fi
  847.       if test -n "$gentop"; then
  848. $show "${rm}r $gentop"
  849. $run ${rm}r $gentop
  850.       fi
  851.       exit $EXIT_SUCCESS
  852.       ;;
  853.     prog)
  854.       case $host in
  855. *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
  856.       esac
  857.       if test -n "$vinfo"; then
  858. $echo "$modename: warning: `-version-info' is ignored for programs" 1>&2
  859.       fi
  860.       if test -n "$release"; then
  861. $echo "$modename: warning: `-release' is ignored for programs" 1>&2
  862.       fi
  863.       if test "$preload" = yes; then
  864. if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
  865.    test "$dlopen_self_static" = unknown; then
  866.   $echo "$modename: warning: `AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
  867. fi
  868.       fi
  869.       case $host in
  870.       *-*-rhapsody* | *-*-darwin1.[012])
  871. # On Rhapsody replace the C library is the System framework
  872. compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
  873. finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
  874. ;;
  875.       esac
  876.       case $host in
  877.       *darwin*)
  878.         # Don't allow lazy linking, it breaks C++ global constructors
  879.         if test "$tagname" = CXX ; then
  880.         compile_command="$compile_command ${wl}-bind_at_load"
  881.         finalize_command="$finalize_command ${wl}-bind_at_load"
  882.         fi
  883.         ;;
  884.       esac
  885.       compile_command="$compile_command $compile_deplibs"
  886.       finalize_command="$finalize_command $finalize_deplibs"
  887.       if test -n "$rpath$xrpath"; then
  888. # If the user specified any rpath flags, then add them.
  889. for libdir in $rpath $xrpath; do
  890.   # This is the magic to use -rpath.
  891.   case "$finalize_rpath " in
  892.   *" $libdir "*) ;;
  893.   *) finalize_rpath="$finalize_rpath $libdir" ;;
  894.   esac
  895. done
  896.       fi
  897.       # Now hardcode the library paths
  898.       rpath=
  899.       hardcode_libdirs=
  900.       for libdir in $compile_rpath $finalize_rpath; do
  901. if test -n "$hardcode_libdir_flag_spec"; then
  902.   if test -n "$hardcode_libdir_separator"; then
  903.     if test -z "$hardcode_libdirs"; then
  904.       hardcode_libdirs="$libdir"
  905.     else
  906.       # Just accumulate the unique libdirs.
  907.       case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  908.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  909. ;;
  910.       *)
  911. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  912. ;;
  913.       esac
  914.     fi
  915.   else
  916.     eval flag="$hardcode_libdir_flag_spec"
  917.     rpath="$rpath $flag"
  918.   fi
  919. elif test -n "$runpath_var"; then
  920.   case "$perm_rpath " in
  921.   *" $libdir "*) ;;
  922.   *) perm_rpath="$perm_rpath $libdir" ;;
  923.   esac
  924. fi
  925. case $host in
  926. *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
  927.   case :$dllsearchpath: in
  928.   *":$libdir:"*) ;;
  929.   *) dllsearchpath="$dllsearchpath:$libdir";;
  930.   esac
  931.   ;;
  932. esac
  933.       done
  934.       # Substitute the hardcoded libdirs into the rpath.
  935.       if test -n "$hardcode_libdir_separator" &&
  936.  test -n "$hardcode_libdirs"; then
  937. libdir="$hardcode_libdirs"
  938. eval rpath=" $hardcode_libdir_flag_spec"
  939.       fi
  940.       compile_rpath="$rpath"
  941.       rpath=
  942.       hardcode_libdirs=
  943.       for libdir in $finalize_rpath; do
  944. if test -n "$hardcode_libdir_flag_spec"; then
  945.   if test -n "$hardcode_libdir_separator"; then
  946.     if test -z "$hardcode_libdirs"; then
  947.       hardcode_libdirs="$libdir"
  948.     else
  949.       # Just accumulate the unique libdirs.
  950.       case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  951.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  952. ;;
  953.       *)
  954. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  955. ;;
  956.       esac
  957.     fi
  958.   else
  959.     eval flag="$hardcode_libdir_flag_spec"
  960.     rpath="$rpath $flag"
  961.   fi
  962. elif test -n "$runpath_var"; then
  963.   case "$finalize_perm_rpath " in
  964.   *" $libdir "*) ;;
  965.   *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
  966.   esac
  967. fi
  968.       done
  969.       # Substitute the hardcoded libdirs into the rpath.
  970.       if test -n "$hardcode_libdir_separator" &&
  971.  test -n "$hardcode_libdirs"; then
  972. libdir="$hardcode_libdirs"
  973. eval rpath=" $hardcode_libdir_flag_spec"
  974.       fi
  975.       finalize_rpath="$rpath"
  976.       if test -n "$libobjs" && test "$build_old_libs" = yes; then
  977. # Transform all the library objects into standard objects.
  978. compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  979. finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  980.       fi
  981.       dlsyms=
  982.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  983. if test -n "$NM" && test -n "$global_symbol_pipe"; then
  984.   dlsyms="${outputname}S.c"
  985. else
  986.   $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
  987. fi
  988.       fi
  989.       if test -n "$dlsyms"; then
  990. case $dlsyms in
  991. "") ;;
  992. *.c)
  993.   # Discover the nlist of each of the dlfiles.
  994.   nlist="$output_objdir/${outputname}.nm"
  995.   $show "$rm $nlist ${nlist}S ${nlist}T"
  996.   $run $rm "$nlist" "${nlist}S" "${nlist}T"
  997.   # Parse the name list into a source file.
  998.   $show "creating $output_objdir/$dlsyms"
  999.   test -z "$run" && $echo > "$output_objdir/$dlsyms" "
  1000. /* $dlsyms - symbol resolution table for `$outputname' dlsym emulation. */
  1001. /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
  1002. #ifdef __cplusplus
  1003. extern "C" {
  1004. #endif
  1005. /* Prevent the only kind of declaration conflicts we can make. */
  1006. #define lt_preloaded_symbols some_other_symbol
  1007. /* External symbol declarations for the compiler. */
  1008. "
  1009.   if test "$dlself" = yes; then
  1010.     $show "generating symbol list for `$output'"
  1011.     test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
  1012.     # Add our own program objects to the symbol list.
  1013.     progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  1014.     for arg in $progfiles; do
  1015.       $show "extracting global C symbols from `$arg'"
  1016.       $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
  1017.     done
  1018.     if test -n "$exclude_expsyms"; then
  1019.       $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
  1020.       $run eval '$mv "$nlist"T "$nlist"'
  1021.     fi
  1022.     if test -n "$export_symbols_regex"; then
  1023.       $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
  1024.       $run eval '$mv "$nlist"T "$nlist"'
  1025.     fi
  1026.     # Prepare the list of exported symbols
  1027.     if test -z "$export_symbols"; then
  1028.       export_symbols="$output_objdir/$outputname.exp"
  1029.       $run $rm $export_symbols
  1030.       $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* (.*)$/1/p' "'< "$nlist" > "$export_symbols"'
  1031.     else
  1032.       $run eval "${SED} -e 's/([ ][.*^$])/\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
  1033.       $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
  1034.       $run eval 'mv "$nlist"T "$nlist"'
  1035.     fi
  1036.   fi
  1037.   for arg in $dlprefiles; do
  1038.     $show "extracting global C symbols from `$arg'"
  1039.     name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
  1040.     $run eval '$echo ": $name " >> "$nlist"'
  1041.     $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
  1042.   done
  1043.   if test -z "$run"; then
  1044.     # Make sure we have at least an empty file.
  1045.     test -f "$nlist" || : > "$nlist"
  1046.     if test -n "$exclude_expsyms"; then
  1047.       $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
  1048.       $mv "$nlist"T "$nlist"
  1049.     fi
  1050.     # Try sorting and uniquifying the output.
  1051.     if grep -v "^: " < "$nlist" |
  1052. if sort -k 3 </dev/null >/dev/null 2>&1; then
  1053.   sort -k 3
  1054. else
  1055.   sort +2
  1056. fi |
  1057. uniq > "$nlist"S; then
  1058.       :
  1059.     else
  1060.       grep -v "^: " < "$nlist" > "$nlist"S
  1061.     fi
  1062.     if test -f "$nlist"S; then
  1063.       eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
  1064.     else
  1065.       $echo '/* NONE */' >> "$output_objdir/$dlsyms"
  1066.     fi
  1067.     $echo >> "$output_objdir/$dlsyms" "
  1068. #undef lt_preloaded_symbols
  1069. #if defined (__STDC__) && __STDC__
  1070. # define lt_ptr void *
  1071. #else
  1072. # define lt_ptr char *
  1073. # define const
  1074. #endif
  1075. /* The mapping between symbol names and symbols. */
  1076. "
  1077.     case $host in
  1078.     *cygwin* | *mingw* )
  1079.   $echo >> "$output_objdir/$dlsyms" "
  1080. /* DATA imports from DLLs on WIN32 can't be const, because
  1081.    runtime relocations are performed -- see ld's documentation
  1082.    on pseudo-relocs */
  1083. struct {
  1084. "
  1085.       ;;
  1086.     * )
  1087.   $echo >> "$output_objdir/$dlsyms" "
  1088. const struct {
  1089. "
  1090.       ;;
  1091.     esac
  1092.   $echo >> "$output_objdir/$dlsyms" "
  1093.   const char *name;
  1094.   lt_ptr address;
  1095. }
  1096. lt_preloaded_symbols[] =
  1097. {
  1098. "
  1099.     eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
  1100.     $echo >> "$output_objdir/$dlsyms" "
  1101.   {0, (lt_ptr) 0}
  1102. };
  1103. /* This works around a problem in FreeBSD linker */
  1104. #ifdef FREEBSD_WORKAROUND
  1105. static const void *lt_preloaded_setup() {
  1106.   return lt_preloaded_symbols;
  1107. }
  1108. #endif
  1109. #ifdef __cplusplus
  1110. }
  1111. #endif
  1112. "
  1113.   fi
  1114.   pic_flag_for_symtable=
  1115.   case $host in
  1116.   # compiling the symbol table file with pic_flag works around
  1117.   # a FreeBSD bug that causes programs to crash when -lm is
  1118.   # linked before any other PIC object.  But we must not use
  1119.   # pic_flag when linking with -static.  The problem exists in
  1120.   # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
  1121.   *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
  1122.     case "$compile_command " in
  1123.     *" -static "*) ;;
  1124.     *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
  1125.     esac;;
  1126.   *-*-hpux*)
  1127.     case "$compile_command " in
  1128.     *" -static "*) ;;
  1129.     *) pic_flag_for_symtable=" $pic_flag";;
  1130.     esac
  1131.   esac
  1132.   # Now compile the dynamic symbol file.
  1133.   $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")"
  1134.   $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
  1135.   # Clean up the generated files.
  1136.   $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
  1137.   $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
  1138.   # Transform the symbol file into the correct name.
  1139.   compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
  1140.   finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
  1141.   ;;
  1142. *)
  1143.   $echo "$modename: unknown suffix for `$dlsyms'" 1>&2
  1144.   exit $EXIT_FAILURE
  1145.   ;;
  1146. esac
  1147.       else
  1148. # We keep going just in case the user didn't refer to
  1149. # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
  1150. # really was required.
  1151. # Nullify the symbol file.
  1152. compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
  1153. finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
  1154.       fi
  1155.       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
  1156. # Replace the output file specification.
  1157. compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  1158. link_command="$compile_command$compile_rpath"
  1159. # We have no uninstalled library dependencies, so finalize right now.
  1160. $show "$link_command"
  1161. $run eval "$link_command"
  1162. status=$?
  1163. # Delete the generated files.
  1164. if test -n "$dlsyms"; then
  1165.   $show "$rm $output_objdir/${outputname}S.${objext}"
  1166.   $run $rm "$output_objdir/${outputname}S.${objext}"
  1167. fi
  1168. exit $status
  1169.       fi
  1170.       if test -n "$shlibpath_var"; then
  1171. # We should set the shlibpath_var
  1172. rpath=
  1173. for dir in $temp_rpath; do
  1174.   case $dir in
  1175.   [\/]* | [A-Za-z]:[\/]*)
  1176.     # Absolute path.
  1177.     rpath="$rpath$dir:"
  1178.     ;;
  1179.   *)
  1180.     # Relative path: add a thisdir entry.
  1181.     rpath="$rpath$thisdir/$dir:"
  1182.     ;;
  1183.   esac
  1184. done
  1185. temp_rpath="$rpath"
  1186.       fi
  1187.       if test -n "$compile_shlibpath$finalize_shlibpath"; then
  1188. compile_command="$shlibpath_var="$compile_shlibpath$finalize_shlibpath$$shlibpath_var" $compile_command"
  1189.       fi
  1190.       if test -n "$finalize_shlibpath"; then
  1191. finalize_command="$shlibpath_var="$finalize_shlibpath$$shlibpath_var" $finalize_command"
  1192.       fi
  1193.       compile_var=
  1194.       finalize_var=
  1195.       if test -n "$runpath_var"; then
  1196. if test -n "$perm_rpath"; then
  1197.   # We should set the runpath_var.
  1198.   rpath=
  1199.   for dir in $perm_rpath; do
  1200.     rpath="$rpath$dir:"
  1201.   done
  1202.   compile_var="$runpath_var="$rpath$$runpath_var" "
  1203. fi
  1204. if test -n "$finalize_perm_rpath"; then
  1205.   # We should set the runpath_var.
  1206.   rpath=
  1207.   for dir in $finalize_perm_rpath; do
  1208.     rpath="$rpath$dir:"
  1209.   done
  1210.   finalize_var="$runpath_var="$rpath$$runpath_var" "
  1211. fi
  1212.       fi
  1213.       if test "$no_install" = yes; then
  1214. # We don't need to create a wrapper script.
  1215. link_command="$compile_var$compile_command$compile_rpath"
  1216. # Replace the output file specification.
  1217. link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  1218. # Delete the old output file.
  1219. $run $rm $output
  1220. # Link the executable and exit
  1221. $show "$link_command"
  1222. $run eval "$link_command" || exit $?
  1223. exit $EXIT_SUCCESS
  1224.       fi
  1225.       if test "$hardcode_action" = relink; then
  1226. # Fast installation is not supported
  1227. link_command="$compile_var$compile_command$compile_rpath"
  1228. relink_command="$finalize_var$finalize_command$finalize_rpath"
  1229. $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
  1230. $echo "$modename: `$output' will be relinked during installation" 1>&2
  1231.       else
  1232. if test "$fast_install" != no; then
  1233.   link_command="$finalize_var$compile_command$finalize_rpath"
  1234.   if test "$fast_install" = yes; then
  1235.     relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%$progdir/$file%g'`
  1236.   else
  1237.     # fast_install is set to needless
  1238.     relink_command=
  1239.   fi
  1240. else
  1241.   link_command="$compile_var$compile_command$compile_rpath"
  1242.   relink_command="$finalize_var$finalize_command$finalize_rpath"
  1243. fi
  1244.       fi
  1245.       # Replace the output file specification.
  1246.       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
  1247.       # Delete the old output files.
  1248.       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
  1249.       $show "$link_command"
  1250.       $run eval "$link_command" || exit $?
  1251.       # Now create the wrapper script.
  1252.       $show "creating $output"
  1253.       # Quote the relink command for shipping.
  1254.       if test -n "$relink_command"; then
  1255. # Preserve any variables that may affect compiler behavior
  1256. for var in $variables_saved_for_relink; do
  1257.   if eval test -z "${$var+set}"; then
  1258.     relink_command="{ test -z "${$var+set}" || unset $var || { $var=; export $var; }; }; $relink_command"
  1259.   elif eval var_value=$$var; test -z "$var_value"; then
  1260.     relink_command="$var=; export $var; $relink_command"
  1261.   else
  1262.     var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
  1263.     relink_command="$var="$var_value"; export $var; $relink_command"
  1264.   fi
  1265. done
  1266. relink_command="(cd `pwd`; $relink_command)"
  1267. relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
  1268.       fi
  1269.       # Quote $echo for shipping.
  1270.       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
  1271. case $progpath in
  1272. [\/]* | [A-Za-z]:[\/]*) qecho="$SHELL $progpath --fallback-echo";;
  1273. *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
  1274. esac
  1275. qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
  1276.       else
  1277. qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
  1278.       fi
  1279.       # Only actually do things if our run command is non-null.
  1280.       if test -z "$run"; then
  1281. # win32 will think the script is a binary if it has
  1282. # a .exe suffix, so we strip it off here.
  1283. case $output in
  1284.   *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
  1285. esac
  1286. # test for cygwin because mv fails w/o .exe extensions
  1287. case $host in
  1288.   *cygwin*)
  1289.     exeext=.exe
  1290.     outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
  1291.   *) exeext= ;;
  1292. esac
  1293. case $host in
  1294.   *cygwin* | *mingw* )
  1295.     cwrappersource=`$echo ${objdir}/lt-${outputname}.c`
  1296.     cwrapper=`$echo ${output}.exe`
  1297.     $rm $cwrappersource $cwrapper
  1298.     trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
  1299.     cat > $cwrappersource <<EOF
  1300. /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
  1301.    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  1302.    The $output program cannot be directly executed until all the libtool
  1303.    libraries that it depends on are installed.
  1304.    This wrapper executable should never be moved out of the build directory.
  1305.    If it is, it will not operate correctly.
  1306.    Currently, it simply execs the wrapper *script* "/bin/sh $output",
  1307.    but could eventually absorb all of the scripts functionality and
  1308.    exec $objdir/$outputname directly.
  1309. */
  1310. EOF
  1311.     cat >> $cwrappersource<<"EOF"
  1312. #include <stdio.h>
  1313. #include <stdlib.h>
  1314. #include <unistd.h>
  1315. #include <malloc.h>
  1316. #include <stdarg.h>
  1317. #include <assert.h>
  1318. #if defined(PATH_MAX)
  1319. # define LT_PATHMAX PATH_MAX
  1320. #elif defined(MAXPATHLEN)
  1321. # define LT_PATHMAX MAXPATHLEN
  1322. #else
  1323. # define LT_PATHMAX 1024
  1324. #endif
  1325. #ifndef DIR_SEPARATOR
  1326. #define DIR_SEPARATOR '/'
  1327. #endif
  1328. #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || 
  1329.   defined (__OS2__)
  1330. #define HAVE_DOS_BASED_FILE_SYSTEM
  1331. #ifndef DIR_SEPARATOR_2
  1332. #define DIR_SEPARATOR_2 '\'
  1333. #endif
  1334. #endif
  1335. #ifndef DIR_SEPARATOR_2
  1336. # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
  1337. #else /* DIR_SEPARATOR_2 */
  1338. # define IS_DIR_SEPARATOR(ch) 
  1339.         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
  1340. #endif /* DIR_SEPARATOR_2 */
  1341. #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
  1342. #define XFREE(stale) do { 
  1343.   if (stale) { free ((void *) stale); stale = 0; } 
  1344. } while (0)
  1345. const char *program_name = NULL;
  1346. void * xmalloc (size_t num);
  1347. char * xstrdup (const char *string);
  1348. char * basename (const char *name);
  1349. char * fnqualify(const char *path);
  1350. char * strendzap(char *str, const char *pat);
  1351. void lt_fatal (const char *message, ...);
  1352. int
  1353. main (int argc, char *argv[])
  1354. {
  1355.   char **newargz;
  1356.   int i;
  1357.   program_name = (char *) xstrdup ((char *) basename (argv[0]));
  1358.   newargz = XMALLOC(char *, argc+2);
  1359. EOF
  1360.     cat >> $cwrappersource <<EOF
  1361.   newargz[0] = "$SHELL";
  1362. EOF
  1363.     cat >> $cwrappersource <<"EOF"
  1364.   newargz[1] = fnqualify(argv[0]);
  1365.   /* we know the script has the same name, without the .exe */
  1366.   /* so make sure newargz[1] doesn't end in .exe */
  1367.   strendzap(newargz[1],".exe");
  1368.   for (i = 1; i < argc; i++)
  1369.     newargz[i+1] = xstrdup(argv[i]);
  1370.   newargz[argc+1] = NULL;
  1371. EOF
  1372.     cat >> $cwrappersource <<EOF
  1373.   execv("$SHELL",newargz);
  1374. EOF
  1375.     cat >> $cwrappersource <<"EOF"
  1376.   return 127;
  1377. }
  1378. void *
  1379. xmalloc (size_t num)
  1380. {
  1381.   void * p = (void *) malloc (num);
  1382.   if (!p)
  1383.     lt_fatal ("Memory exhausted");
  1384.   return p;
  1385. }
  1386. char *
  1387. xstrdup (const char *string)
  1388. {
  1389.   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
  1390. ;
  1391. }
  1392. char *
  1393. basename (const char *name)
  1394. {
  1395.   const char *base;
  1396. #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  1397.   /* Skip over the disk name in MSDOS pathnames. */
  1398.   if (isalpha (name[0]) && name[1] == ':')
  1399.     name += 2;
  1400. #endif
  1401.   for (base = name; *name; name++)
  1402.     if (IS_DIR_SEPARATOR (*name))
  1403.       base = name + 1;
  1404.   return (char *) base;
  1405. }
  1406. char *
  1407. fnqualify(const char *path)
  1408. {
  1409.   size_t size;
  1410.   char *p;
  1411.   char tmp[LT_PATHMAX + 1];
  1412.   assert(path != NULL);
  1413.   /* Is it qualified already? */
  1414. #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  1415.   if (isalpha (path[0]) && path[1] == ':')
  1416.     return xstrdup (path);
  1417. #endif
  1418.   if (IS_DIR_SEPARATOR (path[0]))
  1419.     return xstrdup (path);
  1420.   /* prepend the current directory */
  1421.   /* doesn't handle '~' */
  1422.   if (getcwd (tmp, LT_PATHMAX) == NULL)
  1423.     lt_fatal ("getcwd failed");
  1424.   size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '' */
  1425.   p = XMALLOC(char, size);
  1426.   sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
  1427.   return p;
  1428. }
  1429. char *
  1430. strendzap(char *str, const char *pat)
  1431. {
  1432.   size_t len, patlen;
  1433.   assert(str != NULL);
  1434.   assert(pat != NULL);
  1435.   len = strlen(str);
  1436.   patlen = strlen(pat);
  1437.   if (patlen <= len)
  1438.   {
  1439.     str += len - patlen;
  1440.     if (strcmp(str, pat) == 0)
  1441.       *str = '';
  1442.   }
  1443.   return str;
  1444. }
  1445. static void
  1446. lt_error_core (int exit_status, const char * mode,
  1447.           const char * message, va_list ap)
  1448. {
  1449.   fprintf (stderr, "%s: %s: ", program_name, mode);
  1450.   vfprintf (stderr, message, ap);
  1451.   fprintf (stderr, ".n");
  1452.   if (exit_status >= 0)
  1453.     exit (exit_status);
  1454. }
  1455. void
  1456. lt_fatal (const char *message, ...)
  1457. {
  1458.   va_list ap;
  1459.   va_start (ap, message);
  1460.   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
  1461.   va_end (ap);
  1462. }
  1463. EOF
  1464.   # we should really use a build-platform specific compiler
  1465.   # here, but OTOH, the wrappers (shell script and this C one)
  1466.   # are only useful if you want to execute the "real" binary.
  1467.   # Since the "real" binary is built for $host, then this
  1468.   # wrapper might as well be built for $host, too.
  1469.   $run $LTCC -s -o $cwrapper $cwrappersource
  1470.   ;;
  1471. esac
  1472. $rm $output
  1473. trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
  1474. $echo > $output "
  1475. #! $SHELL
  1476. # $output - temporary wrapper script for $objdir/$outputname
  1477. # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  1478. #
  1479. # The $output program cannot be directly executed until all the libtool
  1480. # libraries that it depends on are installed.
  1481. #
  1482. # This wrapper script should never be moved out of the build directory.
  1483. # If it is, it will not operate correctly.
  1484. # Sed substitution that helps us do robust quoting.  It backslashifies
  1485. # metacharacters that are still active within double-quoted strings.
  1486. Xsed='${SED} -e 1s/^X//'
  1487. sed_quote_subst='$sed_quote_subst'
  1488. # The HP-UX ksh and POSIX shell print the target directory to stdout
  1489. # if CDPATH is set.
  1490. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
  1491. relink_command="$relink_command"
  1492. # This environment variable determines our operation mode.
  1493. if test "$libtool_install_magic" = "$magic"; then
  1494.   # install mode needs the following variable:
  1495.   notinst_deplibs='$notinst_deplibs'
  1496. else
  1497.   # When we are sourced in execute mode, $file and $echo are already set.
  1498.   if test "$libtool_execute_magic" != "$magic"; then
  1499.     echo="$qecho"
  1500.     file="$0"
  1501.     # Make sure echo works.
  1502.     if test "X$1" = X--no-reexec; then
  1503.       # Discard the --no-reexec flag, and continue.
  1504.       shift
  1505.     elif test "X`($echo 't') 2>/dev/null`" = 'Xt'; then
  1506.       # Yippee, $echo works!
  1507.       :
  1508.     else
  1509.       # Restart under the correct shell, and then maybe $echo will work.
  1510.       exec $SHELL "$0" --no-reexec ${1+"$@"}
  1511.     fi
  1512.   fi
  1513. "
  1514. $echo >> $output "
  1515.   # Find the directory that this script lives in.
  1516.   thisdir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  1517.   test "x$thisdir" = "x$file" && thisdir=.
  1518.   # Follow symbolic links until we get to the real thisdir.
  1519.   file=`ls -ld "$file" | ${SED} -n 's/.*-> //p'`
  1520.   while test -n "$file"; do
  1521.     destdir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  1522.     # If there was a directory component, then change thisdir.
  1523.     if test "x$destdir" != "x$file"; then
  1524.       case "$destdir" in
  1525.       [\\/]* | [A-Za-z]:[\\/]*) thisdir="$destdir" ;;
  1526.       *) thisdir="$thisdir/$destdir" ;;
  1527.       esac
  1528.     fi
  1529.     file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  1530.     file=`ls -ld "$thisdir/$file" | ${SED} -n 's/.*-> //p'`
  1531.   done
  1532.   # Try to get the absolute directory name.
  1533.   absdir=`cd "$thisdir" && pwd`
  1534.   test -n "$absdir" && thisdir="$absdir"
  1535. "
  1536. if test "$fast_install" = yes; then
  1537.   $echo >> $output "
  1538.   program=lt-'$outputname'$exeext
  1539.   progdir="$thisdir/$objdir"
  1540.   if test ! -f "$progdir/$program" || \
  1541.      { file=`ls -1dt "$progdir/$program" "$progdir/../$program" 2>/dev/null | ${SED} 1q`; \
  1542.        test "X$file" != "X$progdir/$program"; }; then
  1543.     file="$$-$program"
  1544.     if test ! -d "$progdir"; then
  1545.       $mkdir "$progdir"
  1546.     else
  1547.       $rm "$progdir/$file"
  1548.     fi"
  1549.   $echo >> $output "
  1550.     # relink executable if necessary
  1551.     if test -n "$relink_command"; then
  1552.       if relink_command_output=`eval $relink_command 2>&1`; then :
  1553.       else
  1554. $echo "$relink_command_output" >&2
  1555. $rm "$progdir/$file"
  1556. exit $EXIT_FAILURE
  1557.       fi
  1558.     fi
  1559.     $mv "$progdir/$file" "$progdir/$program" 2>/dev/null ||
  1560.     { $rm "$progdir/$program";
  1561.       $mv "$progdir/$file" "$progdir/$program"; }
  1562.     $rm "$progdir/$file"
  1563.   fi"
  1564. else
  1565.   $echo >> $output "
  1566.   program='$outputname'
  1567.   progdir="$thisdir/$objdir"
  1568. "
  1569. fi
  1570. $echo >> $output "
  1571.   if test -f "$progdir/$program"; then"
  1572. # Export our shlibpath_var if we have one.
  1573. if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  1574.   $echo >> $output "
  1575.     # Add our own library path to $shlibpath_var
  1576.     $shlibpath_var="$temp_rpath$$shlibpath_var"
  1577.     # Some systems cannot cope with colon-terminated $shlibpath_var
  1578.     # The second colon is a workaround for a bug in BeOS R4 sed
  1579.     $shlibpath_var=`$echo "X$$shlibpath_var" | $Xsed -e 's/::*$//'`
  1580.     export $shlibpath_var
  1581. "
  1582. fi
  1583. # fixup the dll searchpath if we need to.
  1584. if test -n "$dllsearchpath"; then
  1585.   $echo >> $output "
  1586.     # Add the dll search path components to the executable PATH
  1587.     PATH=$dllsearchpath:$PATH
  1588. "
  1589. fi
  1590. $echo >> $output "
  1591.     if test "$libtool_execute_magic" != "$magic"; then
  1592.       # Run the actual program with our arguments.
  1593. "
  1594. case $host in
  1595. # Backslashes separate directories on plain windows
  1596. *-*-mingw | *-*-os2*)
  1597.   $echo >> $output "
  1598.       exec "$progdir\\$program" ${1+"$@"}
  1599. "
  1600.   ;;
  1601. *)
  1602.   $echo >> $output "
  1603.       exec "$progdir/$program" ${1+"$@"}
  1604. "
  1605.   ;;
  1606. esac
  1607. $echo >> $output "
  1608.       $echo "$0: cannot exec $program ${1+"$@"}"
  1609.       exit $EXIT_FAILURE
  1610.     fi
  1611.   else
  1612.     # The program doesn't exist.
  1613.     $echo "$0: error: \`$progdir/$program' does not exist" 1>&2
  1614.     $echo "This script is just a wrapper for $program." 1>&2
  1615.     $echo "See the $PACKAGE documentation for more information." 1>&2
  1616.     exit $EXIT_FAILURE
  1617.   fi
  1618. fi
  1619. "
  1620. chmod +x $output
  1621.       fi
  1622.       exit $EXIT_SUCCESS
  1623.       ;;
  1624.     esac
  1625.     # See if we need to build an old-fashioned archive.
  1626.     for oldlib in $oldlibs; do
  1627.       if test "$build_libtool_libs" = convenience; then
  1628. oldobjs="$libobjs_save"
  1629. addlibs="$convenience"
  1630. build_libtool_libs=no
  1631.       else
  1632. if test "$build_libtool_libs" = module; then
  1633.   oldobjs="$libobjs_save"
  1634.   build_libtool_libs=no
  1635. else
  1636.   oldobjs="$old_deplibs $non_pic_objects"
  1637. fi
  1638. addlibs="$old_convenience"
  1639.       fi
  1640.       if test -n "$addlibs"; then
  1641. gentop="$output_objdir/${outputname}x"
  1642. generated="$generated $gentop"
  1643. func_extract_archives $gentop $addlibs
  1644. oldobjs="$oldobjs $func_extract_archives_result"
  1645.       fi
  1646.       # Do each command in the archive commands.
  1647.       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
  1648.        cmds=$old_archive_from_new_cmds
  1649.       else
  1650. # POSIX demands no paths to be encoded in archives.  We have
  1651. # to avoid creating archives with duplicate basenames if we
  1652. # might have to extract them afterwards, e.g., when creating a
  1653. # static archive out of a convenience library, or when linking
  1654. # the entirety of a libtool archive into another (currently
  1655. # not supported by libtool).
  1656. if (for obj in $oldobjs
  1657.     do
  1658.       $echo "X$obj" | $Xsed -e 's%^.*/%%'
  1659.     done | sort | sort -uc >/dev/null 2>&1); then
  1660.   :
  1661. else
  1662.   $echo "copying selected object files to avoid basename conflicts..."
  1663.   if test -z "$gentop"; then
  1664.     gentop="$output_objdir/${outputname}x"
  1665.     generated="$generated $gentop"
  1666.     $show "${rm}r $gentop"
  1667.     $run ${rm}r "$gentop"
  1668.     $show "$mkdir $gentop"
  1669.     $run $mkdir "$gentop"
  1670.     status=$?
  1671.     if test "$status" -ne 0 && test ! -d "$gentop"; then
  1672.       exit $status
  1673.     fi
  1674.   fi
  1675.   save_oldobjs=$oldobjs
  1676.   oldobjs=
  1677.   counter=1
  1678.   for obj in $save_oldobjs
  1679.   do
  1680.     objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
  1681.     case " $oldobjs " in
  1682.     " ") oldobjs=$obj ;;
  1683.     *[ /]"$objbase "*)
  1684.       while :; do
  1685. # Make sure we don't pick an alternate name that also
  1686. # overlaps.
  1687. newobj=lt$counter-$objbase
  1688. counter=`expr $counter + 1`
  1689. case " $oldobjs " in
  1690. *[ /]"$newobj "*) ;;
  1691. *) if test ! -f "$gentop/$newobj"; then break; fi ;;
  1692. esac
  1693.       done
  1694.       $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
  1695.       $run ln "$obj" "$gentop/$newobj" ||
  1696.       $run cp "$obj" "$gentop/$newobj"
  1697.       oldobjs="$oldobjs $gentop/$newobj"
  1698.       ;;
  1699.     *) oldobjs="$oldobjs $obj" ;;
  1700.     esac
  1701.   done
  1702. fi
  1703. eval cmds="$old_archive_cmds"
  1704. if len=`expr "X$cmds" : ".*"` &&
  1705.      test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  1706.   cmds=$old_archive_cmds
  1707. else
  1708.   # the command line is too long to link in one step, link in parts
  1709.   $echo "using piecewise archive linking..."
  1710.   save_RANLIB=$RANLIB
  1711.   RANLIB=:
  1712.   objlist=
  1713.   concat_cmds=
  1714.   save_oldobjs=$oldobjs
  1715.   # Is there a better way of finding the last object in the list?
  1716.   for obj in $save_oldobjs
  1717.   do
  1718.     last_oldobj=$obj
  1719.   done
  1720.   for obj in $save_oldobjs
  1721.   do
  1722.     oldobjs="$objlist $obj"
  1723.     objlist="$objlist $obj"
  1724.     eval test_cmds="$old_archive_cmds"
  1725.     if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  1726.        test "$len" -le "$max_cmd_len"; then
  1727.       :
  1728.     else
  1729.       # the above command should be used before it gets too long
  1730.       oldobjs=$objlist
  1731.       if test "$obj" = "$last_oldobj" ; then
  1732.         RANLIB=$save_RANLIB
  1733.       fi
  1734.       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  1735.       eval concat_cmds="${concat_cmds}$old_archive_cmds"
  1736.       objlist=
  1737.     fi
  1738.   done
  1739.   RANLIB=$save_RANLIB
  1740.   oldobjs=$objlist
  1741.   if test "X$oldobjs" = "X" ; then
  1742.     eval cmds="$concat_cmds"
  1743.   else
  1744.     eval cmds="$concat_cmds~$old_archive_cmds"
  1745.   fi
  1746. fi
  1747.       fi
  1748.       save_ifs="$IFS"; IFS='~'
  1749.       for cmd in $cmds; do
  1750.         eval cmd="$cmd"
  1751. IFS="$save_ifs"
  1752. $show "$cmd"
  1753. $run eval "$cmd" || exit $?
  1754.       done
  1755.       IFS="$save_ifs"
  1756.     done
  1757.     if test -n "$generated"; then
  1758.       $show "${rm}r$generated"
  1759.       $run ${rm}r$generated
  1760.     fi
  1761.     # Now create the libtool archive.
  1762.     case $output in
  1763.     *.la)
  1764.       old_library=
  1765.       test "$build_old_libs" = yes && old_library="$libname.$libext"
  1766.       $show "creating $output"
  1767.       # Preserve any variables that may affect compiler behavior
  1768.       for var in $variables_saved_for_relink; do
  1769. if eval test -z "${$var+set}"; then
  1770.   relink_command="{ test -z "${$var+set}" || unset $var || { $var=; export $var; }; }; $relink_command"
  1771. elif eval var_value=$$var; test -z "$var_value"; then
  1772.   relink_command="$var=; export $var; $relink_command"
  1773. else
  1774.   var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
  1775.   relink_command="$var="$var_value"; export $var; $relink_command"
  1776. fi
  1777.       done
  1778.       # Quote the link command for shipping.
  1779.       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
  1780.       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
  1781.       if test "$hardcode_automatic" = yes ; then
  1782. relink_command=
  1783.       fi
  1784.       # Only create the output if not a dry run.
  1785.       if test -z "$run"; then
  1786. for installed in no yes; do
  1787.   if test "$installed" = yes; then
  1788.     if test -z "$install_libdir"; then
  1789.       break
  1790.     fi
  1791.     output="$output_objdir/$outputname"i
  1792.     # Replace all uninstalled libtool libraries with the installed ones
  1793.     newdependency_libs=
  1794.     for deplib in $dependency_libs; do
  1795.       case $deplib in
  1796.       *.la)
  1797. name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
  1798. eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $deplib`
  1799. if test -z "$libdir"; then
  1800.   $echo "$modename: `$deplib' is not a valid libtool archive" 1>&2
  1801.   exit $EXIT_FAILURE
  1802. fi
  1803. newdependency_libs="$newdependency_libs $libdir/$name"
  1804. ;;
  1805.       *) newdependency_libs="$newdependency_libs $deplib" ;;
  1806.       esac
  1807.     done
  1808.     dependency_libs="$newdependency_libs"
  1809.     newdlfiles=
  1810.     for lib in $dlfiles; do
  1811.       name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
  1812.       eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $lib`
  1813.       if test -z "$libdir"; then
  1814. $echo "$modename: `$lib' is not a valid libtool archive" 1>&2
  1815. exit $EXIT_FAILURE
  1816.       fi
  1817.       newdlfiles="$newdlfiles $libdir/$name"
  1818.     done
  1819.     dlfiles="$newdlfiles"
  1820.     newdlprefiles=
  1821.     for lib in $dlprefiles; do
  1822.       name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
  1823.       eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $lib`
  1824.       if test -z "$libdir"; then
  1825. $echo "$modename: `$lib' is not a valid libtool archive" 1>&2
  1826. exit $EXIT_FAILURE
  1827.       fi
  1828.       newdlprefiles="$newdlprefiles $libdir/$name"
  1829.     done
  1830.     dlprefiles="$newdlprefiles"
  1831.   else
  1832.     newdlfiles=
  1833.     for lib in $dlfiles; do
  1834.       case $lib in
  1835. [\/]* | [A-Za-z]:[\/]*) abs="$lib" ;;
  1836. *) abs=`pwd`"/$lib" ;;
  1837.       esac
  1838.       newdlfiles="$newdlfiles $abs"
  1839.     done
  1840.     dlfiles="$newdlfiles"
  1841.     newdlprefiles=
  1842.     for lib in $dlprefiles; do
  1843.       case $lib in
  1844. [\/]* | [A-Za-z]:[\/]*) abs="$lib" ;;
  1845. *) abs=`pwd`"/$lib" ;;
  1846.       esac
  1847.       newdlprefiles="$newdlprefiles $abs"
  1848.     done
  1849.     dlprefiles="$newdlprefiles"
  1850.   fi
  1851.   $rm $output
  1852.   # place dlname in correct position for cygwin
  1853.   tdlname=$dlname
  1854.   case $host,$output,$installed,$module,$dlname in
  1855.     *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
  1856.   esac
  1857.   $echo > $output "
  1858. # $outputname - a libtool library file
  1859. # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  1860. #
  1861. # Please DO NOT delete this file!
  1862. # It is necessary for linking the library.
  1863. # The name that we can dlopen(3).
  1864. dlname='$tdlname'
  1865. # Names of this library.
  1866. library_names='$library_names'
  1867. # The name of the static archive.
  1868. old_library='$old_library'
  1869. # Libraries that this one depends upon.
  1870. dependency_libs='$dependency_libs'
  1871. # Version information for $libname.
  1872. current=$current
  1873. age=$age
  1874. revision=$revision
  1875. # Is this an already installed library?
  1876. installed=$installed
  1877. # Should we warn about portability when linking against -modules?
  1878. shouldnotlink=$module
  1879. # Files to dlopen/dlpreopen
  1880. dlopen='$dlfiles'
  1881. dlpreopen='$dlprefiles'
  1882. # Directory that this library needs to be installed in:
  1883. libdir='$install_libdir'"
  1884.   if test "$installed" = no && test "$need_relink" = yes; then
  1885.     $echo >> $output "
  1886. relink_command="$relink_command""
  1887.   fi
  1888. done
  1889.       fi
  1890.       # Do a symbolic link so that the libtool archive can be found in
  1891.       # LD_LIBRARY_PATH before the program is installed.
  1892.       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
  1893.       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
  1894.       ;;
  1895.     esac
  1896.     exit $EXIT_SUCCESS
  1897.     ;;
  1898.   # libtool install mode
  1899.   install)
  1900.     modename="$modename: install"
  1901.     # There may be an optional sh(1) argument at the beginning of
  1902.     # install_prog (especially on Windows NT).
  1903.     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
  1904.        # Allow the use of GNU shtool's install command.
  1905.        $echo "X$nonopt" | grep shtool > /dev/null; then
  1906.       # Aesthetically quote it.
  1907.       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
  1908.       case $arg in
  1909.       *[[~#^&*(){}|;<>?'  ]*|*]*|"")
  1910. arg=""$arg""
  1911. ;;
  1912.       esac
  1913.       install_prog="$arg "
  1914.       arg="$1"
  1915.       shift
  1916.     else
  1917.       install_prog=
  1918.       arg=$nonopt
  1919.     fi
  1920.     # The real first argument should be the name of the installation program.
  1921.     # Aesthetically quote it.
  1922.     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1923.     case $arg in
  1924.     *[[~#^&*(){}|;<>?'  ]*|*]*|"")
  1925.       arg=""$arg""
  1926.       ;;
  1927.     esac
  1928.     install_prog="$install_prog$arg"
  1929.     # We need to accept at least all the BSD install flags.
  1930.     dest=
  1931.     files=
  1932.     opts=
  1933.     prev=
  1934.     install_type=
  1935.     isdir=no
  1936.     stripme=
  1937.     for arg
  1938.     do
  1939.       if test -n "$dest"; then
  1940. files="$files $dest"
  1941. dest=$arg
  1942. continue
  1943.       fi
  1944.       case $arg in
  1945.       -d) isdir=yes ;;
  1946.       -f) 
  1947.        case " $install_prog " in
  1948. *[\ /]cp *) ;;
  1949. *) prev=$arg ;;
  1950. esac
  1951. ;;
  1952.       -g | -m | -o) prev=$arg ;;
  1953.       -s)
  1954. stripme=" -s"
  1955. continue
  1956. ;;
  1957.       -*)
  1958. ;;
  1959.       *)
  1960. # If the previous option needed an argument, then skip it.
  1961. if test -n "$prev"; then
  1962.   prev=
  1963. else
  1964.   dest=$arg
  1965.   continue
  1966. fi
  1967. ;;
  1968.       esac
  1969.       # Aesthetically quote the argument.
  1970.       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
  1971.       case $arg in
  1972.       *[[~#^&*(){}|;<>?'  ]*|*]*|"")
  1973. arg=""$arg""
  1974. ;;
  1975.       esac
  1976.       install_prog="$install_prog $arg"
  1977.     done
  1978.     if test -z "$install_prog"; then
  1979.       $echo "$modename: you must specify an install program" 1>&2
  1980.       $echo "$help" 1>&2
  1981.       exit $EXIT_FAILURE
  1982.     fi
  1983.     if test -n "$prev"; then
  1984.       $echo "$modename: the `$prev' option requires an argument" 1>&2
  1985.       $echo "$help" 1>&2
  1986.       exit $EXIT_FAILURE
  1987.     fi
  1988.     if test -z "$files"; then
  1989.       if test -z "$dest"; then
  1990. $echo "$modename: no file or destination specified" 1>&2
  1991.       else
  1992. $echo "$modename: you must specify a destination" 1>&2
  1993.       fi
  1994.       $echo "$help" 1>&2
  1995.       exit $EXIT_FAILURE
  1996.     fi
  1997.     # Strip any trailing slash from the destination.
  1998.     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
  1999.     # Check to see that the destination is a directory.
  2000.     test -d "$dest" && isdir=yes
  2001.     if test "$isdir" = yes; then
  2002.       destdir="$dest"
  2003.       destname=
  2004.     else
  2005.       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
  2006.       test "X$destdir" = "X$dest" && destdir=.
  2007.       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
  2008.       # Not a directory, so check to see that there is only one file specified.
  2009.       set dummy $files
  2010.       if test "$#" -gt 2; then
  2011. $echo "$modename: `$dest' is not a directory" 1>&2
  2012. $echo "$help" 1>&2
  2013. exit $EXIT_FAILURE
  2014.       fi
  2015.     fi
  2016.     case $destdir in
  2017.     [\/]* | [A-Za-z]:[\/]*) ;;
  2018.     *)
  2019.       for file in $files; do
  2020. case $file in
  2021. *.lo) ;;
  2022. *)
  2023.   $echo "$modename: `$destdir' must be an absolute directory name" 1>&2
  2024.   $echo "$help" 1>&2
  2025.   exit $EXIT_FAILURE
  2026.   ;;
  2027. esac
  2028.       done
  2029.       ;;
  2030.     esac
  2031.     # This variable tells wrapper scripts just to set variables rather
  2032.     # than running their programs.
  2033.     libtool_install_magic="$magic"
  2034.     staticlibs=
  2035.     future_libdirs=
  2036.     current_libdirs=
  2037.     for file in $files; do
  2038.       # Do each installation.
  2039.       case $file in
  2040.       *.$libext)
  2041. # Do the static libraries later.
  2042. staticlibs="$staticlibs $file"
  2043. ;;
  2044.       *.la)
  2045. # Check to see that this really is a libtool archive.
  2046. if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
  2047. else
  2048.   $echo "$modename: `$file' is not a valid libtool archive" 1>&2
  2049.   $echo "$help" 1>&2
  2050.   exit $EXIT_FAILURE
  2051. fi
  2052. library_names=
  2053. old_library=
  2054. relink_command=
  2055. # If there is no directory component, then add one.
  2056. case $file in
  2057. */* | *\*) . $file ;;
  2058. *) . ./$file ;;
  2059. esac
  2060. # Add the libdir to current_libdirs if it is the destination.
  2061. if test "X$destdir" = "X$libdir"; then
  2062.   case "$current_libdirs " in
  2063.   *" $libdir "*) ;;
  2064.   *) current_libdirs="$current_libdirs $libdir" ;;
  2065.   esac
  2066. else
  2067.   # Note the libdir as a future libdir.
  2068.   case "$future_libdirs " in
  2069.   *" $libdir "*) ;;
  2070.   *) future_libdirs="$future_libdirs $libdir" ;;
  2071.   esac
  2072. fi
  2073. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
  2074. test "X$dir" = "X$file/" && dir=
  2075. dir="$dir$objdir"
  2076. if test -n "$relink_command"; then
  2077.   # Determine the prefix the user has applied to our future dir.
  2078.   inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir$%%"`
  2079.   # Don't allow the user to place us outside of our expected
  2080.   # location b/c this prevents finding dependent libraries that
  2081.   # are installed to the same prefix.
  2082.   # At present, this check doesn't affect windows .dll's that
  2083.   # are installed into $libdir/../bin (currently, that works fine)
  2084.   # but it's something to keep an eye on.
  2085.   if test "$inst_prefix_dir" = "$destdir"; then
  2086.     $echo "$modename: error: cannot install `$file' to a directory not ending in $libdir" 1>&2
  2087.     exit $EXIT_FAILURE
  2088.   fi
  2089.   if test -n "$inst_prefix_dir"; then
  2090.     # Stick the inst_prefix_dir data into the link command.
  2091.     relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
  2092.   else
  2093.     relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
  2094.   fi
  2095.   $echo "$modename: warning: relinking `$file'" 1>&2
  2096.   $show "$relink_command"
  2097.   if $run eval "$relink_command"; then :
  2098.   else
  2099.     $echo "$modename: error: relink `$file' with the above command before installing it" 1>&2
  2100.     exit $EXIT_FAILURE
  2101.   fi
  2102. fi
  2103. # See the names of the shared library.
  2104. set dummy $library_names
  2105. if test -n "$2"; then
  2106.   realname="$2"
  2107.   shift
  2108.   shift
  2109.   srcname="$realname"
  2110.   test -n "$relink_command" && srcname="$realname"T
  2111.   # Install the shared library and build the symlinks.
  2112.   $show "$install_prog $dir/$srcname $destdir/$realname"
  2113.   $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
  2114.   if test -n "$stripme" && test -n "$striplib"; then
  2115.     $show "$striplib $destdir/$realname"
  2116.     $run eval "$striplib $destdir/$realname" || exit $?
  2117.   fi
  2118.   if test "$#" -gt 0; then
  2119.     # Delete the old symlinks, and create new ones.
  2120.     # Try `ln -sf' first, because the `ln' binary might depend on
  2121.     # the symlink we replace!  Solaris /bin/ln does not understand -f,
  2122.     # so we also need to try rm && ln -s.
  2123.     for linkname
  2124.     do
  2125.       if test "$linkname" != "$realname"; then
  2126.                 $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
  2127.                 $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
  2128.       fi
  2129.     done
  2130.   fi
  2131.   # Do each command in the postinstall commands.
  2132.   lib="$destdir/$realname"
  2133.   cmds=$postinstall_cmds
  2134.   save_ifs="$IFS"; IFS='~'
  2135.   for cmd in $cmds; do
  2136.     IFS="$save_ifs"
  2137.     eval cmd="$cmd"
  2138.     $show "$cmd"
  2139.     $run eval "$cmd" || {
  2140.       lt_exit=$?
  2141.       # Restore the uninstalled library and exit
  2142.       if test "$mode" = relink; then
  2143. $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
  2144.       fi
  2145.       exit $lt_exit
  2146.     }
  2147.   done
  2148.   IFS="$save_ifs"
  2149. fi
  2150. # Install the pseudo-library for information purposes.
  2151. name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2152. instname="$dir/$name"i
  2153. $show "$install_prog $instname $destdir/$name"
  2154. $run eval "$install_prog $instname $destdir/$name" || exit $?
  2155. # Maybe install the static library, too.
  2156. test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
  2157. ;;
  2158.       *.lo)
  2159. # Install (i.e. copy) a libtool object.
  2160. # Figure out destination file name, if it wasn't already specified.
  2161. if test -n "$destname"; then
  2162.   destfile="$destdir/$destname"
  2163. else
  2164.   destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2165.   destfile="$destdir/$destfile"
  2166. fi
  2167. # Deduce the name of the destination old-style object file.
  2168. case $destfile in
  2169. *.lo)
  2170.   staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
  2171.   ;;
  2172. *.$objext)
  2173.   staticdest="$destfile"
  2174.   destfile=
  2175.   ;;
  2176. *)
  2177.   $echo "$modename: cannot copy a libtool object to `$destfile'" 1>&2
  2178.   $echo "$help" 1>&2
  2179.   exit $EXIT_FAILURE
  2180.   ;;
  2181. esac
  2182. # Install the libtool object if requested.
  2183. if test -n "$destfile"; then
  2184.   $show "$install_prog $file $destfile"
  2185.   $run eval "$install_prog $file $destfile" || exit $?
  2186. fi
  2187. # Install the old object if enabled.
  2188. if test "$build_old_libs" = yes; then
  2189.   # Deduce the name of the old-style object file.
  2190.   staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
  2191.   $show "$install_prog $staticobj $staticdest"
  2192.   $run eval "$install_prog $staticobj $staticdest" || exit $?
  2193. fi
  2194. exit $EXIT_SUCCESS
  2195. ;;
  2196.       *)
  2197. # Figure out destination file name, if it wasn't already specified.
  2198. if test -n "$destname"; then
  2199.   destfile="$destdir/$destname"
  2200. else
  2201.   destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2202.   destfile="$destdir/$destfile"
  2203. fi
  2204. # If the file is missing, and there is a .exe on the end, strip it
  2205. # because it is most likely a libtool script we actually want to
  2206. # install
  2207. stripped_ext=""
  2208. case $file in
  2209.   *.exe)
  2210.     if test ! -f "$file"; then
  2211.       file=`$echo $file|${SED} 's,.exe$,,'`
  2212.       stripped_ext=".exe"
  2213.     fi
  2214.     ;;
  2215. esac
  2216. # Do a test to see if this is really a libtool program.
  2217. case $host in
  2218. *cygwin*|*mingw*)
  2219.     wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
  2220.     ;;
  2221. *)
  2222.     wrapper=$file
  2223.     ;;
  2224. esac
  2225. if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
  2226.   notinst_deplibs=
  2227.   relink_command=
  2228.   # Note that it is not necessary on cygwin/mingw to append a dot to
  2229.   # foo even if both foo and FILE.exe exist: automatic-append-.exe
  2230.   # behavior happens only for exec(3), not for open(2)!  Also, sourcing
  2231.   # `FILE.' does not work on cygwin managed mounts.
  2232.   #
  2233.   # If there is no directory component, then add one.
  2234.   case $wrapper in
  2235.   */* | *\*) . ${wrapper} ;;
  2236.   *) . ./${wrapper} ;;
  2237.   esac
  2238.   # Check the variables that should have been set.
  2239.   if test -z "$notinst_deplibs"; then
  2240.     $echo "$modename: invalid libtool wrapper script `$wrapper'" 1>&2
  2241.     exit $EXIT_FAILURE
  2242.   fi
  2243.   finalize=yes
  2244.   for lib in $notinst_deplibs; do
  2245.     # Check to see that each library is installed.
  2246.     libdir=
  2247.     if test -f "$lib"; then
  2248.       # If there is no directory component, then add one.
  2249.       case $lib in
  2250.       */* | *\*) . $lib ;;
  2251.       *) . ./$lib ;;
  2252.       esac
  2253.     fi
  2254.     libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
  2255.     if test -n "$libdir" && test ! -f "$libfile"; then
  2256.       $echo "$modename: warning: `$lib' has not been installed in `$libdir'" 1>&2
  2257.       finalize=no
  2258.     fi
  2259.   done
  2260.   relink_command=
  2261.   # Note that it is not necessary on cygwin/mingw to append a dot to
  2262.   # foo even if both foo and FILE.exe exist: automatic-append-.exe
  2263.   # behavior happens only for exec(3), not for open(2)!  Also, sourcing
  2264.   # `FILE.' does not work on cygwin managed mounts.
  2265.   #
  2266.   # If there is no directory component, then add one.
  2267.   case $wrapper in
  2268.   */* | *\*) . ${wrapper} ;;
  2269.   *) . ./${wrapper} ;;
  2270.   esac
  2271.   outputname=
  2272.   if test "$fast_install" = no && test -n "$relink_command"; then
  2273.     if test "$finalize" = yes && test -z "$run"; then
  2274.       tmpdir="/tmp"
  2275.       test -n "$TMPDIR" && tmpdir="$TMPDIR"
  2276.       tmpdir="$tmpdir/libtool-$$"
  2277.       save_umask=`umask`
  2278.       umask 0077
  2279.       if $mkdir "$tmpdir"; then
  2280.         umask $save_umask
  2281.       else
  2282.         umask $save_umask
  2283. $echo "$modename: error: cannot create temporary directory `$tmpdir'" 1>&2
  2284. continue
  2285.       fi
  2286.       file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
  2287.       outputname="$tmpdir/$file"
  2288.       # Replace the output file specification.
  2289.       relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
  2290.       $show "$relink_command"
  2291.       if $run eval "$relink_command"; then :
  2292.       else
  2293. $echo "$modename: error: relink `$file' with the above command before installing it" 1>&2
  2294. ${rm}r "$tmpdir"
  2295. continue
  2296.       fi
  2297.       file="$outputname"
  2298.     else
  2299.       $echo "$modename: warning: cannot relink `$file'" 1>&2
  2300.     fi
  2301.   else
  2302.     # Install the binary that we compiled earlier.
  2303.     file=`$echo "X$file$stripped_ext" | $Xsed -e "s%([^/]*)$%$objdir/1%"`
  2304.   fi
  2305. fi
  2306. # remove .exe since cygwin /usr/bin/install will append another
  2307. # one anyway 
  2308. case $install_prog,$host in
  2309. */usr/bin/install*,*cygwin*)
  2310.   case $file:$destfile in
  2311.   *.exe:*.exe)
  2312.     # this is ok
  2313.     ;;
  2314.   *.exe:*)
  2315.     destfile=$destfile.exe
  2316.     ;;
  2317.   *:*.exe)
  2318.     destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
  2319.     ;;
  2320.   esac
  2321.   ;;
  2322. esac
  2323. $show "$install_prog$stripme $file $destfile"
  2324. $run eval "$install_prog$stripme $file $destfile" || exit $?
  2325. test -n "$outputname" && ${rm}r "$tmpdir"
  2326. ;;
  2327.       esac
  2328.     done
  2329.     for file in $staticlibs; do
  2330.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2331.       # Set up the ranlib parameters.
  2332.       oldlib="$destdir/$name"
  2333.       $show "$install_prog $file $oldlib"
  2334.       $run eval "$install_prog $file $oldlib" || exit $?
  2335.       if test -n "$stripme" && test -n "$old_striplib"; then
  2336. $show "$old_striplib $oldlib"
  2337. $run eval "$old_striplib $oldlib" || exit $?
  2338.       fi
  2339.       # Do each command in the postinstall commands.
  2340.       cmds=$old_postinstall_cmds
  2341.       save_ifs="$IFS"; IFS='~'
  2342.       for cmd in $cmds; do
  2343. IFS="$save_ifs"
  2344. eval cmd="$cmd"
  2345. $show "$cmd"
  2346. $run eval "$cmd" || exit $?
  2347.       done
  2348.       IFS="$save_ifs"
  2349.     done
  2350.     if test -n "$future_libdirs"; then
  2351.       $echo "$modename: warning: remember to run `$progname --finish$future_libdirs'" 1>&2
  2352.     fi
  2353.     if test -n "$current_libdirs"; then
  2354.       # Maybe just do a dry run.
  2355.       test -n "$run" && current_libdirs=" -n$current_libdirs"
  2356.       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
  2357.     else
  2358.       exit $EXIT_SUCCESS
  2359.     fi
  2360.     ;;
  2361.   # libtool finish mode
  2362.   finish)
  2363.     modename="$modename: finish"
  2364.     libdirs="$nonopt"
  2365.     admincmds=
  2366.     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  2367.       for dir
  2368.       do
  2369. libdirs="$libdirs $dir"
  2370.       done
  2371.       for libdir in $libdirs; do
  2372. if test -n "$finish_cmds"; then
  2373.   # Do each command in the finish commands.
  2374.   cmds=$finish_cmds
  2375.   save_ifs="$IFS"; IFS='~'
  2376.   for cmd in $cmds; do
  2377.     IFS="$save_ifs"
  2378.     eval cmd="$cmd"
  2379.     $show "$cmd"
  2380.     $run eval "$cmd" || admincmds="$admincmds
  2381.        $cmd"
  2382.   done
  2383.   IFS="$save_ifs"
  2384. fi
  2385. if test -n "$finish_eval"; then
  2386.   # Do the single finish_eval.
  2387.   eval cmds="$finish_eval"
  2388.   $run eval "$cmds" || admincmds="$admincmds
  2389.        $cmds"
  2390. fi
  2391.       done
  2392.     fi
  2393.     # Exit here if they wanted silent mode.
  2394.     test "$show" = : && exit $EXIT_SUCCESS
  2395.     $echo "----------------------------------------------------------------------"
  2396.     $echo "Libraries have been installed in:"
  2397.     for libdir in $libdirs; do
  2398.       $echo "   $libdir"
  2399.     done
  2400.     $echo
  2401.     $echo "If you ever happen to want to link against installed libraries"
  2402.     $echo "in a given directory, LIBDIR, you must either use libtool, and"
  2403.     $echo "specify the full pathname of the library, or use the `-LLIBDIR'"
  2404.     $echo "flag during linking and do at least one of the following:"
  2405.     if test -n "$shlibpath_var"; then
  2406.       $echo "   - add LIBDIR to the `$shlibpath_var' environment variable"
  2407.       $echo "     during execution"
  2408.     fi
  2409.     if test -n "$runpath_var"; then
  2410.       $echo "   - add LIBDIR to the `$runpath_var' environment variable"
  2411.       $echo "     during linking"
  2412.     fi
  2413.     if test -n "$hardcode_libdir_flag_spec"; then
  2414.       libdir=LIBDIR
  2415.       eval flag="$hardcode_libdir_flag_spec"
  2416.       $echo "   - use the `$flag' linker flag"
  2417.     fi
  2418.     if test -n "$admincmds"; then
  2419.       $echo "   - have your system administrator run these commands:$admincmds"
  2420.     fi
  2421.     if test -f /etc/ld.so.conf; then
  2422.       $echo "   - have your system administrator add LIBDIR to `/etc/ld.so.conf'"
  2423.     fi
  2424.     $echo
  2425.     $echo "See any operating system documentation about shared libraries for"
  2426.     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
  2427.     $echo "----------------------------------------------------------------------"
  2428.     exit $EXIT_SUCCESS
  2429.     ;;
  2430.   # libtool execute mode
  2431.   execute)
  2432.     modename="$modename: execute"
  2433.     # The first argument is the command name.
  2434.     cmd="$nonopt"
  2435.     if test -z "$cmd"; then
  2436.       $echo "$modename: you must specify a COMMAND" 1>&2
  2437.       $echo "$help"
  2438.       exit $EXIT_FAILURE
  2439.     fi
  2440.     # Handle -dlopen flags immediately.
  2441.     for file in $execute_dlfiles; do
  2442.       if test ! -f "$file"; then
  2443. $echo "$modename: `$file' is not a file" 1>&2
  2444. $echo "$help" 1>&2
  2445. exit $EXIT_FAILURE
  2446.       fi
  2447.       dir=
  2448.       case $file in
  2449.       *.la)
  2450. # Check to see that this really is a libtool archive.
  2451. if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
  2452. else
  2453.   $echo "$modename: `$lib' is not a valid libtool archive" 1>&2
  2454.   $echo "$help" 1>&2
  2455.   exit $EXIT_FAILURE
  2456. fi
  2457. # Read the libtool library.
  2458. dlname=
  2459. library_names=
  2460. # If there is no directory component, then add one.
  2461. case $file in
  2462. */* | *\*) . $file ;;
  2463. *) . ./$file ;;
  2464. esac
  2465. # Skip this library if it cannot be dlopened.
  2466. if test -z "$dlname"; then
  2467.   # Warn if it was a shared library.
  2468.   test -n "$library_names" && $echo "$modename: warning: `$file' was not linked with `-export-dynamic'"
  2469.   continue
  2470. fi
  2471. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2472. test "X$dir" = "X$file" && dir=.
  2473. if test -f "$dir/$objdir/$dlname"; then
  2474.   dir="$dir/$objdir"
  2475. else
  2476.   $echo "$modename: cannot find `$dlname' in `$dir' or `$dir/$objdir'" 1>&2
  2477.   exit $EXIT_FAILURE
  2478. fi
  2479. ;;
  2480.       *.lo)
  2481. # Just add the directory containing the .lo file.
  2482. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2483. test "X$dir" = "X$file" && dir=.
  2484. ;;
  2485.       *)
  2486. $echo "$modename: warning `-dlopen' is ignored for non-libtool libraries and objects" 1>&2
  2487. continue
  2488. ;;
  2489.       esac
  2490.       # Get the absolute pathname.
  2491.       absdir=`cd "$dir" && pwd`
  2492.       test -n "$absdir" && dir="$absdir"
  2493.       # Now add the directory to shlibpath_var.
  2494.       if eval "test -z "$$shlibpath_var""; then
  2495. eval "$shlibpath_var="$dir""
  2496.       else
  2497. eval "$shlibpath_var="$dir:$$shlibpath_var""
  2498.       fi
  2499.     done
  2500.     # This variable tells wrapper scripts just to set shlibpath_var
  2501.     # rather than running their programs.
  2502.     libtool_execute_magic="$magic"
  2503.     # Check if any of the arguments is a wrapper script.
  2504.     args=
  2505.     for file
  2506.     do
  2507.       case $file in
  2508.       -*) ;;
  2509.       *)
  2510. # Do a test to see if this is really a libtool program.
  2511. if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  2512.   # If there is no directory component, then add one.
  2513.   case $file in
  2514.   */* | *\*) . $file ;;
  2515.   *) . ./$file ;;
  2516.   esac
  2517.   # Transform arg to wrapped name.
  2518.   file="$progdir/$program"
  2519. fi
  2520. ;;
  2521.       esac
  2522.       # Quote arguments (to preserve shell metacharacters).
  2523.       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
  2524.       args="$args "$file""
  2525.     done
  2526.     if test -z "$run"; then
  2527.       if test -n "$shlibpath_var"; then
  2528. # Export the shlibpath_var.
  2529. eval "export $shlibpath_var"
  2530.       fi
  2531.       # Restore saved environment variables
  2532.       if test "${save_LC_ALL+set}" = set; then
  2533. LC_ALL="$save_LC_ALL"; export LC_ALL
  2534.       fi
  2535.       if test "${save_LANG+set}" = set; then
  2536. LANG="$save_LANG"; export LANG
  2537.       fi
  2538.       # Now prepare to actually exec the command.
  2539.       exec_cmd="$cmd$args"
  2540.     else
  2541.       # Display what would be done.
  2542.       if test -n "$shlibpath_var"; then
  2543. eval "$echo "$shlibpath_var=$$shlibpath_var""
  2544. $echo "export $shlibpath_var"
  2545.       fi
  2546.       $echo "$cmd$args"
  2547.       exit $EXIT_SUCCESS
  2548.     fi
  2549.     ;;
  2550.   # libtool clean and uninstall mode
  2551.   clean | uninstall)
  2552.     modename="$modename: $mode"
  2553.     rm="$nonopt"
  2554.     files=
  2555.     rmforce=
  2556.     exit_status=0
  2557.     # This variable tells wrapper scripts just to set variables rather
  2558.     # than running their programs.
  2559.     libtool_install_magic="$magic"
  2560.     for arg
  2561.     do
  2562.       case $arg in
  2563.       -f) rm="$rm $arg"; rmforce=yes ;;
  2564.       -*) rm="$rm $arg" ;;
  2565.       *) files="$files $arg" ;;
  2566.       esac
  2567.     done
  2568.     if test -z "$rm"; then
  2569.       $echo "$modename: you must specify an RM program" 1>&2
  2570.       $echo "$help" 1>&2
  2571.       exit $EXIT_FAILURE
  2572.     fi
  2573.     rmdirs=
  2574.     origobjdir="$objdir"
  2575.     for file in $files; do
  2576.       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
  2577.       if test "X$dir" = "X$file"; then
  2578. dir=.
  2579. objdir="$origobjdir"
  2580.       else
  2581. objdir="$dir/$origobjdir"
  2582.       fi
  2583.       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
  2584.       test "$mode" = uninstall && objdir="$dir"
  2585.       # Remember objdir for removal later, being careful to avoid duplicates
  2586.       if test "$mode" = clean; then
  2587. case " $rmdirs " in
  2588.   *" $objdir "*) ;;
  2589.   *) rmdirs="$rmdirs $objdir" ;;
  2590. esac
  2591.       fi
  2592.       # Don't error if the file doesn't exist and rm -f was used.
  2593.       if (test -L "$file") >/dev/null 2>&1 
  2594. || (test -h "$file") >/dev/null 2>&1 
  2595. || test -f "$file"; then
  2596. :
  2597.       elif test -d "$file"; then
  2598. exit_status=1
  2599. continue
  2600.       elif test "$rmforce" = yes; then
  2601. continue
  2602.       fi
  2603.       rmfiles="$file"
  2604.       case $name in
  2605.       *.la)
  2606. # Possibly a libtool archive, so verify it.
  2607. if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  2608.   . $dir/$name
  2609.   # Delete the libtool libraries and symlinks.
  2610.   for n in $library_names; do
  2611.     rmfiles="$rmfiles $objdir/$n"
  2612.   done
  2613.   test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
  2614.   test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
  2615.   if test "$mode" = uninstall; then
  2616.     if test -n "$library_names"; then
  2617.       # Do each command in the postuninstall commands.
  2618.       cmds=$postuninstall_cmds
  2619.       save_ifs="$IFS"; IFS='~'
  2620.       for cmd in $cmds; do
  2621. IFS="$save_ifs"
  2622. eval cmd="$cmd"
  2623. $show "$cmd"
  2624. $run eval "$cmd"
  2625. if test "$?" -ne 0 && test "$rmforce" != yes; then
  2626.   exit_status=1
  2627. fi
  2628.       done
  2629.       IFS="$save_ifs"
  2630.     fi
  2631.     if test -n "$old_library"; then
  2632.       # Do each command in the old_postuninstall commands.
  2633.       cmds=$old_postuninstall_cmds
  2634.       save_ifs="$IFS"; IFS='~'
  2635.       for cmd in $cmds; do
  2636. IFS="$save_ifs"
  2637. eval cmd="$cmd"
  2638. $show "$cmd"
  2639. $run eval "$cmd"
  2640. if test "$?" -ne 0 && test "$rmforce" != yes; then
  2641.   exit_status=1
  2642. fi
  2643.       done
  2644.       IFS="$save_ifs"
  2645.     fi
  2646.     # FIXME: should reinstall the best remaining shared library.
  2647.   fi
  2648. fi
  2649. ;;
  2650.       *.lo)
  2651. # Possibly a libtool object, so verify it.
  2652. if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  2653.   # Read the .lo file
  2654.   . $dir/$name
  2655.   # Add PIC object to the list of files to remove.
  2656.   if test -n "$pic_object" 
  2657.      && test "$pic_object" != none; then
  2658.     rmfiles="$rmfiles $dir/$pic_object"
  2659.   fi
  2660.   # Add non-PIC object to the list of files to remove.
  2661.   if test -n "$non_pic_object" 
  2662.      && test "$non_pic_object" != none; then
  2663.     rmfiles="$rmfiles $dir/$non_pic_object"
  2664.   fi
  2665. fi
  2666. ;;
  2667.       *)
  2668. if test "$mode" = clean ; then
  2669.   noexename=$name
  2670.   case $file in
  2671.   *.exe)
  2672.     file=`$echo $file|${SED} 's,.exe$,,'`
  2673.     noexename=`$echo $name|${SED} 's,.exe$,,'`
  2674.     # $file with .exe has already been added to rmfiles,
  2675.     # add $file without .exe
  2676.     rmfiles="$rmfiles $file"
  2677.     ;;
  2678.   esac
  2679.   # Do a test to see if this is a libtool program.
  2680.   if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
  2681.     relink_command=
  2682.     . $dir/$noexename
  2683.     # note $name still contains .exe if it was in $file originally
  2684.     # as does the version of $file that was added into $rmfiles
  2685.     rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
  2686.     if test "$fast_install" = yes && test -n "$relink_command"; then
  2687.       rmfiles="$rmfiles $objdir/lt-$name"
  2688.     fi
  2689.     if test "X$noexename" != "X$name" ; then
  2690.       rmfiles="$rmfiles $objdir/lt-${noexename}.c"
  2691.     fi
  2692.   fi
  2693. fi
  2694. ;;
  2695.       esac
  2696.       $show "$rm $rmfiles"
  2697.       $run $rm $rmfiles || exit_status=1
  2698.     done
  2699.     objdir="$origobjdir"
  2700.     # Try to remove the ${objdir}s in the directories where we deleted files
  2701.     for dir in $rmdirs; do
  2702.       if test -d "$dir"; then
  2703. $show "rmdir $dir"
  2704. $run rmdir $dir >/dev/null 2>&1
  2705.       fi
  2706.     done
  2707.     exit $exit_status
  2708.     ;;
  2709.   "")
  2710.     $echo "$modename: you must specify a MODE" 1>&2
  2711.     $echo "$generic_help" 1>&2
  2712.     exit $EXIT_FAILURE
  2713.     ;;
  2714.   esac
  2715.   if test -z "$exec_cmd"; then
  2716.     $echo "$modename: invalid operation mode `$mode'" 1>&2
  2717.     $echo "$generic_help" 1>&2
  2718.     exit $EXIT_FAILURE
  2719.   fi
  2720. fi # test -z "$show_help"
  2721. if test -n "$exec_cmd"; then
  2722.   eval exec $exec_cmd
  2723.   exit $EXIT_FAILURE
  2724. fi
  2725. # We need to display help for each of the modes.
  2726. case $mode in
  2727. "") $echo 
  2728. "Usage: $modename [OPTION]... [MODE-ARG]...
  2729. Provide generalized library-building support services.
  2730.     --config          show all configuration variables
  2731.     --debug           enable verbose shell tracing
  2732. -n, --dry-run         display commands without modifying any files
  2733.     --features        display basic configuration information and exit
  2734.     --finish          same as `--mode=finish'
  2735.     --help            display this help message and exit
  2736.     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
  2737.     --quiet           same as `--silent'
  2738.     --silent          don't print informational messages
  2739.     --tag=TAG         use configuration variables from tag TAG
  2740.     --version         print version information
  2741. MODE must be one of the following:
  2742.       clean           remove files from the build directory
  2743.       compile         compile a source file into a libtool object
  2744.       execute         automatically set library path, then run a program
  2745.       finish          complete the installation of libtool libraries
  2746.       install         install libraries or executables
  2747.       link            create a library or an executable
  2748.       uninstall       remove libraries from an installed directory
  2749. MODE-ARGS vary depending on the MODE.  Try `$modename --help --mode=MODE' for
  2750. a more detailed description of MODE.
  2751. Report bugs to <bug-libtool@gnu.org>."
  2752.   exit $EXIT_SUCCESS
  2753.   ;;
  2754. clean)
  2755.   $echo 
  2756. "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
  2757. Remove files from the build directory.
  2758. RM is the name of the program to use to delete files associated with each FILE
  2759. (typically `/bin/rm').  RM-OPTIONS are options (such as `-f') to be passed
  2760. to RM.
  2761. If FILE is a libtool library, object or program, all the files associated
  2762. with it are deleted. Otherwise, only FILE itself is deleted using RM."
  2763.   ;;
  2764. compile)
  2765.   $echo 
  2766. "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
  2767. Compile a source file into a libtool library object.
  2768. This mode accepts the following additional options:
  2769.   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  2770.   -prefer-pic       try to building PIC objects only
  2771.   -prefer-non-pic   try to building non-PIC objects only
  2772.   -static           always build a `.o' file suitable for static linking
  2773. COMPILE-COMMAND is a command to be used in creating a `standard' object file
  2774. from the given SOURCEFILE.
  2775. The output file name is determined by removing the directory component from
  2776. SOURCEFILE, then substituting the C source code suffix `.c' with the
  2777. library object suffix, `.lo'."
  2778.   ;;
  2779. execute)
  2780.   $echo 
  2781. "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
  2782. Automatically set library path, then run a program.
  2783. This mode accepts the following additional options:
  2784.   -dlopen FILE      add the directory containing FILE to the library path
  2785. This mode sets the library path environment variable according to `-dlopen'
  2786. flags.
  2787. If any of the ARGS are libtool executable wrappers, then they are translated
  2788. into their corresponding uninstalled binary, and any of their required library
  2789. directories are added to the library path.
  2790. Then, COMMAND is executed, with ARGS as arguments."
  2791.   ;;
  2792. finish)
  2793.   $echo 
  2794. "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
  2795. Complete the installation of libtool libraries.
  2796. Each LIBDIR is a directory that contains libtool libraries.
  2797. The commands that this mode executes may require superuser privileges.  Use
  2798. the `--dry-run' option if you just want to see what would be executed."
  2799.   ;;
  2800. install)
  2801.   $echo 
  2802. "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
  2803. Install executables or libraries.
  2804. INSTALL-COMMAND is the installation command.  The first component should be
  2805. either the `install' or `cp' program.
  2806. The rest of the components are interpreted as arguments to that command (only
  2807. BSD-compatible install options are recognized)."
  2808.   ;;
  2809. link)
  2810.   $echo 
  2811. "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
  2812. Link object files or libraries together to form another library, or to
  2813. create an executable program.
  2814. LINK-COMMAND is a command using the C compiler that you would use to create
  2815. a program from several object files.
  2816. The following components of LINK-COMMAND are treated specially:
  2817.   -all-static       do not do any dynamic linking at all
  2818.   -avoid-version    do not add a version suffix if possible
  2819.   -dlopen FILE      `-dlpreopen' FILE if it cannot be dlopened at runtime
  2820.   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  2821.   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  2822.   -export-symbols SYMFILE
  2823.     try to export only the symbols listed in SYMFILE
  2824.   -export-symbols-regex REGEX
  2825.     try to export only the symbols matching REGEX
  2826.   -LLIBDIR          search LIBDIR for required installed libraries
  2827.   -lNAME            OUTPUT-FILE requires the installed library libNAME
  2828.   -module           build a library that can dlopened
  2829.   -no-fast-install  disable the fast-install mode
  2830.   -no-install       link a not-installable executable
  2831.   -no-undefined     declare that a library does not refer to external symbols
  2832.   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  2833.   -objectlist FILE  Use a list of object files found in FILE to specify objects
  2834.   -precious-files-regex REGEX
  2835.                     don't remove output files matching REGEX
  2836.   -release RELEASE  specify package release information
  2837.   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  2838.   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  2839.   -static           do not do any dynamic linking of libtool libraries
  2840.   -version-info CURRENT[:REVISION[:AGE]]
  2841.     specify library version info [each variable defaults to 0]
  2842. All other options (arguments beginning with `-') are ignored.
  2843. Every other argument is treated as a filename.  Files ending in `.la' are
  2844. treated as uninstalled libtool libraries, other files are standard or library
  2845. object files.
  2846. If the OUTPUT-FILE ends in `.la', then a libtool library is created,
  2847. only library objects (`.lo' files) may be specified, and `-rpath' is
  2848. required, except when creating a convenience library.
  2849. If OUTPUT-FILE ends in `.a' or `.lib', then a standard library is created
  2850. using `ar' and `ranlib', or on Windows using `lib'.
  2851. If OUTPUT-FILE ends in `.lo' or `.${objext}', then a reloadable object file
  2852. is created, otherwise an executable program is created."
  2853.   ;;
  2854. uninstall)
  2855.   $echo 
  2856. "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
  2857. Remove libraries from an installation directory.
  2858. RM is the name of the program to use to delete files associated with each FILE
  2859. (typically `/bin/rm').  RM-OPTIONS are options (such as `-f') to be passed
  2860. to RM.
  2861. If FILE is a libtool library, all the files associated with it are deleted.
  2862. Otherwise, only FILE itself is deleted using RM."
  2863.   ;;
  2864. *)
  2865.   $echo "$modename: invalid operation mode `$mode'" 1>&2
  2866.   $echo "$help" 1>&2
  2867.   exit $EXIT_FAILURE
  2868.   ;;
  2869. esac
  2870. $echo
  2871. $echo "Try `$modename --help' for more information about other modes."
  2872. exit $?
  2873. # The TAGs below are defined such that we never get into a situation
  2874. # in which we disable both kinds of libraries.  Given conflicting
  2875. # choices, we go for a static library, that is the most portable,
  2876. # since we can't tell whether shared libraries were disabled because
  2877. # the user asked for that or because the platform doesn't support
  2878. # them.  This is particularly important on AIX, because we don't
  2879. # support having both static and shared libraries enabled at the same
  2880. # time on that platform, so we default to a shared-only configuration.
  2881. # If a disable-shared tag is given, we'll fallback to a static-only
  2882. # configuration.  But we'll never go from static-only to shared-only.
  2883. # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
  2884. build_libtool_libs=no
  2885. build_old_libs=yes
  2886. # ### END LIBTOOL TAG CONFIG: disable-shared
  2887. # ### BEGIN LIBTOOL TAG CONFIG: disable-static
  2888. build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
  2889. # ### END LIBTOOL TAG CONFIG: disable-static
  2890. # Local Variables:
  2891. # mode:shell-script
  2892. # sh-indentation:2
  2893. # End: