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

网格计算

开发平台:

Java

  1.   ;;
  2. esac
  3. continue
  4. ;;
  5.       -L*)
  6. func_stripname '-L' '' "$arg"
  7. dir=$func_stripname_result
  8. # We need an absolute path.
  9. case $dir in
  10. [\/]* | [A-Za-z]:[\/]*) ;;
  11. *)
  12.   absdir=`cd "$dir" && pwd`
  13.   test -z "$absdir" && 
  14.     func_fatal_error "cannot determine absolute directory name of `$dir'"
  15.   dir="$absdir"
  16.   ;;
  17. esac
  18. case "$deplibs " in
  19. *" -L$dir "*) ;;
  20. *)
  21.   deplibs="$deplibs -L$dir"
  22.   lib_search_path="$lib_search_path $dir"
  23.   ;;
  24. esac
  25. case $host in
  26. *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
  27.   testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
  28.   case :$dllsearchpath: in
  29.   *":$dir:"*) ;;
  30.   *) dllsearchpath="$dllsearchpath:$dir";;
  31.   esac
  32.   case :$dllsearchpath: in
  33.   *":$testbindir:"*) ;;
  34.   *) dllsearchpath="$dllsearchpath:$testbindir";;
  35.   esac
  36.   ;;
  37. esac
  38. continue
  39. ;;
  40.       -l*)
  41. if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
  42.   case $host in
  43.   *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
  44.     # These systems don't actually have a C or math library (as such)
  45.     continue
  46.     ;;
  47.   *-*-os2*)
  48.     # These systems don't actually have a C library (as such)
  49.     test "X$arg" = "X-lc" && continue
  50.     ;;
  51.   *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
  52.     # Do not include libc due to us having libc/libc_r.
  53.     test "X$arg" = "X-lc" && continue
  54.     ;;
  55.   *-*-rhapsody* | *-*-darwin1.[012])
  56.     # Rhapsody C and math libraries are in the System framework
  57.     deplibs="$deplibs System.ltframework"
  58.     continue
  59.     ;;
  60.   *-*-sco3.2v5* | *-*-sco5v6*)
  61.     # Causes problems with __ctype
  62.     test "X$arg" = "X-lc" && continue
  63.     ;;
  64.   *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
  65.     # Compiler inserts libc in the correct place for threads to work
  66.     test "X$arg" = "X-lc" && continue
  67.     ;;
  68.   esac
  69. elif test "X$arg" = "X-lc_r"; then
  70.  case $host in
  71.  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
  72.    # Do not include libc_r directly, use -pthread flag.
  73.    continue
  74.    ;;
  75.  esac
  76. fi
  77. deplibs="$deplibs $arg"
  78. continue
  79. ;;
  80.       -module)
  81. module=yes
  82. continue
  83. ;;
  84.       # Tru64 UNIX uses -model [arg] to determine the layout of C++
  85.       # classes, name mangling, and exception handling.
  86.       # Darwin uses the -arch flag to determine output architecture.
  87.       -model|-arch|-isysroot)
  88. compiler_flags="$compiler_flags $arg"
  89. func_append compile_command " $arg"
  90. func_append finalize_command " $arg"
  91. prev=xcompiler
  92. continue
  93. ;;
  94.       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
  95. compiler_flags="$compiler_flags $arg"
  96. func_append compile_command " $arg"
  97. func_append finalize_command " $arg"
  98. case "$new_inherited_linker_flags " in
  99.     *" $arg "*) ;;
  100.     * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
  101. esac
  102. continue
  103. ;;
  104.       -multi_module)
  105. single_module="${wl}-multi_module"
  106. continue
  107. ;;
  108.       -no-fast-install)
  109. fast_install=no
  110. continue
  111. ;;
  112.       -no-install)
  113. case $host in
  114. *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
  115.   # The PATH hackery in wrapper scripts is required on Windows
  116.   # and Darwin in order for the loader to find any dlls it needs.
  117.   func_warning "`-no-install' is ignored for $host"
  118.   func_warning "assuming `-no-fast-install' instead"
  119.   fast_install=no
  120.   ;;
  121. *) no_install=yes ;;
  122. esac
  123. continue
  124. ;;
  125.       -no-undefined)
  126. allow_undefined=no
  127. continue
  128. ;;
  129.       -objectlist)
  130. prev=objectlist
  131. continue
  132. ;;
  133.       -o) prev=output ;;
  134.       -precious-files-regex)
  135. prev=precious_regex
  136. continue
  137. ;;
  138.       -release)
  139. prev=release
  140. continue
  141. ;;
  142.       -rpath)
  143. prev=rpath
  144. continue
  145. ;;
  146.       -R)
  147. prev=xrpath
  148. continue
  149. ;;
  150.       -R*)
  151. func_stripname '-R' '' "$arg"
  152. dir=$func_stripname_result
  153. # We need an absolute path.
  154. case $dir in
  155. [\/]* | [A-Za-z]:[\/]*) ;;
  156. *)
  157.   func_fatal_error "only absolute run-paths are allowed"
  158.   ;;
  159. esac
  160. case "$xrpath " in
  161. *" $dir "*) ;;
  162. *) xrpath="$xrpath $dir" ;;
  163. esac
  164. continue
  165. ;;
  166.       -shared)
  167. # The effects of -shared are defined in a previous loop.
  168. continue
  169. ;;
  170.       -shrext)
  171. prev=shrext
  172. continue
  173. ;;
  174.       -static | -static-libtool-libs)
  175. # The effects of -static are defined in a previous loop.
  176. # We used to do the same as -all-static on platforms that
  177. # didn't have a PIC flag, but the assumption that the effects
  178. # would be equivalent was wrong.  It would break on at least
  179. # Digital Unix and AIX.
  180. continue
  181. ;;
  182.       -thread-safe)
  183. thread_safe=yes
  184. continue
  185. ;;
  186.       -version-info)
  187. prev=vinfo
  188. continue
  189. ;;
  190.       -version-number)
  191. prev=vinfo
  192. vinfo_number=yes
  193. continue
  194. ;;
  195.       -weak)
  196.         prev=weak
  197. continue
  198. ;;
  199.       -Wc,*)
  200. func_stripname '-Wc,' '' "$arg"
  201. args=$func_stripname_result
  202. arg=
  203. save_ifs="$IFS"; IFS=','
  204. for flag in $args; do
  205.   IFS="$save_ifs"
  206.           func_quote_for_eval "$flag"
  207.   arg="$arg $wl$func_quote_for_eval_result"
  208.   compiler_flags="$compiler_flags $func_quote_for_eval_result"
  209. done
  210. IFS="$save_ifs"
  211. func_stripname ' ' '' "$arg"
  212. arg=$func_stripname_result
  213. ;;
  214.       -Wl,*)
  215. func_stripname '-Wl,' '' "$arg"
  216. args=$func_stripname_result
  217. arg=
  218. save_ifs="$IFS"; IFS=','
  219. for flag in $args; do
  220.   IFS="$save_ifs"
  221.           func_quote_for_eval "$flag"
  222.   arg="$arg $wl$func_quote_for_eval_result"
  223.   compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
  224.   linker_flags="$linker_flags $func_quote_for_eval_result"
  225. done
  226. IFS="$save_ifs"
  227. func_stripname ' ' '' "$arg"
  228. arg=$func_stripname_result
  229. ;;
  230.       -Xcompiler)
  231. prev=xcompiler
  232. continue
  233. ;;
  234.       -Xlinker)
  235. prev=xlinker
  236. continue
  237. ;;
  238.       -XCClinker)
  239. prev=xcclinker
  240. continue
  241. ;;
  242.       # -msg_* for osf cc
  243.       -msg_*)
  244. func_quote_for_eval "$arg"
  245. arg="$func_quote_for_eval_result"
  246. ;;
  247.       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
  248.       # -r[0-9][0-9]* specifies the processor on the SGI compiler
  249.       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
  250.       # +DA*, +DD* enable 64-bit mode on the HP compiler
  251.       # -q* pass through compiler args for the IBM compiler
  252.       # -m*, -t[45]*, -txscale* pass through architecture-specific
  253.       # compiler args for GCC
  254.       # -F/path gives path to uninstalled frameworks, gcc on darwin
  255.       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
  256.       # @file GCC response files
  257.       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| 
  258.       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
  259.         func_quote_for_eval "$arg"
  260. arg="$func_quote_for_eval_result"
  261.         func_append compile_command " $arg"
  262.         func_append finalize_command " $arg"
  263.         compiler_flags="$compiler_flags $arg"
  264.         continue
  265.         ;;
  266.       # Some other compiler flag.
  267.       -* | +*)
  268.         func_quote_for_eval "$arg"
  269. arg="$func_quote_for_eval_result"
  270. ;;
  271.       *.$objext)
  272. # A standard object.
  273. objs="$objs $arg"
  274. ;;
  275.       *.lo)
  276. # A libtool-controlled object.
  277. # Check to see that this really is a libtool object.
  278. if func_lalib_unsafe_p "$arg"; then
  279.   pic_object=
  280.   non_pic_object=
  281.   # Read the .lo file
  282.   func_source "$arg"
  283.   if test -z "$pic_object" ||
  284.      test -z "$non_pic_object" ||
  285.      test "$pic_object" = none &&
  286.      test "$non_pic_object" = none; then
  287.     func_fatal_error "cannot find name of object for `$arg'"
  288.   fi
  289.   # Extract subdirectory from the argument.
  290.   func_dirname "$arg" "/" ""
  291.   xdir="$func_dirname_result"
  292.   if test "$pic_object" != none; then
  293.     # Prepend the subdirectory the object is found in.
  294.     pic_object="$xdir$pic_object"
  295.     if test "$prev" = dlfiles; then
  296.       if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
  297. dlfiles="$dlfiles $pic_object"
  298. prev=
  299. continue
  300.       else
  301. # If libtool objects are unsupported, then we need to preload.
  302. prev=dlprefiles
  303.       fi
  304.     fi
  305.     # CHECK ME:  I think I busted this.  -Ossama
  306.     if test "$prev" = dlprefiles; then
  307.       # Preload the old-style object.
  308.       dlprefiles="$dlprefiles $pic_object"
  309.       prev=
  310.     fi
  311.     # A PIC object.
  312.     func_append libobjs " $pic_object"
  313.     arg="$pic_object"
  314.   fi
  315.   # Non-PIC object.
  316.   if test "$non_pic_object" != none; then
  317.     # Prepend the subdirectory the object is found in.
  318.     non_pic_object="$xdir$non_pic_object"
  319.     # A standard non-PIC object
  320.     func_append non_pic_objects " $non_pic_object"
  321.     if test -z "$pic_object" || test "$pic_object" = none ; then
  322.       arg="$non_pic_object"
  323.     fi
  324.   else
  325.     # If the PIC object exists, use it instead.
  326.     # $xdir was prepended to $pic_object above.
  327.     non_pic_object="$pic_object"
  328.     func_append non_pic_objects " $non_pic_object"
  329.   fi
  330. else
  331.   # Only an error if not doing a dry-run.
  332.   if $opt_dry_run; then
  333.     # Extract subdirectory from the argument.
  334.     func_dirname "$arg" "/" ""
  335.     xdir="$func_dirname_result"
  336.     func_lo2o "$arg"
  337.     pic_object=$xdir$objdir/$func_lo2o_result
  338.     non_pic_object=$xdir$func_lo2o_result
  339.     func_append libobjs " $pic_object"
  340.     func_append non_pic_objects " $non_pic_object"
  341.   else
  342.     func_fatal_error "`$arg' is not a valid libtool object"
  343.   fi
  344. fi
  345. ;;
  346.       *.$libext)
  347. # An archive.
  348. deplibs="$deplibs $arg"
  349. old_deplibs="$old_deplibs $arg"
  350. continue
  351. ;;
  352.       *.la)
  353. # A libtool-controlled library.
  354. if test "$prev" = dlfiles; then
  355.   # This library was specified with -dlopen.
  356.   dlfiles="$dlfiles $arg"
  357.   prev=
  358. elif test "$prev" = dlprefiles; then
  359.   # The library was specified with -dlpreopen.
  360.   dlprefiles="$dlprefiles $arg"
  361.   prev=
  362. else
  363.   deplibs="$deplibs $arg"
  364. fi
  365. continue
  366. ;;
  367.       # Some other compiler argument.
  368.       *)
  369. # Unknown arguments in both finalize_command and compile_command need
  370. # to be aesthetically quoted because they are evaled later.
  371. func_quote_for_eval "$arg"
  372. arg="$func_quote_for_eval_result"
  373. ;;
  374.       esac # arg
  375.       # Now actually substitute the argument into the commands.
  376.       if test -n "$arg"; then
  377. func_append compile_command " $arg"
  378. func_append finalize_command " $arg"
  379.       fi
  380.     done # argument parsing loop
  381.     test -n "$prev" && 
  382.       func_fatal_help "the `$prevarg' option requires an argument"
  383.     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
  384.       eval arg="$export_dynamic_flag_spec"
  385.       func_append compile_command " $arg"
  386.       func_append finalize_command " $arg"
  387.     fi
  388.     oldlibs=
  389.     # calculate the name of the file, without its directory
  390.     func_basename "$output"
  391.     outputname="$func_basename_result"
  392.     libobjs_save="$libobjs"
  393.     if test -n "$shlibpath_var"; then
  394.       # get the directories listed in $shlibpath_var
  395.       eval shlib_search_path=`$ECHO "X${$shlibpath_var}" | $Xsed -e 's/:/ /g'`
  396.     else
  397.       shlib_search_path=
  398.     fi
  399.     eval sys_lib_search_path="$sys_lib_search_path_spec"
  400.     eval sys_lib_dlsearch_path="$sys_lib_dlsearch_path_spec"
  401.     func_dirname "$output" "/" ""
  402.     output_objdir="$func_dirname_result$objdir"
  403.     # Create the object directory.
  404.     func_mkdir_p "$output_objdir"
  405.     # Determine the type of output
  406.     case $output in
  407.     "")
  408.       func_fatal_help "you must specify an output file"
  409.       ;;
  410.     *.$libext) linkmode=oldlib ;;
  411.     *.lo | *.$objext) linkmode=obj ;;
  412.     *.la) linkmode=lib ;;
  413.     *) linkmode=prog ;; # Anything else should be a program.
  414.     esac
  415.     specialdeplibs=
  416.     libs=
  417.     # Find all interdependent deplibs by searching for libraries
  418.     # that are linked more than once (e.g. -la -lb -la)
  419.     for deplib in $deplibs; do
  420.       if $opt_duplicate_deps ; then
  421. case "$libs " in
  422. *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
  423. esac
  424.       fi
  425.       libs="$libs $deplib"
  426.     done
  427.     if test "$linkmode" = lib; then
  428.       libs="$predeps $libs $compiler_lib_search_path $postdeps"
  429.       # Compute libraries that are listed more than once in $predeps
  430.       # $postdeps and mark them as special (i.e., whose duplicates are
  431.       # not to be eliminated).
  432.       pre_post_deps=
  433.       if $opt_duplicate_compiler_generated_deps; then
  434. for pre_post_dep in $predeps $postdeps; do
  435.   case "$pre_post_deps " in
  436.   *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
  437.   esac
  438.   pre_post_deps="$pre_post_deps $pre_post_dep"
  439. done
  440.       fi
  441.       pre_post_deps=
  442.     fi
  443.     deplibs=
  444.     newdependency_libs=
  445.     newlib_search_path=
  446.     need_relink=no # whether we're linking any uninstalled libtool libraries
  447.     notinst_deplibs= # not-installed libtool libraries
  448.     notinst_path= # paths that contain not-installed libtool libraries
  449.     case $linkmode in
  450.     lib)
  451. passes="conv dlpreopen link"
  452. for file in $dlfiles $dlprefiles; do
  453.   case $file in
  454.   *.la) ;;
  455.   *)
  456.     func_fatal_help "libraries can `-dlopen' only libtool libraries: $file"
  457.     ;;
  458.   esac
  459. done
  460. ;;
  461.     prog)
  462. compile_deplibs=
  463. finalize_deplibs=
  464. alldeplibs=no
  465. newdlfiles=
  466. newdlprefiles=
  467. passes="conv scan dlopen dlpreopen link"
  468. ;;
  469.     *)  passes="conv"
  470. ;;
  471.     esac
  472.     for pass in $passes; do
  473.       # The preopen pass in lib mode reverses $deplibs; put it back here
  474.       # so that -L comes before libs that need it for instance...
  475.       if test "$linkmode,$pass" = "lib,link"; then
  476. ## FIXME: Find the place where the list is rebuilt in the wrong
  477. ##        order, and fix it there properly
  478.         tmp_deplibs=
  479. for deplib in $deplibs; do
  480.   tmp_deplibs="$deplib $tmp_deplibs"
  481. done
  482. deplibs="$tmp_deplibs"
  483.       fi
  484.       if test "$linkmode,$pass" = "lib,link" ||
  485.  test "$linkmode,$pass" = "prog,scan"; then
  486. libs="$deplibs"
  487. deplibs=
  488.       fi
  489.       if test "$linkmode" = prog; then
  490. case $pass in
  491. dlopen) libs="$dlfiles" ;;
  492. dlpreopen) libs="$dlprefiles" ;;
  493. link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
  494. esac
  495.       fi
  496.       if test "$linkmode,$pass" = "lib,dlpreopen"; then
  497. # Collect and forward deplibs of preopened libtool libs
  498. for lib in $dlprefiles; do
  499.   # Ignore non-libtool-libs
  500.   dependency_libs=
  501.   case $lib in
  502.   *.la) func_source "$lib" ;;
  503.   esac
  504.   # Collect preopened libtool deplibs, except any this library
  505.   # has declared as weak libs
  506.   for deplib in $dependency_libs; do
  507.             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
  508.     case " $weak_libs " in
  509.     *" $deplib_base "*) ;;
  510.     *) deplibs="$deplibs $deplib" ;;
  511.     esac
  512.   done
  513. done
  514. libs="$dlprefiles"
  515.       fi
  516.       if test "$pass" = dlopen; then
  517. # Collect dlpreopened libraries
  518. save_deplibs="$deplibs"
  519. deplibs=
  520.       fi
  521.       for deplib in $libs; do
  522. lib=
  523. found=no
  524. case $deplib in
  525. -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
  526.   if test "$linkmode,$pass" = "prog,link"; then
  527.     compile_deplibs="$deplib $compile_deplibs"
  528.     finalize_deplibs="$deplib $finalize_deplibs"
  529.   else
  530.     compiler_flags="$compiler_flags $deplib"
  531.     if test "$linkmode" = lib ; then
  532. case "$new_inherited_linker_flags " in
  533.     *" $deplib "*) ;;
  534.     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
  535. esac
  536.     fi
  537.   fi
  538.   continue
  539.   ;;
  540. -l*)
  541.   if test "$linkmode" != lib && test "$linkmode" != prog; then
  542.     func_warning "`-l' is ignored for archives/objects"
  543.     continue
  544.   fi
  545.   func_stripname '-l' '' "$deplib"
  546.   name=$func_stripname_result
  547.   if test "$linkmode" = lib; then
  548.     searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
  549.   else
  550.     searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
  551.   fi
  552.   for searchdir in $searchdirs; do
  553.     for search_ext in .la $std_shrext .so .a; do
  554.       # Search the libtool library
  555.       lib="$searchdir/lib${name}${search_ext}"
  556.       if test -f "$lib"; then
  557. if test "$search_ext" = ".la"; then
  558.   found=yes
  559. else
  560.   found=no
  561. fi
  562. break 2
  563.       fi
  564.     done
  565.   done
  566.   if test "$found" != yes; then
  567.     # deplib doesn't seem to be a libtool library
  568.     if test "$linkmode,$pass" = "prog,link"; then
  569.       compile_deplibs="$deplib $compile_deplibs"
  570.       finalize_deplibs="$deplib $finalize_deplibs"
  571.     else
  572.       deplibs="$deplib $deplibs"
  573.       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
  574.     fi
  575.     continue
  576.   else # deplib is a libtool library
  577.     # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
  578.     # We need to do some special things here, and not later.
  579.     if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  580.       case " $predeps $postdeps " in
  581.       *" $deplib "*)
  582. if func_lalib_p "$lib"; then
  583.   library_names=
  584.   old_library=
  585.   func_source "$lib"
  586.   for l in $old_library $library_names; do
  587.     ll="$l"
  588.   done
  589.   if test "X$ll" = "X$old_library" ; then # only static version available
  590.     found=no
  591.     func_dirname "$lib" "" "."
  592.     ladir="$func_dirname_result"
  593.     lib=$ladir/$old_library
  594.     if test "$linkmode,$pass" = "prog,link"; then
  595.       compile_deplibs="$deplib $compile_deplibs"
  596.       finalize_deplibs="$deplib $finalize_deplibs"
  597.     else
  598.       deplibs="$deplib $deplibs"
  599.       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
  600.     fi
  601.     continue
  602.   fi
  603. fi
  604. ;;
  605.       *) ;;
  606.       esac
  607.     fi
  608.   fi
  609.   ;; # -l
  610. *.ltframework)
  611.   if test "$linkmode,$pass" = "prog,link"; then
  612.     compile_deplibs="$deplib $compile_deplibs"
  613.     finalize_deplibs="$deplib $finalize_deplibs"
  614.   else
  615.     deplibs="$deplib $deplibs"
  616.     if test "$linkmode" = lib ; then
  617. case "$new_inherited_linker_flags " in
  618.     *" $deplib "*) ;;
  619.     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
  620. esac
  621.     fi
  622.   fi
  623.   continue
  624.   ;;
  625. -L*)
  626.   case $linkmode in
  627.   lib)
  628.     deplibs="$deplib $deplibs"
  629.     test "$pass" = conv && continue
  630.     newdependency_libs="$deplib $newdependency_libs"
  631.     func_stripname '-L' '' "$deplib"
  632.     newlib_search_path="$newlib_search_path $func_stripname_result"
  633.     ;;
  634.   prog)
  635.     if test "$pass" = conv; then
  636.       deplibs="$deplib $deplibs"
  637.       continue
  638.     fi
  639.     if test "$pass" = scan; then
  640.       deplibs="$deplib $deplibs"
  641.     else
  642.       compile_deplibs="$deplib $compile_deplibs"
  643.       finalize_deplibs="$deplib $finalize_deplibs"
  644.     fi
  645.     func_stripname '-L' '' "$deplib"
  646.     newlib_search_path="$newlib_search_path $func_stripname_result"
  647.     ;;
  648.   *)
  649.     func_warning "`-L' is ignored for archives/objects"
  650.     ;;
  651.   esac # linkmode
  652.   continue
  653.   ;; # -L
  654. -R*)
  655.   if test "$pass" = link; then
  656.     func_stripname '-R' '' "$deplib"
  657.     dir=$func_stripname_result
  658.     # Make sure the xrpath contains only unique directories.
  659.     case "$xrpath " in
  660.     *" $dir "*) ;;
  661.     *) xrpath="$xrpath $dir" ;;
  662.     esac
  663.   fi
  664.   deplibs="$deplib $deplibs"
  665.   continue
  666.   ;;
  667. *.la) lib="$deplib" ;;
  668. *.$libext)
  669.   if test "$pass" = conv; then
  670.     deplibs="$deplib $deplibs"
  671.     continue
  672.   fi
  673.   case $linkmode in
  674.   lib)
  675.     # Linking convenience modules into shared libraries is allowed,
  676.     # but linking other static libraries is non-portable.
  677.     case " $dlpreconveniencelibs " in
  678.     *" $deplib "*) ;;
  679.     *)
  680.       valid_a_lib=no
  681.       case $deplibs_check_method in
  682. match_pattern*)
  683.   set dummy $deplibs_check_method; shift
  684.   match_pattern_regex=`expr "$deplibs_check_method" : "$1 (.*)"`
  685.   if eval "$ECHO "X$deplib"" 2>/dev/null | $Xsed -e 10q 
  686.     | $EGREP "$match_pattern_regex" > /dev/null; then
  687.     valid_a_lib=yes
  688.   fi
  689. ;;
  690. pass_all)
  691.   valid_a_lib=yes
  692. ;;
  693.       esac
  694.       if test "$valid_a_lib" != yes; then
  695. $ECHO
  696. $ECHO "*** Warning: Trying to link with static lib archive $deplib."
  697. $ECHO "*** I have the capability to make that library automatically link in when"
  698. $ECHO "*** you link to this library.  But I can only do this if you have a"
  699. $ECHO "*** shared version of the library, which you do not appear to have"
  700. $ECHO "*** because the file extensions .$libext of this argument makes me believe"
  701. $ECHO "*** that it is just a static archive that I should not use here."
  702.       else
  703. $ECHO
  704. $ECHO "*** Warning: Linking the shared library $output against the"
  705. $ECHO "*** static library $deplib is not portable!"
  706. deplibs="$deplib $deplibs"
  707.       fi
  708.       ;;
  709.     esac
  710.     continue
  711.     ;;
  712.   prog)
  713.     if test "$pass" != link; then
  714.       deplibs="$deplib $deplibs"
  715.     else
  716.       compile_deplibs="$deplib $compile_deplibs"
  717.       finalize_deplibs="$deplib $finalize_deplibs"
  718.     fi
  719.     continue
  720.     ;;
  721.   esac # linkmode
  722.   ;; # *.$libext
  723. *.lo | *.$objext)
  724.   if test "$pass" = conv; then
  725.     deplibs="$deplib $deplibs"
  726.   elif test "$linkmode" = prog; then
  727.     if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
  728.       # If there is no dlopen support or we're linking statically,
  729.       # we need to preload.
  730.       newdlprefiles="$newdlprefiles $deplib"
  731.       compile_deplibs="$deplib $compile_deplibs"
  732.       finalize_deplibs="$deplib $finalize_deplibs"
  733.     else
  734.       newdlfiles="$newdlfiles $deplib"
  735.     fi
  736.   fi
  737.   continue
  738.   ;;
  739. %DEPLIBS%)
  740.   alldeplibs=yes
  741.   continue
  742.   ;;
  743. esac # case $deplib
  744. if test "$found" = yes || test -f "$lib"; then :
  745. else
  746.   func_fatal_error "cannot find the library `$lib' or unhandled argument `$deplib'"
  747. fi
  748. # Check to see that this really is a libtool archive.
  749. func_lalib_unsafe_p "$lib" 
  750.   || func_fatal_error "`$lib' is not a valid libtool archive"
  751. func_dirname "$lib" "" "."
  752. ladir="$func_dirname_result"
  753. dlname=
  754. dlopen=
  755. dlpreopen=
  756. libdir=
  757. library_names=
  758. old_library=
  759. inherited_linker_flags=
  760. # If the library was installed with an old release of libtool,
  761. # it will not redefine variables installed, or shouldnotlink
  762. installed=yes
  763. shouldnotlink=no
  764. avoidtemprpath=
  765. # Read the .la file
  766. func_source "$lib"
  767. # Convert "-framework foo" to "foo.ltframework"
  768. if test -n "$inherited_linker_flags"; then
  769.   tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework ([^ $]*)/1.ltframework/g'`
  770.   for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
  771.     case " $new_inherited_linker_flags " in
  772.       *" $tmp_inherited_linker_flag "*) ;;
  773.       *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
  774.     esac
  775.   done
  776. fi
  777. dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  778. if test "$linkmode,$pass" = "lib,link" ||
  779.    test "$linkmode,$pass" = "prog,scan" ||
  780.    { test "$linkmode" != prog && test "$linkmode" != lib; }; then
  781.   test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
  782.   test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
  783. fi
  784. if test "$pass" = conv; then
  785.   # Only check for convenience libraries
  786.   deplibs="$lib $deplibs"
  787.   if test -z "$libdir"; then
  788.     if test -z "$old_library"; then
  789.       func_fatal_error "cannot find name of link library for `$lib'"
  790.     fi
  791.     # It is a libtool convenience library, so add in its objects.
  792.     convenience="$convenience $ladir/$objdir/$old_library"
  793.     old_convenience="$old_convenience $ladir/$objdir/$old_library"
  794.   elif test "$linkmode" != prog && test "$linkmode" != lib; then
  795.     func_fatal_error "`$lib' is not a convenience library"
  796.   fi
  797.   tmp_libs=
  798.   for deplib in $dependency_libs; do
  799.     deplibs="$deplib $deplibs"
  800.     if $opt_duplicate_deps ; then
  801.       case "$tmp_libs " in
  802.       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
  803.       esac
  804.     fi
  805.     tmp_libs="$tmp_libs $deplib"
  806.   done
  807.   continue
  808. fi # $pass = conv
  809. # Get the name of the library we link against.
  810. linklib=
  811. for l in $old_library $library_names; do
  812.   linklib="$l"
  813. done
  814. if test -z "$linklib"; then
  815.   func_fatal_error "cannot find name of link library for `$lib'"
  816. fi
  817. # This library was specified with -dlopen.
  818. if test "$pass" = dlopen; then
  819.   if test -z "$libdir"; then
  820.     func_fatal_error "cannot -dlopen a convenience library: `$lib'"
  821.   fi
  822.   if test -z "$dlname" ||
  823.      test "$dlopen_support" != yes ||
  824.      test "$build_libtool_libs" = no; then
  825.     # If there is no dlname, no dlopen support or we're linking
  826.     # statically, we need to preload.  We also need to preload any
  827.     # dependent libraries so libltdl's deplib preloader doesn't
  828.     # bomb out in the load deplibs phase.
  829.     dlprefiles="$dlprefiles $lib $dependency_libs"
  830.   else
  831.     newdlfiles="$newdlfiles $lib"
  832.   fi
  833.   continue
  834. fi # $pass = dlopen
  835. # We need an absolute path.
  836. case $ladir in
  837. [\/]* | [A-Za-z]:[\/]*) abs_ladir="$ladir" ;;
  838. *)
  839.   abs_ladir=`cd "$ladir" && pwd`
  840.   if test -z "$abs_ladir"; then
  841.     func_warning "cannot determine absolute directory name of `$ladir'"
  842.     func_warning "passing it literally to the linker, although it might fail"
  843.     abs_ladir="$ladir"
  844.   fi
  845.   ;;
  846. esac
  847. func_basename "$lib"
  848. laname="$func_basename_result"
  849. # Find the relevant object directory and library name.
  850. if test "X$installed" = Xyes; then
  851.   if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
  852.     func_warning "library `$lib' was moved."
  853.     dir="$ladir"
  854.     absdir="$abs_ladir"
  855.     libdir="$abs_ladir"
  856.   else
  857.     dir="$libdir"
  858.     absdir="$libdir"
  859.   fi
  860.   test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
  861. else
  862.   if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
  863.     dir="$ladir"
  864.     absdir="$abs_ladir"
  865.     # Remove this search path later
  866.     notinst_path="$notinst_path $abs_ladir"
  867.   else
  868.     dir="$ladir/$objdir"
  869.     absdir="$abs_ladir/$objdir"
  870.     # Remove this search path later
  871.     notinst_path="$notinst_path $abs_ladir"
  872.   fi
  873. fi # $installed = yes
  874. func_stripname 'lib' '.la' "$laname"
  875. name=$func_stripname_result
  876. # This library was specified with -dlpreopen.
  877. if test "$pass" = dlpreopen; then
  878.   if test -z "$libdir" && test "$linkmode" = prog; then
  879.     func_fatal_error "only libraries may -dlpreopen a convenience library: `$lib'"
  880.   fi
  881.   # Prefer using a static library (so that no silly _DYNAMIC symbols
  882.   # are required to link).
  883.   if test -n "$old_library"; then
  884.     newdlprefiles="$newdlprefiles $dir/$old_library"
  885.     # Keep a list of preopened convenience libraries to check
  886.     # that they are being used correctly in the link pass.
  887.     test -z "$libdir" && 
  888. dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
  889.   # Otherwise, use the dlname, so that lt_dlopen finds it.
  890.   elif test -n "$dlname"; then
  891.     newdlprefiles="$newdlprefiles $dir/$dlname"
  892.   else
  893.     newdlprefiles="$newdlprefiles $dir/$linklib"
  894.   fi
  895. fi # $pass = dlpreopen
  896. if test -z "$libdir"; then
  897.   # Link the convenience library
  898.   if test "$linkmode" = lib; then
  899.     deplibs="$dir/$old_library $deplibs"
  900.   elif test "$linkmode,$pass" = "prog,link"; then
  901.     compile_deplibs="$dir/$old_library $compile_deplibs"
  902.     finalize_deplibs="$dir/$old_library $finalize_deplibs"
  903.   else
  904.     deplibs="$lib $deplibs" # used for prog,scan pass
  905.   fi
  906.   continue
  907. fi
  908. if test "$linkmode" = prog && test "$pass" != link; then
  909.   newlib_search_path="$newlib_search_path $ladir"
  910.   deplibs="$lib $deplibs"
  911.   linkalldeplibs=no
  912.   if test "$link_all_deplibs" != no || test -z "$library_names" ||
  913.      test "$build_libtool_libs" = no; then
  914.     linkalldeplibs=yes
  915.   fi
  916.   tmp_libs=
  917.   for deplib in $dependency_libs; do
  918.     case $deplib in
  919.     -L*) func_stripname '-L' '' "$deplib"
  920.          newlib_search_path="$newlib_search_path $func_stripname_result"
  921.  ;;
  922.     esac
  923.     # Need to link against all dependency_libs?
  924.     if test "$linkalldeplibs" = yes; then
  925.       deplibs="$deplib $deplibs"
  926.     else
  927.       # Need to hardcode shared library paths
  928.       # or/and link against static libraries
  929.       newdependency_libs="$deplib $newdependency_libs"
  930.     fi
  931.     if $opt_duplicate_deps ; then
  932.       case "$tmp_libs " in
  933.       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
  934.       esac
  935.     fi
  936.     tmp_libs="$tmp_libs $deplib"
  937.   done # for deplib
  938.   continue
  939. fi # $linkmode = prog...
  940. if test "$linkmode,$pass" = "prog,link"; then
  941.   if test -n "$library_names" &&
  942.      { { test "$prefer_static_libs" = no ||
  943.          test "$prefer_static_libs,$installed" = "built,yes"; } ||
  944.        test -z "$old_library"; }; then
  945.     # We need to hardcode the library path
  946.     if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
  947.       # Make sure the rpath contains only unique directories.
  948.       case "$temp_rpath:" in
  949.       *"$absdir:"*) ;;
  950.       *) temp_rpath="$temp_rpath$absdir:" ;;
  951.       esac
  952.     fi
  953.     # Hardcode the library path.
  954.     # Skip directories that are in the system default run-time
  955.     # search path.
  956.     case " $sys_lib_dlsearch_path " in
  957.     *" $absdir "*) ;;
  958.     *)
  959.       case "$compile_rpath " in
  960.       *" $absdir "*) ;;
  961.       *) compile_rpath="$compile_rpath $absdir"
  962.       esac
  963.       ;;
  964.     esac
  965.     case " $sys_lib_dlsearch_path " in
  966.     *" $libdir "*) ;;
  967.     *)
  968.       case "$finalize_rpath " in
  969.       *" $libdir "*) ;;
  970.       *) finalize_rpath="$finalize_rpath $libdir"
  971.       esac
  972.       ;;
  973.     esac
  974.   fi # $linkmode,$pass = prog,link...
  975.   if test "$alldeplibs" = yes &&
  976.      { test "$deplibs_check_method" = pass_all ||
  977.        { test "$build_libtool_libs" = yes &&
  978.  test -n "$library_names"; }; }; then
  979.     # We only need to search for static libraries
  980.     continue
  981.   fi
  982. fi
  983. link_static=no # Whether the deplib will be linked statically
  984. use_static_libs=$prefer_static_libs
  985. if test "$use_static_libs" = built && test "$installed" = yes; then
  986.   use_static_libs=no
  987. fi
  988. if test -n "$library_names" &&
  989.    { test "$use_static_libs" = no || test -z "$old_library"; }; then
  990.   case $host in
  991.   *cygwin* | *mingw*)
  992.       # No point in relinking DLLs because paths are not encoded
  993.       notinst_deplibs="$notinst_deplibs $lib"
  994.       need_relink=no
  995.     ;;
  996.   *)
  997.     if test "$installed" = no; then
  998.       notinst_deplibs="$notinst_deplibs $lib"
  999.       need_relink=yes
  1000.     fi
  1001.     ;;
  1002.   esac
  1003.   # This is a shared library
  1004.   # Warn about portability, can't link against -module's on some
  1005.   # systems (darwin).  Don't bleat about dlopened modules though!
  1006.   dlopenmodule=""
  1007.   for dlpremoduletest in $dlprefiles; do
  1008.     if test "X$dlpremoduletest" = "X$lib"; then
  1009.       dlopenmodule="$dlpremoduletest"
  1010.       break
  1011.     fi
  1012.   done
  1013.   if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
  1014.     $ECHO
  1015.     if test "$linkmode" = prog; then
  1016.       $ECHO "*** Warning: Linking the executable $output against the loadable module"
  1017.     else
  1018.       $ECHO "*** Warning: Linking the shared library $output against the loadable module"
  1019.     fi
  1020.     $ECHO "*** $linklib is not portable!"
  1021.   fi
  1022.   if test "$linkmode" = lib &&
  1023.      test "$hardcode_into_libs" = yes; then
  1024.     # Hardcode the library path.
  1025.     # Skip directories that are in the system default run-time
  1026.     # search path.
  1027.     case " $sys_lib_dlsearch_path " in
  1028.     *" $absdir "*) ;;
  1029.     *)
  1030.       case "$compile_rpath " in
  1031.       *" $absdir "*) ;;
  1032.       *) compile_rpath="$compile_rpath $absdir"
  1033.       esac
  1034.       ;;
  1035.     esac
  1036.     case " $sys_lib_dlsearch_path " in
  1037.     *" $libdir "*) ;;
  1038.     *)
  1039.       case "$finalize_rpath " in
  1040.       *" $libdir "*) ;;
  1041.       *) finalize_rpath="$finalize_rpath $libdir"
  1042.       esac
  1043.       ;;
  1044.     esac
  1045.   fi
  1046.   if test -n "$old_archive_from_expsyms_cmds"; then
  1047.     # figure out the soname
  1048.     set dummy $library_names
  1049.     shift
  1050.     realname="$1"
  1051.     shift
  1052.     libname=`eval "\$ECHO "$libname_spec""`
  1053.     # use dlname if we got it. it's perfectly good, no?
  1054.     if test -n "$dlname"; then
  1055.       soname="$dlname"
  1056.     elif test -n "$soname_spec"; then
  1057.       # bleh windows
  1058.       case $host in
  1059.       *cygwin* | mingw*)
  1060. major=`expr $current - $age`
  1061. versuffix="-$major"
  1062. ;;
  1063.       esac
  1064.       eval soname="$soname_spec"
  1065.     else
  1066.       soname="$realname"
  1067.     fi
  1068.     # Make a new name for the extract_expsyms_cmds to use
  1069.     soroot="$soname"
  1070.     func_basename "$soroot"
  1071.     soname="$func_basename_result"
  1072.     func_stripname 'lib' '.dll' "$soname"
  1073.     newlib=libimp-$func_stripname_result.a
  1074.     # If the library has no export list, then create one now
  1075.     if test -f "$output_objdir/$soname-def"; then :
  1076.     else
  1077.       func_verbose "extracting exported symbol list from `$soname'"
  1078.       func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
  1079.     fi
  1080.     # Create $newlib
  1081.     if test -f "$output_objdir/$newlib"; then :; else
  1082.       func_verbose "generating import library for `$soname'"
  1083.       func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
  1084.     fi
  1085.     # make sure the library variables are pointing to the new library
  1086.     dir=$output_objdir
  1087.     linklib=$newlib
  1088.   fi # test -n "$old_archive_from_expsyms_cmds"
  1089.   if test "$linkmode" = prog || test "$mode" != relink; then
  1090.     add_shlibpath=
  1091.     add_dir=
  1092.     add=
  1093.     lib_linked=yes
  1094.     case $hardcode_action in
  1095.     immediate | unsupported)
  1096.       if test "$hardcode_direct" = no; then
  1097. add="$dir/$linklib"
  1098. case $host in
  1099.   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
  1100.   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
  1101.   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | 
  1102.     *-*-unixware7*) add_dir="-L$dir" ;;
  1103.   *-*-darwin* )
  1104.     # if the lib is a (non-dlopened) module then we can not
  1105.     # link against it, someone is ignoring the earlier warnings
  1106.     if /usr/bin/file -L $add 2> /dev/null |
  1107.  $GREP ": [^:]* bundle" >/dev/null ; then
  1108.       if test "X$dlopenmodule" != "X$lib"; then
  1109. $ECHO "*** Warning: lib $linklib is a module, not a shared library"
  1110. if test -z "$old_library" ; then
  1111.   $ECHO
  1112.   $ECHO "*** And there doesn't seem to be a static archive available"
  1113.   $ECHO "*** The link will probably fail, sorry"
  1114. else
  1115.   add="$dir/$old_library"
  1116. fi
  1117.       elif test -n "$old_library"; then
  1118. add="$dir/$old_library"
  1119.       fi
  1120.     fi
  1121. esac
  1122.       elif test "$hardcode_minus_L" = no; then
  1123. case $host in
  1124. *-*-sunos*) add_shlibpath="$dir" ;;
  1125. esac
  1126. add_dir="-L$dir"
  1127. add="-l$name"
  1128.       elif test "$hardcode_shlibpath_var" = no; then
  1129. add_shlibpath="$dir"
  1130. add="-l$name"
  1131.       else
  1132. lib_linked=no
  1133.       fi
  1134.       ;;
  1135.     relink)
  1136.       if test "$hardcode_direct" = yes &&
  1137.          test "$hardcode_direct_absolute" = no; then
  1138. add="$dir/$linklib"
  1139.       elif test "$hardcode_minus_L" = yes; then
  1140. add_dir="-L$dir"
  1141. # Try looking first in the location we're being installed to.
  1142. if test -n "$inst_prefix_dir"; then
  1143.   case $libdir in
  1144.     [\/]*)
  1145.       add_dir="$add_dir -L$inst_prefix_dir$libdir"
  1146.       ;;
  1147.   esac
  1148. fi
  1149. add="-l$name"
  1150.       elif test "$hardcode_shlibpath_var" = yes; then
  1151. add_shlibpath="$dir"
  1152. add="-l$name"
  1153.       else
  1154. lib_linked=no
  1155.       fi
  1156.       ;;
  1157.     *) lib_linked=no ;;
  1158.     esac
  1159.     if test "$lib_linked" != yes; then
  1160.       func_fatal_configuration "unsupported hardcode properties"
  1161.     fi
  1162.     if test -n "$add_shlibpath"; then
  1163.       case :$compile_shlibpath: in
  1164.       *":$add_shlibpath:"*) ;;
  1165.       *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
  1166.       esac
  1167.     fi
  1168.     if test "$linkmode" = prog; then
  1169.       test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
  1170.       test -n "$add" && compile_deplibs="$add $compile_deplibs"
  1171.     else
  1172.       test -n "$add_dir" && deplibs="$add_dir $deplibs"
  1173.       test -n "$add" && deplibs="$add $deplibs"
  1174.       if test "$hardcode_direct" != yes &&
  1175.  test "$hardcode_minus_L" != yes &&
  1176.  test "$hardcode_shlibpath_var" = yes; then
  1177. case :$finalize_shlibpath: in
  1178. *":$libdir:"*) ;;
  1179. *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
  1180. esac
  1181.       fi
  1182.     fi
  1183.   fi
  1184.   if test "$linkmode" = prog || test "$mode" = relink; then
  1185.     add_shlibpath=
  1186.     add_dir=
  1187.     add=
  1188.     # Finalize command for both is simple: just hardcode it.
  1189.     if test "$hardcode_direct" = yes &&
  1190.        test "$hardcode_direct_absolute" = no; then
  1191.       add="$libdir/$linklib"
  1192.     elif test "$hardcode_minus_L" = yes; then
  1193.       add_dir="-L$libdir"
  1194.       add="-l$name"
  1195.     elif test "$hardcode_shlibpath_var" = yes; then
  1196.       case :$finalize_shlibpath: in
  1197.       *":$libdir:"*) ;;
  1198.       *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
  1199.       esac
  1200.       add="-l$name"
  1201.     elif test "$hardcode_automatic" = yes; then
  1202.       if test -n "$inst_prefix_dir" &&
  1203.  test -f "$inst_prefix_dir$libdir/$linklib" ; then
  1204. add="$inst_prefix_dir$libdir/$linklib"
  1205.       else
  1206. add="$libdir/$linklib"
  1207.       fi
  1208.     else
  1209.       # We cannot seem to hardcode it, guess we'll fake it.
  1210.       add_dir="-L$libdir"
  1211.       # Try looking first in the location we're being installed to.
  1212.       if test -n "$inst_prefix_dir"; then
  1213. case $libdir in
  1214.   [\/]*)
  1215.     add_dir="$add_dir -L$inst_prefix_dir$libdir"
  1216.     ;;
  1217. esac
  1218.       fi
  1219.       add="-l$name"
  1220.     fi
  1221.     if test "$linkmode" = prog; then
  1222.       test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
  1223.       test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
  1224.     else
  1225.       test -n "$add_dir" && deplibs="$add_dir $deplibs"
  1226.       test -n "$add" && deplibs="$add $deplibs"
  1227.     fi
  1228.   fi
  1229. elif test "$linkmode" = prog; then
  1230.   # Here we assume that one of hardcode_direct or hardcode_minus_L
  1231.   # is not unsupported.  This is valid on all known static and
  1232.   # shared platforms.
  1233.   if test "$hardcode_direct" != unsupported; then
  1234.     test -n "$old_library" && linklib="$old_library"
  1235.     compile_deplibs="$dir/$linklib $compile_deplibs"
  1236.     finalize_deplibs="$dir/$linklib $finalize_deplibs"
  1237.   else
  1238.     compile_deplibs="-l$name -L$dir $compile_deplibs"
  1239.     finalize_deplibs="-l$name -L$dir $finalize_deplibs"
  1240.   fi
  1241. elif test "$build_libtool_libs" = yes; then
  1242.   # Not a shared library
  1243.   if test "$deplibs_check_method" != pass_all; then
  1244.     # We're trying link a shared library against a static one
  1245.     # but the system doesn't support it.
  1246.     # Just print a warning and add the library to dependency_libs so
  1247.     # that the program can be linked against the static library.
  1248.     $ECHO
  1249.     $ECHO "*** Warning: This system can not link to static lib archive $lib."
  1250.     $ECHO "*** I have the capability to make that library automatically link in when"
  1251.     $ECHO "*** you link to this library.  But I can only do this if you have a"
  1252.     $ECHO "*** shared version of the library, which you do not appear to have."
  1253.     if test "$module" = yes; then
  1254.       $ECHO "*** But as you try to build a module library, libtool will still create "
  1255.       $ECHO "*** a static module, that should work as long as the dlopening application"
  1256.       $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
  1257.       if test -z "$global_symbol_pipe"; then
  1258. $ECHO
  1259. $ECHO "*** However, this would only work if libtool was able to extract symbol"
  1260. $ECHO "*** lists from a program, using `nm' or equivalent, but libtool could"
  1261. $ECHO "*** not find such a program.  So, this module is probably useless."
  1262. $ECHO "*** `nm' from GNU binutils and a full rebuild may help."
  1263.       fi
  1264.       if test "$build_old_libs" = no; then
  1265. build_libtool_libs=module
  1266. build_old_libs=yes
  1267.       else
  1268. build_libtool_libs=no
  1269.       fi
  1270.     fi
  1271.   else
  1272.     deplibs="$dir/$old_library $deplibs"
  1273.     link_static=yes
  1274.   fi
  1275. fi # link shared/static library?
  1276. if test "$linkmode" = lib; then
  1277.   if test -n "$dependency_libs" &&
  1278.      { test "$hardcode_into_libs" != yes ||
  1279.        test "$build_old_libs" = yes ||
  1280.        test "$link_static" = yes; }; then
  1281.     # Extract -R from dependency_libs
  1282.     temp_deplibs=
  1283.     for libdir in $dependency_libs; do
  1284.       case $libdir in
  1285.       -R*) func_stripname '-R' '' "$libdir"
  1286.            temp_xrpath=$func_stripname_result
  1287.    case " $xrpath " in
  1288.    *" $temp_xrpath "*) ;;
  1289.    *) xrpath="$xrpath $temp_xrpath";;
  1290.    esac;;
  1291.       *) temp_deplibs="$temp_deplibs $libdir";;
  1292.       esac
  1293.     done
  1294.     dependency_libs="$temp_deplibs"
  1295.   fi
  1296.   newlib_search_path="$newlib_search_path $absdir"
  1297.   # Link against this library
  1298.   test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
  1299.   # ... and its dependency_libs
  1300.   tmp_libs=
  1301.   for deplib in $dependency_libs; do
  1302.     newdependency_libs="$deplib $newdependency_libs"
  1303.     if $opt_duplicate_deps ; then
  1304.       case "$tmp_libs " in
  1305.       *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
  1306.       esac
  1307.     fi
  1308.     tmp_libs="$tmp_libs $deplib"
  1309.   done
  1310.   if test "$link_all_deplibs" != no; then
  1311.     # Add the search paths of all dependency libraries
  1312.     for deplib in $dependency_libs; do
  1313.       case $deplib in
  1314.       -L*) path="$deplib" ;;
  1315.       *.la)
  1316.         func_dirname "$deplib" "" "."
  1317. dir="$func_dirname_result"
  1318. # We need an absolute path.
  1319. case $dir in
  1320. [\/]* | [A-Za-z]:[\/]*) absdir="$dir" ;;
  1321. *)
  1322.   absdir=`cd "$dir" && pwd`
  1323.   if test -z "$absdir"; then
  1324.     func_warning "cannot determine absolute directory name of `$dir'"
  1325.     absdir="$dir"
  1326.   fi
  1327.   ;;
  1328. esac
  1329. if $GREP "^installed=no" $deplib > /dev/null; then
  1330. case $host in
  1331. *-*-darwin*)
  1332.   depdepl=
  1333.   eval deplibrary_names=`${SED} -n -e 's/^library_names=(.*)$/1/p' $deplib`
  1334.   if test -n "$deplibrary_names" ; then
  1335.     for tmp in $deplibrary_names ; do
  1336.       depdepl=$tmp
  1337.     done
  1338.     if test -f "$absdir/$objdir/$depdepl" ; then
  1339.       depdepl="$absdir/$objdir/$depdepl"
  1340.       darwin_install_name=`otool -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`
  1341.       darwin_install_name=`$ECHO $darwin_install_name`
  1342.                       if test -z "$darwin_install_name"; then
  1343.                           darwin_install_name=`otool64 -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`
  1344.                           darwin_install_name=`$ECHO $darwin_install_name`
  1345.                       fi
  1346.       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
  1347.       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
  1348.       path=
  1349.     fi
  1350.   fi
  1351.   ;;
  1352. *)
  1353.   path="-L$absdir/$objdir"
  1354.   ;;
  1355. esac
  1356. else
  1357.   eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $deplib`
  1358.   test -z "$libdir" && 
  1359.     func_fatal_error "`$deplib' is not a valid libtool archive"
  1360.   test "$absdir" != "$libdir" && 
  1361.     func_warning "`$deplib' seems to be moved"
  1362.   path="-L$absdir"
  1363. fi
  1364. ;;
  1365.       esac
  1366.       case " $deplibs " in
  1367.       *" $path "*) ;;
  1368.       *) deplibs="$path $deplibs" ;;
  1369.       esac
  1370.     done
  1371.   fi # link_all_deplibs != no
  1372. fi # linkmode = lib
  1373.       done # for deplib in $libs
  1374.       if test "$pass" = link; then
  1375. if test "$linkmode" = "prog"; then
  1376.   compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
  1377.   finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
  1378. else
  1379.   compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  1380. fi
  1381.       fi
  1382.       dependency_libs="$newdependency_libs"
  1383.       if test "$pass" = dlpreopen; then
  1384. # Link the dlpreopened libraries before other libraries
  1385. for deplib in $save_deplibs; do
  1386.   deplibs="$deplib $deplibs"
  1387. done
  1388.       fi
  1389.       if test "$pass" != dlopen; then
  1390. if test "$pass" != conv; then
  1391.   # Make sure lib_search_path contains only unique directories.
  1392.   lib_search_path=
  1393.   for dir in $newlib_search_path; do
  1394.     case "$lib_search_path " in
  1395.     *" $dir "*) ;;
  1396.     *) lib_search_path="$lib_search_path $dir" ;;
  1397.     esac
  1398.   done
  1399.   newlib_search_path=
  1400. fi
  1401. if test "$linkmode,$pass" != "prog,link"; then
  1402.   vars="deplibs"
  1403. else
  1404.   vars="compile_deplibs finalize_deplibs"
  1405. fi
  1406. for var in $vars dependency_libs; do
  1407.   # Add libraries to $var in reverse order
  1408.   eval tmp_libs="$$var"
  1409.   new_libs=
  1410.   for deplib in $tmp_libs; do
  1411.     # FIXME: Pedantically, this is the right thing to do, so
  1412.     #        that some nasty dependency loop isn't accidentally
  1413.     #        broken:
  1414.     #new_libs="$deplib $new_libs"
  1415.     # Pragmatically, this seems to cause very few problems in
  1416.     # practice:
  1417.     case $deplib in
  1418.     -L*) new_libs="$deplib $new_libs" ;;
  1419.     -R*) ;;
  1420.     *)
  1421.       # And here is the reason: when a library appears more
  1422.       # than once as an explicit dependence of a library, or
  1423.       # is implicitly linked in more than once by the
  1424.       # compiler, it is considered special, and multiple
  1425.       # occurrences thereof are not removed.  Compare this
  1426.       # with having the same library being listed as a
  1427.       # dependency of multiple other libraries: in this case,
  1428.       # we know (pedantically, we assume) the library does not
  1429.       # need to be listed more than once, so we keep only the
  1430.       # last copy.  This is not always right, but it is rare
  1431.       # enough that we require users that really mean to play
  1432.       # such unportable linking tricks to link the library
  1433.       # using -Wl,-lname, so that libtool does not consider it
  1434.       # for duplicate removal.
  1435.       case " $specialdeplibs " in
  1436.       *" $deplib "*) new_libs="$deplib $new_libs" ;;
  1437.       *)
  1438. case " $new_libs " in
  1439. *" $deplib "*) ;;
  1440. *) new_libs="$deplib $new_libs" ;;
  1441. esac
  1442. ;;
  1443.       esac
  1444.       ;;
  1445.     esac
  1446.   done
  1447.   tmp_libs=
  1448.   for deplib in $new_libs; do
  1449.     case $deplib in
  1450.     -L*)
  1451.       case " $tmp_libs " in
  1452.       *" $deplib "*) ;;
  1453.       *) tmp_libs="$tmp_libs $deplib" ;;
  1454.       esac
  1455.       ;;
  1456.     *) tmp_libs="$tmp_libs $deplib" ;;
  1457.     esac
  1458.   done
  1459.   eval $var="$tmp_libs"
  1460. done # for var
  1461.       fi
  1462.       # Last step: remove runtime libs from dependency_libs
  1463.       # (they stay in deplibs)
  1464.       tmp_libs=
  1465.       for i in $dependency_libs ; do
  1466. case " $predeps $postdeps $compiler_lib_search_path " in
  1467. *" $i "*)
  1468.   i=""
  1469.   ;;
  1470. esac
  1471. if test -n "$i" ; then
  1472.   tmp_libs="$tmp_libs $i"
  1473. fi
  1474.       done
  1475.       dependency_libs=$tmp_libs
  1476.     done # for pass
  1477.     if test "$linkmode" = prog; then
  1478.       dlfiles="$newdlfiles"
  1479.     fi
  1480.     if test "$linkmode" = prog || test "$linkmode" = lib; then
  1481.       dlprefiles="$newdlprefiles"
  1482.     fi
  1483.     case $linkmode in
  1484.     oldlib)
  1485.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  1486. func_warning "`-dlopen' is ignored for archives"
  1487.       fi
  1488.       case " $deplibs" in
  1489.       * -l* | * -L*)
  1490. func_warning "`-l' and `-L' are ignored for archives" ;;
  1491.       esac
  1492.       test -n "$rpath" && 
  1493. func_warning "`-rpath' is ignored for archives"
  1494.       test -n "$xrpath" && 
  1495. func_warning "`-R' is ignored for archives"
  1496.       test -n "$vinfo" && 
  1497. func_warning "`-version-info/-version-number' is ignored for archives"
  1498.       test -n "$release" && 
  1499. func_warning "`-release' is ignored for archives"
  1500.       test -n "$export_symbols$export_symbols_regex" && 
  1501. func_warning "`-export-symbols' is ignored for archives"
  1502.       # Now set the variables for building old libraries.
  1503.       build_libtool_libs=no
  1504.       oldlibs="$output"
  1505.       objs="$objs$old_deplibs"
  1506.       ;;
  1507.     lib)
  1508.       # Make sure we only generate libraries of the form `libNAME.la'.
  1509.       case $outputname in
  1510.       lib*)
  1511. func_stripname 'lib' '.la' "$outputname"
  1512. name=$func_stripname_result
  1513. eval shared_ext="$shrext_cmds"
  1514. eval libname="$libname_spec"
  1515. ;;
  1516.       *)
  1517. test "$module" = no && 
  1518.   func_fatal_help "libtool library `$output' must begin with `lib'"
  1519. if test "$need_lib_prefix" != no; then
  1520.   # Add the "lib" prefix for modules if required
  1521.   func_stripname '' '.la' "$outputname"
  1522.   name=$func_stripname_result
  1523.   eval shared_ext="$shrext_cmds"
  1524.   eval libname="$libname_spec"
  1525. else
  1526.   func_stripname '' '.la' "$outputname"
  1527.   libname=$func_stripname_result
  1528. fi
  1529. ;;
  1530.       esac
  1531.       if test -n "$objs"; then
  1532. if test "$deplibs_check_method" != pass_all; then
  1533.   func_fatal_error "cannot build libtool library `$output' from non-libtool objects on this host:$objs"
  1534. else
  1535.   $ECHO
  1536.   $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
  1537.   $ECHO "*** objects $objs is not portable!"
  1538.   libobjs="$libobjs $objs"
  1539. fi
  1540.       fi
  1541.       test "$dlself" != no && 
  1542. func_warning "`-dlopen self' is ignored for libtool libraries"
  1543.       set dummy $rpath
  1544.       shift
  1545.       test "$#" -gt 1 && 
  1546. func_warning "ignoring multiple `-rpath's for a libtool library"
  1547.       install_libdir="$1"
  1548.       oldlibs=
  1549.       if test -z "$rpath"; then
  1550. if test "$build_libtool_libs" = yes; then
  1551.   # Building a libtool convenience library.
  1552.   # Some compilers have problems with a `.al' extension so
  1553.   # convenience libraries should have the same extension an
  1554.   # archive normally would.
  1555.   oldlibs="$output_objdir/$libname.$libext $oldlibs"
  1556.   build_libtool_libs=convenience
  1557.   build_old_libs=yes
  1558. fi
  1559. test -n "$vinfo" && 
  1560.   func_warning "`-version-info/-version-number' is ignored for convenience libraries"
  1561. test -n "$release" && 
  1562.   func_warning "`-release' is ignored for convenience libraries"
  1563.       else
  1564. # Parse the version information argument.
  1565. save_ifs="$IFS"; IFS=':'
  1566. set dummy $vinfo 0 0 0
  1567. shift
  1568. IFS="$save_ifs"
  1569. test -n "$7" && 
  1570.   func_fatal_help "too many parameters to `-version-info'"
  1571. # convert absolute version numbers to libtool ages
  1572. # this retains compatibility with .la files and attempts
  1573. # to make the code below a bit more comprehensible
  1574. case $vinfo_number in
  1575. yes)
  1576.   number_major="$1"
  1577.   number_minor="$2"
  1578.   number_revision="$3"
  1579.   #
  1580.   # There are really only two kinds -- those that
  1581.   # use the current revision as the major version
  1582.   # and those that subtract age and use age as
  1583.   # a minor version.  But, then there is irix
  1584.   # which has an extra 1 added just for fun
  1585.   #
  1586.   case $version_type in
  1587.   darwin|linux|osf|windows|none)
  1588.     current=`expr $number_major + $number_minor`
  1589.     age="$number_minor"
  1590.     revision="$number_revision"
  1591.     ;;
  1592.   freebsd-aout|freebsd-elf|sunos)
  1593.     current="$number_major"
  1594.     revision="$number_minor"
  1595.     age="0"
  1596.     ;;
  1597.   irix|nonstopux)
  1598.     current=`expr $number_major + $number_minor`
  1599.     age="$number_minor"
  1600.     revision="$number_minor"
  1601.     lt_irix_increment=no
  1602.     ;;
  1603.   esac
  1604.   ;;
  1605. no)
  1606.   current="$1"
  1607.   revision="$2"
  1608.   age="$3"
  1609.   ;;
  1610. esac
  1611. # Check that each of the things are valid numbers.
  1612. case $current in
  1613. 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
  1614. *)
  1615.   func_error "CURRENT `$current' must be a nonnegative integer"
  1616.   func_fatal_error "`$vinfo' is not valid version information"
  1617.   ;;
  1618. esac
  1619. case $revision in
  1620. 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
  1621. *)
  1622.   func_error "REVISION `$revision' must be a nonnegative integer"
  1623.   func_fatal_error "`$vinfo' is not valid version information"
  1624.   ;;
  1625. esac
  1626. case $age in
  1627. 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
  1628. *)
  1629.   func_error "AGE `$age' must be a nonnegative integer"
  1630.   func_fatal_error "`$vinfo' is not valid version information"
  1631.   ;;
  1632. esac
  1633. if test "$age" -gt "$current"; then
  1634.   func_error "AGE `$age' is greater than the current interface number `$current'"
  1635.   func_fatal_error "`$vinfo' is not valid version information"
  1636. fi
  1637. # Calculate the version variables.
  1638. major=
  1639. versuffix=
  1640. verstring=
  1641. case $version_type in
  1642. none) ;;
  1643. darwin)
  1644.   # Like Linux, but with the current version available in
  1645.   # verstring for coding it into the library header
  1646.   major=.`expr $current - $age`
  1647.   versuffix="$major.$age.$revision"
  1648.   # Darwin ld doesn't like 0 for these options...
  1649.   minor_current=`expr $current + 1`
  1650.   xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
  1651.   verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
  1652.   ;;
  1653. freebsd-aout)
  1654.   major=".$current"
  1655.   versuffix=".$current.$revision";
  1656.   ;;
  1657. freebsd-elf)
  1658.   major=".$current"
  1659.   versuffix=".$current"
  1660.   ;;
  1661. irix | nonstopux)
  1662.   if test "X$lt_irix_increment" = "Xno"; then
  1663.     major=`expr $current - $age`
  1664.   else
  1665.     major=`expr $current - $age + 1`
  1666.   fi
  1667.   case $version_type in
  1668.     nonstopux) verstring_prefix=nonstopux ;;
  1669.     *)         verstring_prefix=sgi ;;
  1670.   esac
  1671.   verstring="$verstring_prefix$major.$revision"
  1672.   # Add in all the interfaces that we are compatible with.
  1673.   loop=$revision
  1674.   while test "$loop" -ne 0; do
  1675.     iface=`expr $revision - $loop`
  1676.     loop=`expr $loop - 1`
  1677.     verstring="$verstring_prefix$major.$iface:$verstring"
  1678.   done
  1679.   # Before this point, $major must not contain `.'.
  1680.   major=.$major
  1681.   versuffix="$major.$revision"
  1682.   ;;
  1683. linux)
  1684.   major=.`expr $current - $age`
  1685.   versuffix="$major.$age.$revision"
  1686.   ;;
  1687. osf)
  1688.   major=.`expr $current - $age`
  1689.   versuffix=".$current.$age.$revision"
  1690.   verstring="$current.$age.$revision"
  1691.   # Add in all the interfaces that we are compatible with.
  1692.   loop=$age
  1693.   while test "$loop" -ne 0; do
  1694.     iface=`expr $current - $loop`
  1695.     loop=`expr $loop - 1`
  1696.     verstring="$verstring:${iface}.0"
  1697.   done
  1698.   # Make executables depend on our current version.
  1699.   verstring="$verstring:${current}.0"
  1700.   ;;
  1701. qnx)
  1702.   major=".$current"
  1703.   versuffix=".$current"
  1704.   ;;
  1705. sunos)
  1706.   major=".$current"
  1707.   versuffix=".$current.$revision"
  1708.   ;;
  1709. windows)
  1710.   # Use '-' rather than '.', since we only want one
  1711.   # extension on DOS 8.3 filesystems.
  1712.   major=`expr $current - $age`
  1713.   versuffix="-$major"
  1714.   ;;
  1715. *)
  1716.   func_fatal_configuration "unknown library version type `$version_type'"
  1717.   ;;
  1718. esac
  1719. # Clear the version info if we defaulted, and they specified a release.
  1720. if test -z "$vinfo" && test -n "$release"; then
  1721.   major=
  1722.   case $version_type in
  1723.   darwin)
  1724.     # we can't check for "0.0" in archive_cmds due to quoting
  1725.     # problems, so we reset it completely
  1726.     verstring=
  1727.     ;;
  1728.   *)
  1729.     verstring="0.0"
  1730.     ;;
  1731.   esac
  1732.   if test "$need_version" = no; then
  1733.     versuffix=
  1734.   else
  1735.     versuffix=".0.0"
  1736.   fi
  1737. fi
  1738. # Remove version info from name if versioning should be avoided
  1739. if test "$avoid_version" = yes && test "$need_version" = no; then
  1740.   major=
  1741.   versuffix=
  1742.   verstring=""
  1743. fi
  1744. # Check to see if the archive will have undefined symbols.
  1745. if test "$allow_undefined" = yes; then
  1746.   if test "$allow_undefined_flag" = unsupported; then
  1747.     func_warning "undefined symbols not allowed in $host shared libraries"
  1748.     build_libtool_libs=no
  1749.     build_old_libs=yes
  1750.   fi
  1751. else
  1752.   # Don't allow undefined symbols.
  1753.   allow_undefined_flag="$no_undefined_flag"
  1754. fi
  1755.       fi
  1756.       func_generate_dlsyms "$libname" "$libname" "yes"
  1757.       libobjs="$libobjs $symfileobj"
  1758.       test "X$libobjs" = "X " && libobjs=
  1759.       if test "$mode" != relink; then
  1760. # Remove our outputs, but don't remove object files since they
  1761. # may have been created when compiling PIC objects.
  1762. removelist=
  1763. tempremovelist=`$ECHO "$output_objdir/*"`
  1764. for p in $tempremovelist; do
  1765.   case $p in
  1766.     *.$objext)
  1767.        ;;
  1768.     $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
  1769.        if test "X$precious_files_regex" != "X"; then
  1770.  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
  1771.  then
  1772.    continue
  1773.  fi
  1774.        fi
  1775.        removelist="$removelist $p"
  1776.        ;;
  1777.     *) ;;
  1778.   esac
  1779. done
  1780. test -n "$removelist" && 
  1781.   func_show_eval "${RM}r $removelist"
  1782.       fi
  1783.       # Now set the variables for building old libraries.
  1784.       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
  1785. oldlibs="$oldlibs $output_objdir/$libname.$libext"
  1786. # Transform .lo files to .o files.
  1787. oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/.'${libext}'$/d' -e "$lo2o" | $NL2SP`
  1788.       fi
  1789.       # Eliminate all temporary directories.
  1790.       #for path in $notinst_path; do
  1791.       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
  1792.       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
  1793.       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
  1794.       #done
  1795.       if test -n "$xrpath"; then
  1796. # If the user specified any rpath flags, then add them.
  1797. temp_xrpath=
  1798. for libdir in $xrpath; do
  1799.   temp_xrpath="$temp_xrpath -R$libdir"
  1800.   case "$finalize_rpath " in
  1801.   *" $libdir "*) ;;
  1802.   *) finalize_rpath="$finalize_rpath $libdir" ;;
  1803.   esac
  1804. done
  1805. if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
  1806.   dependency_libs="$temp_xrpath $dependency_libs"
  1807. fi
  1808.       fi
  1809.       # Make sure dlfiles contains only unique files that won't be dlpreopened
  1810.       old_dlfiles="$dlfiles"
  1811.       dlfiles=
  1812.       for lib in $old_dlfiles; do
  1813. case " $dlprefiles $dlfiles " in
  1814. *" $lib "*) ;;
  1815. *) dlfiles="$dlfiles $lib" ;;
  1816. esac
  1817.       done
  1818.       # Make sure dlprefiles contains only unique files
  1819.       old_dlprefiles="$dlprefiles"
  1820.       dlprefiles=
  1821.       for lib in $old_dlprefiles; do
  1822. case "$dlprefiles " in
  1823. *" $lib "*) ;;
  1824. *) dlprefiles="$dlprefiles $lib" ;;
  1825. esac
  1826.       done
  1827.       if test "$build_libtool_libs" = yes; then
  1828. if test -n "$rpath"; then
  1829.   case $host in
  1830.   *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
  1831.     # these systems don't actually have a c library (as such)!
  1832.     ;;
  1833.   *-*-rhapsody* | *-*-darwin1.[012])
  1834.     # Rhapsody C library is in the System framework
  1835.     deplibs="$deplibs System.ltframework"
  1836.     ;;
  1837.   *-*-netbsd*)
  1838.     # Don't link with libc until the a.out ld.so is fixed.
  1839.     ;;
  1840.   *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
  1841.     # Do not include libc due to us having libc/libc_r.
  1842.     ;;
  1843.   *-*-sco3.2v5* | *-*-sco5v6*)
  1844.     # Causes problems with __ctype
  1845.     ;;
  1846.   *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
  1847.     # Compiler inserts libc in the correct place for threads to work
  1848.     ;;
  1849.   *)
  1850.     # Add libc to deplibs on all other systems if necessary.
  1851.     if test "$build_libtool_need_lc" = "yes"; then
  1852.       deplibs="$deplibs -lc"
  1853.     fi
  1854.     ;;
  1855.   esac
  1856. fi
  1857. # Transform deplibs into only deplibs that can be linked in shared.
  1858. name_save=$name
  1859. libname_save=$libname
  1860. release_save=$release
  1861. versuffix_save=$versuffix
  1862. major_save=$major
  1863. # I'm not sure if I'm treating the release correctly.  I think
  1864. # release should show up in the -l (ie -lgmp5) so we don't want to
  1865. # add it in twice.  Is that correct?
  1866. release=""
  1867. versuffix=""
  1868. major=""
  1869. newdeplibs=
  1870. droppeddeps=no
  1871. case $deplibs_check_method in
  1872. pass_all)
  1873.   # Don't check for shared/static.  Everything works.
  1874.   # This might be a little naive.  We might want to check
  1875.   # whether the library exists or not.  But this is on
  1876.   # osf3 & osf4 and I'm not really sure... Just
  1877.   # implementing what was already the behavior.
  1878.   newdeplibs=$deplibs
  1879.   ;;
  1880. test_compile)
  1881.   # This code stresses the "libraries are programs" paradigm to its
  1882.   # limits. Maybe even breaks it.  We compile a program, linking it
  1883.   # against the deplibs as a proxy for the library.  Then we can check
  1884.   # whether they linked in statically or dynamically with ldd.
  1885.   $opt_dry_run || $RM conftest.c
  1886.   cat > conftest.c <<EOF
  1887.   int main() { return 0; }
  1888. EOF
  1889.   $opt_dry_run || $RM conftest
  1890.   if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
  1891.     ldd_output=`ldd conftest`
  1892.     for i in $deplibs; do
  1893.       name=`expr $i : '-l(.*)'`
  1894.       # If $name is empty we are operating on a -L argument.
  1895.       if test "$name" != "" && test "$name" != "0"; then
  1896. if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  1897.   case " $predeps $postdeps " in
  1898.   *" $i "*)
  1899.     newdeplibs="$newdeplibs $i"
  1900.     i=""
  1901.     ;;
  1902.   esac
  1903. fi
  1904. if test -n "$i" ; then
  1905.   libname=`eval "\$ECHO "$libname_spec""`
  1906.   deplib_matches=`eval "\$ECHO "$library_names_spec""`
  1907.   set dummy $deplib_matches; shift
  1908.   deplib_match=$1
  1909.   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  1910.     newdeplibs="$newdeplibs $i"
  1911.   else
  1912.     droppeddeps=yes
  1913.     $ECHO
  1914.     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
  1915.     $ECHO "*** I have the capability to make that library automatically link in when"
  1916.     $ECHO "*** you link to this library.  But I can only do this if you have a"
  1917.     $ECHO "*** shared version of the library, which I believe you do not have"
  1918.     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
  1919.     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
  1920.   fi
  1921. fi
  1922.       else
  1923. newdeplibs="$newdeplibs $i"
  1924.       fi
  1925.     done
  1926.   else
  1927.     # Error occurred in the first compile.  Let's try to salvage
  1928.     # the situation: Compile a separate program for each library.
  1929.     for i in $deplibs; do
  1930.       name=`expr $i : '-l(.*)'`
  1931.       # If $name is empty we are operating on a -L argument.
  1932.       if test "$name" != "" && test "$name" != "0"; then
  1933. $opt_dry_run || $RM conftest
  1934. if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
  1935.   ldd_output=`ldd conftest`
  1936.   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  1937.     case " $predeps $postdeps " in
  1938.     *" $i "*)
  1939.       newdeplibs="$newdeplibs $i"
  1940.       i=""
  1941.       ;;
  1942.     esac
  1943.   fi
  1944.   if test -n "$i" ; then
  1945.     libname=`eval "\$ECHO "$libname_spec""`
  1946.     deplib_matches=`eval "\$ECHO "$library_names_spec""`
  1947.     set dummy $deplib_matches; shift
  1948.     deplib_match=$1
  1949.     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
  1950.       newdeplibs="$newdeplibs $i"
  1951.     else
  1952.       droppeddeps=yes
  1953.       $ECHO
  1954.       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
  1955.       $ECHO "*** I have the capability to make that library automatically link in when"
  1956.       $ECHO "*** you link to this library.  But I can only do this if you have a"
  1957.       $ECHO "*** shared version of the library, which you do not appear to have"
  1958.       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
  1959.       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
  1960.     fi
  1961.   fi
  1962. else
  1963.   droppeddeps=yes
  1964.   $ECHO
  1965.   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
  1966.   $ECHO "*** make it link in!  You will probably need to install it or some"
  1967.   $ECHO "*** library that it depends on before this library will be fully"
  1968.   $ECHO "*** functional.  Installing it before continuing would be even better."
  1969. fi
  1970.       else
  1971. newdeplibs="$newdeplibs $i"
  1972.       fi
  1973.     done
  1974.   fi
  1975.   ;;
  1976. file_magic*)
  1977.   set dummy $deplibs_check_method; shift
  1978.   file_magic_regex=`expr "$deplibs_check_method" : "$1 (.*)"`
  1979.   for a_deplib in $deplibs; do
  1980.     name=`expr $a_deplib : '-l(.*)'`
  1981.     # If $name is empty we are operating on a -L argument.
  1982.     if test "$name" != "" && test  "$name" != "0"; then
  1983.       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  1984. case " $predeps $postdeps " in
  1985. *" $a_deplib "*)
  1986.   newdeplibs="$newdeplibs $a_deplib"
  1987.   a_deplib=""
  1988.   ;;
  1989. esac
  1990.       fi
  1991.       if test -n "$a_deplib" ; then
  1992. libname=`eval "\$ECHO "$libname_spec""`
  1993. for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  1994.   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  1995.   for potent_lib in $potential_libs; do
  1996.       # Follow soft links.
  1997.       if ls -lLd "$potent_lib" 2>/dev/null |
  1998.  $GREP " -> " >/dev/null; then
  1999. continue
  2000.       fi
  2001.       # The statement above tries to avoid entering an
  2002.       # endless loop below, in case of cyclic links.
  2003.       # We might still enter an endless loop, since a link
  2004.       # loop can be closed while we follow links,
  2005.       # but so what?
  2006.       potlib="$potent_lib"
  2007.       while test -h "$potlib" 2>/dev/null; do
  2008. potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
  2009. case $potliblink in
  2010. [\/]* | [A-Za-z]:[\/]*) potlib="$potliblink";;
  2011. *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
  2012. esac
  2013.       done
  2014.       if eval $file_magic_cmd "$potlib" 2>/dev/null |
  2015.  $SED -e 10q |
  2016.  $EGREP "$file_magic_regex" > /dev/null; then
  2017. newdeplibs="$newdeplibs $a_deplib"
  2018. a_deplib=""
  2019. break 2
  2020.       fi
  2021.   done
  2022. done
  2023.       fi
  2024.       if test -n "$a_deplib" ; then
  2025. droppeddeps=yes
  2026. $ECHO
  2027. $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
  2028. $ECHO "*** I have the capability to make that library automatically link in when"
  2029. $ECHO "*** you link to this library.  But I can only do this if you have a"
  2030. $ECHO "*** shared version of the library, which you do not appear to have"
  2031. $ECHO "*** because I did check the linker path looking for a file starting"
  2032. if test -z "$potlib" ; then
  2033.   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
  2034. else
  2035.   $ECHO "*** with $libname and none of the candidates passed a file format test"
  2036.   $ECHO "*** using a file magic. Last file checked: $potlib"
  2037. fi
  2038.       fi
  2039.     else
  2040.       # Add a -L argument.
  2041.       newdeplibs="$newdeplibs $a_deplib"
  2042.     fi
  2043.   done # Gone through all deplibs.
  2044.   ;;
  2045. match_pattern*)
  2046.   set dummy $deplibs_check_method; shift
  2047.   match_pattern_regex=`expr "$deplibs_check_method" : "$1 (.*)"`
  2048.   for a_deplib in $deplibs; do
  2049.     name=`expr $a_deplib : '-l(.*)'`
  2050.     # If $name is empty we are operating on a -L argument.
  2051.     if test -n "$name" && test "$name" != "0"; then
  2052.       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  2053. case " $predeps $postdeps " in
  2054. *" $a_deplib "*)
  2055.   newdeplibs="$newdeplibs $a_deplib"
  2056.   a_deplib=""
  2057.   ;;
  2058. esac
  2059.       fi
  2060.       if test -n "$a_deplib" ; then
  2061. libname=`eval "\$ECHO "$libname_spec""`
  2062. for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  2063.   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  2064.   for potent_lib in $potential_libs; do
  2065.     potlib="$potent_lib" # see symlink-check above in file_magic test
  2066.     if eval "$ECHO "X$potent_lib"" 2>/dev/null | $Xsed -e 10q | 
  2067.        $EGREP "$match_pattern_regex" > /dev/null; then
  2068.       newdeplibs="$newdeplibs $a_deplib"
  2069.       a_deplib=""
  2070.       break 2
  2071.     fi
  2072.   done
  2073. done
  2074.       fi
  2075.       if test -n "$a_deplib" ; then
  2076. droppeddeps=yes
  2077. $ECHO
  2078. $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
  2079. $ECHO "*** I have the capability to make that library automatically link in when"
  2080. $ECHO "*** you link to this library.  But I can only do this if you have a"
  2081. $ECHO "*** shared version of the library, which you do not appear to have"
  2082. $ECHO "*** because I did check the linker path looking for a file starting"
  2083. if test -z "$potlib" ; then
  2084.   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
  2085. else
  2086.   $ECHO "*** with $libname and none of the candidates passed a file format test"
  2087.   $ECHO "*** using a regex pattern. Last file checked: $potlib"
  2088. fi
  2089.       fi
  2090.     else
  2091.       # Add a -L argument.
  2092.       newdeplibs="$newdeplibs $a_deplib"
  2093.     fi
  2094.   done # Gone through all deplibs.
  2095.   ;;
  2096. none | unknown | *)
  2097.   newdeplibs=""
  2098.   tmp_deplibs=`$ECHO "X $deplibs" | $Xsed 
  2099.       -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
  2100.   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
  2101.     for i in $predeps $postdeps ; do
  2102.       # can't use Xsed below, because $i might contain '/'
  2103.       tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
  2104.     done
  2105.   fi
  2106.   if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[  ]//g' |
  2107.      $GREP . >/dev/null; then
  2108.     $ECHO
  2109.     if test "X$deplibs_check_method" = "Xnone"; then
  2110.       $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
  2111.     else
  2112.       $ECHO "*** Warning: inter-library dependencies are not known to be supported."
  2113.     fi
  2114.     $ECHO "*** All declared inter-library dependencies are being dropped."
  2115.     droppeddeps=yes
  2116.   fi
  2117.   ;;
  2118. esac
  2119. versuffix=$versuffix_save
  2120. major=$major_save
  2121. release=$release_save
  2122. libname=$libname_save
  2123. name=$name_save
  2124. case $host in
  2125. *-*-rhapsody* | *-*-darwin1.[012])
  2126.   # On Rhapsody replace the C library with the System framework
  2127.   newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
  2128.   ;;
  2129. esac
  2130. if test "$droppeddeps" = yes; then
  2131.   if test "$module" = yes; then
  2132.     $ECHO
  2133.     $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
  2134.     $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
  2135.     $ECHO "*** a static module, that should work as long as the dlopening"
  2136.     $ECHO "*** application is linked with the -dlopen flag."
  2137.     if test -z "$global_symbol_pipe"; then
  2138.       $ECHO
  2139.       $ECHO "*** However, this would only work if libtool was able to extract symbol"
  2140.       $ECHO "*** lists from a program, using `nm' or equivalent, but libtool could"
  2141.       $ECHO "*** not find such a program.  So, this module is probably useless."
  2142.       $ECHO "*** `nm' from GNU binutils and a full rebuild may help."
  2143.     fi
  2144.     if test "$build_old_libs" = no; then
  2145.       oldlibs="$output_objdir/$libname.$libext"
  2146.       build_libtool_libs=module
  2147.       build_old_libs=yes
  2148.     else
  2149.       build_libtool_libs=no
  2150.     fi
  2151.   else
  2152.     $ECHO "*** The inter-library dependencies that have been dropped here will be"
  2153.     $ECHO "*** automatically added whenever a program is linked with this library"
  2154.     $ECHO "*** or is declared to -dlopen it."
  2155.     if test "$allow_undefined" = no; then
  2156.       $ECHO
  2157.       $ECHO "*** Since this library must not contain undefined symbols,"
  2158.       $ECHO "*** because either the platform does not support them or"
  2159.       $ECHO "*** it was explicitly requested with -no-undefined,"
  2160.       $ECHO "*** libtool will only create a static version of it."
  2161.       if test "$build_old_libs" = no; then
  2162. oldlibs="$output_objdir/$libname.$libext"
  2163. build_libtool_libs=module
  2164. build_old_libs=yes
  2165.       else
  2166. build_libtool_libs=no
  2167.       fi
  2168.     fi
  2169.   fi
  2170. fi
  2171. # Done checking deplibs!
  2172. deplibs=$newdeplibs
  2173.       fi
  2174.       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
  2175.       case $host in
  2176. *-*-darwin*)
  2177.   newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  2178.   new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  2179.   deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  2180.   ;;
  2181.       esac
  2182.       # move library search paths that coincide with paths to not yet
  2183.       # installed libraries to the beginning of the library search list
  2184.       new_libs=
  2185.       for path in $notinst_path; do
  2186. case " $new_libs " in
  2187. *" -L$path/$objdir "*) ;;
  2188. *)
  2189.   case " $deplibs " in
  2190.   *" -L$path/$objdir "*)
  2191.     new_libs="$new_libs -L$path/$objdir" ;;
  2192.   esac
  2193.   ;;
  2194. esac
  2195.       done
  2196.       for deplib in $deplibs; do
  2197. case $deplib in
  2198. -L*)
  2199.   case " $new_libs " in
  2200.   *" $deplib "*) ;;
  2201.   *) new_libs="$new_libs $deplib" ;;
  2202.   esac
  2203.   ;;
  2204. *) new_libs="$new_libs $deplib" ;;
  2205. esac
  2206.       done
  2207.       deplibs="$new_libs"
  2208.       # All the library-specific variables (install_libdir is set above).
  2209.       library_names=
  2210.       old_library=
  2211.       dlname=
  2212.       # Test again, we may have decided not to build it any more
  2213.       if test "$build_libtool_libs" = yes; then
  2214. if test "$hardcode_into_libs" = yes; then
  2215.   # Hardcode the library paths
  2216.   hardcode_libdirs=
  2217.   dep_rpath=
  2218.   rpath="$finalize_rpath"
  2219.   test "$mode" != relink && rpath="$compile_rpath$rpath"
  2220.   for libdir in $rpath; do
  2221.     if test -n "$hardcode_libdir_flag_spec"; then
  2222.       if test -n "$hardcode_libdir_separator"; then
  2223. if test -z "$hardcode_libdirs"; then
  2224.   hardcode_libdirs="$libdir"
  2225. else
  2226.   # Just accumulate the unique libdirs.
  2227.   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  2228.   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  2229.     ;;
  2230.   *)
  2231.     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  2232.     ;;
  2233.   esac
  2234. fi
  2235.       else
  2236. eval flag="$hardcode_libdir_flag_spec"
  2237. dep_rpath="$dep_rpath $flag"
  2238.       fi
  2239.     elif test -n "$runpath_var"; then
  2240.       case "$perm_rpath " in
  2241.       *" $libdir "*) ;;
  2242.       *) perm_rpath="$perm_rpath $libdir" ;;
  2243.       esac
  2244.     fi
  2245.   done
  2246.   # Substitute the hardcoded libdirs into the rpath.
  2247.   if test -n "$hardcode_libdir_separator" &&
  2248.      test -n "$hardcode_libdirs"; then
  2249.     libdir="$hardcode_libdirs"
  2250.     if test -n "$hardcode_libdir_flag_spec_ld"; then
  2251.       eval dep_rpath="$hardcode_libdir_flag_spec_ld"
  2252.     else
  2253.       eval dep_rpath="$hardcode_libdir_flag_spec"
  2254.     fi
  2255.   fi
  2256.   if test -n "$runpath_var" && test -n "$perm_rpath"; then
  2257.     # We should set the runpath_var.
  2258.     rpath=
  2259.     for dir in $perm_rpath; do
  2260.       rpath="$rpath$dir:"
  2261.     done
  2262.     eval "$runpath_var='$rpath$$runpath_var'; export $runpath_var"
  2263.   fi
  2264.   test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
  2265. fi
  2266. shlibpath="$finalize_shlibpath"
  2267. test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
  2268. if test -n "$shlibpath"; then
  2269.   eval "$shlibpath_var='$shlibpath$$shlibpath_var'; export $shlibpath_var"
  2270. fi
  2271. # Get the real and link names of the library.
  2272. eval shared_ext="$shrext_cmds"
  2273. eval library_names="$library_names_spec"
  2274. set dummy $library_names
  2275. shift
  2276. realname="$1"
  2277. shift
  2278. if test -n "$soname_spec"; then
  2279.   eval soname="$soname_spec"
  2280. else
  2281.   soname="$realname"
  2282. fi
  2283. if test -z "$dlname"; then
  2284.   dlname=$soname
  2285. fi
  2286. lib="$output_objdir/$realname"
  2287. linknames=
  2288. for link
  2289. do
  2290.   linknames="$linknames $link"
  2291. done
  2292. # Use standard objects if they are pic
  2293. test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2294. test "X$libobjs" = "X " && libobjs=
  2295. delfiles=
  2296. if test -n "$export_symbols" && test -n "$include_expsyms"; then
  2297.   $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
  2298.   export_symbols="$output_objdir/$libname.uexp"
  2299.   delfiles="$delfiles $export_symbols"
  2300. fi
  2301. orig_export_symbols=
  2302. case $host_os in
  2303. cygwin* | mingw*)
  2304.   if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
  2305.     # exporting using user supplied symfile
  2306.     if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
  2307.       # and it's NOT already a .def file. Must figure out
  2308.       # which of the given symbols are data symbols and tag
  2309.       # them as such. So, trigger use of export_symbols_cmds.
  2310.       # export_symbols gets reassigned inside the "prepare
  2311.       # the list of exported symbols" if statement, so the
  2312.       # include_expsyms logic still works.
  2313.       orig_export_symbols="$export_symbols"
  2314.       export_symbols=
  2315.       always_export_symbols=yes
  2316.     fi
  2317.   fi
  2318.   ;;
  2319. esac
  2320. # Prepare the list of exported symbols
  2321. if test -z "$export_symbols"; then
  2322.   if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
  2323.     func_verbose "generating symbol list for `$libname.la'"
  2324.     export_symbols="$output_objdir/$libname.exp"
  2325.     $opt_dry_run || $RM $export_symbols
  2326.     cmds=$export_symbols_cmds
  2327.     save_ifs="$IFS"; IFS='~'
  2328.     for cmd in $cmds; do
  2329.       IFS="$save_ifs"
  2330.       eval cmd="$cmd"
  2331.       if len=`expr "X$cmd" : ".*"` &&
  2332.        test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  2333. func_show_eval "$cmd" 'exit $?'
  2334. skipped_export=false
  2335.       else
  2336. # The command line is too long to execute in one step.
  2337. func_verbose "using reloadable object file for export list..."
  2338. skipped_export=:
  2339. # Break out early, otherwise skipped_export may be
  2340. # set to false by a later but shorter cmd.
  2341. break
  2342.       fi
  2343.     done
  2344.     IFS="$save_ifs"
  2345.     if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
  2346.       func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  2347.       func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
  2348.     fi
  2349.   fi
  2350. fi
  2351. if test -n "$export_symbols" && test -n "$include_expsyms"; then
  2352.   tmp_export_symbols="$export_symbols"
  2353.   test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
  2354.   $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
  2355. fi
  2356. if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
  2357.   # The given exports_symbols file has to be filtered, so filter it.
  2358.   func_verbose "filter symbol list for `$libname.la' to tag DATA exports"
  2359.   # FIXME: $output_objdir/$libname.filter potentially contains lots of
  2360.   # 's' commands which not all seds can handle. GNU sed should be fine
  2361.   # though. Also, the filter scales superlinearly with the number of
  2362.   # global variables. join(1) would be nice here, but unfortunately
  2363.   # isn't a blessed tool.
  2364.   $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,(.*)([ ,].*),s|^1$|12|,' < $export_symbols > $output_objdir/$libname.filter
  2365.   delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
  2366.   export_symbols=$output_objdir/$libname.def
  2367.   $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
  2368. fi
  2369. tmp_deplibs=
  2370. for test_deplib in $deplibs; do
  2371.   case " $convenience " in
  2372.   *" $test_deplib "*) ;;
  2373.   *)
  2374.     tmp_deplibs="$tmp_deplibs $test_deplib"
  2375.     ;;
  2376.   esac
  2377. done
  2378. deplibs="$tmp_deplibs"
  2379. if test -n "$convenience"; then
  2380.   if test -n "$whole_archive_flag_spec" &&
  2381.     test "$compiler_needs_object" = yes &&
  2382.     test -z "$libobjs"; then
  2383.     # extract the archives, so we have objects to list.
  2384.     # TODO: could optimize this to just extract one archive.
  2385.     whole_archive_flag_spec=
  2386.   fi
  2387.   if test -n "$whole_archive_flag_spec"; then
  2388.     save_libobjs=$libobjs
  2389.     eval libobjs="$libobjs $whole_archive_flag_spec"
  2390.     test "X$libobjs" = "X " && libobjs=
  2391.   else
  2392.     gentop="$output_objdir/${outputname}x"
  2393.     generated="$generated $gentop"
  2394.     func_extract_archives $gentop $convenience
  2395.     libobjs="$libobjs $func_extract_archives_result"
  2396.     test "X$libobjs" = "X " && libobjs=
  2397.   fi
  2398. fi
  2399. if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
  2400.   eval flag="$thread_safe_flag_spec"
  2401.   linker_flags="$linker_flags $flag"
  2402. fi
  2403. # Make a backup of the uninstalled library when relinking
  2404. if test "$mode" = relink; then
  2405.   $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
  2406. fi
  2407. # Do each of the archive commands.
  2408. if test "$module" = yes && test -n "$module_cmds" ; then
  2409.   if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  2410.     eval test_cmds="$module_expsym_cmds"
  2411.     cmds=$module_expsym_cmds
  2412.   else
  2413.     eval test_cmds="$module_cmds"
  2414.     cmds=$module_cmds
  2415.   fi
  2416. else
  2417.   if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  2418.     eval test_cmds="$archive_expsym_cmds"
  2419.     cmds=$archive_expsym_cmds
  2420.   else
  2421.     eval test_cmds="$archive_cmds"
  2422.     cmds=$archive_cmds
  2423.   fi
  2424. fi
  2425. if test "X$skipped_export" != "X:" &&
  2426.    len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  2427.    test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  2428.   :
  2429. else
  2430.   # The command line is too long to link in one step, link piecewise
  2431.   # or, if using GNU ld and skipped_export is not :, use a linker
  2432.   # script.
  2433.   # Save the value of $output and $libobjs because we want to
  2434.   # use them later.  If we have whole_archive_flag_spec, we
  2435.   # want to use save_libobjs as it was before
  2436.   # whole_archive_flag_spec was expanded, because we can't
  2437.   # assume the linker understands whole_archive_flag_spec.
  2438.   # This may have to be revisited, in case too many
  2439.   # convenience libraries get linked in and end up exceeding
  2440.   # the spec.
  2441.   if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
  2442.     save_libobjs=$libobjs
  2443.   fi
  2444.   save_output=$output
  2445.   output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
  2446.   # Clear the reloadable object creation command queue and
  2447.   # initialize k to one.
  2448.   test_cmds=
  2449.   concat_cmds=
  2450.   objlist=
  2451.   last_robj=
  2452.   k=1
  2453.   if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
  2454.     output=${output_objdir}/${output_la}.lnkscript
  2455.     func_verbose "creating GNU ld script: $output"
  2456.     $ECHO 'INPUT (' > $output
  2457.     for obj in $save_libobjs
  2458.     do
  2459.       $ECHO "$obj" >> $output
  2460.     done
  2461.     $ECHO ')' >> $output
  2462.     delfiles="$delfiles $output"
  2463.   elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
  2464.     output=${output_objdir}/${output_la}.lnk
  2465.     func_verbose "creating linker input file list: $output"
  2466.     : > $output
  2467.     set x $save_libobjs
  2468.     shift
  2469.     firstobj=
  2470.     if test "$compiler_needs_object" = yes; then
  2471.       firstobj="$1 "
  2472.       shift
  2473.     fi
  2474.     for obj
  2475.     do
  2476.       $ECHO "$obj" >> $output
  2477.     done
  2478.     delfiles="$delfiles $output"
  2479.     output=$firstobj"$file_list_spec$output"
  2480.   else
  2481.     if test -n "$save_libobjs"; then
  2482.       func_verbose "creating reloadable object files..."
  2483.       output=$output_objdir/$output_la-${k}.$objext
  2484.       # Loop over the list of objects to be linked.
  2485.       for obj in $save_libobjs
  2486.       do
  2487. eval test_cmds="$reload_cmds $objlist $last_robj"
  2488. if test "X$objlist" = X ||
  2489.    { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  2490.      test "$len" -le "$max_cmd_len"; }; then
  2491.   objlist="$objlist $obj"
  2492. else
  2493.   # The command $test_cmds is almost too long, add a
  2494.   # command to the queue.
  2495.   if test "$k" -eq 1 ; then
  2496.     # The first file doesn't have a previous command to add.
  2497.     eval concat_cmds="$reload_cmds $objlist $last_robj"
  2498.   else
  2499.     # All subsequent reloadable object files will link in
  2500.     # the last one created.
  2501.     eval concat_cmds="$concat_cmds~$reload_cmds $objlist $last_robj~$RM $last_robj"
  2502.   fi
  2503.   last_robj=$output_objdir/$output_la-${k}.$objext
  2504.   k=`expr $k + 1`
  2505.   output=$output_objdir/$output_la-${k}.$objext
  2506.   objlist=$obj
  2507.   len=1
  2508. fi
  2509.       done
  2510.       # Handle the remaining objects by creating one last
  2511.       # reloadable object file.  All subsequent reloadable object
  2512.       # files will link in the last one created.
  2513.       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  2514.       eval concat_cmds="${concat_cmds}$reload_cmds $objlist $last_robj"
  2515.       if test -n "$last_robj"; then
  2516.         eval concat_cmds="${concat_cmds}~$RM $last_robj"
  2517.       fi
  2518.       delfiles="$delfiles $output"
  2519.     else
  2520.       output=
  2521.     fi
  2522.     if ${skipped_export-false}; then
  2523.       func_verbose "generating symbol list for `$libname.la'"
  2524.       export_symbols="$output_objdir/$libname.exp"
  2525.       $opt_dry_run || $RM $export_symbols
  2526.       libobjs=$output
  2527.       # Append the command to create the export file.
  2528.       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  2529.       eval concat_cmds="$concat_cmds$export_symbols_cmds"
  2530.       if test -n "$last_robj"; then
  2531. eval concat_cmds="$concat_cmds~$RM $last_robj"
  2532.       fi
  2533.     fi
  2534.     test -n "$save_libobjs" &&
  2535.       func_verbose "creating a temporary reloadable object file: $output"
  2536.     # Loop through the commands generated above and execute them.
  2537.     save_ifs="$IFS"; IFS='~'
  2538.     for cmd in $concat_cmds; do
  2539.       IFS="$save_ifs"
  2540.       $opt_silent || {
  2541.   func_quote_for_expand "$cmd"
  2542.   eval "func_echo $func_quote_for_expand_result"
  2543.       }
  2544.       $opt_dry_run || eval "$cmd" || {
  2545. lt_exit=$?
  2546. # Restore the uninstalled library and exit
  2547. if test "$mode" = relink; then
  2548.   ( cd "$output_objdir" && 
  2549.     $RM "${realname}T" && 
  2550.     $MV "${realname}U" "$realname" )
  2551. fi
  2552. exit $lt_exit
  2553.       }
  2554.     done
  2555.     IFS="$save_ifs"
  2556.     if test -n "$export_symbols_regex" && ${skipped_export-false}; then
  2557.       func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  2558.       func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
  2559.     fi
  2560.   fi
  2561.           if ${skipped_export-false}; then
  2562.     if test -n "$export_symbols" && test -n "$include_expsyms"; then
  2563.       tmp_export_symbols="$export_symbols"
  2564.       test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
  2565.       $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
  2566.     fi
  2567.     if test -n "$orig_export_symbols"; then
  2568.       # The given exports_symbols file has to be filtered, so filter it.
  2569.       func_verbose "filter symbol list for `$libname.la' to tag DATA exports"
  2570.       # FIXME: $output_objdir/$libname.filter potentially contains lots of
  2571.       # 's' commands which not all seds can handle. GNU sed should be fine
  2572.       # though. Also, the filter scales superlinearly with the number of
  2573.       # global variables. join(1) would be nice here, but unfortunately
  2574.       # isn't a blessed tool.
  2575.       $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,(.*)([ ,].*),s|^1$|12|,' < $export_symbols > $output_objdir/$libname.filter
  2576.       delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
  2577.       export_symbols=$output_objdir/$libname.def
  2578.       $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
  2579.     fi
  2580.   fi
  2581.   libobjs=$output
  2582.   # Restore the value of output.
  2583.   output=$save_output
  2584.   if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
  2585.     eval libobjs="$libobjs $whole_archive_flag_spec"
  2586.     test "X$libobjs" = "X " && libobjs=
  2587.   fi
  2588.   # Expand the library linking commands again to reset the
  2589.   # value of $libobjs for piecewise linking.
  2590.   # Do each of the archive commands.
  2591.   if test "$module" = yes && test -n "$module_cmds" ; then
  2592.     if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  2593.       cmds=$module_expsym_cmds
  2594.     else
  2595.       cmds=$module_cmds
  2596.     fi
  2597.   else
  2598.     if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  2599.       cmds=$archive_expsym_cmds
  2600.     else
  2601.       cmds=$archive_cmds
  2602.     fi
  2603.   fi
  2604. fi
  2605. if test -n "$delfiles"; then
  2606.   # Append the command to remove temporary files to $cmds.
  2607.   eval cmds="$cmds~$RM $delfiles"
  2608. fi
  2609. # Add any objects from preloaded convenience libraries
  2610. if test -n "$dlprefiles"; then
  2611.   gentop="$output_objdir/${outputname}x"
  2612.   generated="$generated $gentop"
  2613.   func_extract_archives $gentop $dlprefiles
  2614.   libobjs="$libobjs $func_extract_archives_result"
  2615.   test "X$libobjs" = "X " && libobjs=
  2616. fi
  2617. save_ifs="$IFS"; IFS='~'
  2618. for cmd in $cmds; do
  2619.   IFS="$save_ifs"
  2620.   eval cmd="$cmd"
  2621.   $opt_silent || {
  2622.     func_quote_for_expand "$cmd"
  2623.     eval "func_echo $func_quote_for_expand_result"
  2624.   }
  2625.   $opt_dry_run || eval "$cmd" || {
  2626.     lt_exit=$?
  2627.     # Restore the uninstalled library and exit
  2628.     if test "$mode" = relink; then
  2629.       ( cd "$output_objdir" && 
  2630.         $RM "${realname}T" && 
  2631. $MV "${realname}U" "$realname" )
  2632.     fi
  2633.     exit $lt_exit
  2634.   }
  2635. done
  2636. IFS="$save_ifs"
  2637. # Restore the uninstalled library and exit
  2638. if test "$mode" = relink; then
  2639.   $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
  2640.   if test -n "$convenience"; then
  2641.     if test -z "$whole_archive_flag_spec"; then
  2642.       func_show_eval '${RM}r "$gentop"'
  2643.     fi
  2644.   fi
  2645.   exit $EXIT_SUCCESS
  2646. fi
  2647. # Create links to the real library.
  2648. for linkname in $linknames; do
  2649.   if test "$realname" != "$linkname"; then
  2650.     func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
  2651.   fi
  2652. done
  2653. # If -module or -export-dynamic was specified, set the dlname.
  2654. if test "$module" = yes || test "$export_dynamic" = yes; then
  2655.   # On all known operating systems, these are identical.
  2656.   dlname="$soname"
  2657. fi
  2658.       fi
  2659.       ;;
  2660.     obj)
  2661.       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
  2662. func_warning "`-dlopen' is ignored for objects"
  2663.       fi
  2664.       case " $deplibs" in
  2665.       * -l* | * -L*)
  2666. func_warning "`-l' and `-L' are ignored for objects" ;;
  2667.       esac
  2668.       test -n "$rpath" && 
  2669. func_warning "`-rpath' is ignored for objects"
  2670.       test -n "$xrpath" && 
  2671. func_warning "`-R' is ignored for objects"
  2672.       test -n "$vinfo" && 
  2673. func_warning "`-version-info' is ignored for objects"
  2674.       test -n "$release" && 
  2675. func_warning "`-release' is ignored for objects"
  2676.       case $output in
  2677.       *.lo)
  2678. test -n "$objs$old_deplibs" && 
  2679.   func_fatal_error "cannot build library object `$output' from non-libtool objects"
  2680. libobj=$output
  2681. func_lo2o "$libobj"
  2682. obj=$func_lo2o_result
  2683. ;;
  2684.       *)
  2685. libobj=
  2686. obj="$output"
  2687. ;;
  2688.       esac
  2689.       # Delete the old objects.
  2690.       $opt_dry_run || $RM $obj $libobj
  2691.       # Objects from convenience libraries.  This assumes
  2692.       # single-version convenience libraries.  Whenever we create
  2693.       # different ones for PIC/non-PIC, this we'll have to duplicate
  2694.       # the extraction.
  2695.       reload_conv_objs=
  2696.       gentop=
  2697.       # reload_cmds runs $LD directly, so let us get rid of
  2698.       # -Wl from whole_archive_flag_spec and hope we can get by with
  2699.       # turning comma into space..
  2700.       wl=
  2701.       if test -n "$convenience"; then
  2702. if test -n "$whole_archive_flag_spec"; then
  2703.   eval tmp_whole_archive_flags="$whole_archive_flag_spec"
  2704.   reload_conv_objs=$reload_objs `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
  2705. else
  2706.   gentop="$output_objdir/${obj}x"
  2707.   generated="$generated $gentop"
  2708.   func_extract_archives $gentop $convenience
  2709.   reload_conv_objs="$reload_objs $func_extract_archives_result"
  2710. fi
  2711.       fi
  2712.       # Create the old-style object.
  2713.       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
  2714.       output="$obj"
  2715.       func_execute_cmds "$reload_cmds" 'exit $?'
  2716.       # Exit if we aren't doing a library object file.
  2717.       if test -z "$libobj"; then
  2718. if test -n "$gentop"; then
  2719.   func_show_eval '${RM}r "$gentop"'
  2720. fi
  2721. exit $EXIT_SUCCESS
  2722.       fi
  2723.       if test "$build_libtool_libs" != yes; then
  2724. if test -n "$gentop"; then
  2725.   func_show_eval '${RM}r "$gentop"'
  2726. fi
  2727. # Create an invalid libtool object if no PIC, so that we don't
  2728. # accidentally link it into a program.
  2729. # $show "echo timestamp > $libobj"
  2730. # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
  2731. exit $EXIT_SUCCESS
  2732.       fi
  2733.       if test -n "$pic_flag" || test "$pic_mode" != default; then
  2734. # Only do commands if we really have different PIC objects.
  2735. reload_objs="$libobjs $reload_conv_objs"
  2736. output="$libobj"
  2737. func_execute_cmds "$reload_cmds" 'exit $?'
  2738.       fi
  2739.       if test -n "$gentop"; then
  2740. func_show_eval '${RM}r "$gentop"'
  2741.       fi
  2742.       exit $EXIT_SUCCESS
  2743.       ;;
  2744.     prog)
  2745.       case $host in
  2746. *cygwin*) func_stripname '' '.exe' "$output"
  2747.           output=$func_stripname_result.exe;;
  2748.       esac
  2749.       test -n "$vinfo" && 
  2750. func_warning "`-version-info' is ignored for programs"
  2751.       test -n "$release" && 
  2752. func_warning "`-release' is ignored for programs"
  2753.       test "$preload" = yes 
  2754.         && test "$dlopen_support" = unknown 
  2755. && test "$dlopen_self" = unknown 
  2756. && test "$dlopen_self_static" = unknown && 
  2757.   func_warning "`LT_INIT([dlopen])' not used. Assuming no dlopen support."
  2758.       case $host in
  2759.       *-*-rhapsody* | *-*-darwin1.[012])
  2760. # On Rhapsody replace the C library is the System framework
  2761. compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
  2762. finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
  2763. ;;
  2764.       esac
  2765.       case $host in
  2766.       *-*-darwin*)
  2767. # Don't allow lazy linking, it breaks C++ global constructors
  2768. # But is supposedly fixed on 10.4 or later (yay!).
  2769. if test "$tagname" = CXX ; then
  2770.   case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
  2771.     10.[0123])
  2772.       compile_command="$compile_command ${wl}-bind_at_load"
  2773.       finalize_command="$finalize_command ${wl}-bind_at_load"
  2774.     ;;
  2775.   esac
  2776. fi
  2777. # Time to change all our "foo.ltframework" stuff back to "-framework foo"
  2778. compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  2779. finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% ([^ $]*).ltframework% -framework 1%g'`
  2780. ;;
  2781.       esac
  2782.       # move library search paths that coincide with paths to not yet
  2783.       # installed libraries to the beginning of the library search list
  2784.       new_libs=
  2785.       for path in $notinst_path; do
  2786. case " $new_libs " in
  2787. *" -L$path/$objdir "*) ;;
  2788. *)
  2789.   case " $compile_deplibs " in
  2790.   *" -L$path/$objdir "*)
  2791.     new_libs="$new_libs -L$path/$objdir" ;;
  2792.   esac
  2793.   ;;
  2794. esac
  2795.       done
  2796.       for deplib in $compile_deplibs; do
  2797. case $deplib in
  2798. -L*)
  2799.   case " $new_libs " in
  2800.   *" $deplib "*) ;;
  2801.   *) new_libs="$new_libs $deplib" ;;
  2802.   esac
  2803.   ;;
  2804. *) new_libs="$new_libs $deplib" ;;
  2805. esac
  2806.       done
  2807.       compile_deplibs="$new_libs"
  2808.       compile_command="$compile_command $compile_deplibs"
  2809.       finalize_command="$finalize_command $finalize_deplibs"
  2810.       if test -n "$rpath$xrpath"; then
  2811. # If the user specified any rpath flags, then add them.
  2812. for libdir in $rpath $xrpath; do
  2813.   # This is the magic to use -rpath.
  2814.   case "$finalize_rpath " in
  2815.   *" $libdir "*) ;;
  2816.   *) finalize_rpath="$finalize_rpath $libdir" ;;
  2817.   esac
  2818. done
  2819.       fi
  2820.       # Now hardcode the library paths
  2821.       rpath=
  2822.       hardcode_libdirs=
  2823.       for libdir in $compile_rpath $finalize_rpath; do
  2824. if test -n "$hardcode_libdir_flag_spec"; then
  2825.   if test -n "$hardcode_libdir_separator"; then
  2826.     if test -z "$hardcode_libdirs"; then
  2827.       hardcode_libdirs="$libdir"
  2828.     else
  2829.       # Just accumulate the unique libdirs.
  2830.       case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  2831.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  2832. ;;
  2833.       *)
  2834. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  2835. ;;
  2836.       esac
  2837.     fi
  2838.   else
  2839.     eval flag="$hardcode_libdir_flag_spec"
  2840.     rpath="$rpath $flag"
  2841.   fi
  2842. elif test -n "$runpath_var"; then
  2843.   case "$perm_rpath " in
  2844.   *" $libdir "*) ;;
  2845.   *) perm_rpath="$perm_rpath $libdir" ;;
  2846.   esac
  2847. fi
  2848. case $host in
  2849. *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
  2850.   testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
  2851.   case :$dllsearchpath: in
  2852.   *":$libdir:"*) ;;
  2853.   *) dllsearchpath="$dllsearchpath:$libdir";;
  2854.   esac
  2855.   case :$dllsearchpath: in
  2856.   *":$testbindir:"*) ;;
  2857.   *) dllsearchpath="$dllsearchpath:$testbindir";;
  2858.   esac
  2859.   ;;
  2860. esac
  2861.       done
  2862.       # Substitute the hardcoded libdirs into the rpath.
  2863.       if test -n "$hardcode_libdir_separator" &&
  2864.  test -n "$hardcode_libdirs"; then
  2865. libdir="$hardcode_libdirs"
  2866. eval rpath=" $hardcode_libdir_flag_spec"
  2867.       fi
  2868.       compile_rpath="$rpath"
  2869.       rpath=
  2870.       hardcode_libdirs=
  2871.       for libdir in $finalize_rpath; do
  2872. if test -n "$hardcode_libdir_flag_spec"; then
  2873.   if test -n "$hardcode_libdir_separator"; then
  2874.     if test -z "$hardcode_libdirs"; then
  2875.       hardcode_libdirs="$libdir"
  2876.     else
  2877.       # Just accumulate the unique libdirs.
  2878.       case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  2879.       *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  2880. ;;
  2881.       *)
  2882. hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
  2883. ;;
  2884.       esac
  2885.     fi
  2886.   else
  2887.     eval flag="$hardcode_libdir_flag_spec"
  2888.     rpath="$rpath $flag"
  2889.   fi
  2890. elif test -n "$runpath_var"; then
  2891.   case "$finalize_perm_rpath " in
  2892.   *" $libdir "*) ;;
  2893.   *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
  2894.   esac
  2895. fi
  2896.       done
  2897.       # Substitute the hardcoded libdirs into the rpath.
  2898.       if test -n "$hardcode_libdir_separator" &&
  2899.  test -n "$hardcode_libdirs"; then
  2900. libdir="$hardcode_libdirs"
  2901. eval rpath=" $hardcode_libdir_flag_spec"
  2902.       fi
  2903.       finalize_rpath="$rpath"
  2904.       if test -n "$libobjs" && test "$build_old_libs" = yes; then
  2905. # Transform all the library objects into standard objects.
  2906. compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2907. finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
  2908.       fi
  2909.       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
  2910.       # template prelinking step
  2911.       if test -n "$prelink_cmds"; then
  2912. func_execute_cmds "$prelink_cmds" 'exit $?'
  2913.       fi
  2914.       wrappers_required=yes
  2915.       case $host in
  2916.       *cygwin* | *mingw* )
  2917.         if test "$build_libtool_libs" != yes; then
  2918.           wrappers_required=no
  2919.         fi
  2920.         ;;
  2921.       *)
  2922.         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
  2923.           wrappers_required=no
  2924.         fi
  2925.         ;;
  2926.       esac
  2927.       if test "$wrappers_required" = no; then
  2928. # Replace the output file specification.
  2929. compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  2930. link_command="$compile_command$compile_rpath"
  2931. # We have no uninstalled library dependencies, so finalize right now.
  2932. exit_status=0
  2933. func_show_eval "$link_command" 'exit_status=$?'
  2934. # Delete the generated files.
  2935. if test -f "$output_objdir/${outputname}S.${objext}"; then
  2936.   func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
  2937. fi
  2938. exit $exit_status
  2939.       fi
  2940.       if test -n "$compile_shlibpath$finalize_shlibpath"; then
  2941. compile_command="$shlibpath_var="$compile_shlibpath$finalize_shlibpath$$shlibpath_var" $compile_command"
  2942.       fi
  2943.       if test -n "$finalize_shlibpath"; then
  2944. finalize_command="$shlibpath_var="$finalize_shlibpath$$shlibpath_var" $finalize_command"
  2945.       fi
  2946.       compile_var=
  2947.       finalize_var=
  2948.       if test -n "$runpath_var"; then
  2949. if test -n "$perm_rpath"; then
  2950.   # We should set the runpath_var.
  2951.   rpath=
  2952.   for dir in $perm_rpath; do
  2953.     rpath="$rpath$dir:"
  2954.   done
  2955.   compile_var="$runpath_var="$rpath$$runpath_var" "
  2956. fi
  2957. if test -n "$finalize_perm_rpath"; then
  2958.   # We should set the runpath_var.
  2959.   rpath=
  2960.   for dir in $finalize_perm_rpath; do
  2961.     rpath="$rpath$dir:"
  2962.   done
  2963.   finalize_var="$runpath_var="$rpath$$runpath_var" "
  2964. fi
  2965.       fi
  2966.       if test "$no_install" = yes; then
  2967. # We don't need to create a wrapper script.
  2968. link_command="$compile_var$compile_command$compile_rpath"
  2969. # Replace the output file specification.
  2970. link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
  2971. # Delete the old output file.
  2972. $opt_dry_run || $RM $output
  2973. # Link the executable and exit
  2974. func_show_eval "$link_command" 'exit $?'
  2975. exit $EXIT_SUCCESS
  2976.       fi
  2977.       if test "$hardcode_action" = relink; then
  2978. # Fast installation is not supported
  2979. link_command="$compile_var$compile_command$compile_rpath"
  2980. relink_command="$finalize_var$finalize_command$finalize_rpath"
  2981. func_warning "this platform does not like uninstalled shared libraries"
  2982. func_warning "`$output' will be relinked during installation"
  2983.       else
  2984. if test "$fast_install" != no; then
  2985.   link_command="$finalize_var$compile_command$finalize_rpath"
  2986.   if test "$fast_install" = yes; then
  2987.     relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%$progdir/$file%g'`
  2988.   else
  2989.     # fast_install is set to needless
  2990.     relink_command=
  2991.   fi
  2992. else
  2993.   link_command="$compile_var$compile_command$compile_rpath"
  2994.   relink_command="$finalize_var$finalize_command$finalize_rpath"
  2995. fi
  2996.       fi
  2997.       # Replace the output file specification.
  2998.       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
  2999.       # Delete the old output files.
  3000.       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
  3001.       func_show_eval "$link_command" 'exit $?'
  3002.       # Now create the wrapper script.
  3003.       func_verbose "creating $output"
  3004.       # Quote the relink command for shipping.
  3005.       if test -n "$relink_command"; then
  3006. # Preserve any variables that may affect compiler behavior
  3007. for var in $variables_saved_for_relink; do
  3008.   if eval test -z "${$var+set}"; then
  3009.     relink_command="{ test -z "${$var+set}" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
  3010.   elif eval var_value=$$var; test -z "$var_value"; then
  3011.     relink_command="$var=; export $var; $relink_command"
  3012.   else
  3013.     func_quote_for_eval "$var_value"
  3014.     relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
  3015.   fi
  3016. done
  3017. relink_command="(cd `pwd`; $relink_command)"
  3018. relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
  3019.       fi
  3020.       # Quote $ECHO for shipping.
  3021.       if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
  3022. case $progpath in
  3023. [\/]* | [A-Za-z]:[\/]*) qecho="$SHELL $progpath --fallback-echo";;
  3024. *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
  3025. esac
  3026. qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
  3027.       else
  3028. qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
  3029.       fi
  3030.       # Only actually do things if not in dry run mode.
  3031.       $opt_dry_run || {
  3032. # win32 will think the script is a binary if it has
  3033. # a .exe suffix, so we strip it off here.
  3034. case $output in
  3035.   *.exe) func_stripname '' '.exe' "$output"
  3036.          output=$func_stripname_result ;;
  3037. esac
  3038. # test for cygwin because mv fails w/o .exe extensions
  3039. case $host in
  3040.   *cygwin*)
  3041.     exeext=.exe
  3042.     func_stripname '' '.exe' "$outputname"
  3043.     outputname=$func_stripname_result ;;
  3044.   *) exeext= ;;
  3045. esac
  3046. case $host in
  3047.   *cygwin* | *mingw* )
  3048.     func_dirname_and_basename "$output" "" "."
  3049.     output_name=$func_basename_result
  3050.     output_path=$func_dirname_result
  3051.     cwrappersource="$output_path/$objdir/lt-$output_name.c"
  3052.     cwrapper="$output_path/$output_name.exe"
  3053.     $RM $cwrappersource $cwrapper
  3054.     trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
  3055.     func_emit_cwrapperexe_src > $cwrappersource
  3056.     # we should really use a build-platform specific compiler
  3057.     # here, but OTOH, the wrappers (shell script and this C one)
  3058.     # are only useful if you want to execute the "real" binary.
  3059.     # Since the "real" binary is built for $host, then this
  3060.     # wrapper might as well be built for $host, too.
  3061.     $opt_dry_run || {
  3062.       $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
  3063.       $STRIP $cwrapper
  3064.     }
  3065.     # Now, create the wrapper script for func_source use:
  3066.     func_ltwrapper_scriptname $cwrapper
  3067.     $RM $func_ltwrapper_scriptname_result
  3068.     trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
  3069.     $opt_dry_run || {
  3070.       $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
  3071.     }
  3072.   ;;
  3073.   * )
  3074.     $RM $output
  3075.     trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
  3076.     func_emit_wrapper no > $output
  3077.     chmod +x $output
  3078.   ;;
  3079. esac
  3080.       }
  3081.       exit $EXIT_SUCCESS
  3082.       ;;
  3083.     esac
  3084.     # See if we need to build an old-fashioned archive.
  3085.     for oldlib in $oldlibs; do
  3086.       if test "$build_libtool_libs" = convenience; then
  3087. oldobjs="$libobjs_save $symfileobj"
  3088. addlibs="$convenience"
  3089. build_libtool_libs=no
  3090.       else
  3091. if test "$build_libtool_libs" = module; then
  3092.   oldobjs="$libobjs_save"
  3093.   build_libtool_libs=no
  3094. else
  3095.   oldobjs="$old_deplibs $non_pic_objects"
  3096.   if test "$preload" = yes && test -f "$symfileobj"; then
  3097.     oldobjs="$oldobjs $symfileobj"
  3098.   fi
  3099. fi
  3100. addlibs="$old_convenience"
  3101.       fi
  3102.       if test -n "$addlibs"; then
  3103. gentop="$output_objdir/${outputname}x"
  3104. generated="$generated $gentop"
  3105. func_extract_archives $gentop $addlibs
  3106. oldobjs="$oldobjs $func_extract_archives_result"
  3107.       fi
  3108.       # Do each command in the archive commands.
  3109.       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
  3110. cmds=$old_archive_from_new_cmds
  3111.       else
  3112. # Add any objects from preloaded convenience libraries
  3113. if test -n "$dlprefiles"; then
  3114.   gentop="$output_objdir/${outputname}x"
  3115.   generated="$generated $gentop"
  3116.   func_extract_archives $gentop $dlprefiles
  3117.   oldobjs="$oldobjs $func_extract_archives_result"
  3118. fi
  3119. # POSIX demands no paths to be encoded in archives.  We have
  3120. # to avoid creating archives with duplicate basenames if we
  3121. # might have to extract them afterwards, e.g., when creating a
  3122. # static archive out of a convenience library, or when linking
  3123. # the entirety of a libtool archive into another (currently
  3124. # not supported by libtool).
  3125. if (for obj in $oldobjs
  3126.     do
  3127.       func_basename "$obj"
  3128.       $ECHO "$func_basename_result"
  3129.     done | sort | sort -uc >/dev/null 2>&1); then
  3130.   :
  3131. else
  3132.   $ECHO "copying selected object files to avoid basename conflicts..."
  3133.   gentop="$output_objdir/${outputname}x"
  3134.   generated="$generated $gentop"
  3135.   func_mkdir_p "$gentop"
  3136.   save_oldobjs=$oldobjs
  3137.   oldobjs=
  3138.   counter=1
  3139.   for obj in $save_oldobjs
  3140.   do
  3141.     func_basename "$obj"
  3142.     objbase="$func_basename_result"
  3143.     case " $oldobjs " in
  3144.     " ") oldobjs=$obj ;;
  3145.     *[ /]"$objbase "*)
  3146.       while :; do
  3147. # Make sure we don't pick an alternate name that also
  3148. # overlaps.
  3149. newobj=lt$counter-$objbase
  3150. counter=`expr $counter + 1`
  3151. case " $oldobjs " in
  3152. *[ /]"$newobj "*) ;;
  3153. *) if test ! -f "$gentop/$newobj"; then break; fi ;;
  3154. esac
  3155.       done
  3156.       func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
  3157.       oldobjs="$oldobjs $gentop/$newobj"
  3158.       ;;
  3159.     *) oldobjs="$oldobjs $obj" ;;
  3160.     esac
  3161.   done
  3162. fi
  3163. eval cmds="$old_archive_cmds"
  3164. if len=`expr "X$cmds" : ".*" 2>/dev/null` &&
  3165.    test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  3166.   cmds=$old_archive_cmds
  3167. else
  3168.   # the command line is too long to link in one step, link in parts
  3169.   func_verbose "using piecewise archive linking..."
  3170.   save_RANLIB=$RANLIB
  3171.   RANLIB=:
  3172.   objlist=
  3173.   concat_cmds=
  3174.   save_oldobjs=$oldobjs
  3175.   # Is there a better way of finding the last object in the list?
  3176.   for obj in $save_oldobjs
  3177.   do
  3178.     last_oldobj=$obj
  3179.   done
  3180.   for obj in $save_oldobjs
  3181.   do
  3182.     oldobjs="$objlist $obj"
  3183.     objlist="$objlist $obj"
  3184.     eval test_cmds="$old_archive_cmds"
  3185.     if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
  3186.        test "$len" -le "$max_cmd_len"; then
  3187.       :
  3188.     else
  3189.       # the above command should be used before it gets too long
  3190.       oldobjs=$objlist
  3191.       if test "$obj" = "$last_oldobj" ; then
  3192. RANLIB=$save_RANLIB
  3193.       fi
  3194.       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  3195.       eval concat_cmds="${concat_cmds}$old_archive_cmds"
  3196.       objlist=
  3197.     fi
  3198.   done
  3199.   RANLIB=$save_RANLIB
  3200.   oldobjs=$objlist
  3201.   if test "X$oldobjs" = "X" ; then
  3202.     eval cmds="$concat_cmds"
  3203.   else
  3204.     eval cmds="$concat_cmds~$old_archive_cmds"
  3205.   fi
  3206. fi
  3207.       fi
  3208.       func_execute_cmds "$cmds" 'exit $?'
  3209.     done
  3210.     test -n "$generated" && 
  3211.       func_show_eval "${RM}r$generated"
  3212.     # Now create the libtool archive.
  3213.     case $output in
  3214.     *.la)
  3215.       old_library=
  3216.       test "$build_old_libs" = yes && old_library="$libname.$libext"
  3217.       func_verbose "creating $output"
  3218.       # Preserve any variables that may affect compiler behavior
  3219.       for var in $variables_saved_for_relink; do
  3220. if eval test -z "${$var+set}"; then
  3221.   relink_command="{ test -z "${$var+set}" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
  3222. elif eval var_value=$$var; test -z "$var_value"; then
  3223.   relink_command="$var=; export $var; $relink_command"
  3224. else
  3225.   func_quote_for_eval "$var_value"
  3226.   relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
  3227. fi
  3228.       done
  3229.       # Quote the link command for shipping.
  3230.       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
  3231.       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
  3232.       if test "$hardcode_automatic" = yes ; then
  3233. relink_command=
  3234.       fi
  3235.       # Only create the output if not a dry run.
  3236.       $opt_dry_run || {
  3237. for installed in no yes; do
  3238.   if test "$installed" = yes; then
  3239.     if test -z "$install_libdir"; then
  3240.       break
  3241.     fi
  3242.     output="$output_objdir/$outputname"i
  3243.     # Replace all uninstalled libtool libraries with the installed ones
  3244.     newdependency_libs=
  3245.     for deplib in $dependency_libs; do
  3246.       case $deplib in
  3247.       *.la)
  3248. func_basename "$deplib"
  3249. name="$func_basename_result"
  3250. eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $deplib`
  3251. test -z "$libdir" && 
  3252.   func_fatal_error "`$deplib' is not a valid libtool archive"
  3253. newdependency_libs="$newdependency_libs $libdir/$name"
  3254. ;;
  3255.       *) newdependency_libs="$newdependency_libs $deplib" ;;
  3256.       esac
  3257.     done
  3258.     dependency_libs="$newdependency_libs"
  3259.     newdlfiles=
  3260.     for lib in $dlfiles; do
  3261.       case $lib in
  3262.       *.la)
  3263.         func_basename "$lib"
  3264. name="$func_basename_result"
  3265. eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $lib`
  3266. test -z "$libdir" && 
  3267.   func_fatal_error "`$lib' is not a valid libtool archive"
  3268. newdlfiles="$newdlfiles $libdir/$name"
  3269. ;;
  3270.       *) newdlfiles="$newdlfiles $lib" ;;
  3271.       esac
  3272.     done
  3273.     dlfiles="$newdlfiles"
  3274.     newdlprefiles=
  3275.     for lib in $dlprefiles; do
  3276.       case $lib in
  3277.       *.la)
  3278. # Only pass preopened files to the pseudo-archive (for
  3279. # eventual linking with the app. that links it) if we
  3280. # didn't already link the preopened objects directly into
  3281. # the library:
  3282. func_basename "$lib"
  3283. name="$func_basename_result"
  3284. eval libdir=`${SED} -n -e 's/^libdir=(.*)$/1/p' $lib`
  3285. test -z "$libdir" && 
  3286.   func_fatal_error "`$lib' is not a valid libtool archive"
  3287. newdlprefiles="$newdlprefiles $libdir/$name"
  3288. ;;
  3289.       esac
  3290.     done
  3291.     dlprefiles="$newdlprefiles"
  3292.   else
  3293.     newdlfiles=
  3294.     for lib in $dlfiles; do
  3295.       case $lib in
  3296. [\/]* | [A-Za-z]:[\/]*) abs="$lib" ;;
  3297. *) abs=`pwd`"/$lib" ;;
  3298.       esac
  3299.       newdlfiles="$newdlfiles $abs"
  3300.     done
  3301.     dlfiles="$newdlfiles"
  3302.     newdlprefiles=
  3303.     for lib in $dlprefiles; do
  3304.       case $lib in
  3305. [\/]* | [A-Za-z]:[\/]*) abs="$lib" ;;
  3306. *) abs=`pwd`"/$lib" ;;
  3307.       esac
  3308.       newdlprefiles="$newdlprefiles $abs"
  3309.     done
  3310.     dlprefiles="$newdlprefiles"
  3311.   fi
  3312.   $RM $output
  3313.   # place dlname in correct position for cygwin
  3314.   tdlname=$dlname
  3315.   case $host,$output,$installed,$module,$dlname in
  3316.     *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
  3317.   esac
  3318.   $ECHO > $output "
  3319. # $outputname - a libtool library file
  3320. # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
  3321. #
  3322. # Please DO NOT delete this file!
  3323. # It is necessary for linking the library.
  3324. # The name that we can dlopen(3).
  3325. dlname='$tdlname'
  3326. # Names of this library.
  3327. library_names='$library_names'
  3328. # The name of the static archive.
  3329. old_library='$old_library'
  3330. # Linker flags that can not go in dependency_libs.
  3331. inherited_linker_flags='$new_inherited_linker_flags'
  3332. # Libraries that this one depends upon.
  3333. dependency_libs='$dependency_libs'
  3334. # Names of additional weak libraries provided by this library
  3335. weak_library_names='$weak_libs'
  3336. # Version information for $libname.
  3337. current=$current
  3338. age=$age
  3339. revision=$revision
  3340. # Is this an already installed library?
  3341. installed=$installed
  3342. # Should we warn about portability when linking against -modules?
  3343. shouldnotlink=$module
  3344. # Files to dlopen/dlpreopen
  3345. dlopen='$dlfiles'
  3346. dlpreopen='$dlprefiles'
  3347. # Directory that this library needs to be installed in:
  3348. libdir='$install_libdir'"
  3349.   if test "$installed" = no && test "$need_relink" = yes; then
  3350.     $ECHO >> $output "
  3351. relink_command="$relink_command""
  3352.   fi
  3353. done
  3354.       }
  3355.       # Do a symbolic link so that the libtool archive can be found in
  3356.       # LD_LIBRARY_PATH before the program is installed.
  3357.       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
  3358.       ;;
  3359.     esac
  3360.     exit $EXIT_SUCCESS
  3361. }
  3362. { test "$mode" = link || test "$mode" = relink; } &&
  3363.     func_mode_link ${1+"$@"}
  3364. # func_mode_uninstall arg...
  3365. func_mode_uninstall ()
  3366. {
  3367.     $opt_debug
  3368.     RM="$nonopt"
  3369.     files=
  3370.     rmforce=
  3371.     exit_status=0
  3372.     # This variable tells wrapper scripts just to set variables rather
  3373.     # than running their programs.
  3374.     libtool_install_magic="$magic"
  3375.     for arg
  3376.     do
  3377.       case $arg in
  3378.       -f) RM="$RM $arg"; rmforce=yes ;;
  3379.       -*) RM="$RM $arg" ;;
  3380.       *) files="$files $arg" ;;
  3381.       esac
  3382.     done
  3383.     test -z "$RM" && 
  3384.       func_fatal_help "you must specify an RM program"
  3385.     rmdirs=
  3386.     origobjdir="$objdir"
  3387.     for file in $files; do
  3388.       func_dirname "$file" "" "."
  3389.       dir="$func_dirname_result"
  3390.       if test "X$dir" = X.; then
  3391. objdir="$origobjdir"
  3392.       else
  3393. objdir="$dir/$origobjdir"
  3394.       fi
  3395.       func_basename "$file"
  3396.       name="$func_basename_result"
  3397.       test "$mode" = uninstall && objdir="$dir"
  3398.       # Remember objdir for removal later, being careful to avoid duplicates
  3399.       if test "$mode" = clean; then
  3400. case " $rmdirs " in
  3401.   *" $objdir "*) ;;
  3402.   *) rmdirs="$rmdirs $objdir" ;;
  3403. esac
  3404.       fi
  3405.       # Don't error if the file doesn't exist and rm -f was used.
  3406.       if { test -L "$file"; } >/dev/null 2>&1 ||
  3407.  { test -h "$file"; } >/dev/null 2>&1 ||
  3408.  test -f "$file"; then
  3409. :
  3410.       elif test -d "$file"; then
  3411. exit_status=1
  3412. continue
  3413.       elif test "$rmforce" = yes; then
  3414. continue
  3415.       fi
  3416.       rmfiles="$file"
  3417.       case $name in
  3418.       *.la)
  3419. # Possibly a libtool archive, so verify it.
  3420. if func_lalib_p "$file"; then
  3421.   func_source $dir/$name
  3422.   # Delete the libtool libraries and symlinks.
  3423.   for n in $library_names; do
  3424.     rmfiles="$rmfiles $objdir/$n"
  3425.   done
  3426.   test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
  3427.   case "$mode" in
  3428.   clean)
  3429.     case "  $library_names " in
  3430.     # "  " in the beginning catches empty $dlname
  3431.     *" $dlname "*) ;;
  3432.     *) rmfiles="$rmfiles $objdir/$dlname" ;;
  3433.     esac
  3434.     test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
  3435.     ;;
  3436.   uninstall)
  3437.     if test -n "$library_names"; then
  3438.       # Do each command in the postuninstall commands.
  3439.       func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
  3440.     fi
  3441.     if test -n "$old_library"; then
  3442.       # Do each command in the old_postuninstall commands.
  3443.       func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
  3444.     fi
  3445.     # FIXME: should reinstall the best remaining shared library.
  3446.     ;;
  3447.   esac
  3448. fi
  3449. ;;
  3450.       *.lo)
  3451. # Possibly a libtool object, so verify it.
  3452. if func_lalib_p "$file"; then
  3453.   # Read the .lo file
  3454.   func_source $dir/$name
  3455.   # Add PIC object to the list of files to remove.
  3456.   if test -n "$pic_object" &&
  3457.      test "$pic_object" != none; then
  3458.     rmfiles="$rmfiles $dir/$pic_object"
  3459.   fi
  3460.   # Add non-PIC object to the list of files to remove.
  3461.   if test -n "$non_pic_object" &&
  3462.      test "$non_pic_object" != none; then
  3463.     rmfiles="$rmfiles $dir/$non_pic_object"
  3464.   fi
  3465. fi
  3466. ;;
  3467.       *)
  3468. if test "$mode" = clean ; then
  3469.   noexename=$name
  3470.   case $file in
  3471.   *.exe)
  3472.     func_stripname '' '.exe' "$file"
  3473.     file=$func_stripname_result
  3474.     func_stripname '' '.exe' "$name"
  3475.     noexename=$func_stripname_result
  3476.     # $file with .exe has already been added to rmfiles,
  3477.     # add $file without .exe
  3478.     rmfiles="$rmfiles $file"
  3479.     ;;
  3480.   esac
  3481.   # Do a test to see if this is a libtool program.
  3482.   if func_ltwrapper_p "$file"; then
  3483.     if func_ltwrapper_executable_p "$file"; then
  3484.       func_ltwrapper_scriptname "$file"
  3485.       relink_command=
  3486.       func_source $func_ltwrapper_scriptname_result
  3487.       rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
  3488.     else
  3489.       relink_command=
  3490.       func_source $dir/$noexename
  3491.     fi
  3492.     # note $name still contains .exe if it was in $file originally
  3493.     # as does the version of $file that was added into $rmfiles
  3494.     rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
  3495.     if test "$fast_install" = yes && test -n "$relink_command"; then
  3496.       rmfiles="$rmfiles $objdir/lt-$name"
  3497.     fi
  3498.     if test "X$noexename" != "X$name" ; then
  3499.       rmfiles="$rmfiles $objdir/lt-${noexename}.c"
  3500.     fi
  3501.   fi
  3502. fi
  3503. ;;
  3504.       esac
  3505.       func_show_eval "$RM $rmfiles" 'exit_status=1'
  3506.     done
  3507.     objdir="$origobjdir"
  3508.     # Try to remove the ${objdir}s in the directories where we deleted files
  3509.     for dir in $rmdirs; do
  3510.       if test -d "$dir"; then
  3511. func_show_eval "rmdir $dir >/dev/null 2>&1"
  3512.       fi
  3513.     done
  3514.     exit $exit_status
  3515. }
  3516. { test "$mode" = uninstall || test "$mode" = clean; } &&
  3517.     func_mode_uninstall ${1+"$@"}
  3518. test -z "$mode" && {
  3519.   help="$generic_help"
  3520.   func_fatal_help "you must specify a MODE"
  3521. }
  3522. test -z "$exec_cmd" && 
  3523.   func_fatal_help "invalid operation mode `$mode'"
  3524. if test -n "$exec_cmd"; then
  3525.   eval exec "$exec_cmd"
  3526.   exit $EXIT_FAILURE
  3527. fi
  3528. exit $exit_status
  3529. # The TAGs below are defined such that we never get into a situation
  3530. # in which we disable both kinds of libraries.  Given conflicting
  3531. # choices, we go for a static library, that is the most portable,
  3532. # since we can't tell whether shared libraries were disabled because
  3533. # the user asked for that or because the platform doesn't support
  3534. # them.  This is particularly important on AIX, because we don't
  3535. # support having both static and shared libraries enabled at the same
  3536. # time on that platform, so we default to a shared-only configuration.
  3537. # If a disable-shared tag is given, we'll fallback to a static-only
  3538. # configuration.  But we'll never go from static-only to shared-only.
  3539. # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
  3540. build_libtool_libs=no
  3541. build_old_libs=yes
  3542. # ### END LIBTOOL TAG CONFIG: disable-shared
  3543. # ### BEGIN LIBTOOL TAG CONFIG: disable-static
  3544. build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
  3545. # ### END LIBTOOL TAG CONFIG: disable-static
  3546. # Local Variables:
  3547. # mode:shell-script
  3548. # sh-indentation:2
  3549. # End:
  3550. # vi:sw=2