Add GSM HR reference codec that is automatically downloaded from 3gpp.org
[lcr.git] / libtool
1 #! /bin/sh
2
3 # libtool - Provide generalized library-building support services.
4 # Generated automatically by config.status (lcr) 1.14
5 # Libtool was configured on host netbook:
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="CXX "
39
40 # ### BEGIN LIBTOOL CONFIG
41
42 # Which release of libtool.m4 was used?
43 macro_version=2.4
44 macro_revision=1.3293
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=needless
57
58 # Shell to use when invoking shell scripts.
59 SHELL="/bin/sh"
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=1572864
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="-g -O2"
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=yes
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/gcc/i686-pc-linux-gnu/4.4.5 /usr/i686-pc-linux-gnu/lib /usr/lib /lib "
241
242 # Run-time system search path for libraries.
243 sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/local/lib /usr/i686-pc-linux-gnu/lib /opt/uhd/lib //usr/lib/opengl/xorg-x11/lib /usr/lib/gcc/i686-pc-linux-gnu/4.4.5 /usr/lib/qt4 "
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/i686-pc-linux-gnu/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 # The directories searched by this compiler when creating a shared library.
398 compiler_lib_search_dirs=""
399
400 # Dependencies to place before and after the objects being linked to
401 # create a shared library.
402 predep_objects=""
403 postdep_objects=""
404 predeps=""
405 postdeps=""
406
407 # The library search path used internally by the compiler when linking
408 # a shared library.
409 compiler_lib_search_path=""
410
411 # ### END LIBTOOL CONFIG
412
413
414 # libtool (GNU libtool) 2.4
415 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
416
417 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
418 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
419 # This is free software; see the source for copying conditions.  There is NO
420 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
421
422 # GNU Libtool is free software; you can redistribute it and/or modify
423 # it under the terms of the GNU General Public License as published by
424 # the Free Software Foundation; either version 2 of the License, or
425 # (at your option) any later version.
426 #
427 # As a special exception to the GNU General Public License,
428 # if you distribute this file as part of a program or library that
429 # is built using GNU Libtool, you may include this file under the
430 # same distribution terms that you use for the rest of that program.
431 #
432 # GNU Libtool is distributed in the hope that it will be useful, but
433 # WITHOUT ANY WARRANTY; without even the implied warranty of
434 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
435 # General Public License for more details.
436 #
437 # You should have received a copy of the GNU General Public License
438 # along with GNU Libtool; see the file COPYING.  If not, a copy
439 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
440 # or obtained by writing to the Free Software Foundation, Inc.,
441 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
442
443 # Usage: $progname [OPTION]... [MODE-ARG]...
444 #
445 # Provide generalized library-building support services.
446 #
447 #       --config             show all configuration variables
448 #       --debug              enable verbose shell tracing
449 #   -n, --dry-run            display commands without modifying any files
450 #       --features           display basic configuration information and exit
451 #       --mode=MODE          use operation mode MODE
452 #       --preserve-dup-deps  don't remove duplicate dependency libraries
453 #       --quiet, --silent    don't print informational messages
454 #       --no-quiet, --no-silent
455 #                            print informational messages (default)
456 #       --tag=TAG            use configuration variables from tag TAG
457 #   -v, --verbose            print more informational messages than default
458 #       --no-verbose         don't print the extra informational messages
459 #       --version            print version information
460 #   -h, --help, --help-all   print short, long, or detailed help message
461 #
462 # MODE must be one of the following:
463 #
464 #         clean              remove files from the build directory
465 #         compile            compile a source file into a libtool object
466 #         execute            automatically set library path, then run a program
467 #         finish             complete the installation of libtool libraries
468 #         install            install libraries or executables
469 #         link               create a library or an executable
470 #         uninstall          remove libraries from an installed directory
471 #
472 # MODE-ARGS vary depending on the MODE.  When passed as first option,
473 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
474 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
475 #
476 # When reporting a bug, please describe a test case to reproduce it and
477 # include the following information:
478 #
479 #         host-triplet: $host
480 #         shell:                $SHELL
481 #         compiler:             $LTCC
482 #         compiler flags:               $LTCFLAGS
483 #         linker:               $LD (gnu? $with_gnu_ld)
484 #         $progname:    (GNU libtool) 2.4
485 #         automake:     $automake_version
486 #         autoconf:     $autoconf_version
487 #
488 # Report bugs to <bug-libtool@gnu.org>.
489 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
490 # General help using GNU software: <http://www.gnu.org/gethelp/>.
491
492 PROGRAM=libtool
493 PACKAGE=libtool
494 VERSION=2.4
495 TIMESTAMP=""
496 package_revision=1.3293
497
498 # Be Bourne compatible
499 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
500   emulate sh
501   NULLCMD=:
502   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
503   # is contrary to our usage.  Disable this feature.
504   alias -g '${1+"$@"}'='"$@"'
505   setopt NO_GLOB_SUBST
506 else
507   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
508 fi
509 BIN_SH=xpg4; export BIN_SH # for Tru64
510 DUALCASE=1; export DUALCASE # for MKS sh
511
512 # A function that is used when there is no print builtin or printf.
513 func_fallback_echo ()
514 {
515   eval 'cat <<_LTECHO_EOF
516 $1
517 _LTECHO_EOF'
518 }
519
520 # NLS nuisances: We save the old values to restore during execute mode.
521 lt_user_locale=
522 lt_safe_locale=
523 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
524 do
525   eval "if test \"\${$lt_var+set}\" = set; then
526           save_$lt_var=\$$lt_var
527           $lt_var=C
528           export $lt_var
529           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
530           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
531         fi"
532 done
533 LC_ALL=C
534 LANGUAGE=C
535 export LANGUAGE LC_ALL
536
537 $lt_unset CDPATH
538
539
540 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
541 # is ksh but when the shell is invoked as "sh" and the current value of
542 # the _XPG environment variable is not equal to 1 (one), the special
543 # positional parameter $0, within a function call, is the name of the
544 # function.
545 progpath="$0"
546
547
548
549 : ${CP="cp -f"}
550 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
551 : ${EGREP="grep -E"}
552 : ${FGREP="grep -F"}
553 : ${GREP="grep"}
554 : ${LN_S="ln -s"}
555 : ${MAKE="make"}
556 : ${MKDIR="mkdir"}
557 : ${MV="mv -f"}
558 : ${RM="rm -f"}
559 : ${SED="sed"}
560 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
561 : ${Xsed="$SED -e 1s/^X//"}
562
563 # Global variables:
564 EXIT_SUCCESS=0
565 EXIT_FAILURE=1
566 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
567 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
568
569 exit_status=$EXIT_SUCCESS
570
571 # Make sure IFS has a sensible default
572 lt_nl='
573 '
574 IFS="   $lt_nl"
575
576 dirname="s,/[^/]*$,,"
577 basename="s,^.*/,,"
578
579 # func_dirname file append nondir_replacement
580 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
581 # otherwise set result to NONDIR_REPLACEMENT.
582 func_dirname ()
583 {
584     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
585     if test "X$func_dirname_result" = "X${1}"; then
586       func_dirname_result="${3}"
587     else
588       func_dirname_result="$func_dirname_result${2}"
589     fi
590 } # func_dirname may be replaced by extended shell implementation
591
592
593 # func_basename file
594 func_basename ()
595 {
596     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
597 } # func_basename may be replaced by extended shell implementation
598
599
600 # func_dirname_and_basename file append nondir_replacement
601 # perform func_basename and func_dirname in a single function
602 # call:
603 #   dirname:  Compute the dirname of FILE.  If nonempty,
604 #             add APPEND to the result, otherwise set result
605 #             to NONDIR_REPLACEMENT.
606 #             value returned in "$func_dirname_result"
607 #   basename: Compute filename of FILE.
608 #             value retuned in "$func_basename_result"
609 # Implementation must be kept synchronized with func_dirname
610 # and func_basename. For efficiency, we do not delegate to
611 # those functions but instead duplicate the functionality here.
612 func_dirname_and_basename ()
613 {
614     # Extract subdirectory from the argument.
615     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
616     if test "X$func_dirname_result" = "X${1}"; then
617       func_dirname_result="${3}"
618     else
619       func_dirname_result="$func_dirname_result${2}"
620     fi
621     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
622 } # func_dirname_and_basename may be replaced by extended shell implementation
623
624
625 # func_stripname prefix suffix name
626 # strip PREFIX and SUFFIX off of NAME.
627 # PREFIX and SUFFIX must not contain globbing or regex special
628 # characters, hashes, percent signs, but SUFFIX may contain a leading
629 # dot (in which case that matches only a dot).
630 # func_strip_suffix prefix name
631 func_stripname ()
632 {
633     case ${2} in
634       .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
635       *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
636     esac
637 } # func_stripname may be replaced by extended shell implementation
638
639
640 # These SED scripts presuppose an absolute path with a trailing slash.
641 pathcar='s,^/\([^/]*\).*$,\1,'
642 pathcdr='s,^/[^/]*,,'
643 removedotparts=':dotsl
644                 s@/\./@/@g
645                 t dotsl
646                 s,/\.$,/,'
647 collapseslashes='s@/\{1,\}@/@g'
648 finalslash='s,/*$,/,'
649
650 # func_normal_abspath PATH
651 # Remove doubled-up and trailing slashes, "." path components,
652 # and cancel out any ".." path components in PATH after making
653 # it an absolute path.
654 #             value returned in "$func_normal_abspath_result"
655 func_normal_abspath ()
656 {
657   # Start from root dir and reassemble the path.
658   func_normal_abspath_result=
659   func_normal_abspath_tpath=$1
660   func_normal_abspath_altnamespace=
661   case $func_normal_abspath_tpath in
662     "")
663       # Empty path, that just means $cwd.
664       func_stripname '' '/' "`pwd`"
665       func_normal_abspath_result=$func_stripname_result
666       return
667     ;;
668     # The next three entries are used to spot a run of precisely
669     # two leading slashes without using negated character classes;
670     # we take advantage of case's first-match behaviour.
671     ///*)
672       # Unusual form of absolute path, do nothing.
673     ;;
674     //*)
675       # Not necessarily an ordinary path; POSIX reserves leading '//'
676       # and for example Cygwin uses it to access remote file shares
677       # over CIFS/SMB, so we conserve a leading double slash if found.
678       func_normal_abspath_altnamespace=/
679     ;;
680     /*)
681       # Absolute path, do nothing.
682     ;;
683     *)
684       # Relative path, prepend $cwd.
685       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
686     ;;
687   esac
688   # Cancel out all the simple stuff to save iterations.  We also want
689   # the path to end with a slash for ease of parsing, so make sure
690   # there is one (and only one) here.
691   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
692         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
693   while :; do
694     # Processed it all yet?
695     if test "$func_normal_abspath_tpath" = / ; then
696       # If we ascended to the root using ".." the result may be empty now.
697       if test -z "$func_normal_abspath_result" ; then
698         func_normal_abspath_result=/
699       fi
700       break
701     fi
702     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
703         -e "$pathcar"`
704     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
705         -e "$pathcdr"`
706     # Figure out what to do with it
707     case $func_normal_abspath_tcomponent in
708       "")
709         # Trailing empty path component, ignore it.
710       ;;
711       ..)
712         # Parent dir; strip last assembled component from result.
713         func_dirname "$func_normal_abspath_result"
714         func_normal_abspath_result=$func_dirname_result
715       ;;
716       *)
717         # Actual path component, append it.
718         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
719       ;;
720     esac
721   done
722   # Restore leading double-slash if one was found on entry.
723   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
724 }
725
726 # func_relative_path SRCDIR DSTDIR
727 # generates a relative path from SRCDIR to DSTDIR, with a trailing
728 # slash if non-empty, suitable for immediately appending a filename
729 # without needing to append a separator.
730 #             value returned in "$func_relative_path_result"
731 func_relative_path ()
732 {
733   func_relative_path_result=
734   func_normal_abspath "$1"
735   func_relative_path_tlibdir=$func_normal_abspath_result
736   func_normal_abspath "$2"
737   func_relative_path_tbindir=$func_normal_abspath_result
738
739   # Ascend the tree starting from libdir
740   while :; do
741     # check if we have found a prefix of bindir
742     case $func_relative_path_tbindir in
743       $func_relative_path_tlibdir)
744         # found an exact match
745         func_relative_path_tcancelled=
746         break
747         ;;
748       $func_relative_path_tlibdir*)
749         # found a matching prefix
750         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
751         func_relative_path_tcancelled=$func_stripname_result
752         if test -z "$func_relative_path_result"; then
753           func_relative_path_result=.
754         fi
755         break
756         ;;
757       *)
758         func_dirname $func_relative_path_tlibdir
759         func_relative_path_tlibdir=${func_dirname_result}
760         if test "x$func_relative_path_tlibdir" = x ; then
761           # Have to descend all the way to the root!
762           func_relative_path_result=../$func_relative_path_result
763           func_relative_path_tcancelled=$func_relative_path_tbindir
764           break
765         fi
766         func_relative_path_result=../$func_relative_path_result
767         ;;
768     esac
769   done
770
771   # Now calculate path; take care to avoid doubling-up slashes.
772   func_stripname '' '/' "$func_relative_path_result"
773   func_relative_path_result=$func_stripname_result
774   func_stripname '/' '/' "$func_relative_path_tcancelled"
775   if test "x$func_stripname_result" != x ; then
776     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
777   fi
778
779   # Normalisation. If bindir is libdir, return empty string,
780   # else relative path ending with a slash; either way, target
781   # file name can be directly appended.
782   if test ! -z "$func_relative_path_result"; then
783     func_stripname './' '' "$func_relative_path_result/"
784     func_relative_path_result=$func_stripname_result
785   fi
786 }
787
788 # The name of this program:
789 func_dirname_and_basename "$progpath"
790 progname=$func_basename_result
791
792 # Make sure we have an absolute path for reexecution:
793 case $progpath in
794   [\\/]*|[A-Za-z]:\\*) ;;
795   *[\\/]*)
796      progdir=$func_dirname_result
797      progdir=`cd "$progdir" && pwd`
798      progpath="$progdir/$progname"
799      ;;
800   *)
801      save_IFS="$IFS"
802      IFS=:
803      for progdir in $PATH; do
804        IFS="$save_IFS"
805        test -x "$progdir/$progname" && break
806      done
807      IFS="$save_IFS"
808      test -n "$progdir" || progdir=`pwd`
809      progpath="$progdir/$progname"
810      ;;
811 esac
812
813 # Sed substitution that helps us do robust quoting.  It backslashifies
814 # metacharacters that are still active within double-quoted strings.
815 Xsed="${SED}"' -e 1s/^X//'
816 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
817
818 # Same as above, but do not quote variable references.
819 double_quote_subst='s/\(["`\\]\)/\\\1/g'
820
821 # Sed substitution that turns a string into a regex matching for the
822 # string literally.
823 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
824
825 # Sed substitution that converts a w32 file name or path
826 # which contains forward slashes, into one that contains
827 # (escaped) backslashes.  A very naive implementation.
828 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
829
830 # Re-`\' parameter expansions in output of double_quote_subst that were
831 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
832 # in input to double_quote_subst, that '$' was protected from expansion.
833 # Since each input `\' is now two `\'s, look for any number of runs of
834 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
835 bs='\\'
836 bs2='\\\\'
837 bs4='\\\\\\\\'
838 dollar='\$'
839 sed_double_backslash="\
840   s/$bs4/&\\
841 /g
842   s/^$bs2$dollar/$bs&/
843   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
844   s/\n//g"
845
846 # Standard options:
847 opt_dry_run=false
848 opt_help=false
849 opt_quiet=false
850 opt_verbose=false
851 opt_warning=:
852
853 # func_echo arg...
854 # Echo program name prefixed message, along with the current mode
855 # name if it has been set yet.
856 func_echo ()
857 {
858     $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
859 }
860
861 # func_verbose arg...
862 # Echo program name prefixed message in verbose mode only.
863 func_verbose ()
864 {
865     $opt_verbose && func_echo ${1+"$@"}
866
867     # A bug in bash halts the script if the last line of a function
868     # fails when set -e is in force, so we need another command to
869     # work around that:
870     :
871 }
872
873 # func_echo_all arg...
874 # Invoke $ECHO with all args, space-separated.
875 func_echo_all ()
876 {
877     $ECHO "$*"
878 }
879
880 # func_error arg...
881 # Echo program name prefixed message to standard error.
882 func_error ()
883 {
884     $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
885 }
886
887 # func_warning arg...
888 # Echo program name prefixed warning message to standard error.
889 func_warning ()
890 {
891     $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
892
893     # bash bug again:
894     :
895 }
896
897 # func_fatal_error arg...
898 # Echo program name prefixed message to standard error, and exit.
899 func_fatal_error ()
900 {
901     func_error ${1+"$@"}
902     exit $EXIT_FAILURE
903 }
904
905 # func_fatal_help arg...
906 # Echo program name prefixed message to standard error, followed by
907 # a help hint, and exit.
908 func_fatal_help ()
909 {
910     func_error ${1+"$@"}
911     func_fatal_error "$help"
912 }
913 help="Try \`$progname --help' for more information."  ## default
914
915
916 # func_grep expression filename
917 # Check whether EXPRESSION matches any line of FILENAME, without output.
918 func_grep ()
919 {
920     $GREP "$1" "$2" >/dev/null 2>&1
921 }
922
923
924 # func_mkdir_p directory-path
925 # Make sure the entire path to DIRECTORY-PATH is available.
926 func_mkdir_p ()
927 {
928     my_directory_path="$1"
929     my_dir_list=
930
931     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
932
933       # Protect directory names starting with `-'
934       case $my_directory_path in
935         -*) my_directory_path="./$my_directory_path" ;;
936       esac
937
938       # While some portion of DIR does not yet exist...
939       while test ! -d "$my_directory_path"; do
940         # ...make a list in topmost first order.  Use a colon delimited
941         # list incase some portion of path contains whitespace.
942         my_dir_list="$my_directory_path:$my_dir_list"
943
944         # If the last portion added has no slash in it, the list is done
945         case $my_directory_path in */*) ;; *) break ;; esac
946
947         # ...otherwise throw away the child directory and loop
948         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
949       done
950       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
951
952       save_mkdir_p_IFS="$IFS"; IFS=':'
953       for my_dir in $my_dir_list; do
954         IFS="$save_mkdir_p_IFS"
955         # mkdir can fail with a `File exist' error if two processes
956         # try to create one of the directories concurrently.  Don't
957         # stop in that case!
958         $MKDIR "$my_dir" 2>/dev/null || :
959       done
960       IFS="$save_mkdir_p_IFS"
961
962       # Bail out if we (or some other process) failed to create a directory.
963       test -d "$my_directory_path" || \
964         func_fatal_error "Failed to create \`$1'"
965     fi
966 }
967
968
969 # func_mktempdir [string]
970 # Make a temporary directory that won't clash with other running
971 # libtool processes, and avoids race conditions if possible.  If
972 # given, STRING is the basename for that directory.
973 func_mktempdir ()
974 {
975     my_template="${TMPDIR-/tmp}/${1-$progname}"
976
977     if test "$opt_dry_run" = ":"; then
978       # Return a directory name, but don't create it in dry-run mode
979       my_tmpdir="${my_template}-$$"
980     else
981
982       # If mktemp works, use that first and foremost
983       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
984
985       if test ! -d "$my_tmpdir"; then
986         # Failing that, at least try and use $RANDOM to avoid a race
987         my_tmpdir="${my_template}-${RANDOM-0}$$"
988
989         save_mktempdir_umask=`umask`
990         umask 0077
991         $MKDIR "$my_tmpdir"
992         umask $save_mktempdir_umask
993       fi
994
995       # If we're not in dry-run mode, bomb out on failure
996       test -d "$my_tmpdir" || \
997         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
998     fi
999
1000     $ECHO "$my_tmpdir"
1001 }
1002
1003
1004 # func_quote_for_eval arg
1005 # Aesthetically quote ARG to be evaled later.
1006 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
1007 # is double-quoted, suitable for a subsequent eval, whereas
1008 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
1009 # which are still active within double quotes backslashified.
1010 func_quote_for_eval ()
1011 {
1012     case $1 in
1013       *[\\\`\"\$]*)
1014         func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
1015       *)
1016         func_quote_for_eval_unquoted_result="$1" ;;
1017     esac
1018
1019     case $func_quote_for_eval_unquoted_result in
1020       # Double-quote args containing shell metacharacters to delay
1021       # word splitting, command substitution and and variable
1022       # expansion for a subsequent eval.
1023       # Many Bourne shells cannot handle close brackets correctly
1024       # in scan sets, so we specify it separately.
1025       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1026         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
1027         ;;
1028       *)
1029         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
1030     esac
1031 }
1032
1033
1034 # func_quote_for_expand arg
1035 # Aesthetically quote ARG to be evaled later; same as above,
1036 # but do not quote variable references.
1037 func_quote_for_expand ()
1038 {
1039     case $1 in
1040       *[\\\`\"]*)
1041         my_arg=`$ECHO "$1" | $SED \
1042             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
1043       *)
1044         my_arg="$1" ;;
1045     esac
1046
1047     case $my_arg in
1048       # Double-quote args containing shell metacharacters to delay
1049       # word splitting and command substitution for a subsequent eval.
1050       # Many Bourne shells cannot handle close brackets correctly
1051       # in scan sets, so we specify it separately.
1052       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1053         my_arg="\"$my_arg\""
1054         ;;
1055     esac
1056
1057     func_quote_for_expand_result="$my_arg"
1058 }
1059
1060
1061 # func_show_eval cmd [fail_exp]
1062 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
1063 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
1064 # is given, then evaluate it.
1065 func_show_eval ()
1066 {
1067     my_cmd="$1"
1068     my_fail_exp="${2-:}"
1069
1070     ${opt_silent-false} || {
1071       func_quote_for_expand "$my_cmd"
1072       eval "func_echo $func_quote_for_expand_result"
1073     }
1074
1075     if ${opt_dry_run-false}; then :; else
1076       eval "$my_cmd"
1077       my_status=$?
1078       if test "$my_status" -eq 0; then :; else
1079         eval "(exit $my_status); $my_fail_exp"
1080       fi
1081     fi
1082 }
1083
1084
1085 # func_show_eval_locale cmd [fail_exp]
1086 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
1087 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
1088 # is given, then evaluate it.  Use the saved locale for evaluation.
1089 func_show_eval_locale ()
1090 {
1091     my_cmd="$1"
1092     my_fail_exp="${2-:}"
1093
1094     ${opt_silent-false} || {
1095       func_quote_for_expand "$my_cmd"
1096       eval "func_echo $func_quote_for_expand_result"
1097     }
1098
1099     if ${opt_dry_run-false}; then :; else
1100       eval "$lt_user_locale
1101             $my_cmd"
1102       my_status=$?
1103       eval "$lt_safe_locale"
1104       if test "$my_status" -eq 0; then :; else
1105         eval "(exit $my_status); $my_fail_exp"
1106       fi
1107     fi
1108 }
1109
1110 # func_tr_sh
1111 # Turn $1 into a string suitable for a shell variable name.
1112 # Result is stored in $func_tr_sh_result.  All characters
1113 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
1114 # if $1 begins with a digit, a '_' is prepended as well.
1115 func_tr_sh ()
1116 {
1117   case $1 in
1118   [0-9]* | *[!a-zA-Z0-9_]*)
1119     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
1120     ;;
1121   * )
1122     func_tr_sh_result=$1
1123     ;;
1124   esac
1125 }
1126
1127
1128 # func_version
1129 # Echo version message to standard output and exit.
1130 func_version ()
1131 {
1132     $opt_debug
1133
1134     $SED -n '/(C)/!b go
1135         :more
1136         /\./!{
1137           N
1138           s/\n# / /
1139           b more
1140         }
1141         :go
1142         /^# '$PROGRAM' (GNU /,/# warranty; / {
1143         s/^# //
1144         s/^# *$//
1145         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
1146         p
1147      }' < "$progpath"
1148      exit $?
1149 }
1150
1151 # func_usage
1152 # Echo short help message to standard output and exit.
1153 func_usage ()
1154 {
1155     $opt_debug
1156
1157     $SED -n '/^# Usage:/,/^#  *.*--help/ {
1158         s/^# //
1159         s/^# *$//
1160         s/\$progname/'$progname'/
1161         p
1162     }' < "$progpath"
1163     echo
1164     $ECHO "run \`$progname --help | more' for full usage"
1165     exit $?
1166 }
1167
1168 # func_help [NOEXIT]
1169 # Echo long help message to standard output and exit,
1170 # unless 'noexit' is passed as argument.
1171 func_help ()
1172 {
1173     $opt_debug
1174
1175     $SED -n '/^# Usage:/,/# Report bugs to/ {
1176         :print
1177         s/^# //
1178         s/^# *$//
1179         s*\$progname*'$progname'*
1180         s*\$host*'"$host"'*
1181         s*\$SHELL*'"$SHELL"'*
1182         s*\$LTCC*'"$LTCC"'*
1183         s*\$LTCFLAGS*'"$LTCFLAGS"'*
1184         s*\$LD*'"$LD"'*
1185         s/\$with_gnu_ld/'"$with_gnu_ld"'/
1186         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1187         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1188         p
1189         d
1190      }
1191      /^# .* home page:/b print
1192      /^# General help using/b print
1193      ' < "$progpath"
1194     ret=$?
1195     if test -z "$1"; then
1196       exit $ret
1197     fi
1198 }
1199
1200 # func_missing_arg argname
1201 # Echo program name prefixed message to standard error and set global
1202 # exit_cmd.
1203 func_missing_arg ()
1204 {
1205     $opt_debug
1206
1207     func_error "missing argument for $1."
1208     exit_cmd=exit
1209 }
1210
1211
1212 # func_split_short_opt shortopt
1213 # Set func_split_short_opt_name and func_split_short_opt_arg shell
1214 # variables after splitting SHORTOPT after the 2nd character.
1215 func_split_short_opt ()
1216 {
1217     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
1218     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
1219
1220     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
1221     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
1222 } # func_split_short_opt may be replaced by extended shell implementation
1223
1224
1225 # func_split_long_opt longopt
1226 # Set func_split_long_opt_name and func_split_long_opt_arg shell
1227 # variables after splitting LONGOPT at the `=' sign.
1228 func_split_long_opt ()
1229 {
1230     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
1231     my_sed_long_arg='1s/^--[^=]*=//'
1232
1233     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
1234     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
1235 } # func_split_long_opt may be replaced by extended shell implementation
1236
1237 exit_cmd=:
1238
1239
1240
1241
1242
1243 magic="%%%MAGIC variable%%%"
1244 magic_exe="%%%MAGIC EXE variable%%%"
1245
1246 # Global variables.
1247 nonopt=
1248 preserve_args=
1249 lo2o="s/\\.lo\$/.${objext}/"
1250 o2lo="s/\\.${objext}\$/.lo/"
1251 extracted_archives=
1252 extracted_serial=0
1253
1254 # If this variable is set in any of the actions, the command in it
1255 # will be execed at the end.  This prevents here-documents from being
1256 # left over by shells.
1257 exec_cmd=
1258
1259 # func_append var value
1260 # Append VALUE to the end of shell variable VAR.
1261 func_append ()
1262 {
1263     eval "${1}=\$${1}\${2}"
1264 } # func_append may be replaced by extended shell implementation
1265
1266 # func_append_quoted var value
1267 # Quote VALUE and append to the end of shell variable VAR, separated
1268 # by a space.
1269 func_append_quoted ()
1270 {
1271     func_quote_for_eval "${2}"
1272     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
1273 } # func_append_quoted may be replaced by extended shell implementation
1274
1275
1276 # func_arith arithmetic-term...
1277 func_arith ()
1278 {
1279     func_arith_result=`expr "${@}"`
1280 } # func_arith may be replaced by extended shell implementation
1281
1282
1283 # func_len string
1284 # STRING may not start with a hyphen.
1285 func_len ()
1286 {
1287     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
1288 } # func_len may be replaced by extended shell implementation
1289
1290
1291 # func_lo2o object
1292 func_lo2o ()
1293 {
1294     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
1295 } # func_lo2o may be replaced by extended shell implementation
1296
1297
1298 # func_xform libobj-or-source
1299 func_xform ()
1300 {
1301     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
1302 } # func_xform may be replaced by extended shell implementation
1303
1304
1305 # func_fatal_configuration arg...
1306 # Echo program name prefixed message to standard error, followed by
1307 # a configuration failure hint, and exit.
1308 func_fatal_configuration ()
1309 {
1310     func_error ${1+"$@"}
1311     func_error "See the $PACKAGE documentation for more information."
1312     func_fatal_error "Fatal configuration error."
1313 }
1314
1315
1316 # func_config
1317 # Display the configuration for all the tags in this script.
1318 func_config ()
1319 {
1320     re_begincf='^# ### BEGIN LIBTOOL'
1321     re_endcf='^# ### END LIBTOOL'
1322
1323     # Default configuration.
1324     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1325
1326     # Now print the configurations for the tags.
1327     for tagname in $taglist; do
1328       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1329     done
1330
1331     exit $?
1332 }
1333
1334 # func_features
1335 # Display the features supported by this script.
1336 func_features ()
1337 {
1338     echo "host: $host"
1339     if test "$build_libtool_libs" = yes; then
1340       echo "enable shared libraries"
1341     else
1342       echo "disable shared libraries"
1343     fi
1344     if test "$build_old_libs" = yes; then
1345       echo "enable static libraries"
1346     else
1347       echo "disable static libraries"
1348     fi
1349
1350     exit $?
1351 }
1352
1353 # func_enable_tag tagname
1354 # Verify that TAGNAME is valid, and either flag an error and exit, or
1355 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
1356 # variable here.
1357 func_enable_tag ()
1358 {
1359   # Global variable:
1360   tagname="$1"
1361
1362   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1363   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1364   sed_extractcf="/$re_begincf/,/$re_endcf/p"
1365
1366   # Validate tagname.
1367   case $tagname in
1368     *[!-_A-Za-z0-9,/]*)
1369       func_fatal_error "invalid tag name: $tagname"
1370       ;;
1371   esac
1372
1373   # Don't test for the "default" C tag, as we know it's
1374   # there but not specially marked.
1375   case $tagname in
1376     CC) ;;
1377     *)
1378       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1379         taglist="$taglist $tagname"
1380
1381         # Evaluate the configuration.  Be careful to quote the path
1382         # and the sed script, to avoid splitting on whitespace, but
1383         # also don't use non-portable quotes within backquotes within
1384         # quotes we have to do it in 2 steps:
1385         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1386         eval "$extractedcf"
1387       else
1388         func_error "ignoring unknown tag $tagname"
1389       fi
1390       ;;
1391   esac
1392 }
1393
1394 # func_check_version_match
1395 # Ensure that we are using m4 macros, and libtool script from the same
1396 # release of libtool.
1397 func_check_version_match ()
1398 {
1399   if test "$package_revision" != "$macro_revision"; then
1400     if test "$VERSION" != "$macro_version"; then
1401       if test -z "$macro_version"; then
1402         cat >&2 <<_LT_EOF
1403 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1404 $progname: definition of this LT_INIT comes from an older release.
1405 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1406 $progname: and run autoconf again.
1407 _LT_EOF
1408       else
1409         cat >&2 <<_LT_EOF
1410 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1411 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1412 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1413 $progname: and run autoconf again.
1414 _LT_EOF
1415       fi
1416     else
1417       cat >&2 <<_LT_EOF
1418 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1419 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1420 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1421 $progname: of $PACKAGE $VERSION and run autoconf again.
1422 _LT_EOF
1423     fi
1424
1425     exit $EXIT_MISMATCH
1426   fi
1427 }
1428
1429
1430 # Shorthand for --mode=foo, only valid as the first argument
1431 case $1 in
1432 clean|clea|cle|cl)
1433   shift; set dummy --mode clean ${1+"$@"}; shift
1434   ;;
1435 compile|compil|compi|comp|com|co|c)
1436   shift; set dummy --mode compile ${1+"$@"}; shift
1437   ;;
1438 execute|execut|execu|exec|exe|ex|e)
1439   shift; set dummy --mode execute ${1+"$@"}; shift
1440   ;;
1441 finish|finis|fini|fin|fi|f)
1442   shift; set dummy --mode finish ${1+"$@"}; shift
1443   ;;
1444 install|instal|insta|inst|ins|in|i)
1445   shift; set dummy --mode install ${1+"$@"}; shift
1446   ;;
1447 link|lin|li|l)
1448   shift; set dummy --mode link ${1+"$@"}; shift
1449   ;;
1450 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1451   shift; set dummy --mode uninstall ${1+"$@"}; shift
1452   ;;
1453 esac
1454
1455
1456
1457 # Option defaults:
1458 opt_debug=:
1459 opt_dry_run=false
1460 opt_config=false
1461 opt_preserve_dup_deps=false
1462 opt_features=false
1463 opt_finish=false
1464 opt_help=false
1465 opt_help_all=false
1466 opt_silent=:
1467 opt_verbose=:
1468 opt_silent=false
1469 opt_verbose=false
1470
1471
1472 # Parse options once, thoroughly.  This comes as soon as possible in the
1473 # script to make things like `--version' happen as quickly as we can.
1474 {
1475   # this just eases exit handling
1476   while test $# -gt 0; do
1477     opt="$1"
1478     shift
1479     case $opt in
1480       --debug|-x)       opt_debug='set -x'
1481                         func_echo "enabling shell trace mode"
1482                         $opt_debug
1483                         ;;
1484       --dry-run|--dryrun|-n)
1485                         opt_dry_run=:
1486                         ;;
1487       --config)
1488                         opt_config=:
1489 func_config
1490                         ;;
1491       --dlopen|-dlopen)
1492                         optarg="$1"
1493                         opt_dlopen="${opt_dlopen+$opt_dlopen
1494 }$optarg"
1495                         shift
1496                         ;;
1497       --preserve-dup-deps)
1498                         opt_preserve_dup_deps=:
1499                         ;;
1500       --features)
1501                         opt_features=:
1502 func_features
1503                         ;;
1504       --finish)
1505                         opt_finish=:
1506 set dummy --mode finish ${1+"$@"}; shift
1507                         ;;
1508       --help)
1509                         opt_help=:
1510                         ;;
1511       --help-all)
1512                         opt_help_all=:
1513 opt_help=': help-all'
1514                         ;;
1515       --mode)
1516                         test $# = 0 && func_missing_arg $opt && break
1517                         optarg="$1"
1518                         opt_mode="$optarg"
1519 case $optarg in
1520   # Valid mode arguments:
1521   clean|compile|execute|finish|install|link|relink|uninstall) ;;
1522
1523   # Catch anything else as an error
1524   *) func_error "invalid argument for $opt"
1525      exit_cmd=exit
1526      break
1527      ;;
1528 esac
1529                         shift
1530                         ;;
1531       --no-silent|--no-quiet)
1532                         opt_silent=false
1533 func_append preserve_args " $opt"
1534                         ;;
1535       --no-verbose)
1536                         opt_verbose=false
1537 func_append preserve_args " $opt"
1538                         ;;
1539       --silent|--quiet)
1540                         opt_silent=:
1541 func_append preserve_args " $opt"
1542         opt_verbose=false
1543                         ;;
1544       --verbose|-v)
1545                         opt_verbose=:
1546 func_append preserve_args " $opt"
1547 opt_silent=false
1548                         ;;
1549       --tag)
1550                         test $# = 0 && func_missing_arg $opt && break
1551                         optarg="$1"
1552                         opt_tag="$optarg"
1553 func_append preserve_args " $opt $optarg"
1554 func_enable_tag "$optarg"
1555                         shift
1556                         ;;
1557
1558       -\?|-h)           func_usage                              ;;
1559       --help)           func_help                               ;;
1560       --version)        func_version                            ;;
1561
1562       # Separate optargs to long options:
1563       --*=*)
1564                         func_split_long_opt "$opt"
1565                         set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1566                         shift
1567                         ;;
1568
1569       # Separate non-argument short options:
1570       -\?*|-h*|-n*|-v*)
1571                         func_split_short_opt "$opt"
1572                         set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1573                         shift
1574                         ;;
1575
1576       --)               break                                   ;;
1577       -*)               func_fatal_help "unrecognized option \`$opt'" ;;
1578       *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
1579     esac
1580   done
1581
1582   # Validate options:
1583
1584   # save first non-option argument
1585   if test "$#" -gt 0; then
1586     nonopt="$opt"
1587     shift
1588   fi
1589
1590   # preserve --debug
1591   test "$opt_debug" = : || func_append preserve_args " --debug"
1592
1593   case $host in
1594     *cygwin* | *mingw* | *pw32* | *cegcc*)
1595       # don't eliminate duplications in $postdeps and $predeps
1596       opt_duplicate_compiler_generated_deps=:
1597       ;;
1598     *)
1599       opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1600       ;;
1601   esac
1602
1603   $opt_help || {
1604     # Sanity checks first:
1605     func_check_version_match
1606
1607     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1608       func_fatal_configuration "not configured to build any kind of library"
1609     fi
1610
1611     # Darwin sucks
1612     eval std_shrext=\"$shrext_cmds\"
1613
1614     # Only execute mode is allowed to have -dlopen flags.
1615     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1616       func_error "unrecognized option \`-dlopen'"
1617       $ECHO "$help" 1>&2
1618       exit $EXIT_FAILURE
1619     fi
1620
1621     # Change the help message to a mode-specific one.
1622     generic_help="$help"
1623     help="Try \`$progname --help --mode=$opt_mode' for more information."
1624   }
1625
1626
1627   # Bail if the options were screwed
1628   $exit_cmd $EXIT_FAILURE
1629 }
1630
1631
1632
1633
1634 ## ----------- ##
1635 ##    Main.    ##
1636 ## ----------- ##
1637
1638 # func_lalib_p file
1639 # True iff FILE is a libtool `.la' library or `.lo' object file.
1640 # This function is only a basic sanity check; it will hardly flush out
1641 # determined imposters.
1642 func_lalib_p ()
1643 {
1644     test -f "$1" &&
1645       $SED -e 4q "$1" 2>/dev/null \
1646         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1647 }
1648
1649 # func_lalib_unsafe_p file
1650 # True iff FILE is a libtool `.la' library or `.lo' object file.
1651 # This function implements the same check as func_lalib_p without
1652 # resorting to external programs.  To this end, it redirects stdin and
1653 # closes it afterwards, without saving the original file descriptor.
1654 # As a safety measure, use it only where a negative result would be
1655 # fatal anyway.  Works if `file' does not exist.
1656 func_lalib_unsafe_p ()
1657 {
1658     lalib_p=no
1659     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1660         for lalib_p_l in 1 2 3 4
1661         do
1662             read lalib_p_line
1663             case "$lalib_p_line" in
1664                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1665             esac
1666         done
1667         exec 0<&5 5<&-
1668     fi
1669     test "$lalib_p" = yes
1670 }
1671
1672 # func_ltwrapper_script_p file
1673 # True iff FILE is a libtool wrapper script
1674 # This function is only a basic sanity check; it will hardly flush out
1675 # determined imposters.
1676 func_ltwrapper_script_p ()
1677 {
1678     func_lalib_p "$1"
1679 }
1680
1681 # func_ltwrapper_executable_p file
1682 # True iff FILE is a libtool wrapper executable
1683 # This function is only a basic sanity check; it will hardly flush out
1684 # determined imposters.
1685 func_ltwrapper_executable_p ()
1686 {
1687     func_ltwrapper_exec_suffix=
1688     case $1 in
1689     *.exe) ;;
1690     *) func_ltwrapper_exec_suffix=.exe ;;
1691     esac
1692     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1693 }
1694
1695 # func_ltwrapper_scriptname file
1696 # Assumes file is an ltwrapper_executable
1697 # uses $file to determine the appropriate filename for a
1698 # temporary ltwrapper_script.
1699 func_ltwrapper_scriptname ()
1700 {
1701     func_dirname_and_basename "$1" "" "."
1702     func_stripname '' '.exe' "$func_basename_result"
1703     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1704 }
1705
1706 # func_ltwrapper_p file
1707 # True iff FILE is a libtool wrapper script or wrapper executable
1708 # This function is only a basic sanity check; it will hardly flush out
1709 # determined imposters.
1710 func_ltwrapper_p ()
1711 {
1712     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1713 }
1714
1715
1716 # func_execute_cmds commands fail_cmd
1717 # Execute tilde-delimited COMMANDS.
1718 # If FAIL_CMD is given, eval that upon failure.
1719 # FAIL_CMD may read-access the current command in variable CMD!
1720 func_execute_cmds ()
1721 {
1722     $opt_debug
1723     save_ifs=$IFS; IFS='~'
1724     for cmd in $1; do
1725       IFS=$save_ifs
1726       eval cmd=\"$cmd\"
1727       func_show_eval "$cmd" "${2-:}"
1728     done
1729     IFS=$save_ifs
1730 }
1731
1732
1733 # func_source file
1734 # Source FILE, adding directory component if necessary.
1735 # Note that it is not necessary on cygwin/mingw to append a dot to
1736 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1737 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1738 # `FILE.' does not work on cygwin managed mounts.
1739 func_source ()
1740 {
1741     $opt_debug
1742     case $1 in
1743     */* | *\\*) . "$1" ;;
1744     *)          . "./$1" ;;
1745     esac
1746 }
1747
1748
1749 # func_resolve_sysroot PATH
1750 # Replace a leading = in PATH with a sysroot.  Store the result into
1751 # func_resolve_sysroot_result
1752 func_resolve_sysroot ()
1753 {
1754   func_resolve_sysroot_result=$1
1755   case $func_resolve_sysroot_result in
1756   =*)
1757     func_stripname '=' '' "$func_resolve_sysroot_result"
1758     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1759     ;;
1760   esac
1761 }
1762
1763 # func_replace_sysroot PATH
1764 # If PATH begins with the sysroot, replace it with = and
1765 # store the result into func_replace_sysroot_result.
1766 func_replace_sysroot ()
1767 {
1768   case "$lt_sysroot:$1" in
1769   ?*:"$lt_sysroot"*)
1770     func_stripname "$lt_sysroot" '' "$1"
1771     func_replace_sysroot_result="=$func_stripname_result"
1772     ;;
1773   *)
1774     # Including no sysroot.
1775     func_replace_sysroot_result=$1
1776     ;;
1777   esac
1778 }
1779
1780 # func_infer_tag arg
1781 # Infer tagged configuration to use if any are available and
1782 # if one wasn't chosen via the "--tag" command line option.
1783 # Only attempt this if the compiler in the base compile
1784 # command doesn't match the default compiler.
1785 # arg is usually of the form 'gcc ...'
1786 func_infer_tag ()
1787 {
1788     $opt_debug
1789     if test -n "$available_tags" && test -z "$tagname"; then
1790       CC_quoted=
1791       for arg in $CC; do
1792         func_append_quoted CC_quoted "$arg"
1793       done
1794       CC_expanded=`func_echo_all $CC`
1795       CC_quoted_expanded=`func_echo_all $CC_quoted`
1796       case $@ in
1797       # Blanks in the command may have been stripped by the calling shell,
1798       # but not from the CC environment variable when configure was run.
1799       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1800       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1801       # Blanks at the start of $base_compile will cause this to fail
1802       # if we don't check for them as well.
1803       *)
1804         for z in $available_tags; do
1805           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1806             # Evaluate the configuration.
1807             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1808             CC_quoted=
1809             for arg in $CC; do
1810               # Double-quote args containing other shell metacharacters.
1811               func_append_quoted CC_quoted "$arg"
1812             done
1813             CC_expanded=`func_echo_all $CC`
1814             CC_quoted_expanded=`func_echo_all $CC_quoted`
1815             case "$@ " in
1816             " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1817             " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1818               # The compiler in the base compile command matches
1819               # the one in the tagged configuration.
1820               # Assume this is the tagged configuration we want.
1821               tagname=$z
1822               break
1823               ;;
1824             esac
1825           fi
1826         done
1827         # If $tagname still isn't set, then no tagged configuration
1828         # was found and let the user know that the "--tag" command
1829         # line option must be used.
1830         if test -z "$tagname"; then
1831           func_echo "unable to infer tagged configuration"
1832           func_fatal_error "specify a tag with \`--tag'"
1833 #       else
1834 #         func_verbose "using $tagname tagged configuration"
1835         fi
1836         ;;
1837       esac
1838     fi
1839 }
1840
1841
1842
1843 # func_write_libtool_object output_name pic_name nonpic_name
1844 # Create a libtool object file (analogous to a ".la" file),
1845 # but don't create it if we're doing a dry run.
1846 func_write_libtool_object ()
1847 {
1848     write_libobj=${1}
1849     if test "$build_libtool_libs" = yes; then
1850       write_lobj=\'${2}\'
1851     else
1852       write_lobj=none
1853     fi
1854
1855     if test "$build_old_libs" = yes; then
1856       write_oldobj=\'${3}\'
1857     else
1858       write_oldobj=none
1859     fi
1860
1861     $opt_dry_run || {
1862       cat >${write_libobj}T <<EOF
1863 # $write_libobj - a libtool object file
1864 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1865 #
1866 # Please DO NOT delete this file!
1867 # It is necessary for linking the library.
1868
1869 # Name of the PIC object.
1870 pic_object=$write_lobj
1871
1872 # Name of the non-PIC object
1873 non_pic_object=$write_oldobj
1874
1875 EOF
1876       $MV "${write_libobj}T" "${write_libobj}"
1877     }
1878 }
1879
1880
1881 ##################################################
1882 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1883 ##################################################
1884
1885 # func_convert_core_file_wine_to_w32 ARG
1886 # Helper function used by file name conversion functions when $build is *nix,
1887 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1888 # correctly configured wine environment available, with the winepath program
1889 # in $build's $PATH.
1890 #
1891 # ARG is the $build file name to be converted to w32 format.
1892 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1893 # be empty on error (or when ARG is empty)
1894 func_convert_core_file_wine_to_w32 ()
1895 {
1896   $opt_debug
1897   func_convert_core_file_wine_to_w32_result="$1"
1898   if test -n "$1"; then
1899     # Unfortunately, winepath does not exit with a non-zero error code, so we
1900     # are forced to check the contents of stdout. On the other hand, if the
1901     # command is not found, the shell will set an exit code of 127 and print
1902     # *an error message* to stdout. So we must check for both error code of
1903     # zero AND non-empty stdout, which explains the odd construction:
1904     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1905     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1906       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1907         $SED -e "$lt_sed_naive_backslashify"`
1908     else
1909       func_convert_core_file_wine_to_w32_result=
1910     fi
1911   fi
1912 }
1913 # end: func_convert_core_file_wine_to_w32
1914
1915
1916 # func_convert_core_path_wine_to_w32 ARG
1917 # Helper function used by path conversion functions when $build is *nix, and
1918 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1919 # configured wine environment available, with the winepath program in $build's
1920 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1921 #
1922 # ARG is path to be converted from $build format to win32.
1923 # Result is available in $func_convert_core_path_wine_to_w32_result.
1924 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1925 # are convertible, then the result may be empty.
1926 func_convert_core_path_wine_to_w32 ()
1927 {
1928   $opt_debug
1929   # unfortunately, winepath doesn't convert paths, only file names
1930   func_convert_core_path_wine_to_w32_result=""
1931   if test -n "$1"; then
1932     oldIFS=$IFS
1933     IFS=:
1934     for func_convert_core_path_wine_to_w32_f in $1; do
1935       IFS=$oldIFS
1936       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1937       if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1938         if test -z "$func_convert_core_path_wine_to_w32_result"; then
1939           func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1940         else
1941           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1942         fi
1943       fi
1944     done
1945     IFS=$oldIFS
1946   fi
1947 }
1948 # end: func_convert_core_path_wine_to_w32
1949
1950
1951 # func_cygpath ARGS...
1952 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1953 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1954 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1955 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1956 # file name or path is assumed to be in w32 format, as previously converted
1957 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1958 # or path in func_cygpath_result (input file name or path is assumed to be in
1959 # Cygwin format). Returns an empty string on error.
1960 #
1961 # ARGS are passed to cygpath, with the last one being the file name or path to
1962 # be converted.
1963 #
1964 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1965 # environment variable; do not put it in $PATH.
1966 func_cygpath ()
1967 {
1968   $opt_debug
1969   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1970     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1971     if test "$?" -ne 0; then
1972       # on failure, ensure result is empty
1973       func_cygpath_result=
1974     fi
1975   else
1976     func_cygpath_result=
1977     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1978   fi
1979 }
1980 #end: func_cygpath
1981
1982
1983 # func_convert_core_msys_to_w32 ARG
1984 # Convert file name or path ARG from MSYS format to w32 format.  Return
1985 # result in func_convert_core_msys_to_w32_result.
1986 func_convert_core_msys_to_w32 ()
1987 {
1988   $opt_debug
1989   # awkward: cmd appends spaces to result
1990   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1991     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1992 }
1993 #end: func_convert_core_msys_to_w32
1994
1995
1996 # func_convert_file_check ARG1 ARG2
1997 # Verify that ARG1 (a file name in $build format) was converted to $host
1998 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1999 # func_to_host_file_result to ARG1).
2000 func_convert_file_check ()
2001 {
2002   $opt_debug
2003   if test -z "$2" && test -n "$1" ; then
2004     func_error "Could not determine host file name corresponding to"
2005     func_error "  \`$1'"
2006     func_error "Continuing, but uninstalled executables may not work."
2007     # Fallback:
2008     func_to_host_file_result="$1"
2009   fi
2010 }
2011 # end func_convert_file_check
2012
2013
2014 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
2015 # Verify that FROM_PATH (a path in $build format) was converted to $host
2016 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
2017 # func_to_host_file_result to a simplistic fallback value (see below).
2018 func_convert_path_check ()
2019 {
2020   $opt_debug
2021   if test -z "$4" && test -n "$3"; then
2022     func_error "Could not determine the host path corresponding to"
2023     func_error "  \`$3'"
2024     func_error "Continuing, but uninstalled executables may not work."
2025     # Fallback.  This is a deliberately simplistic "conversion" and
2026     # should not be "improved".  See libtool.info.
2027     if test "x$1" != "x$2"; then
2028       lt_replace_pathsep_chars="s|$1|$2|g"
2029       func_to_host_path_result=`echo "$3" |
2030         $SED -e "$lt_replace_pathsep_chars"`
2031     else
2032       func_to_host_path_result="$3"
2033     fi
2034   fi
2035 }
2036 # end func_convert_path_check
2037
2038
2039 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
2040 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
2041 # and appending REPL if ORIG matches BACKPAT.
2042 func_convert_path_front_back_pathsep ()
2043 {
2044   $opt_debug
2045   case $4 in
2046   $1 ) func_to_host_path_result="$3$func_to_host_path_result"
2047     ;;
2048   esac
2049   case $4 in
2050   $2 ) func_append func_to_host_path_result "$3"
2051     ;;
2052   esac
2053 }
2054 # end func_convert_path_front_back_pathsep
2055
2056
2057 ##################################################
2058 # $build to $host FILE NAME CONVERSION FUNCTIONS #
2059 ##################################################
2060 # invoked via `$to_host_file_cmd ARG'
2061 #
2062 # In each case, ARG is the path to be converted from $build to $host format.
2063 # Result will be available in $func_to_host_file_result.
2064
2065
2066 # func_to_host_file ARG
2067 # Converts the file name ARG from $build format to $host format. Return result
2068 # in func_to_host_file_result.
2069 func_to_host_file ()
2070 {
2071   $opt_debug
2072   $to_host_file_cmd "$1"
2073 }
2074 # end func_to_host_file
2075
2076
2077 # func_to_tool_file ARG LAZY
2078 # converts the file name ARG from $build format to toolchain format. Return
2079 # result in func_to_tool_file_result.  If the conversion in use is listed
2080 # in (the comma separated) LAZY, no conversion takes place.
2081 func_to_tool_file ()
2082 {
2083   $opt_debug
2084   case ,$2, in
2085     *,"$to_tool_file_cmd",*)
2086       func_to_tool_file_result=$1
2087       ;;
2088     *)
2089       $to_tool_file_cmd "$1"
2090       func_to_tool_file_result=$func_to_host_file_result
2091       ;;
2092   esac
2093 }
2094 # end func_to_tool_file
2095
2096
2097 # func_convert_file_noop ARG
2098 # Copy ARG to func_to_host_file_result.
2099 func_convert_file_noop ()
2100 {
2101   func_to_host_file_result="$1"
2102 }
2103 # end func_convert_file_noop
2104
2105
2106 # func_convert_file_msys_to_w32 ARG
2107 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
2108 # conversion to w32 is not available inside the cwrapper.  Returns result in
2109 # func_to_host_file_result.
2110 func_convert_file_msys_to_w32 ()
2111 {
2112   $opt_debug
2113   func_to_host_file_result="$1"
2114   if test -n "$1"; then
2115     func_convert_core_msys_to_w32 "$1"
2116     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
2117   fi
2118   func_convert_file_check "$1" "$func_to_host_file_result"
2119 }
2120 # end func_convert_file_msys_to_w32
2121
2122
2123 # func_convert_file_cygwin_to_w32 ARG
2124 # Convert file name ARG from Cygwin to w32 format.  Returns result in
2125 # func_to_host_file_result.
2126 func_convert_file_cygwin_to_w32 ()
2127 {
2128   $opt_debug
2129   func_to_host_file_result="$1"
2130   if test -n "$1"; then
2131     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
2132     # LT_CYGPATH in this case.
2133     func_to_host_file_result=`cygpath -m "$1"`
2134   fi
2135   func_convert_file_check "$1" "$func_to_host_file_result"
2136 }
2137 # end func_convert_file_cygwin_to_w32
2138
2139
2140 # func_convert_file_nix_to_w32 ARG
2141 # Convert file name ARG from *nix to w32 format.  Requires a wine environment
2142 # and a working winepath. Returns result in func_to_host_file_result.
2143 func_convert_file_nix_to_w32 ()
2144 {
2145   $opt_debug
2146   func_to_host_file_result="$1"
2147   if test -n "$1"; then
2148     func_convert_core_file_wine_to_w32 "$1"
2149     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
2150   fi
2151   func_convert_file_check "$1" "$func_to_host_file_result"
2152 }
2153 # end func_convert_file_nix_to_w32
2154
2155
2156 # func_convert_file_msys_to_cygwin ARG
2157 # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
2158 # Returns result in func_to_host_file_result.
2159 func_convert_file_msys_to_cygwin ()
2160 {
2161   $opt_debug
2162   func_to_host_file_result="$1"
2163   if test -n "$1"; then
2164     func_convert_core_msys_to_w32 "$1"
2165     func_cygpath -u "$func_convert_core_msys_to_w32_result"
2166     func_to_host_file_result="$func_cygpath_result"
2167   fi
2168   func_convert_file_check "$1" "$func_to_host_file_result"
2169 }
2170 # end func_convert_file_msys_to_cygwin
2171
2172
2173 # func_convert_file_nix_to_cygwin ARG
2174 # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
2175 # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
2176 # in func_to_host_file_result.
2177 func_convert_file_nix_to_cygwin ()
2178 {
2179   $opt_debug
2180   func_to_host_file_result="$1"
2181   if test -n "$1"; then
2182     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
2183     func_convert_core_file_wine_to_w32 "$1"
2184     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
2185     func_to_host_file_result="$func_cygpath_result"
2186   fi
2187   func_convert_file_check "$1" "$func_to_host_file_result"
2188 }
2189 # end func_convert_file_nix_to_cygwin
2190
2191
2192 #############################################
2193 # $build to $host PATH CONVERSION FUNCTIONS #
2194 #############################################
2195 # invoked via `$to_host_path_cmd ARG'
2196 #
2197 # In each case, ARG is the path to be converted from $build to $host format.
2198 # The result will be available in $func_to_host_path_result.
2199 #
2200 # Path separators are also converted from $build format to $host format.  If
2201 # ARG begins or ends with a path separator character, it is preserved (but
2202 # converted to $host format) on output.
2203 #
2204 # All path conversion functions are named using the following convention:
2205 #   file name conversion function    : func_convert_file_X_to_Y ()
2206 #   path conversion function         : func_convert_path_X_to_Y ()
2207 # where, for any given $build/$host combination the 'X_to_Y' value is the
2208 # same.  If conversion functions are added for new $build/$host combinations,
2209 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
2210 # will break.
2211
2212
2213 # func_init_to_host_path_cmd
2214 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
2215 # appropriate value, based on the value of $to_host_file_cmd.
2216 to_host_path_cmd=
2217 func_init_to_host_path_cmd ()
2218 {
2219   $opt_debug
2220   if test -z "$to_host_path_cmd"; then
2221     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
2222     to_host_path_cmd="func_convert_path_${func_stripname_result}"
2223   fi
2224 }
2225
2226
2227 # func_to_host_path ARG
2228 # Converts the path ARG from $build format to $host format. Return result
2229 # in func_to_host_path_result.
2230 func_to_host_path ()
2231 {
2232   $opt_debug
2233   func_init_to_host_path_cmd
2234   $to_host_path_cmd "$1"
2235 }
2236 # end func_to_host_path
2237
2238
2239 # func_convert_path_noop ARG
2240 # Copy ARG to func_to_host_path_result.
2241 func_convert_path_noop ()
2242 {
2243   func_to_host_path_result="$1"
2244 }
2245 # end func_convert_path_noop
2246
2247
2248 # func_convert_path_msys_to_w32 ARG
2249 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
2250 # conversion to w32 is not available inside the cwrapper.  Returns result in
2251 # func_to_host_path_result.
2252 func_convert_path_msys_to_w32 ()
2253 {
2254   $opt_debug
2255   func_to_host_path_result="$1"
2256   if test -n "$1"; then
2257     # Remove leading and trailing path separator characters from ARG.  MSYS
2258     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
2259     # and winepath ignores them completely.
2260     func_stripname : : "$1"
2261     func_to_host_path_tmp1=$func_stripname_result
2262     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
2263     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
2264     func_convert_path_check : ";" \
2265       "$func_to_host_path_tmp1" "$func_to_host_path_result"
2266     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
2267   fi
2268 }
2269 # end func_convert_path_msys_to_w32
2270
2271
2272 # func_convert_path_cygwin_to_w32 ARG
2273 # Convert path ARG from Cygwin to w32 format.  Returns result in
2274 # func_to_host_file_result.
2275 func_convert_path_cygwin_to_w32 ()
2276 {
2277   $opt_debug
2278   func_to_host_path_result="$1"
2279   if test -n "$1"; then
2280     # See func_convert_path_msys_to_w32:
2281     func_stripname : : "$1"
2282     func_to_host_path_tmp1=$func_stripname_result
2283     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
2284     func_convert_path_check : ";" \
2285       "$func_to_host_path_tmp1" "$func_to_host_path_result"
2286     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
2287   fi
2288 }
2289 # end func_convert_path_cygwin_to_w32
2290
2291
2292 # func_convert_path_nix_to_w32 ARG
2293 # Convert path ARG from *nix to w32 format.  Requires a wine environment and
2294 # a working winepath.  Returns result in func_to_host_file_result.
2295 func_convert_path_nix_to_w32 ()
2296 {
2297   $opt_debug
2298   func_to_host_path_result="$1"
2299   if test -n "$1"; then
2300     # See func_convert_path_msys_to_w32:
2301     func_stripname : : "$1"
2302     func_to_host_path_tmp1=$func_stripname_result
2303     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
2304     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
2305     func_convert_path_check : ";" \
2306       "$func_to_host_path_tmp1" "$func_to_host_path_result"
2307     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
2308   fi
2309 }
2310 # end func_convert_path_nix_to_w32
2311
2312
2313 # func_convert_path_msys_to_cygwin ARG
2314 # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
2315 # Returns result in func_to_host_file_result.
2316 func_convert_path_msys_to_cygwin ()
2317 {
2318   $opt_debug
2319   func_to_host_path_result="$1"
2320   if test -n "$1"; then
2321     # See func_convert_path_msys_to_w32:
2322     func_stripname : : "$1"
2323     func_to_host_path_tmp1=$func_stripname_result
2324     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
2325     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
2326     func_to_host_path_result="$func_cygpath_result"
2327     func_convert_path_check : : \
2328       "$func_to_host_path_tmp1" "$func_to_host_path_result"
2329     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
2330   fi
2331 }
2332 # end func_convert_path_msys_to_cygwin
2333
2334
2335 # func_convert_path_nix_to_cygwin ARG
2336 # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
2337 # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
2338 # func_to_host_file_result.
2339 func_convert_path_nix_to_cygwin ()
2340 {
2341   $opt_debug
2342   func_to_host_path_result="$1"
2343   if test -n "$1"; then
2344     # Remove leading and trailing path separator characters from
2345     # ARG. msys behavior is inconsistent here, cygpath turns them
2346     # into '.;' and ';.', and winepath ignores them completely.
2347     func_stripname : : "$1"
2348     func_to_host_path_tmp1=$func_stripname_result
2349     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
2350     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
2351     func_to_host_path_result="$func_cygpath_result"
2352     func_convert_path_check : : \
2353       "$func_to_host_path_tmp1" "$func_to_host_path_result"
2354     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
2355   fi
2356 }
2357 # end func_convert_path_nix_to_cygwin
2358
2359
2360 # func_mode_compile arg...
2361 func_mode_compile ()
2362 {
2363     $opt_debug
2364     # Get the compilation command and the source file.
2365     base_compile=
2366     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
2367     suppress_opt=yes
2368     suppress_output=
2369     arg_mode=normal
2370     libobj=
2371     later=
2372     pie_flag=
2373
2374     for arg
2375     do
2376       case $arg_mode in
2377       arg  )
2378         # do not "continue".  Instead, add this to base_compile
2379         lastarg="$arg"
2380         arg_mode=normal
2381         ;;
2382
2383       target )
2384         libobj="$arg"
2385         arg_mode=normal
2386         continue
2387         ;;
2388
2389       normal )
2390         # Accept any command-line options.
2391         case $arg in
2392         -o)
2393           test -n "$libobj" && \
2394             func_fatal_error "you cannot specify \`-o' more than once"
2395           arg_mode=target
2396           continue
2397           ;;
2398
2399         -pie | -fpie | -fPIE)
2400           func_append pie_flag " $arg"
2401           continue
2402           ;;
2403
2404         -shared | -static | -prefer-pic | -prefer-non-pic)
2405           func_append later " $arg"
2406           continue
2407           ;;
2408
2409         -no-suppress)
2410           suppress_opt=no
2411           continue
2412           ;;
2413
2414         -Xcompiler)
2415           arg_mode=arg  #  the next one goes into the "base_compile" arg list
2416           continue      #  The current "srcfile" will either be retained or
2417           ;;            #  replaced later.  I would guess that would be a bug.
2418
2419         -Wc,*)
2420           func_stripname '-Wc,' '' "$arg"
2421           args=$func_stripname_result
2422           lastarg=
2423           save_ifs="$IFS"; IFS=','
2424           for arg in $args; do
2425             IFS="$save_ifs"
2426             func_append_quoted lastarg "$arg"
2427           done
2428           IFS="$save_ifs"
2429           func_stripname ' ' '' "$lastarg"
2430           lastarg=$func_stripname_result
2431
2432           # Add the arguments to base_compile.
2433           func_append base_compile " $lastarg"
2434           continue
2435           ;;
2436
2437         *)
2438           # Accept the current argument as the source file.
2439           # The previous "srcfile" becomes the current argument.
2440           #
2441           lastarg="$srcfile"
2442           srcfile="$arg"
2443           ;;
2444         esac  #  case $arg
2445         ;;
2446       esac    #  case $arg_mode
2447
2448       # Aesthetically quote the previous argument.
2449       func_append_quoted base_compile "$lastarg"
2450     done # for arg
2451
2452     case $arg_mode in
2453     arg)
2454       func_fatal_error "you must specify an argument for -Xcompile"
2455       ;;
2456     target)
2457       func_fatal_error "you must specify a target with \`-o'"
2458       ;;
2459     *)
2460       # Get the name of the library object.
2461       test -z "$libobj" && {
2462         func_basename "$srcfile"
2463         libobj="$func_basename_result"
2464       }
2465       ;;
2466     esac
2467
2468     # Recognize several different file suffixes.
2469     # If the user specifies -o file.o, it is replaced with file.lo
2470     case $libobj in
2471     *.[cCFSifmso] | \
2472     *.ada | *.adb | *.ads | *.asm | \
2473     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2474     *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
2475       func_xform "$libobj"
2476       libobj=$func_xform_result
2477       ;;
2478     esac
2479
2480     case $libobj in
2481     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2482     *)
2483       func_fatal_error "cannot determine name of library object from \`$libobj'"
2484       ;;
2485     esac
2486
2487     func_infer_tag $base_compile
2488
2489     for arg in $later; do
2490       case $arg in
2491       -shared)
2492         test "$build_libtool_libs" != yes && \
2493           func_fatal_configuration "can not build a shared library"
2494         build_old_libs=no
2495         continue
2496         ;;
2497
2498       -static)
2499         build_libtool_libs=no
2500         build_old_libs=yes
2501         continue
2502         ;;
2503
2504       -prefer-pic)
2505         pic_mode=yes
2506         continue
2507         ;;
2508
2509       -prefer-non-pic)
2510         pic_mode=no
2511         continue
2512         ;;
2513       esac
2514     done
2515
2516     func_quote_for_eval "$libobj"
2517     test "X$libobj" != "X$func_quote_for_eval_result" \
2518       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
2519       && func_warning "libobj name \`$libobj' may not contain shell special characters."
2520     func_dirname_and_basename "$obj" "/" ""
2521     objname="$func_basename_result"
2522     xdir="$func_dirname_result"
2523     lobj=${xdir}$objdir/$objname
2524
2525     test -z "$base_compile" && \
2526       func_fatal_help "you must specify a compilation command"
2527
2528     # Delete any leftover library objects.
2529     if test "$build_old_libs" = yes; then
2530       removelist="$obj $lobj $libobj ${libobj}T"
2531     else
2532       removelist="$lobj $libobj ${libobj}T"
2533     fi
2534
2535     # On Cygwin there's no "real" PIC flag so we must build both object types
2536     case $host_os in
2537     cygwin* | mingw* | pw32* | os2* | cegcc*)
2538       pic_mode=default
2539       ;;
2540     esac
2541     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2542       # non-PIC code in shared libraries is not supported
2543       pic_mode=default
2544     fi
2545
2546     # Calculate the filename of the output object if compiler does
2547     # not support -o with -c
2548     if test "$compiler_c_o" = no; then
2549       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2550       lockfile="$output_obj.lock"
2551     else
2552       output_obj=
2553       need_locks=no
2554       lockfile=
2555     fi
2556
2557     # Lock this critical section if it is needed
2558     # We use this script file to make the link, it avoids creating a new file
2559     if test "$need_locks" = yes; then
2560       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2561         func_echo "Waiting for $lockfile to be removed"
2562         sleep 2
2563       done
2564     elif test "$need_locks" = warn; then
2565       if test -f "$lockfile"; then
2566         $ECHO "\
2567 *** ERROR, $lockfile exists and contains:
2568 `cat $lockfile 2>/dev/null`
2569
2570 This indicates that another process is trying to use the same
2571 temporary object file, and libtool could not work around it because
2572 your compiler does not support \`-c' and \`-o' together.  If you
2573 repeat this compilation, it may succeed, by chance, but you had better
2574 avoid parallel builds (make -j) in this platform, or get a better
2575 compiler."
2576
2577         $opt_dry_run || $RM $removelist
2578         exit $EXIT_FAILURE
2579       fi
2580       func_append removelist " $output_obj"
2581       $ECHO "$srcfile" > "$lockfile"
2582     fi
2583
2584     $opt_dry_run || $RM $removelist
2585     func_append removelist " $lockfile"
2586     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2587
2588     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2589     srcfile=$func_to_tool_file_result
2590     func_quote_for_eval "$srcfile"
2591     qsrcfile=$func_quote_for_eval_result
2592
2593     # Only build a PIC object if we are building libtool libraries.
2594     if test "$build_libtool_libs" = yes; then
2595       # Without this assignment, base_compile gets emptied.
2596       fbsd_hideous_sh_bug=$base_compile
2597
2598       if test "$pic_mode" != no; then
2599         command="$base_compile $qsrcfile $pic_flag"
2600       else
2601         # Don't build PIC code
2602         command="$base_compile $qsrcfile"
2603       fi
2604
2605       func_mkdir_p "$xdir$objdir"
2606
2607       if test -z "$output_obj"; then
2608         # Place PIC objects in $objdir
2609         func_append command " -o $lobj"
2610       fi
2611
2612       func_show_eval_locale "$command"  \
2613           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2614
2615       if test "$need_locks" = warn &&
2616          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2617         $ECHO "\
2618 *** ERROR, $lockfile contains:
2619 `cat $lockfile 2>/dev/null`
2620
2621 but it should contain:
2622 $srcfile
2623
2624 This indicates that another process is trying to use the same
2625 temporary object file, and libtool could not work around it because
2626 your compiler does not support \`-c' and \`-o' together.  If you
2627 repeat this compilation, it may succeed, by chance, but you had better
2628 avoid parallel builds (make -j) in this platform, or get a better
2629 compiler."
2630
2631         $opt_dry_run || $RM $removelist
2632         exit $EXIT_FAILURE
2633       fi
2634
2635       # Just move the object if needed, then go on to compile the next one
2636       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2637         func_show_eval '$MV "$output_obj" "$lobj"' \
2638           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2639       fi
2640
2641       # Allow error messages only from the first compilation.
2642       if test "$suppress_opt" = yes; then
2643         suppress_output=' >/dev/null 2>&1'
2644       fi
2645     fi
2646
2647     # Only build a position-dependent object if we build old libraries.
2648     if test "$build_old_libs" = yes; then
2649       if test "$pic_mode" != yes; then
2650         # Don't build PIC code
2651         command="$base_compile $qsrcfile$pie_flag"
2652       else
2653         command="$base_compile $qsrcfile $pic_flag"
2654       fi
2655       if test "$compiler_c_o" = yes; then
2656         func_append command " -o $obj"
2657       fi
2658
2659       # Suppress compiler output if we already did a PIC compilation.
2660       func_append command "$suppress_output"
2661       func_show_eval_locale "$command" \
2662         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2663
2664       if test "$need_locks" = warn &&
2665          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2666         $ECHO "\
2667 *** ERROR, $lockfile contains:
2668 `cat $lockfile 2>/dev/null`
2669
2670 but it should contain:
2671 $srcfile
2672
2673 This indicates that another process is trying to use the same
2674 temporary object file, and libtool could not work around it because
2675 your compiler does not support \`-c' and \`-o' together.  If you
2676 repeat this compilation, it may succeed, by chance, but you had better
2677 avoid parallel builds (make -j) in this platform, or get a better
2678 compiler."
2679
2680         $opt_dry_run || $RM $removelist
2681         exit $EXIT_FAILURE
2682       fi
2683
2684       # Just move the object if needed
2685       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2686         func_show_eval '$MV "$output_obj" "$obj"' \
2687           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2688       fi
2689     fi
2690
2691     $opt_dry_run || {
2692       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2693
2694       # Unlock the critical section if it was locked
2695       if test "$need_locks" != no; then
2696         removelist=$lockfile
2697         $RM "$lockfile"
2698       fi
2699     }
2700
2701     exit $EXIT_SUCCESS
2702 }
2703
2704 $opt_help || {
2705   test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2706 }
2707
2708 func_mode_help ()
2709 {
2710     # We need to display help for each of the modes.
2711     case $opt_mode in
2712       "")
2713         # Generic help is extracted from the usage comments
2714         # at the start of this file.
2715         func_help
2716         ;;
2717
2718       clean)
2719         $ECHO \
2720 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2721
2722 Remove files from the build directory.
2723
2724 RM is the name of the program to use to delete files associated with each FILE
2725 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2726 to RM.
2727
2728 If FILE is a libtool library, object or program, all the files associated
2729 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2730         ;;
2731
2732       compile)
2733       $ECHO \
2734 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2735
2736 Compile a source file into a libtool library object.
2737
2738 This mode accepts the following additional options:
2739
2740   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
2741   -no-suppress      do not suppress compiler output for multiple passes
2742   -prefer-pic       try to build PIC objects only
2743   -prefer-non-pic   try to build non-PIC objects only
2744   -shared           do not build a \`.o' file suitable for static linking
2745   -static           only build a \`.o' file suitable for static linking
2746   -Wc,FLAG          pass FLAG directly to the compiler
2747
2748 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2749 from the given SOURCEFILE.
2750
2751 The output file name is determined by removing the directory component from
2752 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2753 library object suffix, \`.lo'."
2754         ;;
2755
2756       execute)
2757         $ECHO \
2758 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2759
2760 Automatically set library path, then run a program.
2761
2762 This mode accepts the following additional options:
2763
2764   -dlopen FILE      add the directory containing FILE to the library path
2765
2766 This mode sets the library path environment variable according to \`-dlopen'
2767 flags.
2768
2769 If any of the ARGS are libtool executable wrappers, then they are translated
2770 into their corresponding uninstalled binary, and any of their required library
2771 directories are added to the library path.
2772
2773 Then, COMMAND is executed, with ARGS as arguments."
2774         ;;
2775
2776       finish)
2777         $ECHO \
2778 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2779
2780 Complete the installation of libtool libraries.
2781
2782 Each LIBDIR is a directory that contains libtool libraries.
2783
2784 The commands that this mode executes may require superuser privileges.  Use
2785 the \`--dry-run' option if you just want to see what would be executed."
2786         ;;
2787
2788       install)
2789         $ECHO \
2790 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2791
2792 Install executables or libraries.
2793
2794 INSTALL-COMMAND is the installation command.  The first component should be
2795 either the \`install' or \`cp' program.
2796
2797 The following components of INSTALL-COMMAND are treated specially:
2798
2799   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2800
2801 The rest of the components are interpreted as arguments to that command (only
2802 BSD-compatible install options are recognized)."
2803         ;;
2804
2805       link)
2806         $ECHO \
2807 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2808
2809 Link object files or libraries together to form another library, or to
2810 create an executable program.
2811
2812 LINK-COMMAND is a command using the C compiler that you would use to create
2813 a program from several object files.
2814
2815 The following components of LINK-COMMAND are treated specially:
2816
2817   -all-static       do not do any dynamic linking at all
2818   -avoid-version    do not add a version suffix if possible
2819   -bindir BINDIR    specify path to binaries directory (for systems where
2820                     libraries must be found in the PATH setting at runtime)
2821   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2822   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2823   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2824   -export-symbols SYMFILE
2825                     try to export only the symbols listed in SYMFILE
2826   -export-symbols-regex REGEX
2827                     try to export only the symbols matching REGEX
2828   -LLIBDIR          search LIBDIR for required installed libraries
2829   -lNAME            OUTPUT-FILE requires the installed library libNAME
2830   -module           build a library that can dlopened
2831   -no-fast-install  disable the fast-install mode
2832   -no-install       link a not-installable executable
2833   -no-undefined     declare that a library does not refer to external symbols
2834   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2835   -objectlist FILE  Use a list of object files found in FILE to specify objects
2836   -precious-files-regex REGEX
2837                     don't remove output files matching REGEX
2838   -release RELEASE  specify package release information
2839   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2840   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2841   -shared           only do dynamic linking of libtool libraries
2842   -shrext SUFFIX    override the standard shared library file extension
2843   -static           do not do any dynamic linking of uninstalled libtool libraries
2844   -static-libtool-libs
2845                     do not do any dynamic linking of libtool libraries
2846   -version-info CURRENT[:REVISION[:AGE]]
2847                     specify library version info [each variable defaults to 0]
2848   -weak LIBNAME     declare that the target provides the LIBNAME interface
2849   -Wc,FLAG
2850   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
2851   -Wl,FLAG
2852   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
2853   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
2854
2855 All other options (arguments beginning with \`-') are ignored.
2856
2857 Every other argument is treated as a filename.  Files ending in \`.la' are
2858 treated as uninstalled libtool libraries, other files are standard or library
2859 object files.
2860
2861 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2862 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2863 required, except when creating a convenience library.
2864
2865 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2866 using \`ar' and \`ranlib', or on Windows using \`lib'.
2867
2868 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2869 is created, otherwise an executable program is created."
2870         ;;
2871
2872       uninstall)
2873         $ECHO \
2874 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2875
2876 Remove libraries from an installation directory.
2877
2878 RM is the name of the program to use to delete files associated with each FILE
2879 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2880 to RM.
2881
2882 If FILE is a libtool library, all the files associated with it are deleted.
2883 Otherwise, only FILE itself is deleted using RM."
2884         ;;
2885
2886       *)
2887         func_fatal_help "invalid operation mode \`$opt_mode'"
2888         ;;
2889     esac
2890
2891     echo
2892     $ECHO "Try \`$progname --help' for more information about other modes."
2893 }
2894
2895 # Now that we've collected a possible --mode arg, show help if necessary
2896 if $opt_help; then
2897   if test "$opt_help" = :; then
2898     func_mode_help
2899   else
2900     {
2901       func_help noexit
2902       for opt_mode in compile link execute install finish uninstall clean; do
2903         func_mode_help
2904       done
2905     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
2906     {
2907       func_help noexit
2908       for opt_mode in compile link execute install finish uninstall clean; do
2909         echo
2910         func_mode_help
2911       done
2912     } |
2913     sed '1d
2914       /^When reporting/,/^Report/{
2915         H
2916         d
2917       }
2918       $x
2919       /information about other modes/d
2920       /more detailed .*MODE/d
2921       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2922   fi
2923   exit $?
2924 fi
2925
2926
2927 # func_mode_execute arg...
2928 func_mode_execute ()
2929 {
2930     $opt_debug
2931     # The first argument is the command name.
2932     cmd="$nonopt"
2933     test -z "$cmd" && \
2934       func_fatal_help "you must specify a COMMAND"
2935
2936     # Handle -dlopen flags immediately.
2937     for file in $opt_dlopen; do
2938       test -f "$file" \
2939         || func_fatal_help "\`$file' is not a file"
2940
2941       dir=
2942       case $file in
2943       *.la)
2944         func_resolve_sysroot "$file"
2945         file=$func_resolve_sysroot_result
2946
2947         # Check to see that this really is a libtool archive.
2948         func_lalib_unsafe_p "$file" \
2949           || func_fatal_help "\`$lib' is not a valid libtool archive"
2950
2951         # Read the libtool library.
2952         dlname=
2953         library_names=
2954         func_source "$file"
2955
2956         # Skip this library if it cannot be dlopened.
2957         if test -z "$dlname"; then
2958           # Warn if it was a shared library.
2959           test -n "$library_names" && \
2960             func_warning "\`$file' was not linked with \`-export-dynamic'"
2961           continue
2962         fi
2963
2964         func_dirname "$file" "" "."
2965         dir="$func_dirname_result"
2966
2967         if test -f "$dir/$objdir/$dlname"; then
2968           func_append dir "/$objdir"
2969         else
2970           if test ! -f "$dir/$dlname"; then
2971             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2972           fi
2973         fi
2974         ;;
2975
2976       *.lo)
2977         # Just add the directory containing the .lo file.
2978         func_dirname "$file" "" "."
2979         dir="$func_dirname_result"
2980         ;;
2981
2982       *)
2983         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2984         continue
2985         ;;
2986       esac
2987
2988       # Get the absolute pathname.
2989       absdir=`cd "$dir" && pwd`
2990       test -n "$absdir" && dir="$absdir"
2991
2992       # Now add the directory to shlibpath_var.
2993       if eval "test -z \"\$$shlibpath_var\""; then
2994         eval "$shlibpath_var=\"\$dir\""
2995       else
2996         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2997       fi
2998     done
2999
3000     # This variable tells wrapper scripts just to set shlibpath_var
3001     # rather than running their programs.
3002     libtool_execute_magic="$magic"
3003
3004     # Check if any of the arguments is a wrapper script.
3005     args=
3006     for file
3007     do
3008       case $file in
3009       -* | *.la | *.lo ) ;;
3010       *)
3011         # Do a test to see if this is really a libtool program.
3012         if func_ltwrapper_script_p "$file"; then
3013           func_source "$file"
3014           # Transform arg to wrapped name.
3015           file="$progdir/$program"
3016         elif func_ltwrapper_executable_p "$file"; then
3017           func_ltwrapper_scriptname "$file"
3018           func_source "$func_ltwrapper_scriptname_result"
3019           # Transform arg to wrapped name.
3020           file="$progdir/$program"
3021         fi
3022         ;;
3023       esac
3024       # Quote arguments (to preserve shell metacharacters).
3025       func_append_quoted args "$file"
3026     done
3027
3028     if test "X$opt_dry_run" = Xfalse; then
3029       if test -n "$shlibpath_var"; then
3030         # Export the shlibpath_var.
3031         eval "export $shlibpath_var"
3032       fi
3033
3034       # Restore saved environment variables
3035       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
3036       do
3037         eval "if test \"\${save_$lt_var+set}\" = set; then
3038                 $lt_var=\$save_$lt_var; export $lt_var
3039               else
3040                 $lt_unset $lt_var
3041               fi"
3042       done
3043
3044       # Now prepare to actually exec the command.
3045       exec_cmd="\$cmd$args"
3046     else
3047       # Display what would be done.
3048       if test -n "$shlibpath_var"; then
3049         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
3050         echo "export $shlibpath_var"
3051       fi
3052       $ECHO "$cmd$args"
3053       exit $EXIT_SUCCESS
3054     fi
3055 }
3056
3057 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
3058
3059
3060 # func_mode_finish arg...
3061 func_mode_finish ()
3062 {
3063     $opt_debug
3064     libs=
3065     libdirs=
3066     admincmds=
3067
3068     for opt in "$nonopt" ${1+"$@"}
3069     do
3070       if test -d "$opt"; then
3071         func_append libdirs " $opt"
3072
3073       elif test -f "$opt"; then
3074         if func_lalib_unsafe_p "$opt"; then
3075           func_append libs " $opt"
3076         else
3077           func_warning "\`$opt' is not a valid libtool archive"
3078         fi
3079
3080       else
3081         func_fatal_error "invalid argument \`$opt'"
3082       fi
3083     done
3084
3085     if test -n "$libs"; then
3086       if test -n "$lt_sysroot"; then
3087         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
3088         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
3089       else
3090         sysroot_cmd=
3091       fi
3092
3093       # Remove sysroot references
3094       if $opt_dry_run; then
3095         for lib in $libs; do
3096           echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
3097         done
3098       else
3099         tmpdir=`func_mktempdir`
3100         for lib in $libs; do
3101           sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
3102             > $tmpdir/tmp-la
3103           mv -f $tmpdir/tmp-la $lib
3104         done
3105         ${RM}r "$tmpdir"
3106       fi
3107     fi
3108
3109     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
3110       for libdir in $libdirs; do
3111         if test -n "$finish_cmds"; then
3112           # Do each command in the finish commands.
3113           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
3114 '"$cmd"'"'
3115         fi
3116         if test -n "$finish_eval"; then
3117           # Do the single finish_eval.
3118           eval cmds=\"$finish_eval\"
3119           $opt_dry_run || eval "$cmds" || func_append admincmds "
3120        $cmds"
3121         fi
3122       done
3123     fi
3124
3125     # Exit here if they wanted silent mode.
3126     $opt_silent && exit $EXIT_SUCCESS
3127
3128     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
3129       echo "----------------------------------------------------------------------"
3130       echo "Libraries have been installed in:"
3131       for libdir in $libdirs; do
3132         $ECHO "   $libdir"
3133       done
3134       echo
3135       echo "If you ever happen to want to link against installed libraries"
3136       echo "in a given directory, LIBDIR, you must either use libtool, and"
3137       echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
3138       echo "flag during linking and do at least one of the following:"
3139       if test -n "$shlibpath_var"; then
3140         echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
3141         echo "     during execution"
3142       fi
3143       if test -n "$runpath_var"; then
3144         echo "   - add LIBDIR to the \`$runpath_var' environment variable"
3145         echo "     during linking"
3146       fi
3147       if test -n "$hardcode_libdir_flag_spec"; then
3148         libdir=LIBDIR
3149         eval flag=\"$hardcode_libdir_flag_spec\"
3150
3151         $ECHO "   - use the \`$flag' linker flag"
3152       fi
3153       if test -n "$admincmds"; then
3154         $ECHO "   - have your system administrator run these commands:$admincmds"
3155       fi
3156       if test -f /etc/ld.so.conf; then
3157         echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
3158       fi
3159       echo
3160
3161       echo "See any operating system documentation about shared libraries for"
3162       case $host in
3163         solaris2.[6789]|solaris2.1[0-9])
3164           echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
3165           echo "pages."
3166           ;;
3167         *)
3168           echo "more information, such as the ld(1) and ld.so(8) manual pages."
3169           ;;
3170       esac
3171       echo "----------------------------------------------------------------------"
3172     fi
3173     exit $EXIT_SUCCESS
3174 }
3175
3176 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
3177
3178
3179 # func_mode_install arg...
3180 func_mode_install ()
3181 {
3182     $opt_debug
3183     # There may be an optional sh(1) argument at the beginning of
3184     # install_prog (especially on Windows NT).
3185     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
3186        # Allow the use of GNU shtool's install command.
3187        case $nonopt in *shtool*) :;; *) false;; esac; then
3188       # Aesthetically quote it.
3189       func_quote_for_eval "$nonopt"
3190       install_prog="$func_quote_for_eval_result "
3191       arg=$1
3192       shift
3193     else
3194       install_prog=
3195       arg=$nonopt
3196     fi
3197
3198     # The real first argument should be the name of the installation program.
3199     # Aesthetically quote it.
3200     func_quote_for_eval "$arg"
3201     func_append install_prog "$func_quote_for_eval_result"
3202     install_shared_prog=$install_prog
3203     case " $install_prog " in
3204       *[\\\ /]cp\ *) install_cp=: ;;
3205       *) install_cp=false ;;
3206     esac
3207
3208     # We need to accept at least all the BSD install flags.
3209     dest=
3210     files=
3211     opts=
3212     prev=
3213     install_type=
3214     isdir=no
3215     stripme=
3216     no_mode=:
3217     for arg
3218     do
3219       arg2=
3220       if test -n "$dest"; then
3221         func_append files " $dest"
3222         dest=$arg
3223         continue
3224       fi
3225
3226       case $arg in
3227       -d) isdir=yes ;;
3228       -f)
3229         if $install_cp; then :; else
3230           prev=$arg
3231         fi
3232         ;;
3233       -g | -m | -o)
3234         prev=$arg
3235         ;;
3236       -s)
3237         stripme=" -s"
3238         continue
3239         ;;
3240       -*)
3241         ;;
3242       *)
3243         # If the previous option needed an argument, then skip it.
3244         if test -n "$prev"; then
3245           if test "x$prev" = x-m && test -n "$install_override_mode"; then
3246             arg2=$install_override_mode
3247             no_mode=false
3248           fi
3249           prev=
3250         else
3251           dest=$arg
3252           continue
3253         fi
3254         ;;
3255       esac
3256
3257       # Aesthetically quote the argument.
3258       func_quote_for_eval "$arg"
3259       func_append install_prog " $func_quote_for_eval_result"
3260       if test -n "$arg2"; then
3261         func_quote_for_eval "$arg2"
3262       fi
3263       func_append install_shared_prog " $func_quote_for_eval_result"
3264     done
3265
3266     test -z "$install_prog" && \
3267       func_fatal_help "you must specify an install program"
3268
3269     test -n "$prev" && \
3270       func_fatal_help "the \`$prev' option requires an argument"
3271
3272     if test -n "$install_override_mode" && $no_mode; then
3273       if $install_cp; then :; else
3274         func_quote_for_eval "$install_override_mode"
3275         func_append install_shared_prog " -m $func_quote_for_eval_result"
3276       fi
3277     fi
3278
3279     if test -z "$files"; then
3280       if test -z "$dest"; then
3281         func_fatal_help "no file or destination specified"
3282       else
3283         func_fatal_help "you must specify a destination"
3284       fi
3285     fi
3286
3287     # Strip any trailing slash from the destination.
3288     func_stripname '' '/' "$dest"
3289     dest=$func_stripname_result
3290
3291     # Check to see that the destination is a directory.
3292     test -d "$dest" && isdir=yes
3293     if test "$isdir" = yes; then
3294       destdir="$dest"
3295       destname=
3296     else
3297       func_dirname_and_basename "$dest" "" "."
3298       destdir="$func_dirname_result"
3299       destname="$func_basename_result"
3300
3301       # Not a directory, so check to see that there is only one file specified.
3302       set dummy $files; shift
3303       test "$#" -gt 1 && \
3304         func_fatal_help "\`$dest' is not a directory"
3305     fi
3306     case $destdir in
3307     [\\/]* | [A-Za-z]:[\\/]*) ;;
3308     *)
3309       for file in $files; do
3310         case $file in
3311         *.lo) ;;
3312         *)
3313           func_fatal_help "\`$destdir' must be an absolute directory name"
3314           ;;
3315         esac
3316       done
3317       ;;
3318     esac
3319
3320     # This variable tells wrapper scripts just to set variables rather
3321     # than running their programs.
3322     libtool_install_magic="$magic"
3323
3324     staticlibs=
3325     future_libdirs=
3326     current_libdirs=
3327     for file in $files; do
3328
3329       # Do each installation.
3330       case $file in
3331       *.$libext)
3332         # Do the static libraries later.
3333         func_append staticlibs " $file"
3334         ;;
3335
3336       *.la)
3337         func_resolve_sysroot "$file"
3338         file=$func_resolve_sysroot_result
3339
3340         # Check to see that this really is a libtool archive.
3341         func_lalib_unsafe_p "$file" \
3342           || func_fatal_help "\`$file' is not a valid libtool archive"
3343
3344         library_names=
3345         old_library=
3346         relink_command=
3347         func_source "$file"
3348
3349         # Add the libdir to current_libdirs if it is the destination.
3350         if test "X$destdir" = "X$libdir"; then
3351           case "$current_libdirs " in
3352           *" $libdir "*) ;;
3353           *) func_append current_libdirs " $libdir" ;;
3354           esac
3355         else
3356           # Note the libdir as a future libdir.
3357           case "$future_libdirs " in
3358           *" $libdir "*) ;;
3359           *) func_append future_libdirs " $libdir" ;;
3360           esac
3361         fi
3362
3363         func_dirname "$file" "/" ""
3364         dir="$func_dirname_result"
3365         func_append dir "$objdir"
3366
3367         if test -n "$relink_command"; then
3368           # Determine the prefix the user has applied to our future dir.
3369           inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
3370
3371           # Don't allow the user to place us outside of our expected
3372           # location b/c this prevents finding dependent libraries that
3373           # are installed to the same prefix.
3374           # At present, this check doesn't affect windows .dll's that
3375           # are installed into $libdir/../bin (currently, that works fine)
3376           # but it's something to keep an eye on.
3377           test "$inst_prefix_dir" = "$destdir" && \
3378             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
3379
3380           if test -n "$inst_prefix_dir"; then
3381             # Stick the inst_prefix_dir data into the link command.
3382             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
3383           else
3384             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
3385           fi
3386
3387           func_warning "relinking \`$file'"
3388           func_show_eval "$relink_command" \
3389             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
3390         fi
3391
3392         # See the names of the shared library.
3393         set dummy $library_names; shift
3394         if test -n "$1"; then
3395           realname="$1"
3396           shift
3397
3398           srcname="$realname"
3399           test -n "$relink_command" && srcname="$realname"T
3400
3401           # Install the shared library and build the symlinks.
3402           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
3403               'exit $?'
3404           tstripme="$stripme"
3405           case $host_os in
3406           cygwin* | mingw* | pw32* | cegcc*)
3407             case $realname in
3408             *.dll.a)
3409               tstripme=""
3410               ;;
3411             esac
3412             ;;
3413           esac
3414           if test -n "$tstripme" && test -n "$striplib"; then
3415             func_show_eval "$striplib $destdir/$realname" 'exit $?'
3416           fi
3417
3418           if test "$#" -gt 0; then
3419             # Delete the old symlinks, and create new ones.
3420             # Try `ln -sf' first, because the `ln' binary might depend on
3421             # the symlink we replace!  Solaris /bin/ln does not understand -f,
3422             # so we also need to try rm && ln -s.
3423             for linkname
3424             do
3425               test "$linkname" != "$realname" \
3426                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3427             done
3428           fi
3429
3430           # Do each command in the postinstall commands.
3431           lib="$destdir/$realname"
3432           func_execute_cmds "$postinstall_cmds" 'exit $?'
3433         fi
3434
3435         # Install the pseudo-library for information purposes.
3436         func_basename "$file"
3437         name="$func_basename_result"
3438         instname="$dir/$name"i
3439         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3440
3441         # Maybe install the static library, too.
3442         test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3443         ;;
3444
3445       *.lo)
3446         # Install (i.e. copy) a libtool object.
3447
3448         # Figure out destination file name, if it wasn't already specified.
3449         if test -n "$destname"; then
3450           destfile="$destdir/$destname"
3451         else
3452           func_basename "$file"
3453           destfile="$func_basename_result"
3454           destfile="$destdir/$destfile"
3455         fi
3456
3457         # Deduce the name of the destination old-style object file.
3458         case $destfile in
3459         *.lo)
3460           func_lo2o "$destfile"
3461           staticdest=$func_lo2o_result
3462           ;;
3463         *.$objext)
3464           staticdest="$destfile"
3465           destfile=
3466           ;;
3467         *)
3468           func_fatal_help "cannot copy a libtool object to \`$destfile'"
3469           ;;
3470         esac
3471
3472         # Install the libtool object if requested.
3473         test -n "$destfile" && \
3474           func_show_eval "$install_prog $file $destfile" 'exit $?'
3475
3476         # Install the old object if enabled.
3477         if test "$build_old_libs" = yes; then
3478           # Deduce the name of the old-style object file.
3479           func_lo2o "$file"
3480           staticobj=$func_lo2o_result
3481           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3482         fi
3483         exit $EXIT_SUCCESS
3484         ;;
3485
3486       *)
3487         # Figure out destination file name, if it wasn't already specified.
3488         if test -n "$destname"; then
3489           destfile="$destdir/$destname"
3490         else
3491           func_basename "$file"
3492           destfile="$func_basename_result"
3493           destfile="$destdir/$destfile"
3494         fi
3495
3496         # If the file is missing, and there is a .exe on the end, strip it
3497         # because it is most likely a libtool script we actually want to
3498         # install
3499         stripped_ext=""
3500         case $file in
3501           *.exe)
3502             if test ! -f "$file"; then
3503               func_stripname '' '.exe' "$file"
3504               file=$func_stripname_result
3505               stripped_ext=".exe"
3506             fi
3507             ;;
3508         esac
3509
3510         # Do a test to see if this is really a libtool program.
3511         case $host in
3512         *cygwin* | *mingw*)
3513             if func_ltwrapper_executable_p "$file"; then
3514               func_ltwrapper_scriptname "$file"
3515               wrapper=$func_ltwrapper_scriptname_result
3516             else
3517               func_stripname '' '.exe' "$file"
3518               wrapper=$func_stripname_result
3519             fi
3520             ;;
3521         *)
3522             wrapper=$file
3523             ;;
3524         esac
3525         if func_ltwrapper_script_p "$wrapper"; then
3526           notinst_deplibs=
3527           relink_command=
3528
3529           func_source "$wrapper"
3530
3531           # Check the variables that should have been set.
3532           test -z "$generated_by_libtool_version" && \
3533             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3534
3535           finalize=yes
3536           for lib in $notinst_deplibs; do
3537             # Check to see that each library is installed.
3538             libdir=
3539             if test -f "$lib"; then
3540               func_source "$lib"
3541             fi
3542             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3543             if test -n "$libdir" && test ! -f "$libfile"; then
3544               func_warning "\`$lib' has not been installed in \`$libdir'"
3545               finalize=no
3546             fi
3547           done
3548
3549           relink_command=
3550           func_source "$wrapper"
3551
3552           outputname=
3553           if test "$fast_install" = no && test -n "$relink_command"; then
3554             $opt_dry_run || {
3555               if test "$finalize" = yes; then
3556                 tmpdir=`func_mktempdir`
3557                 func_basename "$file$stripped_ext"
3558                 file="$func_basename_result"
3559                 outputname="$tmpdir/$file"
3560                 # Replace the output file specification.
3561                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3562
3563                 $opt_silent || {
3564                   func_quote_for_expand "$relink_command"
3565                   eval "func_echo $func_quote_for_expand_result"
3566                 }
3567                 if eval "$relink_command"; then :
3568                   else
3569                   func_error "error: relink \`$file' with the above command before installing it"
3570                   $opt_dry_run || ${RM}r "$tmpdir"
3571                   continue
3572                 fi
3573                 file="$outputname"
3574               else
3575                 func_warning "cannot relink \`$file'"
3576               fi
3577             }
3578           else
3579             # Install the binary that we compiled earlier.
3580             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3581           fi
3582         fi
3583
3584         # remove .exe since cygwin /usr/bin/install will append another
3585         # one anyway
3586         case $install_prog,$host in
3587         */usr/bin/install*,*cygwin*)
3588           case $file:$destfile in
3589           *.exe:*.exe)
3590             # this is ok
3591             ;;
3592           *.exe:*)
3593             destfile=$destfile.exe
3594             ;;
3595           *:*.exe)
3596             func_stripname '' '.exe' "$destfile"
3597             destfile=$func_stripname_result
3598             ;;
3599           esac
3600           ;;
3601         esac
3602         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3603         $opt_dry_run || if test -n "$outputname"; then
3604           ${RM}r "$tmpdir"
3605         fi
3606         ;;
3607       esac
3608     done
3609
3610     for file in $staticlibs; do
3611       func_basename "$file"
3612       name="$func_basename_result"
3613
3614       # Set up the ranlib parameters.
3615       oldlib="$destdir/$name"
3616
3617       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3618
3619       if test -n "$stripme" && test -n "$old_striplib"; then
3620         func_show_eval "$old_striplib $oldlib" 'exit $?'
3621       fi
3622
3623       # Do each command in the postinstall commands.
3624       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3625     done
3626
3627     test -n "$future_libdirs" && \
3628       func_warning "remember to run \`$progname --finish$future_libdirs'"
3629
3630     if test -n "$current_libdirs"; then
3631       # Maybe just do a dry run.
3632       $opt_dry_run && current_libdirs=" -n$current_libdirs"
3633       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3634     else
3635       exit $EXIT_SUCCESS
3636     fi
3637 }
3638
3639 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3640
3641
3642 # func_generate_dlsyms outputname originator pic_p
3643 # Extract symbols from dlprefiles and create ${outputname}S.o with
3644 # a dlpreopen symbol table.
3645 func_generate_dlsyms ()
3646 {
3647     $opt_debug
3648     my_outputname="$1"
3649     my_originator="$2"
3650     my_pic_p="${3-no}"
3651     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3652     my_dlsyms=
3653
3654     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3655       if test -n "$NM" && test -n "$global_symbol_pipe"; then
3656         my_dlsyms="${my_outputname}S.c"
3657       else
3658         func_error "not configured to extract global symbols from dlpreopened files"
3659       fi
3660     fi
3661
3662     if test -n "$my_dlsyms"; then
3663       case $my_dlsyms in
3664       "") ;;
3665       *.c)
3666         # Discover the nlist of each of the dlfiles.
3667         nlist="$output_objdir/${my_outputname}.nm"
3668
3669         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3670
3671         # Parse the name list into a source file.
3672         func_verbose "creating $output_objdir/$my_dlsyms"
3673
3674         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3675 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3676 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3677
3678 #ifdef __cplusplus
3679 extern \"C\" {
3680 #endif
3681
3682 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3683 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3684 #endif
3685
3686 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
3687 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3688 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3689    relocations are performed -- see ld's documentation on pseudo-relocs.  */
3690 # define LT_DLSYM_CONST
3691 #elif defined(__osf__)
3692 /* This system does not cope well with relocations in const data.  */
3693 # define LT_DLSYM_CONST
3694 #else
3695 # define LT_DLSYM_CONST const
3696 #endif
3697
3698 /* External symbol declarations for the compiler. */\
3699 "
3700
3701         if test "$dlself" = yes; then
3702           func_verbose "generating symbol list for \`$output'"
3703
3704           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3705
3706           # Add our own program objects to the symbol list.
3707           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3708           for progfile in $progfiles; do
3709             func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3710             func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3711             $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3712           done
3713
3714           if test -n "$exclude_expsyms"; then
3715             $opt_dry_run || {
3716               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3717               eval '$MV "$nlist"T "$nlist"'
3718             }
3719           fi
3720
3721           if test -n "$export_symbols_regex"; then
3722             $opt_dry_run || {
3723               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3724               eval '$MV "$nlist"T "$nlist"'
3725             }
3726           fi
3727
3728           # Prepare the list of exported symbols
3729           if test -z "$export_symbols"; then
3730             export_symbols="$output_objdir/$outputname.exp"
3731             $opt_dry_run || {
3732               $RM $export_symbols
3733               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3734               case $host in
3735               *cygwin* | *mingw* | *cegcc* )
3736                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3737                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3738                 ;;
3739               esac
3740             }
3741           else
3742             $opt_dry_run || {
3743               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3744               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3745               eval '$MV "$nlist"T "$nlist"'
3746               case $host in
3747                 *cygwin* | *mingw* | *cegcc* )
3748                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3749                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3750                   ;;
3751               esac
3752             }
3753           fi
3754         fi
3755
3756         for dlprefile in $dlprefiles; do
3757           func_verbose "extracting global C symbols from \`$dlprefile'"
3758           func_basename "$dlprefile"
3759           name="$func_basename_result"
3760           case $host in
3761             *cygwin* | *mingw* | *cegcc* )
3762               # if an import library, we need to obtain dlname
3763               if func_win32_import_lib_p "$dlprefile"; then
3764                 func_tr_sh "$dlprefile"
3765                 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3766                 dlprefile_dlbasename=""
3767                 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3768                   # Use subshell, to avoid clobbering current variable values
3769                   dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3770                   if test -n "$dlprefile_dlname" ; then
3771                     func_basename "$dlprefile_dlname"
3772                     dlprefile_dlbasename="$func_basename_result"
3773                   else
3774                     # no lafile. user explicitly requested -dlpreopen <import library>.
3775                     $sharedlib_from_linklib_cmd "$dlprefile"
3776                     dlprefile_dlbasename=$sharedlib_from_linklib_result
3777                   fi
3778                 fi
3779                 $opt_dry_run || {
3780                   if test -n "$dlprefile_dlbasename" ; then
3781                     eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3782                   else
3783                     func_warning "Could not compute DLL name from $name"
3784                     eval '$ECHO ": $name " >> "$nlist"'
3785                   fi
3786                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3787                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3788                     $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3789                 }
3790               else # not an import lib
3791                 $opt_dry_run || {
3792                   eval '$ECHO ": $name " >> "$nlist"'
3793                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3794                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3795                 }
3796               fi
3797             ;;
3798             *)
3799               $opt_dry_run || {
3800                 eval '$ECHO ": $name " >> "$nlist"'
3801                 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3802                 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3803               }
3804             ;;
3805           esac
3806         done
3807
3808         $opt_dry_run || {
3809           # Make sure we have at least an empty file.
3810           test -f "$nlist" || : > "$nlist"
3811
3812           if test -n "$exclude_expsyms"; then
3813             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3814             $MV "$nlist"T "$nlist"
3815           fi
3816
3817           # Try sorting and uniquifying the output.
3818           if $GREP -v "^: " < "$nlist" |
3819               if sort -k 3 </dev/null >/dev/null 2>&1; then
3820                 sort -k 3
3821               else
3822                 sort +2
3823               fi |
3824               uniq > "$nlist"S; then
3825             :
3826           else
3827             $GREP -v "^: " < "$nlist" > "$nlist"S
3828           fi
3829
3830           if test -f "$nlist"S; then
3831             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3832           else
3833             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3834           fi
3835
3836           echo >> "$output_objdir/$my_dlsyms" "\
3837
3838 /* The mapping between symbol names and symbols.  */
3839 typedef struct {
3840   const char *name;
3841   void *address;
3842 } lt_dlsymlist;
3843 extern LT_DLSYM_CONST lt_dlsymlist
3844 lt_${my_prefix}_LTX_preloaded_symbols[];
3845 LT_DLSYM_CONST lt_dlsymlist
3846 lt_${my_prefix}_LTX_preloaded_symbols[] =
3847 {\
3848   { \"$my_originator\", (void *) 0 },"
3849
3850           case $need_lib_prefix in
3851           no)
3852             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3853             ;;
3854           *)
3855             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3856             ;;
3857           esac
3858           echo >> "$output_objdir/$my_dlsyms" "\
3859   {0, (void *) 0}
3860 };
3861
3862 /* This works around a problem in FreeBSD linker */
3863 #ifdef FREEBSD_WORKAROUND
3864 static const void *lt_preloaded_setup() {
3865   return lt_${my_prefix}_LTX_preloaded_symbols;
3866 }
3867 #endif
3868
3869 #ifdef __cplusplus
3870 }
3871 #endif\
3872 "
3873         } # !$opt_dry_run
3874
3875         pic_flag_for_symtable=
3876         case "$compile_command " in
3877         *" -static "*) ;;
3878         *)
3879           case $host in
3880           # compiling the symbol table file with pic_flag works around
3881           # a FreeBSD bug that causes programs to crash when -lm is
3882           # linked before any other PIC object.  But we must not use
3883           # pic_flag when linking with -static.  The problem exists in
3884           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3885           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3886             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3887           *-*-hpux*)
3888             pic_flag_for_symtable=" $pic_flag"  ;;
3889           *)
3890             if test "X$my_pic_p" != Xno; then
3891               pic_flag_for_symtable=" $pic_flag"
3892             fi
3893             ;;
3894           esac
3895           ;;
3896         esac
3897         symtab_cflags=
3898         for arg in $LTCFLAGS; do
3899           case $arg in
3900           -pie | -fpie | -fPIE) ;;
3901           *) func_append symtab_cflags " $arg" ;;
3902           esac
3903         done
3904
3905         # Now compile the dynamic symbol file.
3906         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3907
3908         # Clean up the generated files.
3909         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3910
3911         # Transform the symbol file into the correct name.
3912         symfileobj="$output_objdir/${my_outputname}S.$objext"
3913         case $host in
3914         *cygwin* | *mingw* | *cegcc* )
3915           if test -f "$output_objdir/$my_outputname.def"; then
3916             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3917             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3918           else
3919             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3920             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3921           fi
3922           ;;
3923         *)
3924           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3925           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3926           ;;
3927         esac
3928         ;;
3929       *)
3930         func_fatal_error "unknown suffix for \`$my_dlsyms'"
3931         ;;
3932       esac
3933     else
3934       # We keep going just in case the user didn't refer to
3935       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3936       # really was required.
3937
3938       # Nullify the symbol file.
3939       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3940       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3941     fi
3942 }
3943
3944 # func_win32_libid arg
3945 # return the library type of file 'arg'
3946 #
3947 # Need a lot of goo to handle *both* DLLs and import libs
3948 # Has to be a shell function in order to 'eat' the argument
3949 # that is supplied when $file_magic_command is called.
3950 # Despite the name, also deal with 64 bit binaries.
3951 func_win32_libid ()
3952 {
3953   $opt_debug
3954   win32_libid_type="unknown"
3955   win32_fileres=`file -L $1 2>/dev/null`
3956   case $win32_fileres in
3957   *ar\ archive\ import\ library*) # definitely import
3958     win32_libid_type="x86 archive import"
3959     ;;
3960   *ar\ archive*) # could be an import, or static
3961     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3962     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3963        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3964       func_to_tool_file "$1" func_convert_file_msys_to_w32
3965       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3966         $SED -n -e '
3967             1,100{
3968                 / I /{
3969                     s,.*,import,
3970                     p
3971                     q
3972                 }
3973             }'`
3974       case $win32_nmres in
3975       import*)  win32_libid_type="x86 archive import";;
3976       *)        win32_libid_type="x86 archive static";;
3977       esac
3978     fi
3979     ;;
3980   *DLL*)
3981     win32_libid_type="x86 DLL"
3982     ;;
3983   *executable*) # but shell scripts are "executable" too...
3984     case $win32_fileres in
3985     *MS\ Windows\ PE\ Intel*)
3986       win32_libid_type="x86 DLL"
3987       ;;
3988     esac
3989     ;;
3990   esac
3991   $ECHO "$win32_libid_type"
3992 }
3993
3994 # func_cygming_dll_for_implib ARG
3995 #
3996 # Platform-specific function to extract the
3997 # name of the DLL associated with the specified
3998 # import library ARG.
3999 # Invoked by eval'ing the libtool variable
4000 #    $sharedlib_from_linklib_cmd
4001 # Result is available in the variable
4002 #    $sharedlib_from_linklib_result
4003 func_cygming_dll_for_implib ()
4004 {
4005   $opt_debug
4006   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
4007 }
4008
4009 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
4010 #
4011 # The is the core of a fallback implementation of a
4012 # platform-specific function to extract the name of the
4013 # DLL associated with the specified import library LIBNAME.
4014 #
4015 # SECTION_NAME is either .idata$6 or .idata$7, depending
4016 # on the platform and compiler that created the implib.
4017 #
4018 # Echos the name of the DLL associated with the
4019 # specified import library.
4020 func_cygming_dll_for_implib_fallback_core ()
4021 {
4022   $opt_debug
4023   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
4024   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
4025     $SED '/^Contents of section '"$match_literal"':/{
4026       # Place marker at beginning of archive member dllname section
4027       s/.*/====MARK====/
4028       p
4029       d
4030     }
4031     # These lines can sometimes be longer than 43 characters, but
4032     # are always uninteresting
4033     /:[  ]*file format pe[i]\{,1\}-/d
4034     /^In archive [^:]*:/d
4035     # Ensure marker is printed
4036     /^====MARK====/p
4037     # Remove all lines with less than 43 characters
4038     /^.\{43\}/!d
4039     # From remaining lines, remove first 43 characters
4040     s/^.\{43\}//' |
4041     $SED -n '
4042       # Join marker and all lines until next marker into a single line
4043       /^====MARK====/ b para
4044       H
4045       $ b para
4046       b
4047       :para
4048       x
4049       s/\n//g
4050       # Remove the marker
4051       s/^====MARK====//
4052       # Remove trailing dots and whitespace
4053       s/[\. \t]*$//
4054       # Print
4055       /./p' |
4056     # we now have a list, one entry per line, of the stringified
4057     # contents of the appropriate section of all members of the
4058     # archive which possess that section. Heuristic: eliminate
4059     # all those which have a first or second character that is
4060     # a '.' (that is, objdump's representation of an unprintable
4061     # character.) This should work for all archives with less than
4062     # 0x302f exports -- but will fail for DLLs whose name actually
4063     # begins with a literal '.' or a single character followed by
4064     # a '.'.
4065     #
4066     # Of those that remain, print the first one.
4067     $SED -e '/^\./d;/^.\./d;q'
4068 }
4069
4070 # func_cygming_gnu_implib_p ARG
4071 # This predicate returns with zero status (TRUE) if
4072 # ARG is a GNU/binutils-style import library. Returns
4073 # with nonzero status (FALSE) otherwise.
4074 func_cygming_gnu_implib_p ()
4075 {
4076   $opt_debug
4077   func_to_tool_file "$1" func_convert_file_msys_to_w32
4078   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
4079   test -n "$func_cygming_gnu_implib_tmp"
4080 }
4081
4082 # func_cygming_ms_implib_p ARG
4083 # This predicate returns with zero status (TRUE) if
4084 # ARG is an MS-style import library. Returns
4085 # with nonzero status (FALSE) otherwise.
4086 func_cygming_ms_implib_p ()
4087 {
4088   $opt_debug
4089   func_to_tool_file "$1" func_convert_file_msys_to_w32
4090   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
4091   test -n "$func_cygming_ms_implib_tmp"
4092 }
4093
4094 # func_cygming_dll_for_implib_fallback ARG
4095 # Platform-specific function to extract the
4096 # name of the DLL associated with the specified
4097 # import library ARG.
4098 #
4099 # This fallback implementation is for use when $DLLTOOL
4100 # does not support the --identify-strict option.
4101 # Invoked by eval'ing the libtool variable
4102 #    $sharedlib_from_linklib_cmd
4103 # Result is available in the variable
4104 #    $sharedlib_from_linklib_result
4105 func_cygming_dll_for_implib_fallback ()
4106 {
4107   $opt_debug
4108   if func_cygming_gnu_implib_p "$1" ; then
4109     # binutils import library
4110     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
4111   elif func_cygming_ms_implib_p "$1" ; then
4112     # ms-generated import library
4113     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
4114   else
4115     # unknown
4116     sharedlib_from_linklib_result=""
4117   fi
4118 }
4119
4120
4121 # func_extract_an_archive dir oldlib
4122 func_extract_an_archive ()
4123 {
4124     $opt_debug
4125     f_ex_an_ar_dir="$1"; shift
4126     f_ex_an_ar_oldlib="$1"
4127     if test "$lock_old_archive_extraction" = yes; then
4128       lockfile=$f_ex_an_ar_oldlib.lock
4129       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
4130         func_echo "Waiting for $lockfile to be removed"
4131         sleep 2
4132       done
4133     fi
4134     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
4135                    'stat=$?; rm -f "$lockfile"; exit $stat'
4136     if test "$lock_old_archive_extraction" = yes; then
4137       $opt_dry_run || rm -f "$lockfile"
4138     fi
4139     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
4140      :
4141     else
4142       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
4143     fi
4144 }
4145
4146
4147 # func_extract_archives gentop oldlib ...
4148 func_extract_archives ()
4149 {
4150     $opt_debug
4151     my_gentop="$1"; shift
4152     my_oldlibs=${1+"$@"}
4153     my_oldobjs=""
4154     my_xlib=""
4155     my_xabs=""
4156     my_xdir=""
4157
4158     for my_xlib in $my_oldlibs; do
4159       # Extract the objects.
4160       case $my_xlib in
4161         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
4162         *) my_xabs=`pwd`"/$my_xlib" ;;
4163       esac
4164       func_basename "$my_xlib"
4165       my_xlib="$func_basename_result"
4166       my_xlib_u=$my_xlib
4167       while :; do
4168         case " $extracted_archives " in
4169         *" $my_xlib_u "*)
4170           func_arith $extracted_serial + 1
4171           extracted_serial=$func_arith_result
4172           my_xlib_u=lt$extracted_serial-$my_xlib ;;
4173         *) break ;;
4174         esac
4175       done
4176       extracted_archives="$extracted_archives $my_xlib_u"
4177       my_xdir="$my_gentop/$my_xlib_u"
4178
4179       func_mkdir_p "$my_xdir"
4180
4181       case $host in
4182       *-darwin*)
4183         func_verbose "Extracting $my_xabs"
4184         # Do not bother doing anything if just a dry run
4185         $opt_dry_run || {
4186           darwin_orig_dir=`pwd`
4187           cd $my_xdir || exit $?
4188           darwin_archive=$my_xabs
4189           darwin_curdir=`pwd`
4190           darwin_base_archive=`basename "$darwin_archive"`
4191           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
4192           if test -n "$darwin_arches"; then
4193             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
4194             darwin_arch=
4195             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
4196             for darwin_arch in  $darwin_arches ; do
4197               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
4198               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
4199               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
4200               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
4201               cd "$darwin_curdir"
4202               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
4203             done # $darwin_arches
4204             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
4205             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
4206             darwin_file=
4207             darwin_files=
4208             for darwin_file in $darwin_filelist; do
4209               darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
4210               $LIPO -create -output "$darwin_file" $darwin_files
4211             done # $darwin_filelist
4212             $RM -rf unfat-$$
4213             cd "$darwin_orig_dir"
4214           else
4215             cd $darwin_orig_dir
4216             func_extract_an_archive "$my_xdir" "$my_xabs"
4217           fi # $darwin_arches
4218         } # !$opt_dry_run
4219         ;;
4220       *)
4221         func_extract_an_archive "$my_xdir" "$my_xabs"
4222         ;;
4223       esac
4224       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
4225     done
4226
4227     func_extract_archives_result="$my_oldobjs"
4228 }
4229
4230
4231 # func_emit_wrapper [arg=no]
4232 #
4233 # Emit a libtool wrapper script on stdout.
4234 # Don't directly open a file because we may want to
4235 # incorporate the script contents within a cygwin/mingw
4236 # wrapper executable.  Must ONLY be called from within
4237 # func_mode_link because it depends on a number of variables
4238 # set therein.
4239 #
4240 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
4241 # variable will take.  If 'yes', then the emitted script
4242 # will assume that the directory in which it is stored is
4243 # the $objdir directory.  This is a cygwin/mingw-specific
4244 # behavior.
4245 func_emit_wrapper ()
4246 {
4247         func_emit_wrapper_arg1=${1-no}
4248
4249         $ECHO "\
4250 #! $SHELL
4251
4252 # $output - temporary wrapper script for $objdir/$outputname
4253 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4254 #
4255 # The $output program cannot be directly executed until all the libtool
4256 # libraries that it depends on are installed.
4257 #
4258 # This wrapper script should never be moved out of the build directory.
4259 # If it is, it will not operate correctly.
4260
4261 # Sed substitution that helps us do robust quoting.  It backslashifies
4262 # metacharacters that are still active within double-quoted strings.
4263 sed_quote_subst='$sed_quote_subst'
4264
4265 # Be Bourne compatible
4266 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
4267   emulate sh
4268   NULLCMD=:
4269   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
4270   # is contrary to our usage.  Disable this feature.
4271   alias -g '\${1+\"\$@\"}'='\"\$@\"'
4272   setopt NO_GLOB_SUBST
4273 else
4274   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
4275 fi
4276 BIN_SH=xpg4; export BIN_SH # for Tru64
4277 DUALCASE=1; export DUALCASE # for MKS sh
4278
4279 # The HP-UX ksh and POSIX shell print the target directory to stdout
4280 # if CDPATH is set.
4281 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
4282
4283 relink_command=\"$relink_command\"
4284
4285 # This environment variable determines our operation mode.
4286 if test \"\$libtool_install_magic\" = \"$magic\"; then
4287   # install mode needs the following variables:
4288   generated_by_libtool_version='$macro_version'
4289   notinst_deplibs='$notinst_deplibs'
4290 else
4291   # When we are sourced in execute mode, \$file and \$ECHO are already set.
4292   if test \"\$libtool_execute_magic\" != \"$magic\"; then
4293     file=\"\$0\""
4294
4295     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
4296     $ECHO "\
4297
4298 # A function that is used when there is no print builtin or printf.
4299 func_fallback_echo ()
4300 {
4301   eval 'cat <<_LTECHO_EOF
4302 \$1
4303 _LTECHO_EOF'
4304 }
4305     ECHO=\"$qECHO\"
4306   fi
4307
4308 # Very basic option parsing. These options are (a) specific to
4309 # the libtool wrapper, (b) are identical between the wrapper
4310 # /script/ and the wrapper /executable/ which is used only on
4311 # windows platforms, and (c) all begin with the string "--lt-"
4312 # (application programs are unlikely to have options which match
4313 # this pattern).
4314 #
4315 # There are only two supported options: --lt-debug and
4316 # --lt-dump-script. There is, deliberately, no --lt-help.
4317 #
4318 # The first argument to this parsing function should be the
4319 # script's $0 value, followed by "$@".
4320 lt_option_debug=
4321 func_parse_lt_options ()
4322 {
4323   lt_script_arg0=\$0
4324   shift
4325   for lt_opt
4326   do
4327     case \"\$lt_opt\" in
4328     --lt-debug) lt_option_debug=1 ;;
4329     --lt-dump-script)
4330         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
4331         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
4332         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
4333         cat \"\$lt_dump_D/\$lt_dump_F\"
4334         exit 0
4335       ;;
4336     --lt-*)
4337         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
4338         exit 1
4339       ;;
4340     esac
4341   done
4342
4343   # Print the debug banner immediately:
4344   if test -n \"\$lt_option_debug\"; then
4345     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
4346   fi
4347 }
4348
4349 # Used when --lt-debug. Prints its arguments to stdout
4350 # (redirection is the responsibility of the caller)
4351 func_lt_dump_args ()
4352 {
4353   lt_dump_args_N=1;
4354   for lt_arg
4355   do
4356     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
4357     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
4358   done
4359 }
4360
4361 # Core function for launching the target application
4362 func_exec_program_core ()
4363 {
4364 "
4365   case $host in
4366   # Backslashes separate directories on plain windows
4367   *-*-mingw | *-*-os2* | *-cegcc*)
4368     $ECHO "\
4369       if test -n \"\$lt_option_debug\"; then
4370         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
4371         func_lt_dump_args \${1+\"\$@\"} 1>&2
4372       fi
4373       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
4374 "
4375     ;;
4376
4377   *)
4378     $ECHO "\
4379       if test -n \"\$lt_option_debug\"; then
4380         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
4381         func_lt_dump_args \${1+\"\$@\"} 1>&2
4382       fi
4383       exec \"\$progdir/\$program\" \${1+\"\$@\"}
4384 "
4385     ;;
4386   esac
4387   $ECHO "\
4388       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
4389       exit 1
4390 }
4391
4392 # A function to encapsulate launching the target application
4393 # Strips options in the --lt-* namespace from \$@ and
4394 # launches target application with the remaining arguments.
4395 func_exec_program ()
4396 {
4397   for lt_wr_arg
4398   do
4399     case \$lt_wr_arg in
4400     --lt-*) ;;
4401     *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
4402     esac
4403     shift
4404   done
4405   func_exec_program_core \${1+\"\$@\"}
4406 }
4407
4408   # Parse options
4409   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4410
4411   # Find the directory that this script lives in.
4412   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4413   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4414
4415   # Follow symbolic links until we get to the real thisdir.
4416   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4417   while test -n \"\$file\"; do
4418     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4419
4420     # If there was a directory component, then change thisdir.
4421     if test \"x\$destdir\" != \"x\$file\"; then
4422       case \"\$destdir\" in
4423       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4424       *) thisdir=\"\$thisdir/\$destdir\" ;;
4425       esac
4426     fi
4427
4428     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4429     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4430   done
4431
4432   # Usually 'no', except on cygwin/mingw when embedded into
4433   # the cwrapper.
4434   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4435   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4436     # special case for '.'
4437     if test \"\$thisdir\" = \".\"; then
4438       thisdir=\`pwd\`
4439     fi
4440     # remove .libs from thisdir
4441     case \"\$thisdir\" in
4442     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4443     $objdir )   thisdir=. ;;
4444     esac
4445   fi
4446
4447   # Try to get the absolute directory name.
4448   absdir=\`cd \"\$thisdir\" && pwd\`
4449   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4450 "
4451
4452         if test "$fast_install" = yes; then
4453           $ECHO "\
4454   program=lt-'$outputname'$exeext
4455   progdir=\"\$thisdir/$objdir\"
4456
4457   if test ! -f \"\$progdir/\$program\" ||
4458      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4459        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4460
4461     file=\"\$\$-\$program\"
4462
4463     if test ! -d \"\$progdir\"; then
4464       $MKDIR \"\$progdir\"
4465     else
4466       $RM \"\$progdir/\$file\"
4467     fi"
4468
4469           $ECHO "\
4470
4471     # relink executable if necessary
4472     if test -n \"\$relink_command\"; then
4473       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4474       else
4475         $ECHO \"\$relink_command_output\" >&2
4476         $RM \"\$progdir/\$file\"
4477         exit 1
4478       fi
4479     fi
4480
4481     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4482     { $RM \"\$progdir/\$program\";
4483       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4484     $RM \"\$progdir/\$file\"
4485   fi"
4486         else
4487           $ECHO "\
4488   program='$outputname'
4489   progdir=\"\$thisdir/$objdir\"
4490 "
4491         fi
4492
4493         $ECHO "\
4494
4495   if test -f \"\$progdir/\$program\"; then"
4496
4497         # fixup the dll searchpath if we need to.
4498         #
4499         # Fix the DLL searchpath if we need to.  Do this before prepending
4500         # to shlibpath, because on Windows, both are PATH and uninstalled
4501         # libraries must come first.
4502         if test -n "$dllsearchpath"; then
4503           $ECHO "\
4504     # Add the dll search path components to the executable PATH
4505     PATH=$dllsearchpath:\$PATH
4506 "
4507         fi
4508
4509         # Export our shlibpath_var if we have one.
4510         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4511           $ECHO "\
4512     # Add our own library path to $shlibpath_var
4513     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4514
4515     # Some systems cannot cope with colon-terminated $shlibpath_var
4516     # The second colon is a workaround for a bug in BeOS R4 sed
4517     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4518
4519     export $shlibpath_var
4520 "
4521         fi
4522
4523         $ECHO "\
4524     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4525       # Run the actual program with our arguments.
4526       func_exec_program \${1+\"\$@\"}
4527     fi
4528   else
4529     # The program doesn't exist.
4530     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4531     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4532     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4533     exit 1
4534   fi
4535 fi\
4536 "
4537 }
4538
4539
4540 # func_emit_cwrapperexe_src
4541 # emit the source code for a wrapper executable on stdout
4542 # Must ONLY be called from within func_mode_link because
4543 # it depends on a number of variable set therein.
4544 func_emit_cwrapperexe_src ()
4545 {
4546         cat <<EOF
4547
4548 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4549    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4550
4551    The $output program cannot be directly executed until all the libtool
4552    libraries that it depends on are installed.
4553
4554    This wrapper executable should never be moved out of the build directory.
4555    If it is, it will not operate correctly.
4556 */
4557 EOF
4558             cat <<"EOF"
4559 #ifdef _MSC_VER
4560 # define _CRT_SECURE_NO_DEPRECATE 1
4561 #endif
4562 #include <stdio.h>
4563 #include <stdlib.h>
4564 #ifdef _MSC_VER
4565 # include <direct.h>
4566 # include <process.h>
4567 # include <io.h>
4568 #else
4569 # include <unistd.h>
4570 # include <stdint.h>
4571 # ifdef __CYGWIN__
4572 #  include <io.h>
4573 # endif
4574 #endif
4575 #include <malloc.h>
4576 #include <stdarg.h>
4577 #include <assert.h>
4578 #include <string.h>
4579 #include <ctype.h>
4580 #include <errno.h>
4581 #include <fcntl.h>
4582 #include <sys/stat.h>
4583
4584 /* declarations of non-ANSI functions */
4585 #if defined(__MINGW32__)
4586 # ifdef __STRICT_ANSI__
4587 int _putenv (const char *);
4588 # endif
4589 #elif defined(__CYGWIN__)
4590 # ifdef __STRICT_ANSI__
4591 char *realpath (const char *, char *);
4592 int putenv (char *);
4593 int setenv (const char *, const char *, int);
4594 # endif
4595 /* #elif defined (other platforms) ... */
4596 #endif
4597
4598 /* portability defines, excluding path handling macros */
4599 #if defined(_MSC_VER)
4600 # define setmode _setmode
4601 # define stat    _stat
4602 # define chmod   _chmod
4603 # define getcwd  _getcwd
4604 # define putenv  _putenv
4605 # define S_IXUSR _S_IEXEC
4606 # ifndef _INTPTR_T_DEFINED
4607 #  define _INTPTR_T_DEFINED
4608 #  define intptr_t int
4609 # endif
4610 #elif defined(__MINGW32__)
4611 # define setmode _setmode
4612 # define stat    _stat
4613 # define chmod   _chmod
4614 # define getcwd  _getcwd
4615 # define putenv  _putenv
4616 #elif defined(__CYGWIN__)
4617 # define HAVE_SETENV
4618 # define FOPEN_WB "wb"
4619 /* #elif defined (other platforms) ... */
4620 #endif
4621
4622 #if defined(PATH_MAX)
4623 # define LT_PATHMAX PATH_MAX
4624 #elif defined(MAXPATHLEN)
4625 # define LT_PATHMAX MAXPATHLEN
4626 #else
4627 # define LT_PATHMAX 1024
4628 #endif