www.gitorious.org Git - gnutls:gnutls.git/blob

2 # libtool (GNU libtool) 2.4.2

3 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

6 # 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

7 # This is free software; see the source for copying conditions. There is NO

8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

10 # GNU Libtool is free software; you can redistribute it and/or modify

11 # it under the terms of the GNU General Public License as published by

12 # the Free Software Foundation; either version 2 of the License, or

13 # (at your option) any later version.

14 #

15 # As a special exception to the GNU General Public License,

16 # if you distribute this file as part of a program or library that

17 # is built using GNU Libtool, you may include this file under the

18 # same distribution terms that you use for the rest of that program.

19 #

20 # GNU Libtool is distributed in the hope that it will be useful, but

21 # WITHOUT ANY WARRANTY; without even the implied warranty of

22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

23 # General Public License for more details.

24 #

25 # You should have received a copy of the GNU General Public License

26 # along with GNU Libtool; see the file COPYING. If not, a copy

27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,

28 # or obtained by writing to the Free Software Foundation, Inc.,

29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

31 # Usage: $progname [OPTION]... [MODE-ARG]...

32 #

33 # Provide generalized library-building support services.

34 #

35 # --config show all configuration variables

36 # --debug enable verbose shell tracing

37 # -n, --dry-run display commands without modifying any files

38 # --features display basic configuration information and exit

39 # --mode=MODE use operation mode MODE

40 # --preserve-dup-deps don't remove duplicate dependency libraries

41 # --quiet, --silent don't print informational messages

42 # --no-quiet, --no-silent

43 # print informational messages (default)

44 # --no-warn don't display warning messages

45 # --tag=TAG use configuration variables from tag TAG

46 # -v, --verbose print more informational messages than default

47 # --no-verbose don't print the extra informational messages

48 # --version print version information

49 # -h, --help, --help-all print short, long, or detailed help message

50 #

51 # MODE must be one of the following:

52 #

53 # clean remove files from the build directory

54 # compile compile a source file into a libtool object

55 # execute automatically set library path, then run a program

56 # finish complete the installation of libtool libraries

57 # install install libraries or executables

58 # link create a library or an executable

59 # uninstall remove libraries from an installed directory

60 #

61 # MODE-ARGS vary depending on the MODE. When passed as first option,

62 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.

63 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.

64 #

65 # When reporting a bug, please describe a test case to reproduce it and

66 # include the following information:

67 #

68 # host-triplet: $host

69 # shell: $SHELL

70 # compiler: $LTCC

71 # compiler flags: $LTCFLAGS

72 # linker: $LD (gnu? $with_gnu_ld)

73 # $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1

74 # automake: $automake_version

75 # autoconf: $autoconf_version

76 #

77 # Report bugs to <bug-libtool@gnu.org>.

78 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.

79 # General help using GNU software: <http://www.gnu.org/gethelp/>.

81 PROGRAM=libtool

82 PACKAGE=libtool

83 VERSION="2.4.2 Debian-2.4.2-1"

84 TIMESTAMP=""

85 package_revision=1.3337

87 # Be Bourne compatible

88 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

89 emulate sh

90 NULLCMD=:

91 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

92 # is contrary to our usage. Disable this feature.

93 alias -g '${1+"$@"}'='"$@"'

94 setopt NO_GLOB_SUBST

95 else

96 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac

97 fi

98 BIN_SH=xpg4; export BIN_SH # for Tru64

99 DUALCASE=1; export DUALCASE # for MKS sh

100

101 # A function that is used when there is no print builtin or printf.

102 func_fallback_echo ()

103 {

104 eval 'cat <<_LTECHO_EOF

105 $1

106 _LTECHO_EOF'

107 }

108

109 # NLS nuisances: We save the old values to restore during execute mode.

110 lt_user_locale=

111 lt_safe_locale=

112 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

113 do

114 eval "if test \"\${$lt_var+set}\" = set; then

115 save_$lt_var=\$$lt_var

116 $lt_var=C

117 export $lt_var

118 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"

119 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"

120 fi"

121 done

122 LC_ALL=C

123 LANGUAGE=C

124 export LANGUAGE LC_ALL

125

126 $lt_unset CDPATH

127

128

129 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

130 # is ksh but when the shell is invoked as "sh" and the current value of

131 # the _XPG environment variable is not equal to 1 (one), the special

132 # positional parameter $0, within a function call, is the name of the

133 # function.

134 progpath="$0"

135

136

137

138 : ${CP="cp -f"}

139 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}

140 : ${MAKE="make"}

141 : ${MKDIR="mkdir"}

142 : ${MV="mv -f"}

143 : ${RM="rm -f"}

144 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}

145 : ${Xsed="$SED -e 1s/^X//"}

146

147 # Global variables:

148 EXIT_SUCCESS=0

149 EXIT_FAILURE=1

150 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.

151 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.

152

153 exit_status=$EXIT_SUCCESS

154

155 # Make sure IFS has a sensible default

156 lt_nl='

157 '

158 IFS=" $lt_nl"

159

160 dirname="s,/[^/]*$,,"

161 basename="s,^.*/,,"

162

163 # func_dirname file append nondir_replacement

164 # Compute the dirname of FILE. If nonempty, add APPEND to the result,

165 # otherwise set result to NONDIR_REPLACEMENT.

166 func_dirname ()

167 {

168 func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`

169 if test "X$func_dirname_result" = "X${1}"; then

170 func_dirname_result="${3}"

171 else

172 func_dirname_result="$func_dirname_result${2}"

173 fi

174 } # func_dirname may be replaced by extended shell implementation

175

176

177 # func_basename file

178 func_basename ()

179 {

180 func_basename_result=`$ECHO "${1}" | $SED "$basename"`

181 } # func_basename may be replaced by extended shell implementation

182

183

184 # func_dirname_and_basename file append nondir_replacement

185 # perform func_basename and func_dirname in a single function

186 # call:

187 # dirname: Compute the dirname of FILE. If nonempty,

188 # add APPEND to the result, otherwise set result

189 # to NONDIR_REPLACEMENT.

190 # value returned in "$func_dirname_result"

191 # basename: Compute filename of FILE.

192 # value retuned in "$func_basename_result"

193 # Implementation must be kept synchronized with func_dirname

194 # and func_basename. For efficiency, we do not delegate to

195 # those functions but instead duplicate the functionality here.

196 func_dirname_and_basename ()

197 {

198 # Extract subdirectory from the argument.

199 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`

200 if test "X$func_dirname_result" = "X${1}"; then

201 func_dirname_result="${3}"

202 else

203 func_dirname_result="$func_dirname_result${2}"

204 fi

205 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`

206 } # func_dirname_and_basename may be replaced by extended shell implementation

207

208

209 # func_stripname prefix suffix name

210 # strip PREFIX and SUFFIX off of NAME.

211 # PREFIX and SUFFIX must not contain globbing or regex special

212 # characters, hashes, percent signs, but SUFFIX may contain a leading

213 # dot (in which case that matches only a dot).

214 # func_strip_suffix prefix name

215 func_stripname ()

216 {

217 case ${2} in

218 .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;

219 *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;

220 esac

221 } # func_stripname may be replaced by extended shell implementation

222

223

224 # These SED scripts presuppose an absolute path with a trailing slash.

225 pathcar='s,^/$[^/]*$.*$,\1,'

226 pathcdr='s,^/[^/]*,,'

227 removedotparts=':dotsl

228 s@/\./@/@g

229 t dotsl

230 s,/\.$,/,'

231 collapseslashes='s@/\{1,\}@/@g'

232 finalslash='s,/*$,/,'

233

234 # func_normal_abspath PATH

235 # Remove doubled-up and trailing slashes, "." path components,

236 # and cancel out any ".." path components in PATH after making

237 # it an absolute path.

238 # value returned in "$func_normal_abspath_result"

239 func_normal_abspath ()

240 {

241 # Start from root dir and reassemble the path.

242 func_normal_abspath_result=

243 func_normal_abspath_tpath=$1

244 func_normal_abspath_altnamespace=

245 case $func_normal_abspath_tpath in

246 "")

247 # Empty path, that just means $cwd.

248 func_stripname '' '/' "`pwd`"

249 func_normal_abspath_result=$func_stripname_result

250 return

251 ;;

252 # The next three entries are used to spot a run of precisely

253 # two leading slashes without using negated character classes;

254 # we take advantage of case's first-match behaviour.

255 ///*)

256 # Unusual form of absolute path, do nothing.

257 ;;

258 //*)

259 # Not necessarily an ordinary path; POSIX reserves leading '//'

260 # and for example Cygwin uses it to access remote file shares

261 # over CIFS/SMB, so we conserve a leading double slash if found.

262 func_normal_abspath_altnamespace=/

263 ;;

264 /*)

265 # Absolute path, do nothing.

266 ;;

267 *)

268 # Relative path, prepend $cwd.

269 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

270 ;;

271 esac

272 # Cancel out all the simple stuff to save iterations. We also want

273 # the path to end with a slash for ease of parsing, so make sure

274 # there is one (and only one) here.

275 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

276 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`

277 while :; do

278 # Processed it all yet?

279 if test "$func_normal_abspath_tpath" = / ; then

280 # If we ascended to the root using ".." the result may be empty now.

281 if test -z "$func_normal_abspath_result" ; then

282 func_normal_abspath_result=/

283 fi

284 break

285 fi

286 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \

287 -e "$pathcar"`

288 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

289 -e "$pathcdr"`

290 # Figure out what to do with it

291 case $func_normal_abspath_tcomponent in

292 "")

293 # Trailing empty path component, ignore it.

294 ;;

295 ..)

296 # Parent dir; strip last assembled component from result.

297 func_dirname "$func_normal_abspath_result"

298 func_normal_abspath_result=$func_dirname_result

299 ;;

300 *)

301 # Actual path component, append it.

302 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

303 ;;

304 esac

305 done

306 # Restore leading double-slash if one was found on entry.

307 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

308 }

309

310 # func_relative_path SRCDIR DSTDIR

311 # generates a relative path from SRCDIR to DSTDIR, with a trailing

312 # slash if non-empty, suitable for immediately appending a filename

313 # without needing to append a separator.

314 # value returned in "$func_relative_path_result"

315 func_relative_path ()

316 {

317 func_relative_path_result=

318 func_normal_abspath "$1"

319 func_relative_path_tlibdir=$func_normal_abspath_result

320 func_normal_abspath "$2"

321 func_relative_path_tbindir=$func_normal_abspath_result

322

323 # Ascend the tree starting from libdir

324 while :; do

325 # check if we have found a prefix of bindir

326 case $func_relative_path_tbindir in

327 $func_relative_path_tlibdir)

328 # found an exact match

329 func_relative_path_tcancelled=

330 break

331 ;;

332 $func_relative_path_tlibdir*)

333 # found a matching prefix

334 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

335 func_relative_path_tcancelled=$func_stripname_result

336 if test -z "$func_relative_path_result"; then

337 func_relative_path_result=.

338 fi

339 break

340 ;;

341 *)

342 func_dirname $func_relative_path_tlibdir

343 func_relative_path_tlibdir=${func_dirname_result}

344 if test "x$func_relative_path_tlibdir" = x ; then

345 # Have to descend all the way to the root!

346 func_relative_path_result=../$func_relative_path_result

347 func_relative_path_tcancelled=$func_relative_path_tbindir

348 break

349 fi

350 func_relative_path_result=../$func_relative_path_result

351 ;;

352 esac

353 done

354

355 # Now calculate path; take care to avoid doubling-up slashes.

356 func_stripname '' '/' "$func_relative_path_result"

357 func_relative_path_result=$func_stripname_result

358 func_stripname '/' '/' "$func_relative_path_tcancelled"

359 if test "x$func_stripname_result" != x ; then

360 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

361 fi

362

363 # Normalisation. If bindir is libdir, return empty string,

364 # else relative path ending with a slash; either way, target

365 # file name can be directly appended.

366 if test ! -z "$func_relative_path_result"; then

367 func_stripname './' '' "$func_relative_path_result/"

368 func_relative_path_result=$func_stripname_result

369 fi

370 }

371

372 # The name of this program:

373 func_dirname_and_basename "$progpath"

374 progname=$func_basename_result

375

376 # Make sure we have an absolute path for reexecution:

377 case $progpath in

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

379 *[\\/]*)

380 progdir=$func_dirname_result

381 progdir=`cd "$progdir" && pwd`

382 progpath="$progdir/$progname"

383 ;;

384 *)

385 save_IFS="$IFS"

386 IFS=${PATH_SEPARATOR-:}

387 for progdir in $PATH; do

388 IFS="$save_IFS"

389 test -x "$progdir/$progname" && break

390 done

391 IFS="$save_IFS"

392 test -n "$progdir" || progdir=`pwd`

393 progpath="$progdir/$progname"

394 ;;

395 esac

396

397 # Sed substitution that helps us do robust quoting. It backslashifies

398 # metacharacters that are still active within double-quoted strings.

399 Xsed="${SED}"' -e 1s/^X//'

400 sed_quote_subst='s/$[`"$\\]$/\\\1/g'

401

402 # Same as above, but do not quote variable references.

403 double_quote_subst='s/$["`\\]$/\\\1/g'

404

405 # Sed substitution that turns a string into a regex matching for the

406 # string literally.

407 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'

408

409 # Sed substitution that converts a w32 file name or path

410 # which contains forward slashes, into one that contains

411 # (escaped) backslashes. A very naive implementation.

412 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'

413

414 # Re-`\' parameter expansions in output of double_quote_subst that were

415 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'

416 # in input to double_quote_subst, that '$' was protected from expansion.

417 # Since each input `\' is now two `\'s, look for any number of runs of

418 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.

419 bs='\\'

420 bs2='\\\\'

421 bs4='\\\\\\\\'

422 dollar='\$'

423 sed_double_backslash="\

424 s/$bs4/&\\

425 /g

426 s/^$bs2$dollar/$bs&/

427 s/\$[^$bs]\$$bs2$dollar/\\1$bs2$bs$dollar/g

428 s/\n//g"

429

430 # Standard options:

431 opt_dry_run=false

432 opt_help=false

433 opt_quiet=false

434 opt_verbose=false

435 opt_warning=:

436

437 # func_echo arg...

438 # Echo program name prefixed message, along with the current mode

439 # name if it has been set yet.

440 func_echo ()

441 {

442 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"

443 }

444

445 # func_verbose arg...

446 # Echo program name prefixed message in verbose mode only.

447 func_verbose ()

448 {

449 $opt_verbose && func_echo ${1+"$@"}

450

451 # A bug in bash halts the script if the last line of a function

452 # fails when set -e is in force, so we need another command to

453 # work around that:

454 :

455 }

456

457 # func_echo_all arg...

458 # Invoke $ECHO with all args, space-separated.

459 func_echo_all ()

460 {

461 $ECHO "$*"

462 }

463

464 # func_error arg...

465 # Echo program name prefixed message to standard error.

466 func_error ()

467 {

468 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2

469 }

470

471 # func_warning arg...

472 # Echo program name prefixed warning message to standard error.

473 func_warning ()

474 {

475 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2

476

477 # bash bug again:

478 :

479 }

480

481 # func_fatal_error arg...

482 # Echo program name prefixed message to standard error, and exit.

483 func_fatal_error ()

484 {

485 func_error ${1+"$@"}

486 exit $EXIT_FAILURE

487 }

488

489 # func_fatal_help arg...

490 # Echo program name prefixed message to standard error, followed by

491 # a help hint, and exit.

492 func_fatal_help ()

493 {

494 func_error ${1+"$@"}

495 func_fatal_error "$help"

496 }

497 help="Try \`$progname --help' for more information." ## default

498

499

500 # func_grep expression filename

501 # Check whether EXPRESSION matches any line of FILENAME, without output.

502 func_grep ()

503 {

504 $GREP "$1" "$2" >/dev/null 2>&1

505 }

506

507

508 # func_mkdir_p directory-path

509 # Make sure the entire path to DIRECTORY-PATH is available.

510 func_mkdir_p ()

511 {

512 my_directory_path="$1"

513 my_dir_list=

514

515 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then

516

517 # Protect directory names starting with `-'

518 case $my_directory_path in

519 -*) my_directory_path="./$my_directory_path" ;;

520 esac

521

522 # While some portion of DIR does not yet exist...

523 while test ! -d "$my_directory_path"; do

524 # ...make a list in topmost first order. Use a colon delimited

525 # list incase some portion of path contains whitespace.

526 my_dir_list="$my_directory_path:$my_dir_list"

527

528 # If the last portion added has no slash in it, the list is done

529 case $my_directory_path in */*) ;; *) break ;; esac

530

531 # ...otherwise throw away the child directory and loop

532 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`

533 done

534 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`

535

536 save_mkdir_p_IFS="$IFS"; IFS=':'

537 for my_dir in $my_dir_list; do

538 IFS="$save_mkdir_p_IFS"

539 # mkdir can fail with a `File exist' error if two processes

540 # try to create one of the directories concurrently. Don't

541 # stop in that case!

542 $MKDIR "$my_dir" 2>/dev/null || :

543 done

544 IFS="$save_mkdir_p_IFS"

545

546 # Bail out if we (or some other process) failed to create a directory.

547 test -d "$my_directory_path" || \

548 func_fatal_error "Failed to create \`$1'"

549 fi

550 }

551

552

553 # func_mktempdir [string]

554 # Make a temporary directory that won't clash with other running

555 # libtool processes, and avoids race conditions if possible. If

556 # given, STRING is the basename for that directory.

557 func_mktempdir ()

558 {

559 my_template="${TMPDIR-/tmp}/${1-$progname}"

560

561 if test "$opt_dry_run" = ":"; then

562 # Return a directory name, but don't create it in dry-run mode

563 my_tmpdir="${my_template}-$$"

564 else

565

566 # If mktemp works, use that first and foremost

567 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

568

569 if test ! -d "$my_tmpdir"; then

570 # Failing that, at least try and use $RANDOM to avoid a race

571 my_tmpdir="${my_template}-${RANDOM-0}$$"

572

573 save_mktempdir_umask=`umask`

574 umask 0077

575 $MKDIR "$my_tmpdir"

576 umask $save_mktempdir_umask

577 fi

578

579 # If we're not in dry-run mode, bomb out on failure

580 test -d "$my_tmpdir" || \

581 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"

582 fi

583

584 $ECHO "$my_tmpdir"

585 }

586

587

588 # func_quote_for_eval arg

589 # Aesthetically quote ARG to be evaled later.

590 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

591 # is double-quoted, suitable for a subsequent eval, whereas

592 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

593 # which are still active within double quotes backslashified.

594 func_quote_for_eval ()

595 {

596 case $1 in

597 *[\\\`\"\$]*)

598 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;

599 *)

600 func_quote_for_eval_unquoted_result="$1" ;;

601 esac

602

603 case $func_quote_for_eval_unquoted_result in

604 # Double-quote args containing shell metacharacters to delay

605 # word splitting, command substitution and and variable

606 # expansion for a subsequent eval.

607 # Many Bourne shells cannot handle close brackets correctly

608 # in scan sets, so we specify it separately.

609 *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

610 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

611 ;;

612 *)

613 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

614 esac

615 }

616

617

618 # func_quote_for_expand arg

619 # Aesthetically quote ARG to be evaled later; same as above,

620 # but do not quote variable references.

621 func_quote_for_expand ()

622 {

623 case $1 in

624 *[\\\`\"]*)

625 my_arg=`$ECHO "$1" | $SED \

626 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;

627 *)

628 my_arg="$1" ;;

629 esac

630

631 case $my_arg in

632 # Double-quote args containing shell metacharacters to delay

633 # word splitting and command substitution for a subsequent eval.

634 # Many Bourne shells cannot handle close brackets correctly

635 # in scan sets, so we specify it separately.

636 *[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

637 my_arg="\"$my_arg\""

638 ;;

639 esac

640

641 func_quote_for_expand_result="$my_arg"

642 }

643

644

645 # func_show_eval cmd [fail_exp]

646 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is

647 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP

648 # is given, then evaluate it.

649 func_show_eval ()

650 {

651 my_cmd="$1"

652 my_fail_exp="${2-:}"

653

654 ${opt_silent-false} || {

655 func_quote_for_expand "$my_cmd"

656 eval "func_echo $func_quote_for_expand_result"

657 }

658

659 if ${opt_dry_run-false}; then :; else

660 eval "$my_cmd"

661 my_status=$?

662 if test "$my_status" -eq 0; then :; else

663 eval "(exit $my_status); $my_fail_exp"

664 fi

665 fi

666 }

667

668

669 # func_show_eval_locale cmd [fail_exp]

670 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is

671 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP

672 # is given, then evaluate it. Use the saved locale for evaluation.

673 func_show_eval_locale ()

674 {

675 my_cmd="$1"

676 my_fail_exp="${2-:}"

677

678 ${opt_silent-false} || {

679 func_quote_for_expand "$my_cmd"

680 eval "func_echo $func_quote_for_expand_result"

681 }

682

683 if ${opt_dry_run-false}; then :; else

684 eval "$lt_user_locale

685 $my_cmd"

686 my_status=$?

687 eval "$lt_safe_locale"

688 if test "$my_status" -eq 0; then :; else

689 eval "(exit $my_status); $my_fail_exp"

690 fi

691 fi

692 }

693

694 # func_tr_sh

695 # Turn $1 into a string suitable for a shell variable name.

696 # Result is stored in $func_tr_sh_result. All characters

697 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,

698 # if $1 begins with a digit, a '_' is prepended as well.

699 func_tr_sh ()

700 {

701 case $1 in

702 [0-9]* | *[!a-zA-Z0-9_]*)

703 func_tr_sh_result=`$ECHO "$1" | $SED 's/^$[0-9]$/_\1/; s/[^a-zA-Z0-9_]/_/g'`

704 ;;

705 * )

706 func_tr_sh_result=$1

707 ;;

708 esac

709 }

710

711

712 # func_version

713 # Echo version message to standard output and exit.

714 func_version ()

715 {

716 $opt_debug

717

718 $SED -n '/(C)/!b go

719 :more

720 /\./!{

721 N

722 s/\n# / /

723 b more

724 }

725 :go

726 /^# '$PROGRAM' (GNU /,/# warranty; / {

727 s/^# //

728 s/^# *$//

729 s/$(C)$[ 0-9,-]*$ [1-9][0-9]*$/\1\2/

730 p

731 }' < "$progpath"

732 exit $?

733 }

734

735 # func_usage

736 # Echo short help message to standard output and exit.

737 func_usage ()

738 {

739 $opt_debug

740

741 $SED -n '/^# Usage:/,/^# *.*--help/ {

742 s/^# //

743 s/^# *$//

744 s/\$progname/'$progname'/

745 p

746 }' < "$progpath"

747 echo

748 $ECHO "run \`$progname --help | more' for full usage"

749 exit $?

750 }

751

752 # func_help [NOEXIT]

753 # Echo long help message to standard output and exit,

754 # unless 'noexit' is passed as argument.

755 func_help ()

756 {

757 $opt_debug

758

759 $SED -n '/^# Usage:/,/# Report bugs to/ {

760 :print

761 s/^# //

762 s/^# *$//

763 s*\$progname*'$progname'*

764 s*\$host*'"$host"'*

765 s*\$SHELL*'"$SHELL"'*

766 s*\$LTCC*'"$LTCC"'*

767 s*\$LTCFLAGS*'"$LTCFLAGS"'*

768 s*\$LD*'"$LD"'*

769 s/\$with_gnu_ld/'"$with_gnu_ld"'/

770 s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/

771 s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/

772 p

773 d

774 }

775 /^# .* home page:/b print

776 /^# General help using/b print

777 ' < "$progpath"

778 ret=$?

779 if test -z "$1"; then

780 exit $ret

781 fi

782 }

783

784 # func_missing_arg argname

785 # Echo program name prefixed message to standard error and set global

786 # exit_cmd.

787 func_missing_arg ()

788 {

789 $opt_debug

790

791 func_error "missing argument for $1."

792 exit_cmd=exit

793 }

794

795

796 # func_split_short_opt shortopt

797 # Set func_split_short_opt_name and func_split_short_opt_arg shell

798 # variables after splitting SHORTOPT after the 2nd character.

799 func_split_short_opt ()

800 {

801 my_sed_short_opt='1s/^$..$.*$/\1/;q'

802 my_sed_short_rest='1s/^..$.*$$/\1/;q'

803

804 func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`

805 func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`

806 } # func_split_short_opt may be replaced by extended shell implementation

807

808

809 # func_split_long_opt longopt

810 # Set func_split_long_opt_name and func_split_long_opt_arg shell

811 # variables after splitting LONGOPT at the `=' sign.

812 func_split_long_opt ()

813 {

814 my_sed_long_opt='1s/^$--[^=]*$=.*/\1/;q'

815 my_sed_long_arg='1s/^--[^=]*=//'

816

817 func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`

818 func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`

819 } # func_split_long_opt may be replaced by extended shell implementation

821 exit_cmd=:

827 magic="%%%MAGIC variable%%%"

828 magic_exe="%%%MAGIC EXE variable%%%"

829

830 # Global variables.

831 nonopt=

832 preserve_args=

833 lo2o="s/\\.lo\$/.${objext}/"

834 o2lo="s/\\.${objext}\$/.lo/"

835 extracted_archives=

836 extracted_serial=0

837

838 # If this variable is set in any of the actions, the command in it

839 # will be execed at the end. This prevents here-documents from being

840 # left over by shells.

841 exec_cmd=

842

843 # func_append var value

844 # Append VALUE to the end of shell variable VAR.

845 func_append ()

846 {

847 eval "${1}=\$${1}\${2}"

848 } # func_append may be replaced by extended shell implementation

849

850 # func_append_quoted var value

851 # Quote VALUE and append to the end of shell variable VAR, separated

852 # by a space.

853 func_append_quoted ()

854 {

855 func_quote_for_eval "${2}"

856 eval "${1}=\$${1}\\ \$func_quote_for_eval_result"

857 } # func_append_quoted may be replaced by extended shell implementation

858

859

860 # func_arith arithmetic-term...

861 func_arith ()

862 {

863 func_arith_result=`expr "${@}"`

864 } # func_arith may be replaced by extended shell implementation

865

866

867 # func_len string

868 # STRING may not start with a hyphen.

869 func_len ()

870 {

871 func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`

872 } # func_len may be replaced by extended shell implementation

873

874

875 # func_lo2o object

876 func_lo2o ()

877 {

878 func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`

879 } # func_lo2o may be replaced by extended shell implementation

880

881

882 # func_xform libobj-or-source

883 func_xform ()

884 {

885 func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`

886 } # func_xform may be replaced by extended shell implementation

887

888

889 # func_fatal_configuration arg...

890 # Echo program name prefixed message to standard error, followed by

891 # a configuration failure hint, and exit.

892 func_fatal_configuration ()

893 {

894 func_error ${1+"$@"}

895 func_error "See the $PACKAGE documentation for more information."

896 func_fatal_error "Fatal configuration error."

897 }

898

899

900 # func_config

901 # Display the configuration for all the tags in this script.

902 func_config ()

903 {

904 re_begincf='^# ### BEGIN LIBTOOL'

905 re_endcf='^# ### END LIBTOOL'

906

907 # Default configuration.

908 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"

909

910 # Now print the configurations for the tags.

911 for tagname in $taglist; do

912 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"

913 done

914

915 exit $?

916 }

917

918 # func_features

919 # Display the features supported by this script.

920 func_features ()

921 {

922 echo "host: $host"

923 if test "$build_libtool_libs" = yes; then

924 echo "enable shared libraries"

925 else

926 echo "disable shared libraries"

927 fi

928 if test "$build_old_libs" = yes; then

929 echo "enable static libraries"

930 else

931 echo "disable static libraries"

932 fi

933

934 exit $?

935 }

936

937 # func_enable_tag tagname

938 # Verify that TAGNAME is valid, and either flag an error and exit, or

939 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist

940 # variable here.

941 func_enable_tag ()

942 {

943 # Global variable:

944 tagname="$1"

945

946 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"

947 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"

948 sed_extractcf="/$re_begincf/,/$re_endcf/p"

949

950 # Validate tagname.

951 case $tagname in

952 *[!-_A-Za-z0-9,/]*)

953 func_fatal_error "invalid tag name: $tagname"

954 ;;

955 esac

956

957 # Don't test for the "default" C tag, as we know it's

958 # there but not specially marked.

959 case $tagname in

960 CC) ;;

961 *)

962 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then

963 taglist="$taglist $tagname"

964

965 # Evaluate the configuration. Be careful to quote the path

966 # and the sed script, to avoid splitting on whitespace, but

967 # also don't use non-portable quotes within backquotes within

968 # quotes we have to do it in 2 steps:

969 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`

970 eval "$extractedcf"

971 else

972 func_error "ignoring unknown tag $tagname"

973 fi

974 ;;

975 esac

976 }

977

978 # func_check_version_match

979 # Ensure that we are using m4 macros, and libtool script from the same

980 # release of libtool.

981 func_check_version_match ()

982 {

983 if test "$package_revision" != "$macro_revision"; then

984 if test "$VERSION" != "$macro_version"; then

985 if test -z "$macro_version"; then

986 cat >&2 <<_LT_EOF

987 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the

988 $progname: definition of this LT_INIT comes from an older release.

989 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

990 $progname: and run autoconf again.

991 _LT_EOF

992 else

993 cat >&2 <<_LT_EOF

994 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the

995 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.

996 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

997 $progname: and run autoconf again.

998 _LT_EOF

999 fi

1000 else

1001 cat >&2 <<_LT_EOF

1002 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,

1003 $progname: but the definition of this LT_INIT comes from revision $macro_revision.

1004 $progname: You should recreate aclocal.m4 with macros from revision $package_revision

1005 $progname: of $PACKAGE $VERSION and run autoconf again.

1006 _LT_EOF

1007 fi

1008

1009 exit $EXIT_MISMATCH

1010 fi

1011 }

1012

1013

1014 # Shorthand for --mode=foo, only valid as the first argument

1015 case $1 in

1016 clean|clea|cle|cl)

1017 shift; set dummy --mode clean ${1+"$@"}; shift

1018 ;;

1019 compile|compil|compi|comp|com|co|c)

1020 shift; set dummy --mode compile ${1+"$@"}; shift

1021 ;;

1022 execute|execut|execu|exec|exe|ex|e)

1023 shift; set dummy --mode execute ${1+"$@"}; shift

1024 ;;

1025 finish|finis|fini|fin|fi|f)

1026 shift; set dummy --mode finish ${1+"$@"}; shift

1027 ;;

1028 install|instal|insta|inst|ins|in|i)

1029 shift; set dummy --mode install ${1+"$@"}; shift

1030 ;;

1031 link|lin|li|l)

1032 shift; set dummy --mode link ${1+"$@"}; shift

1033 ;;

1035 shift; set dummy --mode uninstall ${1+"$@"}; shift

1036 ;;

1037 esac

1038

1039

1040

1041 # Option defaults:

1042 opt_debug=:

1043 opt_dry_run=false

1044 opt_config=false

1045 opt_preserve_dup_deps=false

1046 opt_features=false

1047 opt_finish=false

1048 opt_help=false

1049 opt_help_all=false

1050 opt_silent=:

1051 opt_warning=:

1052 opt_verbose=:

1053 opt_silent=false

1054 opt_verbose=false

1055

1056

1057 # Parse options once, thoroughly. This comes as soon as possible in the

1058 # script to make things like `--version' happen as quickly as we can.

1059 {

1060 # this just eases exit handling

1061 while test $# -gt 0; do

1062 opt="$1"

1063 shift

1064 case $opt in

1065 --debug|-x) opt_debug='set -x'

1066 func_echo "enabling shell trace mode"

1067 $opt_debug

1068 ;;

1069 --dry-run|--dryrun|-n)

1070 opt_dry_run=:

1071 ;;

1072 --config)

1073 opt_config=:

1074 func_config

1075 ;;

1076 --dlopen|-dlopen)

1077 optarg="$1"

1078 opt_dlopen="${opt_dlopen+$opt_dlopen

1079 }$optarg"

1080 shift

1081 ;;

1082 --preserve-dup-deps)

1083 opt_preserve_dup_deps=:

1084 ;;

1085 --features)

1086 opt_features=:

1087 func_features

1088 ;;

1089 --finish)

1090 opt_finish=:

1091 set dummy --mode finish ${1+"$@"}; shift

1092 ;;

1093 --help)

1094 opt_help=:

1095 ;;

1096 --help-all)

1097 opt_help_all=:

1098 opt_help=': help-all'

1099 ;;

1100 --mode)

1101 test $# = 0 && func_missing_arg $opt && break

1102 optarg="$1"

1103 opt_mode="$optarg"

1104 case $optarg in

1105 # Valid mode arguments:

1107

1108 # Catch anything else as an error

1109 *) func_error "invalid argument for $opt"

1110 exit_cmd=exit

1111 break

1112 ;;

1113 esac

1114 shift

1115 ;;

1116 --no-silent|--no-quiet)

1117 opt_silent=false

1118 func_append preserve_args " $opt"

1119 ;;

1120 --no-warning|--no-warn)

1121 opt_warning=false

1122 func_append preserve_args " $opt"

1123 ;;

1124 --no-verbose)

1125 opt_verbose=false

1126 func_append preserve_args " $opt"

1127 ;;

1128 --silent|--quiet)

1129 opt_silent=:

1130 func_append preserve_args " $opt"

1131 opt_verbose=false

1132 ;;

1133 --verbose|-v)

1134 opt_verbose=:

1135 func_append preserve_args " $opt"

1136 opt_silent=false

1137 ;;

1138 --tag)

1139 test $# = 0 && func_missing_arg $opt && break

1140 optarg="$1"

1141 opt_tag="$optarg"

1142 func_append preserve_args " $opt $optarg"

1143 func_enable_tag "$optarg"

1144 shift

1145 ;;

1146

1147 -\?|-h) func_usage ;;

1148 --help) func_help ;;

1149 --version) func_version ;;

1150

1151 # Separate optargs to long options:

1152 --*=*)

1153 func_split_long_opt "$opt"

1154 set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}

1155 shift

1156 ;;

1157

1158 # Separate non-argument short options:

1159 -\?*|-h*|-n*|-v*)

1160 func_split_short_opt "$opt"

1161 set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}

1162 shift

1163 ;;

1164

1165 --) break ;;

1166 -*) func_fatal_help "unrecognized option \`$opt'" ;;

1167 *) set dummy "$opt" ${1+"$@"}; shift; break ;;

1168 esac

1169 done

1170

1171 # Validate options:

1172

1173 # save first non-option argument

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

1175 nonopt="$opt"

1176 shift

1177 fi

1178

1179 # preserve --debug

1180 test "$opt_debug" = : || func_append preserve_args " --debug"

1181

1182 case $host in

1183 *cygwin* | *mingw* | *pw32* | *cegcc*)

1184 # don't eliminate duplications in $postdeps and $predeps

1185 opt_duplicate_compiler_generated_deps=:

1186 ;;

1187 *)

1188 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

1189 ;;

1190 esac

1191

1192 $opt_help || {

1193 # Sanity checks first:

1194 func_check_version_match

1195

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

1197 func_fatal_configuration "not configured to build any kind of library"

1198 fi

1199

1200 # Darwin sucks

1201 eval std_shrext=\"$shrext_cmds\"

1202

1203 # Only execute mode is allowed to have -dlopen flags.

1204 if test -n "$opt_dlopen" && test "$opt_mode" != execute; then

1205 func_error "unrecognized option \`-dlopen'"

1206 $ECHO "$help" 1>&2

1207 exit $EXIT_FAILURE

1208 fi

1209

1210 # Change the help message to a mode-specific one.

1211 generic_help="$help"

1212 help="Try \`$progname --help --mode=$opt_mode' for more information."

1213 }

1214

1215

1216 # Bail if the options were screwed

1217 $exit_cmd $EXIT_FAILURE

1218 }

1223 ## ----------- ##

1224 ## Main. ##

1225 ## ----------- ##

1226

1227 # func_lalib_p file

1228 # True iff FILE is a libtool `.la' library or `.lo' object file.

1229 # This function is only a basic sanity check; it will hardly flush out

1230 # determined imposters.

1231 func_lalib_p ()

1232 {

1233 test -f "$1" &&

1234 $SED -e 4q "$1" 2>/dev/null \

1235 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1

1236 }

1237

1238 # func_lalib_unsafe_p file

1239 # True iff FILE is a libtool `.la' library or `.lo' object file.

1240 # This function implements the same check as func_lalib_p without

1241 # resorting to external programs. To this end, it redirects stdin and

1242 # closes it afterwards, without saving the original file descriptor.

1243 # As a safety measure, use it only where a negative result would be

1244 # fatal anyway. Works if `file' does not exist.

1245 func_lalib_unsafe_p ()

1246 {

1247 lalib_p=no

1248 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then

1249 for lalib_p_l in 1 2 3 4

1250 do

1251 read lalib_p_line

1252 case "$lalib_p_line" in

1253 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;

1254 esac

1255 done

1256 exec 0<&5 5<&-

1257 fi

1258 test "$lalib_p" = yes

1259 }

1260

1261 # func_ltwrapper_script_p file

1262 # True iff FILE is a libtool wrapper script

1263 # This function is only a basic sanity check; it will hardly flush out

1264 # determined imposters.

1265 func_ltwrapper_script_p ()

1266 {

1267 func_lalib_p "$1"

1268 }

1269

1270 # func_ltwrapper_executable_p file

1271 # True iff FILE is a libtool wrapper executable

1272 # This function is only a basic sanity check; it will hardly flush out

1273 # determined imposters.

1274 func_ltwrapper_executable_p ()

1275 {

1276 func_ltwrapper_exec_suffix=

1277 case $1 in

1278 *.exe) ;;

1279 *) func_ltwrapper_exec_suffix=.exe ;;

1280 esac

1281 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1

1282 }

1283

1284 # func_ltwrapper_scriptname file

1285 # Assumes file is an ltwrapper_executable

1286 # uses $file to determine the appropriate filename for a

1287 # temporary ltwrapper_script.

1288 func_ltwrapper_scriptname ()

1289 {

1290 func_dirname_and_basename "$1" "" "."

1291 func_stripname '' '.exe' "$func_basename_result"

1292 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"

1293 }

1294

1295 # func_ltwrapper_p file

1296 # True iff FILE is a libtool wrapper script or wrapper executable

1297 # This function is only a basic sanity check; it will hardly flush out

1298 # determined imposters.

1299 func_ltwrapper_p ()

1300 {

1301 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"

1302 }

1303

1304

1305 # func_execute_cmds commands fail_cmd

1306 # Execute tilde-delimited COMMANDS.

1307 # If FAIL_CMD is given, eval that upon failure.

1308 # FAIL_CMD may read-access the current command in variable CMD!

1309 func_execute_cmds ()

1310 {

1311 $opt_debug

1312 save_ifs=$IFS; IFS='~'

1313 for cmd in $1; do

1314 IFS=$save_ifs

1315 eval cmd=\"$cmd\"

1316 func_show_eval "$cmd" "${2-:}"

1317 done

1318 IFS=$save_ifs

1319 }

1320

1321

1322 # func_source file

1323 # Source FILE, adding directory component if necessary.

1324 # Note that it is not necessary on cygwin/mingw to append a dot to

1325 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe

1326 # behavior happens only for exec(3), not for open(2)! Also, sourcing

1327 # `FILE.' does not work on cygwin managed mounts.

1328 func_source ()

1329 {

1330 $opt_debug

1331 case $1 in

1332 */* | *\\*) . "$1" ;;

1333 *) . "./$1" ;;

1334 esac

1335 }

1336

1337

1338 # func_resolve_sysroot PATH

1339 # Replace a leading = in PATH with a sysroot. Store the result into

1340 # func_resolve_sysroot_result

1341 func_resolve_sysroot ()

1342 {

1343 func_resolve_sysroot_result=$1

1344 case $func_resolve_sysroot_result in

1345 =*)

1346 func_stripname '=' '' "$func_resolve_sysroot_result"

1347 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result

1348 ;;

1349 esac

1350 }

1351

1352 # func_replace_sysroot PATH

1353 # If PATH begins with the sysroot, replace it with = and

1354 # store the result into func_replace_sysroot_result.

1355 func_replace_sysroot ()

1356 {

1357 case "$lt_sysroot:$1" in

1358 ?*:"$lt_sysroot"*)

1359 func_stripname "$lt_sysroot" '' "$1"

1360 func_replace_sysroot_result="=$func_stripname_result"

1361 ;;

1362 *)

1363 # Including no sysroot.

1364 func_replace_sysroot_result=$1

1365 ;;

1366 esac

1367 }

1368

1369 # func_infer_tag arg

1370 # Infer tagged configuration to use if any are available and

1371 # if one wasn't chosen via the "--tag" command line option.

1372 # Only attempt this if the compiler in the base compile

1373 # command doesn't match the default compiler.

1374 # arg is usually of the form 'gcc ...'

1375 func_infer_tag ()

1376 {

1377 $opt_debug

1378 if test -n "$available_tags" && test -z "$tagname"; then

1379 CC_quoted=

1380 for arg in $CC; do

1381 func_append_quoted CC_quoted "$arg"

1382 done

1383 CC_expanded=`func_echo_all $CC`

1384 CC_quoted_expanded=`func_echo_all $CC_quoted`

1385 case $@ in

1386 # Blanks in the command may have been stripped by the calling shell,

1387 # but not from the CC environment variable when configure was run.

1388 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \

1389 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;

1390 # Blanks at the start of $base_compile will cause this to fail

1391 # if we don't check for them as well.

1392 *)

1393 for z in $available_tags; do

1394 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then

1395 # Evaluate the configuration.

1396 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"

1397 CC_quoted=

1398 for arg in $CC; do

1399 # Double-quote args containing other shell metacharacters.

1400 func_append_quoted CC_quoted "$arg"

1401 done

1402 CC_expanded=`func_echo_all $CC`

1403 CC_quoted_expanded=`func_echo_all $CC_quoted`

1404 case "$@ " in

1405 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \

1406 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)

1407 # The compiler in the base compile command matches

1408 # the one in the tagged configuration.

1409 # Assume this is the tagged configuration we want.

1410 tagname=$z

1411 break

1412 ;;

1413 esac

1414 fi

1415 done

1416 # If $tagname still isn't set, then no tagged configuration

1417 # was found and let the user know that the "--tag" command

1418 # line option must be used.

1419 if test -z "$tagname"; then

1420 func_echo "unable to infer tagged configuration"

1421 func_fatal_error "specify a tag with \`--tag'"

1422 # else

1423 # func_verbose "using $tagname tagged configuration"

1424 fi

1425 ;;

1426 esac

1427 fi

1428 }

1429

1430

1431

1432 # func_write_libtool_object output_name pic_name nonpic_name

1433 # Create a libtool object file (analogous to a ".la" file),

1434 # but don't create it if we're doing a dry run.

1435 func_write_libtool_object ()

1436 {

1437 write_libobj=${1}

1438 if test "$build_libtool_libs" = yes; then

1439 write_lobj=\'${2}\'

1440 else

1441 write_lobj=none

1442 fi

1443

1444 if test "$build_old_libs" = yes; then

1445 write_oldobj=\'${3}\'

1446 else

1447 write_oldobj=none

1448 fi

1449

1450 $opt_dry_run || {

1451 cat >${write_libobj}T <<EOF

1452 # $write_libobj - a libtool object file

1453 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

1454 #

1455 # Please DO NOT delete this file!

1456 # It is necessary for linking the library.

1457

1458 # Name of the PIC object.

1459 pic_object=$write_lobj

1460

1461 # Name of the non-PIC object

1462 non_pic_object=$write_oldobj

1463

1464 EOF

1465 $MV "${write_libobj}T" "${write_libobj}"

1466 }

1467 }

1468

1469

1470 ##################################################

1471 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #

1472 ##################################################

1473

1474 # func_convert_core_file_wine_to_w32 ARG

1475 # Helper function used by file name conversion functions when $build is *nix,

1476 # and $host is mingw, cygwin, or some other w32 environment. Relies on a

1477 # correctly configured wine environment available, with the winepath program

1478 # in $build's $PATH.

1479 #

1480 # ARG is the $build file name to be converted to w32 format.

1481 # Result is available in $func_convert_core_file_wine_to_w32_result, and will

1482 # be empty on error (or when ARG is empty)

1483 func_convert_core_file_wine_to_w32 ()

1484 {

1485 $opt_debug

1486 func_convert_core_file_wine_to_w32_result="$1"

1487 if test -n "$1"; then

1488 # Unfortunately, winepath does not exit with a non-zero error code, so we

1489 # are forced to check the contents of stdout. On the other hand, if the

1490 # command is not found, the shell will set an exit code of 127 and print

1491 # *an error message* to stdout. So we must check for both error code of

1492 # zero AND non-empty stdout, which explains the odd construction:

1493 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`

1494 if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then

1495 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |

1496 $SED -e "$lt_sed_naive_backslashify"`

1497 else

1498 func_convert_core_file_wine_to_w32_result=

1499 fi

1500 fi

1501 }

1502 # end: func_convert_core_file_wine_to_w32

1503

1504

1505 # func_convert_core_path_wine_to_w32 ARG

1506 # Helper function used by path conversion functions when $build is *nix, and

1507 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly

1508 # configured wine environment available, with the winepath program in $build's

1509 # $PATH. Assumes ARG has no leading or trailing path separator characters.

1510 #

1511 # ARG is path to be converted from $build format to win32.

1512 # Result is available in $func_convert_core_path_wine_to_w32_result.

1513 # Unconvertible file (directory) names in ARG are skipped; if no directory names

1514 # are convertible, then the result may be empty.

1515 func_convert_core_path_wine_to_w32 ()

1516 {

1517 $opt_debug

1518 # unfortunately, winepath doesn't convert paths, only file names

1519 func_convert_core_path_wine_to_w32_result=""

1520 if test -n "$1"; then

1521 oldIFS=$IFS

1522 IFS=:

1523 for func_convert_core_path_wine_to_w32_f in $1; do

1524 IFS=$oldIFS

1525 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"

1526 if test -n "$func_convert_core_file_wine_to_w32_result" ; then

1527 if test -z "$func_convert_core_path_wine_to_w32_result"; then

1528 func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"

1529 else

1530 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"

1531 fi

1532 fi

1533 done

1534 IFS=$oldIFS

1535 fi

1536 }

1537 # end: func_convert_core_path_wine_to_w32

1538

1539

1540 # func_cygpath ARGS...

1541 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when

1542 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)

1543 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or

1544 # (2), returns the Cygwin file name or path in func_cygpath_result (input

1545 # file name or path is assumed to be in w32 format, as previously converted

1546 # from $build's *nix or MSYS format). In case (3), returns the w32 file name

1547 # or path in func_cygpath_result (input file name or path is assumed to be in

1548 # Cygwin format). Returns an empty string on error.

1549 #

1550 # ARGS are passed to cygpath, with the last one being the file name or path to

1551 # be converted.

1552 #

1553 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH

1554 # environment variable; do not put it in $PATH.

1555 func_cygpath ()

1556 {

1557 $opt_debug

1558 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then

1559 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`

1560 if test "$?" -ne 0; then

1561 # on failure, ensure result is empty

1562 func_cygpath_result=

1563 fi

1564 else

1565 func_cygpath_result=

1566 func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"

1567 fi

1568 }

1569 #end: func_cygpath

1570

1571

1572 # func_convert_core_msys_to_w32 ARG

1573 # Convert file name or path ARG from MSYS format to w32 format. Return

1574 # result in func_convert_core_msys_to_w32_result.

1575 func_convert_core_msys_to_w32 ()

1576 {

1577 $opt_debug

1578 # awkward: cmd appends spaces to result

1579 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |

1580 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`

1581 }

1582 #end: func_convert_core_msys_to_w32

1583

1584

1585 # func_convert_file_check ARG1 ARG2

1586 # Verify that ARG1 (a file name in $build format) was converted to $host

1587 # format in ARG2. Otherwise, emit an error message, but continue (resetting

1588 # func_to_host_file_result to ARG1).

1589 func_convert_file_check ()

1590 {

1591 $opt_debug

1592 if test -z "$2" && test -n "$1" ; then

1593 func_error "Could not determine host file name corresponding to"

1594 func_error " \`$1'"

1595 func_error "Continuing, but uninstalled executables may not work."

1596 # Fallback:

1597 func_to_host_file_result="$1"

1598 fi

1599 }

1600 # end func_convert_file_check

1601

1602

1603 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH

1604 # Verify that FROM_PATH (a path in $build format) was converted to $host

1605 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting

1606 # func_to_host_file_result to a simplistic fallback value (see below).

1607 func_convert_path_check ()

1608 {

1609 $opt_debug

1610 if test -z "$4" && test -n "$3"; then

1611 func_error "Could not determine the host path corresponding to"

1612 func_error " \`$3'"

1613 func_error "Continuing, but uninstalled executables may not work."

1614 # Fallback. This is a deliberately simplistic "conversion" and

1615 # should not be "improved". See libtool.info.

1616 if test "x$1" != "x$2"; then

1617 lt_replace_pathsep_chars="s|$1|$2|g"

1618 func_to_host_path_result=`echo "$3" |

1619 $SED -e "$lt_replace_pathsep_chars"`

1620 else

1621 func_to_host_path_result="$3"

1622 fi

1623 fi

1624 }

1625 # end func_convert_path_check

1626

1627

1628 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG

1629 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT

1630 # and appending REPL if ORIG matches BACKPAT.

1631 func_convert_path_front_back_pathsep ()

1632 {

1633 $opt_debug

1634 case $4 in

1635 $1 ) func_to_host_path_result="$3$func_to_host_path_result"

1636 ;;

1637 esac

1638 case $4 in

1639 $2 ) func_append func_to_host_path_result "$3"

1640 ;;

1641 esac

1642 }

1643 # end func_convert_path_front_back_pathsep

1644

1645

1646 ##################################################

1647 # $build to $host FILE NAME CONVERSION FUNCTIONS #

1648 ##################################################

1649 # invoked via `$to_host_file_cmd ARG'

1650 #

1651 # In each case, ARG is the path to be converted from $build to $host format.

1652 # Result will be available in $func_to_host_file_result.

1653

1654

1655 # func_to_host_file ARG

1656 # Converts the file name ARG from $build format to $host format. Return result

1657 # in func_to_host_file_result.

1658 func_to_host_file ()

1659 {

1660 $opt_debug

1661 $to_host_file_cmd "$1"

1662 }

1663 # end func_to_host_file

1664

1665

1666 # func_to_tool_file ARG LAZY

1667 # converts the file name ARG from $build format to toolchain format. Return

1668 # result in func_to_tool_file_result. If the conversion in use is listed

1669 # in (the comma separated) LAZY, no conversion takes place.

1670 func_to_tool_file ()

1671 {

1672 $opt_debug

1673 case ,$2, in

1674 *,"$to_tool_file_cmd",*)

1675 func_to_tool_file_result=$1

1676 ;;

1677 *)

1678 $to_tool_file_cmd "$1"

1679 func_to_tool_file_result=$func_to_host_file_result

1680 ;;

1681 esac

1682 }

1683 # end func_to_tool_file

1684

1685

1686 # func_convert_file_noop ARG

1687 # Copy ARG to func_to_host_file_result.

1688 func_convert_file_noop ()

1689 {

1690 func_to_host_file_result="$1"

1691 }

1692 # end func_convert_file_noop

1693

1694

1695 # func_convert_file_msys_to_w32 ARG

1696 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic

1697 # conversion to w32 is not available inside the cwrapper. Returns result in

1698 # func_to_host_file_result.

1699 func_convert_file_msys_to_w32 ()

1700 {

1701 $opt_debug

1702 func_to_host_file_result="$1"

1703 if test -n "$1"; then

1704 func_convert_core_msys_to_w32 "$1"

1705 func_to_host_file_result="$func_convert_core_msys_to_w32_result"

1706 fi

1707 func_convert_file_check "$1" "$func_to_host_file_result"

1708 }

1709 # end func_convert_file_msys_to_w32

1710

1711

1712 # func_convert_file_cygwin_to_w32 ARG

1713 # Convert file name ARG from Cygwin to w32 format. Returns result in

1714 # func_to_host_file_result.

1715 func_convert_file_cygwin_to_w32 ()

1716 {

1717 $opt_debug

1718 func_to_host_file_result="$1"

1719 if test -n "$1"; then

1720 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use

1721 # LT_CYGPATH in this case.

1722 func_to_host_file_result=`cygpath -m "$1"`

1723 fi

1724 func_convert_file_check "$1" "$func_to_host_file_result"

1725 }

1726 # end func_convert_file_cygwin_to_w32

1727

1728

1729 # func_convert_file_nix_to_w32 ARG

1730 # Convert file name ARG from *nix to w32 format. Requires a wine environment

1731 # and a working winepath. Returns result in func_to_host_file_result.

1732 func_convert_file_nix_to_w32 ()

1733 {

1734 $opt_debug

1735 func_to_host_file_result="$1"

1736 if test -n "$1"; then

1737 func_convert_core_file_wine_to_w32 "$1"

1738 func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

1739 fi

1740 func_convert_file_check "$1" "$func_to_host_file_result"

1741 }

1742 # end func_convert_file_nix_to_w32

1743

1744

1745 # func_convert_file_msys_to_cygwin ARG

1746 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.

1747 # Returns result in func_to_host_file_result.

1748 func_convert_file_msys_to_cygwin ()

1749 {

1750 $opt_debug

1751 func_to_host_file_result="$1"

1752 if test -n "$1"; then

1753 func_convert_core_msys_to_w32 "$1"

1754 func_cygpath -u "$func_convert_core_msys_to_w32_result"

1755 func_to_host_file_result="$func_cygpath_result"

1756 fi

1757 func_convert_file_check "$1" "$func_to_host_file_result"

1758 }

1759 # end func_convert_file_msys_to_cygwin

1760

1761

1762 # func_convert_file_nix_to_cygwin ARG

1763 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed

1764 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result

1765 # in func_to_host_file_result.

1766 func_convert_file_nix_to_cygwin ()

1767 {

1768 $opt_debug

1769 func_to_host_file_result="$1"

1770 if test -n "$1"; then

1771 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.

1772 func_convert_core_file_wine_to_w32 "$1"

1773 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

1774 func_to_host_file_result="$func_cygpath_result"

1775 fi

1776 func_convert_file_check "$1" "$func_to_host_file_result"

1777 }

1778 # end func_convert_file_nix_to_cygwin

1779

1780

1781 #############################################

1782 # $build to $host PATH CONVERSION FUNCTIONS #

1783 #############################################

1784 # invoked via `$to_host_path_cmd ARG'

1785 #

1786 # In each case, ARG is the path to be converted from $build to $host format.

1787 # The result will be available in $func_to_host_path_result.

1788 #

1789 # Path separators are also converted from $build format to $host format. If

1790 # ARG begins or ends with a path separator character, it is preserved (but

1791 # converted to $host format) on output.

1792 #

1793 # All path conversion functions are named using the following convention:

1794 # file name conversion function : func_convert_file_X_to_Y ()

1795 # path conversion function : func_convert_path_X_to_Y ()

1796 # where, for any given $build/$host combination the 'X_to_Y' value is the

1797 # same. If conversion functions are added for new $build/$host combinations,

1798 # the two new functions must follow this pattern, or func_init_to_host_path_cmd

1799 # will break.

1800

1801

1802 # func_init_to_host_path_cmd

1803 # Ensures that function "pointer" variable $to_host_path_cmd is set to the

1804 # appropriate value, based on the value of $to_host_file_cmd.

1805 to_host_path_cmd=

1806 func_init_to_host_path_cmd ()

1807 {

1808 $opt_debug

1809 if test -z "$to_host_path_cmd"; then

1810 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

1811 to_host_path_cmd="func_convert_path_${func_stripname_result}"

1812 fi

1813 }

1814

1815

1816 # func_to_host_path ARG

1817 # Converts the path ARG from $build format to $host format. Return result

1818 # in func_to_host_path_result.

1819 func_to_host_path ()

1820 {

1821 $opt_debug

1822 func_init_to_host_path_cmd

1823 $to_host_path_cmd "$1"

1824 }

1825 # end func_to_host_path

1826

1827

1828 # func_convert_path_noop ARG

1829 # Copy ARG to func_to_host_path_result.

1830 func_convert_path_noop ()

1831 {

1832 func_to_host_path_result="$1"

1833 }

1834 # end func_convert_path_noop

1835

1836

1837 # func_convert_path_msys_to_w32 ARG

1838 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic

1839 # conversion to w32 is not available inside the cwrapper. Returns result in

1840 # func_to_host_path_result.

1841 func_convert_path_msys_to_w32 ()

1842 {

1843 $opt_debug

1844 func_to_host_path_result="$1"

1845 if test -n "$1"; then

1846 # Remove leading and trailing path separator characters from ARG. MSYS

1847 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';

1848 # and winepath ignores them completely.

1849 func_stripname : : "$1"

1850 func_to_host_path_tmp1=$func_stripname_result

1851 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1852 func_to_host_path_result="$func_convert_core_msys_to_w32_result"

1853 func_convert_path_check : ";" \

1854 "$func_to_host_path_tmp1" "$func_to_host_path_result"

1855 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"

1856 fi

1857 }

1858 # end func_convert_path_msys_to_w32

1859

1860

1861 # func_convert_path_cygwin_to_w32 ARG

1862 # Convert path ARG from Cygwin to w32 format. Returns result in

1863 # func_to_host_file_result.

1864 func_convert_path_cygwin_to_w32 ()

1865 {

1866 $opt_debug

1867 func_to_host_path_result="$1"

1868 if test -n "$1"; then

1869 # See func_convert_path_msys_to_w32:

1870 func_stripname : : "$1"

1871 func_to_host_path_tmp1=$func_stripname_result

1872 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`

1873 func_convert_path_check : ";" \

1874 "$func_to_host_path_tmp1" "$func_to_host_path_result"

1875 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"

1876 fi

1877 }

1878 # end func_convert_path_cygwin_to_w32

1879

1880

1881 # func_convert_path_nix_to_w32 ARG

1882 # Convert path ARG from *nix to w32 format. Requires a wine environment and

1883 # a working winepath. Returns result in func_to_host_file_result.

1884 func_convert_path_nix_to_w32 ()

1885 {

1886 $opt_debug

1887 func_to_host_path_result="$1"

1888 if test -n "$1"; then

1889 # See func_convert_path_msys_to_w32:

1890 func_stripname : : "$1"

1891 func_to_host_path_tmp1=$func_stripname_result

1892 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1893 func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

1894 func_convert_path_check : ";" \

1895 "$func_to_host_path_tmp1" "$func_to_host_path_result"

1896 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"

1897 fi

1898 }

1899 # end func_convert_path_nix_to_w32

1900

1901

1902 # func_convert_path_msys_to_cygwin ARG

1903 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.

1904 # Returns result in func_to_host_file_result.

1905 func_convert_path_msys_to_cygwin ()

1906 {

1907 $opt_debug

1908 func_to_host_path_result="$1"

1909 if test -n "$1"; then

1910 # See func_convert_path_msys_to_w32:

1911 func_stripname : : "$1"

1912 func_to_host_path_tmp1=$func_stripname_result

1913 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1914 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

1915 func_to_host_path_result="$func_cygpath_result"

1916 func_convert_path_check : : \

1917 "$func_to_host_path_tmp1" "$func_to_host_path_result"

1918 func_convert_path_front_back_pathsep ":*" "*:" : "$1"

1919 fi

1920 }

1921 # end func_convert_path_msys_to_cygwin

1922

1923

1924 # func_convert_path_nix_to_cygwin ARG

1925 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a

1926 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in

1927 # func_to_host_file_result.

1928 func_convert_path_nix_to_cygwin ()

1929 {

1930 $opt_debug

1931 func_to_host_path_result="$1"

1932 if test -n "$1"; then

1933 # Remove leading and trailing path separator characters from

1934 # ARG. msys behavior is inconsistent here, cygpath turns them

1935 # into '.;' and ';.', and winepath ignores them completely.

1936 func_stripname : : "$1"

1937 func_to_host_path_tmp1=$func_stripname_result

1938 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1939 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

1940 func_to_host_path_result="$func_cygpath_result"

1941 func_convert_path_check : : \

1942 "$func_to_host_path_tmp1" "$func_to_host_path_result"

1943 func_convert_path_front_back_pathsep ":*" "*:" : "$1"

1944 fi

1945 }

1946 # end func_convert_path_nix_to_cygwin

1947

1948

1949 # func_mode_compile arg...

1950 func_mode_compile ()

1951 {

1952 $opt_debug

1953 # Get the compilation command and the source file.

1954 base_compile=

1955 srcfile="$nonopt" # always keep a non-empty value in "srcfile"

1956 suppress_opt=yes

1957 suppress_output=

1958 arg_mode=normal

1959 libobj=

1960 later=

1961 pie_flag=

1962

1963 for arg

1964 do

1965 case $arg_mode in

1966 arg )

1967 # do not "continue". Instead, add this to base_compile

1968 lastarg="$arg"

1969 arg_mode=normal

1970 ;;

1971

1972 target )

1973 libobj="$arg"

1974 arg_mode=normal

1975 continue

1976 ;;

1977

1978 normal )

1979 # Accept any command-line options.

1980 case $arg in

1981 -o)

1982 test -n "$libobj" && \

1983 func_fatal_error "you cannot specify \`-o' more than once"

1984 arg_mode=target

1985 continue

1986 ;;

1987

1988 -pie | -fpie | -fPIE)

1989 func_append pie_flag " $arg"

1990 continue

1991 ;;

1992

1993 -shared | -static | -prefer-pic | -prefer-non-pic)

1994 func_append later " $arg"

1995 continue

1996 ;;

1997

1998 -no-suppress)

1999 suppress_opt=no

2000 continue

2001 ;;

2002

2003 -Xcompiler)

2004 arg_mode=arg # the next one goes into the "base_compile" arg list

2005 continue # The current "srcfile" will either be retained or

2006 ;; # replaced later. I would guess that would be a bug.

2007

2008 -Wc,*)

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

2010 args=$func_stripname_result

2011 lastarg=

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

2013 for arg in $args; do

2014 IFS="$save_ifs"

2015 func_append_quoted lastarg "$arg"

2016 done

2017 IFS="$save_ifs"

2018 func_stripname ' ' '' "$lastarg"

2019 lastarg=$func_stripname_result

2020

2021 # Add the arguments to base_compile.

2022 func_append base_compile " $lastarg"

2023 continue

2024 ;;

2025

2026 *)

2027 # Accept the current argument as the source file.

2028 # The previous "srcfile" becomes the current argument.

2029 #

2030 lastarg="$srcfile"

2031 srcfile="$arg"

2032 ;;

2033 esac # case $arg

2034 ;;

2035 esac # case $arg_mode

2036

2037 # Aesthetically quote the previous argument.

2038 func_append_quoted base_compile "$lastarg"

2039 done # for arg

2040

2041 case $arg_mode in

2042 arg)

2043 func_fatal_error "you must specify an argument for -Xcompile"

2044 ;;

2045 target)

2046 func_fatal_error "you must specify a target with \`-o'"

2047 ;;

2048 *)

2049 # Get the name of the library object.

2050 test -z "$libobj" && {

2051 func_basename "$srcfile"

2052 libobj="$func_basename_result"

2053 }

2054 ;;

2055 esac

2056

2057 # Recognize several different file suffixes.

2058 # If the user specifies -o file.o, it is replaced with file.lo

2059 case $libobj in

2060 *.[cCFSifmso] | \

2061 *.ada | *.adb | *.ads | *.asm | \

2062 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \

2063 *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)

2064 func_xform "$libobj"

2065 libobj=$func_xform_result

2066 ;;

2067 esac

2068

2069 case $libobj in

2070 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;

2071 *)

2072 func_fatal_error "cannot determine name of library object from \`$libobj'"

2073 ;;

2074 esac

2075

2076 func_infer_tag $base_compile

2077

2078 for arg in $later; do

2079 case $arg in

2080 -shared)

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

2082 func_fatal_configuration "can not build a shared library"

2083 build_old_libs=no

2084 continue

2085 ;;

2086

2087 -static)

2088 build_libtool_libs=no

2089 build_old_libs=yes

2090 continue

2091 ;;

2092

2093 -prefer-pic)

2094 pic_mode=yes

2095 continue

2096 ;;

2097

2098 -prefer-non-pic)

2099 pic_mode=no

2100 continue

2101 ;;

2102 esac

2103 done

2104

2105 func_quote_for_eval "$libobj"

2106 test "X$libobj" != "X$func_quote_for_eval_result" \

2107 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \

2108 && func_warning "libobj name \`$libobj' may not contain shell special characters."

2109 func_dirname_and_basename "$obj" "/" ""

2110 objname="$func_basename_result"

2111 xdir="$func_dirname_result"

2112 lobj=${xdir}$objdir/$objname

2113

2114 test -z "$base_compile" && \

2115 func_fatal_help "you must specify a compilation command"

2116

2117 # Delete any leftover library objects.

2118 if test "$build_old_libs" = yes; then

2119 removelist="$obj $lobj $libobj ${libobj}T"

2120 else

2121 removelist="$lobj $libobj ${libobj}T"

2122 fi

2123

2124 # On Cygwin there's no "real" PIC flag so we must build both object types

2125 case $host_os in

2126 cygwin* | mingw* | pw32* | os2* | cegcc*)

2127 pic_mode=default

2128 ;;

2129 esac

2130 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

2131 # non-PIC code in shared libraries is not supported

2132 pic_mode=default

2133 fi

2134

2135 # Calculate the filename of the output object if compiler does

2136 # not support -o with -c

2137 if test "$compiler_c_o" = no; then

2138 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}

2139 lockfile="$output_obj.lock"

2140 else

2141 output_obj=

2142 need_locks=no

2143 lockfile=

2144 fi

2145

2146 # Lock this critical section if it is needed

2147 # We use this script file to make the link, it avoids creating a new file

2148 if test "$need_locks" = yes; then

2149 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do

2150 func_echo "Waiting for $lockfile to be removed"

2151 sleep 2

2152 done

2153 elif test "$need_locks" = warn; then

2154 if test -f "$lockfile"; then

2155 $ECHO "\

2156 *** ERROR, $lockfile exists and contains:

2157 `cat $lockfile 2>/dev/null`

2158

2159 This indicates that another process is trying to use the same

2160 temporary object file, and libtool could not work around it because

2161 your compiler does not support \`-c' and \`-o' together. If you

2162 repeat this compilation, it may succeed, by chance, but you had better

2163 avoid parallel builds (make -j) in this platform, or get a better

2164 compiler."

2165

2166 $opt_dry_run || $RM $removelist

2167 exit $EXIT_FAILURE

2168 fi

2169 func_append removelist " $output_obj"

2170 $ECHO "$srcfile" > "$lockfile"

2171 fi

2172

2173 $opt_dry_run || $RM $removelist

2174 func_append removelist " $lockfile"

2175 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15

2176

2177 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2178 srcfile=$func_to_tool_file_result

2179 func_quote_for_eval "$srcfile"

2180 qsrcfile=$func_quote_for_eval_result

2181

2182 # Only build a PIC object if we are building libtool libraries.

2183 if test "$build_libtool_libs" = yes; then

2184 # Without this assignment, base_compile gets emptied.

2185 fbsd_hideous_sh_bug=$base_compile

2186

2187 if test "$pic_mode" != no; then

2188 command="$base_compile $qsrcfile $pic_flag"

2189 else

2190 # Don't build PIC code

2191 command="$base_compile $qsrcfile"

2192 fi

2193

2194 func_mkdir_p "$xdir$objdir"

2195

2196 if test -z "$output_obj"; then

2197 # Place PIC objects in $objdir

2198 func_append command " -o $lobj"

2199 fi

2200

2201 func_show_eval_locale "$command" \

2202 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'

2203

2204 if test "$need_locks" = warn &&

2205 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

2206 $ECHO "\

2207 *** ERROR, $lockfile contains:

2208 `cat $lockfile 2>/dev/null`

2209

2210 but it should contain:

2211 $srcfile

2212

2213 This indicates that another process is trying to use the same

2214 temporary object file, and libtool could not work around it because

2215 your compiler does not support \`-c' and \`-o' together. If you

2216 repeat this compilation, it may succeed, by chance, but you had better

2217 avoid parallel builds (make -j) in this platform, or get a better

2218 compiler."

2219

2220 $opt_dry_run || $RM $removelist

2221 exit $EXIT_FAILURE

2222 fi

2223

2224 # Just move the object if needed, then go on to compile the next one

2225 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then

2226 func_show_eval '$MV "$output_obj" "$lobj"' \

2227 'error=$?; $opt_dry_run || $RM $removelist; exit $error'

2228 fi

2229

2230 # Allow error messages only from the first compilation.

2231 if test "$suppress_opt" = yes; then

2232 suppress_output=' >/dev/null 2>&1'

2233 fi

2234 fi

2235

2236 # Only build a position-dependent object if we build old libraries.

2237 if test "$build_old_libs" = yes; then

2238 if test "$pic_mode" != yes; then

2239 # Don't build PIC code

2240 command="$base_compile $qsrcfile$pie_flag"

2241 else

2242 command="$base_compile $qsrcfile $pic_flag"

2243 fi

2244 if test "$compiler_c_o" = yes; then

2245 func_append command " -o $obj"

2246 fi

2247

2248 # Suppress compiler output if we already did a PIC compilation.

2249 func_append command "$suppress_output"

2250 func_show_eval_locale "$command" \

2251 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'

2252

2253 if test "$need_locks" = warn &&

2254 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

2255 $ECHO "\

2256 *** ERROR, $lockfile contains:

2257 `cat $lockfile 2>/dev/null`

2258

2259 but it should contain:

2260 $srcfile

2261

2262 This indicates that another process is trying to use the same

2263 temporary object file, and libtool could not work around it because

2264 your compiler does not support \`-c' and \`-o' together. If you

2265 repeat this compilation, it may succeed, by chance, but you had better

2266 avoid parallel builds (make -j) in this platform, or get a better

2267 compiler."

2268

2269 $opt_dry_run || $RM $removelist

2270 exit $EXIT_FAILURE

2271 fi

2272

2273 # Just move the object if needed

2274 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then

2275 func_show_eval '$MV "$output_obj" "$obj"' \

2276 'error=$?; $opt_dry_run || $RM $removelist; exit $error'

2277 fi

2278 fi

2279

2280 $opt_dry_run || {

2281 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

2282

2283 # Unlock the critical section if it was locked

2284 if test "$need_locks" != no; then

2285 removelist=$lockfile

2286 $RM "$lockfile"

2287 fi

2288 }

2289

2290 exit $EXIT_SUCCESS

2291 }

2292

2293 $opt_help || {

2294 test "$opt_mode" = compile && func_mode_compile ${1+"$@"}

2295 }

2296

2297 func_mode_help ()

2298 {

2299 # We need to display help for each of the modes.

2300 case $opt_mode in

2301 "")

2302 # Generic help is extracted from the usage comments

2303 # at the start of this file.

2304 func_help

2305 ;;

2306

2307 clean)

2308 $ECHO \

2309 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

2310

2311 Remove files from the build directory.

2312

2313 RM is the name of the program to use to delete files associated with each FILE

2314 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

2315 to RM.

2316

2317 If FILE is a libtool library, object or program, all the files associated

2318 with it are deleted. Otherwise, only FILE itself is deleted using RM."

2319 ;;

2320

2321 compile)

2322 $ECHO \

2323 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

2324

2325 Compile a source file into a libtool library object.

2326

2327 This mode accepts the following additional options:

2328

2329 -o OUTPUT-FILE set the output file name to OUTPUT-FILE

2330 -no-suppress do not suppress compiler output for multiple passes

2331 -prefer-pic try to build PIC objects only

2332 -prefer-non-pic try to build non-PIC objects only

2333 -shared do not build a \`.o' file suitable for static linking

2334 -static only build a \`.o' file suitable for static linking

2335 -Wc,FLAG pass FLAG directly to the compiler

2336

2337 COMPILE-COMMAND is a command to be used in creating a \`standard' object file

2338 from the given SOURCEFILE.

2339

2340 The output file name is determined by removing the directory component from

2341 SOURCEFILE, then substituting the C source code suffix \`.c' with the

2342 library object suffix, \`.lo'."

2343 ;;

2344

2345 execute)

2346 $ECHO \

2347 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...

2348

2349 Automatically set library path, then run a program.

2350

2351 This mode accepts the following additional options:

2352

2353 -dlopen FILE add the directory containing FILE to the library path

2354

2355 This mode sets the library path environment variable according to \`-dlopen'

2356 flags.

2357

2358 If any of the ARGS are libtool executable wrappers, then they are translated

2359 into their corresponding uninstalled binary, and any of their required library

2360 directories are added to the library path.

2361

2362 Then, COMMAND is executed, with ARGS as arguments."

2363 ;;

2364

2365 finish)

2366 $ECHO \

2367 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...

2368

2369 Complete the installation of libtool libraries.

2370

2371 Each LIBDIR is a directory that contains libtool libraries.

2372

2373 The commands that this mode executes may require superuser privileges. Use

2374 the \`--dry-run' option if you just want to see what would be executed."

2375 ;;

2376

2377 install)

2378 $ECHO \

2379 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...

2380

2381 Install executables or libraries.

2382

2383 INSTALL-COMMAND is the installation command. The first component should be

2384 either the \`install' or \`cp' program.

2385

2386 The following components of INSTALL-COMMAND are treated specially:

2387

2388 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation

2389

2390 The rest of the components are interpreted as arguments to that command (only

2391 BSD-compatible install options are recognized)."

2392 ;;

2393

2394 link)

2395 $ECHO \

2396 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...

2397

2398 Link object files or libraries together to form another library, or to

2399 create an executable program.

2400

2401 LINK-COMMAND is a command using the C compiler that you would use to create

2402 a program from several object files.

2403

2404 The following components of LINK-COMMAND are treated specially:

2405

2406 -all-static do not do any dynamic linking at all

2407 -avoid-version do not add a version suffix if possible

2408 -bindir BINDIR specify path to binaries directory (for systems where

2409 libraries must be found in the PATH setting at runtime)

2410 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime

2411 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols

2412 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)

2413 -export-symbols SYMFILE

2414 try to export only the symbols listed in SYMFILE

2415 -export-symbols-regex REGEX

2416 try to export only the symbols matching REGEX

2417 -LLIBDIR search LIBDIR for required installed libraries

2418 -lNAME OUTPUT-FILE requires the installed library libNAME

2419 -module build a library that can dlopened

2420 -no-fast-install disable the fast-install mode

2421 -no-install link a not-installable executable

2422 -no-undefined declare that a library does not refer to external symbols

2423 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects

2424 -objectlist FILE Use a list of object files found in FILE to specify objects

2425 -precious-files-regex REGEX

2426 don't remove output files matching REGEX

2427 -release RELEASE specify package release information

2428 -rpath LIBDIR the created library will eventually be installed in LIBDIR

2429 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries

2430 -shared only do dynamic linking of libtool libraries

2431 -shrext SUFFIX override the standard shared library file extension

2432 -static do not do any dynamic linking of uninstalled libtool libraries

2433 -static-libtool-libs

2434 do not do any dynamic linking of libtool libraries

2435 -version-info CURRENT[:REVISION[:AGE]]

2436 specify library version info [each variable defaults to 0]

2437 -weak LIBNAME declare that the target provides the LIBNAME interface

2438 -Wc,FLAG

2439 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler

2440 -Wl,FLAG

2441 -Xlinker FLAG pass linker-specific FLAG directly to the linker

2442 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)

2443

2444 All other options (arguments beginning with \`-') are ignored.

2445

2446 Every other argument is treated as a filename. Files ending in \`.la' are

2447 treated as uninstalled libtool libraries, other files are standard or library

2448 object files.

2449

2450 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,

2451 only library objects (\`.lo' files) may be specified, and \`-rpath' is

2452 required, except when creating a convenience library.

2453

2454 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created

2455 using \`ar' and \`ranlib', or on Windows using \`lib'.

2456

2457 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file

2458 is created, otherwise an executable program is created."

2459 ;;

2460

2461 uninstall)

2462 $ECHO \

2463 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...

2464

2465 Remove libraries from an installation directory.

2466

2467 RM is the name of the program to use to delete files associated with each FILE

2468 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

2469 to RM.

2470

2471 If FILE is a libtool library, all the files associated with it are deleted.

2472 Otherwise, only FILE itself is deleted using RM."

2473 ;;

2474

2475 *)

2476 func_fatal_help "invalid operation mode \`$opt_mode'"

2477 ;;

2478 esac

2479

2480 echo

2481 $ECHO "Try \`$progname --help' for more information about other modes."

2482 }

2483

2484 # Now that we've collected a possible --mode arg, show help if necessary

2485 if $opt_help; then

2486 if test "$opt_help" = :; then

2487 func_mode_help

2488 else

2489 {

2490 func_help noexit

2491 for opt_mode in compile link execute install finish uninstall clean; do

2492 func_mode_help

2493 done

2494 } | sed -n '1p; 2,$s/^Usage:/ or: /p'

2495 {

2496 func_help noexit

2497 for opt_mode in compile link execute install finish uninstall clean; do

2498 echo

2499 func_mode_help

2500 done

2501 } |

2502 sed '1d

2503 /^When reporting/,/^Report/{

2504 H

2505 d

2506 }

2507 $x

2508 /information about other modes/d

2509 /more detailed .*MODE/d

2510 s/^Usage:.*--mode=$[^ ]*$ .*/Description of \1 mode:/'

2511 fi

2512 exit $?

2513 fi

2514

2515

2516 # func_mode_execute arg...

2517 func_mode_execute ()

2518 {

2519 $opt_debug

2520 # The first argument is the command name.

2521 cmd="$nonopt"

2522 test -z "$cmd" && \

2523 func_fatal_help "you must specify a COMMAND"

2524

2525 # Handle -dlopen flags immediately.

2526 for file in $opt_dlopen; do

2527 test -f "$file" \

2528 || func_fatal_help "\`$file' is not a file"

2529

2530 dir=

2531 case $file in

2532 *.la)

2533 func_resolve_sysroot "$file"

2534 file=$func_resolve_sysroot_result

2535

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

2537 func_lalib_unsafe_p "$file" \

2538 || func_fatal_help "\`$lib' is not a valid libtool archive"

2539

2540 # Read the libtool library.

2541 dlname=

2542 library_names=

2543 func_source "$file"

2544

2545 # Skip this library if it cannot be dlopened.

2546 if test -z "$dlname"; then

2547 # Warn if it was a shared library.

2548 test -n "$library_names" && \

2549 func_warning "\`$file' was not linked with \`-export-dynamic'"

2550 continue

2551 fi

2552

2553 func_dirname "$file" "" "."

2554 dir="$func_dirname_result"

2555

2556 if test -f "$dir/$objdir/$dlname"; then

2557 func_append dir "/$objdir"

2558 else

2559 if test ! -f "$dir/$dlname"; then

2560 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"

2561 fi

2562 fi

2563 ;;

2564

2565 *.lo)

2566 # Just add the directory containing the .lo file.

2567 func_dirname "$file" "" "."

2568 dir="$func_dirname_result"

2569 ;;

2570

2571 *)

2572 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"

2573 continue

2574 ;;

2575 esac

2576

2577 # Get the absolute pathname.

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

2579 test -n "$absdir" && dir="$absdir"

2580

2581 # Now add the directory to shlibpath_var.

2582 if eval "test -z \"\$$shlibpath_var\""; then

2583 eval "$shlibpath_var=\"\$dir\""

2584 else

2585 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""

2586 fi

2587 done

2588

2589 # This variable tells wrapper scripts just to set shlibpath_var

2590 # rather than running their programs.

2591 libtool_execute_magic="$magic"

2592

2593 # Check if any of the arguments is a wrapper script.

2594 args=

2595 for file

2596 do

2597 case $file in

2598 -* | *.la | *.lo ) ;;

2599 *)

2600 # Do a test to see if this is really a libtool program.

2601 if func_ltwrapper_script_p "$file"; then

2602 func_source "$file"

2603 # Transform arg to wrapped name.

2604 file="$progdir/$program"

2605 elif func_ltwrapper_executable_p "$file"; then

2606 func_ltwrapper_scriptname "$file"

2607 func_source "$func_ltwrapper_scriptname_result"

2608 # Transform arg to wrapped name.

2609 file="$progdir/$program"

2610 fi

2611 ;;

2612 esac

2613 # Quote arguments (to preserve shell metacharacters).

2614 func_append_quoted args "$file"

2615 done

2616

2617 if test "X$opt_dry_run" = Xfalse; then

2618 if test -n "$shlibpath_var"; then

2619 # Export the shlibpath_var.

2620 eval "export $shlibpath_var"

2621 fi

2622

2623 # Restore saved environment variables

2624 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

2625 do

2626 eval "if test \"\${save_$lt_var+set}\" = set; then

2627 $lt_var=\$save_$lt_var; export $lt_var

2628 else

2629 $lt_unset $lt_var

2630 fi"

2631 done

2632

2633 # Now prepare to actually exec the command.

2634 exec_cmd="\$cmd$args"

2635 else

2636 # Display what would be done.

2637 if test -n "$shlibpath_var"; then

2638 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""

2639 echo "export $shlibpath_var"

2640 fi

2641 $ECHO "$cmd$args"

2642 exit $EXIT_SUCCESS

2643 fi

2644 }

2645

2646 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}

2647

2648

2649 # func_mode_finish arg...

2650 func_mode_finish ()

2651 {

2652 $opt_debug

2653 libs=

2654 libdirs=

2655 admincmds=

2656

2657 for opt in "$nonopt" ${1+"$@"}

2658 do

2659 if test -d "$opt"; then

2660 func_append libdirs " $opt"

2661

2662 elif test -f "$opt"; then

2663 if func_lalib_unsafe_p "$opt"; then

2664 func_append libs " $opt"

2665 else

2666 func_warning "\`$opt' is not a valid libtool archive"

2667 fi

2668

2669 else

2670 func_fatal_error "invalid argument \`$opt'"

2671 fi

2672 done

2673

2674 if test -n "$libs"; then

2675 if test -n "$lt_sysroot"; then

2676 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`

2677 sysroot_cmd="s/$[ ']$$sysroot_regex/\1/g;"

2678 else

2679 sysroot_cmd=

2680 fi

2681

2682 # Remove sysroot references

2683 if $opt_dry_run; then

2684 for lib in $libs; do

2685 echo "removing references to $lt_sysroot and \`=' prefixes from $lib"

2686 done

2687 else

2688 tmpdir=`func_mktempdir`

2689 for lib in $libs; do

2690 sed -e "${sysroot_cmd} s/$[ ']-[LR]$=/\1/g; s/$[ ']$=/\1/g" $lib \

2691 > $tmpdir/tmp-la

2692 mv -f $tmpdir/tmp-la $lib

2693 done

2694 ${RM}r "$tmpdir"

2695 fi

2696 fi

2697

2698 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then

2699 for libdir in $libdirs; do

2700 if test -n "$finish_cmds"; then

2701 # Do each command in the finish commands.

2702 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds

2703 '"$cmd"'"'

2704 fi

2705 if test -n "$finish_eval"; then

2706 # Do the single finish_eval.

2707 eval cmds=\"$finish_eval\"

2708 $opt_dry_run || eval "$cmds" || func_append admincmds "

2709 $cmds"

2710 fi

2711 done

2712 fi

2713

2714 # Exit here if they wanted silent mode.

2715 $opt_silent && exit $EXIT_SUCCESS

2716

2717 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then

2718 echo "----------------------------------------------------------------------"

2719 echo "Libraries have been installed in:"

2720 for libdir in $libdirs; do

2721 $ECHO " $libdir"

2722 done

2723 echo

2724 echo "If you ever happen to want to link against installed libraries"

2725 echo "in a given directory, LIBDIR, you must either use libtool, and"

2726 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"

2727 echo "flag during linking and do at least one of the following:"

2728 if test -n "$shlibpath_var"; then

2729 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"

2730 echo " during execution"

2731 fi

2732 if test -n "$runpath_var"; then

2733 echo " - add LIBDIR to the \`$runpath_var' environment variable"

2734 echo " during linking"

2735 fi

2736 if test -n "$hardcode_libdir_flag_spec"; then

2737 libdir=LIBDIR

2738 eval flag=\"$hardcode_libdir_flag_spec\"

2739

2740 $ECHO " - use the \`$flag' linker flag"

2741 fi

2742 if test -n "$admincmds"; then

2743 $ECHO " - have your system administrator run these commands:$admincmds"

2744 fi

2745 if test -f /etc/ld.so.conf; then

2746 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"

2747 fi

2748 echo

2749

2750 echo "See any operating system documentation about shared libraries for"

2751 case $host in

2752 solaris2.[6789]|solaris2.1[0-9])

2753 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"

2754 echo "pages."

2755 ;;

2756 *)

2757 echo "more information, such as the ld(1) and ld.so(8) manual pages."

2758 ;;

2759 esac

2760 echo "----------------------------------------------------------------------"

2761 fi

2762 exit $EXIT_SUCCESS

2763 }

2764

2765 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}

2766

2767

2768 # func_mode_install arg...

2769 func_mode_install ()

2770 {

2771 $opt_debug

2772 # There may be an optional sh(1) argument at the beginning of

2773 # install_prog (especially on Windows NT).

2774 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||

2775 # Allow the use of GNU shtool's install command.

2776 case $nonopt in *shtool*) :;; *) false;; esac; then

2777 # Aesthetically quote it.

2778 func_quote_for_eval "$nonopt"

2779 install_prog="$func_quote_for_eval_result "

2780 arg=$1

2781 shift

2782 else

2783 install_prog=

2784 arg=$nonopt

2785 fi

2786

2787 # The real first argument should be the name of the installation program.

2788 # Aesthetically quote it.

2789 func_quote_for_eval "$arg"

2790 func_append install_prog "$func_quote_for_eval_result"

2791 install_shared_prog=$install_prog

2792 case " $install_prog " in

2793 *[\\\ /]cp\ *) install_cp=: ;;

2794 *) install_cp=false ;;

2795 esac

2796

2797 # We need to accept at least all the BSD install flags.

2798 dest=

2799 files=

2800 opts=

2801 prev=

2802 install_type=

2803 isdir=no

2804 stripme=

2805 no_mode=:

2806 for arg

2807 do

2808 arg2=

2809 if test -n "$dest"; then

2810 func_append files " $dest"

2811 dest=$arg

2812 continue

2813 fi

2814

2815 case $arg in

2816 -d) isdir=yes ;;

2817 -f)

2818 if $install_cp; then :; else

2819 prev=$arg

2820 fi

2821 ;;

2822 -g | -m | -o)

2823 prev=$arg

2824 ;;

2825 -s)

2826 stripme=" -s"

2827 continue

2828 ;;

2829 -*)

2830 ;;

2831 *)

2832 # If the previous option needed an argument, then skip it.

2833 if test -n "$prev"; then

2834 if test "x$prev" = x-m && test -n "$install_override_mode"; then

2835 arg2=$install_override_mode

2836 no_mode=false

2837 fi

2838 prev=

2839 else

2840 dest=$arg

2841 continue

2842 fi

2843 ;;

2844 esac

2845

2846 # Aesthetically quote the argument.

2847 func_quote_for_eval "$arg"

2848 func_append install_prog " $func_quote_for_eval_result"

2849 if test -n "$arg2"; then

2850 func_quote_for_eval "$arg2"

2851 fi

2852 func_append install_shared_prog " $func_quote_for_eval_result"

2853 done

2854

2855 test -z "$install_prog" && \

2856 func_fatal_help "you must specify an install program"

2857

2858 test -n "$prev" && \

2859 func_fatal_help "the \`$prev' option requires an argument"

2860

2861 if test -n "$install_override_mode" && $no_mode; then

2862 if $install_cp; then :; else

2863 func_quote_for_eval "$install_override_mode"

2864 func_append install_shared_prog " -m $func_quote_for_eval_result"

2865 fi

2866 fi

2867

2868 if test -z "$files"; then

2869 if test -z "$dest"; then

2870 func_fatal_help "no file or destination specified"

2871 else

2872 func_fatal_help "you must specify a destination"

2873 fi

2874 fi

2875

2876 # Strip any trailing slash from the destination.

2877 func_stripname '' '/' "$dest"

2878 dest=$func_stripname_result

2879

2880 # Check to see that the destination is a directory.

2881 test -d "$dest" && isdir=yes

2882 if test "$isdir" = yes; then

2883 destdir="$dest"

2884 destname=

2885 else

2886 func_dirname_and_basename "$dest" "" "."

2887 destdir="$func_dirname_result"

2888 destname="$func_basename_result"

2889

2890 # Not a directory, so check to see that there is only one file specified.

2891 set dummy $files; shift

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

2893 func_fatal_help "\`$dest' is not a directory"

2894 fi

2895 case $destdir in

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

2897 *)

2898 for file in $files; do

2899 case $file in

2900 *.lo) ;;

2901 *)

2902 func_fatal_help "\`$destdir' must be an absolute directory name"

2903 ;;

2904 esac

2905 done

2906 ;;

2907 esac

2908

2909 # This variable tells wrapper scripts just to set variables rather

2910 # than running their programs.

2911 libtool_install_magic="$magic"

2912

2913 staticlibs=

2914 future_libdirs=

2915 current_libdirs=

2916 for file in $files; do

2917

2918 # Do each installation.

2919 case $file in

2920 *.$libext)

2921 # Do the static libraries later.

2922 func_append staticlibs " $file"

2923 ;;

2924

2925 *.la)

2926 func_resolve_sysroot "$file"

2927 file=$func_resolve_sysroot_result

2928

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

2930 func_lalib_unsafe_p "$file" \

2931 || func_fatal_help "\`$file' is not a valid libtool archive"

2932

2933 library_names=

2934 old_library=

2935 relink_command=

2936 func_source "$file"

2937

2938 # Add the libdir to current_libdirs if it is the destination.

2939 if test "X$destdir" = "X$libdir"; then

2940 case "$current_libdirs " in

2941 *" $libdir "*) ;;

2942 *) func_append current_libdirs " $libdir" ;;

2943 esac

2944 else

2945 # Note the libdir as a future libdir.

2946 case "$future_libdirs " in

2947 *" $libdir "*) ;;

2948 *) func_append future_libdirs " $libdir" ;;

2949 esac

2950 fi

2951

2952 func_dirname "$file" "/" ""

2953 dir="$func_dirname_result"

2954 func_append dir "$objdir"

2955

2956 if test -n "$relink_command"; then

2957 # Determine the prefix the user has applied to our future dir.

2958 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`

2959

2960 # Don't allow the user to place us outside of our expected

2961 # location b/c this prevents finding dependent libraries that

2962 # are installed to the same prefix.

2963 # At present, this check doesn't affect windows .dll's that

2964 # are installed into $libdir/../bin (currently, that works fine)

2965 # but it's something to keep an eye on.

2966 test "$inst_prefix_dir" = "$destdir" && \

2967 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"

2968

2969 if test -n "$inst_prefix_dir"; then

2970 # Stick the inst_prefix_dir data into the link command.

2971 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`

2972 else

2973 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`

2974 fi

2975

2976 func_warning "relinking \`$file'"

2977 func_show_eval "$relink_command" \

2978 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'

2979 fi

2980

2981 # See the names of the shared library.

2982 set dummy $library_names; shift

2983 if test -n "$1"; then

2984 realname="$1"

2985 shift

2986

2987 srcname="$realname"

2988 test -n "$relink_command" && srcname="$realname"T

2989

2990 # Install the shared library and build the symlinks.

2991 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \

2992 'exit $?'

2993 tstripme="$stripme"

2994 case $host_os in

2995 cygwin* | mingw* | pw32* | cegcc*)

2996 case $realname in

2997 *.dll.a)

2998 tstripme=""

2999 ;;

3000 esac

3001 ;;

3002 esac

3003 if test -n "$tstripme" && test -n "$striplib"; then

3004 func_show_eval "$striplib $destdir/$realname" 'exit $?'

3005 fi

3006

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

3008 # Delete the old symlinks, and create new ones.

3009 # Try `ln -sf' first, because the `ln' binary might depend on

3010 # the symlink we replace! Solaris /bin/ln does not understand -f,

3011 # so we also need to try rm && ln -s.

3012 for linkname

3013 do

3014 test "$linkname" != "$realname" \

3015 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"

3016 done

3017 fi

3018

3019 # Do each command in the postinstall commands.

3020 lib="$destdir/$realname"

3021 func_execute_cmds "$postinstall_cmds" 'exit $?'

3022 fi

3023

3024 # Install the pseudo-library for information purposes.

3025 func_basename "$file"

3026 name="$func_basename_result"

3027 instname="$dir/$name"i

3028 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'

3029

3030 # Maybe install the static library, too.

3031 test -n "$old_library" && func_append staticlibs " $dir/$old_library"

3032 ;;

3033

3034 *.lo)

3035 # Install (i.e. copy) a libtool object.

3036

3037 # Figure out destination file name, if it wasn't already specified.

3038 if test -n "$destname"; then

3039 destfile="$destdir/$destname"

3040 else

3041 func_basename "$file"

3042 destfile="$func_basename_result"

3043 destfile="$destdir/$destfile"

3044 fi

3045

3046 # Deduce the name of the destination old-style object file.

3047 case $destfile in

3048 *.lo)

3049 func_lo2o "$destfile"

3050 staticdest=$func_lo2o_result

3051 ;;

3052 *.$objext)

3053 staticdest="$destfile"

3054 destfile=

3055 ;;

3056 *)

3057 func_fatal_help "cannot copy a libtool object to \`$destfile'"

3058 ;;

3059 esac

3060

3061 # Install the libtool object if requested.

3062 test -n "$destfile" && \

3063 func_show_eval "$install_prog $file $destfile" 'exit $?'

3064

3065 # Install the old object if enabled.

3066 if test "$build_old_libs" = yes; then

3067 # Deduce the name of the old-style object file.

3068 func_lo2o "$file"

3069 staticobj=$func_lo2o_result

3070 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'

3071 fi

3072 exit $EXIT_SUCCESS

3073 ;;

3074

3075 *)

3076 # Figure out destination file name, if it wasn't already specified.

3077 if test -n "$destname"; then

3078 destfile="$destdir/$destname"

3079 else

3080 func_basename "$file"

3081 destfile="$func_basename_result"

3082 destfile="$destdir/$destfile"

3083 fi

3084

3085 # If the file is missing, and there is a .exe on the end, strip it

3086 # because it is most likely a libtool script we actually want to

3087 # install

3088 stripped_ext=""

3089 case $file in

3090 *.exe)

3091 if test ! -f "$file"; then

3092 func_stripname '' '.exe' "$file"

3093 file=$func_stripname_result

3094 stripped_ext=".exe"

3095 fi

3096 ;;

3097 esac

3098

3099 # Do a test to see if this is really a libtool program.

3100 case $host in

3101 *cygwin* | *mingw*)

3102 if func_ltwrapper_executable_p "$file"; then

3103 func_ltwrapper_scriptname "$file"

3104 wrapper=$func_ltwrapper_scriptname_result

3105 else

3106 func_stripname '' '.exe' "$file"

3107 wrapper=$func_stripname_result

3108 fi

3109 ;;

3110 *)

3111 wrapper=$file

3112 ;;

3113 esac

3114 if func_ltwrapper_script_p "$wrapper"; then

3115 notinst_deplibs=

3116 relink_command=

3117

3118 func_source "$wrapper"

3119

3120 # Check the variables that should have been set.

3121 test -z "$generated_by_libtool_version" && \

3122 func_fatal_error "invalid libtool wrapper script \`$wrapper'"

3123

3124 finalize=yes

3125 for lib in $notinst_deplibs; do

3126 # Check to see that each library is installed.

3127 libdir=

3128 if test -f "$lib"; then

3129 func_source "$lib"

3130 fi

3131 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test

3132 if test -n "$libdir" && test ! -f "$libfile"; then

3133 func_warning "\`$lib' has not been installed in \`$libdir'"

3134 finalize=no

3135 fi

3136 done

3137

3138 relink_command=

3139 func_source "$wrapper"

3140

3141 outputname=

3142 if test "$fast_install" = no && test -n "$relink_command"; then

3143 $opt_dry_run || {

3144 if test "$finalize" = yes; then

3145 tmpdir=`func_mktempdir`

3146 func_basename "$file$stripped_ext"

3147 file="$func_basename_result"

3148 outputname="$tmpdir/$file"

3149 # Replace the output file specification.

3150 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`