lemon-project-template-glpk: 33de93886c88 deps/glpk/ltmain.sh

4843 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4844 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4845 char **

4846 prepare_spawn (char **argv)

4847 {

4848 size_t argc;

4849 char **new_argv;

4850 size_t i;

4851

4852 /* Count number of arguments. */

4853 for (argc = 0; argv[argc] != NULL; argc++)

4854 ;

4855

4856 /* Allocate new argument vector. */

4857 new_argv = XMALLOC (char *, argc + 1);

4858

4859 /* Put quoted arguments into the new argument vector. */

4860 for (i = 0; i < argc; i++)

4861 {

4862 const char *string = argv[i];

4863

4864 if (string[0] == '\0')

4865 new_argv[i] = xstrdup ("\"\"");

4866 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)

4867 {

4868 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);

4869 size_t length;

4870 unsigned int backslashes;

4871 const char *s;

4872 char *quoted_string;

4873 char *p;

4874

4875 length = 0;

4876 backslashes = 0;

4877 if (quote_around)

4878 length++;

4879 for (s = string; *s != '\0'; s++)

4880 {

4881 char c = *s;

4882 if (c == '"')

4883 length += backslashes + 1;

4884 length++;

4885 if (c == '\\')

4886 backslashes++;

4887 else

4888 backslashes = 0;

4889 }

4890 if (quote_around)

4891 length += backslashes + 1;

4892

4893 quoted_string = XMALLOC (char, length + 1);

4894

4895 p = quoted_string;

4896 backslashes = 0;

4897 if (quote_around)

4898 *p++ = '"';

4899 for (s = string; *s != '\0'; s++)

4900 {

4901 char c = *s;

4902 if (c == '"')

4903 {

4904 unsigned int j;

4905 for (j = backslashes + 1; j > 0; j--)

4906 *p++ = '\\';

4907 }

4908 *p++ = c;

4909 if (c == '\\')

4910 backslashes++;

4911 else

4912 backslashes = 0;

4913 }

4914 if (quote_around)

4915 {

4916 unsigned int j;

4917 for (j = backslashes; j > 0; j--)

4918 *p++ = '\\';

4919 *p++ = '"';

4920 }

4921 *p = '\0';

4922

4923 new_argv[i] = quoted_string;

4924 }

4925 else

4926 new_argv[i] = (char *) string;

4927 }

4928 new_argv[argc] = NULL;

4929

4930 return new_argv;

4931 }

4932 EOF

4933 ;;

4934 esac

4935

4936 cat <<"EOF"

4937 void lt_dump_script (FILE* f)

4938 {

4939 EOF

4940 func_emit_wrapper yes |

4941 $SED -e 's/$[\\"]$/\\\1/g' \

4942 -e 's/^/ fputs ("/' -e 's/$/\\n", f);/'

4943

4944 cat <<"EOF"

4945 }

4946 EOF

4947 }

4948 # end: func_emit_cwrapperexe_src

4949

4950 # func_emit_exe_manifest

4951 # emit a Win32 UAC manifest for executable on stdout

4952 # Must ONLY be called from within func_mode_link because

4953 # it depends on a number of variable set therein.

4954 func_emit_exe_manifest ()

4955 {

4956 cat <<EOF

4957 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>

4958 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">

4959 <assemblyIdentity version="1.0.0.0"

4960 EOF

4961

4962 case $host in

4963 i?86-*-* ) echo ' processorArchitecture="x86"' ;;

4964 ia64-*-* ) echo ' processorArchitecture="ia64"' ;;

4965 x86_64-*-* ) echo ' processorArchitecture="amd64"' ;;

4966 *) echo ' processorArchitecture="*"' ;;

4967 esac

4968

4969 cat <<EOF

4970 name="$host_os.$PROGRAM.$outputname"

4971 type="win32"/>

4972

4973

4974 <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">

4975 <security>

4976 <requestedPrivileges>

4977 <requestedExecutionLevel level="asInvoker" uiAccess="false"/>

4978 </requestedPrivileges>

4979 </security>

4980 </trustInfo>

4981 </assembly>

4982 EOF

4983 }

4984

4985 # func_win32_import_lib_p ARG

4986 # True if ARG is an import lib, as indicated by $file_magic_cmd

4987 func_win32_import_lib_p ()

4988 {

4989 $opt_debug

4990 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in

4991 *import*) : ;;

4992 *) false ;;

4993 esac

4994 }

4995

4996 # func_mode_link arg...

4997 func_mode_link ()

4998 {

4999 $opt_debug

5000 case $host in

5001 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

5002 # It is impossible to link a dll without this setting, and

5003 # we shouldn't force the makefile maintainer to figure out

5004 # which system we are compiling for in order to pass an extra

5005 # flag for every libtool invocation.

5006 # allow_undefined=no

5007

5008 # FIXME: Unfortunately, there are problems with the above when trying

5009 # to make a dll which has undefined symbols, in which case not

5010 # even a static library is built. For now, we need to specify

5011 # -no-undefined on the libtool link line when we can be certain

5012 # that all symbols are satisfied, otherwise we get a static library.

5013 allow_undefined=yes

5014 ;;

5015 *)

5016 allow_undefined=yes

5017 ;;

5018 esac

5019 libtool_args=$nonopt

5020 base_compile="$nonopt $@"

5021 compile_command=$nonopt

5022 finalize_command=$nonopt

5023

5024 compile_rpath=

5025 finalize_rpath=

5026 compile_shlibpath=

5027 finalize_shlibpath=

5028 convenience=

5029 old_convenience=

5030 deplibs=

5031 old_deplibs=

5032 compiler_flags=

5033 linker_flags=

5034 dllsearchpath=

5035 lib_search_path=`pwd`

5036 inst_prefix_dir=

5037 new_inherited_linker_flags=

5038

5039 avoid_version=no

5040 bindir=

5041 dlfiles=

5042 dlprefiles=

5043 dlself=no

5044 export_dynamic=no

5045 export_symbols=

5046 export_symbols_regex=

5047 generated=

5048 libobjs=

5049 ltlibs=

5050 module=no

5051 no_install=no

5052 objs=

5053 non_pic_objects=

5054 precious_files_regex=

5055 prefer_static_libs=no

5056 preload=no

5057 prev=

5058 prevarg=

5059 release=

5060 rpath=

5061 xrpath=

5062 perm_rpath=

5063 temp_rpath=

5064 thread_safe=no

5065 vinfo=

5066 vinfo_number=no

5067 weak_libs=

5068 single_module="${wl}-single_module"

5069 func_infer_tag $base_compile

5070

5071 # We need to know -static, to get the right output filenames.

5072 for arg

5073 do

5074 case $arg in

5075 -shared)

5076 test "$build_libtool_libs" != yes && \

5077 func_fatal_configuration "can not build a shared library"

5078 build_old_libs=no

5079 break

5080 ;;

5081 -all-static | -static | -static-libtool-libs)

5082 case $arg in

5083 -all-static)

5084 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

5085 func_warning "complete static linking is impossible in this configuration"

5086 fi

5087 if test -n "$link_static_flag"; then

5088 dlopen_self=$dlopen_self_static

5089 fi

5090 prefer_static_libs=yes

5091 ;;

5092 -static)

5093 if test -z "$pic_flag" && test -n "$link_static_flag"; then

5094 dlopen_self=$dlopen_self_static

5095 fi

5096 prefer_static_libs=built

5097 ;;

5098 -static-libtool-libs)

5099 if test -z "$pic_flag" && test -n "$link_static_flag"; then

5100 dlopen_self=$dlopen_self_static

5101 fi

5102 prefer_static_libs=yes

5103 ;;

5104 esac

5105 build_libtool_libs=no

5106 build_old_libs=yes

5107 break

5108 ;;

5109 esac

5110 done

5111

5112 # See if our shared archives depend on static archives.

5113 test -n "$old_archive_from_new_cmds" && build_old_libs=yes

5114

5115 # Go through the arguments, transforming them on the way.

5116 while test "$#" -gt 0; do

5117 arg="$1"

5118 shift

5119 func_quote_for_eval "$arg"

5120 qarg=$func_quote_for_eval_unquoted_result

5121 func_append libtool_args " $func_quote_for_eval_result"

5122

5123 # If the previous option needs an argument, assign it.

5124 if test -n "$prev"; then

5125 case $prev in

5126 output)

5127 func_append compile_command " @OUTPUT@"

5128 func_append finalize_command " @OUTPUT@"

5129 ;;

5130 esac

5131

5132 case $prev in

5133 bindir)

5134 bindir="$arg"

5135 prev=

5136 continue

5137 ;;

5138 dlfiles|dlprefiles)

5139 if test "$preload" = no; then

5140 # Add the symbol object into the linking commands.

5141 func_append compile_command " @SYMFILE@"

5142 func_append finalize_command " @SYMFILE@"

5143 preload=yes

5144 fi

5145 case $arg in

5146 *.la | *.lo) ;; # We handle these cases below.

5147 force)

5148 if test "$dlself" = no; then

5149 dlself=needless

5150 export_dynamic=yes

5151 fi

5152 prev=

5153 continue

5154 ;;

5155 self)

5156 if test "$prev" = dlprefiles; then

5157 dlself=yes

5158 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

5159 dlself=yes

5160 else

5161 dlself=needless

5162 export_dynamic=yes

5163 fi

5164 prev=

5165 continue

5166 ;;

5167 *)

5168 if test "$prev" = dlfiles; then

5169 dlfiles="$dlfiles $arg"

5170 else

5171 dlprefiles="$dlprefiles $arg"

5172 fi

5173 prev=

5174 continue

5175 ;;

5176 esac

5177 ;;

5178 expsyms)

5179 export_symbols="$arg"

5180 test -f "$arg" \

5181 || func_fatal_error "symbol file \`$arg' does not exist"

5182 prev=

5183 continue

5184 ;;

5185 expsyms_regex)

5186 export_symbols_regex="$arg"

5187 prev=

5188 continue

5189 ;;

5190 framework)

5191 case $host in

5192 *-*-darwin*)

5193 case "$deplibs " in

5194 *" $qarg.ltframework "*) ;;

5195 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later

5196 ;;

5197 esac

5198 ;;

5199 esac

5200 prev=

5201 continue

5202 ;;

5203 inst_prefix)

5204 inst_prefix_dir="$arg"

5205 prev=

5206 continue

5207 ;;

5208 objectlist)

5209 if test -f "$arg"; then

5210 save_arg=$arg

5211 moreargs=

5212 for fil in `cat "$save_arg"`

5213 do

5214 # moreargs="$moreargs $fil"

5215 arg=$fil

5216 # A libtool-controlled object.

5217

5218 # Check to see that this really is a libtool object.

5219 if func_lalib_unsafe_p "$arg"; then

5220 pic_object=

5221 non_pic_object=

5222

5223 # Read the .lo file

5224 func_source "$arg"

5225

5226 if test -z "$pic_object" ||

5227 test -z "$non_pic_object" ||

5228 test "$pic_object" = none &&

5229 test "$non_pic_object" = none; then

5230 func_fatal_error "cannot find name of object for \`$arg'"

5231 fi

5232

5233 # Extract subdirectory from the argument.

5234 func_dirname "$arg" "/" ""

5235 xdir="$func_dirname_result"

5236

5237 if test "$pic_object" != none; then

5238 # Prepend the subdirectory the object is found in.

5239 pic_object="$xdir$pic_object"

5240

5241 if test "$prev" = dlfiles; then

5242 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

5243 dlfiles="$dlfiles $pic_object"

5244 prev=

5245 continue

5246 else

5247 # If libtool objects are unsupported, then we need to preload.

5248 prev=dlprefiles

5249 fi

5250 fi

5251

5252 # CHECK ME: I think I busted this. -Ossama

5253 if test "$prev" = dlprefiles; then

5254 # Preload the old-style object.

5255 dlprefiles="$dlprefiles $pic_object"

5256 prev=

5257 fi

5258

5259 # A PIC object.

5260 func_append libobjs " $pic_object"

5261 arg="$pic_object"

5262 fi

5263

5264 # Non-PIC object.

5265 if test "$non_pic_object" != none; then

5266 # Prepend the subdirectory the object is found in.

5267 non_pic_object="$xdir$non_pic_object"

5268

5269 # A standard non-PIC object

5270 func_append non_pic_objects " $non_pic_object"

5271 if test -z "$pic_object" || test "$pic_object" = none ; then

5272 arg="$non_pic_object"

5273 fi

5274 else

5275 # If the PIC object exists, use it instead.

5276 # $xdir was prepended to $pic_object above.

5277 non_pic_object="$pic_object"

5278 func_append non_pic_objects " $non_pic_object"

5279 fi

5280 else

5281 # Only an error if not doing a dry-run.

5282 if $opt_dry_run; then

5283 # Extract subdirectory from the argument.

5284 func_dirname "$arg" "/" ""

5285 xdir="$func_dirname_result"

5286

5287 func_lo2o "$arg"

5288 pic_object=$xdir$objdir/$func_lo2o_result

5289 non_pic_object=$xdir$func_lo2o_result

5290 func_append libobjs " $pic_object"

5291 func_append non_pic_objects " $non_pic_object"

5292 else

5293 func_fatal_error "\`$arg' is not a valid libtool object"

5294 fi

5295 fi

5296 done

5297 else

5298 func_fatal_error "link input file \`$arg' does not exist"

5299 fi

5300 arg=$save_arg

5301 prev=

5302 continue

5303 ;;

5304 precious_regex)

5305 precious_files_regex="$arg"

5306 prev=

5307 continue

5308 ;;

5309 release)

5310 release="-$arg"

5311 prev=

5312 continue

5313 ;;

5314 rpath | xrpath)

5315 # We need an absolute path.

5316 case $arg in

5317 [\\/]* | [A-Za-z]:[\\/]*) ;;

5318 *)

5319 func_fatal_error "only absolute run-paths are allowed"

5320 ;;

5321 esac

5322 if test "$prev" = rpath; then

5323 case "$rpath " in

5324 *" $arg "*) ;;

5325 *) rpath="$rpath $arg" ;;

5326 esac

5327 else

5328 case "$xrpath " in

5329 *" $arg "*) ;;

5330 *) xrpath="$xrpath $arg" ;;

5331 esac

5332 fi

5333 prev=

5334 continue

5335 ;;

5336 shrext)

5337 shrext_cmds="$arg"

5338 prev=

5339 continue

5340 ;;

5341 weak)

5342 weak_libs="$weak_libs $arg"

5343 prev=

5344 continue

5345 ;;

5346 xcclinker)

5347 linker_flags="$linker_flags $qarg"

5348 compiler_flags="$compiler_flags $qarg"

5349 prev=

5350 func_append compile_command " $qarg"

5351 func_append finalize_command " $qarg"

5352 continue

5353 ;;

5354 xcompiler)

5355 compiler_flags="$compiler_flags $qarg"

5356 prev=

5357 func_append compile_command " $qarg"

5358 func_append finalize_command " $qarg"

5359 continue

5360 ;;

5361 xlinker)

5362 linker_flags="$linker_flags $qarg"

5363 compiler_flags="$compiler_flags $wl$qarg"

5364 prev=

5365 func_append compile_command " $wl$qarg"

5366 func_append finalize_command " $wl$qarg"

5367 continue

5368 ;;

5369 *)

5370 eval "$prev=\"\$arg\""

5371 prev=

5372 continue

5373 ;;

5374 esac

5375 fi # test -n "$prev"

5376

5377 prevarg="$arg"

5378

5379 case $arg in

5380 -all-static)

5381 if test -n "$link_static_flag"; then

5382 # See comment for -static flag below, for more details.

5383 func_append compile_command " $link_static_flag"

5384 func_append finalize_command " $link_static_flag"

5385 fi

5386 continue

5387 ;;

5388

5389 -allow-undefined)

5390 # FIXME: remove this flag sometime in the future.

5391 func_fatal_error "\`-allow-undefined' must not be used because it is the default"

5392 ;;

5393

5394 -avoid-version)

5395 avoid_version=yes

5396 continue

5397 ;;

5398

5399 -bindir)

5400 prev=bindir

5401 continue

5402 ;;

5403

5404 -dlopen)

5405 prev=dlfiles

5406 continue

5407 ;;

5408

5409 -dlpreopen)

5410 prev=dlprefiles

5411 continue

5412 ;;

5413

5414 -export-dynamic)

5415 export_dynamic=yes

5416 continue

5417 ;;

5418

5419 -export-symbols | -export-symbols-regex)

5420 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

5421 func_fatal_error "more than one -exported-symbols argument is not allowed"

5422 fi

5423 if test "X$arg" = "X-export-symbols"; then

5424 prev=expsyms

5425 else

5426 prev=expsyms_regex

5427 fi

5428 continue

5429 ;;

5430

5431 -framework)

5432 prev=framework

5433 continue

5434 ;;

5435

5436 -inst-prefix-dir)

5437 prev=inst_prefix

5438 continue

5439 ;;

5440

5441 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*

5442 # so, if we see these flags be careful not to treat them like -L

5443 -L[A-Z][A-Z]*:*)

5444 case $with_gcc/$host in

5445 no/*-*-irix* | /*-*-irix*)

5446 func_append compile_command " $arg"

5447 func_append finalize_command " $arg"

5448 ;;

5449 esac

5450 continue

5451 ;;

5452

5453 -L*)

5454 func_stripname '-L' '' "$arg"

5455 dir=$func_stripname_result

5456 if test -z "$dir"; then

5457 if test "$#" -gt 0; then

5458 func_fatal_error "require no space between \`-L' and \`$1'"

5459 else

5460 func_fatal_error "need path for \`-L' option"

5461 fi

5462 fi

5463 # We need an absolute path.

5464 case $dir in

5465 [\\/]* | [A-Za-z]:[\\/]*) ;;

5466 *)

5467 absdir=`cd "$dir" && pwd`

5468 test -z "$absdir" && \

5469 func_fatal_error "cannot determine absolute directory name of \`$dir'"

5470 dir="$absdir"

5471 ;;

5472 esac

5473 case "$deplibs " in

5474 *" -L$dir "*) ;;

5475 *)

5476 deplibs="$deplibs -L$dir"

5477 lib_search_path="$lib_search_path $dir"

5478 ;;

5479 esac

5480 case $host in

5481 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

5482 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`

5483 case :$dllsearchpath: in

5484 *":$dir:"*) ;;

5485 ::) dllsearchpath=$dir;;

5486 *) dllsearchpath="$dllsearchpath:$dir";;

5487 esac

5488 case :$dllsearchpath: in

5489 *":$testbindir:"*) ;;

5490 ::) dllsearchpath=$testbindir;;

5491 *) dllsearchpath="$dllsearchpath:$testbindir";;

5492 esac

5493 ;;

5494 esac

5495 continue

5496 ;;

5497

5498 -l*)

5499 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

5500 case $host in

5502 # These systems don't actually have a C or math library (as such)

5503 continue

5504 ;;

5505 *-*-os2*)

5506 # These systems don't actually have a C library (as such)

5507 test "X$arg" = "X-lc" && continue

5508 ;;

5509 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

5510 # Do not include libc due to us having libc/libc_r.

5511 test "X$arg" = "X-lc" && continue

5512 ;;

5513 *-*-rhapsody* | *-*-darwin1.[012])

5514 # Rhapsody C and math libraries are in the System framework

5515 deplibs="$deplibs System.ltframework"

5516 continue

5517 ;;

5518 *-*-sco3.2v5* | *-*-sco5v6*)

5519 # Causes problems with __ctype

5520 test "X$arg" = "X-lc" && continue

5521 ;;

5522 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

5523 # Compiler inserts libc in the correct place for threads to work

5524 test "X$arg" = "X-lc" && continue

5525 ;;

5526 esac

5527 elif test "X$arg" = "X-lc_r"; then

5528 case $host in

5529 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

5530 # Do not include libc_r directly, use -pthread flag.

5531 continue

5532 ;;

5533 esac

5534 fi

5535 deplibs="$deplibs $arg"

5536 continue

5537 ;;

5538

5539 -module)

5540 module=yes

5541 continue

5542 ;;

5543

5544 # Tru64 UNIX uses -model [arg] to determine the layout of C++

5545 # classes, name mangling, and exception handling.

5546 # Darwin uses the -arch flag to determine output architecture.

5547 -model|-arch|-isysroot)

5548 compiler_flags="$compiler_flags $arg"

5549 func_append compile_command " $arg"

5550 func_append finalize_command " $arg"

5551 prev=xcompiler

5552 continue

5553 ;;

5554

5556 compiler_flags="$compiler_flags $arg"

5557 func_append compile_command " $arg"

5558 func_append finalize_command " $arg"

5559 case "$new_inherited_linker_flags " in

5560 *" $arg "*) ;;

5561 * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;

5562 esac

5563 continue

5564 ;;

5565

5566 -multi_module)

5567 single_module="${wl}-multi_module"

5568 continue

5569 ;;

5570

5571 -no-fast-install)

5572 fast_install=no

5573 continue

5574 ;;

5575

5576 -no-install)

5577 case $host in

5579 # The PATH hackery in wrapper scripts is required on Windows

5580 # and Darwin in order for the loader to find any dlls it needs.

5581 func_warning "\`-no-install' is ignored for $host"

5582 func_warning "assuming \`-no-fast-install' instead"

5583 fast_install=no

5584 ;;

5585 *) no_install=yes ;;

5586 esac

5587 continue

5588 ;;

5589

5590 -no-undefined)

5591 allow_undefined=no

5592 continue

5593 ;;

5594

5595 -objectlist)

5596 prev=objectlist

5597 continue

5598 ;;

5599

5600 -o) prev=output ;;

5601

5602 -precious-files-regex)

5603 prev=precious_regex

5604 continue

5605 ;;

5606

5607 -release)

5608 prev=release

5609 continue

5610 ;;

5611

5612 -rpath)

5613 prev=rpath

5614 continue

5615 ;;

5616

5617 -R)

5618 prev=xrpath

5619 continue

5620 ;;

5621

5622 -R*)

5623 func_stripname '-R' '' "$arg"

5624 dir=$func_stripname_result

5625 # We need an absolute path.

5626 case $dir in

5627 [\\/]* | [A-Za-z]:[\\/]*) ;;

5628 *)

5629 func_fatal_error "only absolute run-paths are allowed"

5630 ;;

5631 esac

5632 case "$xrpath " in

5633 *" $dir "*) ;;

5634 *) xrpath="$xrpath $dir" ;;

5635 esac

5636 continue

5637 ;;

5638

5639 -shared)

5640 # The effects of -shared are defined in a previous loop.

5641 continue

5642 ;;

5643

5644 -shrext)

5645 prev=shrext

5646 continue

5647 ;;

5648

5649 -static | -static-libtool-libs)

5650 # The effects of -static are defined in a previous loop.

5651 # We used to do the same as -all-static on platforms that

5652 # didn't have a PIC flag, but the assumption that the effects

5653 # would be equivalent was wrong. It would break on at least

5654 # Digital Unix and AIX.

5655 continue

5656 ;;

5657

5658 -thread-safe)

5659 thread_safe=yes

5660 continue

5661 ;;

5662

5663 -version-info)

5664 prev=vinfo

5665 continue

5666 ;;

5667

5668 -version-number)

5669 prev=vinfo

5670 vinfo_number=yes

5671 continue

5672 ;;

5673

5674 -weak)

5675 prev=weak

5676 continue

5677 ;;

5678

5679 -Wc,*)

5680 func_stripname '-Wc,' '' "$arg"

5681 args=$func_stripname_result

5682 arg=

5683 save_ifs="$IFS"; IFS=','

5684 for flag in $args; do

5685 IFS="$save_ifs"

5686 func_quote_for_eval "$flag"

5687 arg="$arg $func_quote_for_eval_result"

5688 compiler_flags="$compiler_flags $func_quote_for_eval_result"

5689 done

5690 IFS="$save_ifs"

5691 func_stripname ' ' '' "$arg"

5692 arg=$func_stripname_result

5693 ;;

5694

5695 -Wl,*)

5696 func_stripname '-Wl,' '' "$arg"

5697 args=$func_stripname_result

5698 arg=

5699 save_ifs="$IFS"; IFS=','

5700 for flag in $args; do

5701 IFS="$save_ifs"

5702 func_quote_for_eval "$flag"

5703 arg="$arg $wl$func_quote_for_eval_result"

5704 compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"

5705 linker_flags="$linker_flags $func_quote_for_eval_result"

5706 done

5707 IFS="$save_ifs"

5708 func_stripname ' ' '' "$arg"

5709 arg=$func_stripname_result

5710 ;;

5711

5712 -Xcompiler)

5713 prev=xcompiler

5714 continue

5715 ;;

5716

5717 -Xlinker)

5718 prev=xlinker

5719 continue

5720 ;;

5721

5722 -XCClinker)

5723 prev=xcclinker

5724 continue

5725 ;;

5726

5727 # -msg_* for osf cc

5728 -msg_*)

5729 func_quote_for_eval "$arg"

5730 arg="$func_quote_for_eval_result"

5731 ;;

5732

5733 # -64, -mips[0-9] enable 64-bit mode on the SGI compiler

5734 # -r[0-9][0-9]* specifies the processor on the SGI compiler

5735 # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler

5736 # +DA*, +DD* enable 64-bit mode on the HP compiler

5737 # -q* pass through compiler args for the IBM compiler

5738 # -m*, -t[45]*, -txscale* pass through architecture-specific

5739 # compiler args for GCC

5740 # -F/path gives path to uninstalled frameworks, gcc on darwin

5741 # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC

5742 # @file GCC response files

5743 # -tp=* Portland pgcc target processor selection

5744 # -{shared,static}-libgcc, -static-{libgfortran|libstdc++}: force GCC

5745 # to link against specified runtime library.

5746 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \

5747 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*| \

5748 -shared-libgcc|-static-libgcc|-static-libgfortran|-static-libstdc++)

5749 func_quote_for_eval "$arg"

5750 arg="$func_quote_for_eval_result"

5751 func_append compile_command " $arg"

5752 func_append finalize_command " $arg"

5753 compiler_flags="$compiler_flags $arg"

5754 continue

5755 ;;

5756

5757 # Some other compiler flag.

5758 -* | +*)

5759 func_quote_for_eval "$arg"

5760 arg="$func_quote_for_eval_result"

5761 ;;

5762

5763 *.$objext)

5764 # A standard object.

5765 objs="$objs $arg"

5766 ;;

5767

5768 *.lo)

5769 # A libtool-controlled object.

5770

5771 # Check to see that this really is a libtool object.

5772 if func_lalib_unsafe_p "$arg"; then

5773 pic_object=

5774 non_pic_object=

5775

5776 # Read the .lo file

5777 func_source "$arg"

5778

5779 if test -z "$pic_object" ||

5780 test -z "$non_pic_object" ||

5781 test "$pic_object" = none &&

5782 test "$non_pic_object" = none; then

5783 func_fatal_error "cannot find name of object for \`$arg'"

5784 fi

5785

5786 # Extract subdirectory from the argument.

5787 func_dirname "$arg" "/" ""

5788 xdir="$func_dirname_result"

5789

5790 if test "$pic_object" != none; then

5791 # Prepend the subdirectory the object is found in.

5792 pic_object="$xdir$pic_object"

5793

5794 if test "$prev" = dlfiles; then

5795 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

5796 dlfiles="$dlfiles $pic_object"

5797 prev=

5798 continue

5799 else

5800 # If libtool objects are unsupported, then we need to preload.

5801 prev=dlprefiles

5802 fi

5803 fi

5804

5805 # CHECK ME: I think I busted this. -Ossama

5806 if test "$prev" = dlprefiles; then

5807 # Preload the old-style object.

5808 dlprefiles="$dlprefiles $pic_object"

5809 prev=

5810 fi

5811

5812 # A PIC object.

5813 func_append libobjs " $pic_object"

5814 arg="$pic_object"

5815 fi

5816

5817 # Non-PIC object.

5818 if test "$non_pic_object" != none; then

5819 # Prepend the subdirectory the object is found in.

5820 non_pic_object="$xdir$non_pic_object"

5821

5822 # A standard non-PIC object

5823 func_append non_pic_objects " $non_pic_object"

5824 if test -z "$pic_object" || test "$pic_object" = none ; then

5825 arg="$non_pic_object"

5826 fi

5827 else

5828 # If the PIC object exists, use it instead.

5829 # $xdir was prepended to $pic_object above.

5830 non_pic_object="$pic_object"

5831 func_append non_pic_objects " $non_pic_object"

5832 fi

5833 else

5834 # Only an error if not doing a dry-run.

5835 if $opt_dry_run; then

5836 # Extract subdirectory from the argument.

5837 func_dirname "$arg" "/" ""

5838 xdir="$func_dirname_result"

5839

5840 func_lo2o "$arg"

5841 pic_object=$xdir$objdir/$func_lo2o_result

5842 non_pic_object=$xdir$func_lo2o_result

5843 func_append libobjs " $pic_object"

5844 func_append non_pic_objects " $non_pic_object"

5845 else

5846 func_fatal_error "\`$arg' is not a valid libtool object"

5847 fi

5848 fi

5849 ;;

5850

5851 *.$libext)

5852 # An archive.

5853 deplibs="$deplibs $arg"

5854 old_deplibs="$old_deplibs $arg"

5855 continue

5856 ;;

5857

5858 *.la)

5859 # A libtool-controlled library.

5860

5861 if test "$prev" = dlfiles; then

5862 # This library was specified with -dlopen.

5863 dlfiles="$dlfiles $arg"

5864 prev=

5865 elif test "$prev" = dlprefiles; then

5866 # The library was specified with -dlpreopen.

5867 dlprefiles="$dlprefiles $arg"

5868 prev=

5869 else

5870 deplibs="$deplibs $arg"

5871 fi

5872 continue

5873 ;;

5874

5875 # Some other compiler argument.

5876 *)

5877 # Unknown arguments in both finalize_command and compile_command need

5878 # to be aesthetically quoted because they are evaled later.

5879 func_quote_for_eval "$arg"

5880 arg="$func_quote_for_eval_result"

5881 ;;

5882 esac # arg

5883

5884 # Now actually substitute the argument into the commands.

5885 if test -n "$arg"; then

5886 func_append compile_command " $arg"

5887 func_append finalize_command " $arg"

5888 fi

5889 done # argument parsing loop

5890

5891 test -n "$prev" && \

5892 func_fatal_help "the \`$prevarg' option requires an argument"

5893

5894 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

5895 eval arg=\"$export_dynamic_flag_spec\"

5896 func_append compile_command " $arg"

5897 func_append finalize_command " $arg"

5898 fi

5899

5900 oldlibs=

5901 # calculate the name of the file, without its directory

5902 func_basename "$output"

5903 outputname="$func_basename_result"

5904 libobjs_save="$libobjs"

5905

5906 if test -n "$shlibpath_var"; then

5907 # get the directories listed in $shlibpath_var

5908 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`

5909 else

5910 shlib_search_path=

5911 fi

5912 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

5913 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

5914

5915 func_dirname "$output" "/" ""

5916 output_objdir="$func_dirname_result$objdir"

5917 # Create the object directory.

5918 func_mkdir_p "$output_objdir"

5919

5920 # Determine the type of output

5921 case $output in

5922 "")

5923 func_fatal_help "you must specify an output file"

5924 ;;

5925 *.$libext) linkmode=oldlib ;;

5926 *.lo | *.$objext) linkmode=obj ;;

5927 *.la) linkmode=lib ;;

5928 *) linkmode=prog ;; # Anything else should be a program.

5929 esac

5930

5931 specialdeplibs=

5932

5933 libs=

5934 # Find all interdependent deplibs by searching for libraries

5935 # that are linked more than once (e.g. -la -lb -la)

5936 for deplib in $deplibs; do

5937 if $opt_duplicate_deps ; then

5938 case "$libs " in

5939 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

5940 esac

5941 fi

5942 libs="$libs $deplib"

5943 done

5944

5945 if test "$linkmode" = lib; then

5946 libs="$predeps $libs $compiler_lib_search_path $postdeps"

5947

5948 # Compute libraries that are listed more than once in $predeps

5949 # $postdeps and mark them as special (i.e., whose duplicates are

5950 # not to be eliminated).

5951 pre_post_deps=

5952 if $opt_duplicate_compiler_generated_deps; then

5953 for pre_post_dep in $predeps $postdeps; do

5954 case "$pre_post_deps " in

5955 *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;

5956 esac

5957 pre_post_deps="$pre_post_deps $pre_post_dep"

5958 done

5959 fi

5960 pre_post_deps=

5961 fi

5962

5963 deplibs=

5964 newdependency_libs=

5965 newlib_search_path=

5966 need_relink=no # whether we're linking any uninstalled libtool libraries

5967 notinst_deplibs= # not-installed libtool libraries

5968 notinst_path= # paths that contain not-installed libtool libraries

5969

5970 case $linkmode in

5971 lib)

5972 passes="conv dlpreopen link"

5973 for file in $dlfiles $dlprefiles; do

5974 case $file in

5975 *.la) ;;

5976 *)

5977 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"

5978 ;;

5979 esac

5980 done

5981 ;;

5982 prog)

5983 compile_deplibs=

5984 finalize_deplibs=

5985 alldeplibs=no

5986 newdlfiles=

5987 newdlprefiles=

5988 passes="conv scan dlopen dlpreopen link"

5989 ;;

5990 *) passes="conv"

5991 ;;

5992 esac

5993

5994 for pass in $passes; do

5995 # The preopen pass in lib mode reverses $deplibs; put it back here

5996 # so that -L comes before libs that need it for instance...

5997 if test "$linkmode,$pass" = "lib,link"; then

5998 ## FIXME: Find the place where the list is rebuilt in the wrong

5999 ## order, and fix it there properly

6000 tmp_deplibs=

6001 for deplib in $deplibs; do

6002 tmp_deplibs="$deplib $tmp_deplibs"

6003 done

6004 deplibs="$tmp_deplibs"

6005 fi

6006

6007 if test "$linkmode,$pass" = "lib,link" ||

6008 test "$linkmode,$pass" = "prog,scan"; then

6009 libs="$deplibs"

6010 deplibs=

6011 fi

6012 if test "$linkmode" = prog; then

6013 case $pass in

6014 dlopen) libs="$dlfiles" ;;

6015 dlpreopen) libs="$dlprefiles" ;;

6016 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

6017 esac

6018 fi

6019 if test "$linkmode,$pass" = "lib,dlpreopen"; then

6020 # Collect and forward deplibs of preopened libtool libs

6021 for lib in $dlprefiles; do

6022 # Ignore non-libtool-libs

6023 dependency_libs=

6024 case $lib in

6025 *.la) func_source "$lib" ;;

6026 esac

6027

6028 # Collect preopened libtool deplibs, except any this library

6029 # has declared as weak libs

6030 for deplib in $dependency_libs; do

6031 func_basename "$deplib"

6032 deplib_base=$func_basename_result

6033 case " $weak_libs " in

6034 *" $deplib_base "*) ;;

6035 *) deplibs="$deplibs $deplib" ;;

6036 esac

6037 done

6038 done

6039 libs="$dlprefiles"

6040 fi

6041 if test "$pass" = dlopen; then

6042 # Collect dlpreopened libraries

6043 save_deplibs="$deplibs"

6044 deplibs=

6045 fi

6046

6047 for deplib in $libs; do

6048 lib=

6049 found=no

6050 case $deplib in

6052 if test "$linkmode,$pass" = "prog,link"; then

6053 compile_deplibs="$deplib $compile_deplibs"

6054 finalize_deplibs="$deplib $finalize_deplibs"

6055 else

6056 compiler_flags="$compiler_flags $deplib"

6057 if test "$linkmode" = lib ; then

6058 case "$new_inherited_linker_flags " in

6059 *" $deplib "*) ;;

6060 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

6061 esac

6062 fi

6063 fi

6064 continue

6065 ;;

6066 -l*)

6067 if test "$linkmode" != lib && test "$linkmode" != prog; then

6068 func_warning "\`-l' is ignored for archives/objects"

6069 continue

6070 fi

6071 func_stripname '-l' '' "$deplib"

6072 name=$func_stripname_result

6073 if test "$linkmode" = lib; then

6074 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"

6075 else

6076 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"

6077 fi

6078 for searchdir in $searchdirs; do

6079 for search_ext in .la $std_shrext .so .a; do

6080 # Search the libtool library

6081 lib="$searchdir/lib${name}${search_ext}"

6082 if test -f "$lib"; then

6083 if test "$search_ext" = ".la"; then

6084 found=yes

6085 else

6086 found=no

6087 fi

6088 break 2

6089 fi

6090 done

6091 done

6092 if test "$found" != yes; then

6093 # deplib doesn't seem to be a libtool library

6094 if test "$linkmode,$pass" = "prog,link"; then

6095 compile_deplibs="$deplib $compile_deplibs"

6096 finalize_deplibs="$deplib $finalize_deplibs"

6097 else

6098 deplibs="$deplib $deplibs"

6099 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6100 fi

6101 continue

6102 else # deplib is a libtool library

6103 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

6104 # We need to do some special things here, and not later.

6105 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

6106 case " $predeps $postdeps " in

6107 *" $deplib "*)

6108 if func_lalib_p "$lib"; then

6109 library_names=

6110 old_library=

6111 func_source "$lib"

6112 for l in $old_library $library_names; do

6113 ll="$l"

6114 done

6115 if test "X$ll" = "X$old_library" ; then # only static version available

6116 found=no

6117 func_dirname "$lib" "" "."

6118 ladir="$func_dirname_result"

6119 lib=$ladir/$old_library

6120 if test "$linkmode,$pass" = "prog,link"; then

6121 compile_deplibs="$deplib $compile_deplibs"

6122 finalize_deplibs="$deplib $finalize_deplibs"

6123 else

6124 deplibs="$deplib $deplibs"

6125 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6126 fi

6127 continue

6128 fi

6129 fi

6130 ;;

6131 *) ;;

6132 esac

6133 fi

6134 fi

6135 ;; # -l

6136 *.ltframework)

6137 if test "$linkmode,$pass" = "prog,link"; then

6138 compile_deplibs="$deplib $compile_deplibs"

6139 finalize_deplibs="$deplib $finalize_deplibs"

6140 else

6141 deplibs="$deplib $deplibs"

6142 if test "$linkmode" = lib ; then

6143 case "$new_inherited_linker_flags " in

6144 *" $deplib "*) ;;

6145 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

6146 esac

6147 fi

6148 fi

6149 continue

6150 ;;

6151 -L*)

6152 case $linkmode in

6153 lib)

6154 deplibs="$deplib $deplibs"

6155 test "$pass" = conv && continue

6156 newdependency_libs="$deplib $newdependency_libs"

6157 func_stripname '-L' '' "$deplib"

6158 newlib_search_path="$newlib_search_path $func_stripname_result"

6159 ;;

6160 prog)

6161 if test "$pass" = conv; then

6162 deplibs="$deplib $deplibs"

6163 continue

6164 fi

6165 if test "$pass" = scan; then

6166 deplibs="$deplib $deplibs"

6167 else

6168 compile_deplibs="$deplib $compile_deplibs"

6169 finalize_deplibs="$deplib $finalize_deplibs"

6170 fi

6171 func_stripname '-L' '' "$deplib"

6172 newlib_search_path="$newlib_search_path $func_stripname_result"

6173 ;;

6174 *)

6175 func_warning "\`-L' is ignored for archives/objects"

6176 ;;

6177 esac # linkmode

6178 continue

6179 ;; # -L

6180 -R*)

6181 if test "$pass" = link; then

6182 func_stripname '-R' '' "$deplib"

6183 dir=$func_stripname_result

6184 # Make sure the xrpath contains only unique directories.

6185 case "$xrpath " in

6186 *" $dir "*) ;;

6187 *) xrpath="$xrpath $dir" ;;

6188 esac

6189 fi

6190 deplibs="$deplib $deplibs"

6191 continue

6192 ;;

6193 *.la) lib="$deplib" ;;

6194 *.$libext)

6195 if test "$pass" = conv; then

6196 deplibs="$deplib $deplibs"

6197 continue

6198 fi

6199 case $linkmode in

6200 lib)

6201 # Linking convenience modules into shared libraries is allowed,

6202 # but linking other static libraries is non-portable.

6203 case " $dlpreconveniencelibs " in

6204 *" $deplib "*) ;;

6205 *)

6206 valid_a_lib=no

6207 case $deplibs_check_method in

6208 match_pattern*)

6209 set dummy $deplibs_check_method; shift

6210 match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

6211 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \

6212 | $EGREP "$match_pattern_regex" > /dev/null; then

6213 valid_a_lib=yes

6214 fi

6215 ;;

6216 pass_all)

6217 valid_a_lib=yes

6218 ;;

6219 esac

6220 if test "$valid_a_lib" != yes; then

6221 echo

6222 $ECHO "*** Warning: Trying to link with static lib archive $deplib."

6223 echo "*** I have the capability to make that library automatically link in when"

6224 echo "*** you link to this library. But I can only do this if you have a"

6225 echo "*** shared version of the library, which you do not appear to have"

6226 echo "*** because the file extensions .$libext of this argument makes me believe"

6227 echo "*** that it is just a static archive that I should not use here."

6228 else

6229 echo

6230 $ECHO "*** Warning: Linking the shared library $output against the"

6231 $ECHO "*** static library $deplib is not portable!"

6232 deplibs="$deplib $deplibs"

6233 fi

6234 ;;

6235 esac

6236 continue

6237 ;;

6238 prog)

6239 if test "$pass" != link; then

6240 deplibs="$deplib $deplibs"

6241 else

6242 compile_deplibs="$deplib $compile_deplibs"

6243 finalize_deplibs="$deplib $finalize_deplibs"

6244 fi

6245 continue

6246 ;;

6247 esac # linkmode

6248 ;; # *.$libext

6249 *.lo | *.$objext)

6250 if test "$pass" = conv; then

6251 deplibs="$deplib $deplibs"

6252 elif test "$linkmode" = prog; then

6253 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

6254 # If there is no dlopen support or we're linking statically,

6255 # we need to preload.

6256 newdlprefiles="$newdlprefiles $deplib"

6257 compile_deplibs="$deplib $compile_deplibs"

6258 finalize_deplibs="$deplib $finalize_deplibs"

6259 else

6260 newdlfiles="$newdlfiles $deplib"

6261 fi

6262 fi

6263 continue

6264 ;;

6265 %DEPLIBS%)

6266 alldeplibs=yes

6267 continue

6268 ;;

6269 esac # case $deplib

6270

6271 if test "$found" = yes || test -f "$lib"; then :

6272 else

6273 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

6274 fi

6275

6276 # Check to see that this really is a libtool archive.

6277 func_lalib_unsafe_p "$lib" \

6278 || func_fatal_error "\`$lib' is not a valid libtool archive"

6279

6280 func_dirname "$lib" "" "."

6281 ladir="$func_dirname_result"

6282

6283 dlname=

6284 dlopen=

6285 dlpreopen=

6286 libdir=

6287 library_names=

6288 old_library=

6289 inherited_linker_flags=

6290 # If the library was installed with an old release of libtool,

6291 # it will not redefine variables installed, or shouldnotlink

6292 installed=yes

6293 shouldnotlink=no

6294 avoidtemprpath=

6295

6296

6297 # Read the .la file

6298 func_source "$lib"

6299

6300 # Convert "-framework foo" to "foo.ltframework"

6301 if test -n "$inherited_linker_flags"; then

6302 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $[^ $]*$/\1.ltframework/g'`

6303 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

6304 case " $new_inherited_linker_flags " in

6305 *" $tmp_inherited_linker_flag "*) ;;

6306 *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;

6307 esac

6308 done

6309 fi

6310 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6311 if test "$linkmode,$pass" = "lib,link" ||

6312 test "$linkmode,$pass" = "prog,scan" ||

6313 { test "$linkmode" != prog && test "$linkmode" != lib; }; then

6314 test -n "$dlopen" && dlfiles="$dlfiles $dlopen"

6315 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"

6316 fi

6317

6318 if test "$pass" = conv; then

6319 # Only check for convenience libraries

6320 deplibs="$lib $deplibs"

6321 if test -z "$libdir"; then

6322 if test -z "$old_library"; then

6323 func_fatal_error "cannot find name of link library for \`$lib'"

6324 fi

6325 # It is a libtool convenience library, so add in its objects.

6326 convenience="$convenience $ladir/$objdir/$old_library"

6327 old_convenience="$old_convenience $ladir/$objdir/$old_library"

6328 elif test "$linkmode" != prog && test "$linkmode" != lib; then

6329 func_fatal_error "\`$lib' is not a convenience library"

6330 fi

6331 tmp_libs=

6332 for deplib in $dependency_libs; do

6333 deplibs="$deplib $deplibs"

6334 if $opt_duplicate_deps ; then

6335 case "$tmp_libs " in

6336 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

6337 esac

6338 fi

6339 tmp_libs="$tmp_libs $deplib"

6340 done

6341 continue

6342 fi # $pass = conv

6343

6344

6345 # Get the name of the library we link against.

6346 linklib=

6347 for l in $old_library $library_names; do

6348 linklib="$l"

6349 done

6350 if test -z "$linklib"; then

6351 func_fatal_error "cannot find name of link library for \`$lib'"

6352 fi

6353

6354 # This library was specified with -dlopen.

6355 if test "$pass" = dlopen; then

6356 if test -z "$libdir"; then

6357 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

6358 fi

6359 if test -z "$dlname" ||

6360 test "$dlopen_support" != yes ||

6361 test "$build_libtool_libs" = no; then

6362 # If there is no dlname, no dlopen support or we're linking

6363 # statically, we need to preload. We also need to preload any

6364 # dependent libraries so libltdl's deplib preloader doesn't

6365 # bomb out in the load deplibs phase.

6366 dlprefiles="$dlprefiles $lib $dependency_libs"

6367 else

6368 newdlfiles="$newdlfiles $lib"

6369 fi

6370 continue

6371 fi # $pass = dlopen

6372

6373 # We need an absolute path.

6374 case $ladir in

6375 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

6376 *)

6377 abs_ladir=`cd "$ladir" && pwd`

6378 if test -z "$abs_ladir"; then

6379 func_warning "cannot determine absolute directory name of \`$ladir'"

6380 func_warning "passing it literally to the linker, although it might fail"

6381 abs_ladir="$ladir"

6382 fi

6383 ;;

6384 esac

6385 func_basename "$lib"

6386 laname="$func_basename_result"

6387

6388 # Find the relevant object directory and library name.

6389 if test "X$installed" = Xyes; then

6390 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6391 func_warning "library \`$lib' was moved."

6392 dir="$ladir"

6393 absdir="$abs_ladir"

6394 libdir="$abs_ladir"

6395 else

6396 dir="$libdir"

6397 absdir="$libdir"

6398 fi

6399 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

6400 else

6401 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6402 dir="$ladir"

6403 absdir="$abs_ladir"

6404 # Remove this search path later

6405 notinst_path="$notinst_path $abs_ladir"

6406 else

6407 dir="$ladir/$objdir"

6408 absdir="$abs_ladir/$objdir"

6409 # Remove this search path later

6410 notinst_path="$notinst_path $abs_ladir"

6411 fi

6412 fi # $installed = yes

6413 func_stripname 'lib' '.la' "$laname"

6414 name=$func_stripname_result

6415

6416 # This library was specified with -dlpreopen.

6417 if test "$pass" = dlpreopen; then

6418 if test -z "$libdir" && test "$linkmode" = prog; then

6419 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

6420 fi

6421 case "$host" in

6422 # special handling for platforms with PE-DLLs.

6423 *cygwin* | *mingw* | *cegcc* )

6424 # Linker will automatically link against shared library if both

6425 # static and shared are present. Therefore, ensure we extract

6426 # symbols from the import library if a shared library is present

6427 # (otherwise, the dlopen module name will be incorrect). We do

6428 # this by putting the import library name into $newdlprefiles.

6429 # We recover the dlopen module name by 'saving' the la file

6430 # name in a special purpose variable, and (later) extracting the

6431 # dlname from the la file.

6432 if test -n "$dlname"; then

6433 func_tr_sh "$dir/$linklib"

6434 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"

6435 newdlprefiles="$newdlprefiles $dir/$linklib"

6436 else

6437 newdlprefiles="$newdlprefiles $dir/$old_library"

6438 # Keep a list of preopened convenience libraries to check

6439 # that they are being used correctly in the link pass.

6440 test -z "$libdir" && \

6441 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"

6442 fi

6443 ;;

6444 * )

6445 # Prefer using a static library (so that no silly _DYNAMIC symbols

6446 # are required to link).

6447 if test -n "$old_library"; then

6448 newdlprefiles="$newdlprefiles $dir/$old_library"

6449 # Keep a list of preopened convenience libraries to check

6450 # that they are being used correctly in the link pass.

6451 test -z "$libdir" && \

6452 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"

6453 # Otherwise, use the dlname, so that lt_dlopen finds it.

6454 elif test -n "$dlname"; then

6455 newdlprefiles="$newdlprefiles $dir/$dlname"

6456 else

6457 newdlprefiles="$newdlprefiles $dir/$linklib"

6458 fi

6459 ;;

6460 esac

6461 fi # $pass = dlpreopen

6462

6463 if test -z "$libdir"; then

6464 # Link the convenience library

6465 if test "$linkmode" = lib; then

6466 deplibs="$dir/$old_library $deplibs"

6467 elif test "$linkmode,$pass" = "prog,link"; then

6468 compile_deplibs="$dir/$old_library $compile_deplibs"

6469 finalize_deplibs="$dir/$old_library $finalize_deplibs"

6470 else

6471 deplibs="$lib $deplibs" # used for prog,scan pass

6472 fi

6473 continue

6474 fi

6475

6476

6477 if test "$linkmode" = prog && test "$pass" != link; then

6478 newlib_search_path="$newlib_search_path $ladir"

6479 deplibs="$lib $deplibs"

6480

6481 linkalldeplibs=no

6482 if test "$link_all_deplibs" != no || test -z "$library_names" ||

6483 test "$build_libtool_libs" = no; then

6484 linkalldeplibs=yes

6485 fi

6486

6487 tmp_libs=

6488 for deplib in $dependency_libs; do

6489 case $deplib in

6490 -L*) func_stripname '-L' '' "$deplib"

6491 newlib_search_path="$newlib_search_path $func_stripname_result"

6492 ;;

6493 esac

6494 # Need to link against all dependency_libs?

6495 if test "$linkalldeplibs" = yes; then

6496 deplibs="$deplib $deplibs"

6497 else

6498 # Need to hardcode shared library paths

6499 # or/and link against static libraries

6500 newdependency_libs="$deplib $newdependency_libs"

6501 fi

6502 if $opt_duplicate_deps ; then

6503 case "$tmp_libs " in

6504 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

6505 esac

6506 fi

6507 tmp_libs="$tmp_libs $deplib"

6508 done # for deplib

6509 continue

6510 fi # $linkmode = prog...

6511

6512 if test "$linkmode,$pass" = "prog,link"; then

6513 if test -n "$library_names" &&

6514 { { test "$prefer_static_libs" = no ||

6515 test "$prefer_static_libs,$installed" = "built,yes"; } ||

6516 test -z "$old_library"; }; then

6517 # We need to hardcode the library path

6518 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

6519 # Make sure the rpath contains only unique directories.

6520 case "$temp_rpath:" in

6521 *"$absdir:"*) ;;

6522 *) temp_rpath="$temp_rpath$absdir:" ;;

6523 esac

6524 fi

6525

6526 # Hardcode the library path.

6527 # Skip directories that are in the system default run-time

6528 # search path.

6529 case " $sys_lib_dlsearch_path " in

6530 *" $absdir "*) ;;

6531 *)

6532 case "$compile_rpath " in

6533 *" $absdir "*) ;;

6534 *) compile_rpath="$compile_rpath $absdir"

6535 esac

6536 ;;

6537 esac

6538 case " $sys_lib_dlsearch_path " in

6539 *" $libdir "*) ;;

6540 *)

6541 case "$finalize_rpath " in

6542 *" $libdir "*) ;;

6543 *) finalize_rpath="$finalize_rpath $libdir"

6544 esac

6545 ;;

6546 esac

6547 fi # $linkmode,$pass = prog,link...

6548

6549 if test "$alldeplibs" = yes &&

6550 { test "$deplibs_check_method" = pass_all ||

6551 { test "$build_libtool_libs" = yes &&

6552 test -n "$library_names"; }; }; then

6553 # We only need to search for static libraries

6554 continue

6555 fi

6556 fi

6557

6558 link_static=no # Whether the deplib will be linked statically

6559 use_static_libs=$prefer_static_libs

6560 if test "$use_static_libs" = built && test "$installed" = yes; then

6561 use_static_libs=no

6562 fi

6563 if test -n "$library_names" &&

6564 { test "$use_static_libs" = no || test -z "$old_library"; }; then

6565 case $host in

6566 *cygwin* | *mingw* | *cegcc*)

6567 # No point in relinking DLLs because paths are not encoded

6568 notinst_deplibs="$notinst_deplibs $lib"

6569 need_relink=no

6570 ;;

6571 *)

6572 if test "$installed" = no; then

6573 notinst_deplibs="$notinst_deplibs $lib"

6574 need_relink=yes

6575 fi

6576 ;;

6577 esac

6578 # This is a shared library

6579

6580 # Warn about portability, can't link against -module's on some

6581 # systems (darwin). Don't bleat about dlopened modules though!

6582 dlopenmodule=""

6583 for dlpremoduletest in $dlprefiles; do

6584 if test "X$dlpremoduletest" = "X$lib"; then

6585 dlopenmodule="$dlpremoduletest"

6586 break

6587 fi

6588 done

6589 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

6590 echo

6591 if test "$linkmode" = prog; then

6592 $ECHO "*** Warning: Linking the executable $output against the loadable module"

6593 else

6594 $ECHO "*** Warning: Linking the shared library $output against the loadable module"

6595 fi

6596 $ECHO "*** $linklib is not portable!"

6597 fi

6598 if test "$linkmode" = lib &&

6599 test "$hardcode_into_libs" = yes; then

6600 # Hardcode the library path.

6601 # Skip directories that are in the system default run-time

6602 # search path.

6603 case " $sys_lib_dlsearch_path " in

6604 *" $absdir "*) ;;

6605 *)

6606 case "$compile_rpath " in

6607 *" $absdir "*) ;;

6608 *) compile_rpath="$compile_rpath $absdir"

6609 esac

6610 ;;

6611 esac

6612 case " $sys_lib_dlsearch_path " in

6613 *" $libdir "*) ;;

6614 *)

6615 case "$finalize_rpath " in

6616 *" $libdir "*) ;;

6617 *) finalize_rpath="$finalize_rpath $libdir"

6618 esac

6619 ;;

6620 esac

6621 fi

6622

6623 if test -n "$old_archive_from_expsyms_cmds"; then

6624 # figure out the soname

6625 set dummy $library_names

6626 shift

6627 realname="$1"

6628 shift

6629 libname=`eval "\\$ECHO \"$libname_spec\""`

6630 # use dlname if we got it. it's perfectly good, no?

6631 if test -n "$dlname"; then

6632 soname="$dlname"

6633 elif test -n "$soname_spec"; then

6634 # bleh windows

6635 case $host in

6636 *cygwin* | mingw* | *cegcc*)

6637 func_arith $current - $age

6638 major=$func_arith_result

6639 versuffix="-$major"

6640 ;;

6641 esac

6642 eval soname=\"$soname_spec\"

6643 else

6644 soname="$realname"

6645 fi

6646

6647 # Make a new name for the extract_expsyms_cmds to use

6648 soroot="$soname"

6649 func_basename "$soroot"

6650 soname="$func_basename_result"

6651 func_stripname 'lib' '.dll' "$soname"

6652 newlib=libimp-$func_stripname_result.a

6653

6654 # If the library has no export list, then create one now

6655 if test -f "$output_objdir/$soname-def"; then :

6656 else

6657 func_verbose "extracting exported symbol list from \`$soname'"

6658 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

6659 fi

6660

6661 # Create $newlib

6662 if test -f "$output_objdir/$newlib"; then :; else

6663 func_verbose "generating import library for \`$soname'"

6664 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

6665 fi

6666 # make sure the library variables are pointing to the new library

6667 dir=$output_objdir

6668 linklib=$newlib

6669 fi # test -n "$old_archive_from_expsyms_cmds"

6670

6671 if test "$linkmode" = prog || test "$mode" != relink; then

6672 add_shlibpath=

6673 add_dir=

6674 add=

6675 lib_linked=yes

6676 case $hardcode_action in

6677 immediate | unsupported)

6678 if test "$hardcode_direct" = no; then

6679 add="$dir/$linklib"

6680 case $host in

6681 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

6682 *-*-sysv4*uw2*) add_dir="-L$dir" ;;

6683 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

6684 *-*-unixware7*) add_dir="-L$dir" ;;

6685 *-*-darwin* )

6686 # if the lib is a (non-dlopened) module then we can not

6687 # link against it, someone is ignoring the earlier warnings

6688 if /usr/bin/file -L $add 2> /dev/null |

6689 $GREP ": [^:]* bundle" >/dev/null ; then

6690 if test "X$dlopenmodule" != "X$lib"; then

6691 $ECHO "*** Warning: lib $linklib is a module, not a shared library"

6692 if test -z "$old_library" ; then

6693 echo

6694 echo "*** And there doesn't seem to be a static archive available"

6695 echo "*** The link will probably fail, sorry"

6696 else

6697 add="$dir/$old_library"

6698 fi

6699 elif test -n "$old_library"; then

6700 add="$dir/$old_library"

6701 fi

6702 fi

6703 esac

6704 elif test "$hardcode_minus_L" = no; then

6705 case $host in

6706 *-*-sunos*) add_shlibpath="$dir" ;;

6707 esac

6708 add_dir="-L$dir"

6709 add="-l$name"

6710 elif test "$hardcode_shlibpath_var" = no; then

6711 add_shlibpath="$dir"

6712 add="-l$name"

6713 else

6714 lib_linked=no

6715 fi

6716 ;;

6717 relink)

6718 if test "$hardcode_direct" = yes &&

6719 test "$hardcode_direct_absolute" = no; then

6720 add="$dir/$linklib"

6721 elif test "$hardcode_minus_L" = yes; then

6722 add_dir="-L$dir"

6723 # Try looking first in the location we're being installed to.

6724 if test -n "$inst_prefix_dir"; then

6725 case $libdir in

6726 [\\/]*)

6727 add_dir="$add_dir -L$inst_prefix_dir$libdir"

6728 ;;

6729 esac

6730 fi

6731 add="-l$name"

6732 elif test "$hardcode_shlibpath_var" = yes; then

6733 add_shlibpath="$dir"

6734 add="-l$name"

6735 else

6736 lib_linked=no

6737 fi

6738 ;;

6739 *) lib_linked=no ;;

6740 esac

6741

6742 if test "$lib_linked" != yes; then

6743 func_fatal_configuration "unsupported hardcode properties"

6744 fi

6745

6746 if test -n "$add_shlibpath"; then

6747 case :$compile_shlibpath: in

6748 *":$add_shlibpath:"*) ;;

6749 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;

6750 esac

6751 fi

6752 if test "$linkmode" = prog; then

6753 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

6754 test -n "$add" && compile_deplibs="$add $compile_deplibs"

6755 else

6756 test -n "$add_dir" && deplibs="$add_dir $deplibs"

6757 test -n "$add" && deplibs="$add $deplibs"

6758 if test "$hardcode_direct" != yes &&

6759 test "$hardcode_minus_L" != yes &&

6760 test "$hardcode_shlibpath_var" = yes; then

6761 case :$finalize_shlibpath: in

6762 *":$libdir:"*) ;;

6763 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

6764 esac

6765 fi

6766 fi

6767 fi

6768

6769 if test "$linkmode" = prog || test "$mode" = relink; then

6770 add_shlibpath=

6771 add_dir=

6772 add=

6773 # Finalize command for both is simple: just hardcode it.

6774 if test "$hardcode_direct" = yes &&

6775 test "$hardcode_direct_absolute" = no; then

6776 add="$libdir/$linklib"

6777 elif test "$hardcode_minus_L" = yes; then

6778 add_dir="-L$libdir"

6779 add="-l$name"

6780 elif test "$hardcode_shlibpath_var" = yes; then

6781 case :$finalize_shlibpath: in

6782 *":$libdir:"*) ;;

6783 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

6784 esac

6785 add="-l$name"

6786 elif test "$hardcode_automatic" = yes; then

6787 if test -n "$inst_prefix_dir" &&

6788 test -f "$inst_prefix_dir$libdir/$linklib" ; then

6789 add="$inst_prefix_dir$libdir/$linklib"

6790 else

6791 add="$libdir/$linklib"

6792 fi

6793 else

6794 # We cannot seem to hardcode it, guess we'll fake it.

6795 add_dir="-L$libdir"

6796 # Try looking first in the location we're being installed to.

6797 if test -n "$inst_prefix_dir"; then

6798 case $libdir in

6799 [\\/]*)

6800 add_dir="$add_dir -L$inst_prefix_dir$libdir"

6801 ;;

6802 esac

6803 fi

6804 add="-l$name"

6805 fi

6806

6807 if test "$linkmode" = prog; then

6808 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

6809 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

6810 else

6811 test -n "$add_dir" && deplibs="$add_dir $deplibs"

6812 test -n "$add" && deplibs="$add $deplibs"

6813 fi

6814 fi

6815 elif test "$linkmode" = prog; then

6816 # Here we assume that one of hardcode_direct or hardcode_minus_L

6817 # is not unsupported. This is valid on all known static and

6818 # shared platforms.

6819 if test "$hardcode_direct" != unsupported; then

6820 test -n "$old_library" && linklib="$old_library"

6821 compile_deplibs="$dir/$linklib $compile_deplibs"

6822 finalize_deplibs="$dir/$linklib $finalize_deplibs"

6823 else

6824 compile_deplibs="-l$name -L$dir $compile_deplibs"

6825 finalize_deplibs="-l$name -L$dir $finalize_deplibs"

6826 fi

6827 elif test "$build_libtool_libs" = yes; then

6828 # Not a shared library

6829 if test "$deplibs_check_method" != pass_all; then

6830 # We're trying link a shared library against a static one

6831 # but the system doesn't support it.

6832

6833 # Just print a warning and add the library to dependency_libs so

6834 # that the program can be linked against the static library.

6835 echo

6836 $ECHO "*** Warning: This system can not link to static lib archive $lib."

6837 echo "*** I have the capability to make that library automatically link in when"

6838 echo "*** you link to this library. But I can only do this if you have a"

6839 echo "*** shared version of the library, which you do not appear to have."

6840 if test "$module" = yes; then

6841 echo "*** But as you try to build a module library, libtool will still create "

6842 echo "*** a static module, that should work as long as the dlopening application"

6843 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

6844 if test -z "$global_symbol_pipe"; then

6845 echo

6846 echo "*** However, this would only work if libtool was able to extract symbol"

6847 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

6848 echo "*** not find such a program. So, this module is probably useless."

6849 echo "*** \`nm' from GNU binutils and a full rebuild may help."

6850 fi

6851 if test "$build_old_libs" = no; then

6852 build_libtool_libs=module

6853 build_old_libs=yes

6854 else

6855 build_libtool_libs=no

6856 fi

6857 fi

6858 else

6859 deplibs="$dir/$old_library $deplibs"

6860 link_static=yes

6861 fi

6862 fi # link shared/static library?

6863

6864 if test "$linkmode" = lib; then

6865 if test -n "$dependency_libs" &&

6866 { test "$hardcode_into_libs" != yes ||

6867 test "$build_old_libs" = yes ||

6868 test "$link_static" = yes; }; then

6869 # Extract -R from dependency_libs

6870 temp_deplibs=

6871 for libdir in $dependency_libs; do

6872 case $libdir in

6873 -R*) func_stripname '-R' '' "$libdir"

6874 temp_xrpath=$func_stripname_result

6875 case " $xrpath " in

6876 *" $temp_xrpath "*) ;;

6877 *) xrpath="$xrpath $temp_xrpath";;

6878 esac;;

6879 *) temp_deplibs="$temp_deplibs $libdir";;

6880 esac

6881 done

6882 dependency_libs="$temp_deplibs"

6883 fi

6884

6885 newlib_search_path="$newlib_search_path $absdir"

6886 # Link against this library

6887 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

6888 # ... and its dependency_libs

6889 tmp_libs=

6890 for deplib in $dependency_libs; do

6891 newdependency_libs="$deplib $newdependency_libs"

6892 if $opt_duplicate_deps ; then

6893 case "$tmp_libs " in

6894 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

6895 esac

6896 fi

6897 tmp_libs="$tmp_libs $deplib"

6898 done

6899

6900 if test "$link_all_deplibs" != no; then

6901 # Add the search paths of all dependency libraries

6902 for deplib in $dependency_libs; do

6903 path=

6904 case $deplib in

6905 -L*) path="$deplib" ;;

6906 *.la)

6907 func_dirname "$deplib" "" "."

6908 dir="$func_dirname_result"

6909 # We need an absolute path.

6910 case $dir in

6911 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

6912 *)

6913 absdir=`cd "$dir" && pwd`

6914 if test -z "$absdir"; then

6915 func_warning "cannot determine absolute directory name of \`$dir'"

6916 absdir="$dir"

6917 fi

6918 ;;

6919 esac

6920 if $GREP "^installed=no" $deplib > /dev/null; then

6921 case $host in

6922 *-*-darwin*)

6923 depdepl=

6924 eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`

6925 if test -n "$deplibrary_names" ; then

6926 for tmp in $deplibrary_names ; do

6927 depdepl=$tmp

6928 done

6929 if test -f "$absdir/$objdir/$depdepl" ; then

6930 depdepl="$absdir/$objdir/$depdepl"

6931 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

6932 if test -z "$darwin_install_name"; then

6933 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

6934 fi

6935 compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

6936 linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"

6937 path=

6938 fi

6939 fi

6940 ;;

6941 *)

6942 path="-L$absdir/$objdir"

6943 ;;

6944 esac

6945 else

6946 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

6947 test -z "$libdir" && \

6948 func_fatal_error "\`$deplib' is not a valid libtool archive"

6949 test "$absdir" != "$libdir" && \

6950 func_warning "\`$deplib' seems to be moved"

6951

6952 path="-L$absdir"

6953 fi

6954 ;;

6955 esac

6956 case " $deplibs " in

6957 *" $path "*) ;;

6958 *) deplibs="$path $deplibs" ;;

6959 esac

6960 done

6961 fi # link_all_deplibs != no

6962 fi # linkmode = lib

6963 done # for deplib in $libs

6964 if test "$pass" = link; then

6965 if test "$linkmode" = "prog"; then

6966 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

6967 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

6968 else

6969 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6970 fi

6971 fi

6972 dependency_libs="$newdependency_libs"

6973 if test "$pass" = dlpreopen; then

6974 # Link the dlpreopened libraries before other libraries

6975 for deplib in $save_deplibs; do

6976 deplibs="$deplib $deplibs"

6977 done

6978 fi

6979 if test "$pass" != dlopen; then

6980 if test "$pass" != conv; then

6981 # Make sure lib_search_path contains only unique directories.

6982 lib_search_path=

6983 for dir in $newlib_search_path; do

6984 case "$lib_search_path " in

6985 *" $dir "*) ;;

6986 *) lib_search_path="$lib_search_path $dir" ;;

6987 esac

6988 done

6989 newlib_search_path=

6990 fi

6991

6992 if test "$linkmode,$pass" != "prog,link"; then

6993 vars="deplibs"

6994 else

6995 vars="compile_deplibs finalize_deplibs"

6996 fi

6997 for var in $vars dependency_libs; do

6998 # Add libraries to $var in reverse order

6999 eval tmp_libs=\"\$$var\"

7000 new_libs=

7001 for deplib in $tmp_libs; do

7002 # FIXME: Pedantically, this is the right thing to do, so

7003 # that some nasty dependency loop isn't accidentally

7004 # broken:

7005 #new_libs="$deplib $new_libs"

7006 # Pragmatically, this seems to cause very few problems in

7007 # practice:

7008 case $deplib in

7009 -L*) new_libs="$deplib $new_libs" ;;

7010 -R*) ;;

7011 *)

7012 # And here is the reason: when a library appears more

7013 # than once as an explicit dependence of a library, or

7014 # is implicitly linked in more than once by the

7015 # compiler, it is considered special, and multiple

7016 # occurrences thereof are not removed. Compare this

7017 # with having the same library being listed as a

7018 # dependency of multiple other libraries: in this case,

7019 # we know (pedantically, we assume) the library does not

7020 # need to be listed more than once, so we keep only the

7021 # last copy. This is not always right, but it is rare

7022 # enough that we require users that really mean to play

7023 # such unportable linking tricks to link the library

7024 # using -Wl,-lname, so that libtool does not consider it

7025 # for duplicate removal.

7026 case " $specialdeplibs " in

7027 *" $deplib "*) new_libs="$deplib $new_libs" ;;

7028 *)

7029 case " $new_libs " in

7030 *" $deplib "*) ;;

7031 *) new_libs="$deplib $new_libs" ;;

7032 esac

7033 ;;

7034 esac

7035 ;;

7036 esac

7037 done

7038 tmp_libs=

7039 for deplib in $new_libs; do

7040 case $deplib in

7041 -L*)

7042 case " $tmp_libs " in

7043 *" $deplib "*) ;;

7044 *) tmp_libs="$tmp_libs $deplib" ;;

7045 esac

7046 ;;

7047 *) tmp_libs="$tmp_libs $deplib" ;;

7048 esac

7049 done

7050 eval $var=\"$tmp_libs\"

7051 done # for var

7052 fi

7053 # Last step: remove runtime libs from dependency_libs

7054 # (they stay in deplibs)

7055 tmp_libs=

7056 for i in $dependency_libs ; do

7057 case " $predeps $postdeps $compiler_lib_search_path " in

7058 *" $i "*)

7059 i=""

7060 ;;

7061 esac

7062 if test -n "$i" ; then

7063 tmp_libs="$tmp_libs $i"

7064 fi

7065 done

7066 dependency_libs=$tmp_libs

7067 done # for pass

7068 if test "$linkmode" = prog; then

7069 dlfiles="$newdlfiles"

7070 fi

7071 if test "$linkmode" = prog || test "$linkmode" = lib; then

7072 dlprefiles="$newdlprefiles"

7073 fi

7074

7075 case $linkmode in

7076 oldlib)

7077 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

7078 func_warning "\`-dlopen' is ignored for archives"

7079 fi

7080

7081 case " $deplibs" in

7082 *\ -l* | *\ -L*)

7083 func_warning "\`-l' and \`-L' are ignored for archives" ;;

7084 esac

7085

7086 test -n "$rpath" && \

7087 func_warning "\`-rpath' is ignored for archives"

7088

7089 test -n "$xrpath" && \

7090 func_warning "\`-R' is ignored for archives"

7091

7092 test -n "$vinfo" && \

7093 func_warning "\`-version-info/-version-number' is ignored for archives"

7094

7095 test -n "$release" && \

7096 func_warning "\`-release' is ignored for archives"

7097

7098 test -n "$export_symbols$export_symbols_regex" && \

7099 func_warning "\`-export-symbols' is ignored for archives"

7100

7101 # Now set the variables for building old libraries.

7102 build_libtool_libs=no

7103 oldlibs="$output"

7104 objs="$objs$old_deplibs"

7105 ;;

7106

7107 lib)

7108 # Make sure we only generate libraries of the form `libNAME.la'.

7109 case $outputname in

7110 lib*)

7111 func_stripname 'lib' '.la' "$outputname"

7112 name=$func_stripname_result

7113 eval shared_ext=\"$shrext_cmds\"

7114 eval libname=\"$libname_spec\"

7115 ;;

7116 *)

7117 test "$module" = no && \

7118 func_fatal_help "libtool library \`$output' must begin with \`lib'"

7119

7120 if test "$need_lib_prefix" != no; then

7121 # Add the "lib" prefix for modules if required

7122 func_stripname '' '.la' "$outputname"

7123 name=$func_stripname_result

7124 eval shared_ext=\"$shrext_cmds\"

7125 eval libname=\"$libname_spec\"

7126 else

7127 func_stripname '' '.la' "$outputname"

7128 libname=$func_stripname_result

7129 fi

7130 ;;

7131 esac

7132

7133 if test -n "$objs"; then

7134 if test "$deplibs_check_method" != pass_all; then

7135 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

7136 else

7137 echo

7138 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"

7139 $ECHO "*** objects $objs is not portable!"

7140 libobjs="$libobjs $objs"

7141 fi

7142 fi

7143

7144 test "$dlself" != no && \

7145 func_warning "\`-dlopen self' is ignored for libtool libraries"

7146

7147 set dummy $rpath

7148 shift

7149 test "$#" -gt 1 && \

7150 func_warning "ignoring multiple \`-rpath's for a libtool library"

7151

7152 install_libdir="$1"

7153

7154 oldlibs=

7155 if test -z "$rpath"; then

7156 if test "$build_libtool_libs" = yes; then

7157 # Building a libtool convenience library.

7158 # Some compilers have problems with a `.al' extension so

7159 # convenience libraries should have the same extension an

7160 # archive normally would.

7161 oldlibs="$output_objdir/$libname.$libext $oldlibs"

7162 build_libtool_libs=convenience

7163 build_old_libs=yes

7164 fi

7165

7166 test -n "$vinfo" && \

7167 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

7168

7169 test -n "$release" && \

7170 func_warning "\`-release' is ignored for convenience libraries"

7171 else

7172

7173 # Parse the version information argument.

7174 save_ifs="$IFS"; IFS=':'

7175 set dummy $vinfo 0 0 0

7176 shift

7177 IFS="$save_ifs"

7178

7179 test -n "$7" && \

7180 func_fatal_help "too many parameters to \`-version-info'"

7181

7182 # convert absolute version numbers to libtool ages

7183 # this retains compatibility with .la files and attempts

7184 # to make the code below a bit more comprehensible

7185

7186 case $vinfo_number in

7187 yes)

7188 number_major="$1"

7189 number_minor="$2"

7190 number_revision="$3"

7191 #

7192 # There are really only two kinds -- those that

7193 # use the current revision as the major version

7194 # and those that subtract age and use age as

7195 # a minor version. But, then there is irix

7196 # which has an extra 1 added just for fun

7197 #

7198 case $version_type in

7199 darwin|linux|osf|windows|none)

7200 func_arith $number_major + $number_minor

7201 current=$func_arith_result

7202 age="$number_minor"

7203 revision="$number_revision"

7204 ;;

7205 freebsd-aout|freebsd-elf|qnx|sunos)

7206 current="$number_major"

7207 revision="$number_minor"

7208 age="0"

7209 ;;

7210 irix|nonstopux)

7211 func_arith $number_major + $number_minor

7212 current=$func_arith_result

7213 age="$number_minor"

7214 revision="$number_minor"

7215 lt_irix_increment=no

7216 ;;

7217 esac

7218 ;;

7219 no)

7220 current="$1"

7221 revision="$2"

7222 age="$3"

7223 ;;

7224 esac

7225

7226 # Check that each of the things are valid numbers.

7227 case $current in

7228 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]) ;;

7229 *)

7230 func_error "CURRENT \`$current' must be a nonnegative integer"

7231 func_fatal_error "\`$vinfo' is not valid version information"

7232 ;;

7233 esac

7234

7235 case $revision in

7236 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]) ;;

7237 *)

7238 func_error "REVISION \`$revision' must be a nonnegative integer"

7239 func_fatal_error "\`$vinfo' is not valid version information"

7240 ;;

7241 esac

7242

7243 case $age in

7244 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]) ;;

7245 *)

7246 func_error "AGE \`$age' must be a nonnegative integer"

7247 func_fatal_error "\`$vinfo' is not valid version information"

7248 ;;

7249 esac

7250

7251 if test "$age" -gt "$current"; then

7252 func_error "AGE \`$age' is greater than the current interface number \`$current'"

7253 func_fatal_error "\`$vinfo' is not valid version information"

7254 fi

7255

7256 # Calculate the version variables.

7257 major=

7258 versuffix=

7259 verstring=

7260 case $version_type in

7261 none) ;;

7262

7263 darwin)

7264 # Like Linux, but with the current version available in

7265 # verstring for coding it into the library header

7266 func_arith $current - $age

7267 major=.$func_arith_result

7268 versuffix="$major.$age.$revision"

7269 # Darwin ld doesn't like 0 for these options...

7270 func_arith $current + 1

7271 minor_current=$func_arith_result

7272 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"

7273 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

7274 ;;

7275

7276 freebsd-aout)

7277 major=".$current"

7278 versuffix=".$current.$revision";

7279 ;;

7280

7281 freebsd-elf)

7282 major=".$current"

7283 versuffix=".$current"

7284 ;;

7285

7286 irix | nonstopux)

7287 if test "X$lt_irix_increment" = "Xno"; then

7288 func_arith $current - $age

7289 else

7290 func_arith $current - $age + 1

7291 fi

7292 major=$func_arith_result

7293

7294 case $version_type in

7295 nonstopux) verstring_prefix=nonstopux ;;

7296 *) verstring_prefix=sgi ;;

7297 esac

7298 verstring="$verstring_prefix$major.$revision"

7299

7300 # Add in all the interfaces that we are compatible with.

7301 loop=$revision

7302 while test "$loop" -ne 0; do

7303 func_arith $revision - $loop

7304 iface=$func_arith_result

7305 func_arith $loop - 1

7306 loop=$func_arith_result

7307 verstring="$verstring_prefix$major.$iface:$verstring"

7308 done

7309

7310 # Before this point, $major must not contain `.'.

7311 major=.$major

7312 versuffix="$major.$revision"

7313 ;;

7314

7315 linux)

7316 func_arith $current - $age

7317 major=.$func_arith_result

7318 versuffix="$major.$age.$revision"

7319 ;;

7320

7321 osf)

7322 func_arith $current - $age

7323 major=.$func_arith_result

7324 versuffix=".$current.$age.$revision"

7325 verstring="$current.$age.$revision"

7326

7327 # Add in all the interfaces that we are compatible with.

7328 loop=$age

7329 while test "$loop" -ne 0; do

7330 func_arith $current - $loop

7331 iface=$func_arith_result

7332 func_arith $loop - 1

7333 loop=$func_arith_result

7334 verstring="$verstring:${iface}.0"

7335 done

7336

7337 # Make executables depend on our current version.

7338 verstring="$verstring:${current}.0"

7339 ;;

7340

7341 qnx)

7342 major=".$current"

7343 versuffix=".$current"

7344 ;;

7345

7346 sunos)

7347 major=".$current"

7348 versuffix=".$current.$revision"

7349 ;;

7350

7351 windows)

7352 # Use '-' rather than '.', since we only want one

7353 # extension on DOS 8.3 filesystems.

7354 func_arith $current - $age

7355 major=$func_arith_result

7356 versuffix="-$major"

7357 ;;

7358

7359 *)

7360 func_fatal_configuration "unknown library version type \`$version_type'"

7361 ;;

7362 esac

7363

7364 # Clear the version info if we defaulted, and they specified a release.

7365 if test -z "$vinfo" && test -n "$release"; then

7366 major=

7367 case $version_type in

7368 darwin)

7369 # we can't check for "0.0" in archive_cmds due to quoting

7370 # problems, so we reset it completely

7371 verstring=

7372 ;;

7373 *)

7374 verstring="0.0"

7375 ;;

7376 esac

7377 if test "$need_version" = no; then

7378 versuffix=

7379 else

7380 versuffix=".0.0"

7381 fi

7382 fi

7383

7384 # Remove version info from name if versioning should be avoided

7385 if test "$avoid_version" = yes && test "$need_version" = no; then

7386 major=

7387 versuffix=

7388 verstring=""

7389 fi

7390

7391 # Check to see if the archive will have undefined symbols.

7392 if test "$allow_undefined" = yes; then

7393 if test "$allow_undefined_flag" = unsupported; then

7394 func_warning "undefined symbols not allowed in $host shared libraries"

7395 build_libtool_libs=no

7396 build_old_libs=yes

7397 fi

7398 else

7399 # Don't allow undefined symbols.

7400 allow_undefined_flag="$no_undefined_flag"

7401 fi

7402

7403 fi

7404

7405 func_generate_dlsyms "$libname" "$libname" "yes"

7406 libobjs="$libobjs $symfileobj"

7407 test "X$libobjs" = "X " && libobjs=

7408

7409 if test "$mode" != relink; then

7410 # Remove our outputs, but don't remove object files since they

7411 # may have been created when compiling PIC objects.

7412 removelist=

7413 tempremovelist=`$ECHO "$output_objdir/*"`

7414 for p in $tempremovelist; do

7415 case $p in

7416 *.$objext | *.gcno)

7417 ;;

7418 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

7419 if test "X$precious_files_regex" != "X"; then

7420 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

7421 then

7422 continue

7423 fi

7424 fi

7425 removelist="$removelist $p"

7426 ;;

7427 *) ;;

7428 esac

7429 done

7430 test -n "$removelist" && \

7431 func_show_eval "${RM}r \$removelist"

7432 fi

7433

7434 # Now set the variables for building old libraries.

7435 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

7436 oldlibs="$oldlibs $output_objdir/$libname.$libext"

7437

7438 # Transform .lo files to .o files.

7439 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

7440 fi

7441

7442 # Eliminate all temporary directories.

7443 #for path in $notinst_path; do

7444 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

7445 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

7446 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

7447 #done

7448

7449 if test -n "$xrpath"; then

7450 # If the user specified any rpath flags, then add them.

7451 temp_xrpath=

7452 for libdir in $xrpath; do

7453 temp_xrpath="$temp_xrpath -R$libdir"

7454 case "$finalize_rpath " in

7455 *" $libdir "*) ;;

7456 *) finalize_rpath="$finalize_rpath $libdir" ;;

7457 esac

7458 done

7459 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

7460 dependency_libs="$temp_xrpath $dependency_libs"

7461 fi

7462 fi

7463

7464 # Make sure dlfiles contains only unique files that won't be dlpreopened

7465 old_dlfiles="$dlfiles"

7466 dlfiles=

7467 for lib in $old_dlfiles; do

7468 case " $dlprefiles $dlfiles " in

7469 *" $lib "*) ;;

7470 *) dlfiles="$dlfiles $lib" ;;

7471 esac

7472 done

7473

7474 # Make sure dlprefiles contains only unique files

7475 old_dlprefiles="$dlprefiles"

7476 dlprefiles=

7477 for lib in $old_dlprefiles; do

7478 case "$dlprefiles " in

7479 *" $lib "*) ;;

7480 *) dlprefiles="$dlprefiles $lib" ;;

7481 esac

7482 done

7483

7484 if test "$build_libtool_libs" = yes; then

7485 if test -n "$rpath"; then

7486 case $host in

7488 # these systems don't actually have a c library (as such)!

7489 ;;

7490 *-*-rhapsody* | *-*-darwin1.[012])

7491 # Rhapsody C library is in the System framework

7492 deplibs="$deplibs System.ltframework"

7493 ;;

7494 *-*-netbsd*)

7495 # Don't link with libc until the a.out ld.so is fixed.

7496 ;;

7497 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

7498 # Do not include libc due to us having libc/libc_r.

7499 ;;

7500 *-*-sco3.2v5* | *-*-sco5v6*)

7501 # Causes problems with __ctype

7502 ;;

7503 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

7504 # Compiler inserts libc in the correct place for threads to work

7505 ;;

7506 *)

7507 # Add libc to deplibs on all other systems if necessary.

7508 if test "$build_libtool_need_lc" = "yes"; then

7509 deplibs="$deplibs -lc"

7510 fi

7511 ;;

7512 esac

7513 fi

7514

7515 # Transform deplibs into only deplibs that can be linked in shared.

7516 name_save=$name

7517 libname_save=$libname

7518 release_save=$release

7519 versuffix_save=$versuffix

7520 major_save=$major

7521 # I'm not sure if I'm treating the release correctly. I think

7522 # release should show up in the -l (ie -lgmp5) so we don't want to

7523 # add it in twice. Is that correct?

7524 release=""

7525 versuffix=""

7526 major=""

7527 newdeplibs=

7528 droppeddeps=no

7529 case $deplibs_check_method in

7530 pass_all)

7531 # Don't check for shared/static. Everything works.

7532 # This might be a little naive. We might want to check

7533 # whether the library exists or not. But this is on

7534 # osf3 & osf4 and I'm not really sure... Just

7535 # implementing what was already the behavior.

7536 newdeplibs=$deplibs

7537 ;;

7538 test_compile)

7539 # This code stresses the "libraries are programs" paradigm to its

7540 # limits. Maybe even breaks it. We compile a program, linking it

7541 # against the deplibs as a proxy for the library. Then we can check

7542 # whether they linked in statically or dynamically with ldd.

7543 $opt_dry_run || $RM conftest.c

7544 cat > conftest.c <<EOF

7545 int main() { return 0; }

7546 EOF

7547 $opt_dry_run || $RM conftest

7548 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then

7549 ldd_output=`ldd conftest`

7550 for i in $deplibs; do

7551 case $i in

7552 -l*)

7553 func_stripname -l '' "$i"

7554 name=$func_stripname_result

7555 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7556 case " $predeps $postdeps " in

7557 *" $i "*)

7558 newdeplibs="$newdeplibs $i"

7559 i=""

7560 ;;

7561 esac

7562 fi

7563 if test -n "$i" ; then

7564 libname=`eval "\\$ECHO \"$libname_spec\""`

7565 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7566 set dummy $deplib_matches; shift

7567 deplib_match=$1

7568 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7569 newdeplibs="$newdeplibs $i"

7570 else

7571 droppeddeps=yes

7572 echo

7573 $ECHO "*** Warning: dynamic linker does not accept needed library $i."

7574 echo "*** I have the capability to make that library automatically link in when"

7575 echo "*** you link to this library. But I can only do this if you have a"

7576 echo "*** shared version of the library, which I believe you do not have"

7577 echo "*** because a test_compile did reveal that the linker did not use it for"

7578 echo "*** its dynamic dependency list that programs get resolved with at runtime."

7579 fi

7580 fi

7581 ;;

7582 *)

7583 newdeplibs="$newdeplibs $i"

7584 ;;

7585 esac

7586 done

7587 else

7588 # Error occurred in the first compile. Let's try to salvage

7589 # the situation: Compile a separate program for each library.

7590 for i in $deplibs; do

7591 case $i in

7592 -l*)

7593 func_stripname -l '' "$i"

7594 name=$func_stripname_result

7595 $opt_dry_run || $RM conftest

7596 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

7597 ldd_output=`ldd conftest`

7598 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7599 case " $predeps $postdeps " in

7600 *" $i "*)

7601 newdeplibs="$newdeplibs $i"

7602 i=""

7603 ;;

7604 esac

7605 fi

7606 if test -n "$i" ; then

7607 libname=`eval "\\$ECHO \"$libname_spec\""`

7608 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7609 set dummy $deplib_matches; shift

7610 deplib_match=$1

7611 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7612 newdeplibs="$newdeplibs $i"

7613 else

7614 droppeddeps=yes

7615 echo

7616 $ECHO "*** Warning: dynamic linker does not accept needed library $i."

7617 echo "*** I have the capability to make that library automatically link in when"

7618 echo "*** you link to this library. But I can only do this if you have a"

7619 echo "*** shared version of the library, which you do not appear to have"

7620 echo "*** because a test_compile did reveal that the linker did not use this one"

7621 echo "*** as a dynamic dependency that programs can get resolved with at runtime."

7622 fi

7623 fi

7624 else

7625 droppeddeps=yes

7626 echo

7627 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"

7628 echo "*** make it link in! You will probably need to install it or some"

7629 echo "*** library that it depends on before this library will be fully"

7630 echo "*** functional. Installing it before continuing would be even better."

7631 fi

7632 ;;

7633 *)

7634 newdeplibs="$newdeplibs $i"

7635 ;;

7636 esac

7637 done

7638 fi

7639 ;;

7640 file_magic*)

7641 set dummy $deplibs_check_method; shift

7642 file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7643 for a_deplib in $deplibs; do

7644 case $a_deplib in

7645 -l*)

7646 func_stripname -l '' "$a_deplib"

7647 name=$func_stripname_result

7648 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7649 case " $predeps $postdeps " in

7650 *" $a_deplib "*)

7651 newdeplibs="$newdeplibs $a_deplib"

7652 a_deplib=""

7653 ;;

7654 esac

7655 fi

7656 if test -n "$a_deplib" ; then

7657 libname=`eval "\\$ECHO \"$libname_spec\""`

7658 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7659 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7660 for potent_lib in $potential_libs; do

7661 # Follow soft links.

7662 if ls -lLd "$potent_lib" 2>/dev/null |

7663 $GREP " -> " >/dev/null; then

7664 continue

7665 fi

7666 # The statement above tries to avoid entering an

7667 # endless loop below, in case of cyclic links.

7668 # We might still enter an endless loop, since a link

7669 # loop can be closed while we follow links,

7670 # but so what?

7671 potlib="$potent_lib"

7672 while test -h "$potlib" 2>/dev/null; do

7673 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

7674 case $potliblink in

7675 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

7676 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

7677 esac

7678 done

7679 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

7680 $SED -e 10q |

7681 $EGREP "$file_magic_regex" > /dev/null; then

7682 newdeplibs="$newdeplibs $a_deplib"

7683 a_deplib=""

7684 break 2

7685 fi

7686 done

7687 done

7688 fi

7689 if test -n "$a_deplib" ; then

7690 droppeddeps=yes

7691 echo

7692 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7693 echo "*** I have the capability to make that library automatically link in when"

7694 echo "*** you link to this library. But I can only do this if you have a"

7695 echo "*** shared version of the library, which you do not appear to have"

7696 echo "*** because I did check the linker path looking for a file starting"

7697 if test -z "$potlib" ; then

7698 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"

7699 else

7700 $ECHO "*** with $libname and none of the candidates passed a file format test"

7701 $ECHO "*** using a file magic. Last file checked: $potlib"

7702 fi

7703 fi

7704 ;;

7705 *)

7706 # Add a -L argument.

7707 newdeplibs="$newdeplibs $a_deplib"

7708 ;;

7709 esac

7710 done # Gone through all deplibs.

7711 ;;

7712 match_pattern*)

7713 set dummy $deplibs_check_method; shift

7714 match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7715 for a_deplib in $deplibs; do

7716 case $a_deplib in

7717 -l*)

7718 func_stripname -l '' "$a_deplib"

7719 name=$func_stripname_result

7720 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7721 case " $predeps $postdeps " in

7722 *" $a_deplib "*)

7723 newdeplibs="$newdeplibs $a_deplib"

7724 a_deplib=""

7725 ;;

7726 esac

7727 fi

7728 if test -n "$a_deplib" ; then

7729 libname=`eval "\\$ECHO \"$libname_spec\""`

7730 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7731 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7732 for potent_lib in $potential_libs; do

7733 potlib="$potent_lib" # see symlink-check above in file_magic test

7734 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

7735 $EGREP "$match_pattern_regex" > /dev/null; then

7736 newdeplibs="$newdeplibs $a_deplib"

7737 a_deplib=""

7738 break 2

7739 fi

7740 done

7741 done

7742 fi

7743 if test -n "$a_deplib" ; then

7744 droppeddeps=yes

7745 echo

7746 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7747 echo "*** I have the capability to make that library automatically link in when"

7748 echo "*** you link to this library. But I can only do this if you have a"

7749 echo "*** shared version of the library, which you do not appear to have"

7750 echo "*** because I did check the linker path looking for a file starting"

7751 if test -z "$potlib" ; then

7752 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

7753 else

7754 $ECHO "*** with $libname and none of the candidates passed a file format test"

7755 $ECHO "*** using a regex pattern. Last file checked: $potlib"

7756 fi

7757 fi

7758 ;;

7759 *)

7760 # Add a -L argument.

7761 newdeplibs="$newdeplibs $a_deplib"

7762 ;;

7763 esac

7764 done # Gone through all deplibs.

7765 ;;

7766 none | unknown | *)

7767 newdeplibs=""

7768 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

7769 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7770 for i in $predeps $postdeps ; do

7771 # can't use Xsed below, because $i might contain '/'

7772 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

7773 done

7774 fi

7775 case $tmp_deplibs in

7776 *[!\ \ ]*)

7777 echo

7778 if test "X$deplibs_check_method" = "Xnone"; then

7779 echo "*** Warning: inter-library dependencies are not supported in this platform."

7780 else

7781 echo "*** Warning: inter-library dependencies are not known to be supported."

7782 fi

7783 echo "*** All declared inter-library dependencies are being dropped."

7784 droppeddeps=yes

7785 ;;

7786 esac

7787 ;;

7788 esac

7789 versuffix=$versuffix_save

7790 major=$major_save

7791 release=$release_save

7792 libname=$libname_save

7793 name=$name_save

7794

7795 case $host in

7796 *-*-rhapsody* | *-*-darwin1.[012])

7797 # On Rhapsody replace the C library with the System framework

7798 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

7799 ;;

7800 esac

7801

7802 if test "$droppeddeps" = yes; then

7803 if test "$module" = yes; then

7804 echo

7805 echo "*** Warning: libtool could not satisfy all declared inter-library"

7806 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"

7807 echo "*** a static module, that should work as long as the dlopening"

7808 echo "*** application is linked with the -dlopen flag."

7809 if test -z "$global_symbol_pipe"; then

7810 echo

7811 echo "*** However, this would only work if libtool was able to extract symbol"

7812 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

7813 echo "*** not find such a program. So, this module is probably useless."

7814 echo "*** \`nm' from GNU binutils and a full rebuild may help."

7815 fi

7816 if test "$build_old_libs" = no; then

7817 oldlibs="$output_objdir/$libname.$libext"

7818 build_libtool_libs=module

7819 build_old_libs=yes

7820 else

7821 build_libtool_libs=no

7822 fi

7823 else

7824 echo "*** The inter-library dependencies that have been dropped here will be"

7825 echo "*** automatically added whenever a program is linked with this library"

7826 echo "*** or is declared to -dlopen it."

7827

7828 if test "$allow_undefined" = no; then

7829 echo

7830 echo "*** Since this library must not contain undefined symbols,"

7831 echo "*** because either the platform does not support them or"

7832 echo "*** it was explicitly requested with -no-undefined,"

7833 echo "*** libtool will only create a static version of it."

7834 if test "$build_old_libs" = no; then

7835 oldlibs="$output_objdir/$libname.$libext"

7836 build_libtool_libs=module

7837 build_old_libs=yes

7838 else

7839 build_libtool_libs=no

7840 fi

7841 fi

7842 fi

7843 fi

7844 # Done checking deplibs!

7845 deplibs=$newdeplibs

7846 fi

7847 # Time to change all our "foo.ltframework" stuff back to "-framework foo"

7848 case $host in

7849 *-*-darwin*)

7850 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7851 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7852 deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7853 ;;

7854 esac

7855

7856 # move library search paths that coincide with paths to not yet

7857 # installed libraries to the beginning of the library search list

7858 new_libs=

7859 for path in $notinst_path; do

7860 case " $new_libs " in

7861 *" -L$path/$objdir "*) ;;

7862 *)

7863 case " $deplibs " in

7864 *" -L$path/$objdir "*)

7865 new_libs="$new_libs -L$path/$objdir" ;;

7866 esac

7867 ;;

7868 esac

7869 done

7870 for deplib in $deplibs; do

7871 case $deplib in

7872 -L*)

7873 case " $new_libs " in

7874 *" $deplib "*) ;;

7875 *) new_libs="$new_libs $deplib" ;;

7876 esac

7877 ;;

7878 *) new_libs="$new_libs $deplib" ;;

7879 esac

7880 done

7881 deplibs="$new_libs"

7882

7883 # All the library-specific variables (install_libdir is set above).

7884 library_names=

7885 old_library=

7886 dlname=

7887

7888 # Test again, we may have decided not to build it any more

7889 if test "$build_libtool_libs" = yes; then

7890 if test "$hardcode_into_libs" = yes; then

7891 # Hardcode the library paths

7892 hardcode_libdirs=

7893 dep_rpath=

7894 rpath="$finalize_rpath"

7895 test "$mode" != relink && rpath="$compile_rpath$rpath"

7896 for libdir in $rpath; do

7897 if test -n "$hardcode_libdir_flag_spec"; then

7898 if test -n "$hardcode_libdir_separator"; then

7899 if test -z "$hardcode_libdirs"; then

7900 hardcode_libdirs="$libdir"

7901 else

7902 # Just accumulate the unique libdirs.

7903 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

7904 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

7905 ;;

7906 *)

7907 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

7908 ;;

7909 esac

7910 fi

7911 else

7912 eval flag=\"$hardcode_libdir_flag_spec\"

7913 dep_rpath="$dep_rpath $flag"

7914 fi

7915 elif test -n "$runpath_var"; then

7916 case "$perm_rpath " in

7917 *" $libdir "*) ;;

7918 *) perm_rpath="$perm_rpath $libdir" ;;

7919 esac

7920 fi

7921 done

7922 # Substitute the hardcoded libdirs into the rpath.

7923 if test -n "$hardcode_libdir_separator" &&

7924 test -n "$hardcode_libdirs"; then

7925 libdir="$hardcode_libdirs"

7926 if test -n "$hardcode_libdir_flag_spec_ld"; then

7927 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"

7928 else

7929 eval dep_rpath=\"$hardcode_libdir_flag_spec\"

7930 fi

7931 fi

7932 if test -n "$runpath_var" && test -n "$perm_rpath"; then

7933 # We should set the runpath_var.

7934 rpath=

7935 for dir in $perm_rpath; do

7936 rpath="$rpath$dir:"

7937 done

7938 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

7939 fi

7940 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

7941 fi

7942

7943 shlibpath="$finalize_shlibpath"

7944 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

7945 if test -n "$shlibpath"; then

7946 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

7947 fi

7948

7949 # Get the real and link names of the library.

7950 eval shared_ext=\"$shrext_cmds\"

7951 eval library_names=\"$library_names_spec\"

7952 set dummy $library_names

7953 shift

7954 realname="$1"

7955 shift

7956

7957 if test -n "$soname_spec"; then

7958 eval soname=\"$soname_spec\"

7959 else

7960 soname="$realname"

7961 fi

7962 if test -z "$dlname"; then

7963 dlname=$soname

7964 fi

7965

7966 lib="$output_objdir/$realname"

7967 linknames=

7968 for link

7969 do

7970 linknames="$linknames $link"

7971 done

7972

7973 # Use standard objects if they are pic

7974 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

7975 test "X$libobjs" = "X " && libobjs=

7976

7977 delfiles=

7978 if test -n "$export_symbols" && test -n "$include_expsyms"; then

7979 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

7980 export_symbols="$output_objdir/$libname.uexp"

7981 delfiles="$delfiles $export_symbols"

7982 fi

7983

7984 orig_export_symbols=

7985 case $host_os in

7986 cygwin* | mingw* | cegcc*)

7987 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

7988 # exporting using user supplied symfile

7989 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

7990 # and it's NOT already a .def file. Must figure out

7991 # which of the given symbols are data symbols and tag

7992 # them as such. So, trigger use of export_symbols_cmds.

7993 # export_symbols gets reassigned inside the "prepare

7994 # the list of exported symbols" if statement, so the

7995 # include_expsyms logic still works.

7996 orig_export_symbols="$export_symbols"

7997 export_symbols=

7998 always_export_symbols=yes

7999 fi

8000 fi

8001 ;;

8002 esac

8003

8004 # Prepare the list of exported symbols

8005 if test -z "$export_symbols"; then

8006 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

8007 func_verbose "generating symbol list for \`$libname.la'"

8008 export_symbols="$output_objdir/$libname.exp"

8009 $opt_dry_run || $RM $export_symbols

8010 cmds=$export_symbols_cmds

8011 save_ifs="$IFS"; IFS='~'

8012 for cmd in $cmds; do

8013 IFS="$save_ifs"

8014 eval cmd=\"$cmd\"

8015 func_len " $cmd"

8016 len=$func_len_result

8017 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8018 func_show_eval "$cmd" 'exit $?'

8019 skipped_export=false

8020 else

8021 # The command line is too long to execute in one step.

8022 func_verbose "using reloadable object file for export list..."

8023 skipped_export=:

8024 # Break out early, otherwise skipped_export may be

8025 # set to false by a later but shorter cmd.

8026 break

8027 fi

8028 done

8029 IFS="$save_ifs"

8030 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

8031 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8032 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8033 fi

8034 fi

8035 fi

8036

8037 if test -n "$export_symbols" && test -n "$include_expsyms"; then

8038 tmp_export_symbols="$export_symbols"

8039 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8040 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8041 fi

8042

8043 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

8044 # The given exports_symbols file has to be filtered, so filter it.

8045 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8046 # FIXME: $output_objdir/$libname.filter potentially contains lots of

8047 # 's' commands which not all seds can handle. GNU sed should be fine

8048 # though. Also, the filter scales superlinearly with the number of

8049 # global variables. join(1) would be nice here, but unfortunately

8050 # isn't a blessed tool.

8051 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8052 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8053 export_symbols=$output_objdir/$libname.def

8054 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8055 fi

8056

8057 tmp_deplibs=

8058 for test_deplib in $deplibs; do

8059 case " $convenience " in

8060 *" $test_deplib "*) ;;

8061 *)

8062 tmp_deplibs="$tmp_deplibs $test_deplib"

8063 ;;

8064 esac

8065 done

8066 deplibs="$tmp_deplibs"

8067

8068 if test -n "$convenience"; then

8069 if test -n "$whole_archive_flag_spec" &&

8070 test "$compiler_needs_object" = yes &&

8071 test -z "$libobjs"; then

8072 # extract the archives, so we have objects to list.

8073 # TODO: could optimize this to just extract one archive.

8074 whole_archive_flag_spec=

8075 fi

8076 if test -n "$whole_archive_flag_spec"; then

8077 save_libobjs=$libobjs

8078 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8079 test "X$libobjs" = "X " && libobjs=

8080 else

8081 gentop="$output_objdir/${outputname}x"

8082 generated="$generated $gentop"

8083

8084 func_extract_archives $gentop $convenience

8085 libobjs="$libobjs $func_extract_archives_result"

8086 test "X$libobjs" = "X " && libobjs=

8087 fi

8088 fi

8089

8090 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

8091 eval flag=\"$thread_safe_flag_spec\"

8092 linker_flags="$linker_flags $flag"

8093 fi

8094

8095 # Make a backup of the uninstalled library when relinking

8096 if test "$mode" = relink; then

8097 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

8098 fi

8099

8100 # Do each of the archive commands.

8101 if test "$module" = yes && test -n "$module_cmds" ; then

8102 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8103 eval test_cmds=\"$module_expsym_cmds\"

8104 cmds=$module_expsym_cmds

8105 else

8106 eval test_cmds=\"$module_cmds\"

8107 cmds=$module_cmds

8108 fi

8109 else

8110 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8111 eval test_cmds=\"$archive_expsym_cmds\"

8112 cmds=$archive_expsym_cmds

8113 else

8114 eval test_cmds=\"$archive_cmds\"

8115 cmds=$archive_cmds

8116 fi

8117 fi

8118

8119 if test "X$skipped_export" != "X:" &&

8120 func_len " $test_cmds" &&

8121 len=$func_len_result &&

8122 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8123 :

8124 else

8125 # The command line is too long to link in one step, link piecewise

8126 # or, if using GNU ld and skipped_export is not :, use a linker

8127 # script.

8128

8129 # Save the value of $output and $libobjs because we want to

8130 # use them later. If we have whole_archive_flag_spec, we

8131 # want to use save_libobjs as it was before

8132 # whole_archive_flag_spec was expanded, because we can't

8133 # assume the linker understands whole_archive_flag_spec.

8134 # This may have to be revisited, in case too many

8135 # convenience libraries get linked in and end up exceeding

8136 # the spec.

8137 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then

8138 save_libobjs=$libobjs

8139 fi

8140 save_output=$output

8141 func_basename "$output"

8142 output_la=$func_basename_result

8143

8144 # Clear the reloadable object creation command queue and

8145 # initialize k to one.

8146 test_cmds=

8147 concat_cmds=

8148 objlist=

8149 last_robj=

8150 k=1

8151

8152 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

8153 output=${output_objdir}/${output_la}.lnkscript

8154 func_verbose "creating GNU ld script: $output"

8155 echo 'INPUT (' > $output

8156 for obj in $save_libobjs

8157 do

8158 $ECHO "$obj" >> $output

8159 done

8160 echo ')' >> $output

8161 delfiles="$delfiles $output"

8162 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

8163 output=${output_objdir}/${output_la}.lnk

8164 func_verbose "creating linker input file list: $output"

8165 : > $output

8166 set x $save_libobjs

8167 shift

8168 firstobj=

8169 if test "$compiler_needs_object" = yes; then

8170 firstobj="$1 "

8171 shift

8172 fi

8173 for obj

8174 do

8175 $ECHO "$obj" >> $output

8176 done

8177 delfiles="$delfiles $output"

8178 output=$firstobj\"$file_list_spec$output\"

8179 else

8180 if test -n "$save_libobjs"; then

8181 func_verbose "creating reloadable object files..."

8182 output=$output_objdir/$output_la-${k}.$objext

8183 eval test_cmds=\"$reload_cmds\"

8184 func_len " $test_cmds"

8185 len0=$func_len_result

8186 len=$len0

8187

8188 # Loop over the list of objects to be linked.

8189 for obj in $save_libobjs

8190 do

8191 func_len " $obj"

8192 func_arith $len + $func_len_result

8193 len=$func_arith_result

8194 if test "X$objlist" = X ||

8195 test "$len" -lt "$max_cmd_len"; then

8196 func_append objlist " $obj"

8197 else

8198 # The command $test_cmds is almost too long, add a

8199 # command to the queue.

8200 if test "$k" -eq 1 ; then

8201 # The first file doesn't have a previous command to add.

8202 reload_objs=$objlist

8203 eval concat_cmds=\"$reload_cmds\"

8204 else

8205 # All subsequent reloadable object files will link in

8206 # the last one created.

8207 reload_objs="$objlist $last_robj"

8208 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

8209 fi

8210 last_robj=$output_objdir/$output_la-${k}.$objext

8211 func_arith $k + 1

8212 k=$func_arith_result

8213 output=$output_objdir/$output_la-${k}.$objext

8214 objlist=" $obj"

8215 func_len " $last_robj"

8216 func_arith $len0 + $func_len_result

8217 len=$func_arith_result

8218 fi

8219 done

8220 # Handle the remaining objects by creating one last

8221 # reloadable object file. All subsequent reloadable object

8222 # files will link in the last one created.

8223 test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8224 reload_objs="$objlist $last_robj"

8225 eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

8226 if test -n "$last_robj"; then

8227 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

8228 fi

8229 delfiles="$delfiles $output"

8230

8231 else

8232 output=

8233 fi

8234

8235 if ${skipped_export-false}; then

8236 func_verbose "generating symbol list for \`$libname.la'"

8237 export_symbols="$output_objdir/$libname.exp"

8238 $opt_dry_run || $RM $export_symbols

8239 libobjs=$output

8240 # Append the command to create the export file.

8241 test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8242 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"

8243 if test -n "$last_robj"; then

8244 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

8245 fi

8246 fi

8247

8248 test -n "$save_libobjs" &&

8249 func_verbose "creating a temporary reloadable object file: $output"

8250

8251 # Loop through the commands generated above and execute them.

8252 save_ifs="$IFS"; IFS='~'

8253 for cmd in $concat_cmds; do

8254 IFS="$save_ifs"

8255 $opt_silent || {

8256 func_quote_for_expand "$cmd"

8257 eval "func_echo $func_quote_for_expand_result"

8258 }

8259 $opt_dry_run || eval "$cmd" || {

8260 lt_exit=$?

8261

8262 # Restore the uninstalled library and exit

8263 if test "$mode" = relink; then

8264 ( cd "$output_objdir" && \

8265 $RM "${realname}T" && \

8266 $MV "${realname}U" "$realname" )

8267 fi

8268

8269 exit $lt_exit

8270 }

8271 done

8272 IFS="$save_ifs"

8273

8274 if test -n "$export_symbols_regex" && ${skipped_export-false}; then

8275 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8276 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8277 fi

8278 fi

8279

8280 if ${skipped_export-false}; then

8281 if test -n "$export_symbols" && test -n "$include_expsyms"; then

8282 tmp_export_symbols="$export_symbols"

8283 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8284 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8285 fi

8286

8287 if test -n "$orig_export_symbols"; then

8288 # The given exports_symbols file has to be filtered, so filter it.

8289 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8290 # FIXME: $output_objdir/$libname.filter potentially contains lots of

8291 # 's' commands which not all seds can handle. GNU sed should be fine

8292 # though. Also, the filter scales superlinearly with the number of

8293 # global variables. join(1) would be nice here, but unfortunately

8294 # isn't a blessed tool.

8295 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8296 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8297 export_symbols=$output_objdir/$libname.def

8298 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8299 fi

8300 fi

8301

8302 libobjs=$output

8303 # Restore the value of output.

8304 output=$save_output

8305

8306 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then

8307 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8308 test "X$libobjs" = "X " && libobjs=

8309 fi

8310 # Expand the library linking commands again to reset the

8311 # value of $libobjs for piecewise linking.

8312

8313 # Do each of the archive commands.

8314 if test "$module" = yes && test -n "$module_cmds" ; then

8315 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8316 cmds=$module_expsym_cmds

8317 else

8318 cmds=$module_cmds

8319 fi

8320 else

8321 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8322 cmds=$archive_expsym_cmds

8323 else

8324 cmds=$archive_cmds

8325 fi

8326 fi

8327 fi

8328

8329 if test -n "$delfiles"; then

8330 # Append the command to remove temporary files to $cmds.

8331 eval cmds=\"\$cmds~\$RM $delfiles\"

8332 fi

8333

8334 # Add any objects from preloaded convenience libraries

8335 if test -n "$dlprefiles"; then

8336 gentop="$output_objdir/${outputname}x"

8337 generated="$generated $gentop"

8338

8339 func_extract_archives $gentop $dlprefiles

8340 libobjs="$libobjs $func_extract_archives_result"

8341 test "X$libobjs" = "X " && libobjs=

8342 fi

8343

8344 save_ifs="$IFS"; IFS='~'

8345 for cmd in $cmds; do

8346 IFS="$save_ifs"

8347 eval cmd=\"$cmd\"

8348 $opt_silent || {

8349 func_quote_for_expand "$cmd"

8350 eval "func_echo $func_quote_for_expand_result"

8351 }

8352 $opt_dry_run || eval "$cmd" || {

8353 lt_exit=$?

8354

8355 # Restore the uninstalled library and exit

8356 if test "$mode" = relink; then

8357 ( cd "$output_objdir" && \

8358 $RM "${realname}T" && \

8359 $MV "${realname}U" "$realname" )

8360 fi

8361

8362 exit $lt_exit

8363 }

8364 done

8365 IFS="$save_ifs"

8366

8367 # Restore the uninstalled library and exit

8368 if test "$mode" = relink; then

8369 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

8370

8371 if test -n "$convenience"; then

8372 if test -z "$whole_archive_flag_spec"; then

8373 func_show_eval '${RM}r "$gentop"'

8374 fi

8375 fi

8376

8377 exit $EXIT_SUCCESS

8378 fi

8379

8380 # Create links to the real library.

8381 for linkname in $linknames; do

8382 if test "$realname" != "$linkname"; then

8383 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'

8384 fi

8385 done

8386

8387 # If -module or -export-dynamic was specified, set the dlname.

8388 if test "$module" = yes || test "$export_dynamic" = yes; then

8389 # On all known operating systems, these are identical.

8390 dlname="$soname"

8391 fi

8392 fi

8393 ;;

8394

8395 obj)

8396 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

8397 func_warning "\`-dlopen' is ignored for objects"

8398 fi

8399

8400 case " $deplibs" in

8401 *\ -l* | *\ -L*)

8402 func_warning "\`-l' and \`-L' are ignored for objects" ;;

8403 esac

8404

8405 test -n "$rpath" && \

8406 func_warning "\`-rpath' is ignored for objects"

8407

8408 test -n "$xrpath" && \

8409 func_warning "\`-R' is ignored for objects"

8410

8411 test -n "$vinfo" && \

8412 func_warning "\`-version-info' is ignored for objects"

8413

8414 test -n "$release" && \

8415 func_warning "\`-release' is ignored for objects"

8416

8417 case $output in

8418 *.lo)

8419 test -n "$objs$old_deplibs" && \

8420 func_fatal_error "cannot build library object \`$output' from non-libtool objects"

8421

8422 libobj=$output

8423 func_lo2o "$libobj"

8424 obj=$func_lo2o_result

8425 ;;

8426 *)

8427 libobj=

8428 obj="$output"

8429 ;;

8430 esac

8431

8432 # Delete the old objects.

8433 $opt_dry_run || $RM $obj $libobj

8434

8435 # Objects from convenience libraries. This assumes

8436 # single-version convenience libraries. Whenever we create

8437 # different ones for PIC/non-PIC, this we'll have to duplicate

8438 # the extraction.

8439 reload_conv_objs=

8440 gentop=

8441 # reload_cmds runs $LD directly, so let us get rid of

8442 # -Wl from whole_archive_flag_spec and hope we can get by with

8443 # turning comma into space..

8444 wl=

8445

8446 if test -n "$convenience"; then

8447 if test -n "$whole_archive_flag_spec"; then

8448 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

8449 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

8450 else

8451 gentop="$output_objdir/${obj}x"

8452 generated="$generated $gentop"

8453

8454 func_extract_archives $gentop $convenience

8455 reload_conv_objs="$reload_objs $func_extract_archives_result"

8456 fi

8457 fi

8458

8459 # Create the old-style object.

8460 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

8461

8462 output="$obj"

8463 func_execute_cmds "$reload_cmds" 'exit $?'

8464

8465 # Exit if we aren't doing a library object file.

8466 if test -z "$libobj"; then

8467 if test -n "$gentop"; then

8468 func_show_eval '${RM}r "$gentop"'

8469 fi

8470

8471 exit $EXIT_SUCCESS

8472 fi

8473

8474 if test "$build_libtool_libs" != yes; then

8475 if test -n "$gentop"; then

8476 func_show_eval '${RM}r "$gentop"'

8477 fi

8478

8479 # Create an invalid libtool object if no PIC, so that we don't

8480 # accidentally link it into a program.

8481 # $show "echo timestamp > $libobj"

8482 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?

8483 exit $EXIT_SUCCESS

8484 fi

8485

8486 if test -n "$pic_flag" || test "$pic_mode" != default; then

8487 # Only do commands if we really have different PIC objects.

8488 reload_objs="$libobjs $reload_conv_objs"

8489 output="$libobj"

8490 func_execute_cmds "$reload_cmds" 'exit $?'

8491 fi

8492

8493 if test -n "$gentop"; then

8494 func_show_eval '${RM}r "$gentop"'

8495 fi

8496

8497 exit $EXIT_SUCCESS

8498 ;;

8499

8500 prog)

8501 case $host in

8502 *cygwin*) func_stripname '' '.exe' "$output"

8503 output=$func_stripname_result.exe;;

8504 esac

8505 test -n "$vinfo" && \

8506 func_warning "\`-version-info' is ignored for programs"

8507

8508 test -n "$release" && \

8509 func_warning "\`-release' is ignored for programs"

8510

8511 test "$preload" = yes \

8512 && test "$dlopen_support" = unknown \

8513 && test "$dlopen_self" = unknown \

8514 && test "$dlopen_self_static" = unknown && \

8515 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

8516

8517 case $host in

8518 *-*-rhapsody* | *-*-darwin1.[012])

8519 # On Rhapsody replace the C library is the System framework

8520 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

8521 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

8522 ;;

8523 esac

8524

8525 case $host in

8526 *-*-darwin*)

8527 # Don't allow lazy linking, it breaks C++ global constructors

8528 # But is supposedly fixed on 10.4 or later (yay!).

8529 if test "$tagname" = CXX ; then

8530 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

8531 10.[0123])

8532 compile_command="$compile_command ${wl}-bind_at_load"

8533 finalize_command="$finalize_command ${wl}-bind_at_load"

8534 ;;

8535 esac

8536 fi

8537 # Time to change all our "foo.ltframework" stuff back to "-framework foo"

8538 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8539 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8540 ;;

8541 esac

8542

8543

8544 # move library search paths that coincide with paths to not yet

8545 # installed libraries to the beginning of the library search list

8546 new_libs=

8547 for path in $notinst_path; do

8548 case " $new_libs " in

8549 *" -L$path/$objdir "*) ;;

8550 *)

8551 case " $compile_deplibs " in

8552 *" -L$path/$objdir "*)

8553 new_libs="$new_libs -L$path/$objdir" ;;

8554 esac

8555 ;;

8556 esac

8557 done

8558 for deplib in $compile_deplibs; do

8559 case $deplib in

8560 -L*)

8561 case " $new_libs " in

8562 *" $deplib "*) ;;

8563 *) new_libs="$new_libs $deplib" ;;

8564 esac

8565 ;;

8566 *) new_libs="$new_libs $deplib" ;;

8567 esac

8568 done

8569 compile_deplibs="$new_libs"

8570

8571

8572 compile_command="$compile_command $compile_deplibs"

8573 finalize_command="$finalize_command $finalize_deplibs"

8574

8575 if test -n "$rpath$xrpath"; then

8576 # If the user specified any rpath flags, then add them.

8577 for libdir in $rpath $xrpath; do

8578 # This is the magic to use -rpath.

8579 case "$finalize_rpath " in

8580 *" $libdir "*) ;;

8581 *) finalize_rpath="$finalize_rpath $libdir" ;;

8582 esac

8583 done

8584 fi

8585

8586 # Now hardcode the library paths

8587 rpath=

8588 hardcode_libdirs=

8589 for libdir in $compile_rpath $finalize_rpath; do

8590 if test -n "$hardcode_libdir_flag_spec"; then

8591 if test -n "$hardcode_libdir_separator"; then

8592 if test -z "$hardcode_libdirs"; then

8593 hardcode_libdirs="$libdir"

8594 else

8595 # Just accumulate the unique libdirs.

8596 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8597 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8598 ;;

8599 *)

8600 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8601 ;;

8602 esac

8603 fi

8604 else

8605 eval flag=\"$hardcode_libdir_flag_spec\"

8606 rpath="$rpath $flag"

8607 fi

8608 elif test -n "$runpath_var"; then

8609 case "$perm_rpath " in

8610 *" $libdir "*) ;;

8611 *) perm_rpath="$perm_rpath $libdir" ;;

8612 esac

8613 fi

8614 case $host in

8615 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

8616 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`

8617 case :$dllsearchpath: in

8618 *":$libdir:"*) ;;

8619 ::) dllsearchpath=$libdir;;

8620 *) dllsearchpath="$dllsearchpath:$libdir";;

8621 esac

8622 case :$dllsearchpath: in

8623 *":$testbindir:"*) ;;

8624 ::) dllsearchpath=$testbindir;;

8625 *) dllsearchpath="$dllsearchpath:$testbindir";;

8626 esac

8627 ;;

8628 esac

8629 done

8630 # Substitute the hardcoded libdirs into the rpath.

8631 if test -n "$hardcode_libdir_separator" &&

8632 test -n "$hardcode_libdirs"; then

8633 libdir="$hardcode_libdirs"

8634 eval rpath=\" $hardcode_libdir_flag_spec\"

8635 fi

8636 compile_rpath="$rpath"

8637

8638 rpath=

8639 hardcode_libdirs=

8640 for libdir in $finalize_rpath; do

8641 if test -n "$hardcode_libdir_flag_spec"; then

8642 if test -n "$hardcode_libdir_separator"; then

8643 if test -z "$hardcode_libdirs"; then

8644 hardcode_libdirs="$libdir"

8645 else

8646 # Just accumulate the unique libdirs.

8647 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8648 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8649 ;;

8650 *)

8651 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8652 ;;

8653 esac

8654 fi

8655 else

8656 eval flag=\"$hardcode_libdir_flag_spec\"

8657 rpath="$rpath $flag"

8658 fi

8659 elif test -n "$runpath_var"; then

8660 case "$finalize_perm_rpath " in

8661 *" $libdir "*) ;;

8662 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

8663 esac

8664 fi

8665 done

8666 # Substitute the hardcoded libdirs into the rpath.

8667 if test -n "$hardcode_libdir_separator" &&

8668 test -n "$hardcode_libdirs"; then

8669 libdir="$hardcode_libdirs"

8670 eval rpath=\" $hardcode_libdir_flag_spec\"

8671 fi

8672 finalize_rpath="$rpath"

8673

8674 if test -n "$libobjs" && test "$build_old_libs" = yes; then

8675 # Transform all the library objects into standard objects.

8676 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8677 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8678 fi

8679

8680 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

8681

8682 # template prelinking step

8683 if test -n "$prelink_cmds"; then

8684 func_execute_cmds "$prelink_cmds" 'exit $?'

8685 fi

8686

8687 wrappers_required=yes

8688 case $host in

8689 *cegcc* | *mingw32ce*)

8690 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

8691 wrappers_required=no

8692 ;;

8693 *cygwin* | *mingw* )

8694 if test "$build_libtool_libs" != yes; then

8695 wrappers_required=no

8696 fi

8697 ;;

8698 *)

8699 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

8700 wrappers_required=no

8701 fi

8702 ;;

8703 esac

8704 if test "$wrappers_required" = no; then

8705 # Replace the output file specification.

8706 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8707 link_command="$compile_command$compile_rpath"

8708

8709 # We have no uninstalled library dependencies, so finalize right now.

8710 exit_status=0

8711 func_show_eval "$link_command" 'exit_status=$?'

8712

8713 # Delete the generated files.

8714 if test -f "$output_objdir/${outputname}S.${objext}"; then

8715 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

8716 fi

8717

8718 exit $exit_status

8719 fi

8720

8721 if test -n "$compile_shlibpath$finalize_shlibpath"; then

8722 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

8723 fi

8724 if test -n "$finalize_shlibpath"; then

8725 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

8726 fi

8727

8728 compile_var=

8729 finalize_var=

8730 if test -n "$runpath_var"; then

8731 if test -n "$perm_rpath"; then

8732 # We should set the runpath_var.

8733 rpath=

8734 for dir in $perm_rpath; do

8735 rpath="$rpath$dir:"

8736 done

8737 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

8738 fi

8739 if test -n "$finalize_perm_rpath"; then

8740 # We should set the runpath_var.

8741 rpath=

8742 for dir in $finalize_perm_rpath; do

8743 rpath="$rpath$dir:"

8744 done

8745 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

8746 fi

8747 fi

8748

8749 if test "$no_install" = yes; then

8750 # We don't need to create a wrapper script.

8751 link_command="$compile_var$compile_command$compile_rpath"

8752 # Replace the output file specification.

8753 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8754 # Delete the old output file.

8755 $opt_dry_run || $RM $output

8756 # Link the executable and exit

8757 func_show_eval "$link_command" 'exit $?'

8758 exit $EXIT_SUCCESS

8759 fi

8760

8761 if test "$hardcode_action" = relink; then

8762 # Fast installation is not supported

8763 link_command="$compile_var$compile_command$compile_rpath"

8764 relink_command="$finalize_var$finalize_command$finalize_rpath"

8765

8766 func_warning "this platform does not like uninstalled shared libraries"

8767 func_warning "\`$output' will be relinked during installation"

8768 else

8769 if test "$fast_install" != no; then

8770 link_command="$finalize_var$compile_command$finalize_rpath"

8771 if test "$fast_install" = yes; then

8772 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

8773 else

8774 # fast_install is set to needless

8775 relink_command=

8776 fi

8777 else

8778 link_command="$compile_var$compile_command$compile_rpath"

8779 relink_command="$finalize_var$finalize_command$finalize_rpath"

8780 fi

8781 fi

8782

8783 # Replace the output file specification.

8784 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

8785

8786 # Delete the old output files.

8787 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

8788

8789 func_show_eval "$link_command" 'exit $?'

8790

8791 # Now create the wrapper script.

8792 func_verbose "creating $output"

8793

8794 # Quote the relink command for shipping.

8795 if test -n "$relink_command"; then

8796 # Preserve any variables that may affect compiler behavior

8797 for var in $variables_saved_for_relink; do

8798 if eval test -z \"\${$var+set}\"; then

8799 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

8800 elif eval var_value=\$$var; test -z "$var_value"; then

8801 relink_command="$var=; export $var; $relink_command"

8802 else

8803 func_quote_for_eval "$var_value"

8804 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

8805 fi

8806 done

8807 relink_command="(cd `pwd`; $relink_command)"

8808 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

8809 fi

8810

8811 # Only actually do things if not in dry run mode.

8812 $opt_dry_run || {

8813 # win32 will think the script is a binary if it has

8814 # a .exe suffix, so we strip it off here.

8815 case $output in

8816 *.exe) func_stripname '' '.exe' "$output"

8817 output=$func_stripname_result ;;

8818 esac

8819 # test for cygwin because mv fails w/o .exe extensions

8820 case $host in

8821 *cygwin*)

8822 exeext=.exe

8823 func_stripname '' '.exe' "$outputname"

8824 outputname=$func_stripname_result ;;

8825 *) exeext= ;;

8826 esac

8827 case $host in

8828 *cygwin* | *mingw* )

8829 func_dirname_and_basename "$output" "" "."

8830 output_name=$func_basename_result

8831 output_path=$func_dirname_result

8832 cwrappersource="$output_path/$objdir/lt-$output_name.c"

8833 cwrapper="$output_path/$output_name.exe"

8834 $RM $cwrappersource $cwrapper

8835 trap "$RM $cwrappersource $cwrapper $cwrapper.manifest; exit $EXIT_FAILURE" 1 2 15

8836

8837 func_emit_cwrapperexe_src > $cwrappersource

8838

8839 # The wrapper executable is built using the $host compiler,

8840 # because it contains $host paths and files. If cross-

8841 # compiling, it, like the target executable, must be

8842 # executed on the $host or under an emulation environment.

8843 $opt_dry_run || {

8844 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource

8845 $STRIP $cwrapper

8846 }

8847

8848 # Now, create the wrapper script for func_source use:

8849 func_ltwrapper_scriptname $cwrapper

8850 $RM $func_ltwrapper_scriptname_result

8851 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15

8852 $opt_dry_run || {

8853 # note: this script will not be executed, so do not chmod.

8854 if test "x$build" = "x$host" ; then

8855 # Create the UAC manifests first if necessary (but the

8856 # manifest files must have executable permission regardless).

8857 case $output_name in

8858 *instal*|*patch*|*setup*|*update*)

8859 func_emit_exe_manifest > $cwrapper.manifest

8860 func_emit_exe_manifest > $output_path/$objdir/$output_name.exe.manifest

8861 chmod +x $cwrapper.manifest

8862 chmod +x $output_path/$objdir/$output_name.exe.manifest

8863 ;;

8864 esac

8865 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result

8866 else

8867 func_emit_wrapper no > $func_ltwrapper_scriptname_result

8868 fi

8869 }

8870 ;;

8871 * )

8872 $RM $output

8873 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

8874

8875 func_emit_wrapper no > $output

8876 chmod +x $output

8877 ;;

8878 esac

8879 }

8880 exit $EXIT_SUCCESS

8881 ;;

8882 esac

8883

8884 # See if we need to build an old-fashioned archive.

8885 for oldlib in $oldlibs; do

8886

8887 if test "$build_libtool_libs" = convenience; then

8888 oldobjs="$libobjs_save $symfileobj"

8889 addlibs="$convenience"

8890 build_libtool_libs=no

8891 else

8892 if test "$build_libtool_libs" = module; then

8893 oldobjs="$libobjs_save"

8894 build_libtool_libs=no

8895 else

8896 oldobjs="$old_deplibs $non_pic_objects"

8897 if test "$preload" = yes && test -f "$symfileobj"; then

8898 oldobjs="$oldobjs $symfileobj"

8899 fi

8900 fi

8901 addlibs="$old_convenience"

8902 fi

8903

8904 if test -n "$addlibs"; then

8905 gentop="$output_objdir/${outputname}x"

8906 generated="$generated $gentop"

8907

8908 func_extract_archives $gentop $addlibs

8909 oldobjs="$oldobjs $func_extract_archives_result"

8910 fi

8911

8912 # Do each command in the archive commands.

8913 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

8914 cmds=$old_archive_from_new_cmds

8915 else

8916

8917 # Add any objects from preloaded convenience libraries

8918 if test -n "$dlprefiles"; then

8919 gentop="$output_objdir/${outputname}x"

8920 generated="$generated $gentop"

8921

8922 func_extract_archives $gentop $dlprefiles

8923 oldobjs="$oldobjs $func_extract_archives_result"

8924 fi

8925

8926 # POSIX demands no paths to be encoded in archives. We have

8927 # to avoid creating archives with duplicate basenames if we

8928 # might have to extract them afterwards, e.g., when creating a

8929 # static archive out of a convenience library, or when linking

8930 # the entirety of a libtool archive into another (currently

8931 # not supported by libtool).

8932 if (for obj in $oldobjs

8933 do

8934 func_basename "$obj"

8935 $ECHO "$func_basename_result"

8936 done | sort | sort -uc >/dev/null 2>&1); then

8937 :

8938 else

8939 echo "copying selected object files to avoid basename conflicts..."

8940 gentop="$output_objdir/${outputname}x"

8941 generated="$generated $gentop"

8942 func_mkdir_p "$gentop"

8943 save_oldobjs=$oldobjs

8944 oldobjs=

8945 counter=1

8946 for obj in $save_oldobjs

8947 do

8948 func_basename "$obj"

8949 objbase="$func_basename_result"

8950 case " $oldobjs " in

8951 " ") oldobjs=$obj ;;

8952 *[\ /]"$objbase "*)

8953 while :; do

8954 # Make sure we don't pick an alternate name that also

8955 # overlaps.

8956 newobj=lt$counter-$objbase

8957 func_arith $counter + 1

8958 counter=$func_arith_result

8959 case " $oldobjs " in

8960 *[\ /]"$newobj "*) ;;

8961 *) if test ! -f "$gentop/$newobj"; then break; fi ;;

8962 esac

8963 done

8964 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

8965 oldobjs="$oldobjs $gentop/$newobj"

8966 ;;

8967 *) oldobjs="$oldobjs $obj" ;;

8968 esac

8969 done

8970 fi

8971 eval cmds=\"$old_archive_cmds\"

8972

8973 func_len " $cmds"

8974 len=$func_len_result

8975 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8976 cmds=$old_archive_cmds

8977 else

8978 # the command line is too long to link in one step, link in parts

8979 func_verbose "using piecewise archive linking..."

8980 save_RANLIB=$RANLIB

8981 RANLIB=:

8982 objlist=

8983 concat_cmds=

8984 save_oldobjs=$oldobjs

8985 oldobjs=

8986 # Is there a better way of finding the last object in the list?

8987 for obj in $save_oldobjs

8988 do

8989 last_oldobj=$obj

8990 done

8991 eval test_cmds=\"$old_archive_cmds\"

8992 func_len " $test_cmds"

8993 len0=$func_len_result

8994 len=$len0

8995 for obj in $save_oldobjs

8996 do

8997 func_len " $obj"

8998 func_arith $len + $func_len_result

8999 len=$func_arith_result

9000 func_append objlist " $obj"

9001 if test "$len" -lt "$max_cmd_len"; then

9002 :

9003 else

9004 # the above command should be used before it gets too long

9005 oldobjs=$objlist

9006 if test "$obj" = "$last_oldobj" ; then

9007 RANLIB=$save_RANLIB

9008 fi

9009 test -z "$concat_cmds" || concat_cmds=$concat_cmds~

9010 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

9011 objlist=

9012 len=$len0

9013 fi

9014 done

9015 RANLIB=$save_RANLIB

9016 oldobjs=$objlist

9017 if test "X$oldobjs" = "X" ; then

9018 eval cmds=\"\$concat_cmds\"

9019 else

9020 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

9021 fi

9022 fi

9023 fi

9024 func_execute_cmds "$cmds" 'exit $?'

9025 done

9026

9027 test -n "$generated" && \

9028 func_show_eval "${RM}r$generated"

9029

9030 # Now create the libtool archive.

9031 case $output in

9032 *.la)

9033 old_library=

9034 test "$build_old_libs" = yes && old_library="$libname.$libext"

9035 func_verbose "creating $output"

9036

9037 # Preserve any variables that may affect compiler behavior

9038 for var in $variables_saved_for_relink; do

9039 if eval test -z \"\${$var+set}\"; then

9040 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9041 elif eval var_value=\$$var; test -z "$var_value"; then

9042 relink_command="$var=; export $var; $relink_command"

9043 else

9044 func_quote_for_eval "$var_value"

9045 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9046 fi

9047 done

9048 # Quote the link command for shipping.

9049 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

9050 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9051 if test "$hardcode_automatic" = yes ; then

9052 relink_command=

9053 fi

9054

9055 # Only create the output if not a dry run.

9056 $opt_dry_run || {

9057 for installed in no yes; do

9058 if test "$installed" = yes; then

9059 if test -z "$install_libdir"; then

9060 break

9061 fi

9062 output="$output_objdir/$outputname"i

9063 # Replace all uninstalled libtool libraries with the installed ones

9064 newdependency_libs=

9065 for deplib in $dependency_libs; do

9066 case $deplib in

9067 *.la)

9068 func_basename "$deplib"

9069 name="$func_basename_result"

9070 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

9071 test -z "$libdir" && \

9072 func_fatal_error "\`$deplib' is not a valid libtool archive"

9073 newdependency_libs="$newdependency_libs $libdir/$name"

9074 ;;

9075 *) newdependency_libs="$newdependency_libs $deplib" ;;

9076 esac

9077 done

9078 dependency_libs="$newdependency_libs"

9079 newdlfiles=

9080

9081 for lib in $dlfiles; do

9082 case $lib in

9083 *.la)

9084 func_basename "$lib"

9085 name="$func_basename_result"

9086 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9087 test -z "$libdir" && \

9088 func_fatal_error "\`$lib' is not a valid libtool archive"

9089 newdlfiles="$newdlfiles $libdir/$name"

9090 ;;

9091 *) newdlfiles="$newdlfiles $lib" ;;

9092 esac

9093 done

9094 dlfiles="$newdlfiles"

9095 newdlprefiles=

9096 for lib in $dlprefiles; do

9097 case $lib in

9098 *.la)

9099 # Only pass preopened files to the pseudo-archive (for

9100 # eventual linking with the app. that links it) if we

9101 # didn't already link the preopened objects directly into

9102 # the library:

9103 func_basename "$lib"

9104 name="$func_basename_result"

9105 eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9106 test -z "$libdir" && \

9107 func_fatal_error "\`$lib' is not a valid libtool archive"

9108 newdlprefiles="$newdlprefiles $libdir/$name"

9109 ;;

9110 esac

9111 done

9112 dlprefiles="$newdlprefiles"

9113 else

9114 newdlfiles=

9115 for lib in $dlfiles; do

9116 case $lib in

9117 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9118 *) abs=`pwd`"/$lib" ;;

9119 esac

9120 newdlfiles="$newdlfiles $abs"

9121 done

9122 dlfiles="$newdlfiles"

9123 newdlprefiles=

9124 for lib in $dlprefiles; do

9125 case $lib in

9126 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9127 *) abs=`pwd`"/$lib" ;;

9128 esac

9129 newdlprefiles="$newdlprefiles $abs"

9130 done

9131 dlprefiles="$newdlprefiles"

9132 fi

9133 $RM $output

9134 # place dlname in correct position for cygwin

9135 # In fact, it would be nice if we could use this code for all target

9136 # systems that can't hard-code library paths into their executables

9137 # and that have no shared library path variable independent of PATH,

9138 # but it turns out we can't easily determine that from inspecting

9139 # libtool variables, so we have to hard-code the OSs to which it

9140 # applies here; at the moment, that means platforms that use the PE

9141 # object format with DLL files. See the long comment at the top of

9142 # tests/bindir.at for full details.

9143 tdlname=$dlname

9144 case $host,$output,$installed,$module,$dlname in

9145 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9146 # If a -bindir argument was supplied, place the dll there.

9147 if test "x$bindir" != x ;

9148 then

9149 func_relative_path "$install_libdir" "$bindir"

9150 tdlname=$func_relative_path_result$dlname

9151 else

9152 # Otherwise fall back on heuristic.

9153 tdlname=../bin/$dlname

9154 fi

9155 ;;

9156 esac

9157 $ECHO > $output "\

9158 # $outputname - a libtool library file

9159 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

9160 #

9161 # Please DO NOT delete this file!

9162 # It is necessary for linking the library.

9163

9164 # The name that we can dlopen(3).

9165 dlname='$tdlname'

9166

9167 # Names of this library.

9168 library_names='$library_names'

9169

9170 # The name of the static archive.

9171 old_library='$old_library'

9172

9173 # Linker flags that can not go in dependency_libs.

9174 inherited_linker_flags='$new_inherited_linker_flags'

9175

9176 # Libraries that this one depends upon.

9177 dependency_libs='$dependency_libs'

9178

9179 # Names of additional weak libraries provided by this library

9180 weak_library_names='$weak_libs'

9181

9182 # Version information for $libname.

9183 current=$current

9184 age=$age

9185 revision=$revision

9186

9187 # Is this an already installed library?

9188 installed=$installed

9189

9190 # Should we warn about portability when linking against -modules?

9191 shouldnotlink=$module

9192

9193 # Files to dlopen/dlpreopen

9194 dlopen='$dlfiles'

9195 dlpreopen='$dlprefiles'

9196

9197 # Directory that this library needs to be installed in:

9198 libdir='$install_libdir'"

9199 if test "$installed" = no && test "$need_relink" = yes; then

9200 $ECHO >> $output "\

9201 relink_command=\"$relink_command\""

9202 fi

9203 done

9204 }

9205

9206 # Do a symbolic link so that the libtool archive can be found in

9207 # LD_LIBRARY_PATH before the program is installed.

9208 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'

9209 ;;

9210 esac

9211 exit $EXIT_SUCCESS

9212 }

9213

9214 { test "$mode" = link || test "$mode" = relink; } &&

9215 func_mode_link ${1+"$@"}

9216

9217

9218 # func_mode_uninstall arg...

9219 func_mode_uninstall ()

9220 {

9221 $opt_debug

9222 RM="$nonopt"

9223 files=

9224 rmforce=

9225 exit_status=0

9226

9227 # This variable tells wrapper scripts just to set variables rather

9228 # than running their programs.

9229 libtool_install_magic="$magic"

9230

9231 for arg

9232 do

9233 case $arg in

9234 -f) RM="$RM $arg"; rmforce=yes ;;

9235 -*) RM="$RM $arg" ;;

9236 *) files="$files $arg" ;;

9237 esac

9238 done

9239

9240 test -z "$RM" && \

9241 func_fatal_help "you must specify an RM program"

9242

9243 rmdirs=

9244

9245 origobjdir="$objdir"

9246 for file in $files; do

9247 func_dirname "$file" "" "."

9248 dir="$func_dirname_result"

9249 if test "X$dir" = X.; then

9250 objdir="$origobjdir"

9251 else

9252 objdir="$dir/$origobjdir"

9253 fi

9254 func_basename "$file"

9255 name="$func_basename_result"

9256 test "$mode" = uninstall && objdir="$dir"

9257

9258 # Remember objdir for removal later, being careful to avoid duplicates

9259 if test "$mode" = clean; then

9260 case " $rmdirs " in

9261 *" $objdir "*) ;;

9262 *) rmdirs="$rmdirs $objdir" ;;

9263 esac

9264 fi

9265

9266 # Don't error if the file doesn't exist and rm -f was used.

9267 if { test -L "$file"; } >/dev/null 2>&1 ||

9268 { test -h "$file"; } >/dev/null 2>&1 ||

9269 test -f "$file"; then

9270 :

9271 elif test -d "$file"; then

9272 exit_status=1

9273 continue

9274 elif test "$rmforce" = yes; then

9275 continue

9276 fi

9277

9278 rmfiles="$file"

9279

9280 case $name in

9281 *.la)

9282 # Possibly a libtool archive, so verify it.

9283 if func_lalib_p "$file"; then

9284 func_source $dir/$name

9285

9286 # Delete the libtool libraries and symlinks.

9287 for n in $library_names; do

9288 rmfiles="$rmfiles $objdir/$n"

9289 done

9290 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

9291

9292 case "$mode" in

9293 clean)

9294 case " $library_names " in

9295 # " " in the beginning catches empty $dlname

9296 *" $dlname "*) ;;

9297 *) rmfiles="$rmfiles $objdir/$dlname" ;;

9298 esac

9299 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

9300 ;;

9301 uninstall)

9302 if test -n "$library_names"; then

9303 # Do each command in the postuninstall commands.

9304 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9305 fi

9306

9307 if test -n "$old_library"; then

9308 # Do each command in the old_postuninstall commands.

9309 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9310 fi

9311 # FIXME: should reinstall the best remaining shared library.

9312 ;;

9313 esac

9314 fi

9315 ;;

9316

9317 *.lo)

9318 # Possibly a libtool object, so verify it.

9319 if func_lalib_p "$file"; then

9320

9321 # Read the .lo file

9322 func_source $dir/$name

9323

9324 # Add PIC object to the list of files to remove.

9325 if test -n "$pic_object" &&

9326 test "$pic_object" != none; then

9327 rmfiles="$rmfiles $dir/$pic_object"

9328 fi

9329

9330 # Add non-PIC object to the list of files to remove.

9331 if test -n "$non_pic_object" &&

9332 test "$non_pic_object" != none; then

9333 rmfiles="$rmfiles $dir/$non_pic_object"

9334 fi

9335 fi

9336 ;;

9337

9338 *)

9339 if test "$mode" = clean ; then

9340 noexename=$name

9341 case $file in

9342 *.exe)

9343 func_stripname '' '.exe' "$file"

9344 file=$func_stripname_result

9345 func_stripname '' '.exe' "$name"

9346 noexename=$func_stripname_result

9347 # $file with .exe has already been added to rmfiles,

9348 # add $file without .exe

9349 rmfiles="$rmfiles $file"

9350 ;;

9351 esac

9352 # Do a test to see if this is a libtool program.

9353 if func_ltwrapper_p "$file"; then

9354 if func_ltwrapper_executable_p "$file"; then

9355 func_ltwrapper_scriptname "$file"

9356 relink_command=

9357 func_source $func_ltwrapper_scriptname_result

9358 rmfiles="$rmfiles $func_ltwrapper_scriptname_result"

9359 else

9360 relink_command=

9361 func_source $dir/$noexename

9362 fi

9363

9364 # note $name still contains .exe if it was in $file originally

9365 # as does the version of $file that was added into $rmfiles

9366 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

9367 rmfiles="$rmfiles ${name}.manifest $objdir/${name}.manifest"

9368 if test "$fast_install" = yes && test -n "$relink_command"; then

9369 rmfiles="$rmfiles $objdir/lt-$name $objdir/lt-${name}.manifest"

9370 fi

9371 if test "X$noexename" != "X$name" ; then

9372 rmfiles="$rmfiles $objdir/lt-${noexename}.c"

9373 fi

9374 fi

9375 fi

9376 ;;

9377 esac

9378 func_show_eval "$RM $rmfiles" 'exit_status=1'

9379 done

9380 objdir="$origobjdir"

9381

9382 # Try to remove the ${objdir}s in the directories where we deleted files

9383 for dir in $rmdirs; do

9384 if test -d "$dir"; then

9385 func_show_eval "rmdir $dir >/dev/null 2>&1"

9386 fi

9387 done

9388

9389 exit $exit_status

9390 }

9391

9392 { test "$mode" = uninstall || test "$mode" = clean; } &&

9393 func_mode_uninstall ${1+"$@"}

9394

9395 test -z "$mode" && {

9396 help="$generic_help"

9397 func_fatal_help "you must specify a MODE"

9398 }

9399

9400 test -z "$exec_cmd" && \

9401 func_fatal_help "invalid operation mode \`$mode'"

9402

9403 if test -n "$exec_cmd"; then

9404 eval exec "$exec_cmd"

9405 exit $EXIT_FAILURE

9406 fi

9407

9408 exit $exit_status

9409

9410

9411 # The TAGs below are defined such that we never get into a situation

9412 # in which we disable both kinds of libraries. Given conflicting

9413 # choices, we go for a static library, that is the most portable,

9414 # since we can't tell whether shared libraries were disabled because

9415 # the user asked for that or because the platform doesn't support

9416 # them. This is particularly important on AIX, because we don't

9417 # support having both static and shared libraries enabled at the same

9418 # time on that platform, so we default to a shared-only configuration.

9419 # If a disable-shared tag is given, we'll fallback to a static-only

9420 # configuration. But we'll never go from static-only to shared-only.

9421

9422 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared

9423 build_libtool_libs=no

9424 build_old_libs=yes

9425 # ### END LIBTOOL TAG CONFIG: disable-shared

9426

9427 # ### BEGIN LIBTOOL TAG CONFIG: disable-static

9428 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

9429 # ### END LIBTOOL TAG CONFIG: disable-static

9430

9431 # Local Variables:

9432 # mode:shell-script

9433 # sh-indentation:2

9434 # End:

9435 # vi:sw=2

9436