ltmain.sh
上传用户:rrhhcc
上传日期:2015-12-11
资源大小:54129k
文件大小:194k
源码类别:

通讯编程

开发平台:

Visual C++

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