OSDN Git Service

save font name to ~/.kp123
[kp123/kp123.git] / libtool
1 #! /bin/bash
2
3 # libtool - Provide generalized library-building support services.
4 # Generated automatically by config.status (kp123) 0.1
5 # Libtool was configured on host noname:
6 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
7 #
8 #   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
9 #                 2006, 2007, 2008, 2009, 2010 Free Software Foundation,
10 #                 Inc.
11 #   Written by Gordon Matzigkeit, 1996
12 #
13 #   This file is part of GNU Libtool.
14 #
15 # GNU Libtool is free software; you can redistribute it and/or
16 # modify it under the terms of the GNU General Public License as
17 # published by the Free Software Foundation; either version 2 of
18 # the License, or (at your option) any later version.
19 #
20 # As a special exception to the GNU General Public License,
21 # if you distribute this file as part of a program or library that
22 # is built using GNU Libtool, you may include this file under the
23 # same distribution terms that you use for the rest of that program.
24 #
25 # GNU Libtool is distributed in the hope that it will be useful,
26 # but WITHOUT ANY WARRANTY; without even the implied warranty of
27 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28 # GNU General Public License for more details.
29 #
30 # You should have received a copy of the GNU General Public License
31 # along with GNU Libtool; see the file COPYING.  If not, a copy
32 # can be downloaded from http://www.gnu.org/licenses/gpl.html, or
33 # obtained by writing to the Free Software Foundation, Inc.,
34 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
35
36
37 # The names of the tagged configurations supported by this script.
38 available_tags=""
39
40 # ### BEGIN LIBTOOL CONFIG
41
42 # Which release of libtool.m4 was used?
43 macro_version=2.2.10
44 macro_revision=1.3175
45
46 # Whether or not to build shared libraries.
47 build_libtool_libs=yes
48
49 # Whether or not to build static libraries.
50 build_old_libs=yes
51
52 # What type of objects to build.
53 pic_mode=default
54
55 # Whether or not to optimize for fast installation.
56 fast_install=yes
57
58 # Shell to use when invoking shell scripts.
59 SHELL="/bin/bash"
60
61 # An echo program that protects backslashes.
62 ECHO="printf %s\\n"
63
64 # The host system.
65 host_alias=
66 host=i686-pc-linux-gnu
67 host_os=linux-gnu
68
69 # The build system.
70 build_alias=
71 build=i686-pc-linux-gnu
72 build_os=linux-gnu
73
74 # A sed program that does not truncate output.
75 SED="/bin/sed"
76
77 # Sed that helps us avoid accidentally triggering echo(1) options like -n.
78 Xsed="$SED -e 1s/^X//"
79
80 # A grep program that handles long lines.
81 GREP="/bin/grep"
82
83 # An ERE matcher.
84 EGREP="/bin/grep -E"
85
86 # A literal string matcher.
87 FGREP="/bin/grep -F"
88
89 # A BSD- or MS-compatible name lister.
90 NM="/usr/bin/nm -B"
91
92 # Whether we need soft or hard links.
93 LN_S="ln -s"
94
95 # What is the maximum length of a command?
96 max_cmd_len=805306365
97
98 # Object file suffix (normally "o").
99 objext=o
100
101 # Executable file suffix (normally "").
102 exeext=
103
104 # whether the shell understands "unset".
105 lt_unset=unset
106
107 # turn spaces into newlines.
108 SP2NL="tr \\040 \\012"
109
110 # turn newlines into spaces.
111 NL2SP="tr \\015\\012 \\040\\040"
112
113 # An object symbol dumper.
114 OBJDUMP="objdump"
115
116 # Method to check whether dependent libraries are shared objects.
117 deplibs_check_method="pass_all"
118
119 # Command to use when deplibs_check_method == "file_magic".
120 file_magic_cmd="\$MAGIC_CMD"
121
122 # The archiver.
123 AR="ar"
124 AR_FLAGS="cru"
125
126 # A symbol stripping program.
127 STRIP="strip"
128
129 # Commands used to install an old-style archive.
130 RANLIB="ranlib"
131 old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
132 old_postuninstall_cmds=""
133
134 # Whether to use a lock for old archive extraction.
135 lock_old_archive_extraction=no
136
137 # A C compiler.
138 LTCC="gcc"
139
140 # LTCC compiler flags.
141 LTCFLAGS="-gstabs -O0"
142
143 # Take the output of nm and produce a listing of raw symbols and C names.
144 global_symbol_pipe="sed -n -e 's/^.*[    ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[       ][      ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"
145
146 # Transform the output of nm in a proper C declaration.
147 global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
148
149 # Transform the output of nm in a C name address pair.
150 global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p'"
151
152 # Transform the output of nm in a C name address pair when lib prefix is needed.
153 global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"lib\\2\", (void *) \\&\\2},/p'"
154
155 # The name of the directory that contains temporary libtool files.
156 objdir=.libs
157
158 # Used to examine libraries when file_magic_cmd begins with "file".
159 MAGIC_CMD=file
160
161 # Must we lock files when doing compilation?
162 need_locks="no"
163
164 # Tool to manipulate archived DWARF debug symbol files on Mac OS X.
165 DSYMUTIL=""
166
167 # Tool to change global to local symbols on Mac OS X.
168 NMEDIT=""
169
170 # Tool to manipulate fat objects and archives on Mac OS X.
171 LIPO=""
172
173 # ldd/readelf like tool for Mach-O binaries on Mac OS X.
174 OTOOL=""
175
176 # ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
177 OTOOL64=""
178
179 # Old archive suffix (normally "a").
180 libext=a
181
182 # Shared library suffix (normally ".so").
183 shrext_cmds=".so"
184
185 # The commands to extract the exported symbol list from a shared archive.
186 extract_expsyms_cmds=""
187
188 # Variables whose values should be saved in libtool wrapper scripts and
189 # restored at link time.
190 variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
191
192 # Do we need the "lib" prefix for modules?
193 need_lib_prefix=no
194
195 # Do we need a version for libraries?
196 need_version=no
197
198 # Library versioning type.
199 version_type=linux
200
201 # Shared library runtime path variable.
202 runpath_var=LD_RUN_PATH
203
204 # Shared library path variable.
205 shlibpath_var=LD_LIBRARY_PATH
206
207 # Is shlibpath searched before the hard-coded library search path?
208 shlibpath_overrides_runpath=no
209
210 # Format of library name prefix.
211 libname_spec="lib\$name"
212
213 # List of archive names.  First name is the real one, the rest are links.
214 # The last name is the one that the linker finds with -lNAME
215 library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"
216
217 # The coded name of the library, if different from the real name.
218 soname_spec="\${libname}\${release}\${shared_ext}\$major"
219
220 # Permission mode override for installation of shared libraries.
221 install_override_mode=""
222
223 # Command to use after installation of a shared archive.
224 postinstall_cmds=""
225
226 # Command to use after uninstallation of a shared archive.
227 postuninstall_cmds=""
228
229 # Commands used to finish a libtool library installation in a directory.
230 finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
231
232 # As "finish_cmds", except a single script fragment to be evaled but
233 # not shown.
234 finish_eval=""
235
236 # Whether we should hardcode library paths into libraries.
237 hardcode_into_libs=yes
238
239 # Compile-time system search path for libraries.
240 sys_lib_search_path_spec="/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5.2 /usr/lib/i386-linux-gnu /lib /usr/lib "
241
242 # Run-time system search path for libraries.
243 sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/mesa /lib/i386-linux-gnu /usr/lib/i386-linux-gnu /lib/i686-linux-gnu /usr/lib/i686-linux-gnu /usr/lib/alsa-lib /usr/local/lib "
244
245 # Whether dlopen is supported.
246 dlopen_support=unknown
247
248 # Whether dlopen of programs is supported.
249 dlopen_self=unknown
250
251 # Whether dlopen of statically linked programs is supported.
252 dlopen_self_static=unknown
253
254 # Commands to strip libraries.
255 old_striplib="strip --strip-debug"
256 striplib="strip --strip-unneeded"
257
258
259 # The linker used to build libraries.
260 LD="/usr/bin/ld"
261
262 # How to create reloadable object files.
263 reload_flag=" -r"
264 reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
265
266 # Commands used to build an old-style archive.
267 old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
268
269 # A language specific compiler.
270 CC="gcc"
271
272 # Is the compiler the GNU compiler?
273 with_gcc=yes
274
275 # Compiler flag to turn off builtin functions.
276 no_builtin_flag=" -fno-builtin"
277
278 # How to pass a linker flag through the compiler.
279 wl="-Wl,"
280
281 # Additional compiler flags for building library objects.
282 pic_flag=" -fPIC -DPIC"
283
284 # Compiler flag to prevent dynamic linking.
285 link_static_flag="-static"
286
287 # Does compiler simultaneously support -c and -o options?
288 compiler_c_o="yes"
289
290 # Whether or not to add -lc for building shared libraries.
291 build_libtool_need_lc=no
292
293 # Whether or not to disallow shared libs when runtime libs are static.
294 allow_libtool_libs_with_static_runtimes=no
295
296 # Compiler flag to allow reflexive dlopens.
297 export_dynamic_flag_spec="\${wl}--export-dynamic"
298
299 # Compiler flag to generate shared objects directly from archives.
300 whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
301
302 # Whether the compiler copes with passing no objects directly.
303 compiler_needs_object="no"
304
305 # Create an old-style archive from a shared archive.
306 old_archive_from_new_cmds=""
307
308 # Create a temporary old-style archive to link instead of a shared archive.
309 old_archive_from_expsyms_cmds=""
310
311 # Commands used to build a shared archive.
312 archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
313 archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
314             cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
315             echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
316             \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"
317
318 # Commands used to build a loadable module if different from building
319 # a shared archive.
320 module_cmds=""
321 module_expsym_cmds=""
322
323 # Whether we are building with GNU ld or not.
324 with_gnu_ld="yes"
325
326 # Flag that allows shared libraries with undefined symbols to be built.
327 allow_undefined_flag=""
328
329 # Flag that enforces no undefined symbols.
330 no_undefined_flag=""
331
332 # Flag to hardcode $libdir into a binary during linking.
333 # This must work even if $libdir does not exist
334 hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"
335
336 # If ld is used when linking, flag to hardcode $libdir into a binary
337 # during linking.  This must work even if $libdir does not exist.
338 hardcode_libdir_flag_spec_ld=""
339
340 # Whether we need a single "-rpath" flag with a separated argument.
341 hardcode_libdir_separator=""
342
343 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
344 # DIR into the resulting binary.
345 hardcode_direct=no
346
347 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
348 # DIR into the resulting binary and the resulting library dependency is
349 # "absolute",i.e impossible to change by setting ${shlibpath_var} if the
350 # library is relocated.
351 hardcode_direct_absolute=no
352
353 # Set to "yes" if using the -LDIR flag during linking hardcodes DIR
354 # into the resulting binary.
355 hardcode_minus_L=no
356
357 # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
358 # into the resulting binary.
359 hardcode_shlibpath_var=unsupported
360
361 # Set to "yes" if building a shared library automatically hardcodes DIR
362 # into the library and all subsequent libraries and executables linked
363 # against it.
364 hardcode_automatic=no
365
366 # Set to yes if linker adds runtime paths of dependent libraries
367 # to runtime path list.
368 inherit_rpath=no
369
370 # Whether libtool must link a program against all its dependency libraries.
371 link_all_deplibs=unknown
372
373 # Fix the shell variable $srcfile for the compiler.
374 fix_srcfile_path=""
375
376 # Set to "yes" if exported symbols are required.
377 always_export_symbols=no
378
379 # The commands to list exported symbols.
380 export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
381
382 # Symbols that should not be listed in the preloaded symbols.
383 exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
384
385 # Symbols that must always be exported.
386 include_expsyms=""
387
388 # Commands necessary for linking programs (against libraries) with templates.
389 prelink_cmds=""
390
391 # Specify filename containing input files.
392 file_list_spec=""
393
394 # How to hardcode a shared library path into an executable.
395 hardcode_action=immediate
396
397 # ### END LIBTOOL CONFIG
398
399 # Generated from ltmain.m4sh.
400
401 # libtool (GNU libtool) 2.2.10
402 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
403
404 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
405 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
406 # This is free software; see the source for copying conditions.  There is NO
407 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
408
409 # GNU Libtool is free software; you can redistribute it and/or modify
410 # it under the terms of the GNU General Public License as published by
411 # the Free Software Foundation; either version 2 of the License, or
412 # (at your option) any later version.
413 #
414 # As a special exception to the GNU General Public License,
415 # if you distribute this file as part of a program or library that
416 # is built using GNU Libtool, you may include this file under the
417 # same distribution terms that you use for the rest of that program.
418 #
419 # GNU Libtool is distributed in the hope that it will be useful, but
420 # WITHOUT ANY WARRANTY; without even the implied warranty of
421 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
422 # General Public License for more details.
423 #
424 # You should have received a copy of the GNU General Public License
425 # along with GNU Libtool; see the file COPYING.  If not, a copy
426 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
427 # or obtained by writing to the Free Software Foundation, Inc.,
428 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
429
430 # Usage: $progname [OPTION]... [MODE-ARG]...
431 #
432 # Provide generalized library-building support services.
433 #
434 #       --config             show all configuration variables
435 #       --debug              enable verbose shell tracing
436 #   -n, --dry-run            display commands without modifying any files
437 #       --features           display basic configuration information and exit
438 #       --mode=MODE          use operation mode MODE
439 #       --preserve-dup-deps  don't remove duplicate dependency libraries
440 #       --quiet, --silent    don't print informational messages
441 #       --no-quiet, --no-silent
442 #                            print informational messages (default)
443 #       --tag=TAG            use configuration variables from tag TAG
444 #   -v, --verbose            print more informational messages than default
445 #       --no-verbose         don't print the extra informational messages
446 #       --version            print version information
447 #   -h, --help, --help-all   print short, long, or detailed help message
448 #
449 # MODE must be one of the following:
450 #
451 #         clean              remove files from the build directory
452 #         compile            compile a source file into a libtool object
453 #         execute            automatically set library path, then run a program
454 #         finish             complete the installation of libtool libraries
455 #         install            install libraries or executables
456 #         link               create a library or an executable
457 #         uninstall          remove libraries from an installed directory
458 #
459 # MODE-ARGS vary depending on the MODE.  When passed as first option,
460 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
461 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
462 #
463 # When reporting a bug, please describe a test case to reproduce it and
464 # include the following information:
465 #
466 #         host-triplet: $host
467 #         shell:                $SHELL
468 #         compiler:             $LTCC
469 #         compiler flags:               $LTCFLAGS
470 #         linker:               $LD (gnu? $with_gnu_ld)
471 #         $progname:    (GNU libtool) 2.2.10
472 #         automake:     $automake_version
473 #         autoconf:     $autoconf_version
474 #
475 # Report bugs to <bug-libtool@gnu.org>.
476
477 PROGRAM=libtool
478 PACKAGE=libtool
479 VERSION=2.2.10
480 TIMESTAMP=""
481 package_revision=1.3175
482
483 # Be Bourne compatible
484 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
485   emulate sh
486   NULLCMD=:
487   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
488   # is contrary to our usage.  Disable this feature.
489   alias -g '${1+"$@"}'='"$@"'
490   setopt NO_GLOB_SUBST
491 else
492   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
493 fi
494 BIN_SH=xpg4; export BIN_SH # for Tru64
495 DUALCASE=1; export DUALCASE # for MKS sh
496
497 # A function that is used when there is no print builtin or printf.
498 func_fallback_echo ()
499 {
500   eval 'cat <<_LTECHO_EOF
501 $1
502 _LTECHO_EOF'
503 }
504
505 # NLS nuisances: We save the old values to restore during execute mode.
506 lt_user_locale=
507 lt_safe_locale=
508 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
509 do
510   eval "if test \"\${$lt_var+set}\" = set; then
511           save_$lt_var=\$$lt_var
512           $lt_var=C
513           export $lt_var
514           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
515           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
516         fi"
517 done
518 LC_ALL=C
519 LANGUAGE=C
520 export LANGUAGE LC_ALL
521
522 $lt_unset CDPATH
523
524
525 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
526 # is ksh but when the shell is invoked as "sh" and the current value of
527 # the _XPG environment variable is not equal to 1 (one), the special
528 # positional parameter $0, within a function call, is the name of the
529 # function.
530 progpath="$0"
531
532
533
534 : ${CP="cp -f"}
535 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
536 : ${EGREP="grep -E"}
537 : ${FGREP="grep -F"}
538 : ${GREP="grep"}
539 : ${LN_S="ln -s"}
540 : ${MAKE="make"}
541 : ${MKDIR="mkdir"}
542 : ${MV="mv -f"}
543 : ${RM="rm -f"}
544 : ${SED="sed"}
545 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
546 : ${Xsed="$SED -e 1s/^X//"}
547
548 # Global variables:
549 EXIT_SUCCESS=0
550 EXIT_FAILURE=1
551 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
552 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
553
554 exit_status=$EXIT_SUCCESS
555
556 # Make sure IFS has a sensible default
557 lt_nl='
558 '
559 IFS="   $lt_nl"
560
561 dirname="s,/[^/]*$,,"
562 basename="s,^.*/,,"
563
564 # func_dirname_and_basename file append nondir_replacement
565 # perform func_basename and func_dirname in a single function
566 # call:
567 #   dirname:  Compute the dirname of FILE.  If nonempty,
568 #             add APPEND to the result, otherwise set result
569 #             to NONDIR_REPLACEMENT.
570 #             value returned in "$func_dirname_result"
571 #   basename: Compute filename of FILE.
572 #             value retuned in "$func_basename_result"
573 # Implementation must be kept synchronized with func_dirname
574 # and func_basename. For efficiency, we do not delegate to
575 # those functions but instead duplicate the functionality here.
576 func_dirname_and_basename ()
577 {
578   # Extract subdirectory from the argument.
579   func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
580   if test "X$func_dirname_result" = "X${1}"; then
581     func_dirname_result="${3}"
582   else
583     func_dirname_result="$func_dirname_result${2}"
584   fi
585   func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
586 }
587
588 # Generated shell functions inserted here.
589
590 # func_dirname file append nondir_replacement
591 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
592 # otherwise set result to NONDIR_REPLACEMENT.
593 func_dirname ()
594 {
595   case ${1} in
596     */*) func_dirname_result="${1%/*}${2}" ;;
597     *  ) func_dirname_result="${3}" ;;
598   esac
599 }
600
601 # func_basename file
602 func_basename ()
603 {
604   func_basename_result="${1##*/}"
605 }
606
607 # func_dirname_and_basename file append nondir_replacement
608 # perform func_basename and func_dirname in a single function
609 # call:
610 #   dirname:  Compute the dirname of FILE.  If nonempty,
611 #             add APPEND to the result, otherwise set result
612 #             to NONDIR_REPLACEMENT.
613 #             value returned in "$func_dirname_result"
614 #   basename: Compute filename of FILE.
615 #             value retuned in "$func_basename_result"
616 # Implementation must be kept synchronized with func_dirname
617 # and func_basename. For efficiency, we do not delegate to
618 # those functions but instead duplicate the functionality here.
619 func_dirname_and_basename ()
620 {
621   case ${1} in
622     */*) func_dirname_result="${1%/*}${2}" ;;
623     *  ) func_dirname_result="${3}" ;;
624   esac
625   func_basename_result="${1##*/}"
626 }
627
628 # func_stripname prefix suffix name
629 # strip PREFIX and SUFFIX off of NAME.
630 # PREFIX and SUFFIX must not contain globbing or regex special
631 # characters, hashes, percent signs, but SUFFIX may contain a leading
632 # dot (in which case that matches only a dot).
633 func_stripname ()
634 {
635   # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
636   # positional parameters, so assign one to ordinary parameter first.
637   func_stripname_result=${3}
638   func_stripname_result=${func_stripname_result#"${1}"}
639   func_stripname_result=${func_stripname_result%"${2}"}
640 }
641
642 # func_opt_split
643 func_opt_split ()
644 {
645   func_opt_split_opt=${1%%=*}
646   func_opt_split_arg=${1#*=}
647 }
648
649 # func_lo2o object
650 func_lo2o ()
651 {
652   case ${1} in
653     *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
654     *)    func_lo2o_result=${1} ;;
655   esac
656 }
657
658 # func_xform libobj-or-source
659 func_xform ()
660 {
661   func_xform_result=${1%.*}.lo
662 }
663
664 # func_arith arithmetic-term...
665 func_arith ()
666 {
667   func_arith_result=$(( $* ))
668 }
669
670 # func_len string
671 # STRING may not start with a hyphen.
672 func_len ()
673 {
674   func_len_result=${#1}
675 }
676
677
678 # func_append var value
679 # Append VALUE to the end of shell variable VAR.
680 func_append ()
681 {
682   eval "$1+=\$2"
683 }
684 # Generated shell functions inserted here.
685
686 # These SED scripts presuppose an absolute path with a trailing slash.
687 pathcar='s,^/\([^/]*\).*$,\1,'
688 pathcdr='s,^/[^/]*,,'
689 removedotparts=':dotsl
690                 s@/\./@/@g
691                 t dotsl
692                 s,/\.$,/,'
693 collapseslashes='s@/\{1,\}@/@g'
694 finalslash='s,/*$,/,'
695
696 # func_normal_abspath PATH
697 # Remove doubled-up and trailing slashes, "." path components,
698 # and cancel out any ".." path components in PATH after making
699 # it an absolute path.
700 #             value returned in "$func_normal_abspath_result"
701 func_normal_abspath ()
702 {
703   # Start from root dir and reassemble the path.
704   func_normal_abspath_result=
705   func_normal_abspath_tpath=$1
706   func_normal_abspath_altnamespace=
707   case $func_normal_abspath_tpath in
708     "")
709       # Empty path, that just means $cwd.
710       func_stripname '' '/' "`pwd`"
711       func_normal_abspath_result=$func_stripname_result
712       return
713     ;;
714     # The next three entries are used to spot a run of precisely
715     # two leading slashes without using negated character classes;
716     # we take advantage of case's first-match behaviour.
717     ///*)
718       # Unusual form of absolute path, do nothing.
719     ;;
720     //*)
721       # Not necessarily an ordinary path; POSIX reserves leading '//'
722       # and for example Cygwin uses it to access remote file shares
723       # over CIFS/SMB, so we conserve a leading double slash if found.
724       func_normal_abspath_altnamespace=/
725     ;;
726     /*)
727       # Absolute path, do nothing.
728     ;;
729     *)
730       # Relative path, prepend $cwd.
731       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
732     ;;
733   esac
734   # Cancel out all the simple stuff to save iterations.  We also want
735   # the path to end with a slash for ease of parsing, so make sure
736   # there is one (and only one) here.
737   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
738         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
739   while :; do
740     # Processed it all yet?
741     if test "$func_normal_abspath_tpath" = / ; then
742       # If we ascended to the root using ".." the result may be empty now.
743       if test -z "$func_normal_abspath_result" ; then
744         func_normal_abspath_result=/
745       fi
746       break
747     fi
748     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
749         -e "$pathcar"`
750     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
751         -e "$pathcdr"`
752     # Figure out what to do with it
753     case $func_normal_abspath_tcomponent in
754       "")
755         # Trailing empty path component, ignore it.
756       ;;
757       ..)
758         # Parent dir; strip last assembled component from result.
759         func_dirname "$func_normal_abspath_result"
760         func_normal_abspath_result=$func_dirname_result
761       ;;
762       *)
763         # Actual path component, append it.
764         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
765       ;;
766     esac
767   done
768   # Restore leading double-slash if one was found on entry.
769   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
770 }
771
772 # func_relative_path SRCDIR DSTDIR
773 # generates a relative path from SRCDIR to DSTDIR, with a trailing
774 # slash if non-empty, suitable for immediately appending a filename
775 # without needing to append a separator.
776 #             value returned in "$func_relative_path_result"
777 func_relative_path ()
778 {
779   func_relative_path_result=
780   func_normal_abspath "$1"
781   func_relative_path_tlibdir=$func_normal_abspath_result
782   func_normal_abspath "$2"
783   func_relative_path_tbindir=$func_normal_abspath_result
784
785   # Ascend the tree starting from libdir
786   while :; do
787     # check if we have found a prefix of bindir
788     case $func_relative_path_tbindir in
789       $func_relative_path_tlibdir)
790         # found an exact match
791         func_relative_path_tcancelled=
792         break
793         ;;
794       $func_relative_path_tlibdir*)
795         # found a matching prefix
796         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
797         func_relative_path_tcancelled=$func_stripname_result
798         if test -z "$func_relative_path_result"; then
799           func_relative_path_result=.
800         fi
801         break
802         ;;
803       *)
804         func_dirname $func_relative_path_tlibdir
805         func_relative_path_tlibdir=${func_dirname_result}
806         if test "x$func_relative_path_tlibdir" = x ; then
807           # Have to descend all the way to the root!
808           func_relative_path_result=../$func_relative_path_result
809           func_relative_path_tcancelled=$func_relative_path_tbindir
810           break
811         fi
812         func_relative_path_result=../$func_relative_path_result
813         ;;
814     esac
815   done
816
817   # Now calculate path; take care to avoid doubling-up slashes.
818   func_stripname '' '/' "$func_relative_path_result"
819   func_relative_path_result=$func_stripname_result
820   func_stripname '/' '/' "$func_relative_path_tcancelled"
821   if test "x$func_stripname_result" != x ; then
822     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
823   fi
824
825   # Normalisation. If bindir is libdir, return empty string,
826   # else relative path ending with a slash; either way, target
827   # file name can be directly appended.
828   if test ! -z "$func_relative_path_result"; then
829     func_stripname './' '' "$func_relative_path_result/"
830     func_relative_path_result=$func_stripname_result
831   fi
832 }
833
834 # The name of this program:
835 func_dirname_and_basename "$progpath"
836 progname=$func_basename_result
837
838 # Make sure we have an absolute path for reexecution:
839 case $progpath in
840   [\\/]*|[A-Za-z]:\\*) ;;
841   *[\\/]*)
842      progdir=$func_dirname_result
843      progdir=`cd "$progdir" && pwd`
844      progpath="$progdir/$progname"
845      ;;
846   *)
847      save_IFS="$IFS"
848      IFS=:
849      for progdir in $PATH; do
850        IFS="$save_IFS"
851        test -x "$progdir/$progname" && break
852      done
853      IFS="$save_IFS"
854      test -n "$progdir" || progdir=`pwd`
855      progpath="$progdir/$progname"
856      ;;
857 esac
858
859 # Sed substitution that helps us do robust quoting.  It backslashifies
860 # metacharacters that are still active within double-quoted strings.
861 Xsed="${SED}"' -e 1s/^X//'
862 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
863
864 # Same as above, but do not quote variable references.
865 double_quote_subst='s/\(["`\\]\)/\\\1/g'
866
867 # Re-`\' parameter expansions in output of double_quote_subst that were
868 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
869 # in input to double_quote_subst, that '$' was protected from expansion.
870 # Since each input `\' is now two `\'s, look for any number of runs of
871 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
872 bs='\\'
873 bs2='\\\\'
874 bs4='\\\\\\\\'
875 dollar='\$'
876 sed_double_backslash="\
877   s/$bs4/&\\
878 /g
879   s/^$bs2$dollar/$bs&/
880   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
881   s/\n//g"
882
883 # Standard options:
884 opt_dry_run=false
885 opt_help=false
886 opt_quiet=false
887 opt_verbose=false
888 opt_warning=:
889
890 # func_echo arg...
891 # Echo program name prefixed message, along with the current mode
892 # name if it has been set yet.
893 func_echo ()
894 {
895     $ECHO "$progname${mode+: }$mode: $*"
896 }
897
898 # func_verbose arg...
899 # Echo program name prefixed message in verbose mode only.
900 func_verbose ()
901 {
902     $opt_verbose && func_echo ${1+"$@"}
903
904     # A bug in bash halts the script if the last line of a function
905     # fails when set -e is in force, so we need another command to
906     # work around that:
907     :
908 }
909
910 # func_echo_all arg...
911 # Invoke $ECHO with all args, space-separated.
912 func_echo_all ()
913 {
914     $ECHO "$*"
915 }
916
917 # func_error arg...
918 # Echo program name prefixed message to standard error.
919 func_error ()
920 {
921     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
922 }
923
924 # func_warning arg...
925 # Echo program name prefixed warning message to standard error.
926 func_warning ()
927 {
928     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
929
930     # bash bug again:
931     :
932 }
933
934 # func_fatal_error arg...
935 # Echo program name prefixed message to standard error, and exit.
936 func_fatal_error ()
937 {
938     func_error ${1+"$@"}
939     exit $EXIT_FAILURE
940 }
941
942 # func_fatal_help arg...
943 # Echo program name prefixed message to standard error, followed by
944 # a help hint, and exit.
945 func_fatal_help ()
946 {
947     func_error ${1+"$@"}
948     func_fatal_error "$help"
949 }
950 help="Try \`$progname --help' for more information."  ## default
951
952
953 # func_grep expression filename
954 # Check whether EXPRESSION matches any line of FILENAME, without output.
955 func_grep ()
956 {
957     $GREP "$1" "$2" >/dev/null 2>&1
958 }
959
960
961 # func_mkdir_p directory-path
962 # Make sure the entire path to DIRECTORY-PATH is available.
963 func_mkdir_p ()
964 {
965     my_directory_path="$1"
966     my_dir_list=
967
968     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
969
970       # Protect directory names starting with `-'
971       case $my_directory_path in
972         -*) my_directory_path="./$my_directory_path" ;;
973       esac
974
975       # While some portion of DIR does not yet exist...
976       while test ! -d "$my_directory_path"; do
977         # ...make a list in topmost first order.  Use a colon delimited
978         # list incase some portion of path contains whitespace.
979         my_dir_list="$my_directory_path:$my_dir_list"
980
981         # If the last portion added has no slash in it, the list is done
982         case $my_directory_path in */*) ;; *) break ;; esac
983
984         # ...otherwise throw away the child directory and loop
985         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
986       done
987       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
988
989       save_mkdir_p_IFS="$IFS"; IFS=':'
990       for my_dir in $my_dir_list; do
991         IFS="$save_mkdir_p_IFS"
992         # mkdir can fail with a `File exist' error if two processes
993         # try to create one of the directories concurrently.  Don't
994         # stop in that case!
995         $MKDIR "$my_dir" 2>/dev/null || :
996       done
997       IFS="$save_mkdir_p_IFS"
998
999       # Bail out if we (or some other process) failed to create a directory.
1000       test -d "$my_directory_path" || \
1001         func_fatal_error "Failed to create \`$1'"
1002     fi
1003 }
1004
1005
1006 # func_mktempdir [string]
1007 # Make a temporary directory that won't clash with other running
1008 # libtool processes, and avoids race conditions if possible.  If
1009 # given, STRING is the basename for that directory.
1010 func_mktempdir ()
1011 {
1012     my_template="${TMPDIR-/tmp}/${1-$progname}"
1013
1014     if test "$opt_dry_run" = ":"; then
1015       # Return a directory name, but don't create it in dry-run mode
1016       my_tmpdir="${my_template}-$$"
1017     else
1018
1019       # If mktemp works, use that first and foremost
1020       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
1021
1022       if test ! -d "$my_tmpdir"; then
1023         # Failing that, at least try and use $RANDOM to avoid a race
1024         my_tmpdir="${my_template}-${RANDOM-0}$$"
1025
1026         save_mktempdir_umask=`umask`
1027         umask 0077
1028         $MKDIR "$my_tmpdir"
1029         umask $save_mktempdir_umask
1030       fi
1031
1032       # If we're not in dry-run mode, bomb out on failure
1033       test -d "$my_tmpdir" || \
1034         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
1035     fi
1036
1037     $ECHO "$my_tmpdir"
1038 }
1039
1040
1041 # func_quote_for_eval arg
1042 # Aesthetically quote ARG to be evaled later.
1043 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
1044 # is double-quoted, suitable for a subsequent eval, whereas
1045 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
1046 # which are still active within double quotes backslashified.
1047 func_quote_for_eval ()
1048 {
1049     case $1 in
1050       *[\\\`\"\$]*)
1051         func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
1052       *)
1053         func_quote_for_eval_unquoted_result="$1" ;;
1054     esac
1055
1056     case $func_quote_for_eval_unquoted_result in
1057       # Double-quote args containing shell metacharacters to delay
1058       # word splitting, command substitution and and variable
1059       # expansion for a subsequent eval.
1060       # Many Bourne shells cannot handle close brackets correctly
1061       # in scan sets, so we specify it separately.
1062       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1063         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
1064         ;;
1065       *)
1066         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
1067     esac
1068 }
1069
1070
1071 # func_quote_for_expand arg
1072 # Aesthetically quote ARG to be evaled later; same as above,
1073 # but do not quote variable references.
1074 func_quote_for_expand ()
1075 {
1076     case $1 in
1077       *[\\\`\"]*)
1078         my_arg=`$ECHO "$1" | $SED \
1079             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
1080       *)
1081         my_arg="$1" ;;
1082     esac
1083
1084     case $my_arg in
1085       # Double-quote args containing shell metacharacters to delay
1086       # word splitting and command substitution for a subsequent eval.
1087       # Many Bourne shells cannot handle close brackets correctly
1088       # in scan sets, so we specify it separately.
1089       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1090         my_arg="\"$my_arg\""
1091         ;;
1092     esac
1093
1094     func_quote_for_expand_result="$my_arg"
1095 }
1096
1097
1098 # func_show_eval cmd [fail_exp]
1099 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
1100 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
1101 # is given, then evaluate it.
1102 func_show_eval ()
1103 {
1104     my_cmd="$1"
1105     my_fail_exp="${2-:}"
1106
1107     ${opt_silent-false} || {
1108       func_quote_for_expand "$my_cmd"
1109       eval "func_echo $func_quote_for_expand_result"
1110     }
1111
1112     if ${opt_dry_run-false}; then :; else
1113       eval "$my_cmd"
1114       my_status=$?
1115       if test "$my_status" -eq 0; then :; else
1116         eval "(exit $my_status); $my_fail_exp"
1117       fi
1118     fi
1119 }
1120
1121
1122 # func_show_eval_locale cmd [fail_exp]
1123 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
1124 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
1125 # is given, then evaluate it.  Use the saved locale for evaluation.
1126 func_show_eval_locale ()
1127 {
1128     my_cmd="$1"
1129     my_fail_exp="${2-:}"
1130
1131     ${opt_silent-false} || {
1132       func_quote_for_expand "$my_cmd"
1133       eval "func_echo $func_quote_for_expand_result"
1134     }
1135
1136     if ${opt_dry_run-false}; then :; else
1137       eval "$lt_user_locale
1138             $my_cmd"
1139       my_status=$?
1140       eval "$lt_safe_locale"
1141       if test "$my_status" -eq 0; then :; else
1142         eval "(exit $my_status); $my_fail_exp"
1143       fi
1144     fi
1145 }
1146
1147
1148 # func_version
1149 # Echo version message to standard output and exit.
1150 func_version ()
1151 {
1152     $SED -n '/(C)/!b go
1153         :more
1154         /\./!{
1155           N
1156           s/\n# / /
1157           b more
1158         }
1159         :go
1160         /^# '$PROGRAM' (GNU /,/# warranty; / {
1161         s/^# //
1162         s/^# *$//
1163         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
1164         p
1165      }' < "$progpath"
1166      exit $?
1167 }
1168
1169 # func_usage
1170 # Echo short help message to standard output and exit.
1171 func_usage ()
1172 {
1173     $SED -n '/^# Usage:/,/^#  *.*--help/ {
1174         s/^# //
1175         s/^# *$//
1176         s/\$progname/'$progname'/
1177         p
1178     }' < "$progpath"
1179     echo
1180     $ECHO "run \`$progname --help | more' for full usage"
1181     exit $?
1182 }
1183
1184 # func_help [NOEXIT]
1185 # Echo long help message to standard output and exit,
1186 # unless 'noexit' is passed as argument.
1187 func_help ()
1188 {
1189     $SED -n '/^# Usage:/,/# Report bugs to/ {
1190         s/^# //
1191         s/^# *$//
1192         s*\$progname*'$progname'*
1193         s*\$host*'"$host"'*
1194         s*\$SHELL*'"$SHELL"'*
1195         s*\$LTCC*'"$LTCC"'*
1196         s*\$LTCFLAGS*'"$LTCFLAGS"'*
1197         s*\$LD*'"$LD"'*
1198         s/\$with_gnu_ld/'"$with_gnu_ld"'/
1199         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1200         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1201         p
1202      }' < "$progpath"
1203     ret=$?
1204     if test -z "$1"; then
1205       exit $ret
1206     fi
1207 }
1208
1209 # func_missing_arg argname
1210 # Echo program name prefixed message to standard error and set global
1211 # exit_cmd.
1212 func_missing_arg ()
1213 {
1214     func_error "missing argument for $1."
1215     exit_cmd=exit
1216 }
1217
1218 exit_cmd=:
1219
1220
1221
1222
1223
1224
1225 magic="%%%MAGIC variable%%%"
1226 magic_exe="%%%MAGIC EXE variable%%%"
1227
1228 # Global variables.
1229 # $mode is unset
1230 nonopt=
1231 execute_dlfiles=
1232 preserve_args=
1233 lo2o="s/\\.lo\$/.${objext}/"
1234 o2lo="s/\\.${objext}\$/.lo/"
1235 extracted_archives=
1236 extracted_serial=0
1237
1238 opt_dry_run=false
1239 opt_duplicate_deps=false
1240 opt_silent=false
1241 opt_debug=:
1242
1243 # If this variable is set in any of the actions, the command in it
1244 # will be execed at the end.  This prevents here-documents from being
1245 # left over by shells.
1246 exec_cmd=
1247
1248 # func_fatal_configuration arg...
1249 # Echo program name prefixed message to standard error, followed by
1250 # a configuration failure hint, and exit.
1251 func_fatal_configuration ()
1252 {
1253     func_error ${1+"$@"}
1254     func_error "See the $PACKAGE documentation for more information."
1255     func_fatal_error "Fatal configuration error."
1256 }
1257
1258
1259 # func_config
1260 # Display the configuration for all the tags in this script.
1261 func_config ()
1262 {
1263     re_begincf='^# ### BEGIN LIBTOOL'
1264     re_endcf='^# ### END LIBTOOL'
1265
1266     # Default configuration.
1267     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1268
1269     # Now print the configurations for the tags.
1270     for tagname in $taglist; do
1271       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1272     done
1273
1274     exit $?
1275 }
1276
1277 # func_features
1278 # Display the features supported by this script.
1279 func_features ()
1280 {
1281     echo "host: $host"
1282     if test "$build_libtool_libs" = yes; then
1283       echo "enable shared libraries"
1284     else
1285       echo "disable shared libraries"
1286     fi
1287     if test "$build_old_libs" = yes; then
1288       echo "enable static libraries"
1289     else
1290       echo "disable static libraries"
1291     fi
1292
1293     exit $?
1294 }
1295
1296 # func_enable_tag tagname
1297 # Verify that TAGNAME is valid, and either flag an error and exit, or
1298 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
1299 # variable here.
1300 func_enable_tag ()
1301 {
1302   # Global variable:
1303   tagname="$1"
1304
1305   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1306   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1307   sed_extractcf="/$re_begincf/,/$re_endcf/p"
1308
1309   # Validate tagname.
1310   case $tagname in
1311     *[!-_A-Za-z0-9,/]*)
1312       func_fatal_error "invalid tag name: $tagname"
1313       ;;
1314   esac
1315
1316   # Don't test for the "default" C tag, as we know it's
1317   # there but not specially marked.
1318   case $tagname in
1319     CC) ;;
1320     *)
1321       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1322         taglist="$taglist $tagname"
1323
1324         # Evaluate the configuration.  Be careful to quote the path
1325         # and the sed script, to avoid splitting on whitespace, but
1326         # also don't use non-portable quotes within backquotes within
1327         # quotes we have to do it in 2 steps:
1328         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1329         eval "$extractedcf"
1330       else
1331         func_error "ignoring unknown tag $tagname"
1332       fi
1333       ;;
1334   esac
1335 }
1336
1337 # Parse options once, thoroughly.  This comes as soon as possible in
1338 # the script to make things like `libtool --version' happen quickly.
1339 {
1340
1341   # Shorthand for --mode=foo, only valid as the first argument
1342   case $1 in
1343   clean|clea|cle|cl)
1344     shift; set dummy --mode clean ${1+"$@"}; shift
1345     ;;
1346   compile|compil|compi|comp|com|co|c)
1347     shift; set dummy --mode compile ${1+"$@"}; shift
1348     ;;
1349   execute|execut|execu|exec|exe|ex|e)
1350     shift; set dummy --mode execute ${1+"$@"}; shift
1351     ;;
1352   finish|finis|fini|fin|fi|f)
1353     shift; set dummy --mode finish ${1+"$@"}; shift
1354     ;;
1355   install|instal|insta|inst|ins|in|i)
1356     shift; set dummy --mode install ${1+"$@"}; shift
1357     ;;
1358   link|lin|li|l)
1359     shift; set dummy --mode link ${1+"$@"}; shift
1360     ;;
1361   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1362     shift; set dummy --mode uninstall ${1+"$@"}; shift
1363     ;;
1364   esac
1365
1366   # Parse non-mode specific arguments:
1367   while test "$#" -gt 0; do
1368     opt="$1"
1369     shift
1370
1371     case $opt in
1372       --config)         func_config                                     ;;
1373
1374       --debug)          preserve_args="$preserve_args $opt"
1375                         func_echo "enabling shell trace mode"
1376                         opt_debug='set -x'
1377                         $opt_debug
1378                         ;;
1379
1380       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
1381                         execute_dlfiles="$execute_dlfiles $1"
1382                         shift
1383                         ;;
1384
1385       --dry-run | -n)   opt_dry_run=:                                   ;;
1386       --features)       func_features                                   ;;
1387       --finish)         mode="finish"                                   ;;
1388
1389       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
1390                         case $1 in
1391                           # Valid mode arguments:
1392                           clean)        ;;
1393                           compile)      ;;
1394                           execute)      ;;
1395                           finish)       ;;
1396                           install)      ;;
1397                           link)         ;;
1398                           relink)       ;;
1399                           uninstall)    ;;
1400
1401                           # Catch anything else as an error
1402                           *) func_error "invalid argument for $opt"
1403                              exit_cmd=exit
1404                              break
1405                              ;;
1406                         esac
1407
1408                         mode="$1"
1409                         shift
1410                         ;;
1411
1412       --preserve-dup-deps)
1413                         opt_duplicate_deps=:                            ;;
1414
1415       --quiet|--silent) preserve_args="$preserve_args $opt"
1416                         opt_silent=:
1417                         opt_verbose=false
1418                         ;;
1419
1420       --no-quiet|--no-silent)
1421                         preserve_args="$preserve_args $opt"
1422                         opt_silent=false
1423                         ;;
1424
1425       --verbose| -v)    preserve_args="$preserve_args $opt"
1426                         opt_silent=false
1427                         opt_verbose=:
1428                         ;;
1429
1430       --no-verbose)     preserve_args="$preserve_args $opt"
1431                         opt_verbose=false
1432                         ;;
1433
1434       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
1435                         preserve_args="$preserve_args $opt $1"
1436                         func_enable_tag "$1"    # tagname is set here
1437                         shift
1438                         ;;
1439
1440       # Separate optargs to long options:
1441       -dlopen=*|--mode=*|--tag=*)
1442                         func_opt_split "$opt"
1443                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
1444                         shift
1445                         ;;
1446
1447       -\?|-h)           func_usage                                      ;;
1448       --help)           opt_help=:                                      ;;
1449       --help-all)       opt_help=': help-all'                           ;;
1450       --version)        func_version                                    ;;
1451
1452       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
1453
1454       *)                nonopt="$opt"
1455                         break
1456                         ;;
1457     esac
1458   done
1459
1460
1461   case $host in
1462     *cygwin* | *mingw* | *pw32* | *cegcc*)
1463       # don't eliminate duplications in $postdeps and $predeps
1464       opt_duplicate_compiler_generated_deps=:
1465       ;;
1466     *)
1467       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
1468       ;;
1469   esac
1470
1471   # Having warned about all mis-specified options, bail out if
1472   # anything was wrong.
1473   $exit_cmd $EXIT_FAILURE
1474 }
1475
1476 # func_check_version_match
1477 # Ensure that we are using m4 macros, and libtool script from the same
1478 # release of libtool.
1479 func_check_version_match ()
1480 {
1481   if test "$package_revision" != "$macro_revision"; then
1482     if test "$VERSION" != "$macro_version"; then
1483       if test -z "$macro_version"; then
1484         cat >&2 <<_LT_EOF
1485 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1486 $progname: definition of this LT_INIT comes from an older release.
1487 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1488 $progname: and run autoconf again.
1489 _LT_EOF
1490       else
1491         cat >&2 <<_LT_EOF
1492 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1493 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1494 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1495 $progname: and run autoconf again.
1496 _LT_EOF
1497       fi
1498     else
1499       cat >&2 <<_LT_EOF
1500 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1501 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1502 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1503 $progname: of $PACKAGE $VERSION and run autoconf again.
1504 _LT_EOF
1505     fi
1506
1507     exit $EXIT_MISMATCH
1508   fi
1509 }
1510
1511
1512 ## ----------- ##
1513 ##    Main.    ##
1514 ## ----------- ##
1515
1516 $opt_help || {
1517   # Sanity checks first:
1518   func_check_version_match
1519
1520   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1521     func_fatal_configuration "not configured to build any kind of library"
1522   fi
1523
1524   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1525
1526
1527   # Darwin sucks
1528   eval std_shrext=\"$shrext_cmds\"
1529
1530
1531   # Only execute mode is allowed to have -dlopen flags.
1532   if test -n "$execute_dlfiles" && test "$mode" != execute; then
1533     func_error "unrecognized option \`-dlopen'"
1534     $ECHO "$help" 1>&2
1535     exit $EXIT_FAILURE
1536   fi
1537
1538   # Change the help message to a mode-specific one.
1539   generic_help="$help"
1540   help="Try \`$progname --help --mode=$mode' for more information."
1541 }
1542
1543
1544 # func_lalib_p file
1545 # True iff FILE is a libtool `.la' library or `.lo' object file.
1546 # This function is only a basic sanity check; it will hardly flush out
1547 # determined imposters.
1548 func_lalib_p ()
1549 {
1550     test -f "$1" &&
1551       $SED -e 4q "$1" 2>/dev/null \
1552         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1553 }
1554
1555 # func_lalib_unsafe_p file
1556 # True iff FILE is a libtool `.la' library or `.lo' object file.
1557 # This function implements the same check as func_lalib_p without
1558 # resorting to external programs.  To this end, it redirects stdin and
1559 # closes it afterwards, without saving the original file descriptor.
1560 # As a safety measure, use it only where a negative result would be
1561 # fatal anyway.  Works if `file' does not exist.
1562 func_lalib_unsafe_p ()
1563 {
1564     lalib_p=no
1565     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1566         for lalib_p_l in 1 2 3 4
1567         do
1568             read lalib_p_line
1569             case "$lalib_p_line" in
1570                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1571             esac
1572         done
1573         exec 0<&5 5<&-
1574     fi
1575     test "$lalib_p" = yes
1576 }
1577
1578 # func_ltwrapper_script_p file
1579 # True iff FILE is a libtool wrapper script
1580 # This function is only a basic sanity check; it will hardly flush out
1581 # determined imposters.
1582 func_ltwrapper_script_p ()
1583 {
1584     func_lalib_p "$1"
1585 }
1586
1587 # func_ltwrapper_executable_p file
1588 # True iff FILE is a libtool wrapper executable
1589 # This function is only a basic sanity check; it will hardly flush out
1590 # determined imposters.
1591 func_ltwrapper_executable_p ()
1592 {
1593     func_ltwrapper_exec_suffix=
1594     case $1 in
1595     *.exe) ;;
1596     *) func_ltwrapper_exec_suffix=.exe ;;
1597     esac
1598     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1599 }
1600
1601 # func_ltwrapper_scriptname file
1602 # Assumes file is an ltwrapper_executable
1603 # uses $file to determine the appropriate filename for a
1604 # temporary ltwrapper_script.
1605 func_ltwrapper_scriptname ()
1606 {
1607     func_ltwrapper_scriptname_result=""
1608     if func_ltwrapper_executable_p "$1"; then
1609         func_dirname_and_basename "$1" "" "."
1610         func_stripname '' '.exe' "$func_basename_result"
1611         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1612     fi
1613 }
1614
1615 # func_ltwrapper_p file
1616 # True iff FILE is a libtool wrapper script or wrapper executable
1617 # This function is only a basic sanity check; it will hardly flush out
1618 # determined imposters.
1619 func_ltwrapper_p ()
1620 {
1621     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1622 }
1623
1624
1625 # func_execute_cmds commands fail_cmd
1626 # Execute tilde-delimited COMMANDS.
1627 # If FAIL_CMD is given, eval that upon failure.
1628 # FAIL_CMD may read-access the current command in variable CMD!
1629 func_execute_cmds ()
1630 {
1631     $opt_debug
1632     save_ifs=$IFS; IFS='~'
1633     for cmd in $1; do
1634       IFS=$save_ifs
1635       eval cmd=\"$cmd\"
1636       func_show_eval "$cmd" "${2-:}"
1637     done
1638     IFS=$save_ifs
1639 }
1640
1641
1642 # func_source file
1643 # Source FILE, adding directory component if necessary.
1644 # Note that it is not necessary on cygwin/mingw to append a dot to
1645 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1646 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1647 # `FILE.' does not work on cygwin managed mounts.
1648 func_source ()
1649 {
1650     $opt_debug
1651     case $1 in
1652     */* | *\\*) . "$1" ;;
1653     *)          . "./$1" ;;
1654     esac
1655 }
1656
1657
1658 # func_infer_tag arg
1659 # Infer tagged configuration to use if any are available and
1660 # if one wasn't chosen via the "--tag" command line option.
1661 # Only attempt this if the compiler in the base compile
1662 # command doesn't match the default compiler.
1663 # arg is usually of the form 'gcc ...'
1664 func_infer_tag ()
1665 {
1666     $opt_debug
1667     if test -n "$available_tags" && test -z "$tagname"; then
1668       CC_quoted=
1669       for arg in $CC; do
1670         func_quote_for_eval "$arg"
1671         CC_quoted="$CC_quoted $func_quote_for_eval_result"
1672       done
1673       CC_expanded=`func_echo_all $CC`
1674       CC_quoted_expanded=`func_echo_all $CC_quoted`
1675       case $@ in
1676       # Blanks in the command may have been stripped by the calling shell,
1677       # but not from the CC environment variable when configure was run.
1678       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1679       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1680       # Blanks at the start of $base_compile will cause this to fail
1681       # if we don't check for them as well.
1682       *)
1683         for z in $available_tags; do
1684           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1685             # Evaluate the configuration.
1686             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1687             CC_quoted=
1688             for arg in $CC; do
1689               # Double-quote args containing other shell metacharacters.
1690               func_quote_for_eval "$arg"
1691               CC_quoted="$CC_quoted $func_quote_for_eval_result"
1692             done
1693             CC_expanded=`func_echo_all $CC`
1694             CC_quoted_expanded=`func_echo_all $CC_quoted`
1695             case "$@ " in
1696             " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1697             " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1698               # The compiler in the base compile command matches
1699               # the one in the tagged configuration.
1700               # Assume this is the tagged configuration we want.
1701               tagname=$z
1702               break
1703               ;;
1704             esac
1705           fi
1706         done
1707         # If $tagname still isn't set, then no tagged configuration
1708         # was found and let the user know that the "--tag" command
1709         # line option must be used.
1710         if test -z "$tagname"; then
1711           func_echo "unable to infer tagged configuration"
1712           func_fatal_error "specify a tag with \`--tag'"
1713 #       else
1714 #         func_verbose "using $tagname tagged configuration"
1715         fi
1716         ;;
1717       esac
1718     fi
1719 }
1720
1721
1722
1723 # func_write_libtool_object output_name pic_name nonpic_name
1724 # Create a libtool object file (analogous to a ".la" file),
1725 # but don't create it if we're doing a dry run.
1726 func_write_libtool_object ()
1727 {
1728     write_libobj=${1}
1729     if test "$build_libtool_libs" = yes; then
1730       write_lobj=\'${2}\'
1731     else
1732       write_lobj=none
1733     fi
1734
1735     if test "$build_old_libs" = yes; then
1736       write_oldobj=\'${3}\'
1737     else
1738       write_oldobj=none
1739     fi
1740
1741     $opt_dry_run || {
1742       cat >${write_libobj}T <<EOF
1743 # $write_libobj - a libtool object file
1744 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1745 #
1746 # Please DO NOT delete this file!
1747 # It is necessary for linking the library.
1748
1749 # Name of the PIC object.
1750 pic_object=$write_lobj
1751
1752 # Name of the non-PIC object
1753 non_pic_object=$write_oldobj
1754
1755 EOF
1756       $MV "${write_libobj}T" "${write_libobj}"
1757     }
1758 }
1759
1760 # func_mode_compile arg...
1761 func_mode_compile ()
1762 {
1763     $opt_debug
1764     # Get the compilation command and the source file.
1765     base_compile=
1766     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1767     suppress_opt=yes
1768     suppress_output=
1769     arg_mode=normal
1770     libobj=
1771     later=
1772     pie_flag=
1773
1774     for arg
1775     do
1776       case $arg_mode in
1777       arg  )
1778         # do not "continue".  Instead, add this to base_compile
1779         lastarg="$arg"
1780         arg_mode=normal
1781         ;;
1782
1783       target )
1784         libobj="$arg"
1785         arg_mode=normal
1786         continue
1787         ;;
1788
1789       normal )
1790         # Accept any command-line options.
1791         case $arg in
1792         -o)
1793           test -n "$libobj" && \
1794             func_fatal_error "you cannot specify \`-o' more than once"
1795           arg_mode=target
1796           continue
1797           ;;
1798
1799         -pie | -fpie | -fPIE)
1800           pie_flag="$pie_flag $arg"
1801           continue
1802           ;;
1803
1804         -shared | -static | -prefer-pic | -prefer-non-pic)
1805           later="$later $arg"
1806           continue
1807           ;;
1808
1809         -no-suppress)
1810           suppress_opt=no
1811           continue
1812           ;;
1813
1814         -Xcompiler)
1815           arg_mode=arg  #  the next one goes into the "base_compile" arg list
1816           continue      #  The current "srcfile" will either be retained or
1817           ;;            #  replaced later.  I would guess that would be a bug.
1818
1819         -Wc,*)
1820           func_stripname '-Wc,' '' "$arg"
1821           args=$func_stripname_result
1822           lastarg=
1823           save_ifs="$IFS"; IFS=','
1824           for arg in $args; do
1825             IFS="$save_ifs"
1826             func_quote_for_eval "$arg"
1827             lastarg="$lastarg $func_quote_for_eval_result"
1828           done
1829           IFS="$save_ifs"
1830           func_stripname ' ' '' "$lastarg"
1831           lastarg=$func_stripname_result
1832
1833           # Add the arguments to base_compile.
1834           base_compile="$base_compile $lastarg"
1835           continue
1836           ;;
1837
1838         *)
1839           # Accept the current argument as the source file.
1840           # The previous "srcfile" becomes the current argument.
1841           #
1842           lastarg="$srcfile"
1843           srcfile="$arg"
1844           ;;
1845         esac  #  case $arg
1846         ;;
1847       esac    #  case $arg_mode
1848
1849       # Aesthetically quote the previous argument.
1850       func_quote_for_eval "$lastarg"
1851       base_compile="$base_compile $func_quote_for_eval_result"
1852     done # for arg
1853
1854     case $arg_mode in
1855     arg)
1856       func_fatal_error "you must specify an argument for -Xcompile"
1857       ;;
1858     target)
1859       func_fatal_error "you must specify a target with \`-o'"
1860       ;;
1861     *)
1862       # Get the name of the library object.
1863       test -z "$libobj" && {
1864         func_basename "$srcfile"
1865         libobj="$func_basename_result"
1866       }
1867       ;;
1868     esac
1869
1870     # Recognize several different file suffixes.
1871     # If the user specifies -o file.o, it is replaced with file.lo
1872     case $libobj in
1873     *.[cCFSifmso] | \
1874     *.ada | *.adb | *.ads | *.asm | \
1875     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1876     *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1877       func_xform "$libobj"
1878       libobj=$func_xform_result
1879       ;;
1880     esac
1881
1882     case $libobj in
1883     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1884     *)
1885       func_fatal_error "cannot determine name of library object from \`$libobj'"
1886       ;;
1887     esac
1888
1889     func_infer_tag $base_compile
1890
1891     for arg in $later; do
1892       case $arg in
1893       -shared)
1894         test "$build_libtool_libs" != yes && \
1895           func_fatal_configuration "can not build a shared library"
1896         build_old_libs=no
1897         continue
1898         ;;
1899
1900       -static)
1901         build_libtool_libs=no
1902         build_old_libs=yes
1903         continue
1904         ;;
1905
1906       -prefer-pic)
1907         pic_mode=yes
1908         continue
1909         ;;
1910
1911       -prefer-non-pic)
1912         pic_mode=no
1913         continue
1914         ;;
1915       esac
1916     done
1917
1918     func_quote_for_eval "$libobj"
1919     test "X$libobj" != "X$func_quote_for_eval_result" \
1920       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1921       && func_warning "libobj name \`$libobj' may not contain shell special characters."
1922     func_dirname_and_basename "$obj" "/" ""
1923     objname="$func_basename_result"
1924     xdir="$func_dirname_result"
1925     lobj=${xdir}$objdir/$objname
1926
1927     test -z "$base_compile" && \
1928       func_fatal_help "you must specify a compilation command"
1929
1930     # Delete any leftover library objects.
1931     if test "$build_old_libs" = yes; then
1932       removelist="$obj $lobj $libobj ${libobj}T"
1933     else
1934       removelist="$lobj $libobj ${libobj}T"
1935     fi
1936
1937     # On Cygwin there's no "real" PIC flag so we must build both object types
1938     case $host_os in
1939     cygwin* | mingw* | pw32* | os2* | cegcc*)
1940       pic_mode=default
1941       ;;
1942     esac
1943     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1944       # non-PIC code in shared libraries is not supported
1945       pic_mode=default
1946     fi
1947
1948     # Calculate the filename of the output object if compiler does
1949     # not support -o with -c
1950     if test "$compiler_c_o" = no; then
1951       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1952       lockfile="$output_obj.lock"
1953     else
1954       output_obj=
1955       need_locks=no
1956       lockfile=
1957     fi
1958
1959     # Lock this critical section if it is needed
1960     # We use this script file to make the link, it avoids creating a new file
1961     if test "$need_locks" = yes; then
1962       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1963         func_echo "Waiting for $lockfile to be removed"
1964         sleep 2
1965       done
1966     elif test "$need_locks" = warn; then
1967       if test -f "$lockfile"; then
1968         $ECHO "\
1969 *** ERROR, $lockfile exists and contains:
1970 `cat $lockfile 2>/dev/null`
1971
1972 This indicates that another process is trying to use the same
1973 temporary object file, and libtool could not work around it because
1974 your compiler does not support \`-c' and \`-o' together.  If you
1975 repeat this compilation, it may succeed, by chance, but you had better
1976 avoid parallel builds (make -j) in this platform, or get a better
1977 compiler."
1978
1979         $opt_dry_run || $RM $removelist
1980         exit $EXIT_FAILURE
1981       fi
1982       removelist="$removelist $output_obj"
1983       $ECHO "$srcfile" > "$lockfile"
1984     fi
1985
1986     $opt_dry_run || $RM $removelist
1987     removelist="$removelist $lockfile"
1988     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1989
1990     if test -n "$fix_srcfile_path"; then
1991       eval srcfile=\"$fix_srcfile_path\"
1992     fi
1993     func_quote_for_eval "$srcfile"
1994     qsrcfile=$func_quote_for_eval_result
1995
1996     # Only build a PIC object if we are building libtool libraries.
1997     if test "$build_libtool_libs" = yes; then
1998       # Without this assignment, base_compile gets emptied.
1999       fbsd_hideous_sh_bug=$base_compile
2000
2001       if test "$pic_mode" != no; then
2002         command="$base_compile $qsrcfile $pic_flag"
2003       else
2004         # Don't build PIC code
2005         command="$base_compile $qsrcfile"
2006       fi
2007
2008       func_mkdir_p "$xdir$objdir"
2009
2010       if test -z "$output_obj"; then
2011         # Place PIC objects in $objdir
2012         command="$command -o $lobj"
2013       fi
2014
2015       func_show_eval_locale "$command"  \
2016           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2017
2018       if test "$need_locks" = warn &&
2019          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2020         $ECHO "\
2021 *** ERROR, $lockfile contains:
2022 `cat $lockfile 2>/dev/null`
2023
2024 but it should contain:
2025 $srcfile
2026
2027 This indicates that another process is trying to use the same
2028 temporary object file, and libtool could not work around it because
2029 your compiler does not support \`-c' and \`-o' together.  If you
2030 repeat this compilation, it may succeed, by chance, but you had better
2031 avoid parallel builds (make -j) in this platform, or get a better
2032 compiler."
2033
2034         $opt_dry_run || $RM $removelist
2035         exit $EXIT_FAILURE
2036       fi
2037
2038       # Just move the object if needed, then go on to compile the next one
2039       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2040         func_show_eval '$MV "$output_obj" "$lobj"' \
2041           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2042       fi
2043
2044       # Allow error messages only from the first compilation.
2045       if test "$suppress_opt" = yes; then
2046         suppress_output=' >/dev/null 2>&1'
2047       fi
2048     fi
2049
2050     # Only build a position-dependent object if we build old libraries.
2051     if test "$build_old_libs" = yes; then
2052       if test "$pic_mode" != yes; then
2053         # Don't build PIC code
2054         command="$base_compile $qsrcfile$pie_flag"
2055       else
2056         command="$base_compile $qsrcfile $pic_flag"
2057       fi
2058       if test "$compiler_c_o" = yes; then
2059         command="$command -o $obj"
2060       fi
2061
2062       # Suppress compiler output if we already did a PIC compilation.
2063       command="$command$suppress_output"
2064       func_show_eval_locale "$command" \
2065         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2066
2067       if test "$need_locks" = warn &&
2068          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2069         $ECHO "\
2070 *** ERROR, $lockfile contains:
2071 `cat $lockfile 2>/dev/null`
2072
2073 but it should contain:
2074 $srcfile
2075
2076 This indicates that another process is trying to use the same
2077 temporary object file, and libtool could not work around it because
2078 your compiler does not support \`-c' and \`-o' together.  If you
2079 repeat this compilation, it may succeed, by chance, but you had better
2080 avoid parallel builds (make -j) in this platform, or get a better
2081 compiler."
2082
2083         $opt_dry_run || $RM $removelist
2084         exit $EXIT_FAILURE
2085       fi
2086
2087       # Just move the object if needed
2088       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2089         func_show_eval '$MV "$output_obj" "$obj"' \
2090           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2091       fi
2092     fi
2093
2094     $opt_dry_run || {
2095       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2096
2097       # Unlock the critical section if it was locked
2098       if test "$need_locks" != no; then
2099         removelist=$lockfile
2100         $RM "$lockfile"
2101       fi
2102     }
2103
2104     exit $EXIT_SUCCESS
2105 }
2106
2107 $opt_help || {
2108   test "$mode" = compile && func_mode_compile ${1+"$@"}
2109 }
2110
2111 func_mode_help ()
2112 {
2113     # We need to display help for each of the modes.
2114     case $mode in
2115       "")
2116         # Generic help is extracted from the usage comments
2117         # at the start of this file.
2118         func_help
2119         ;;
2120
2121       clean)
2122         $ECHO \
2123 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2124
2125 Remove files from the build directory.
2126
2127 RM is the name of the program to use to delete files associated with each FILE
2128 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2129 to RM.
2130
2131 If FILE is a libtool library, object or program, all the files associated
2132 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2133         ;;
2134
2135       compile)
2136       $ECHO \
2137 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2138
2139 Compile a source file into a libtool library object.
2140
2141 This mode accepts the following additional options:
2142
2143   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
2144   -no-suppress      do not suppress compiler output for multiple passes
2145   -prefer-pic       try to build PIC objects only
2146   -prefer-non-pic   try to build non-PIC objects only
2147   -shared           do not build a \`.o' file suitable for static linking
2148   -static           only build a \`.o' file suitable for static linking
2149   -Wc,FLAG          pass FLAG directly to the compiler
2150
2151 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2152 from the given SOURCEFILE.
2153
2154 The output file name is determined by removing the directory component from
2155 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2156 library object suffix, \`.lo'."
2157         ;;
2158
2159       execute)
2160         $ECHO \
2161 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2162
2163 Automatically set library path, then run a program.
2164
2165 This mode accepts the following additional options:
2166
2167   -dlopen FILE      add the directory containing FILE to the library path
2168
2169 This mode sets the library path environment variable according to \`-dlopen'
2170 flags.
2171
2172 If any of the ARGS are libtool executable wrappers, then they are translated
2173 into their corresponding uninstalled binary, and any of their required library
2174 directories are added to the library path.
2175
2176 Then, COMMAND is executed, with ARGS as arguments."
2177         ;;
2178
2179       finish)
2180         $ECHO \
2181 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2182
2183 Complete the installation of libtool libraries.
2184
2185 Each LIBDIR is a directory that contains libtool libraries.
2186
2187 The commands that this mode executes may require superuser privileges.  Use
2188 the \`--dry-run' option if you just want to see what would be executed."
2189         ;;
2190
2191       install)
2192         $ECHO \
2193 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2194
2195 Install executables or libraries.
2196
2197 INSTALL-COMMAND is the installation command.  The first component should be
2198 either the \`install' or \`cp' program.
2199
2200 The following components of INSTALL-COMMAND are treated specially:
2201
2202   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2203
2204 The rest of the components are interpreted as arguments to that command (only
2205 BSD-compatible install options are recognized)."
2206         ;;
2207
2208       link)
2209         $ECHO \
2210 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2211
2212 Link object files or libraries together to form another library, or to
2213 create an executable program.
2214
2215 LINK-COMMAND is a command using the C compiler that you would use to create
2216 a program from several object files.
2217
2218 The following components of LINK-COMMAND are treated specially:
2219
2220   -all-static       do not do any dynamic linking at all
2221   -avoid-version    do not add a version suffix if possible
2222   -bindir BINDIR    specify path to binaries directory (for systems where
2223                     libraries must be found in the PATH setting at runtime)
2224   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2225   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2226   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2227   -export-symbols SYMFILE
2228                     try to export only the symbols listed in SYMFILE
2229   -export-symbols-regex REGEX
2230                     try to export only the symbols matching REGEX
2231   -LLIBDIR          search LIBDIR for required installed libraries
2232   -lNAME            OUTPUT-FILE requires the installed library libNAME
2233   -module           build a library that can dlopened
2234   -no-fast-install  disable the fast-install mode
2235   -no-install       link a not-installable executable
2236   -no-undefined     declare that a library does not refer to external symbols
2237   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2238   -objectlist FILE  Use a list of object files found in FILE to specify objects
2239   -precious-files-regex REGEX
2240                     don't remove output files matching REGEX
2241   -release RELEASE  specify package release information
2242   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2243   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2244   -shared           only do dynamic linking of libtool libraries
2245   -shrext SUFFIX    override the standard shared library file extension
2246   -static           do not do any dynamic linking of uninstalled libtool libraries
2247   -static-libtool-libs
2248                     do not do any dynamic linking of libtool libraries
2249   -version-info CURRENT[:REVISION[:AGE]]
2250                     specify library version info [each variable defaults to 0]
2251   -weak LIBNAME     declare that the target provides the LIBNAME interface
2252   -Wc,FLAG
2253   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
2254   -Wl,FLAG
2255   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
2256   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
2257
2258 All other options (arguments beginning with \`-') are ignored.
2259
2260 Every other argument is treated as a filename.  Files ending in \`.la' are
2261 treated as uninstalled libtool libraries, other files are standard or library
2262 object files.
2263
2264 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2265 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2266 required, except when creating a convenience library.
2267
2268 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2269 using \`ar' and \`ranlib', or on Windows using \`lib'.
2270
2271 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2272 is created, otherwise an executable program is created."
2273         ;;
2274
2275       uninstall)
2276         $ECHO \
2277 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2278
2279 Remove libraries from an installation directory.
2280
2281 RM is the name of the program to use to delete files associated with each FILE
2282 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2283 to RM.
2284
2285 If FILE is a libtool library, all the files associated with it are deleted.
2286 Otherwise, only FILE itself is deleted using RM."
2287         ;;
2288
2289       *)
2290         func_fatal_help "invalid operation mode \`$mode'"
2291         ;;
2292     esac
2293
2294     echo
2295     $ECHO "Try \`$progname --help' for more information about other modes."
2296 }
2297
2298 # Now that we've collected a possible --mode arg, show help if necessary
2299 if $opt_help; then
2300   if test "$opt_help" = :; then
2301     func_mode_help
2302   else
2303     {
2304       func_help noexit
2305       for mode in compile link execute install finish uninstall clean; do
2306         func_mode_help
2307       done
2308     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
2309     {
2310       func_help noexit
2311       for mode in compile link execute install finish uninstall clean; do
2312         echo
2313         func_mode_help
2314       done
2315     } |
2316     sed '1d
2317       /^When reporting/,/^Report/{
2318         H
2319         d
2320       }
2321       $x
2322       /information about other modes/d
2323       /more detailed .*MODE/d
2324       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2325   fi
2326   exit $?
2327 fi
2328
2329
2330 # func_mode_execute arg...
2331 func_mode_execute ()
2332 {
2333     $opt_debug
2334     # The first argument is the command name.
2335     cmd="$nonopt"
2336     test -z "$cmd" && \
2337       func_fatal_help "you must specify a COMMAND"
2338
2339     # Handle -dlopen flags immediately.
2340     for file in $execute_dlfiles; do
2341       test -f "$file" \
2342         || func_fatal_help "\`$file' is not a file"
2343
2344       dir=
2345       case $file in
2346       *.la)
2347         # Check to see that this really is a libtool archive.
2348         func_lalib_unsafe_p "$file" \
2349           || func_fatal_help "\`$lib' is not a valid libtool archive"
2350
2351         # Read the libtool library.
2352         dlname=
2353         library_names=
2354         func_source "$file"
2355
2356         # Skip this library if it cannot be dlopened.
2357         if test -z "$dlname"; then
2358           # Warn if it was a shared library.
2359           test -n "$library_names" && \
2360             func_warning "\`$file' was not linked with \`-export-dynamic'"
2361           continue
2362         fi
2363
2364         func_dirname "$file" "" "."
2365         dir="$func_dirname_result"
2366
2367         if test -f "$dir/$objdir/$dlname"; then
2368           dir="$dir/$objdir"
2369         else
2370           if test ! -f "$dir/$dlname"; then
2371             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2372           fi
2373         fi
2374         ;;
2375
2376       *.lo)
2377         # Just add the directory containing the .lo file.
2378         func_dirname "$file" "" "."
2379         dir="$func_dirname_result"
2380         ;;
2381
2382       *)
2383         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2384         continue
2385         ;;
2386       esac
2387
2388       # Get the absolute pathname.
2389       absdir=`cd "$dir" && pwd`
2390       test -n "$absdir" && dir="$absdir"
2391
2392       # Now add the directory to shlibpath_var.
2393       if eval "test -z \"\$$shlibpath_var\""; then
2394         eval "$shlibpath_var=\"\$dir\""
2395       else
2396         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2397       fi
2398     done
2399
2400     # This variable tells wrapper scripts just to set shlibpath_var
2401     # rather than running their programs.
2402     libtool_execute_magic="$magic"
2403
2404     # Check if any of the arguments is a wrapper script.
2405     args=
2406     for file
2407     do
2408       case $file in
2409       -* | *.la | *.lo ) ;;
2410       *)
2411         # Do a test to see if this is really a libtool program.
2412         if func_ltwrapper_script_p "$file"; then
2413           func_source "$file"
2414           # Transform arg to wrapped name.
2415           file="$progdir/$program"
2416         elif func_ltwrapper_executable_p "$file"; then
2417           func_ltwrapper_scriptname "$file"
2418           func_source "$func_ltwrapper_scriptname_result"
2419           # Transform arg to wrapped name.
2420           file="$progdir/$program"
2421         fi
2422         ;;
2423       esac
2424       # Quote arguments (to preserve shell metacharacters).
2425       func_quote_for_eval "$file"
2426       args="$args $func_quote_for_eval_result"
2427     done
2428
2429     if test "X$opt_dry_run" = Xfalse; then
2430       if test -n "$shlibpath_var"; then
2431         # Export the shlibpath_var.
2432         eval "export $shlibpath_var"
2433       fi
2434
2435       # Restore saved environment variables
2436       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2437       do
2438         eval "if test \"\${save_$lt_var+set}\" = set; then
2439                 $lt_var=\$save_$lt_var; export $lt_var
2440               else
2441                 $lt_unset $lt_var
2442               fi"
2443       done
2444
2445       # Now prepare to actually exec the command.
2446       exec_cmd="\$cmd$args"
2447     else
2448       # Display what would be done.
2449       if test -n "$shlibpath_var"; then
2450         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2451         echo "export $shlibpath_var"
2452       fi
2453       $ECHO "$cmd$args"
2454       exit $EXIT_SUCCESS
2455     fi
2456 }
2457
2458 test "$mode" = execute && func_mode_execute ${1+"$@"}
2459
2460
2461 # func_mode_finish arg...
2462 func_mode_finish ()
2463 {
2464     $opt_debug
2465     libdirs="$nonopt"
2466     admincmds=
2467
2468     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2469       for dir
2470       do
2471         libdirs="$libdirs $dir"
2472       done
2473
2474       for libdir in $libdirs; do
2475         if test -n "$finish_cmds"; then
2476           # Do each command in the finish commands.
2477           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2478 '"$cmd"'"'
2479         fi
2480         if test -n "$finish_eval"; then
2481           # Do the single finish_eval.
2482           eval cmds=\"$finish_eval\"
2483           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2484        $cmds"
2485         fi
2486       done
2487     fi
2488
2489     # Exit here if they wanted silent mode.
2490     $opt_silent && exit $EXIT_SUCCESS
2491
2492     echo "----------------------------------------------------------------------"
2493     echo "Libraries have been installed in:"
2494     for libdir in $libdirs; do
2495       $ECHO "   $libdir"
2496     done
2497     echo
2498     echo "If you ever happen to want to link against installed libraries"
2499     echo "in a given directory, LIBDIR, you must either use libtool, and"
2500     echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2501     echo "flag during linking and do at least one of the following:"
2502     if test -n "$shlibpath_var"; then
2503       echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2504       echo "     during execution"
2505     fi
2506     if test -n "$runpath_var"; then
2507       echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2508       echo "     during linking"
2509     fi
2510     if test -n "$hardcode_libdir_flag_spec"; then
2511       libdir=LIBDIR
2512       eval flag=\"$hardcode_libdir_flag_spec\"
2513
2514       $ECHO "   - use the \`$flag' linker flag"
2515     fi
2516     if test -n "$admincmds"; then
2517       $ECHO "   - have your system administrator run these commands:$admincmds"
2518     fi
2519     if test -f /etc/ld.so.conf; then
2520       echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2521     fi
2522     echo
2523
2524     echo "See any operating system documentation about shared libraries for"
2525     case $host in
2526       solaris2.[6789]|solaris2.1[0-9])
2527         echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2528         echo "pages."
2529         ;;
2530       *)
2531         echo "more information, such as the ld(1) and ld.so(8) manual pages."
2532         ;;
2533     esac
2534     echo "----------------------------------------------------------------------"
2535     exit $EXIT_SUCCESS
2536 }
2537
2538 test "$mode" = finish && func_mode_finish ${1+"$@"}
2539
2540
2541 # func_mode_install arg...
2542 func_mode_install ()
2543 {
2544     $opt_debug
2545     # There may be an optional sh(1) argument at the beginning of
2546     # install_prog (especially on Windows NT).
2547     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2548        # Allow the use of GNU shtool's install command.
2549        case $nonopt in *shtool*) :;; *) false;; esac; then
2550       # Aesthetically quote it.
2551       func_quote_for_eval "$nonopt"
2552       install_prog="$func_quote_for_eval_result "
2553       arg=$1
2554       shift
2555     else
2556       install_prog=
2557       arg=$nonopt
2558     fi
2559
2560     # The real first argument should be the name of the installation program.
2561     # Aesthetically quote it.
2562     func_quote_for_eval "$arg"
2563     install_prog="$install_prog$func_quote_for_eval_result"
2564     install_shared_prog=$install_prog
2565     case " $install_prog " in
2566       *[\\\ /]cp\ *) install_cp=: ;;
2567       *) install_cp=false ;;
2568     esac
2569
2570     # We need to accept at least all the BSD install flags.
2571     dest=
2572     files=
2573     opts=
2574     prev=
2575     install_type=
2576     isdir=no
2577     stripme=
2578     no_mode=:
2579     for arg
2580     do
2581       arg2=
2582       if test -n "$dest"; then
2583         files="$files $dest"
2584         dest=$arg
2585         continue
2586       fi
2587
2588       case $arg in
2589       -d) isdir=yes ;;
2590       -f)
2591         if $install_cp; then :; else
2592           prev=$arg
2593         fi
2594         ;;
2595       -g | -m | -o)
2596         prev=$arg
2597         ;;
2598       -s)
2599         stripme=" -s"
2600         continue
2601         ;;
2602       -*)
2603         ;;
2604       *)
2605         # If the previous option needed an argument, then skip it.
2606         if test -n "$prev"; then
2607           if test "x$prev" = x-m && test -n "$install_override_mode"; then
2608             arg2=$install_override_mode
2609             no_mode=false
2610           fi
2611           prev=
2612         else
2613           dest=$arg
2614           continue
2615         fi
2616         ;;
2617       esac
2618
2619       # Aesthetically quote the argument.
2620       func_quote_for_eval "$arg"
2621       install_prog="$install_prog $func_quote_for_eval_result"
2622       if test -n "$arg2"; then
2623         func_quote_for_eval "$arg2"
2624       fi
2625       install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2626     done
2627
2628     test -z "$install_prog" && \
2629       func_fatal_help "you must specify an install program"
2630
2631     test -n "$prev" && \
2632       func_fatal_help "the \`$prev' option requires an argument"
2633
2634     if test -n "$install_override_mode" && $no_mode; then
2635       if $install_cp; then :; else
2636         func_quote_for_eval "$install_override_mode"
2637         install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2638       fi
2639     fi
2640
2641     if test -z "$files"; then
2642       if test -z "$dest"; then
2643         func_fatal_help "no file or destination specified"
2644       else
2645         func_fatal_help "you must specify a destination"
2646       fi
2647     fi
2648
2649     # Strip any trailing slash from the destination.
2650     func_stripname '' '/' "$dest"
2651     dest=$func_stripname_result
2652
2653     # Check to see that the destination is a directory.
2654     test -d "$dest" && isdir=yes
2655     if test "$isdir" = yes; then
2656       destdir="$dest"
2657       destname=
2658     else
2659       func_dirname_and_basename "$dest" "" "."
2660       destdir="$func_dirname_result"
2661       destname="$func_basename_result"
2662
2663       # Not a directory, so check to see that there is only one file specified.
2664       set dummy $files; shift
2665       test "$#" -gt 1 && \
2666         func_fatal_help "\`$dest' is not a directory"
2667     fi
2668     case $destdir in
2669     [\\/]* | [A-Za-z]:[\\/]*) ;;
2670     *)
2671       for file in $files; do
2672         case $file in
2673         *.lo) ;;
2674         *)
2675           func_fatal_help "\`$destdir' must be an absolute directory name"
2676           ;;
2677         esac
2678       done
2679       ;;
2680     esac
2681
2682     # This variable tells wrapper scripts just to set variables rather
2683     # than running their programs.
2684     libtool_install_magic="$magic"
2685
2686     staticlibs=
2687     future_libdirs=
2688     current_libdirs=
2689     for file in $files; do
2690
2691       # Do each installation.
2692       case $file in
2693       *.$libext)
2694         # Do the static libraries later.
2695         staticlibs="$staticlibs $file"
2696         ;;
2697
2698       *.la)
2699         # Check to see that this really is a libtool archive.
2700         func_lalib_unsafe_p "$file" \
2701           || func_fatal_help "\`$file' is not a valid libtool archive"
2702
2703         library_names=
2704         old_library=
2705         relink_command=
2706         func_source "$file"
2707
2708         # Add the libdir to current_libdirs if it is the destination.
2709         if test "X$destdir" = "X$libdir"; then
2710           case "$current_libdirs " in
2711           *" $libdir "*) ;;
2712           *) current_libdirs="$current_libdirs $libdir" ;;
2713           esac
2714         else
2715           # Note the libdir as a future libdir.
2716           case "$future_libdirs " in
2717           *" $libdir "*) ;;
2718           *) future_libdirs="$future_libdirs $libdir" ;;
2719           esac
2720         fi
2721
2722         func_dirname "$file" "/" ""
2723         dir="$func_dirname_result"
2724         dir="$dir$objdir"
2725
2726         if test -n "$relink_command"; then
2727           # Determine the prefix the user has applied to our future dir.
2728           inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2729
2730           # Don't allow the user to place us outside of our expected
2731           # location b/c this prevents finding dependent libraries that
2732           # are installed to the same prefix.
2733           # At present, this check doesn't affect windows .dll's that
2734           # are installed into $libdir/../bin (currently, that works fine)
2735           # but it's something to keep an eye on.
2736           test "$inst_prefix_dir" = "$destdir" && \
2737             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2738
2739           if test -n "$inst_prefix_dir"; then
2740             # Stick the inst_prefix_dir data into the link command.
2741             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2742           else
2743             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2744           fi
2745
2746           func_warning "relinking \`$file'"
2747           func_show_eval "$relink_command" \
2748             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2749         fi
2750
2751         # See the names of the shared library.
2752         set dummy $library_names; shift
2753         if test -n "$1"; then
2754           realname="$1"
2755           shift
2756
2757           srcname="$realname"
2758           test -n "$relink_command" && srcname="$realname"T
2759
2760           # Install the shared library and build the symlinks.
2761           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2762               'exit $?'
2763           tstripme="$stripme"
2764           case $host_os in
2765           cygwin* | mingw* | pw32* | cegcc*)
2766             case $realname in
2767             *.dll.a)
2768               tstripme=""
2769               ;;
2770             esac
2771             ;;
2772           esac
2773           if test -n "$tstripme" && test -n "$striplib"; then
2774             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2775           fi
2776
2777           if test "$#" -gt 0; then
2778             # Delete the old symlinks, and create new ones.
2779             # Try `ln -sf' first, because the `ln' binary might depend on
2780             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2781             # so we also need to try rm && ln -s.
2782             for linkname
2783             do
2784               test "$linkname" != "$realname" \
2785                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2786             done
2787           fi
2788
2789           # Do each command in the postinstall commands.
2790           lib="$destdir/$realname"
2791           func_execute_cmds "$postinstall_cmds" 'exit $?'
2792         fi
2793
2794         # Install the pseudo-library for information purposes.
2795         func_basename "$file"
2796         name="$func_basename_result"
2797         instname="$dir/$name"i
2798         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2799
2800         # Maybe install the static library, too.
2801         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2802         ;;
2803
2804       *.lo)
2805         # Install (i.e. copy) a libtool object.
2806
2807         # Figure out destination file name, if it wasn't already specified.
2808         if test -n "$destname"; then
2809           destfile="$destdir/$destname"
2810         else
2811           func_basename "$file"
2812           destfile="$func_basename_result"
2813           destfile="$destdir/$destfile"
2814         fi
2815
2816         # Deduce the name of the destination old-style object file.
2817         case $destfile in
2818         *.lo)
2819           func_lo2o "$destfile"
2820           staticdest=$func_lo2o_result
2821           ;;
2822         *.$objext)
2823           staticdest="$destfile"
2824           destfile=
2825           ;;
2826         *)
2827           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2828           ;;
2829         esac
2830
2831         # Install the libtool object if requested.
2832         test -n "$destfile" && \
2833           func_show_eval "$install_prog $file $destfile" 'exit $?'
2834
2835         # Install the old object if enabled.
2836         if test "$build_old_libs" = yes; then
2837           # Deduce the name of the old-style object file.
2838           func_lo2o "$file"
2839           staticobj=$func_lo2o_result
2840           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2841         fi
2842         exit $EXIT_SUCCESS
2843         ;;
2844
2845       *)
2846         # Figure out destination file name, if it wasn't already specified.
2847         if test -n "$destname"; then
2848           destfile="$destdir/$destname"
2849         else
2850           func_basename "$file"
2851           destfile="$func_basename_result"
2852           destfile="$destdir/$destfile"
2853         fi
2854
2855         # If the file is missing, and there is a .exe on the end, strip it
2856         # because it is most likely a libtool script we actually want to
2857         # install
2858         stripped_ext=""
2859         case $file in
2860           *.exe)
2861             if test ! -f "$file"; then
2862               func_stripname '' '.exe' "$file"
2863               file=$func_stripname_result
2864               stripped_ext=".exe"
2865             fi
2866             ;;
2867         esac
2868
2869         # Do a test to see if this is really a libtool program.
2870         case $host in
2871         *cygwin* | *mingw*)
2872             if func_ltwrapper_executable_p "$file"; then
2873               func_ltwrapper_scriptname "$file"
2874               wrapper=$func_ltwrapper_scriptname_result
2875             else
2876               func_stripname '' '.exe' "$file"
2877               wrapper=$func_stripname_result
2878             fi
2879             ;;
2880         *)
2881             wrapper=$file
2882             ;;
2883         esac
2884         if func_ltwrapper_script_p "$wrapper"; then
2885           notinst_deplibs=
2886           relink_command=
2887
2888           func_source "$wrapper"
2889
2890           # Check the variables that should have been set.
2891           test -z "$generated_by_libtool_version" && \
2892             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2893
2894           finalize=yes
2895           for lib in $notinst_deplibs; do
2896             # Check to see that each library is installed.
2897             libdir=
2898             if test -f "$lib"; then
2899               func_source "$lib"
2900             fi
2901             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2902             if test -n "$libdir" && test ! -f "$libfile"; then
2903               func_warning "\`$lib' has not been installed in \`$libdir'"
2904               finalize=no
2905             fi
2906           done
2907
2908           relink_command=
2909           func_source "$wrapper"
2910
2911           outputname=
2912           if test "$fast_install" = no && test -n "$relink_command"; then
2913             $opt_dry_run || {
2914               if test "$finalize" = yes; then
2915                 tmpdir=`func_mktempdir`
2916                 func_basename "$file$stripped_ext"
2917                 file="$func_basename_result"
2918                 outputname="$tmpdir/$file"
2919                 # Replace the output file specification.
2920                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2921
2922                 $opt_silent || {
2923                   func_quote_for_expand "$relink_command"
2924                   eval "func_echo $func_quote_for_expand_result"
2925                 }
2926                 if eval "$relink_command"; then :
2927                   else
2928                   func_error "error: relink \`$file' with the above command before installing it"
2929                   $opt_dry_run || ${RM}r "$tmpdir"
2930                   continue
2931                 fi
2932                 file="$outputname"
2933               else
2934                 func_warning "cannot relink \`$file'"
2935               fi
2936             }
2937           else
2938             # Install the binary that we compiled earlier.
2939             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2940           fi
2941         fi
2942
2943         # remove .exe since cygwin /usr/bin/install will append another
2944         # one anyway
2945         case $install_prog,$host in
2946         */usr/bin/install*,*cygwin*)
2947           case $file:$destfile in
2948           *.exe:*.exe)
2949             # this is ok
2950             ;;
2951           *.exe:*)
2952             destfile=$destfile.exe
2953             ;;
2954           *:*.exe)
2955             func_stripname '' '.exe' "$destfile"
2956             destfile=$func_stripname_result
2957             ;;
2958           esac
2959           ;;
2960         esac
2961         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2962         $opt_dry_run || if test -n "$outputname"; then
2963           ${RM}r "$tmpdir"
2964         fi
2965         ;;
2966       esac
2967     done
2968
2969     for file in $staticlibs; do
2970       func_basename "$file"
2971       name="$func_basename_result"
2972
2973       # Set up the ranlib parameters.
2974       oldlib="$destdir/$name"
2975
2976       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2977
2978       if test -n "$stripme" && test -n "$old_striplib"; then
2979         func_show_eval "$old_striplib $oldlib" 'exit $?'
2980       fi
2981
2982       # Do each command in the postinstall commands.
2983       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2984     done
2985
2986     test -n "$future_libdirs" && \
2987       func_warning "remember to run \`$progname --finish$future_libdirs'"
2988
2989     if test -n "$current_libdirs"; then
2990       # Maybe just do a dry run.
2991       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2992       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2993     else
2994       exit $EXIT_SUCCESS
2995     fi
2996 }
2997
2998 test "$mode" = install && func_mode_install ${1+"$@"}
2999
3000
3001 # func_generate_dlsyms outputname originator pic_p
3002 # Extract symbols from dlprefiles and create ${outputname}S.o with
3003 # a dlpreopen symbol table.
3004 func_generate_dlsyms ()
3005 {
3006     $opt_debug
3007     my_outputname="$1"
3008     my_originator="$2"
3009     my_pic_p="${3-no}"
3010     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3011     my_dlsyms=
3012
3013     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3014       if test -n "$NM" && test -n "$global_symbol_pipe"; then
3015         my_dlsyms="${my_outputname}S.c"
3016       else
3017         func_error "not configured to extract global symbols from dlpreopened files"
3018       fi
3019     fi
3020
3021     if test -n "$my_dlsyms"; then
3022       case $my_dlsyms in
3023       "") ;;
3024       *.c)
3025         # Discover the nlist of each of the dlfiles.
3026         nlist="$output_objdir/${my_outputname}.nm"
3027
3028         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3029
3030         # Parse the name list into a source file.
3031         func_verbose "creating $output_objdir/$my_dlsyms"
3032
3033         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3034 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3035 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3036
3037 #ifdef __cplusplus
3038 extern \"C\" {
3039 #endif
3040
3041 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3042 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3043 #endif
3044
3045 /* External symbol declarations for the compiler. */\
3046 "
3047
3048         if test "$dlself" = yes; then
3049           func_verbose "generating symbol list for \`$output'"
3050
3051           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3052
3053           # Add our own program objects to the symbol list.
3054           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3055           for progfile in $progfiles; do
3056             func_verbose "extracting global C symbols from \`$progfile'"
3057             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
3058           done
3059
3060           if test -n "$exclude_expsyms"; then
3061             $opt_dry_run || {
3062               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3063               eval '$MV "$nlist"T "$nlist"'
3064             }
3065           fi
3066
3067           if test -n "$export_symbols_regex"; then
3068             $opt_dry_run || {
3069               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3070               eval '$MV "$nlist"T "$nlist"'
3071             }
3072           fi
3073
3074           # Prepare the list of exported symbols
3075           if test -z "$export_symbols"; then
3076             export_symbols="$output_objdir/$outputname.exp"
3077             $opt_dry_run || {
3078               $RM $export_symbols
3079               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3080               case $host in
3081               *cygwin* | *mingw* | *cegcc* )
3082                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3083                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3084                 ;;
3085               esac
3086             }
3087           else
3088             $opt_dry_run || {
3089               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3090               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3091               eval '$MV "$nlist"T "$nlist"'
3092               case $host in
3093                 *cygwin* | *mingw* | *cegcc* )
3094                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3095                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3096                   ;;
3097               esac
3098             }
3099           fi
3100         fi
3101
3102         for dlprefile in $dlprefiles; do
3103           func_verbose "extracting global C symbols from \`$dlprefile'"
3104           func_basename "$dlprefile"
3105           name="$func_basename_result"
3106           $opt_dry_run || {
3107             eval '$ECHO ": $name " >> "$nlist"'
3108             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3109           }
3110         done
3111
3112         $opt_dry_run || {
3113           # Make sure we have at least an empty file.
3114           test -f "$nlist" || : > "$nlist"
3115
3116           if test -n "$exclude_expsyms"; then
3117             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3118             $MV "$nlist"T "$nlist"
3119           fi
3120
3121           # Try sorting and uniquifying the output.
3122           if $GREP -v "^: " < "$nlist" |
3123               if sort -k 3 </dev/null >/dev/null 2>&1; then
3124                 sort -k 3
3125               else
3126                 sort +2
3127               fi |
3128               uniq > "$nlist"S; then
3129             :
3130           else
3131             $GREP -v "^: " < "$nlist" > "$nlist"S
3132           fi
3133
3134           if test -f "$nlist"S; then
3135             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3136           else
3137             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3138           fi
3139
3140           echo >> "$output_objdir/$my_dlsyms" "\
3141
3142 /* The mapping between symbol names and symbols.  */
3143 typedef struct {
3144   const char *name;
3145   void *address;
3146 } lt_dlsymlist;
3147 "
3148           case $host in
3149           *cygwin* | *mingw* | *cegcc* )
3150             echo >> "$output_objdir/$my_dlsyms" "\
3151 /* DATA imports from DLLs on WIN32 con't be const, because
3152    runtime relocations are performed -- see ld's documentation
3153    on pseudo-relocs.  */"
3154             lt_dlsym_const= ;;
3155           *osf5*)
3156             echo >> "$output_objdir/$my_dlsyms" "\
3157 /* This system does not cope well with relocations in const data */"
3158             lt_dlsym_const= ;;
3159           *)
3160             lt_dlsym_const=const ;;
3161           esac
3162
3163           echo >> "$output_objdir/$my_dlsyms" "\
3164 extern $lt_dlsym_const lt_dlsymlist
3165 lt_${my_prefix}_LTX_preloaded_symbols[];
3166 $lt_dlsym_const lt_dlsymlist
3167 lt_${my_prefix}_LTX_preloaded_symbols[] =
3168 {\
3169   { \"$my_originator\", (void *) 0 },"
3170
3171           case $need_lib_prefix in
3172           no)
3173             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3174             ;;
3175           *)
3176             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3177             ;;
3178           esac
3179           echo >> "$output_objdir/$my_dlsyms" "\
3180   {0, (void *) 0}
3181 };
3182
3183 /* This works around a problem in FreeBSD linker */
3184 #ifdef FREEBSD_WORKAROUND
3185 static const void *lt_preloaded_setup() {
3186   return lt_${my_prefix}_LTX_preloaded_symbols;
3187 }
3188 #endif
3189
3190 #ifdef __cplusplus
3191 }
3192 #endif\
3193 "
3194         } # !$opt_dry_run
3195
3196         pic_flag_for_symtable=
3197         case "$compile_command " in
3198         *" -static "*) ;;
3199         *)
3200           case $host in
3201           # compiling the symbol table file with pic_flag works around
3202           # a FreeBSD bug that causes programs to crash when -lm is
3203           # linked before any other PIC object.  But we must not use
3204           # pic_flag when linking with -static.  The problem exists in
3205           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3206           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3207             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3208           *-*-hpux*)
3209             pic_flag_for_symtable=" $pic_flag"  ;;
3210           *)
3211             if test "X$my_pic_p" != Xno; then
3212               pic_flag_for_symtable=" $pic_flag"
3213             fi
3214             ;;
3215           esac
3216           ;;
3217         esac
3218         symtab_cflags=
3219         for arg in $LTCFLAGS; do
3220           case $arg in
3221           -pie | -fpie | -fPIE) ;;
3222           *) symtab_cflags="$symtab_cflags $arg" ;;
3223           esac
3224         done
3225
3226         # Now compile the dynamic symbol file.
3227         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3228
3229         # Clean up the generated files.
3230         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3231
3232         # Transform the symbol file into the correct name.
3233         symfileobj="$output_objdir/${my_outputname}S.$objext"
3234         case $host in
3235         *cygwin* | *mingw* | *cegcc* )
3236           if test -f "$output_objdir/$my_outputname.def"; then
3237             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3238             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3239           else
3240             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3241             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3242           fi
3243           ;;
3244         *)
3245           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3246           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3247           ;;
3248         esac
3249         ;;
3250       *)
3251         func_fatal_error "unknown suffix for \`$my_dlsyms'"
3252         ;;
3253       esac
3254     else
3255       # We keep going just in case the user didn't refer to
3256       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3257       # really was required.
3258
3259       # Nullify the symbol file.
3260       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3261       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3262     fi
3263 }
3264
3265 # func_win32_libid arg
3266 # return the library type of file 'arg'
3267 #
3268 # Need a lot of goo to handle *both* DLLs and import libs
3269 # Has to be a shell function in order to 'eat' the argument
3270 # that is supplied when $file_magic_command is called.
3271 # Despite the name, also deal with 64 bit binaries.
3272 func_win32_libid ()
3273 {
3274   $opt_debug
3275   win32_libid_type="unknown"
3276   win32_fileres=`file -L $1 2>/dev/null`
3277   case $win32_fileres in
3278   *ar\ archive\ import\ library*) # definitely import
3279     win32_libid_type="x86 archive import"
3280     ;;
3281   *ar\ archive*) # could be an import, or static
3282     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3283     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3284        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3285       win32_nmres=`eval $NM -f posix -A $1 |
3286         $SED -n -e '
3287             1,100{
3288                 / I /{
3289                     s,.*,import,
3290                     p
3291                     q
3292                 }
3293             }'`
3294       case $win32_nmres in
3295       import*)  win32_libid_type="x86 archive import";;
3296       *)        win32_libid_type="x86 archive static";;
3297       esac
3298     fi
3299     ;;
3300   *DLL*)
3301     win32_libid_type="x86 DLL"
3302     ;;
3303   *executable*) # but shell scripts are "executable" too...
3304     case $win32_fileres in
3305     *MS\ Windows\ PE\ Intel*)
3306       win32_libid_type="x86 DLL"
3307       ;;
3308     esac
3309     ;;
3310   esac
3311   $ECHO "$win32_libid_type"
3312 }
3313
3314
3315
3316 # func_extract_an_archive dir oldlib
3317 func_extract_an_archive ()
3318 {
3319     $opt_debug
3320     f_ex_an_ar_dir="$1"; shift
3321     f_ex_an_ar_oldlib="$1"
3322     if test "$lock_old_archive_extraction" = yes; then
3323       lockfile=$f_ex_an_ar_oldlib.lock
3324       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3325         func_echo "Waiting for $lockfile to be removed"
3326         sleep 2
3327       done
3328     fi
3329     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3330                    'stat=$?; rm -f "$lockfile"; exit $stat'
3331     if test "$lock_old_archive_extraction" = yes; then
3332       $opt_dry_run || rm -f "$lockfile"
3333     fi
3334     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3335      :
3336     else
3337       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3338     fi
3339 }
3340
3341
3342 # func_extract_archives gentop oldlib ...
3343 func_extract_archives ()
3344 {
3345     $opt_debug
3346     my_gentop="$1"; shift
3347     my_oldlibs=${1+"$@"}
3348     my_oldobjs=""
3349     my_xlib=""
3350     my_xabs=""
3351     my_xdir=""
3352
3353     for my_xlib in $my_oldlibs; do
3354       # Extract the objects.
3355       case $my_xlib in
3356         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3357         *) my_xabs=`pwd`"/$my_xlib" ;;
3358       esac
3359       func_basename "$my_xlib"
3360       my_xlib="$func_basename_result"
3361       my_xlib_u=$my_xlib
3362       while :; do
3363         case " $extracted_archives " in
3364         *" $my_xlib_u "*)
3365           func_arith $extracted_serial + 1
3366           extracted_serial=$func_arith_result
3367           my_xlib_u=lt$extracted_serial-$my_xlib ;;
3368         *) break ;;
3369         esac
3370       done
3371       extracted_archives="$extracted_archives $my_xlib_u"
3372       my_xdir="$my_gentop/$my_xlib_u"
3373
3374       func_mkdir_p "$my_xdir"
3375
3376       case $host in
3377       *-darwin*)
3378         func_verbose "Extracting $my_xabs"
3379         # Do not bother doing anything if just a dry run
3380         $opt_dry_run || {
3381           darwin_orig_dir=`pwd`
3382           cd $my_xdir || exit $?
3383           darwin_archive=$my_xabs
3384           darwin_curdir=`pwd`
3385           darwin_base_archive=`basename "$darwin_archive"`
3386           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3387           if test -n "$darwin_arches"; then
3388             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3389             darwin_arch=
3390             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3391             for darwin_arch in  $darwin_arches ; do
3392               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3393               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3394               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3395               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3396               cd "$darwin_curdir"
3397               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3398             done # $darwin_arches
3399             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3400             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3401             darwin_file=
3402             darwin_files=
3403             for darwin_file in $darwin_filelist; do
3404               darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3405               $LIPO -create -output "$darwin_file" $darwin_files
3406             done # $darwin_filelist
3407             $RM -rf unfat-$$
3408             cd "$darwin_orig_dir"
3409           else
3410             cd $darwin_orig_dir
3411             func_extract_an_archive "$my_xdir" "$my_xabs"
3412           fi # $darwin_arches
3413         } # !$opt_dry_run
3414         ;;
3415       *)
3416         func_extract_an_archive "$my_xdir" "$my_xabs"
3417         ;;
3418       esac
3419       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3420     done
3421
3422     func_extract_archives_result="$my_oldobjs"
3423 }
3424
3425
3426 # func_emit_wrapper [arg=no]
3427 #
3428 # Emit a libtool wrapper script on stdout.
3429 # Don't directly open a file because we may want to
3430 # incorporate the script contents within a cygwin/mingw
3431 # wrapper executable.  Must ONLY be called from within
3432 # func_mode_link because it depends on a number of variables
3433 # set therein.
3434 #
3435 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3436 # variable will take.  If 'yes', then the emitted script
3437 # will assume that the directory in which it is stored is
3438 # the $objdir directory.  This is a cygwin/mingw-specific
3439 # behavior.
3440 func_emit_wrapper ()
3441 {
3442         func_emit_wrapper_arg1=${1-no}
3443
3444         $ECHO "\
3445 #! $SHELL
3446
3447 # $output - temporary wrapper script for $objdir/$outputname
3448 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3449 #
3450 # The $output program cannot be directly executed until all the libtool
3451 # libraries that it depends on are installed.
3452 #
3453 # This wrapper script should never be moved out of the build directory.
3454 # If it is, it will not operate correctly.
3455
3456 # Sed substitution that helps us do robust quoting.  It backslashifies
3457 # metacharacters that are still active within double-quoted strings.
3458 sed_quote_subst='$sed_quote_subst'
3459
3460 # Be Bourne compatible
3461 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3462   emulate sh
3463   NULLCMD=:
3464   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3465   # is contrary to our usage.  Disable this feature.
3466   alias -g '\${1+\"\$@\"}'='\"\$@\"'
3467   setopt NO_GLOB_SUBST
3468 else
3469   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3470 fi
3471 BIN_SH=xpg4; export BIN_SH # for Tru64
3472 DUALCASE=1; export DUALCASE # for MKS sh
3473
3474 # The HP-UX ksh and POSIX shell print the target directory to stdout
3475 # if CDPATH is set.
3476 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3477
3478 relink_command=\"$relink_command\"
3479
3480 # This environment variable determines our operation mode.
3481 if test \"\$libtool_install_magic\" = \"$magic\"; then
3482   # install mode needs the following variables:
3483   generated_by_libtool_version='$macro_version'
3484   notinst_deplibs='$notinst_deplibs'
3485 else
3486   # When we are sourced in execute mode, \$file and \$ECHO are already set.
3487   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3488     file=\"\$0\""
3489
3490     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3491     $ECHO "\
3492
3493 # A function that is used when there is no print builtin or printf.
3494 func_fallback_echo ()
3495 {
3496   eval 'cat <<_LTECHO_EOF
3497 \$1
3498 _LTECHO_EOF'
3499 }
3500     ECHO=\"$qECHO\"
3501   fi
3502
3503 # Very basic option parsing. These options are (a) specific to
3504 # the libtool wrapper, (b) are identical between the wrapper
3505 # /script/ and the wrapper /executable/ which is used only on
3506 # windows platforms, and (c) all begin with the string "--lt-"
3507 # (application programs are unlikely to have options which match
3508 # this pattern).
3509 #
3510 # There are only two supported options: --lt-debug and
3511 # --lt-dump-script. There is, deliberately, no --lt-help.
3512 #
3513 # The first argument to this parsing function should be the
3514 # script's $0 value, followed by "$@".
3515 lt_option_debug=
3516 func_parse_lt_options ()
3517 {
3518   lt_script_arg0=\$0
3519   shift
3520   for lt_opt
3521   do
3522     case \"\$lt_opt\" in
3523     --lt-debug) lt_option_debug=1 ;;
3524     --lt-dump-script)
3525         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3526         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3527         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3528         cat \"\$lt_dump_D/\$lt_dump_F\"
3529         exit 0
3530       ;;
3531     --lt-*)
3532         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3533         exit 1
3534       ;;
3535     esac
3536   done
3537
3538   # Print the debug banner immediately:
3539   if test -n \"\$lt_option_debug\"; then
3540     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3541   fi
3542 }
3543
3544 # Used when --lt-debug. Prints its arguments to stdout
3545 # (redirection is the responsibility of the caller)
3546 func_lt_dump_args ()
3547 {
3548   lt_dump_args_N=1;
3549   for lt_arg
3550   do
3551     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3552     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3553   done
3554 }
3555
3556 # Core function for launching the target application
3557 func_exec_program_core ()
3558 {
3559 "
3560   case $host in
3561   # Backslashes separate directories on plain windows
3562   *-*-mingw | *-*-os2* | *-cegcc*)
3563     $ECHO "\
3564       if test -n \"\$lt_option_debug\"; then
3565         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3566         func_lt_dump_args \${1+\"\$@\"} 1>&2
3567       fi
3568       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3569 "
3570     ;;
3571
3572   *)
3573     $ECHO "\
3574       if test -n \"\$lt_option_debug\"; then
3575         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3576         func_lt_dump_args \${1+\"\$@\"} 1>&2
3577       fi
3578       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3579 "
3580     ;;
3581   esac
3582   $ECHO "\
3583       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3584       exit 1
3585 }
3586
3587 # A function to encapsulate launching the target application
3588 # Strips options in the --lt-* namespace from \$@ and
3589 # launches target application with the remaining arguments.
3590 func_exec_program ()
3591 {
3592   for lt_wr_arg
3593   do
3594     case \$lt_wr_arg in
3595     --lt-*) ;;
3596     *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3597     esac
3598     shift
3599   done
3600   func_exec_program_core \${1+\"\$@\"}
3601 }
3602
3603   # Parse options
3604   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3605
3606   # Find the directory that this script lives in.
3607   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3608   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3609
3610   # Follow symbolic links until we get to the real thisdir.
3611   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3612   while test -n \"\$file\"; do
3613     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3614
3615     # If there was a directory component, then change thisdir.
3616     if test \"x\$destdir\" != \"x\$file\"; then
3617       case \"\$destdir\" in
3618       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3619       *) thisdir=\"\$thisdir/\$destdir\" ;;
3620       esac
3621     fi
3622
3623     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3624     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3625   done
3626
3627   # Usually 'no', except on cygwin/mingw when embedded into
3628   # the cwrapper.
3629   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3630   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3631     # special case for '.'
3632     if test \"\$thisdir\" = \".\"; then
3633       thisdir=\`pwd\`
3634     fi
3635     # remove .libs from thisdir
3636     case \"\$thisdir\" in
3637     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3638     $objdir )   thisdir=. ;;
3639     esac
3640   fi
3641
3642   # Try to get the absolute directory name.
3643   absdir=\`cd \"\$thisdir\" && pwd\`
3644   test -n \"\$absdir\" && thisdir=\"\$absdir\"
3645 "
3646
3647         if test "$fast_install" = yes; then
3648           $ECHO "\
3649   program=lt-'$outputname'$exeext
3650   progdir=\"\$thisdir/$objdir\"
3651
3652   if test ! -f \"\$progdir/\$program\" ||
3653      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3654        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3655
3656     file=\"\$\$-\$program\"
3657
3658     if test ! -d \"\$progdir\"; then
3659       $MKDIR \"\$progdir\"
3660     else
3661       $RM \"\$progdir/\$file\"
3662     fi"
3663
3664           $ECHO "\
3665
3666     # relink executable if necessary
3667     if test -n \"\$relink_command\"; then
3668       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3669       else
3670         $ECHO \"\$relink_command_output\" >&2
3671         $RM \"\$progdir/\$file\"
3672         exit 1
3673       fi
3674     fi
3675
3676     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3677     { $RM \"\$progdir/\$program\";
3678       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3679     $RM \"\$progdir/\$file\"
3680   fi"
3681         else
3682           $ECHO "\
3683   program='$outputname'
3684   progdir=\"\$thisdir/$objdir\"
3685 "
3686         fi
3687
3688         $ECHO "\
3689
3690   if test -f \"\$progdir/\$program\"; then"
3691
3692         # Export our shlibpath_var if we have one.
3693         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3694           $ECHO "\
3695     # Add our own library path to $shlibpath_var
3696     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3697
3698     # Some systems cannot cope with colon-terminated $shlibpath_var
3699     # The second colon is a workaround for a bug in BeOS R4 sed
3700     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3701
3702     export $shlibpath_var
3703 "
3704         fi
3705
3706         # fixup the dll searchpath if we need to.
3707         if test -n "$dllsearchpath"; then
3708           $ECHO "\
3709     # Add the dll search path components to the executable PATH
3710     PATH=$dllsearchpath:\$PATH
3711 "
3712         fi
3713
3714         $ECHO "\
3715     if test \"\$libtool_execute_magic\" != \"$magic\"; then
3716       # Run the actual program with our arguments.
3717       func_exec_program \${1+\"\$@\"}
3718     fi
3719   else
3720     # The program doesn't exist.
3721     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3722     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3723     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3724     exit 1
3725   fi
3726 fi\
3727 "
3728 }
3729
3730
3731 # func_to_host_path arg
3732 #
3733 # Convert paths to host format when used with build tools.
3734 # Intended for use with "native" mingw (where libtool itself
3735 # is running under the msys shell), or in the following cross-
3736 # build environments:
3737 #    $build          $host
3738 #    mingw (msys)    mingw  [e.g. native]
3739 #    cygwin          mingw
3740 #    *nix + wine     mingw
3741 # where wine is equipped with the `winepath' executable.
3742 # In the native mingw case, the (msys) shell automatically
3743 # converts paths for any non-msys applications it launches,
3744 # but that facility isn't available from inside the cwrapper.
3745 # Similar accommodations are necessary for $host mingw and
3746 # $build cygwin.  Calling this function does no harm for other
3747 # $host/$build combinations not listed above.
3748 #
3749 # ARG is the path (on $build) that should be converted to
3750 # the proper representation for $host. The result is stored
3751 # in $func_to_host_path_result.
3752 func_to_host_path ()
3753 {
3754   func_to_host_path_result="$1"
3755   if test -n "$1"; then
3756     case $host in
3757       *mingw* )
3758         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3759         case $build in
3760           *mingw* ) # actually, msys
3761             # awkward: cmd appends spaces to result
3762             func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3763               $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3764             ;;
3765           *cygwin* )
3766             func_to_host_path_result=`cygpath -w "$1" |
3767               $SED -e "$lt_sed_naive_backslashify"`
3768             ;;
3769           * )
3770             # Unfortunately, winepath does not exit with a non-zero
3771             # error code, so we are forced to check the contents of
3772             # stdout. On the other hand, if the command is not
3773             # found, the shell will set an exit code of 127 and print
3774             # *an error message* to stdout. So we must check for both
3775             # error code of zero AND non-empty stdout, which explains
3776             # the odd construction:
3777             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3778             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3779               func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3780                 $SED -e "$lt_sed_naive_backslashify"`
3781             else
3782               # Allow warning below.
3783               func_to_host_path_result=
3784             fi
3785             ;;
3786         esac
3787         if test -z "$func_to_host_path_result" ; then
3788           func_error "Could not determine host path corresponding to"
3789           func_error "  \`$1'"
3790           func_error "Continuing, but uninstalled executables may not work."
3791           # Fallback:
3792           func_to_host_path_result="$1"
3793         fi
3794         ;;
3795     esac
3796   fi
3797 }
3798 # end: func_to_host_path
3799
3800 # func_to_host_pathlist arg
3801 #
3802 # Convert pathlists to host format when used with build tools.
3803 # See func_to_host_path(), above. This function supports the
3804 # following $build/$host combinations (but does no harm for
3805 # combinations not listed here):
3806 #    $build          $host
3807 #    mingw (msys)    mingw  [e.g. native]
3808 #    cygwin          mingw
3809 #    *nix + wine     mingw
3810 #
3811 # Path separators are also converted from $build format to
3812 # $host format. If ARG begins or ends with a path separator
3813 # character, it is preserved (but converted to $host format)
3814 # on output.
3815 #
3816 # ARG is a pathlist (on $build) that should be converted to
3817 # the proper representation on $host. The result is stored
3818 # in $func_to_host_pathlist_result.
3819 func_to_host_pathlist ()
3820 {
3821   func_to_host_pathlist_result="$1"
3822   if test -n "$1"; then
3823     case $host in
3824       *mingw* )
3825         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'