~ubuntu-branches/ubuntu/vivid/blueman/vivid-proposed : revision 22

1

#! /bin/bash

2

3

# libtool - Provide generalized library-building support services.

4

# Generated automatically by config.status (blueman) 1.23

5

# Libtool was configured on host A:

6

# NOTE: Changes made to this file will be lost: look at ltmain.sh.

7

#

8

9

# 2006, 2007, 2008, 2009, 2010, 2011 Free Software

10

# Foundation, Inc.

11

# Written by Gordon Matzigkeit, 1996

12

#

13

# This file is part of GNU Libtool.

14

#

15

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

16

# modify it under the terms of the GNU General Public License as

17

# published by the Free Software Foundation; either version 2 of

18

# the License, or (at your option) any later version.

19

#

20

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

21

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

22

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

23

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

24

#

25

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

26

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

27

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

28

# GNU General Public License for more details.

29

#

30

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

31

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

32

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

33

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

34

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

35

36

37

# The names of the tagged configurations supported by this script.

38

available_tags=""

39

40

# ### BEGIN LIBTOOL CONFIG

41

42

# Which release of libtool.m4 was used?

43

macro_version=2.4.2

44

macro_revision=1.3337

45

46

# Whether or not to build shared libraries.

47

build_libtool_libs=yes

48

49

# Whether or not to build static libraries.

50

build_old_libs=yes

51

52

# What type of objects to build.

53

pic_mode=default

54

55

# Whether or not to optimize for fast installation.

56

fast_install=yes

57

58

# Shell to use when invoking shell scripts.

59

SHELL="/bin/bash"

60

61

# An echo program that protects backslashes.

62

ECHO="printf %s\\n"

63

64

# The PATH separator for the build system.

65

PATH_SEPARATOR=":"

66

67

# The host system.

68

host_alias=

69

host=x86_64-unknown-linux-gnu

70

host_os=linux-gnu

71

72

# The build system.

73

build_alias=

74

build=x86_64-unknown-linux-gnu

75

build_os=linux-gnu

76

77

# A sed program that does not truncate output.

78

SED="/bin/sed"

79

80

# Sed that helps us avoid accidentally triggering echo(1) options like -n.

81

Xsed="$SED -e 1s/^X//"

82

83

# A grep program that handles long lines.

84

GREP="/bin/grep"

85

86

# An ERE matcher.

87

EGREP="/bin/grep -E"

88

89

# A literal string matcher.

90

FGREP="/bin/grep -F"

91

92

# A BSD- or MS-compatible name lister.

93

NM="/usr/bin/nm -B"

94

95

# Whether we need soft or hard links.

96

LN_S="ln -s"

97

98

# What is the maximum length of a command?

99

max_cmd_len=1572864

100

101

# Object file suffix (normally "o").

102

objext=o

103

104

# Executable file suffix (normally "").

105

exeext=

106

107

# whether the shell understands "unset".

108

lt_unset=unset

109

110

# turn spaces into newlines.

111

SP2NL="tr \\040 \\012"

112

113

# turn newlines into spaces.

114

NL2SP="tr \\015\\012 \\040\\040"

115

116

# convert $build file names to $host format.

117

to_host_file_cmd=func_convert_file_noop

118

119

# convert $build files to toolchain format.

120

to_tool_file_cmd=func_convert_file_noop

121

122

# An object symbol dumper.

123

OBJDUMP="objdump"

124

125

# Method to check whether dependent libraries are shared objects.

126

deplibs_check_method="pass_all"

127

128

# Command to use when deplibs_check_method = "file_magic".

129

file_magic_cmd="\$MAGIC_CMD"

130

131

# How to find potential files when deplibs_check_method = "file_magic".

132

file_magic_glob=""

133

134

# Find potential files using nocaseglob when deplibs_check_method = "file_magic".

135

want_nocaseglob="no"

136

137

# DLL creation program.

138

DLLTOOL="false"

139

140

# Command to associate shared and link libraries.

141

sharedlib_from_linklib_cmd="printf %s\\n"

142

143

# The archiver.

144

AR="ar"

145

146

# Flags to create an archive.

147

AR_FLAGS="cru"

148

149

# How to feed a file listing to the archiver.

150

archiver_list_spec="@"

151

152

# A symbol stripping program.

153

STRIP="strip"

154

155

# Commands used to install an old-style archive.

156

RANLIB="ranlib"

157

old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$tool_oldlib"

158

old_postuninstall_cmds=""

159

160

# Whether to use a lock for old archive extraction.

161

lock_old_archive_extraction=no

162

163

# A C compiler.

164

LTCC="gcc"

165

166

# LTCC compiler flags.

167

LTCFLAGS="-g -O2"

168

169

# Take the output of nm and produce a listing of raw symbols and C names.

170

global_symbol_pipe="sed -n -e 's/^.*[ ]\$[ABCDGIRSTW][ABCDGIRSTW]*\$[ ][ ]*\$[_A-Za-z][_A-Za-z0-9]*\$\$/\\1 \\2 \\2/p' | sed '/ __gnu_lto/d'"

171

172

# Transform the output of nm in a proper C declaration.

173

global_symbol_to_cdecl="sed -n -e 's/^T .* \$.*\$\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \$.*\$\$/extern char \\1;/p'"

174

175

# Transform the output of nm in a C name address pair.

176

global_symbol_to_c_name_address="sed -n -e 's/^: \$[^ ]*\$[ ]*\$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \$[^ ]*\$ \$[^ ]*\$\$/ {\"\\2\", (void *) \\&\\2},/p'"

177

178

# Transform the output of nm in a C name address pair when lib prefix is needed.

179

global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \$[^ ]*\$[ ]*\$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \$[^ ]*\$ \$lib[^ ]*\$\$/ {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \$[^ ]*\$ \$[^ ]*\$\$/ {\"lib\\2\", (void *) \\&\\2},/p'"

180

181

# Specify filename containing input files for $NM.

182

nm_file_list_spec="@"

183

184

# The root where to search for dependent libraries,and in which our libraries should be installed.

185

lt_sysroot=

186

187

# The name of the directory that contains temporary libtool files.

188

objdir=.libs

189

190

# Used to examine libraries when file_magic_cmd begins with "file".

191

MAGIC_CMD=file

192

193

# Must we lock files when doing compilation?

194

need_locks="no"

195

196

# Manifest tool.

197

MANIFEST_TOOL=":"

198

199

# Tool to manipulate archived DWARF debug symbol files on Mac OS X.

200

DSYMUTIL=""

201

202

# Tool to change global to local symbols on Mac OS X.

203

NMEDIT=""

204

205

# Tool to manipulate fat objects and archives on Mac OS X.

206

LIPO=""

207

208

# ldd/readelf like tool for Mach-O binaries on Mac OS X.

209

OTOOL=""

210

211

# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.

212

OTOOL64=""

213

214

# Old archive suffix (normally "a").

215

libext=a

216

217

# Shared library suffix (normally ".so").

218

shrext_cmds=".so"

219

220

# The commands to extract the exported symbol list from a shared archive.

221

extract_expsyms_cmds=""

222

223

# Variables whose values should be saved in libtool wrapper scripts and

224

# restored at link time.

225

variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

226

227

# Do we need the "lib" prefix for modules?

228

need_lib_prefix=no

229

230

# Do we need a version for libraries?

231

need_version=no

232

233

# Library versioning type.

234

version_type=linux

235

236

# Shared library runtime path variable.

237

runpath_var=LD_RUN_PATH

238

239

# Shared library path variable.

240

shlibpath_var=LD_LIBRARY_PATH

241

242

# Is shlibpath searched before the hard-coded library search path?

243

shlibpath_overrides_runpath=no

244

245

# Format of library name prefix.

246

libname_spec="lib\$name"

247

248

# List of archive names. First name is the real one, the rest are links.

249

# The last name is the one that the linker finds with -lNAME

250

library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"

251

252

# The coded name of the library, if different from the real name.

253

soname_spec="\${libname}\${release}\${shared_ext}\$major"

254

255

# Permission mode override for installation of shared libraries.

256

install_override_mode=""

257

258

# Command to use after installation of a shared archive.

259

postinstall_cmds=""

260

261

# Command to use after uninstallation of a shared archive.

262

postuninstall_cmds=""

263

264

# Commands used to finish a libtool library installation in a directory.

265

finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"

266

267

# As "finish_cmds", except a single script fragment to be evaled but

268

# not shown.

269

finish_eval=""

270

271

# Whether we should hardcode library paths into libraries.

272

hardcode_into_libs=yes

273

274

# Compile-time system search path for libraries.

275

sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/4.8 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib "

276

277

# Run-time system search path for libraries.

278

sys_lib_dlsearch_path_spec="/lib /usr/lib /lib/i386-linux-gnu /usr/lib/i386-linux-gnu /lib/i486-linux-gnu /usr/lib/i486-linux-gnu /usr/local/lib /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu "

279

280

# Whether dlopen is supported.

281

dlopen_support=unknown

282

283

# Whether dlopen of programs is supported.

284

dlopen_self=unknown

285

286

# Whether dlopen of statically linked programs is supported.

287

dlopen_self_static=unknown

288

289

# Commands to strip libraries.

290

old_striplib="strip --strip-debug"

291

striplib="strip --strip-unneeded"

292

293

294

# The linker used to build libraries.

295

LD="/usr/bin/ld -m elf_x86_64"

296

297

# How to create reloadable object files.

298

reload_flag=" -r"

299

reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"

300

301

# Commands used to build an old-style archive.

302

old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$tool_oldlib"

303

304

# A language specific compiler.

305

CC="gcc"

306

307

# Is the compiler the GNU compiler?

308

with_gcc=yes

309

310

# Compiler flag to turn off builtin functions.

311

no_builtin_flag=" -fno-builtin"

312

313

# Additional compiler flags for building library objects.

314

pic_flag=" -fPIC -DPIC"

315

316

# How to pass a linker flag through the compiler.

317

wl="-Wl,"

318

319

# Compiler flag to prevent dynamic linking.

320

link_static_flag="-static"

321

322

# Does compiler simultaneously support -c and -o options?

323

compiler_c_o="yes"

324

325

# Whether or not to add -lc for building shared libraries.

326

build_libtool_need_lc=no

327

328

# Whether or not to disallow shared libs when runtime libs are static.

329

allow_libtool_libs_with_static_runtimes=no

330

331

# Compiler flag to allow reflexive dlopens.

332

export_dynamic_flag_spec="\${wl}--export-dynamic"

333

334

# Compiler flag to generate shared objects directly from archives.

335

whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"

336

337

# Whether the compiler copes with passing no objects directly.

338

compiler_needs_object="no"

339

340

# Create an old-style archive from a shared archive.

341

old_archive_from_new_cmds=""

342

343

# Create a temporary old-style archive to link instead of a shared archive.

344

old_archive_from_expsyms_cmds=""

345

346

# Commands used to build a shared archive.

347

archive_cmds="\$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"

348

archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~

349

cat \$export_symbols | sed -e \\\"s/\\\$.*\\\$/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~

350

echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~

351

\$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"

352

353

# Commands used to build a loadable module if different from building

354

# a shared archive.

355

module_cmds=""

356

module_expsym_cmds=""

357

358

# Whether we are building with GNU ld or not.

359

with_gnu_ld="yes"

360

361

# Flag that allows shared libraries with undefined symbols to be built.

362

allow_undefined_flag=""

363

364

# Flag that enforces no undefined symbols.

365

no_undefined_flag=""

366

367

# Flag to hardcode $libdir into a binary during linking.

368

# This must work even if $libdir does not exist

369

hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"

370

371

# Whether we need a single "-rpath" flag with a separated argument.

372

hardcode_libdir_separator=""

373

374

# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes

375

# DIR into the resulting binary.

376

hardcode_direct=no

377

378

# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes

379

# DIR into the resulting binary and the resulting library dependency is

380

# "absolute",i.e impossible to change by setting ${shlibpath_var} if the

381

# library is relocated.

382

hardcode_direct_absolute=no

383

384

# Set to "yes" if using the -LDIR flag during linking hardcodes DIR

385

# into the resulting binary.

386

hardcode_minus_L=no

387

388

# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR

389

# into the resulting binary.

390

hardcode_shlibpath_var=unsupported

391

392

# Set to "yes" if building a shared library automatically hardcodes DIR

393

# into the library and all subsequent libraries and executables linked

394

# against it.

395

hardcode_automatic=no

396

397

# Set to yes if linker adds runtime paths of dependent libraries

398

# to runtime path list.

399

inherit_rpath=no

400

401

# Whether libtool must link a program against all its dependency libraries.

402

link_all_deplibs=no

403

404

# Set to "yes" if exported symbols are required.

405

always_export_symbols=no

406

407

# The commands to list exported symbols.

408

export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"

409

410

# Symbols that should not be listed in the preloaded symbols.

411

exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"

412

413

# Symbols that must always be exported.

414

include_expsyms=""

415

416

# Commands necessary for linking programs (against libraries) with templates.

417

prelink_cmds=""

418

419

# Commands necessary for finishing linking programs.

420

postlink_cmds=""

421

422

# Specify filename containing input files.

423

file_list_spec=""

424

425

# How to hardcode a shared library path into an executable.

426

hardcode_action=immediate

427

428

# ### END LIBTOOL CONFIG

429

430

431

# libtool (GNU libtool) 2.4.2

432

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

433

434

435

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

436

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

437

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

438

439

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

440

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

441

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

442

# (at your option) any later version.

443

#

444

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

445

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

446

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

447

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

448

#

449

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

450

# WITHOUT ANY WARRANTY; without even the implied warranty of

451

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

452

# General Public License for more details.

453

#

454

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

455

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

456

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

457

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

458

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

459

460

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

461

#

462

# Provide generalized library-building support services.

463

#

464

# --config show all configuration variables

465

# --debug enable verbose shell tracing

466

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

467

# --features display basic configuration information and exit

468

# --mode=MODE use operation mode MODE

469

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

470

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

471

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

472

# print informational messages (default)

473

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

474

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

475

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

476

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

477

# --version print version information

478

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

479

#

480

# MODE must be one of the following:

481

#

482

# clean remove files from the build directory

483

# compile compile a source file into a libtool object

484

# execute automatically set library path, then run a program

485

# finish complete the installation of libtool libraries

486

# install install libraries or executables

487

# link create a library or an executable

488

# uninstall remove libraries from an installed directory

489

#

490

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

491

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

492

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

493

#

494

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

495

# include the following information:

496

#

497

# host-triplet: $host

498

# shell: $SHELL

499

# compiler: $LTCC

500

# compiler flags: $LTCFLAGS

501

# linker: $LD (gnu? $with_gnu_ld)

502

# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.7

503

# automake: $automake_version

504

# autoconf: $autoconf_version

505

#

506

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

507

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

508

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

509

510

PROGRAM=libtool

511

PACKAGE=libtool

512

VERSION="2.4.2 Debian-2.4.2-1.7"

513

TIMESTAMP=""

514

package_revision=1.3337

515

516

# Be Bourne compatible

517

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

518

emulate sh

519

NULLCMD=:

520

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

521

# is contrary to our usage. Disable this feature.

522

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

523

setopt NO_GLOB_SUBST

524

else

525

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

526

fi

527

BIN_SH=xpg4; export BIN_SH # for Tru64

528

DUALCASE=1; export DUALCASE # for MKS sh

529

530

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

531

func_fallback_echo ()

532

{

533

eval 'cat <<_LTECHO_EOF

534

$1

535

_LTECHO_EOF'

536

}

537

538

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

539

lt_user_locale=

540

lt_safe_locale=

541

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

542

do

543

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

544

save_$lt_var=\$$lt_var

545

$lt_var=C

546

export $lt_var

547

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

548

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

549

fi"

550

done

551

LC_ALL=C

552

LANGUAGE=C

553

export LANGUAGE LC_ALL

554

555

$lt_unset CDPATH

556

557

558

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

559

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

560

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

561

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

562

# function.

563

progpath="$0"

564

565

566

567

: ${CP="cp -f"}

568

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

569

: ${MAKE="make"}

570

: ${MKDIR="mkdir"}

571

: ${MV="mv -f"}

572

: ${RM="rm -f"}

573

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

574

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

575

576

# Global variables:

577

EXIT_SUCCESS=0

578

EXIT_FAILURE=1

579

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

580

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

581

582

exit_status=$EXIT_SUCCESS

583

584

# Make sure IFS has a sensible default

585

lt_nl='

586

'

587

IFS=" $lt_nl"

588

589

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

590

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

591

592

# func_dirname file append nondir_replacement

593

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

594

# otherwise set result to NONDIR_REPLACEMENT.

595

func_dirname ()

596

{

597

case ${1} in

598

*/*) func_dirname_result="${1%/*}${2}" ;;

599

* ) func_dirname_result="${3}" ;;

600

esac

601

} # Extended-shell func_dirname implementation

602

603

604

# func_basename file

605

func_basename ()

606

{

607

func_basename_result="${1##*/}"

608

} # Extended-shell func_basename implementation

609

610

611

# func_dirname_and_basename file append nondir_replacement

612

# perform func_basename and func_dirname in a single function

613

# call:

614

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

615

# add APPEND to the result, otherwise set result

616

# to NONDIR_REPLACEMENT.

617

# value returned in "$func_dirname_result"

618

# basename: Compute filename of FILE.

619

# value retuned in "$func_basename_result"

620

# Implementation must be kept synchronized with func_dirname

621

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

622

# those functions but instead duplicate the functionality here.

623

func_dirname_and_basename ()

624

{

625

case ${1} in

626

*/*) func_dirname_result="${1%/*}${2}" ;;

627

* ) func_dirname_result="${3}" ;;

628

esac

629

func_basename_result="${1##*/}"

630

} # Extended-shell func_dirname_and_basename implementation

631

632

633

# func_stripname prefix suffix name

634

# strip PREFIX and SUFFIX off of NAME.

635

# PREFIX and SUFFIX must not contain globbing or regex special

636

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

637

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

638

# func_strip_suffix prefix name

639

func_stripname ()

640

{

641

# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are

642

# positional parameters, so assign one to ordinary parameter first.

643

func_stripname_result=${3}

644

func_stripname_result=${func_stripname_result#"${1}"}

645

func_stripname_result=${func_stripname_result%"${2}"}

646

} # Extended-shell func_stripname implementation

647

648

649

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

650

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

651

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

652

removedotparts=':dotsl

653

s@/\./@/@g

654

t dotsl

655

s,/\.$,/,'

656

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

657

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

658

659

# func_normal_abspath PATH

660

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

661

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

662

# it an absolute path.

663

# value returned in "$func_normal_abspath_result"

664

func_normal_abspath ()

665

{

666

# Start from root dir and reassemble the path.

667

func_normal_abspath_result=

668

func_normal_abspath_tpath=$1

669

func_normal_abspath_altnamespace=

670

case $func_normal_abspath_tpath in

671

"")

672

# Empty path, that just means $cwd.

673

func_stripname '' '/' "`pwd`"

674

func_normal_abspath_result=$func_stripname_result

675

return

676

;;

677

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

678

# two leading slashes without using negated character classes;

679

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

680

///*)

681

# Unusual form of absolute path, do nothing.

682

;;

683

//*)

684

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

685

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

686

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

687

func_normal_abspath_altnamespace=/

688

;;

689

/*)

690

# Absolute path, do nothing.

691

;;

692

*)

693

# Relative path, prepend $cwd.

694

func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

695

;;

696

esac

697

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

698

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

699

# there is one (and only one) here.

700

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

701

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

702

while :; do

703

# Processed it all yet?

704

if test "$func_normal_abspath_tpath" = / ; then

705

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

706

if test -z "$func_normal_abspath_result" ; then

707

func_normal_abspath_result=/

708

fi

709

break

710

fi

711

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

712

-e "$pathcar"`

713

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

714

-e "$pathcdr"`

715

# Figure out what to do with it

716

case $func_normal_abspath_tcomponent in

717

"")

718

# Trailing empty path component, ignore it.

719

;;

720

..)

721

# Parent dir; strip last assembled component from result.

722

func_dirname "$func_normal_abspath_result"

723

func_normal_abspath_result=$func_dirname_result

724

;;

725

*)

726

# Actual path component, append it.

727

func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

728

;;

729

esac

730

done

731

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

732

func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

733

}

734

735

# func_relative_path SRCDIR DSTDIR

736

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

737

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

738

# without needing to append a separator.

739

# value returned in "$func_relative_path_result"

740

func_relative_path ()

741

{

742

func_relative_path_result=

743

func_normal_abspath "$1"

744

func_relative_path_tlibdir=$func_normal_abspath_result

745

func_normal_abspath "$2"

746

func_relative_path_tbindir=$func_normal_abspath_result

747

748

# Ascend the tree starting from libdir

749

while :; do

750

# check if we have found a prefix of bindir

751

case $func_relative_path_tbindir in

752

$func_relative_path_tlibdir)

753

# found an exact match

754

func_relative_path_tcancelled=

755

break

756

;;

757

$func_relative_path_tlibdir*)

758

# found a matching prefix

759

func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

760

func_relative_path_tcancelled=$func_stripname_result

761

if test -z "$func_relative_path_result"; then

762

func_relative_path_result=.

763

fi

764

break

765

;;

766

*)

767

func_dirname $func_relative_path_tlibdir

768

func_relative_path_tlibdir=${func_dirname_result}

769

if test "x$func_relative_path_tlibdir" = x ; then

770

# Have to descend all the way to the root!

771

func_relative_path_result=../$func_relative_path_result

772

func_relative_path_tcancelled=$func_relative_path_tbindir

773

break

774

fi

775

func_relative_path_result=../$func_relative_path_result

776

;;

777

esac

778

done

779

780

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

781

func_stripname '' '/' "$func_relative_path_result"

782

func_relative_path_result=$func_stripname_result

783

func_stripname '/' '/' "$func_relative_path_tcancelled"

784

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

785

func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

786

fi

787

788

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

789

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

790

# file name can be directly appended.

791

if test ! -z "$func_relative_path_result"; then

792

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

793

func_relative_path_result=$func_stripname_result

794

fi

795

}

796

797

# The name of this program:

798

func_dirname_and_basename "$progpath"

799

progname=$func_basename_result

800

801

# Make sure we have an absolute path for reexecution:

802

case $progpath in

803

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

804

*[\\/]*)

805

progdir=$func_dirname_result

806

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

807

progpath="$progdir/$progname"

808

;;

809

*)

810

save_IFS="$IFS"

811

IFS=${PATH_SEPARATOR-:}

812

for progdir in $PATH; do

813

IFS="$save_IFS"

814

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

815

done

816

IFS="$save_IFS"

817

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

818

progpath="$progdir/$progname"

819

;;

820

esac

821

822

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

823

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

824

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

825

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

826

827

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

828

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

829

830

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

831

# string literally.

832

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

833

834

# Sed substitution that converts a w32 file name or path

835

# which contains forward slashes, into one that contains

836

# (escaped) backslashes. A very naive implementation.

837

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

838

839

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

840

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

841

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

842

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

843

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

844

bs='\\'

845

bs2='\\\\'

846

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

847

dollar='\$'

848

sed_double_backslash="\

849

s/$bs4/&\\

850

/g

851

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

852

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

853

s/\n//g"

854

855

# Standard options:

856

opt_dry_run=false

857

opt_help=false

858

opt_quiet=false

859

opt_verbose=false

860

opt_warning=:

861

862

# func_echo arg...

863

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

864

# name if it has been set yet.

865

func_echo ()

866

{

867

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

868

}

869

870

# func_verbose arg...

871

# Echo program name prefixed message in verbose mode only.

872

func_verbose ()

873

{

874

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

875

876

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

877

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

878

# work around that:

879

:

880

}

881

882

# func_echo_all arg...

883

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

884

func_echo_all ()

885

{

886

$ECHO "$*"

887

}

888

889

# func_error arg...

890

# Echo program name prefixed message to standard error.

891

func_error ()

892

{

893

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

894

}

895

896

# func_warning arg...

897

# Echo program name prefixed warning message to standard error.

898

func_warning ()

899

{

900

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

901

902

# bash bug again:

903

:

904

}

905

906

# func_fatal_error arg...

907

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

908

func_fatal_error ()

909

{

910

func_error ${1+"$@"}

911

exit $EXIT_FAILURE

912

}

913

914

# func_fatal_help arg...

915

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

916

# a help hint, and exit.

917

func_fatal_help ()

918

{

919

func_error ${1+"$@"}

920

func_fatal_error "$help"

921

}

922

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

923

924

925

# func_grep expression filename

926

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

927

func_grep ()

928

{

929

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

930

}

931

932

933

# func_mkdir_p directory-path

934

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

935

func_mkdir_p ()

936

{

937

my_directory_path="$1"

938

my_dir_list=

939

940

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

941

942

# Protect directory names starting with `-'

943

case $my_directory_path in

944

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

945

esac

946

947

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

948

while test ! -d "$my_directory_path"; do

949

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

950

# list incase some portion of path contains whitespace.

951

my_dir_list="$my_directory_path:$my_dir_list"

952

953

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

954

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

955

956

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

957

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

958

done

959

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

960

961

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

962

for my_dir in $my_dir_list; do

963

IFS="$save_mkdir_p_IFS"

964

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

965

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

966

# stop in that case!

967

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

968

done

969

IFS="$save_mkdir_p_IFS"

970

971

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

972

test -d "$my_directory_path" || \

973

func_fatal_error "Failed to create \`$1'"

974

fi

975

}

976

977

978

# func_mktempdir [string]

979

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

980

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

981

# given, STRING is the basename for that directory.

982

func_mktempdir ()

983

{

984

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

985

986

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

987

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

988

my_tmpdir="${my_template}-$$"

989

else

990

991

# If mktemp works, use that first and foremost

992

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

993

994

if test ! -d "$my_tmpdir"; then

995

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

996

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

997

998

save_mktempdir_umask=`umask`

999

umask 0077

1000

$MKDIR "$my_tmpdir"

1001

umask $save_mktempdir_umask

1002

fi

1003

1004

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

1005

test -d "$my_tmpdir" || \

1006

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

1007

fi

1008

1009

$ECHO "$my_tmpdir"

1010

}

1011

1012

1013

# func_quote_for_eval arg

1014

# Aesthetically quote ARG to be evaled later.

1015

# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

1016

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

1017

# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

1018

# which are still active within double quotes backslashified.

1019

func_quote_for_eval ()

1020

{

1021

case $1 in

1022

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

1023

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

1024

*)

1025

func_quote_for_eval_unquoted_result="$1" ;;

1026

esac

1027

1028

case $func_quote_for_eval_unquoted_result in

1029

# Double-quote args containing shell metacharacters to delay

1030

# word splitting, command substitution and and variable

1031

# expansion for a subsequent eval.

1032

# Many Bourne shells cannot handle close brackets correctly

1033

# in scan sets, so we specify it separately.

1034

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

1035

func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

1036

;;

1037

*)

1038

func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

1039

esac

1040

}

1041

1042

1043

# func_quote_for_expand arg

1044

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

1045

# but do not quote variable references.

1046

func_quote_for_expand ()

1047

{

1048

case $1 in

1049

*[\\\`\"]*)

1050

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

1051

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

1052

*)

1053

my_arg="$1" ;;

1054

esac

1055

1056

case $my_arg in

1057

# Double-quote args containing shell metacharacters to delay

1058

# word splitting and command substitution for a subsequent eval.

1059

# Many Bourne shells cannot handle close brackets correctly

1060

# in scan sets, so we specify it separately.

1061

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

1062

my_arg="\"$my_arg\""

1063

;;

1064

esac

1065

1066

func_quote_for_expand_result="$my_arg"

1067

}

1068

1069

1070

# func_show_eval cmd [fail_exp]

1071

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

1072

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

1073

# is given, then evaluate it.

1074

func_show_eval ()

1075

{

1076

my_cmd="$1"

1077

my_fail_exp="${2-:}"

1078

1079

${opt_silent-false} || {

1080

func_quote_for_expand "$my_cmd"

1081

eval "func_echo $func_quote_for_expand_result"

1082

}

1083

1084

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

1085

eval "$my_cmd"

1086

my_status=$?

1087

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

1088

eval "(exit $my_status); $my_fail_exp"

1089

fi

1090

fi

1091

}

1092

1093

1094

# func_show_eval_locale cmd [fail_exp]

1095

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

1096

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

1097

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

1098

func_show_eval_locale ()

1099

{

1100

my_cmd="$1"

1101

my_fail_exp="${2-:}"

1102

1103

${opt_silent-false} || {

1104

func_quote_for_expand "$my_cmd"

1105

eval "func_echo $func_quote_for_expand_result"

1106

}

1107

1108

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

1109

eval "$lt_user_locale

1110

$my_cmd"

1111

my_status=$?

1112

eval "$lt_safe_locale"

1113

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

1114

eval "(exit $my_status); $my_fail_exp"

1115

fi

1116

fi

1117

}

1118

1119

# func_tr_sh

1120

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

1121

# Result is stored in $func_tr_sh_result. All characters

1122

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

1123

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

1124

func_tr_sh ()

1125

{

1126

case $1 in

1127

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

1128

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

1129

;;

1130

* )

1131

func_tr_sh_result=$1

1132

;;

1133

esac

1134

}

1135

1136

1137

# func_version

1138

# Echo version message to standard output and exit.

1139

func_version ()

1140

{

1141

$opt_debug

1142

1143

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

1144

:more

1145

/\./!{

1146

N

1147

s/\n# / /

1148

b more

1149

}

1150

:go

1151

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

1152

s/^# //

1153

s/^# *$//

1154

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

1155

p

1156

}' < "$progpath"

1157

exit $?

1158

}

1159

1160

# func_usage

1161

# Echo short help message to standard output and exit.

1162

func_usage ()

1163

{

1164

$opt_debug

1165

1166

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

1167

s/^# //

1168

s/^# *$//

1169

s/\$progname/'$progname'/

1170

p

1171

}' < "$progpath"

1172

echo

1173

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

1174

exit $?

1175

}

1176

1177

# func_help [NOEXIT]

1178

# Echo long help message to standard output and exit,

1179

# unless 'noexit' is passed as argument.

1180

func_help ()

1181

{

1182

$opt_debug

1183

1184

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

1185

:print

1186

s/^# //

1187

s/^# *$//

1188

s*\$progname*'$progname'*

1189

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

1190

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

1191

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

1192

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

1193

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

1194

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

1195

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

1196

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

1197

p

1198

d

1199

}

1200

/^# .* home page:/b print

1201

/^# General help using/b print

1202

' < "$progpath"

1203

ret=$?

1204

if test -z "$1"; then

1205

exit $ret

1206

fi

1207

}

1208

1209

# func_missing_arg argname

1210

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

1211

# exit_cmd.

1212

func_missing_arg ()

1213

{

1214

$opt_debug

1215

1216

func_error "missing argument for $1."

1217

exit_cmd=exit

1218

}

1219

1220

1221

# func_split_short_opt shortopt

1222

# Set func_split_short_opt_name and func_split_short_opt_arg shell

1223

# variables after splitting SHORTOPT after the 2nd character.

1224

func_split_short_opt ()

1225

{

1226

func_split_short_opt_arg=${1#??}

1227

func_split_short_opt_name=${1%"$func_split_short_opt_arg"}

1228

} # Extended-shell func_split_short_opt implementation

1229

1230

1231

# func_split_long_opt longopt

1232

# Set func_split_long_opt_name and func_split_long_opt_arg shell

1233

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

1234

func_split_long_opt ()

1235

{

1236

func_split_long_opt_name=${1%%=*}

1237

func_split_long_opt_arg=${1#*=}

1238

} # Extended-shell func_split_long_opt implementation

1239

1240

exit_cmd=:

1241

1242

1243

1244

1245

1246

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

1247

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

1248

1249

# Global variables.

1250

nonopt=

1251

preserve_args=

1252

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

1253

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

1254

extracted_archives=

1255

extracted_serial=0

1256

1257

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

1258

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

1259

# left over by shells.

1260

exec_cmd=

1261

1262

# func_append var value

1263

# Append VALUE to the end of shell variable VAR.

1264

func_append ()

1265

{

1266

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

1267

} # Extended-shell func_append implementation

1268

1269

# func_append_quoted var value

1270

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

1271

# by a space.

1272

func_append_quoted ()

1273

{

1274

func_quote_for_eval "${2}"

1275

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

1276

} # Extended-shell func_append_quoted implementation

1277

1278

1279

# func_arith arithmetic-term...

1280

func_arith ()

1281

{

1282

func_arith_result=$(( $* ))

1283

} # Extended-shell func_arith implementation

1284

1285

1286

# func_len string

1287

# STRING may not start with a hyphen.

1288

func_len ()

1289

{

1290

func_len_result=${#1}

1291

} # Extended-shell func_len implementation

1292

1293

1294

# func_lo2o object

1295

func_lo2o ()

1296

{

1297

case ${1} in

1298

*.lo) func_lo2o_result=${1%.lo}.${objext} ;;

1299

*) func_lo2o_result=${1} ;;

1300

esac

1301

} # Extended-shell func_lo2o implementation

1302

1303

1304

# func_xform libobj-or-source

1305

func_xform ()

1306

{

1307

func_xform_result=${1%.*}.lo

1308

} # Extended-shell func_xform implementation

1309

1310

1311

# func_fatal_configuration arg...

1312

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

1313

# a configuration failure hint, and exit.

1314

func_fatal_configuration ()

1315

{

1316

func_error ${1+"$@"}

1317

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

1318

func_fatal_error "Fatal configuration error."

1319

}

1320

1321

1322

# func_config

1323

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

1324

func_config ()

1325

{

1326

re_begincf='^# ### BEGIN LIBTOOL'

1327

re_endcf='^# ### END LIBTOOL'

1328

1329

# Default configuration.

1330

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

1331

1332

# Now print the configurations for the tags.

1333

for tagname in $taglist; do

1334

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

1335

done

1336

1337

exit $?

1338

}

1339

1340

# func_features

1341

# Display the features supported by this script.

1342

func_features ()

1343

{

1344

echo "host: $host"

1345

if test "$build_libtool_libs" = yes; then

1346

echo "enable shared libraries"

1347

else

1348

echo "disable shared libraries"

1349

fi

1350

if test "$build_old_libs" = yes; then

1351

echo "enable static libraries"

1352

else

1353

echo "disable static libraries"

1354

fi

1355

1356

exit $?

1357

}

1358

1359

# func_enable_tag tagname

1360

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

1361

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

1362

# variable here.

1363

func_enable_tag ()

1364

{

1365

# Global variable:

1366

tagname="$1"

1367

1368

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

1369

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

1370

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

1371

1372

# Validate tagname.

1373

case $tagname in

1374

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

1375

func_fatal_error "invalid tag name: $tagname"

1376

;;

1377

esac

1378

1379

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

1380

# there but not specially marked.

1381

case $tagname in

1382

CC) ;;

1383

*)

1384

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

1385

taglist="$taglist $tagname"

1386

1387

# Evaluate the configuration. Be careful to quote the path

1388

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

1389

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

1390

# quotes we have to do it in 2 steps:

1391

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

1392

eval "$extractedcf"

1393

else

1394

func_error "ignoring unknown tag $tagname"

1395

fi

1396

;;

1397

esac

1398

}

1399

1400

# func_check_version_match

1401

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

1402

# release of libtool.

1403

func_check_version_match ()

1404

{

1405

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

1406

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

1407

if test -z "$macro_version"; then

1408

cat >&2 <<_LT_EOF

1409

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

1410

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

1411

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

1412

$progname: and run autoconf again.

1413

_LT_EOF

1414

else

1415

cat >&2 <<_LT_EOF

1416

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

1417

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

1418

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

1419

$progname: and run autoconf again.

1420

_LT_EOF

1421

fi

1422

else

1423

cat >&2 <<_LT_EOF

1424

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

1425

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

1426

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

1427

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

1428

_LT_EOF

1429

fi

1430

1431

exit $EXIT_MISMATCH

1432

fi

1433

}

1434

1435

1436

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

1437

case $1 in

1438

clean|clea|cle|cl)

1439

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

1440

;;

1441

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

1442

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

1443

;;

1444

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

1445

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

1446

;;

1447

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

1448

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

1449

;;

1450

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

1451

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

1452

;;

1453

link|lin|li|l)

1454

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

1455

;;

1456

1457

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

1458

;;

1459

esac

1460

1461

1462

1463

# Option defaults:

1464

opt_debug=:

1465

opt_dry_run=false

1466

opt_config=false

1467

opt_preserve_dup_deps=false

1468

opt_features=false

1469

opt_finish=false

1470

opt_help=false

1471

opt_help_all=false

1472

opt_silent=:

1473

opt_warning=:

1474

opt_verbose=:

1475

opt_silent=false

1476

opt_verbose=false

1477

1478

1479

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

1480

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

1481

{

1482

# this just eases exit handling

1483

while test $# -gt 0; do

1484

opt="$1"

1485

shift

1486

case $opt in

1487

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

1488

func_echo "enabling shell trace mode"

1489

$opt_debug

1490

;;

1491

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

1492

opt_dry_run=:

1493

;;

1494

--config)

1495

opt_config=:

1496

func_config

1497

;;

1498

--dlopen|-dlopen)

1499

optarg="$1"

1500

opt_dlopen="${opt_dlopen+$opt_dlopen

1501

}$optarg"

1502

shift

1503

;;

1504

--preserve-dup-deps)

1505

opt_preserve_dup_deps=:

1506

;;

1507

--features)

1508

opt_features=:

1509

func_features

1510

;;

1511

--finish)

1512

opt_finish=:

1513

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

1514

;;

1515

--help)

1516

opt_help=:

1517

;;

1518

--help-all)

1519

opt_help_all=:

1520

opt_help=': help-all'

1521

;;

1522

--mode)

1523

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

1524

optarg="$1"

1525

opt_mode="$optarg"

1526

case $optarg in

1527

# Valid mode arguments:

1528

1529

1530

# Catch anything else as an error

1531

*) func_error "invalid argument for $opt"

1532

exit_cmd=exit

1533

break

1534

;;

1535

esac

1536

shift

1537

;;

1538

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

1539

opt_silent=false

1540

preserve_args+=" $opt"

1541

;;

1542

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

1543

opt_warning=false

1544

preserve_args+=" $opt"

1545

;;

1546

--no-verbose)

1547

opt_verbose=false

1548

preserve_args+=" $opt"

1549

;;

1550

--silent|--quiet)

1551

opt_silent=:

1552

preserve_args+=" $opt"

1553

opt_verbose=false

1554

;;

1555

--verbose|-v)

1556

opt_verbose=:

1557

preserve_args+=" $opt"

1558

opt_silent=false

1559

;;

1560

--tag)

1561

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

1562

optarg="$1"

1563

opt_tag="$optarg"

1564

preserve_args+=" $opt $optarg"

1565

func_enable_tag "$optarg"

1566

shift

1567

;;

1568

1569

-\?|-h) func_usage ;;

1570

--help) func_help ;;

1571

--version) func_version ;;

1572

1573

# Separate optargs to long options:

1574

--*=*)

1575

func_split_long_opt "$opt"

1576

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

1577

shift

1578

;;

1579

1580

# Separate non-argument short options:

1581

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

1582

func_split_short_opt "$opt"

1583

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

1584

shift

1585

;;

1586

1587

--) break ;;

1588

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

1589

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

1590

esac

1591

done

1592

1593

# Validate options:

1594

1595

# save first non-option argument

1596

if test "$#" -gt 0; then

1597

nonopt="$opt"

1598

shift

1599

fi

1600

1601

# preserve --debug

1602

test "$opt_debug" = : || preserve_args+=" --debug"

1603

1604

case $host in

1605

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

1606

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

1607

opt_duplicate_compiler_generated_deps=:

1608

;;

1609

*)

1610

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

1611

;;

1612

esac

1613

1614

$opt_help || {

1615

# Sanity checks first:

1616

func_check_version_match

1617

1618

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

1619

func_fatal_configuration "not configured to build any kind of library"

1620

fi

1621

1622

# Darwin sucks

1623

eval std_shrext=\"$shrext_cmds\"

1624

1625

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

1626

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

1627

func_error "unrecognized option \`-dlopen'"

1628

$ECHO "$help" 1>&2

1629

exit $EXIT_FAILURE

1630

fi

1631

1632

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

1633

generic_help="$help"

1634

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

1635

}

1636

1637

1638

# Bail if the options were screwed

1639

$exit_cmd $EXIT_FAILURE

1640

}

1641

1642

1643

1644

1645

## ----------- ##

1646

## Main. ##

1647

## ----------- ##

1648

1649

# func_lalib_p file

1650

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

1651

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

1652

# determined imposters.

1653

func_lalib_p ()

1654

{

1655

test -f "$1" &&

1656

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

1657

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

1658

}

1659

1660

# func_lalib_unsafe_p file

1661

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

1662

# This function implements the same check as func_lalib_p without

1663

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

1664

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

1665

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

1666

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

1667

func_lalib_unsafe_p ()

1668

{

1669

lalib_p=no

1670

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

1671

for lalib_p_l in 1 2 3 4

1672

do

1673

read lalib_p_line

1674

case "$lalib_p_line" in

1675

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

1676

esac

1677

done

1678

exec 0<&5 5<&-

1679

fi

1680

test "$lalib_p" = yes

1681

}

1682

1683

# func_ltwrapper_script_p file

1684

# True iff FILE is a libtool wrapper script

1685

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

1686

# determined imposters.

1687

func_ltwrapper_script_p ()

1688

{

1689

func_lalib_p "$1"

1690

}

1691

1692

# func_ltwrapper_executable_p file

1693

# True iff FILE is a libtool wrapper executable

1694

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

1695

# determined imposters.

1696

func_ltwrapper_executable_p ()

1697

{

1698

func_ltwrapper_exec_suffix=

1699

case $1 in

1700

*.exe) ;;

1701

*) func_ltwrapper_exec_suffix=.exe ;;

1702

esac

1703

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

1704

}

1705

1706

# func_ltwrapper_scriptname file

1707

# Assumes file is an ltwrapper_executable

1708

# uses $file to determine the appropriate filename for a

1709

# temporary ltwrapper_script.

1710

func_ltwrapper_scriptname ()

1711

{

1712

func_dirname_and_basename "$1" "" "."

1713

func_stripname '' '.exe' "$func_basename_result"

1714

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

1715

}

1716

1717

# func_ltwrapper_p file

1718

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

1719

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

1720

# determined imposters.

1721

func_ltwrapper_p ()

1722

{

1723

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

1724

}

1725

1726

1727

# func_execute_cmds commands fail_cmd

1728

# Execute tilde-delimited COMMANDS.

1729

# If FAIL_CMD is given, eval that upon failure.

1730

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

1731

func_execute_cmds ()

1732

{

1733

$opt_debug

1734

save_ifs=$IFS; IFS='~'

1735

for cmd in $1; do

1736

IFS=$save_ifs

1737

eval cmd=\"$cmd\"

1738

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

1739

done

1740

IFS=$save_ifs

1741

}

1742

1743

1744

# func_source file

1745

# Source FILE, adding directory component if necessary.

1746

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

1747

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

1748

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

1749

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

1750

func_source ()

1751

{

1752

$opt_debug

1753

case $1 in

1754

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

1755

*) . "./$1" ;;

1756

esac

1757

}

1758

1759

1760

# func_resolve_sysroot PATH

1761

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

1762

# func_resolve_sysroot_result

1763

func_resolve_sysroot ()

1764

{

1765

func_resolve_sysroot_result=$1

1766

case $func_resolve_sysroot_result in

1767

=*)

1768

func_stripname '=' '' "$func_resolve_sysroot_result"

1769

func_resolve_sysroot_result=$lt_sysroot$func_stripname_result

1770

;;

1771

esac

1772

}

1773

1774

# func_replace_sysroot PATH

1775

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

1776

# store the result into func_replace_sysroot_result.

1777

func_replace_sysroot ()

1778

{

1779

case "$lt_sysroot:$1" in

1780

?*:"$lt_sysroot"*)

1781

func_stripname "$lt_sysroot" '' "$1"

1782

func_replace_sysroot_result="=$func_stripname_result"

1783

;;

1784

*)

1785

# Including no sysroot.

1786

func_replace_sysroot_result=$1

1787

;;

1788

esac

1789

}

1790

1791

# func_infer_tag arg

1792

# Infer tagged configuration to use if any are available and

1793

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

1794

# Only attempt this if the compiler in the base compile

1795

# command doesn't match the default compiler.

1796

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

1797

func_infer_tag ()

1798

{

1799

$opt_debug

1800

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

1801

CC_quoted=

1802

for arg in $CC; do

1803

func_append_quoted CC_quoted "$arg"

1804

done

1805

CC_expanded=`func_echo_all $CC`

1806

CC_quoted_expanded=`func_echo_all $CC_quoted`

1807

case $@ in

1808

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

1809

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

1810

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

1811

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

1812

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

1813

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

1814

*)

1815

for z in $available_tags; do

1816

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

1817

# Evaluate the configuration.

1818

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

1819

CC_quoted=

1820

for arg in $CC; do

1821

# Double-quote args containing other shell metacharacters.

1822

func_append_quoted CC_quoted "$arg"

1823

done

1824

CC_expanded=`func_echo_all $CC`

1825

CC_quoted_expanded=`func_echo_all $CC_quoted`

1826

case "$@ " in

1827

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

1828

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

1829

# The compiler in the base compile command matches

1830

# the one in the tagged configuration.

1831

# Assume this is the tagged configuration we want.

1832

tagname=$z

1833

break

1834

;;

1835

esac

1836

fi

1837

done

1838

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

1839

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

1840

# line option must be used.

1841

if test -z "$tagname"; then

1842

func_echo "unable to infer tagged configuration"

1843

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

1844

# else

1845

# func_verbose "using $tagname tagged configuration"

1846

fi

1847

;;

1848

esac

1849

fi

1850

}

1851

1852

1853

1854

# func_write_libtool_object output_name pic_name nonpic_name

1855

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

1856

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

1857

func_write_libtool_object ()

1858

{

1859

write_libobj=${1}

1860

if test "$build_libtool_libs" = yes; then

1861

write_lobj=\'${2}\'

1862

else

1863

write_lobj=none

1864

fi

1865

1866

if test "$build_old_libs" = yes; then

1867

write_oldobj=\'${3}\'

1868

else

1869

write_oldobj=none

1870

fi

1871

1872

$opt_dry_run || {

1873

cat >${write_libobj}T <<EOF

1874

# $write_libobj - a libtool object file

1875

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

1876

#

1877

# Please DO NOT delete this file!

1878

# It is necessary for linking the library.

1879

1880

# Name of the PIC object.

1881

pic_object=$write_lobj

1882

1883

# Name of the non-PIC object

1884

non_pic_object=$write_oldobj

1885

1886

EOF

1887

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

1888

}

1889

}

1890

1891

1892

##################################################

1893

# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #

1894

##################################################

1895

1896

# func_convert_core_file_wine_to_w32 ARG

1897

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

1898

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

1899

# correctly configured wine environment available, with the winepath program

1900

# in $build's $PATH.

1901

#

1902

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

1903

# Result is available in $func_convert_core_file_wine_to_w32_result, and will

1904

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

1905

func_convert_core_file_wine_to_w32 ()

1906

{

1907

$opt_debug

1908

func_convert_core_file_wine_to_w32_result="$1"

1909

if test -n "$1"; then

1910

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

1911

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

1912

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

1913

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

1914

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

1915

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

1916

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

1917

func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |

1918

$SED -e "$lt_sed_naive_backslashify"`

1919

else

1920

func_convert_core_file_wine_to_w32_result=

1921

fi

1922

fi

1923

}

1924

# end: func_convert_core_file_wine_to_w32

1925

1926

1927

# func_convert_core_path_wine_to_w32 ARG

1928

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

1929

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

1930

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

1931

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

1932

#

1933

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

1934

# Result is available in $func_convert_core_path_wine_to_w32_result.

1935

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

1936

# are convertible, then the result may be empty.

1937

func_convert_core_path_wine_to_w32 ()

1938

{

1939

$opt_debug

1940

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

1941

func_convert_core_path_wine_to_w32_result=""

1942

if test -n "$1"; then

1943

oldIFS=$IFS

1944

IFS=:

1945

for func_convert_core_path_wine_to_w32_f in $1; do

1946

IFS=$oldIFS

1947

func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"

1948

if test -n "$func_convert_core_file_wine_to_w32_result" ; then

1949

if test -z "$func_convert_core_path_wine_to_w32_result"; then

1950

func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"

1951

else

1952

func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"

1953

fi

1954

fi

1955

done

1956

IFS=$oldIFS

1957

fi

1958

}

1959

# end: func_convert_core_path_wine_to_w32

1960

1961

1962

# func_cygpath ARGS...

1963

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

1964

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

1965

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

1966

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

1967

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

1968

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

1969

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

1970

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

1971

#

1972

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

1973

# be converted.

1974

#

1975

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

1976

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

1977

func_cygpath ()

1978

{

1979

$opt_debug

1980

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

1981

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

1982

if test "$?" -ne 0; then

1983

# on failure, ensure result is empty

1984

func_cygpath_result=

1985

fi

1986

else

1987

func_cygpath_result=

1988

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

1989

fi

1990

}

1991

#end: func_cygpath

1992

1993

1994

# func_convert_core_msys_to_w32 ARG

1995

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

1996

# result in func_convert_core_msys_to_w32_result.

1997

func_convert_core_msys_to_w32 ()

1998

{

1999

$opt_debug

2000

# awkward: cmd appends spaces to result

2001

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

2002

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

2003

}

2004

#end: func_convert_core_msys_to_w32

2005

2006

2007

# func_convert_file_check ARG1 ARG2

2008

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

2009

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

2010

# func_to_host_file_result to ARG1).

2011

func_convert_file_check ()

2012

{

2013

$opt_debug

2014

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

2015

func_error "Could not determine host file name corresponding to"

2016

func_error " \`$1'"

2017

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

2018

# Fallback:

2019

func_to_host_file_result="$1"

2020

fi

2021

}

2022

# end func_convert_file_check

2023

2024

2025

# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH

2026

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

2027

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

2028

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

2029

func_convert_path_check ()

2030

{

2031

$opt_debug

2032

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

2033

func_error "Could not determine the host path corresponding to"

2034

func_error " \`$3'"

2035

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

2036

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

2037

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

2038

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

2039

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

2040

func_to_host_path_result=`echo "$3" |

2041

$SED -e "$lt_replace_pathsep_chars"`

2042

else

2043

func_to_host_path_result="$3"

2044

fi

2045

fi

2046

}

2047

# end func_convert_path_check

2048

2049

2050

# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG

2051

# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT

2052

# and appending REPL if ORIG matches BACKPAT.

2053

func_convert_path_front_back_pathsep ()

2054

{

2055

$opt_debug

2056

case $4 in

2057

$1 ) func_to_host_path_result="$3$func_to_host_path_result"

2058

;;

2059

esac

2060

case $4 in

2061

$2 ) func_to_host_path_result+="$3"

2062

;;

2063

esac

2064

}

2065

# end func_convert_path_front_back_pathsep

2066

2067

2068

##################################################

2069

# $build to $host FILE NAME CONVERSION FUNCTIONS #

2070

##################################################

2071

# invoked via `$to_host_file_cmd ARG'

2072

#

2073

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

2074

# Result will be available in $func_to_host_file_result.

2075

2076

2077

# func_to_host_file ARG

2078

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

2079

# in func_to_host_file_result.

2080

func_to_host_file ()

2081

{

2082

$opt_debug

2083

$to_host_file_cmd "$1"

2084

}

2085

# end func_to_host_file

2086

2087

2088

# func_to_tool_file ARG LAZY

2089

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

2090

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

2091

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

2092

func_to_tool_file ()

2093

{

2094

$opt_debug

2095

case ,$2, in

2096

*,"$to_tool_file_cmd",*)

2097

func_to_tool_file_result=$1

2098

;;

2099

*)

2100

$to_tool_file_cmd "$1"

2101

func_to_tool_file_result=$func_to_host_file_result

2102

;;

2103

esac

2104

}

2105

# end func_to_tool_file

2106

2107

2108

# func_convert_file_noop ARG

2109

# Copy ARG to func_to_host_file_result.

2110

func_convert_file_noop ()

2111

{

2112

func_to_host_file_result="$1"

2113

}

2114

# end func_convert_file_noop

2115

2116

2117

# func_convert_file_msys_to_w32 ARG

2118

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

2119

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

2120

# func_to_host_file_result.

2121

func_convert_file_msys_to_w32 ()

2122

{

2123

$opt_debug

2124

func_to_host_file_result="$1"

2125

if test -n "$1"; then

2126

func_convert_core_msys_to_w32 "$1"

2127

func_to_host_file_result="$func_convert_core_msys_to_w32_result"

2128

fi

2129

func_convert_file_check "$1" "$func_to_host_file_result"

2130

}

2131

# end func_convert_file_msys_to_w32

2132

2133

2134

# func_convert_file_cygwin_to_w32 ARG

2135

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

2136

# func_to_host_file_result.

2137

func_convert_file_cygwin_to_w32 ()

2138

{

2139

$opt_debug

2140

func_to_host_file_result="$1"

2141

if test -n "$1"; then

2142

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

2143

# LT_CYGPATH in this case.

2144

func_to_host_file_result=`cygpath -m "$1"`

2145

fi

2146

func_convert_file_check "$1" "$func_to_host_file_result"

2147

}

2148

# end func_convert_file_cygwin_to_w32

2149

2150

2151

# func_convert_file_nix_to_w32 ARG

2152

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

2153

# and a working winepath. Returns result in func_to_host_file_result.

2154

func_convert_file_nix_to_w32 ()

2155

{

2156

$opt_debug

2157

func_to_host_file_result="$1"

2158

if test -n "$1"; then

2159

func_convert_core_file_wine_to_w32 "$1"

2160

func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

2161

fi

2162

func_convert_file_check "$1" "$func_to_host_file_result"

2163

}

2164

# end func_convert_file_nix_to_w32

2165

2166

2167

# func_convert_file_msys_to_cygwin ARG

2168

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

2169

# Returns result in func_to_host_file_result.

2170

func_convert_file_msys_to_cygwin ()

2171

{

2172

$opt_debug

2173

func_to_host_file_result="$1"

2174

if test -n "$1"; then

2175

func_convert_core_msys_to_w32 "$1"

2176

func_cygpath -u "$func_convert_core_msys_to_w32_result"

2177

func_to_host_file_result="$func_cygpath_result"

2178

fi

2179

func_convert_file_check "$1" "$func_to_host_file_result"

2180

}

2181

# end func_convert_file_msys_to_cygwin

2182

2183

2184

# func_convert_file_nix_to_cygwin ARG

2185

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

2186

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

2187

# in func_to_host_file_result.

2188

func_convert_file_nix_to_cygwin ()

2189

{

2190

$opt_debug

2191

func_to_host_file_result="$1"

2192

if test -n "$1"; then

2193

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

2194

func_convert_core_file_wine_to_w32 "$1"

2195

func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

2196

func_to_host_file_result="$func_cygpath_result"

2197

fi

2198

func_convert_file_check "$1" "$func_to_host_file_result"

2199

}

2200

# end func_convert_file_nix_to_cygwin

2201

2202

2203

#############################################

2204

# $build to $host PATH CONVERSION FUNCTIONS #

2205

#############################################

2206

# invoked via `$to_host_path_cmd ARG'

2207

#

2208

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

2209

# The result will be available in $func_to_host_path_result.

2210

#

2211

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

2212

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

2213

# converted to $host format) on output.

2214

#

2215

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

2216

# file name conversion function : func_convert_file_X_to_Y ()

2217

# path conversion function : func_convert_path_X_to_Y ()

2218

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

2219

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

2220

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

2221

# will break.

2222

2223

2224

# func_init_to_host_path_cmd

2225

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

2226

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

2227

to_host_path_cmd=

2228

func_init_to_host_path_cmd ()

2229

{

2230

$opt_debug

2231

if test -z "$to_host_path_cmd"; then

2232

func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

2233

to_host_path_cmd="func_convert_path_${func_stripname_result}"

2234

fi

2235

}

2236

2237

2238

# func_to_host_path ARG

2239

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

2240

# in func_to_host_path_result.

2241

func_to_host_path ()

2242

{

2243

$opt_debug

2244

func_init_to_host_path_cmd

2245

$to_host_path_cmd "$1"

2246

}

2247

# end func_to_host_path

2248

2249

2250

# func_convert_path_noop ARG

2251

# Copy ARG to func_to_host_path_result.

2252

func_convert_path_noop ()

2253

{

2254

func_to_host_path_result="$1"

2255

}

2256

# end func_convert_path_noop

2257

2258

2259

# func_convert_path_msys_to_w32 ARG

2260

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

2261

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

2262

# func_to_host_path_result.

2263

func_convert_path_msys_to_w32 ()

2264

{

2265

$opt_debug

2266

func_to_host_path_result="$1"

2267

if test -n "$1"; then

2268

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

2269

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

2270

# and winepath ignores them completely.

2271

func_stripname : : "$1"

2272

func_to_host_path_tmp1=$func_stripname_result

2273

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

2274

func_to_host_path_result="$func_convert_core_msys_to_w32_result"

2275

func_convert_path_check : ";" \

2276

"$func_to_host_path_tmp1" "$func_to_host_path_result"

2277

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

2278

fi

2279

}

2280

# end func_convert_path_msys_to_w32

2281

2282

2283

# func_convert_path_cygwin_to_w32 ARG

2284

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

2285

# func_to_host_file_result.

2286

func_convert_path_cygwin_to_w32 ()

2287

{

2288

$opt_debug

2289

func_to_host_path_result="$1"

2290

if test -n "$1"; then

2291

# See func_convert_path_msys_to_w32:

2292

func_stripname : : "$1"

2293

func_to_host_path_tmp1=$func_stripname_result

2294

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

2295

func_convert_path_check : ";" \

2296

"$func_to_host_path_tmp1" "$func_to_host_path_result"

2297

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

2298

fi

2299

}

2300

# end func_convert_path_cygwin_to_w32

2301

2302

2303

# func_convert_path_nix_to_w32 ARG

2304

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

2305

# a working winepath. Returns result in func_to_host_file_result.

2306

func_convert_path_nix_to_w32 ()

2307

{

2308

$opt_debug

2309

func_to_host_path_result="$1"

2310

if test -n "$1"; then

2311

# See func_convert_path_msys_to_w32:

2312

func_stripname : : "$1"

2313

func_to_host_path_tmp1=$func_stripname_result

2314

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

2315

func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

2316

func_convert_path_check : ";" \

2317

"$func_to_host_path_tmp1" "$func_to_host_path_result"

2318

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

2319

fi

2320

}

2321

# end func_convert_path_nix_to_w32

2322

2323

2324

# func_convert_path_msys_to_cygwin ARG

2325

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

2326

# Returns result in func_to_host_file_result.

2327

func_convert_path_msys_to_cygwin ()

2328

{

2329

$opt_debug

2330

func_to_host_path_result="$1"

2331

if test -n "$1"; then

2332

# See func_convert_path_msys_to_w32:

2333

func_stripname : : "$1"

2334

func_to_host_path_tmp1=$func_stripname_result

2335

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

2336

func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

2337

func_to_host_path_result="$func_cygpath_result"

2338

func_convert_path_check : : \

2339

"$func_to_host_path_tmp1" "$func_to_host_path_result"

2340

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

2341

fi

2342

}

2343

# end func_convert_path_msys_to_cygwin

2344

2345

2346

# func_convert_path_nix_to_cygwin ARG

2347

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

2348

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

2349

# func_to_host_file_result.

2350

func_convert_path_nix_to_cygwin ()

2351

{

2352

$opt_debug

2353

func_to_host_path_result="$1"

2354

if test -n "$1"; then

2355

# Remove leading and trailing path separator characters from

2356

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

2357

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

2358

func_stripname : : "$1"

2359

func_to_host_path_tmp1=$func_stripname_result

2360

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

2361

func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

2362

func_to_host_path_result="$func_cygpath_result"

2363

func_convert_path_check : : \

2364

"$func_to_host_path_tmp1" "$func_to_host_path_result"

2365

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

2366

fi

2367

}

2368

# end func_convert_path_nix_to_cygwin

2369

2370

2371

# func_mode_compile arg...

2372

func_mode_compile ()

2373

{

2374

$opt_debug

2375

# Get the compilation command and the source file.

2376

base_compile=

2377

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

2378

suppress_opt=yes

2379

suppress_output=

2380

arg_mode=normal

2381

libobj=

2382

later=

2383

pie_flag=

2384

2385

for arg

2386

do

2387

case $arg_mode in

2388

arg )

2389

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

2390

lastarg="$arg"

2391

arg_mode=normal

2392

;;

2393

2394

target )

2395

libobj="$arg"

2396

arg_mode=normal

2397

continue

2398

;;

2399

2400

normal )

2401

# Accept any command-line options.

2402

case $arg in

2403

-o)

2404

test -n "$libobj" && \

2405

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

2406

arg_mode=target

2407

continue

2408

;;

2409

2410

-pie | -fpie | -fPIE)

2411

pie_flag+=" $arg"

2412

continue

2413

;;

2414

2415

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

2416

later+=" $arg"

2417

continue

2418

;;

2419

2420

-no-suppress)

2421

suppress_opt=no

2422

continue

2423

;;

2424

2425

-Xcompiler)

2426

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

2427

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

2428

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

2429

2430

-Wc,*)

2431

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

2432

args=$func_stripname_result

2433

lastarg=

2434

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

2435

for arg in $args; do

2436

IFS="$save_ifs"

2437

func_append_quoted lastarg "$arg"

2438

done

2439

IFS="$save_ifs"

2440

func_stripname ' ' '' "$lastarg"

2441

lastarg=$func_stripname_result

2442

2443

# Add the arguments to base_compile.

2444

base_compile+=" $lastarg"

2445

continue

2446

;;

2447

2448

*)

2449

# Accept the current argument as the source file.

2450

# The previous "srcfile" becomes the current argument.

2451

#

2452

lastarg="$srcfile"

2453

srcfile="$arg"

2454

;;

2455

esac # case $arg

2456

;;

2457

esac # case $arg_mode

2458

2459

# Aesthetically quote the previous argument.

2460

func_append_quoted base_compile "$lastarg"

2461

done # for arg

2462

2463

case $arg_mode in

2464

arg)

2465

func_fatal_error "you must specify an argument for -Xcompile"

2466

;;

2467

target)

2468

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

2469

;;

2470

*)

2471

# Get the name of the library object.

2472

test -z "$libobj" && {

2473

func_basename "$srcfile"

2474

libobj="$func_basename_result"

2475

}

2476

;;

2477

esac

2478

2479

# Recognize several different file suffixes.

2480

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

2481

case $libobj in

2482

*.[cCFSifmso] | \

2483

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

2484

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

2485

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

2486

func_xform "$libobj"

2487

libobj=$func_xform_result

2488

;;

2489

esac

2490

2491

case $libobj in

2492

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

2493

*)

2494

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

2495

;;

2496

esac

2497

2498

func_infer_tag $base_compile

2499

2500

for arg in $later; do

2501

case $arg in

2502

-shared)

2503

test "$build_libtool_libs" != yes && \

2504

func_fatal_configuration "can not build a shared library"

2505

build_old_libs=no

2506

continue

2507

;;

2508

2509

-static)

2510

build_libtool_libs=no

2511

build_old_libs=yes

2512

continue

2513

;;

2514

2515

-prefer-pic)

2516

pic_mode=yes

2517

continue

2518

;;

2519

2520

-prefer-non-pic)

2521

pic_mode=no

2522

continue

2523

;;

2524

esac

2525

done

2526

2527

func_quote_for_eval "$libobj"

2528

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

2529

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

2530

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

2531

func_dirname_and_basename "$obj" "/" ""

2532

objname="$func_basename_result"

2533

xdir="$func_dirname_result"

2534

lobj=${xdir}$objdir/$objname

2535

2536

test -z "$base_compile" && \

2537

func_fatal_help "you must specify a compilation command"

2538

2539

# Delete any leftover library objects.

2540

if test "$build_old_libs" = yes; then

2541

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

2542

else

2543

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

2544

fi

2545

2546

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

2547

case $host_os in

2548

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

2549

pic_mode=default

2550

;;

2551

esac

2552

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

2553

# non-PIC code in shared libraries is not supported

2554

pic_mode=default

2555

fi

2556

2557

# Calculate the filename of the output object if compiler does

2558

# not support -o with -c

2559

if test "$compiler_c_o" = no; then

2560

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

2561

lockfile="$output_obj.lock"

2562

else

2563

output_obj=

2564

need_locks=no

2565

lockfile=

2566

fi

2567

2568

# Lock this critical section if it is needed

2569

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

2570

if test "$need_locks" = yes; then

2571

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

2572

func_echo "Waiting for $lockfile to be removed"

2573

sleep 2

2574

done

2575

elif test "$need_locks" = warn; then

2576

if test -f "$lockfile"; then

2577

$ECHO "\

2578

*** ERROR, $lockfile exists and contains:

2579

`cat $lockfile 2>/dev/null`

2580

2581

This indicates that another process is trying to use the same

2582

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

2583

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

2584

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

2585

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

2586

compiler."

2587

2588

$opt_dry_run || $RM $removelist

2589

exit $EXIT_FAILURE

2590

fi

2591

removelist+=" $output_obj"

2592

$ECHO "$srcfile" > "$lockfile"

2593

fi

2594

2595

$opt_dry_run || $RM $removelist

2596

removelist+=" $lockfile"

2597

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

2598

2599

func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2600

srcfile=$func_to_tool_file_result

2601

func_quote_for_eval "$srcfile"

2602

qsrcfile=$func_quote_for_eval_result

2603

2604

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

2605

if test "$build_libtool_libs" = yes; then

2606

# Without this assignment, base_compile gets emptied.

2607

fbsd_hideous_sh_bug=$base_compile

2608

2609

if test "$pic_mode" != no; then

2610

command="$base_compile $qsrcfile $pic_flag"

2611

else

2612

# Don't build PIC code

2613

command="$base_compile $qsrcfile"

2614

fi

2615

2616

func_mkdir_p "$xdir$objdir"

2617

2618

if test -z "$output_obj"; then

2619

# Place PIC objects in $objdir

2620

command+=" -o $lobj"

2621

fi

2622

2623

func_show_eval_locale "$command" \

2624

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

2625

2626

if test "$need_locks" = warn &&

2627

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

2628

$ECHO "\

2629

*** ERROR, $lockfile contains:

2630

`cat $lockfile 2>/dev/null`

2631

2632

but it should contain:

2633

$srcfile

2634

2635

This indicates that another process is trying to use the same

2636

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

2637

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

2638

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

2639

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

2640

compiler."

2641

2642

$opt_dry_run || $RM $removelist

2643

exit $EXIT_FAILURE

2644

fi

2645

2646

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

2647

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

2648

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

2649

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

2650

fi

2651

2652

# Allow error messages only from the first compilation.

2653

if test "$suppress_opt" = yes; then

2654

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

2655

fi

2656

fi

2657

2658

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

2659

if test "$build_old_libs" = yes; then

2660

if test "$pic_mode" != yes; then

2661

# Don't build PIC code

2662

command="$base_compile $qsrcfile$pie_flag"

2663

else

2664

command="$base_compile $qsrcfile $pic_flag"

2665

fi

2666

if test "$compiler_c_o" = yes; then

2667

command+=" -o $obj"

2668

fi

2669

2670

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

2671

command+="$suppress_output"

2672

func_show_eval_locale "$command" \

2673

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

2674

2675

if test "$need_locks" = warn &&

2676

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

2677

$ECHO "\

2678

*** ERROR, $lockfile contains:

2679

`cat $lockfile 2>/dev/null`

2680

2681

but it should contain:

2682

$srcfile

2683

2684

This indicates that another process is trying to use the same

2685

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

2686

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

2687

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

2688

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

2689

compiler."

2690

2691

$opt_dry_run || $RM $removelist

2692

exit $EXIT_FAILURE

2693

fi

2694

2695

# Just move the object if needed

2696

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

2697

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

2698

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

2699

fi

2700

fi

2701

2702

$opt_dry_run || {

2703

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

2704

2705

# Unlock the critical section if it was locked

2706

if test "$need_locks" != no; then

2707

removelist=$lockfile

2708

$RM "$lockfile"

2709

fi

2710

}

2711

2712

exit $EXIT_SUCCESS

2713

}

2714

2715

$opt_help || {

2716

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

2717

}

2718

2719

func_mode_help ()

2720

{

2721

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

2722

case $opt_mode in

2723

"")

2724

# Generic help is extracted from the usage comments

2725

# at the start of this file.

2726

func_help

2727

;;

2728

2729

clean)

2730

$ECHO \

2731

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

2732

2733

Remove files from the build directory.

2734

2735

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

2736

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

2737

to RM.

2738

2739

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

2740

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

2741

;;

2742

2743

compile)

2744

$ECHO \

2745

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

2746

2747

Compile a source file into a libtool library object.

2748

2749

This mode accepts the following additional options:

2750

2751

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

2752

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

2753

-prefer-pic try to build PIC objects only

2754

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

2755

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

2756

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

2757

-Wc,FLAG pass FLAG directly to the compiler

2758

2759

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

2760

from the given SOURCEFILE.

2761

2762

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

2763

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

2764

library object suffix, \`.lo'."

2765

;;

2766

2767

execute)

2768

$ECHO \

2769

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

2770

2771

Automatically set library path, then run a program.

2772

2773

This mode accepts the following additional options:

2774

2775

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

2776

2777

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

2778

flags.

2779

2780

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

2781

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

2782

directories are added to the library path.

2783

2784

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

2785

;;

2786

2787

finish)

2788

$ECHO \

2789

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

2790

2791

Complete the installation of libtool libraries.

2792

2793

Each LIBDIR is a directory that contains libtool libraries.

2794

2795

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

2796

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

2797

;;

2798

2799

install)

2800

$ECHO \

2801

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

2802

2803

Install executables or libraries.

2804

2805

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

2806

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

2807

2808

The following components of INSTALL-COMMAND are treated specially:

2809

2810

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

2811

2812

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

2813

BSD-compatible install options are recognized)."

2814

;;

2815

2816

link)

2817

$ECHO \

2818

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

2819

2820

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

2821

create an executable program.

2822

2823

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

2824

a program from several object files.

2825

2826

The following components of LINK-COMMAND are treated specially:

2827

2828

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

2829

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

2830

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

2831

libraries must be found in the PATH setting at runtime)

2832

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

2833

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

2834

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

2835

-export-symbols SYMFILE

2836

try to export only the symbols listed in SYMFILE

2837

-export-symbols-regex REGEX

2838

try to export only the symbols matching REGEX

2839

-LLIBDIR search LIBDIR for required installed libraries

2840

-lNAME OUTPUT-FILE requires the installed library libNAME

2841

-module build a library that can dlopened

2842

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

2843

-no-install link a not-installable executable

2844

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

2845

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

2846

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

2847

-precious-files-regex REGEX

2848

don't remove output files matching REGEX

2849

-release RELEASE specify package release information

2850

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

2851

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

2852

-shared only do dynamic linking of libtool libraries

2853

-shrext SUFFIX override the standard shared library file extension

2854

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

2855

-static-libtool-libs

2856

do not do any dynamic linking of libtool libraries

2857

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

2858

specify library version info [each variable defaults to 0]

2859

-weak LIBNAME declare that the target provides the LIBNAME interface

2860

-Wc,FLAG

2861

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

2862

-Wl,FLAG

2863

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

2864

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

2865

2866

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

2867

2868

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

2869

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

2870

object files.

2871

2872

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

2873

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

2874

required, except when creating a convenience library.

2875

2876

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

2877

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

2878

2879

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

2880

is created, otherwise an executable program is created."

2881

;;

2882

2883

uninstall)

2884

$ECHO \

2885

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

2886

2887

Remove libraries from an installation directory.

2888

2889

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

2890

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

2891

to RM.

2892

2893

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

2894

Otherwise, only FILE itself is deleted using RM."

2895

;;

2896

2897

*)

2898

func_fatal_help "invalid operation mode \`$opt_mode'"

2899

;;

2900

esac

2901

2902

echo

2903

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

2904

}

2905

2906

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

2907

if $opt_help; then

2908

if test "$opt_help" = :; then

2909

func_mode_help

2910

else

2911

{

2912

func_help noexit

2913

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

2914

func_mode_help

2915

done

2916

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

2917

{

2918

func_help noexit

2919

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

2920

echo

2921

func_mode_help

2922

done

2923

} |

2924

sed '1d

2925

/^When reporting/,/^Report/{

2926

H

2927

d

2928

}

2929

$x

2930

/information about other modes/d

2931

/more detailed .*MODE/d

2932

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

2933

fi

2934

exit $?

2935

fi

2936

2937

2938

# func_mode_execute arg...

2939

func_mode_execute ()

2940

{

2941

$opt_debug

2942

# The first argument is the command name.

2943

cmd="$nonopt"

2944

test -z "$cmd" && \

2945

func_fatal_help "you must specify a COMMAND"

2946

2947

# Handle -dlopen flags immediately.

2948

for file in $opt_dlopen; do

2949

test -f "$file" \

2950

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

2951

2952

dir=

2953

case $file in

2954

*.la)

2955

func_resolve_sysroot "$file"

2956

file=$func_resolve_sysroot_result

2957

2958

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

2959

func_lalib_unsafe_p "$file" \

2960

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

2961

2962

# Read the libtool library.

2963

dlname=

2964

library_names=

2965

func_source "$file"

2966

2967

# Skip this library if it cannot be dlopened.

2968

if test -z "$dlname"; then

2969

# Warn if it was a shared library.

2970

test -n "$library_names" && \

2971

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

2972

continue

2973

fi

2974

2975

func_dirname "$file" "" "."

2976

dir="$func_dirname_result"

2977

2978

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

2979

dir+="/$objdir"

2980

else

2981

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

2982

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

2983

fi

2984

fi

2985

;;

2986

2987

*.lo)

2988

# Just add the directory containing the .lo file.

2989

func_dirname "$file" "" "."

2990

dir="$func_dirname_result"

2991

;;

2992

2993

*)

2994

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

2995

continue

2996

;;

2997

esac

2998

2999

# Get the absolute pathname.

3000

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

3001

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

3002

3003

# Now add the directory to shlibpath_var.

3004

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

3005

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

3006

else

3007

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

3008

fi

3009

done

3010

3011

# This variable tells wrapper scripts just to set shlibpath_var

3012

# rather than running their programs.

3013

libtool_execute_magic="$magic"

3014

3015

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

3016

args=

3017

for file

3018

do

3019

case $file in

3020

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

3021

*)

3022

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

3023

if func_ltwrapper_script_p "$file"; then

3024

func_source "$file"

3025

# Transform arg to wrapped name.

3026

file="$progdir/$program"

3027

elif func_ltwrapper_executable_p "$file"; then

3028

func_ltwrapper_scriptname "$file"

3029

func_source "$func_ltwrapper_scriptname_result"

3030

# Transform arg to wrapped name.

3031

file="$progdir/$program"

3032

fi

3033

;;

3034

esac

3035

# Quote arguments (to preserve shell metacharacters).

3036

func_append_quoted args "$file"

3037

done

3038

3039

if test "X$opt_dry_run" = Xfalse; then

3040

if test -n "$shlibpath_var"; then

3041

# Export the shlibpath_var.

3042

eval "export $shlibpath_var"

3043

fi

3044

3045

# Restore saved environment variables

3046

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

3047

do

3048

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

3049

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

3050

else

3051

$lt_unset $lt_var

3052

fi"

3053

done

3054

3055

# Now prepare to actually exec the command.

3056

exec_cmd="\$cmd$args"

3057

else

3058

# Display what would be done.

3059

if test -n "$shlibpath_var"; then

3060

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

3061

echo "export $shlibpath_var"

3062

fi

3063

$ECHO "$cmd$args"

3064

exit $EXIT_SUCCESS

3065

fi

3066

}

3067

3068

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

3069

3070

3071

# func_mode_finish arg...

3072

func_mode_finish ()

3073

{

3074

$opt_debug

3075

libs=

3076

libdirs=

3077

admincmds=

3078

3079

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

3080

do

3081

if test -d "$opt"; then

3082

libdirs+=" $opt"

3083

3084

elif test -f "$opt"; then

3085

if func_lalib_unsafe_p "$opt"; then

3086

libs+=" $opt"

3087

else

3088

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

3089

fi

3090

3091

else

3092

func_fatal_error "invalid argument \`$opt'"

3093

fi

3094

done

3095

3096

if test -n "$libs"; then

3097

if test -n "$lt_sysroot"; then

3098

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

3099

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

3100

else

3101

sysroot_cmd=

3102

fi

3103

3104

# Remove sysroot references

3105

if $opt_dry_run; then

3106

for lib in $libs; do

3107

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

3108

done

3109

else

3110

tmpdir=`func_mktempdir`

3111

for lib in $libs; do

3112

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

3113

> $tmpdir/tmp-la

3114

mv -f $tmpdir/tmp-la $lib

3115

done

3116

${RM}r "$tmpdir"

3117

fi

3118

fi

3119

3120

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

3121

for libdir in $libdirs; do

3122

if test -n "$finish_cmds"; then

3123

# Do each command in the finish commands.

3124

func_execute_cmds "$finish_cmds" 'admincmds="$admincmds

3125

'"$cmd"'"'

3126

fi

3127

if test -n "$finish_eval"; then

3128

# Do the single finish_eval.

3129

eval cmds=\"$finish_eval\"

3130

$opt_dry_run || eval "$cmds" || admincmds+="

3131

$cmds"

3132

fi

3133

done

3134

fi

3135

3136

# Exit here if they wanted silent mode.

3137

$opt_silent && exit $EXIT_SUCCESS

3138

3139

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

3140

echo "----------------------------------------------------------------------"

3141

echo "Libraries have been installed in:"

3142

for libdir in $libdirs; do

3143

$ECHO " $libdir"

3144

done

3145

echo

3146

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

3147

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

3148

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

3149

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

3150

if test -n "$shlibpath_var"; then

3151

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

3152

echo " during execution"

3153

fi

3154

if test -n "$runpath_var"; then

3155

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

3156

echo " during linking"

3157

fi

3158

if test -n "$hardcode_libdir_flag_spec"; then

3159

libdir=LIBDIR

3160

eval flag=\"$hardcode_libdir_flag_spec\"

3161

3162

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

3163

fi

3164

if test -n "$admincmds"; then

3165

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

3166

fi

3167

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

3168

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

3169

fi

3170

echo

3171

3172

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

3173

case $host in

3174

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

3175

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

3176

echo "pages."

3177

;;

3178

*)

3179

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

3180

;;

3181

esac

3182

echo "----------------------------------------------------------------------"

3183

fi

3184

exit $EXIT_SUCCESS

3185

}

3186

3187

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

3188

3189

3190

# func_mode_install arg...

3191

func_mode_install ()

3192

{

3193

$opt_debug

3194

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

3195

# install_prog (especially on Windows NT).

3196

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

3197

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

3198

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

3199

# Aesthetically quote it.

3200

func_quote_for_eval "$nonopt"

3201

install_prog="$func_quote_for_eval_result "

3202

arg=$1

3203

shift

3204

else

3205

install_prog=

3206

arg=$nonopt

3207

fi

3208

3209

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

3210

# Aesthetically quote it.

3211

func_quote_for_eval "$arg"

3212

install_prog+="$func_quote_for_eval_result"

3213

install_shared_prog=$install_prog

3214

case " $install_prog " in

3215

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

3216

*) install_cp=false ;;

3217

esac

3218

3219

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

3220

dest=

3221

files=

3222

opts=

3223

prev=

3224

install_type=

3225

isdir=no

3226

stripme=

3227

no_mode=:

3228

for arg

3229

do

3230

arg2=

3231

if test -n "$dest"; then

3232

files+=" $dest"

3233

dest=$arg

3234

continue

3235

fi

3236

3237

case $arg in

3238

-d) isdir=yes ;;

3239

-f)

3240

if $install_cp; then :; else

3241

prev=$arg

3242

fi

3243

;;

3244

-g | -m | -o)

3245

prev=$arg

3246

;;

3247

-s)

3248

stripme=" -s"

3249

continue

3250

;;

3251

-*)

3252

;;

3253

*)

3254

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

3255

if test -n "$prev"; then

3256

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

3257

arg2=$install_override_mode

3258

no_mode=false

3259

fi

3260

prev=

3261

else

3262

dest=$arg

3263

continue

3264

fi

3265

;;

3266

esac

3267

3268

# Aesthetically quote the argument.

3269

func_quote_for_eval "$arg"

3270

install_prog+=" $func_quote_for_eval_result"

3271

if test -n "$arg2"; then

3272

func_quote_for_eval "$arg2"

3273

fi

3274

install_shared_prog+=" $func_quote_for_eval_result"

3275

done

3276

3277

test -z "$install_prog" && \

3278

func_fatal_help "you must specify an install program"

3279

3280

test -n "$prev" && \

3281

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

3282

3283

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

3284

if $install_cp; then :; else

3285

func_quote_for_eval "$install_override_mode"

3286

install_shared_prog+=" -m $func_quote_for_eval_result"

3287

fi

3288

fi

3289

3290

if test -z "$files"; then

3291

if test -z "$dest"; then

3292

func_fatal_help "no file or destination specified"

3293

else

3294

func_fatal_help "you must specify a destination"

3295

fi

3296

fi

3297

3298

# Strip any trailing slash from the destination.

3299

func_stripname '' '/' "$dest"

3300

dest=$func_stripname_result

3301

3302

# Check to see that the destination is a directory.

3303

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

3304

if test "$isdir" = yes; then

3305

destdir="$dest"

3306

destname=

3307

else

3308

func_dirname_and_basename "$dest" "" "."

3309

destdir="$func_dirname_result"

3310

destname="$func_basename_result"

3311

3312

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

3313

set dummy $files; shift

3314

test "$#" -gt 1 && \

3315

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

3316

fi

3317

case $destdir in

3318

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

3319

*)

3320

for file in $files; do

3321

case $file in

3322

*.lo) ;;

3323

*)

3324

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

3325

;;

3326

esac

3327

done

3328

;;

3329

esac

3330

3331

# This variable tells wrapper scripts just to set variables rather

3332

# than running their programs.

3333

libtool_install_magic="$magic"

3334

3335

staticlibs=

3336

future_libdirs=

3337

current_libdirs=

3338

for file in $files; do

3339

3340

# Do each installation.

3341

case $file in

3342

*.$libext)

3343

# Do the static libraries later.

3344

staticlibs+=" $file"

3345

;;

3346

3347

*.la)

3348

func_resolve_sysroot "$file"

3349

file=$func_resolve_sysroot_result

3350

3351

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

3352

func_lalib_unsafe_p "$file" \

3353

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

3354

3355

library_names=

3356

old_library=

3357

relink_command=

3358

func_source "$file"

3359

3360

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

3361

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

3362

case "$current_libdirs " in

3363

*" $libdir "*) ;;

3364

*) current_libdirs+=" $libdir" ;;

3365

esac

3366

else

3367

# Note the libdir as a future libdir.

3368

case "$future_libdirs " in

3369

*" $libdir "*) ;;

3370

*) future_libdirs+=" $libdir" ;;

3371

esac

3372

fi

3373

3374

func_dirname "$file" "/" ""

3375

dir="$func_dirname_result"

3376

dir+="$objdir"

3377

3378

if test -n "$relink_command"; then

3379

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

3380

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

3381

3382

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

3383

# location b/c this prevents finding dependent libraries that

3384

# are installed to the same prefix.

3385

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

3386

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

3387

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

3388

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

3389

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

3390

3391

if test -n "$inst_prefix_dir"; then

3392

# Stick the inst_prefix_dir data into the link command.

3393

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

3394

else

3395

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

3396

fi

3397

3398

func_warning "relinking \`$file'"

3399

func_show_eval "$relink_command" \

3400

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

3401

fi

3402

3403

# See the names of the shared library.

3404

set dummy $library_names; shift

3405

if test -n "$1"; then

3406

realname="$1"

3407

shift

3408

3409

srcname="$realname"

3410

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

3411

3412

# Install the shared library and build the symlinks.

3413

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

3414

'exit $?'

3415

tstripme="$stripme"

3416

case $host_os in

3417

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

3418

case $realname in

3419

*.dll.a)

3420

tstripme=""

3421

;;

3422

esac

3423

;;

3424

esac

3425

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

3426

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

3427

fi

3428

3429

if test "$#" -gt 0; then

3430

# Delete the old symlinks, and create new ones.

3431

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

3432

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

3433

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

3434

for linkname

3435

do

3436

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

3437

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

3438

done

3439

fi

3440

3441

# Do each command in the postinstall commands.

3442

lib="$destdir/$realname"

3443

func_execute_cmds "$postinstall_cmds" 'exit $?'

3444

fi

3445

3446

# Install the pseudo-library for information purposes.

3447

func_basename "$file"

3448

name="$func_basename_result"

3449

instname="$dir/$name"i

3450

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

3451

3452

# Maybe install the static library, too.

3453

test -n "$old_library" && staticlibs+=" $dir/$old_library"

3454

;;

3455

3456

*.lo)

3457

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

3458

3459

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

3460

if test -n "$destname"; then

3461

destfile="$destdir/$destname"

3462

else

3463

func_basename "$file"

3464

destfile="$func_basename_result"

3465

destfile="$destdir/$destfile"

3466

fi

3467

3468

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

3469

case $destfile in

3470

*.lo)

3471

func_lo2o "$destfile"

3472

staticdest=$func_lo2o_result

3473

;;

3474

*.$objext)

3475

staticdest="$destfile"

3476

destfile=

3477

;;

3478

*)

3479

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

3480

;;

3481

esac

3482

3483

# Install the libtool object if requested.

3484

test -n "$destfile" && \

3485

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

3486

3487

# Install the old object if enabled.

3488

if test "$build_old_libs" = yes; then

3489

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

3490

func_lo2o "$file"

3491

staticobj=$func_lo2o_result

3492

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

3493

fi

3494

exit $EXIT_SUCCESS

3495

;;

3496

3497

*)

3498

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

3499

if test -n "$destname"; then

3500

destfile="$destdir/$destname"

3501

else

3502

func_basename "$file"

3503

destfile="$func_basename_result"

3504

destfile="$destdir/$destfile"

3505

fi

3506

3507

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

3508

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

3509

# install

3510

stripped_ext=""

3511

case $file in

3512

*.exe)

3513

if test ! -f "$file"; then

3514

func_stripname '' '.exe' "$file"

3515

file=$func_stripname_result

3516

stripped_ext=".exe"

3517

fi

3518

;;

3519

esac

3520

3521

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

3522

case $host in

3523

*cygwin* | *mingw*)

3524

if func_ltwrapper_executable_p "$file"; then

3525

func_ltwrapper_scriptname "$file"

3526

wrapper=$func_ltwrapper_scriptname_result

3527

else

3528

func_stripname '' '.exe' "$file"

3529

wrapper=$func_stripname_result

3530

fi

3531

;;

3532

*)

3533

wrapper=$file

3534

;;

3535

esac

3536

if func_ltwrapper_script_p "$wrapper"; then

3537

notinst_deplibs=

3538

relink_command=

3539

3540

func_source "$wrapper"

3541

3542

# Check the variables that should have been set.

3543

test -z "$generated_by_libtool_version" && \

3544

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

3545

3546

finalize=yes

3547

for lib in $notinst_deplibs; do

3548

# Check to see that each library is installed.

3549

libdir=

3550

if test -f "$lib"; then

3551

func_source "$lib"

3552

fi

3553

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

3554

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

3555

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

3556

finalize=no

3557

fi

3558

done

3559

3560

relink_command=

3561

func_source "$wrapper"

3562

3563

outputname=

3564

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

3565

$opt_dry_run || {

3566

if test "$finalize" = yes; then

3567

tmpdir=`func_mktempdir`

3568

func_basename "$file$stripped_ext"

3569

file="$func_basename_result"

3570

outputname="$tmpdir/$file"

3571

# Replace the output file specification.

3572

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

3573

3574

$opt_silent || {

3575

func_quote_for_expand "$relink_command"

3576

eval "func_echo $func_quote_for_expand_result"

3577

}

3578

if eval "$relink_command"; then :

3579

else

3580

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

3581

$opt_dry_run || ${RM}r "$tmpdir"

3582

continue

3583

fi

3584

file="$outputname"

3585

else

3586

func_warning "cannot relink \`$file'"

3587

fi

3588

}

3589

else

3590

# Install the binary that we compiled earlier.

3591

file=`$ECHO "$file$stripped_ext" | $SED "s%$[^/]*$$%$objdir/\1%"`

3592

fi

3593

fi

3594

3595

# remove .exe since cygwin /usr/bin/install will append another

3596

# one anyway

3597

case $install_prog,$host in

3598

*/usr/bin/install*,*cygwin*)

3599

case $file:$destfile in

3600

*.exe:*.exe)

3601

# this is ok

3602

;;

3603

*.exe:*)

3604

destfile=$destfile.exe

3605

;;

3606

*:*.exe)

3607

func_stripname '' '.exe' "$destfile"

3608

destfile=$func_stripname_result

3609

;;

3610

esac

3611

;;

3612

esac

3613

func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'

3614

$opt_dry_run || if test -n "$outputname"; then

3615

${RM}r "$tmpdir"

3616

fi

3617

;;

3618

esac

3619

done

3620

3621

for file in $staticlibs; do

3622

func_basename "$file"

3623

name="$func_basename_result"

3624

3625

# Set up the ranlib parameters.

3626

oldlib="$destdir/$name"

3627

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

3628

tool_oldlib=$func_to_tool_file_result

3629

3630

func_show_eval "$install_prog \$file \$oldlib" 'exit $?'

3631

3632

if test -n "$stripme" && test -n "$old_striplib"; then

3633

func_show_eval "$old_striplib $tool_oldlib" 'exit $?'

3634

fi

3635

3636

# Do each command in the postinstall commands.

3637

func_execute_cmds "$old_postinstall_cmds" 'exit $?'

3638

done

3639

3640

test -n "$future_libdirs" && \

3641

func_warning "remember to run \`$progname --finish$future_libdirs'"

3642

3643

if test -n "$current_libdirs"; then

3644

# Maybe just do a dry run.

3645

$opt_dry_run && current_libdirs=" -n$current_libdirs"

3646

exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'

3647

else

3648

exit $EXIT_SUCCESS

3649

fi

3650

}

3651

3652

test "$opt_mode" = install && func_mode_install ${1+"$@"}

3653

3654

3655

# func_generate_dlsyms outputname originator pic_p

3656

# Extract symbols from dlprefiles and create ${outputname}S.o with

3657

# a dlpreopen symbol table.

3658

func_generate_dlsyms ()

3659

{

3660

$opt_debug

3661

my_outputname="$1"

3662

my_originator="$2"

3663

my_pic_p="${3-no}"

3664

my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`

3665

my_dlsyms=

3666

3667

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

3668

if test -n "$NM" && test -n "$global_symbol_pipe"; then

3669

my_dlsyms="${my_outputname}S.c"

3670

else

3671

func_error "not configured to extract global symbols from dlpreopened files"

3672

fi

3673

fi

3674

3675

if test -n "$my_dlsyms"; then

3676

case $my_dlsyms in

3677

"") ;;

3678

*.c)

3679

# Discover the nlist of each of the dlfiles.

3680

nlist="$output_objdir/${my_outputname}.nm"

3681

3682

func_show_eval "$RM $nlist ${nlist}S ${nlist}T"

3683

3684

# Parse the name list into a source file.

3685

func_verbose "creating $output_objdir/$my_dlsyms"

3686

3687

$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\

3688

/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */

3689

/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */

3690

3691

#ifdef __cplusplus

3692

extern \"C\" {

3693

#endif

3694

3695

#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))

3696

#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"

3697

#endif

3698

3699

/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */

3700

#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)

3701

/* DATA imports from DLLs on WIN32 con't be const, because runtime

3702

relocations are performed -- see ld's documentation on pseudo-relocs. */

3703

# define LT_DLSYM_CONST

3704

#elif defined(__osf__)

3705

/* This system does not cope well with relocations in const data. */

3706

# define LT_DLSYM_CONST

3707

#else

3708

# define LT_DLSYM_CONST const

3709

#endif

3710

3711

/* External symbol declarations for the compiler. */\

3712

"

3713

3714

if test "$dlself" = yes; then

3715

func_verbose "generating symbol list for \`$output'"

3716

3717

$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"

3718

3719

# Add our own program objects to the symbol list.

3720

progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`

3721

for progfile in $progfiles; do

3722

func_to_tool_file "$progfile" func_convert_file_msys_to_w32

3723

func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"

3724

$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"

3725

done

3726

3727

if test -n "$exclude_expsyms"; then

3728

$opt_dry_run || {

3729

eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'

3730

eval '$MV "$nlist"T "$nlist"'

3731

}

3732

fi

3733

3734

if test -n "$export_symbols_regex"; then

3735

$opt_dry_run || {

3736

eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'

3737

eval '$MV "$nlist"T "$nlist"'

3738

}

3739

fi

3740

3741

# Prepare the list of exported symbols

3742

if test -z "$export_symbols"; then

3743

export_symbols="$output_objdir/$outputname.exp"

3744

$opt_dry_run || {

3745

$RM $export_symbols

3746

eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'

3747

case $host in

3748

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

3749

eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

3750

eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'

3751

;;

3752

esac

3753

}

3754

else

3755

$opt_dry_run || {

3756

eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'

3757

eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'

3758

eval '$MV "$nlist"T "$nlist"'

3759

case $host in

3760

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

3761

eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

3762

eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'

3763

;;

3764

esac

3765

}

3766

fi

3767

fi

3768

3769

for dlprefile in $dlprefiles; do

3770

func_verbose "extracting global C symbols from \`$dlprefile'"

3771

func_basename "$dlprefile"

3772

name="$func_basename_result"

3773

case $host in

3774

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

3775

# if an import library, we need to obtain dlname

3776

if func_win32_import_lib_p "$dlprefile"; then

3777

func_tr_sh "$dlprefile"

3778

eval "curr_lafile=\$libfile_$func_tr_sh_result"

3779

dlprefile_dlbasename=""

3780

if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then

3781

# Use subshell, to avoid clobbering current variable values

3782

dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`

3783

if test -n "$dlprefile_dlname" ; then

3784

func_basename "$dlprefile_dlname"

3785

dlprefile_dlbasename="$func_basename_result"

3786

else

3787

# no lafile. user explicitly requested -dlpreopen <import library>.

3788

$sharedlib_from_linklib_cmd "$dlprefile"

3789

dlprefile_dlbasename=$sharedlib_from_linklib_result

3790

fi

3791

fi

3792

$opt_dry_run || {

3793

if test -n "$dlprefile_dlbasename" ; then

3794

eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'

3795

else

3796

func_warning "Could not compute DLL name from $name"

3797

eval '$ECHO ": $name " >> "$nlist"'

3798

fi

3799

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3800

eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |

3801

$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"

3802

}

3803

else # not an import lib

3804

$opt_dry_run || {

3805

eval '$ECHO ": $name " >> "$nlist"'

3806

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3807

eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"

3808

}

3809

fi

3810

;;

3811

*)

3812

$opt_dry_run || {

3813

eval '$ECHO ": $name " >> "$nlist"'

3814

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3815

eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"

3816

}

3817

;;

3818

esac

3819

done

3820

3821

$opt_dry_run || {

3822

# Make sure we have at least an empty file.

3823

test -f "$nlist" || : > "$nlist"

3824

3825

if test -n "$exclude_expsyms"; then

3826

$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T

3827

$MV "$nlist"T "$nlist"

3828

fi

3829

3830

# Try sorting and uniquifying the output.

3831

if $GREP -v "^: " < "$nlist" |

3832

if sort -k 3 </dev/null >/dev/null 2>&1; then

3833

sort -k 3

3834

else

3835

sort +2

3836

fi |

3837

uniq > "$nlist"S; then

3838

:

3839

else

3840

$GREP -v "^: " < "$nlist" > "$nlist"S

3841

fi

3842

3843

if test -f "$nlist"S; then

3844

eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'

3845

else

3846

echo '/* NONE */' >> "$output_objdir/$my_dlsyms"

3847

fi

3848

3849

echo >> "$output_objdir/$my_dlsyms" "\

3850

3851

/* The mapping between symbol names and symbols. */

3852

typedef struct {

3853

const char *name;

3854

void *address;

3855

} lt_dlsymlist;

3856

extern LT_DLSYM_CONST lt_dlsymlist

3857

lt_${my_prefix}_LTX_preloaded_symbols[];

3858

LT_DLSYM_CONST lt_dlsymlist

3859

lt_${my_prefix}_LTX_preloaded_symbols[] =

3860

{\

3861

{ \"$my_originator\", (void *) 0 },"

3862

3863

case $need_lib_prefix in

3864

no)

3865

eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"

3866

;;

3867

*)

3868

eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"

3869

;;

3870

esac

3871

echo >> "$output_objdir/$my_dlsyms" "\

3872

{0, (void *) 0}

3873

};

3874

3875

/* This works around a problem in FreeBSD linker */

3876

#ifdef FREEBSD_WORKAROUND

3877

static const void *lt_preloaded_setup() {

3878

return lt_${my_prefix}_LTX_preloaded_symbols;

3879

}

3880

#endif

3881

3882

#ifdef __cplusplus

3883

}

3884

#endif\

3885

"

3886

} # !$opt_dry_run

3887

3888

pic_flag_for_symtable=

3889

case "$compile_command " in

3890

*" -static "*) ;;

3891

*)

3892

case $host in

3893

# compiling the symbol table file with pic_flag works around

3894

# a FreeBSD bug that causes programs to crash when -lm is

3895

# linked before any other PIC object. But we must not use

3896

# pic_flag when linking with -static. The problem exists in

3897

# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

3898

*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)

3899

pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;

3900

*-*-hpux*)

3901

pic_flag_for_symtable=" $pic_flag" ;;

3902

*)

3903

if test "X$my_pic_p" != Xno; then

3904

pic_flag_for_symtable=" $pic_flag"

3905

fi

3906

;;

3907

esac

3908

;;

3909

esac

3910

symtab_cflags=

3911

for arg in $LTCFLAGS; do

3912

case $arg in

3913

-pie | -fpie | -fPIE) ;;

3914

*) symtab_cflags+=" $arg" ;;

3915

esac

3916

done

3917

3918

# Now compile the dynamic symbol file.

3919

func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'

3920

3921

# Clean up the generated files.

3922

func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'

3923

3924

# Transform the symbol file into the correct name.

3925

symfileobj="$output_objdir/${my_outputname}S.$objext"

3926

case $host in

3927

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

3928

if test -f "$output_objdir/$my_outputname.def"; then

3929

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

3930

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

3931

else

3932

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3933

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3934

fi

3935

;;

3936

*)

3937

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3938

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3939

;;

3940

esac

3941

;;

3942

*)

3943

func_fatal_error "unknown suffix for \`$my_dlsyms'"

3944

;;

3945

esac

3946

else

3947

# We keep going just in case the user didn't refer to

3948

# lt_preloaded_symbols. The linker will fail if global_symbol_pipe

3949

# really was required.

3950

3951

# Nullify the symbol file.

3952

compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`

3953

finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`

3954

fi

3955

}

3956

3957

# func_win32_libid arg

3958

# return the library type of file 'arg'

3959

#

3960

# Need a lot of goo to handle *both* DLLs and import libs

3961

# Has to be a shell function in order to 'eat' the argument

3962

# that is supplied when $file_magic_command is called.

3963

# Despite the name, also deal with 64 bit binaries.

3964

func_win32_libid ()

3965

{

3966

$opt_debug

3967

win32_libid_type="unknown"

3968

win32_fileres=`file -L $1 2>/dev/null`

3969

case $win32_fileres in

3970

*ar\ archive\ import\ library*) # definitely import

3971

win32_libid_type="x86 archive import"

3972

;;

3973

*ar\ archive*) # could be an import, or static

3974

# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.

3975

if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |

3976

$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then

3977

func_to_tool_file "$1" func_convert_file_msys_to_w32

3978

win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |

3979

$SED -n -e '

3980

1,100{

3981

/ I /{

3982

s,.*,import,

3983

p

3984

q

3985

}

3986

}'`

3987

case $win32_nmres in

3988

import*) win32_libid_type="x86 archive import";;

3989

*) win32_libid_type="x86 archive static";;

3990

esac

3991

fi

3992

;;

3993

*DLL*)

3994

win32_libid_type="x86 DLL"

3995

;;

3996

*executable*) # but shell scripts are "executable" too...

3997

case $win32_fileres in

3998

*MS\ Windows\ PE\ Intel*)

3999

win32_libid_type="x86 DLL"

4000

;;

4001

esac

4002

;;

4003

esac

4004

$ECHO "$win32_libid_type"

4005

}

4006

4007

# func_cygming_dll_for_implib ARG

4008

#

4009

# Platform-specific function to extract the

4010

# name of the DLL associated with the specified

4011

# import library ARG.

4012

# Invoked by eval'ing the libtool variable

4013

# $sharedlib_from_linklib_cmd

4014

# Result is available in the variable

4015

# $sharedlib_from_linklib_result

4016

func_cygming_dll_for_implib ()

4017

{

4018

$opt_debug

4019

sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`

4020

}

4021

4022

# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs

4023

#

4024

# The is the core of a fallback implementation of a

4025

# platform-specific function to extract the name of the

4026

# DLL associated with the specified import library LIBNAME.

4027

#

4028

# SECTION_NAME is either .idata$6 or .idata$7, depending

4029

# on the platform and compiler that created the implib.

4030

#

4031

# Echos the name of the DLL associated with the

4032

# specified import library.

4033

func_cygming_dll_for_implib_fallback_core ()

4034

{

4035

$opt_debug

4036

match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`

4037

$OBJDUMP -s --section "$1" "$2" 2>/dev/null |

4038

$SED '/^Contents of section '"$match_literal"':/{

4039

# Place marker at beginning of archive member dllname section

4040

s/.*/====MARK====/

4041

p

4042

d

4043

}

4044

# These lines can sometimes be longer than 43 characters, but

4045

# are always uninteresting

4046

/:[ ]*file format pe[i]\{,1\}-/d

4047

/^In archive [^:]*:/d

4048

# Ensure marker is printed

4049

/^====MARK====/p

4050

# Remove all lines with less than 43 characters

4051

/^.\{43\}/!d

4052

# From remaining lines, remove first 43 characters

4053

s/^.\{43\}//' |

4054

$SED -n '

4055

# Join marker and all lines until next marker into a single line

4056

/^====MARK====/ b para

4057

H

4058

$ b para

4059

b

4060

:para

4061

x

4062

s/\n//g

4063

# Remove the marker

4064

s/^====MARK====//

4065

# Remove trailing dots and whitespace

4066

s/[\. \t]*$//

4067

# Print

4068

/./p' |

4069

# we now have a list, one entry per line, of the stringified

4070

# contents of the appropriate section of all members of the

4071

# archive which possess that section. Heuristic: eliminate

4072

# all those which have a first or second character that is

4073

# a '.' (that is, objdump's representation of an unprintable

4074

# character.) This should work for all archives with less than

4075

# 0x302f exports -- but will fail for DLLs whose name actually

4076

# begins with a literal '.' or a single character followed by

4077

# a '.'.

4078

#

4079

# Of those that remain, print the first one.

4080

$SED -e '/^\./d;/^.\./d;q'

4081

}

4082

4083

# func_cygming_gnu_implib_p ARG

4084

# This predicate returns with zero status (TRUE) if

4085

# ARG is a GNU/binutils-style import library. Returns

4086

# with nonzero status (FALSE) otherwise.

4087

func_cygming_gnu_implib_p ()

4088

{

4089

$opt_debug

4090

func_to_tool_file "$1" func_convert_file_msys_to_w32

4091

func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`

4092

test -n "$func_cygming_gnu_implib_tmp"

4093

}

4094

4095

# func_cygming_ms_implib_p ARG

4096

# This predicate returns with zero status (TRUE) if

4097

# ARG is an MS-style import library. Returns

4098

# with nonzero status (FALSE) otherwise.

4099

func_cygming_ms_implib_p ()

4100

{

4101

$opt_debug

4102

func_to_tool_file "$1" func_convert_file_msys_to_w32

4103

func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`

4104

test -n "$func_cygming_ms_implib_tmp"

4105

}

4106

4107

# func_cygming_dll_for_implib_fallback ARG

4108

# Platform-specific function to extract the

4109

# name of the DLL associated with the specified

4110

# import library ARG.

4111

#

4112

# This fallback implementation is for use when $DLLTOOL

4113

# does not support the --identify-strict option.

4114

# Invoked by eval'ing the libtool variable

4115

# $sharedlib_from_linklib_cmd

4116

# Result is available in the variable

4117

# $sharedlib_from_linklib_result

4118

func_cygming_dll_for_implib_fallback ()

4119

{

4120

$opt_debug

4121

if func_cygming_gnu_implib_p "$1" ; then

4122

# binutils import library

4123

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`

4124

elif func_cygming_ms_implib_p "$1" ; then

4125

# ms-generated import library

4126

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`

4127

else

4128

# unknown

4129

sharedlib_from_linklib_result=""

4130

fi

4131

}

4132

4133

4134

# func_extract_an_archive dir oldlib

4135

func_extract_an_archive ()

4136

{

4137

$opt_debug

4138

f_ex_an_ar_dir="$1"; shift

4139

f_ex_an_ar_oldlib="$1"

4140

if test "$lock_old_archive_extraction" = yes; then

4141

lockfile=$f_ex_an_ar_oldlib.lock

4142

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

4143

func_echo "Waiting for $lockfile to be removed"

4144

sleep 2

4145

done

4146

fi

4147

func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \

4148

'stat=$?; rm -f "$lockfile"; exit $stat'

4149

if test "$lock_old_archive_extraction" = yes; then

4150

$opt_dry_run || rm -f "$lockfile"

4151

fi

4152

if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

4153

:

4154

else

4155

func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"

4156

fi

4157

}

4158

4159

4160

# func_extract_archives gentop oldlib ...

4161

func_extract_archives ()

4162

{

4163

$opt_debug

4164

my_gentop="$1"; shift

4165

my_oldlibs=${1+"$@"}

4166

my_oldobjs=""

4167

my_xlib=""

4168

my_xabs=""

4169

my_xdir=""

4170

4171

for my_xlib in $my_oldlibs; do

4172

# Extract the objects.

4173

case $my_xlib in

4174

[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;

4175

*) my_xabs=`pwd`"/$my_xlib" ;;

4176

esac

4177

func_basename "$my_xlib"

4178

my_xlib="$func_basename_result"

4179

my_xlib_u=$my_xlib

4180

while :; do

4181

case " $extracted_archives " in

4182

*" $my_xlib_u "*)

4183

func_arith $extracted_serial + 1

4184

extracted_serial=$func_arith_result

4185

my_xlib_u=lt$extracted_serial-$my_xlib ;;

4186

*) break ;;

4187

esac

4188

done

4189

extracted_archives="$extracted_archives $my_xlib_u"

4190

my_xdir="$my_gentop/$my_xlib_u"

4191

4192

func_mkdir_p "$my_xdir"

4193

4194

case $host in

4195

*-darwin*)

4196

func_verbose "Extracting $my_xabs"

4197

# Do not bother doing anything if just a dry run

4198

$opt_dry_run || {

4199

darwin_orig_dir=`pwd`

4200

cd $my_xdir || exit $?

4201

darwin_archive=$my_xabs

4202

darwin_curdir=`pwd`

4203

darwin_base_archive=`basename "$darwin_archive"`

4204

darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`

4205

if test -n "$darwin_arches"; then

4206

darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`

4207

darwin_arch=

4208

func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"

4209

for darwin_arch in $darwin_arches ; do

4210

func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

4211

$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

4212

cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

4213

func_extract_an_archive "`pwd`" "${darwin_base_archive}"

4214

cd "$darwin_curdir"

4215

$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"

4216

done # $darwin_arches

4217

## Okay now we've a bunch of thin objects, gotta fatten them up :)

4218

darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`

4219

darwin_file=

4220

darwin_files=

4221

for darwin_file in $darwin_filelist; do

4222

darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`

4223

$LIPO -create -output "$darwin_file" $darwin_files

4224

done # $darwin_filelist

4225

$RM -rf unfat-$$

4226

cd "$darwin_orig_dir"

4227

else

4228

cd $darwin_orig_dir

4229

func_extract_an_archive "$my_xdir" "$my_xabs"

4230

fi # $darwin_arches

4231

} # !$opt_dry_run

4232

;;

4233

*)

4234

func_extract_an_archive "$my_xdir" "$my_xabs"

4235

;;

4236

esac

4237

my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`

4238

done

4239

4240

func_extract_archives_result="$my_oldobjs"

4241

}

4242

4243

4244

# func_emit_wrapper [arg=no]

4245

#

4246

# Emit a libtool wrapper script on stdout.

4247

# Don't directly open a file because we may want to

4248

# incorporate the script contents within a cygwin/mingw

4249

# wrapper executable. Must ONLY be called from within

4250

# func_mode_link because it depends on a number of variables

4251

# set therein.

4252

#

4253

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

4254

# variable will take. If 'yes', then the emitted script

4255

# will assume that the directory in which it is stored is

4256

# the $objdir directory. This is a cygwin/mingw-specific

4257

# behavior.

4258

func_emit_wrapper ()

4259

{

4260

func_emit_wrapper_arg1=${1-no}

4261

4262

$ECHO "\

4263

#! $SHELL

4264

4265

# $output - temporary wrapper script for $objdir/$outputname

4266

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

4267

#

4268

# The $output program cannot be directly executed until all the libtool

4269

# libraries that it depends on are installed.

4270

#

4271

# This wrapper script should never be moved out of the build directory.

4272

# If it is, it will not operate correctly.

4273

4274

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

4275

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

4276

sed_quote_subst='$sed_quote_subst'

4277

4278

# Be Bourne compatible

4279

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

4280

emulate sh

4281

NULLCMD=:

4282

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

4283

# is contrary to our usage. Disable this feature.

4284

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

4285

setopt NO_GLOB_SUBST

4286

else

4287

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

4288

fi

4289

BIN_SH=xpg4; export BIN_SH # for Tru64

4290

DUALCASE=1; export DUALCASE # for MKS sh

4291

4292

# The HP-UX ksh and POSIX shell print the target directory to stdout

4293

# if CDPATH is set.

4294

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

4295

4296

relink_command=\"$relink_command\"

4297

4298

# This environment variable determines our operation mode.

4299

if test \"\$libtool_install_magic\" = \"$magic\"; then

4300

# install mode needs the following variables:

4301

generated_by_libtool_version='$macro_version'

4302

notinst_deplibs='$notinst_deplibs'

4303

else

4304

# When we are sourced in execute mode, \$file and \$ECHO are already set.

4305

if test \"\$libtool_execute_magic\" != \"$magic\"; then

4306

file=\"\$0\""

4307

4308

qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`

4309

$ECHO "\

4310

4311

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

4312

func_fallback_echo ()

4313

{

4314

eval 'cat <<_LTECHO_EOF

4315

\$1

4316

_LTECHO_EOF'

4317

}

4318

ECHO=\"$qECHO\"

4319

fi

4320

4321

# Very basic option parsing. These options are (a) specific to

4322

# the libtool wrapper, (b) are identical between the wrapper

4323

# /script/ and the wrapper /executable/ which is used only on

4324

# windows platforms, and (c) all begin with the string "--lt-"

4325

# (application programs are unlikely to have options which match

4326

# this pattern).

4327

#

4328

# There are only two supported options: --lt-debug and

4329

# --lt-dump-script. There is, deliberately, no --lt-help.

4330

#

4331

# The first argument to this parsing function should be the

4332

# script's $0 value, followed by "$@".

4333

lt_option_debug=

4334

func_parse_lt_options ()

4335

{

4336

lt_script_arg0=\$0

4337

shift

4338

for lt_opt

4339

do

4340

case \"\$lt_opt\" in

4341

--lt-debug) lt_option_debug=1 ;;

4342

--lt-dump-script)

4343

lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`

4344

test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.

4345

lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`

4346

cat \"\$lt_dump_D/\$lt_dump_F\"

4347

exit 0

4348

;;

4349

--lt-*)

4350

\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2

4351

exit 1

4352

;;

4353

esac

4354

done

4355

4356

# Print the debug banner immediately:

4357

if test -n \"\$lt_option_debug\"; then

4358

echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2

4359

fi

4360

}

4361

4362

# Used when --lt-debug. Prints its arguments to stdout

4363

# (redirection is the responsibility of the caller)

4364

func_lt_dump_args ()

4365

{

4366

lt_dump_args_N=1;

4367

for lt_arg

4368

do

4369

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"

4370

lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`

4371

done

4372

}

4373

4374

# Core function for launching the target application

4375

func_exec_program_core ()

4376

{

4377

"

4378

case $host in

4379

# Backslashes separate directories on plain windows

4380

*-*-mingw | *-*-os2* | *-cegcc*)

4381

$ECHO "\

4382

if test -n \"\$lt_option_debug\"; then

4383

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2

4384

func_lt_dump_args \${1+\"\$@\"} 1>&2

4385

fi

4386

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

4387

"

4388

;;

4389

4390

*)

4391

$ECHO "\

4392

if test -n \"\$lt_option_debug\"; then

4393

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2

4394

func_lt_dump_args \${1+\"\$@\"} 1>&2

4395

fi

4396

exec \"\$progdir/\$program\" \${1+\"\$@\"}

4397

"

4398

;;

4399

esac

4400

$ECHO "\

4401

\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2

4402

exit 1

4403

}

4404

4405

# A function to encapsulate launching the target application

4406

# Strips options in the --lt-* namespace from \$@ and

4407

# launches target application with the remaining arguments.

4408

func_exec_program ()

4409

{

4410

case \" \$* \" in

4411

*\\ --lt-*)

4412

for lt_wr_arg

4413

do

4414

case \$lt_wr_arg in

4415

--lt-*) ;;

4416

*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;

4417

esac

4418

shift

4419

done ;;

4420

esac

4421

func_exec_program_core \${1+\"\$@\"}

4422

}

4423

4424

# Parse options

4425

func_parse_lt_options \"\$0\" \${1+\"\$@\"}

4426

4427

# Find the directory that this script lives in.

4428

thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`

4429

test \"x\$thisdir\" = \"x\$file\" && thisdir=.

4430

4431

# Follow symbolic links until we get to the real thisdir.

4432

file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`

4433

while test -n \"\$file\"; do

4434

destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`

4435

4436

# If there was a directory component, then change thisdir.

4437

if test \"x\$destdir\" != \"x\$file\"; then

4438

case \"\$destdir\" in

4439

[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;

4440

*) thisdir=\"\$thisdir/\$destdir\" ;;

4441

esac

4442

fi

4443

4444

file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`

4445

file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`

4446

done

4447

4448

# Usually 'no', except on cygwin/mingw when embedded into

4449

# the cwrapper.

4450

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1

4451

if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then

4452

# special case for '.'

4453

if test \"\$thisdir\" = \".\"; then

4454

thisdir=\`pwd\`

4455

fi

4456

# remove .libs from thisdir

4457

case \"\$thisdir\" in

4458

*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;

4459

$objdir ) thisdir=. ;;

4460

esac

4461

fi

4462

4463

# Try to get the absolute directory name.

4464

absdir=\`cd \"\$thisdir\" && pwd\`

4465

test -n \"\$absdir\" && thisdir=\"\$absdir\"

4466

"

4467

4468

if test "$fast_install" = yes; then

4469

$ECHO "\

4470

program=lt-'$outputname'$exeext

4471

progdir=\"\$thisdir/$objdir\"

4472

4473

if test ! -f \"\$progdir/\$program\" ||

4474

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

4475

test \"X\$file\" != \"X\$progdir/\$program\"; }; then

4476

4477

file=\"\$\$-\$program\"

4478

4479

if test ! -d \"\$progdir\"; then

4480

$MKDIR \"\$progdir\"

4481

else

4482

$RM \"\$progdir/\$file\"

4483

fi"

4484

4485

$ECHO "\

4486

4487

# relink executable if necessary

4488

if test -n \"\$relink_command\"; then

4489

if relink_command_output=\`eval \$relink_command 2>&1\`; then :

4490

else

4491

$ECHO \"\$relink_command_output\" >&2

4492

$RM \"\$progdir/\$file\"

4493

exit 1

4494

fi

4495

fi

4496

4497

$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

4498

{ $RM \"\$progdir/\$program\";

4499

$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }

4500

$RM \"\$progdir/\$file\"

4501

fi"

4502

else

4503

$ECHO "\

4504

program='$outputname'

4505

progdir=\"\$thisdir/$objdir\"

4506

"

4507

fi

4508

4509

$ECHO "\

4510

4511

if test -f \"\$progdir/\$program\"; then"

4512

4513

# fixup the dll searchpath if we need to.

4514

#

4515

# Fix the DLL searchpath if we need to. Do this before prepending

4516

# to shlibpath, because on Windows, both are PATH and uninstalled

4517

# libraries must come first.

4518

if test -n "$dllsearchpath"; then

4519

$ECHO "\

4520

# Add the dll search path components to the executable PATH

4521

PATH=$dllsearchpath:\$PATH

4522

"

4523

fi

4524

4525

# Export our shlibpath_var if we have one.

4526

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4527

$ECHO "\

4528

# Add our own library path to $shlibpath_var

4529

$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

4530

4531

# Some systems cannot cope with colon-terminated $shlibpath_var

4532

# The second colon is a workaround for a bug in BeOS R4 sed

4533

$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`

4534

4535

export $shlibpath_var

4536

"

4537

fi

4538

4539

$ECHO "\

4540

if test \"\$libtool_execute_magic\" != \"$magic\"; then

4541

# Run the actual program with our arguments.

4542

func_exec_program \${1+\"\$@\"}

4543

fi

4544

else

4545

# The program doesn't exist.

4546

\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

4547

\$ECHO \"This script is just a wrapper for \$program.\" 1>&2

4548

\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

4549

exit 1

4550

fi

4551

fi\

4552

"

4553

}

4554

4555

4556

# func_emit_cwrapperexe_src

4557

# emit the source code for a wrapper executable on stdout

4558

# Must ONLY be called from within func_mode_link because

4559

# it depends on a number of variable set therein.

4560

func_emit_cwrapperexe_src ()

4561

{

4562

cat <<EOF

4563

4564

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

4565

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

4566

4567

The $output program cannot be directly executed until all the libtool

4568

libraries that it depends on are installed.

4569

4570

This wrapper executable should never be moved out of the build directory.

4571

If it is, it will not operate correctly.

4572

*/

4573

EOF

4574

cat <<"EOF"

4575

#ifdef _MSC_VER

4576

# define _CRT_SECURE_NO_DEPRECATE 1

4577

#endif

4578

#include <stdio.h>

4579

#include <stdlib.h>

4580

#ifdef _MSC_VER

4581

# include <direct.h>

4582

# include <process.h>

4583

# include <io.h>

4584

#else

4585

# include <unistd.h>

4586

# include <stdint.h>

4587

# ifdef __CYGWIN__

4588

# include <io.h>

4589

# endif

4590

#endif

4591

#include <malloc.h>

4592

#include <stdarg.h>

4593

#include <assert.h>

4594

#include <string.h>

4595

#include <ctype.h>

4596

#include <errno.h>

4597

#include <fcntl.h>

4598

#include <sys/stat.h>

4599

4600

/* declarations of non-ANSI functions */

4601

#if defined(__MINGW32__)

4602

# ifdef __STRICT_ANSI__

4603

int _putenv (const char *);

4604

# endif

4605

#elif defined(__CYGWIN__)

4606

# ifdef __STRICT_ANSI__

4607

char *realpath (const char *, char *);

4608

int putenv (char *);

4609

int setenv (const char *, const char *, int);

4610

# endif

4611

/* #elif defined (other platforms) ... */

4612

#endif

4613

4614

/* portability defines, excluding path handling macros */

4615

#if defined(_MSC_VER)

4616

# define setmode _setmode

4617

# define stat _stat

4618

# define chmod _chmod

4619

# define getcwd _getcwd

4620

# define putenv _putenv

4621

# define S_IXUSR _S_IEXEC

4622

# ifndef _INTPTR_T_DEFINED

4623

# define _INTPTR_T_DEFINED

4624

# define intptr_t int

4625

# endif

4626

#elif defined(__MINGW32__)

4627

# define setmode _setmode

4628

# define stat _stat

4629

# define chmod _chmod

4630

# define getcwd _getcwd

4631

# define putenv _putenv

4632

#elif defined(__CYGWIN__)

4633

# define HAVE_SETENV

4634

# define FOPEN_WB "wb"

4635

/* #elif defined (other platforms) ... */

4636

#endif

4637

4638

#if defined(PATH_MAX)

4639

# define LT_PATHMAX PATH_MAX

4640

#elif defined(MAXPATHLEN)

4641

# define LT_PATHMAX MAXPATHLEN

4642

#else

4643

# define LT_PATHMAX 1024

4644

#endif

4645

4646

#ifndef S_IXOTH

4647

# define S_IXOTH 0

4648

#endif

4649

#ifndef S_IXGRP

4650

# define S_IXGRP 0

4651

#endif

4652

4653

/* path handling portability macros */

4654

#ifndef DIR_SEPARATOR

4655

# define DIR_SEPARATOR '/'

4656

# define PATH_SEPARATOR ':'

4657

#endif

4658

4659

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

4660

defined (__OS2__)

4661

# define HAVE_DOS_BASED_FILE_SYSTEM

4662

# define FOPEN_WB "wb"

4663

# ifndef DIR_SEPARATOR_2

4664

# define DIR_SEPARATOR_2 '\\'

4665

# endif

4666

# ifndef PATH_SEPARATOR_2

4667

# define PATH_SEPARATOR_2 ';'

4668

# endif

4669

#endif

4670

4671

#ifndef DIR_SEPARATOR_2

4672

# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

4673

#else /* DIR_SEPARATOR_2 */

4674

# define IS_DIR_SEPARATOR(ch) \

4675

(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

4676

#endif /* DIR_SEPARATOR_2 */

4677

4678

#ifndef PATH_SEPARATOR_2

4679

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

4680

#else /* PATH_SEPARATOR_2 */

4681

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

4682

#endif /* PATH_SEPARATOR_2 */

4683

4684

#ifndef FOPEN_WB

4685

# define FOPEN_WB "w"

4686

#endif

4687

#ifndef _O_BINARY

4688

# define _O_BINARY 0

4689

#endif

4690

4691

#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

4692

#define XFREE(stale) do { \

4693

if (stale) { free ((void *) stale); stale = 0; } \

4694

} while (0)

4695

4696

#if defined(LT_DEBUGWRAPPER)

4697

static int lt_debug = 1;

4698

#else

4699

static int lt_debug = 0;

4700

#endif

4701

4702

const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */

4703

4704

void *xmalloc (size_t num);

4705

char *xstrdup (const char *string);

4706

const char *base_name (const char *name);

4707

char *find_executable (const char *wrapper);

4708

char *chase_symlinks (const char *pathspec);

4709

int make_executable (const char *path);

4710

int check_executable (const char *path);

4711

char *strendzap (char *str, const char *pat);

4712

void lt_debugprintf (const char *file, int line, const char *fmt, ...);

4713

void lt_fatal (const char *file, int line, const char *message, ...);

4714

static const char *nonnull (const char *s);

4715

static const char *nonempty (const char *s);

4716

void lt_setenv (const char *name, const char *value);

4717

char *lt_extend_str (const char *orig_value, const char *add, int to_end);

4718

void lt_update_exe_path (const char *name, const char *value);

4719

void lt_update_lib_path (const char *name, const char *value);

4720

char **prepare_spawn (char **argv);

4721

void lt_dump_script (FILE *f);

4722

EOF

4723

4724

cat <<EOF

4725

volatile const char * MAGIC_EXE = "$magic_exe";

4726

const char * LIB_PATH_VARNAME = "$shlibpath_var";

4727

EOF

4728

4729

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4730

func_to_host_path "$temp_rpath"

4731

cat <<EOF

4732

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

4733

EOF

4734

else

4735

cat <<"EOF"

4736

const char * LIB_PATH_VALUE = "";

4737

EOF

4738

fi

4739

4740

if test -n "$dllsearchpath"; then

4741

func_to_host_path "$dllsearchpath:"

4742

cat <<EOF

4743

const char * EXE_PATH_VARNAME = "PATH";

4744

const char * EXE_PATH_VALUE = "$func_to_host_path_result";

4745

EOF

4746

else

4747

cat <<"EOF"

4748

const char * EXE_PATH_VARNAME = "";

4749

const char * EXE_PATH_VALUE = "";

4750

EOF

4751

fi

4752

4753

if test "$fast_install" = yes; then

4754

cat <<EOF

4755

const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */

4756

EOF

4757

else

4758

cat <<EOF

4759

const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */

4760

EOF

4761

fi

4762

4763

4764

cat <<"EOF"

4765

4766

#define LTWRAPPER_OPTION_PREFIX "--lt-"

4767

4768

static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;

4769

static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";

4770

static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";

4771

4772

int

4773

main (int argc, char *argv[])

4774

{

4775

char **newargz;

4776

int newargc;

4777

char *tmp_pathspec;

4778

char *actual_cwrapper_path;

4779

char *actual_cwrapper_name;

4780

char *target_name;

4781

char *lt_argv_zero;

4782

intptr_t rval = 127;

4783

4784

int i;

4785

4786

program_name = (char *) xstrdup (base_name (argv[0]));

4787

newargz = XMALLOC (char *, argc + 1);

4788

4789

/* very simple arg parsing; don't want to rely on getopt

4790

* also, copy all non cwrapper options to newargz, except

4791

* argz[0], which is handled differently

4792

*/

4793

newargc=0;

4794

for (i = 1; i < argc; i++)

4795

{

4796

if (strcmp (argv[i], dumpscript_opt) == 0)

4797

{

4798

EOF

4799

case "$host" in

4800

*mingw* | *cygwin* )

4801

# make stdout use "unix" line endings

4802

echo " setmode(1,_O_BINARY);"

4803

;;

4804

esac

4805

4806

cat <<"EOF"

4807

lt_dump_script (stdout);

4808

return 0;

4809

}

4810

if (strcmp (argv[i], debug_opt) == 0)

4811

{

4812

lt_debug = 1;

4813

continue;

4814

}

4815

if (strcmp (argv[i], ltwrapper_option_prefix) == 0)

4816

{

4817

/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX

4818

namespace, but it is not one of the ones we know about and

4819

have already dealt with, above (inluding dump-script), then

4820

report an error. Otherwise, targets might begin to believe

4821

they are allowed to use options in the LTWRAPPER_OPTION_PREFIX

4822

namespace. The first time any user complains about this, we'll

4823

need to make LTWRAPPER_OPTION_PREFIX a configure-time option

4824

or a configure.ac-settable value.

4825

*/

4826

lt_fatal (__FILE__, __LINE__,

4827

"unrecognized %s option: '%s'",

4828

ltwrapper_option_prefix, argv[i]);

4829

}

4830

/* otherwise ... */

4831

newargz[++newargc] = xstrdup (argv[i]);

4832

}

4833

newargz[++newargc] = NULL;

4834

4835

EOF

4836

cat <<EOF

4837

/* The GNU banner must be the first non-error debug message */

4838

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");

4839

EOF

4840

cat <<"EOF"

4841

lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);

4842

lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);

4843

4844

tmp_pathspec = find_executable (argv[0]);

4845

if (tmp_pathspec == NULL)

4846

lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);

4847

lt_debugprintf (__FILE__, __LINE__,

4848

"(main) found exe (before symlink chase) at: %s\n",

4849

tmp_pathspec);

4850

4851

actual_cwrapper_path = chase_symlinks (tmp_pathspec);

4852

lt_debugprintf (__FILE__, __LINE__,

4853

"(main) found exe (after symlink chase) at: %s\n",

4854

actual_cwrapper_path);

4855

XFREE (tmp_pathspec);

4856

4857

actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));

4858

strendzap (actual_cwrapper_path, actual_cwrapper_name);

4859

4860

/* wrapper name transforms */

4861

strendzap (actual_cwrapper_name, ".exe");

4862

tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);

4863

XFREE (actual_cwrapper_name);

4864

actual_cwrapper_name = tmp_pathspec;

4865

tmp_pathspec = 0;

4866

4867

/* target_name transforms -- use actual target program name; might have lt- prefix */

4868

target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));

4869

strendzap (target_name, ".exe");

4870

tmp_pathspec = lt_extend_str (target_name, ".exe", 1);

4871

XFREE (target_name);

4872

target_name = tmp_pathspec;

4873

tmp_pathspec = 0;

4874

4875

lt_debugprintf (__FILE__, __LINE__,

4876

"(main) libtool target name: %s\n",

4877

target_name);

4878

EOF

4879

4880

cat <<EOF

4881

newargz[0] =

4882

XMALLOC (char, (strlen (actual_cwrapper_path) +

4883

strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));

4884

strcpy (newargz[0], actual_cwrapper_path);

4885

strcat (newargz[0], "$objdir");

4886

strcat (newargz[0], "/");

4887

EOF

4888

4889

cat <<"EOF"

4890

/* stop here, and copy so we don't have to do this twice */

4891

tmp_pathspec = xstrdup (newargz[0]);

4892

4893

/* do NOT want the lt- prefix here, so use actual_cwrapper_name */

4894

strcat (newargz[0], actual_cwrapper_name);

4895

4896

/* DO want the lt- prefix here if it exists, so use target_name */

4897

lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);

4898

XFREE (tmp_pathspec);

4899

tmp_pathspec = NULL;

4900

EOF

4901

4902

case $host_os in

4903

mingw*)

4904

cat <<"EOF"

4905

{

4906

char* p;

4907

while ((p = strchr (newargz[0], '\\')) != NULL)

4908

{

4909

*p = '/';

4910

}

4911

while ((p = strchr (lt_argv_zero, '\\')) != NULL)

4912

{

4913

*p = '/';

4914

}

4915

}

4916

EOF

4917

;;

4918

esac

4919

4920

cat <<"EOF"

4921

XFREE (target_name);

4922

XFREE (actual_cwrapper_path);

4923

XFREE (actual_cwrapper_name);

4924

4925

lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */

4926

lt_setenv ("DUALCASE", "1"); /* for MSK sh */

4927

/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must

4928

be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)

4929

because on Windows, both *_VARNAMEs are PATH but uninstalled

4930

libraries must come first. */

4931

lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);

4932

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

4933

4934

lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",

4935

nonnull (lt_argv_zero));

4936

for (i = 0; i < newargc; i++)

4937

{

4938

lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",

4939

i, nonnull (newargz[i]));

4940

}

4941

4942

EOF

4943

4944

case $host_os in

4945

mingw*)

4946

cat <<"EOF"

4947

/* execv doesn't actually work on mingw as expected on unix */

4948

newargz = prepare_spawn (newargz);

4949

rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

4950

if (rval == -1)

4951

{

4952

/* failed to start process */

4953

lt_debugprintf (__FILE__, __LINE__,

4954

"(main) failed to launch target \"%s\": %s\n",

4955

lt_argv_zero, nonnull (strerror (errno)));

4956

return 127;

4957

}

4958

return rval;

4959

EOF

4960

;;

4961

*)

4962

cat <<"EOF"

4963

execv (lt_argv_zero, newargz);

4964

return rval; /* =127, but avoids unused variable warning */

4965

EOF

4966

;;

4967

esac

4968

4969

cat <<"EOF"

4970

}

4971

4972

void *

4973

xmalloc (size_t num)

4974

{

4975

void *p = (void *) malloc (num);

4976

if (!p)

4977

lt_fatal (__FILE__, __LINE__, "memory exhausted");

4978

4979

return p;

4980

}

4981

4982

char *

4983

xstrdup (const char *string)

4984

{

4985

return string ? strcpy ((char *) xmalloc (strlen (string) + 1),

4986

string) : NULL;

4987

}

4988

4989

const char *

4990

base_name (const char *name)

4991

{

4992

const char *base;

4993

4994

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4995

/* Skip over the disk name in MSDOS pathnames. */

4996

if (isalpha ((unsigned char) name[0]) && name[1] == ':')

4997

name += 2;

4998

#endif

4999

5000

for (base = name; *name; name++)

5001

if (IS_DIR_SEPARATOR (*name))

5002

base = name + 1;

5003

return base;

5004

}

5005

5006

int

5007

check_executable (const char *path)

5008

{

5009

struct stat st;

5010

5011

lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",

5012

nonempty (path));

5013

if ((!path) || (!*path))

5014

return 0;

5015

5016

if ((stat (path, &st) >= 0)

5017

&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))

5018

return 1;

5019

else

5020

return 0;

5021

}

5022

5023

int

5024

make_executable (const char *path)

5025

{

5026

int rval = 0;

5027

struct stat st;

5028

5029

lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",

5030

nonempty (path));

5031

if ((!path) || (!*path))

5032

return 0;

5033

5034

if (stat (path, &st) >= 0)

5035

{

5036

rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);

5037

}

5038

return rval;

5039

}

5040

5041

/* Searches for the full path of the wrapper. Returns

5042

newly allocated full path name if found, NULL otherwise

5043

Does not chase symlinks, even on platforms that support them.

5044

*/

5045

char *

5046

find_executable (const char *wrapper)

5047

{

5048

int has_slash = 0;

5049

const char *p;

5050

const char *p_next;

5051

/* static buffer for getcwd */

5052

char tmp[LT_PATHMAX + 1];

5053

int tmp_len;

5054

char *concat_name;

5055

5056

lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",

5057

nonempty (wrapper));

5058

5059

if ((wrapper == NULL) || (*wrapper == '\0'))

5060

return NULL;

5061

5062

/* Absolute path? */

5063

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5064

if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')

5065

{

5066

concat_name = xstrdup (wrapper);

5067

if (check_executable (concat_name))

5068

return concat_name;

5069

XFREE (concat_name);

5070

}

5071

else

5072

{

5073

#endif

5074

if (IS_DIR_SEPARATOR (wrapper[0]))

5075

{

5076

concat_name = xstrdup (wrapper);

5077

if (check_executable (concat_name))

5078

return concat_name;

5079

XFREE (concat_name);

5080

}

5081

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5082

}

5083

#endif

5084

5085

for (p = wrapper; *p; p++)

5086

if (*p == '/')

5087

{

5088

has_slash = 1;

5089

break;

5090

}

5091

if (!has_slash)

5092

{

5093

/* no slashes; search PATH */

5094

const char *path = getenv ("PATH");

5095

if (path != NULL)

5096

{

5097

for (p = path; *p; p = p_next)

5098

{

5099

const char *q;

5100

size_t p_len;

5101

for (q = p; *q; q++)

5102

if (IS_PATH_SEPARATOR (*q))

5103

break;

5104

p_len = q - p;

5105

p_next = (*q == '\0' ? q : q + 1);

5106

if (p_len == 0)

5107

{

5108

/* empty path: current directory */

5109

if (getcwd (tmp, LT_PATHMAX) == NULL)

5110

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

5111

nonnull (strerror (errno)));

5112

tmp_len = strlen (tmp);

5113

concat_name =

5114

XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

5115

memcpy (concat_name, tmp, tmp_len);

5116

concat_name[tmp_len] = '/';

5117

strcpy (concat_name + tmp_len + 1, wrapper);

5118

}

5119

else

5120

{

5121

concat_name =

5122

XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);

5123

memcpy (concat_name, p, p_len);

5124

concat_name[p_len] = '/';

5125

strcpy (concat_name + p_len + 1, wrapper);

5126

}

5127

if (check_executable (concat_name))

5128

return concat_name;

5129

XFREE (concat_name);

5130

}

5131

}

5132

/* not found in PATH; assume curdir */

5133

}

5134

/* Relative path | not found in path: prepend cwd */

5135

if (getcwd (tmp, LT_PATHMAX) == NULL)

5136

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

5137

nonnull (strerror (errno)));

5138

tmp_len = strlen (tmp);

5139

concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

5140

memcpy (concat_name, tmp, tmp_len);

5141

concat_name[tmp_len] = '/';

5142

strcpy (concat_name + tmp_len + 1, wrapper);

5143

5144

if (check_executable (concat_name))

5145

return concat_name;

5146

XFREE (concat_name);

5147

return NULL;

5148

}

5149

5150

char *

5151

chase_symlinks (const char *pathspec)

5152

{

5153

#ifndef S_ISLNK

5154

return xstrdup (pathspec);

5155

#else

5156

char buf[LT_PATHMAX];

5157

struct stat s;

5158

char *tmp_pathspec = xstrdup (pathspec);

5159

char *p;

5160

int has_symlinks = 0;

5161

while (strlen (tmp_pathspec) && !has_symlinks)

5162

{

5163

lt_debugprintf (__FILE__, __LINE__,

5164

"checking path component for symlinks: %s\n",

5165

tmp_pathspec);

5166

if (lstat (tmp_pathspec, &s) == 0)

5167

{

5168

if (S_ISLNK (s.st_mode) != 0)

5169

{

5170

has_symlinks = 1;

5171

break;

5172

}

5173

5174

/* search backwards for last DIR_SEPARATOR */

5175

p = tmp_pathspec + strlen (tmp_pathspec) - 1;

5176

while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

5177

p--;

5178

if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

5179

{

5180

/* no more DIR_SEPARATORS left */

5181

break;

5182

}

5183

*p = '\0';

5184

}

5185

else

5186

{

5187

lt_fatal (__FILE__, __LINE__,

5188

"error accessing file \"%s\": %s",

5189

tmp_pathspec, nonnull (strerror (errno)));

5190

}

5191

}

5192

XFREE (tmp_pathspec);

5193

5194

if (!has_symlinks)

5195

{

5196

return xstrdup (pathspec);

5197

}

5198

5199

tmp_pathspec = realpath (pathspec, buf);

5200

if (tmp_pathspec == 0)

5201

{

5202

lt_fatal (__FILE__, __LINE__,

5203

"could not follow symlinks for %s", pathspec);

5204

}

5205

return xstrdup (tmp_pathspec);

5206

#endif

5207

}

5208

5209

char *

5210

strendzap (char *str, const char *pat)

5211

{

5212

size_t len, patlen;

5213

5214

assert (str != NULL);

5215

assert (pat != NULL);

5216

5217

len = strlen (str);

5218

patlen = strlen (pat);

5219

5220

if (patlen <= len)

5221

{

5222

str += len - patlen;

5223

if (strcmp (str, pat) == 0)

5224

*str = '\0';

5225

}

5226

return str;

5227

}

5228

5229

void

5230

lt_debugprintf (const char *file, int line, const char *fmt, ...)

5231

{

5232

va_list args;

5233

if (lt_debug)

5234

{

5235

(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);

5236

va_start (args, fmt);

5237

(void) vfprintf (stderr, fmt, args);

5238

va_end (args);

5239

}

5240

}

5241

5242

static void

5243

lt_error_core (int exit_status, const char *file,

5244

int line, const char *mode,

5245

const char *message, va_list ap)

5246

{

5247

fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);

5248

vfprintf (stderr, message, ap);

5249

fprintf (stderr, ".\n");

5250

5251

if (exit_status >= 0)

5252

exit (exit_status);

5253

}

5254

5255

void

5256

lt_fatal (const char *file, int line, const char *message, ...)

5257

{

5258

va_list ap;

5259

va_start (ap, message);

5260

lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);

5261

va_end (ap);

5262

}

5263

5264

static const char *

5265

nonnull (const char *s)

5266

{

5267

return s ? s : "(null)";

5268

}

5269

5270

static const char *

5271

nonempty (const char *s)

5272

{

5273

return (s && !*s) ? "(empty)" : nonnull (s);

5274

}

5275

5276

void

5277

lt_setenv (const char *name, const char *value)

5278

{

5279

lt_debugprintf (__FILE__, __LINE__,

5280

"(lt_setenv) setting '%s' to '%s'\n",

5281

nonnull (name), nonnull (value));

5282

{

5283

#ifdef HAVE_SETENV

5284

/* always make a copy, for consistency with !HAVE_SETENV */

5285

char *str = xstrdup (value);

5286

setenv (name, str, 1);

5287

#else

5288

int len = strlen (name) + 1 + strlen (value) + 1;

5289

char *str = XMALLOC (char, len);

5290

sprintf (str, "%s=%s", name, value);

5291

if (putenv (str) != EXIT_SUCCESS)

5292

{

5293

XFREE (str);

5294

}

5295

#endif

5296

}

5297

}

5298

5299

char *

5300

lt_extend_str (const char *orig_value, const char *add, int to_end)

5301

{

5302

char *new_value;

5303

if (orig_value && *orig_value)

5304

{

5305

int orig_value_len = strlen (orig_value);

5306

int add_len = strlen (add);

5307

new_value = XMALLOC (char, add_len + orig_value_len + 1);

5308

if (to_end)

5309

{

5310

strcpy (new_value, orig_value);

5311

strcpy (new_value + orig_value_len, add);

5312

}

5313

else

5314

{

5315

strcpy (new_value, add);

5316

strcpy (new_value + add_len, orig_value);

5317

}

5318

}

5319

else

5320

{

5321

new_value = xstrdup (add);

5322

}

5323

return new_value;

5324

}

5325

5326

void

5327

lt_update_exe_path (const char *name, const char *value)

5328

{

5329

lt_debugprintf (__FILE__, __LINE__,

5330

"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",

5331

nonnull (name), nonnull (value));

5332

5333

if (name && *name && value && *value)

5334

{

5335

char *new_value = lt_extend_str (getenv (name), value, 0);

5336

/* some systems can't cope with a ':'-terminated path #' */

5337

int len = strlen (new_value);

5338

while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))

5339

{

5340

new_value[len-1] = '\0';

5341

}

5342

lt_setenv (name, new_value);

5343

XFREE (new_value);

5344

}

5345

}

5346

5347

void

5348

lt_update_lib_path (const char *name, const char *value)

5349

{

5350

lt_debugprintf (__FILE__, __LINE__,

5351

"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",

5352

nonnull (name), nonnull (value));

5353

5354

if (name && *name && value && *value)

5355

{

5356

char *new_value = lt_extend_str (getenv (name), value, 0);

5357

lt_setenv (name, new_value);

5358

XFREE (new_value);

5359

}

5360

}

5361

5362

EOF

5363

case $host_os in

5364

mingw*)

5365

cat <<"EOF"

5366

5367

/* Prepares an argument vector before calling spawn().

5368

Note that spawn() does not by itself call the command interpreter

5369

(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :

5370

({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

5371

GetVersionEx(&v);

5372

v.dwPlatformId == VER_PLATFORM_WIN32_NT;

5373

}) ? "cmd.exe" : "command.com").

5374

Instead it simply concatenates the arguments, separated by ' ', and calls

5375

CreateProcess(). We must quote the arguments since Win32 CreateProcess()

5376

interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a

5377

special way:

5378

- Space and tab are interpreted as delimiters. They are not treated as

5379

delimiters if they are surrounded by double quotes: "...".

5380

- Unescaped double quotes are removed from the input. Their only effect is

5381

that within double quotes, space and tab are treated like normal

5382

characters.

5383

- Backslashes not followed by double quotes are not special.

5384

- But 2*n+1 backslashes followed by a double quote become

5385

n backslashes followed by a double quote (n >= 0):

5386

\" -> "

5387

\\\" -> \"

5388

\\\\\" -> \\"

5389

*/

5390

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

5391

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

5392

char **

5393

prepare_spawn (char **argv)

5394

{

5395

size_t argc;

5396

char **new_argv;

5397

size_t i;

5398

5399

/* Count number of arguments. */

5400

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

5401

;

5402

5403

/* Allocate new argument vector. */

5404

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

5405

5406

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

5407

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

5408

{

5409

const char *string = argv[i];

5410

5411

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

5412

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

5413

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

5414

{

5415

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

5416

size_t length;

5417

unsigned int backslashes;

5418

const char *s;

5419

char *quoted_string;

5420

char *p;

5421

5422

length = 0;

5423

backslashes = 0;

5424

if (quote_around)

5425

length++;

5426

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

5427

{

5428

char c = *s;

5429

if (c == '"')

5430

length += backslashes + 1;

5431

length++;

5432

if (c == '\\')

5433

backslashes++;

5434

else

5435

backslashes = 0;

5436

}

5437

if (quote_around)

5438

length += backslashes + 1;

5439

5440

quoted_string = XMALLOC (char, length + 1);

5441

5442

p = quoted_string;

5443

backslashes = 0;

5444

if (quote_around)

5445

*p++ = '"';

5446

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

5447

{

5448

char c = *s;

5449

if (c == '"')

5450

{

5451

unsigned int j;

5452

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

5453

*p++ = '\\';

5454

}

5455

*p++ = c;

5456

if (c == '\\')

5457

backslashes++;

5458

else

5459

backslashes = 0;

5460

}

5461

if (quote_around)

5462

{

5463

unsigned int j;

5464

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

5465

*p++ = '\\';

5466

*p++ = '"';

5467

}

5468

*p = '\0';

5469

5470

new_argv[i] = quoted_string;

5471

}

5472

else

5473

new_argv[i] = (char *) string;

5474

}

5475

new_argv[argc] = NULL;

5476

5477

return new_argv;

5478

}

5479

EOF

5480

;;

5481

esac

5482

5483

cat <<"EOF"

5484

void lt_dump_script (FILE* f)

5485

{

5486

EOF

5487

func_emit_wrapper yes |

5488

$SED -n -e '

5489

s/^$.\{79\}$$..*$/\1\

5490

\2/

5491

h

5492

s/$[\\"]$/\\\1/g

5493

s/$/\\n/

5494

s/$[^\n]*$.*/ fputs ("\1", f);/p

5495

g

5496

D'

5497

cat <<"EOF"

5498

}

5499

EOF

5500

}

5501

# end: func_emit_cwrapperexe_src

5502

5503

# func_win32_import_lib_p ARG

5504

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

5505

func_win32_import_lib_p ()

5506

{

5507

$opt_debug

5508

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

5509

*import*) : ;;

5510

*) false ;;

5511

esac

5512

}

5513

5514

# func_mode_link arg...

5515

func_mode_link ()

5516

{

5517

$opt_debug

5518

case $host in

5519

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

5520

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

5521

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

5522

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

5523

# flag for every libtool invocation.

5524

# allow_undefined=no

5525

5526

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

5527

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

5528

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

5529

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

5530

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

5531

allow_undefined=yes

5532

;;

5533

*)

5534

allow_undefined=yes

5535

;;

5536

esac

5537

libtool_args=$nonopt

5538

base_compile="$nonopt $@"

5539

compile_command=$nonopt

5540

finalize_command=$nonopt

5541

5542

compile_rpath=

5543

finalize_rpath=

5544

compile_shlibpath=

5545

finalize_shlibpath=

5546

convenience=

5547

old_convenience=

5548

deplibs=

5549

old_deplibs=

5550

compiler_flags=

5551

linker_flags=

5552

dllsearchpath=

5553

lib_search_path=`pwd`

5554

inst_prefix_dir=

5555

new_inherited_linker_flags=

5556

5557

avoid_version=no

5558

bindir=

5559

dlfiles=

5560

dlprefiles=

5561

dlself=no

5562

export_dynamic=no

5563

export_symbols=

5564

export_symbols_regex=

5565

generated=

5566

libobjs=

5567

ltlibs=

5568

module=no

5569

no_install=no

5570

objs=

5571

non_pic_objects=

5572

precious_files_regex=

5573

prefer_static_libs=no

5574

preload=no

5575

prev=

5576

prevarg=

5577

release=

5578

rpath=

5579

xrpath=

5580

perm_rpath=

5581

temp_rpath=

5582

thread_safe=no

5583

vinfo=

5584

vinfo_number=no

5585

weak_libs=

5586

single_module="${wl}-single_module"

5587

func_infer_tag $base_compile

5588

5589

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

5590

for arg

5591

do

5592

case $arg in

5593

-shared)

5594

test "$build_libtool_libs" != yes && \

5595

func_fatal_configuration "can not build a shared library"

5596

build_old_libs=no

5597

break

5598

;;

5599

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

5600

case $arg in

5601

-all-static)

5602

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

5603

func_warning "complete static linking is impossible in this configuration"

5604

fi

5605

if test -n "$link_static_flag"; then

5606

dlopen_self=$dlopen_self_static

5607

fi

5608

prefer_static_libs=yes

5609

;;

5610

-static)

5611

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

5612

dlopen_self=$dlopen_self_static

5613

fi

5614

prefer_static_libs=built

5615

;;

5616

-static-libtool-libs)

5617

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

5618

dlopen_self=$dlopen_self_static

5619

fi

5620

prefer_static_libs=yes

5621

;;

5622

esac

5623

build_libtool_libs=no

5624

build_old_libs=yes

5625

break

5626

;;

5627

esac

5628

done

5629

5630

# See if our shared archives depend on static archives.

5631

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

5632

5633

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

5634

while test "$#" -gt 0; do

5635

arg="$1"

5636

shift

5637

func_quote_for_eval "$arg"

5638

qarg=$func_quote_for_eval_unquoted_result

5639

libtool_args+=" $func_quote_for_eval_result"

5640

5641

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

5642

if test -n "$prev"; then

5643

case $prev in

5644

output)

5645

compile_command+=" @OUTPUT@"

5646

finalize_command+=" @OUTPUT@"

5647

;;

5648

esac

5649

5650

case $prev in

5651

bindir)

5652

bindir="$arg"

5653

prev=

5654

continue

5655

;;

5656

dlfiles|dlprefiles)

5657

if test "$preload" = no; then

5658

# Add the symbol object into the linking commands.

5659

compile_command+=" @SYMFILE@"

5660

finalize_command+=" @SYMFILE@"

5661

preload=yes

5662

fi

5663

case $arg in

5664

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

5665

force)

5666

if test "$dlself" = no; then

5667

dlself=needless

5668

export_dynamic=yes

5669

fi

5670

prev=

5671

continue

5672

;;

5673

self)

5674

if test "$prev" = dlprefiles; then

5675

dlself=yes

5676

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

5677

dlself=yes

5678

else

5679

dlself=needless

5680

export_dynamic=yes

5681

fi

5682

prev=

5683

continue

5684

;;

5685

*)

5686

if test "$prev" = dlfiles; then

5687

dlfiles+=" $arg"

5688

else

5689

dlprefiles+=" $arg"

5690

fi

5691

prev=

5692

continue

5693

;;

5694

esac

5695

;;

5696

expsyms)

5697

export_symbols="$arg"

5698

test -f "$arg" \

5699

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

5700

prev=

5701

continue

5702

;;

5703

expsyms_regex)

5704

export_symbols_regex="$arg"

5705

prev=

5706

continue

5707

;;

5708

framework)

5709

case $host in

5710

*-*-darwin*)

5711

case "$deplibs " in

5712

*" $qarg.ltframework "*) ;;

5713

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

5714

;;

5715

esac

5716

;;

5717

esac

5718

prev=

5719

continue

5720

;;

5721

inst_prefix)

5722

inst_prefix_dir="$arg"

5723

prev=

5724

continue

5725

;;

5726

objectlist)

5727

if test -f "$arg"; then

5728

save_arg=$arg

5729

moreargs=

5730

for fil in `cat "$save_arg"`

5731

do

5732

# moreargs+=" $fil"

5733

arg=$fil

5734

# A libtool-controlled object.

5735

5736

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

5737

if func_lalib_unsafe_p "$arg"; then

5738

pic_object=

5739

non_pic_object=

5740

5741

# Read the .lo file

5742

func_source "$arg"

5743

5744

if test -z "$pic_object" ||

5745

test -z "$non_pic_object" ||

5746

test "$pic_object" = none &&

5747

test "$non_pic_object" = none; then

5748

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

5749

fi

5750

5751

# Extract subdirectory from the argument.

5752

func_dirname "$arg" "/" ""

5753

xdir="$func_dirname_result"

5754

5755

if test "$pic_object" != none; then

5756

# Prepend the subdirectory the object is found in.

5757

pic_object="$xdir$pic_object"

5758

5759

if test "$prev" = dlfiles; then

5760

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

5761

dlfiles+=" $pic_object"

5762

prev=

5763

continue

5764

else

5765

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

5766

prev=dlprefiles

5767

fi

5768

fi

5769

5770

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

5771

if test "$prev" = dlprefiles; then

5772

# Preload the old-style object.

5773

dlprefiles+=" $pic_object"

5774

prev=

5775

fi

5776

5777

# A PIC object.

5778

libobjs+=" $pic_object"

5779

arg="$pic_object"

5780

fi

5781

5782

# Non-PIC object.

5783

if test "$non_pic_object" != none; then

5784

# Prepend the subdirectory the object is found in.

5785

non_pic_object="$xdir$non_pic_object"

5786

5787

# A standard non-PIC object

5788

non_pic_objects+=" $non_pic_object"

5789

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

5790

arg="$non_pic_object"

5791

fi

5792

else

5793

# If the PIC object exists, use it instead.

5794

# $xdir was prepended to $pic_object above.

5795

non_pic_object="$pic_object"

5796

non_pic_objects+=" $non_pic_object"

5797

fi

5798

else

5799

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

5800

if $opt_dry_run; then

5801

# Extract subdirectory from the argument.

5802

func_dirname "$arg" "/" ""

5803

xdir="$func_dirname_result"

5804

5805

func_lo2o "$arg"

5806

pic_object=$xdir$objdir/$func_lo2o_result

5807

non_pic_object=$xdir$func_lo2o_result

5808

libobjs+=" $pic_object"

5809

non_pic_objects+=" $non_pic_object"

5810

else

5811

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

5812

fi

5813

fi

5814

done

5815

else

5816

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

5817

fi

5818

arg=$save_arg

5819

prev=

5820

continue

5821

;;

5822

precious_regex)

5823

precious_files_regex="$arg"

5824

prev=

5825

continue

5826

;;

5827

release)

5828

release="-$arg"

5829

prev=

5830

continue

5831

;;

5832

rpath | xrpath)

5833

# We need an absolute path.

5834

case $arg in

5835

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

5836

*)

5837

func_fatal_error "only absolute run-paths are allowed"

5838

;;

5839

esac

5840

if test "$prev" = rpath; then

5841

case "$rpath " in

5842

*" $arg "*) ;;

5843

*) rpath+=" $arg" ;;

5844

esac

5845

else

5846

case "$xrpath " in

5847

*" $arg "*) ;;

5848

*) xrpath+=" $arg" ;;

5849

esac

5850

fi

5851

prev=

5852

continue

5853

;;

5854

shrext)

5855

shrext_cmds="$arg"

5856

prev=

5857

continue

5858

;;

5859

weak)

5860

weak_libs+=" $arg"

5861

prev=

5862

continue

5863

;;

5864

xcclinker)

5865

linker_flags+=" $qarg"

5866

compiler_flags+=" $qarg"

5867

prev=

5868

compile_command+=" $qarg"

5869

finalize_command+=" $qarg"

5870

continue

5871

;;

5872

xcompiler)

5873

compiler_flags+=" $qarg"

5874

prev=

5875

compile_command+=" $qarg"

5876

finalize_command+=" $qarg"

5877

continue

5878

;;

5879

xlinker)

5880

linker_flags+=" $qarg"

5881

compiler_flags+=" $wl$qarg"

5882

prev=

5883

compile_command+=" $wl$qarg"

5884

finalize_command+=" $wl$qarg"

5885

continue

5886

;;

5887

*)

5888

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

5889

prev=

5890

continue

5891

;;

5892

esac

5893

fi # test -n "$prev"

5894

5895

prevarg="$arg"

5896

5897

case $arg in

5898

-all-static)

5899

if test -n "$link_static_flag"; then

5900

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

5901

compile_command+=" $link_static_flag"

5902

finalize_command+=" $link_static_flag"

5903

fi

5904

continue

5905

;;

5906

5907

-allow-undefined)

5908

# FIXME: remove this flag sometime in the future.

5909

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

5910

;;

5911

5912

-avoid-version)

5913

avoid_version=yes

5914

continue

5915

;;

5916

5917

-bindir)

5918

prev=bindir

5919

continue

5920

;;

5921

5922

-dlopen)

5923

prev=dlfiles

5924

continue

5925

;;

5926

5927

-dlpreopen)

5928

prev=dlprefiles

5929

continue

5930

;;

5931

5932

-export-dynamic)

5933

export_dynamic=yes

5934

continue

5935

;;

5936

5937

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

5938

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

5939

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

5940

fi

5941

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

5942

prev=expsyms

5943

else

5944

prev=expsyms_regex

5945

fi

5946

continue

5947

;;

5948

5949

-framework)

5950

prev=framework

5951

continue

5952

;;

5953

5954

-inst-prefix-dir)

5955

prev=inst_prefix

5956

continue

5957

;;

5958

5959

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

5960

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

5961

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

5962

case $with_gcc/$host in

5963

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

5964

compile_command+=" $arg"

5965

finalize_command+=" $arg"

5966

;;

5967

esac

5968

continue

5969

;;

5970

5971

-L*)

5972

func_stripname "-L" '' "$arg"

5973

if test -z "$func_stripname_result"; then

5974

if test "$#" -gt 0; then

5975

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

5976

else

5977

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

5978

fi

5979

fi

5980

func_resolve_sysroot "$func_stripname_result"

5981

dir=$func_resolve_sysroot_result

5982

# We need an absolute path.

5983

case $dir in

5984

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

5985

*)

5986

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

5987

test -z "$absdir" && \

5988

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

5989

dir="$absdir"

5990

;;

5991

esac

5992

case "$deplibs " in

5993

*" -L$dir "* | *" $arg "*)

5994

# Will only happen for absolute or sysroot arguments

5995

;;

5996

*)

5997

# Preserve sysroot, but never include relative directories

5998

case $dir in

5999

[\\/]* | [A-Za-z]:[\\/]* | =*) deplibs+=" $arg" ;;

6000

*) deplibs+=" -L$dir" ;;

6001

esac

6002

lib_search_path+=" $dir"

6003

;;

6004

esac

6005

case $host in

6006

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

6007

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

6008

case :$dllsearchpath: in

6009

*":$dir:"*) ;;

6010

::) dllsearchpath=$dir;;

6011

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

6012

esac

6013

case :$dllsearchpath: in

6014

*":$testbindir:"*) ;;

6015

::) dllsearchpath=$testbindir;;

6016

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

6017

esac

6018

;;

6019

esac

6020

continue

6021

;;

6022

6023

-l*)

6024

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

6025

case $host in

6026

6027

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

6028

continue

6029

;;

6030

*-*-os2*)

6031

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

6032

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

6033

;;

6034

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

6035

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

6036

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

6037

;;

6038

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

6039

# Rhapsody C and math libraries are in the System framework

6040

deplibs+=" System.ltframework"

6041

continue

6042

;;

6043

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

6044

# Causes problems with __ctype

6045

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

6046

;;

6047

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

6048

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

6049

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

6050

;;

6051

esac

6052

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

6053

case $host in

6054

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

6055

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

6056

continue

6057

;;

6058

esac

6059

fi

6060

deplibs+=" $arg"

6061

continue

6062

;;

6063

6064

-module)

6065

module=yes

6066

continue

6067

;;

6068

6069

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

6070

# classes, name mangling, and exception handling.

6071

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

6072

-model|-arch|-isysroot|--sysroot)

6073

compiler_flags+=" $arg"

6074

compile_command+=" $arg"

6075

finalize_command+=" $arg"

6076

prev=xcompiler

6077

continue

6078

;;

6079

6080

6081

6082

compiler_flags+=" $arg"

6083

compile_command+=" $arg"

6084

finalize_command+=" $arg"

6085

case "$new_inherited_linker_flags " in

6086

*" $arg "*) ;;

6087

* ) new_inherited_linker_flags+=" $arg" ;;

6088

esac

6089

continue

6090

;;

6091

6092

-multi_module)

6093

single_module="${wl}-multi_module"

6094

continue

6095

;;

6096

6097

-no-fast-install)

6098

fast_install=no

6099

continue

6100

;;

6101

6102

-no-install)

6103

case $host in

6104

6105

# The PATH hackery in wrapper scripts is required on Windows

6106

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

6107

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

6108

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

6109

fast_install=no

6110

;;

6111

*) no_install=yes ;;

6112

esac

6113

continue

6114

;;

6115

6116

-no-undefined)

6117

allow_undefined=no

6118

continue

6119

;;

6120

6121

-objectlist)

6122

prev=objectlist

6123

continue

6124

;;

6125

6126

-o) prev=output ;;

6127

6128

-precious-files-regex)

6129

prev=precious_regex

6130

continue

6131

;;

6132

6133

-release)

6134

prev=release

6135

continue

6136

;;

6137

6138

-rpath)

6139

prev=rpath

6140

continue

6141

;;

6142

6143

-R)

6144

prev=xrpath

6145

continue

6146

;;

6147

6148

-R*)

6149

func_stripname '-R' '' "$arg"

6150

dir=$func_stripname_result

6151

# We need an absolute path.

6152

case $dir in

6153

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

6154

=*)

6155

func_stripname '=' '' "$dir"

6156

dir=$lt_sysroot$func_stripname_result

6157

;;

6158

*)

6159

func_fatal_error "only absolute run-paths are allowed"

6160

;;

6161

esac

6162

case "$xrpath " in

6163

*" $dir "*) ;;

6164

*) xrpath+=" $dir" ;;

6165

esac

6166

continue

6167

;;

6168

6169

-shared)

6170

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

6171

continue

6172

;;

6173

6174

-shrext)

6175

prev=shrext

6176

continue

6177

;;

6178

6179

-static | -static-libtool-libs)

6180

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

6181

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

6182

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

6183

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

6184

# Digital Unix and AIX.

6185

continue

6186

;;

6187

6188

-thread-safe)

6189

thread_safe=yes

6190

continue

6191

;;

6192

6193

-version-info)

6194

prev=vinfo

6195

continue

6196

;;

6197

6198

-version-number)

6199

prev=vinfo

6200

vinfo_number=yes

6201

continue

6202

;;

6203

6204

-weak)

6205

prev=weak

6206

continue

6207

;;

6208

6209

-Wc,*)

6210

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

6211

args=$func_stripname_result

6212

arg=

6213

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

6214

for flag in $args; do

6215

IFS="$save_ifs"

6216

func_quote_for_eval "$flag"

6217

arg+=" $func_quote_for_eval_result"

6218

compiler_flags+=" $func_quote_for_eval_result"

6219

done

6220

IFS="$save_ifs"

6221

func_stripname ' ' '' "$arg"

6222

arg=$func_stripname_result

6223

;;

6224

6225

-Wl,*)

6226

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

6227

args=$func_stripname_result

6228

arg=

6229

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

6230

for flag in $args; do

6231

IFS="$save_ifs"

6232

func_quote_for_eval "$flag"

6233

arg+=" $wl$func_quote_for_eval_result"

6234

compiler_flags+=" $wl$func_quote_for_eval_result"

6235

linker_flags+=" $func_quote_for_eval_result"

6236

done

6237

IFS="$save_ifs"

6238

func_stripname ' ' '' "$arg"

6239

arg=$func_stripname_result

6240

;;

6241

6242

-Xcompiler)

6243

prev=xcompiler

6244

continue

6245

;;

6246

6247

-Xlinker)

6248

prev=xlinker

6249

continue

6250

;;

6251

6252

-XCClinker)

6253

prev=xcclinker

6254

continue

6255

;;

6256

6257

# -msg_* for osf cc

6258

-msg_*)

6259

func_quote_for_eval "$arg"

6260

arg="$func_quote_for_eval_result"

6261

;;

6262

6263

# Flags to be passed through unchanged, with rationale:

6264

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

6265

# -r[0-9][0-9]* specify processor for the SGI compiler

6266

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

6267

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

6268

# -q* compiler args for the IBM compiler

6269

# -m*, -t[45]*, -txscale* architecture-specific flags for GCC

6270

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

6271

# -p, -pg, --coverage, -fprofile-* profiling flags for GCC

6272

# @file GCC response files

6273

# -tp=* Portland pgcc target processor selection

6274

# --sysroot=* for sysroot support

6275

# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

6276

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

6277

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

6278

-O*|-flto*|-fwhopr*|-fuse-linker-plugin)

6279

func_quote_for_eval "$arg"

6280

arg="$func_quote_for_eval_result"

6281

compile_command+=" $arg"

6282

finalize_command+=" $arg"

6283

compiler_flags+=" $arg"

6284

continue

6285

;;

6286

6287

# Some other compiler flag.

6288

-* | +*)

6289

func_quote_for_eval "$arg"

6290

arg="$func_quote_for_eval_result"

6291

;;

6292

6293

*.$objext)

6294

# A standard object.

6295

objs+=" $arg"

6296

;;

6297

6298

*.lo)

6299

# A libtool-controlled object.

6300

6301

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

6302

if func_lalib_unsafe_p "$arg"; then

6303

pic_object=

6304

non_pic_object=

6305

6306

# Read the .lo file

6307

func_source "$arg"

6308

6309

if test -z "$pic_object" ||

6310

test -z "$non_pic_object" ||

6311

test "$pic_object" = none &&

6312

test "$non_pic_object" = none; then

6313

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

6314

fi

6315

6316

# Extract subdirectory from the argument.

6317

func_dirname "$arg" "/" ""

6318

xdir="$func_dirname_result"

6319

6320

if test "$pic_object" != none; then

6321

# Prepend the subdirectory the object is found in.

6322

pic_object="$xdir$pic_object"

6323

6324

if test "$prev" = dlfiles; then

6325

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

6326

dlfiles+=" $pic_object"

6327

prev=

6328

continue

6329

else

6330

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

6331

prev=dlprefiles

6332

fi

6333

fi

6334

6335

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

6336

if test "$prev" = dlprefiles; then

6337

# Preload the old-style object.

6338

dlprefiles+=" $pic_object"

6339

prev=

6340

fi

6341

6342

# A PIC object.

6343

libobjs+=" $pic_object"

6344

arg="$pic_object"

6345

fi

6346

6347

# Non-PIC object.

6348

if test "$non_pic_object" != none; then

6349

# Prepend the subdirectory the object is found in.

6350

non_pic_object="$xdir$non_pic_object"

6351

6352

# A standard non-PIC object

6353

non_pic_objects+=" $non_pic_object"

6354

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

6355

arg="$non_pic_object"

6356

fi

6357

else

6358

# If the PIC object exists, use it instead.

6359

# $xdir was prepended to $pic_object above.

6360

non_pic_object="$pic_object"

6361

non_pic_objects+=" $non_pic_object"

6362

fi

6363

else

6364

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

6365

if $opt_dry_run; then

6366

# Extract subdirectory from the argument.

6367

func_dirname "$arg" "/" ""

6368

xdir="$func_dirname_result"

6369

6370

func_lo2o "$arg"

6371

pic_object=$xdir$objdir/$func_lo2o_result

6372

non_pic_object=$xdir$func_lo2o_result

6373

libobjs+=" $pic_object"

6374

non_pic_objects+=" $non_pic_object"

6375

else

6376

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

6377

fi

6378

fi

6379

;;

6380

6381

*.$libext)

6382

# An archive.

6383

deplibs+=" $arg"

6384

old_deplibs+=" $arg"

6385

continue

6386

;;

6387

6388

*.la)

6389

# A libtool-controlled library.

6390

6391

func_resolve_sysroot "$arg"

6392

if test "$prev" = dlfiles; then

6393

# This library was specified with -dlopen.

6394

dlfiles+=" $func_resolve_sysroot_result"

6395

prev=

6396

elif test "$prev" = dlprefiles; then

6397

# The library was specified with -dlpreopen.

6398

dlprefiles+=" $func_resolve_sysroot_result"

6399

prev=

6400

else

6401

deplibs+=" $func_resolve_sysroot_result"

6402

fi

6403

continue

6404

;;

6405

6406

# Some other compiler argument.

6407

*)

6408

# Unknown arguments in both finalize_command and compile_command need

6409

# to be aesthetically quoted because they are evaled later.

6410

func_quote_for_eval "$arg"

6411

arg="$func_quote_for_eval_result"

6412

;;

6413

esac # arg

6414

6415

# Now actually substitute the argument into the commands.

6416

if test -n "$arg"; then

6417

compile_command+=" $arg"

6418

finalize_command+=" $arg"

6419

fi

6420

done # argument parsing loop

6421

6422

test -n "$prev" && \

6423

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

6424

6425

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

6426

eval arg=\"$export_dynamic_flag_spec\"

6427

compile_command+=" $arg"

6428

finalize_command+=" $arg"

6429

fi

6430

6431

oldlibs=

6432

# calculate the name of the file, without its directory

6433

func_basename "$output"

6434

outputname="$func_basename_result"

6435

libobjs_save="$libobjs"

6436

6437

if test -n "$shlibpath_var"; then

6438

# get the directories listed in $shlibpath_var

6439

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

6440

else

6441

shlib_search_path=

6442

fi

6443

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

6444

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

6445

6446

func_dirname "$output" "/" ""

6447

output_objdir="$func_dirname_result$objdir"

6448

func_to_tool_file "$output_objdir/"

6449

tool_output_objdir=$func_to_tool_file_result

6450

# Create the object directory.

6451

func_mkdir_p "$output_objdir"

6452

6453

# Determine the type of output

6454

case $output in

6455

"")

6456

func_fatal_help "you must specify an output file"

6457

;;

6458

*.$libext) linkmode=oldlib ;;

6459

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

6460

*.la) linkmode=lib ;;

6461

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

6462

esac

6463

6464

specialdeplibs=

6465

6466

libs=

6467

# Find all interdependent deplibs by searching for libraries

6468

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

6469

for deplib in $deplibs; do

6470

if $opt_preserve_dup_deps ; then

6471

case "$libs " in

6472

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

6473

esac

6474

fi

6475

libs+=" $deplib"

6476

done

6477

6478

if test "$linkmode" = lib; then

6479

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

6480

6481

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

6482

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

6483

# not to be eliminated).

6484

pre_post_deps=

6485

if $opt_duplicate_compiler_generated_deps; then

6486

for pre_post_dep in $predeps $postdeps; do

6487

case "$pre_post_deps " in

6488

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

6489

esac

6490

pre_post_deps+=" $pre_post_dep"

6491

done

6492

fi

6493

pre_post_deps=

6494

fi

6495

6496

deplibs=

6497

newdependency_libs=

6498

newlib_search_path=

6499

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

6500

notinst_deplibs= # not-installed libtool libraries

6501

notinst_path= # paths that contain not-installed libtool libraries

6502

6503

case $linkmode in

6504

lib)

6505

passes="conv dlpreopen link"

6506

for file in $dlfiles $dlprefiles; do

6507

case $file in

6508

*.la) ;;

6509

*)

6510

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

6511

;;

6512

esac

6513

done

6514

;;

6515

prog)

6516

compile_deplibs=

6517

finalize_deplibs=

6518

alldeplibs=no

6519

newdlfiles=

6520

newdlprefiles=

6521

passes="conv scan dlopen dlpreopen link"

6522

;;

6523

*) passes="conv"

6524

;;

6525

esac

6526

6527

for pass in $passes; do

6528

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

6529

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

6530

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

6531

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

6532

## order, and fix it there properly

6533

tmp_deplibs=

6534

for deplib in $deplibs; do

6535

tmp_deplibs="$deplib $tmp_deplibs"

6536

done

6537

deplibs="$tmp_deplibs"

6538

fi

6539

6540

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

6541

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

6542

libs="$deplibs"

6543

deplibs=

6544

fi

6545

if test "$linkmode" = prog; then

6546

case $pass in

6547

dlopen) libs="$dlfiles" ;;

6548

dlpreopen) libs="$dlprefiles" ;;

6549

link)

6550

libs="$deplibs %DEPLIBS%"

6551

test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"

6552

;;

6553

esac

6554

fi

6555

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

6556

# Collect and forward deplibs of preopened libtool libs

6557

for lib in $dlprefiles; do

6558

# Ignore non-libtool-libs

6559

dependency_libs=

6560

func_resolve_sysroot "$lib"

6561

case $lib in

6562

*.la) func_source "$func_resolve_sysroot_result" ;;

6563

esac

6564

6565

# Collect preopened libtool deplibs, except any this library

6566

# has declared as weak libs

6567

for deplib in $dependency_libs; do

6568

func_basename "$deplib"

6569

deplib_base=$func_basename_result

6570

case " $weak_libs " in

6571

*" $deplib_base "*) ;;

6572

*) deplibs+=" $deplib" ;;

6573

esac

6574

done

6575

done

6576

libs="$dlprefiles"

6577

fi

6578

if test "$pass" = dlopen; then

6579

# Collect dlpreopened libraries

6580

save_deplibs="$deplibs"

6581

deplibs=

6582

fi

6583

6584

for deplib in $libs; do

6585

lib=

6586

found=no

6587

case $deplib in

6588

6589

6590

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

6591

compile_deplibs="$deplib $compile_deplibs"

6592

finalize_deplibs="$deplib $finalize_deplibs"

6593

else

6594

compiler_flags+=" $deplib"

6595

if test "$linkmode" = lib ; then

6596

case "$new_inherited_linker_flags " in

6597

*" $deplib "*) ;;

6598

* ) new_inherited_linker_flags+=" $deplib" ;;

6599

esac

6600

fi

6601

fi

6602

continue

6603

;;

6604

-l*)

6605

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

6606

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

6607

continue

6608

fi

6609

func_stripname '-l' '' "$deplib"

6610

name=$func_stripname_result

6611

if test "$linkmode" = lib; then

6612

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

6613

else

6614

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

6615

fi

6616

for searchdir in $searchdirs; do

6617

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

6618

# Search the libtool library

6619

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

6620

if test -f "$lib"; then

6621

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

6622

found=yes

6623

else

6624

found=no

6625

fi

6626

break 2

6627

fi

6628

done

6629

done

6630

if test "$found" != yes; then

6631

# deplib doesn't seem to be a libtool library

6632

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

6633

compile_deplibs="$deplib $compile_deplibs"

6634

finalize_deplibs="$deplib $finalize_deplibs"

6635

else

6636

deplibs="$deplib $deplibs"

6637

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

6638

fi

6639

continue

6640

else # deplib is a libtool library

6641

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

6642

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

6643

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

6644

case " $predeps $postdeps " in

6645

*" $deplib "*)

6646

if func_lalib_p "$lib"; then

6647

library_names=

6648

old_library=

6649

func_source "$lib"

6650

for l in $old_library $library_names; do

6651

ll="$l"

6652

done

6653

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

6654

found=no

6655

func_dirname "$lib" "" "."

6656

ladir="$func_dirname_result"

6657

lib=$ladir/$old_library

6658

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

6659

compile_deplibs="$deplib $compile_deplibs"

6660

finalize_deplibs="$deplib $finalize_deplibs"

6661

else

6662

deplibs="$deplib $deplibs"

6663

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

6664

fi

6665

continue

6666

fi

6667

fi

6668

;;

6669

*) ;;

6670

esac

6671

fi

6672

fi

6673

;; # -l

6674

*.ltframework)

6675

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

6676

compile_deplibs="$deplib $compile_deplibs"

6677

finalize_deplibs="$deplib $finalize_deplibs"

6678

else

6679

deplibs="$deplib $deplibs"

6680

if test "$linkmode" = lib ; then

6681

case "$new_inherited_linker_flags " in

6682

*" $deplib "*) ;;

6683

* ) new_inherited_linker_flags+=" $deplib" ;;

6684

esac

6685

fi

6686

fi

6687

continue

6688

;;

6689

-L*)

6690

case $linkmode in

6691

lib)

6692

deplibs="$deplib $deplibs"

6693

test "$pass" = conv && continue

6694

newdependency_libs="$deplib $newdependency_libs"

6695

func_stripname '-L' '' "$deplib"

6696

func_resolve_sysroot "$func_stripname_result"

6697

newlib_search_path+=" $func_resolve_sysroot_result"

6698

;;

6699

prog)

6700

if test "$pass" = conv; then

6701

deplibs="$deplib $deplibs"

6702

continue

6703

fi

6704

if test "$pass" = scan; then

6705

deplibs="$deplib $deplibs"

6706

else

6707

compile_deplibs="$deplib $compile_deplibs"

6708

finalize_deplibs="$deplib $finalize_deplibs"

6709

fi

6710

func_stripname '-L' '' "$deplib"

6711

func_resolve_sysroot "$func_stripname_result"

6712

newlib_search_path+=" $func_resolve_sysroot_result"

6713

;;

6714

*)

6715

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

6716

;;

6717

esac # linkmode

6718

continue

6719

;; # -L

6720

-R*)

6721

if test "$pass" = link; then

6722

func_stripname '-R' '' "$deplib"

6723

func_resolve_sysroot "$func_stripname_result"

6724

dir=$func_resolve_sysroot_result

6725

# Make sure the xrpath contains only unique directories.

6726

case "$xrpath " in

6727

*" $dir "*) ;;

6728

*) xrpath+=" $dir" ;;

6729

esac

6730

fi

6731

deplibs="$deplib $deplibs"

6732

continue

6733

;;

6734

*.la)

6735

func_resolve_sysroot "$deplib"

6736

lib=$func_resolve_sysroot_result

6737

;;

6738

*.$libext)

6739

if test "$pass" = conv; then

6740

deplibs="$deplib $deplibs"

6741

continue

6742

fi

6743

case $linkmode in

6744

lib)

6745

# Linking convenience modules into shared libraries is allowed,

6746

# but linking other static libraries is non-portable.

6747

case " $dlpreconveniencelibs " in

6748

*" $deplib "*) ;;

6749

*)

6750

valid_a_lib=no

6751

case $deplibs_check_method in

6752

match_pattern*)

6753

set dummy $deplibs_check_method; shift

6754

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

6755

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

6756

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

6757

valid_a_lib=yes

6758

fi

6759

;;

6760

pass_all)

6761

valid_a_lib=yes

6762

;;

6763

esac

6764

if test "$valid_a_lib" != yes; then

6765

echo

6766

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

6767

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

6768

echo "*** you link to this library. But I can only do this if you have a"

6769

echo "*** shared version of the library, which you do not appear to have"

6770

echo "*** because the file extensions .$libext of this argument makes me believe"

6771

echo "*** that it is just a static archive that I should not use here."

6772

else

6773

echo

6774

$ECHO "*** Warning: Linking the shared library $output against the"

6775

$ECHO "*** static library $deplib is not portable!"

6776

deplibs="$deplib $deplibs"

6777

fi

6778

;;

6779

esac

6780

continue

6781

;;

6782

prog)

6783

if test "$pass" != link; then

6784

deplibs="$deplib $deplibs"

6785

else

6786

compile_deplibs="$deplib $compile_deplibs"

6787

finalize_deplibs="$deplib $finalize_deplibs"

6788

fi

6789

continue

6790

;;

6791

esac # linkmode

6792

;; # *.$libext

6793

*.lo | *.$objext)

6794

if test "$pass" = conv; then

6795

deplibs="$deplib $deplibs"

6796

elif test "$linkmode" = prog; then

6797

if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

6798

# If there is no dlopen support or we're linking statically,

6799

# we need to preload.

6800

newdlprefiles+=" $deplib"

6801

compile_deplibs="$deplib $compile_deplibs"

6802

finalize_deplibs="$deplib $finalize_deplibs"

6803

else

6804

newdlfiles+=" $deplib"

6805

fi

6806

fi

6807

continue

6808

;;

6809

%DEPLIBS%)

6810

alldeplibs=yes

6811

continue

6812

;;

6813

esac # case $deplib

6814

6815

if test "$found" = yes || test -f "$lib"; then :

6816

else

6817

func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

6818

fi

6819

6820

# Check to see that this really is a libtool archive.

6821

func_lalib_unsafe_p "$lib" \

6822

|| func_fatal_error "\`$lib' is not a valid libtool archive"

6823

6824

func_dirname "$lib" "" "."

6825

ladir="$func_dirname_result"

6826

6827

dlname=

6828

dlopen=

6829

dlpreopen=

6830

libdir=

6831

library_names=

6832

old_library=

6833

inherited_linker_flags=

6834

# If the library was installed with an old release of libtool,

6835

# it will not redefine variables installed, or shouldnotlink

6836

installed=yes

6837

shouldnotlink=no

6838

avoidtemprpath=

6839

6840

6841

# Read the .la file

6842

func_source "$lib"

6843

6844

# Convert "-framework foo" to "foo.ltframework"

6845

if test -n "$inherited_linker_flags"; then

6846

tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $[^ $]*$/\1.ltframework/g'`

6847

for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

6848

case " $new_inherited_linker_flags " in

6849

*" $tmp_inherited_linker_flag "*) ;;

6850

*) new_inherited_linker_flags+=" $tmp_inherited_linker_flag";;

6851

esac

6852

done

6853

fi

6854

dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6855

if test "$linkmode,$pass" = "lib,link" ||

6856

test "$linkmode,$pass" = "prog,scan" ||

6857

{ test "$linkmode" != prog && test "$linkmode" != lib; }; then

6858

test -n "$dlopen" && dlfiles+=" $dlopen"

6859

test -n "$dlpreopen" && dlprefiles+=" $dlpreopen"

6860

fi

6861

6862

if test "$pass" = conv; then

6863

# Only check for convenience libraries

6864

deplibs="$lib $deplibs"

6865

if test -z "$libdir"; then

6866

if test -z "$old_library"; then

6867

func_fatal_error "cannot find name of link library for \`$lib'"

6868

fi

6869

# It is a libtool convenience library, so add in its objects.

6870

convenience+=" $ladir/$objdir/$old_library"

6871

old_convenience+=" $ladir/$objdir/$old_library"

6872

tmp_libs=

6873

for deplib in $dependency_libs; do

6874

deplibs="$deplib $deplibs"

6875

if $opt_preserve_dup_deps ; then

6876

case "$tmp_libs " in

6877

*" $deplib "*) specialdeplibs+=" $deplib" ;;

6878

esac

6879

fi

6880

tmp_libs+=" $deplib"

6881

done

6882

elif test "$linkmode" != prog && test "$linkmode" != lib; then

6883

func_fatal_error "\`$lib' is not a convenience library"

6884

fi

6885

continue

6886

fi # $pass = conv

6887

6888

6889

# Get the name of the library we link against.

6890

linklib=

6891

if test -n "$old_library" &&

6892

{ test "$prefer_static_libs" = yes ||

6893

test "$prefer_static_libs,$installed" = "built,no"; }; then

6894

linklib=$old_library

6895

else

6896

for l in $old_library $library_names; do

6897

linklib="$l"

6898

done

6899

fi

6900

if test -z "$linklib"; then

6901

func_fatal_error "cannot find name of link library for \`$lib'"

6902

fi

6903

6904

# This library was specified with -dlopen.

6905

if test "$pass" = dlopen; then

6906

if test -z "$libdir"; then

6907

func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

6908

fi

6909

if test -z "$dlname" ||

6910

test "$dlopen_support" != yes ||

6911

test "$build_libtool_libs" = no; then

6912

# If there is no dlname, no dlopen support or we're linking

6913

# statically, we need to preload. We also need to preload any

6914

# dependent libraries so libltdl's deplib preloader doesn't

6915

# bomb out in the load deplibs phase.

6916

dlprefiles+=" $lib $dependency_libs"

6917

else

6918

newdlfiles+=" $lib"

6919

fi

6920

continue

6921

fi # $pass = dlopen

6922

6923

# We need an absolute path.

6924

case $ladir in

6925

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

6926

*)

6927

abs_ladir=`cd "$ladir" && pwd`

6928

if test -z "$abs_ladir"; then

6929

func_warning "cannot determine absolute directory name of \`$ladir'"

6930

func_warning "passing it literally to the linker, although it might fail"

6931

abs_ladir="$ladir"

6932

fi

6933

;;

6934

esac

6935

func_basename "$lib"

6936

laname="$func_basename_result"

6937

6938

# Find the relevant object directory and library name.

6939

if test "X$installed" = Xyes; then

6940

if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6941

func_warning "library \`$lib' was moved."

6942

dir="$ladir"

6943

absdir="$abs_ladir"

6944

libdir="$abs_ladir"

6945

else

6946

dir="$lt_sysroot$libdir"

6947

absdir="$lt_sysroot$libdir"

6948

fi

6949

test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

6950

else

6951

if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6952

dir="$ladir"

6953

absdir="$abs_ladir"

6954

# Remove this search path later

6955

notinst_path+=" $abs_ladir"

6956

else

6957

dir="$ladir/$objdir"

6958

absdir="$abs_ladir/$objdir"

6959

# Remove this search path later

6960

notinst_path+=" $abs_ladir"

6961

fi

6962

fi # $installed = yes

6963

func_stripname 'lib' '.la' "$laname"

6964

name=$func_stripname_result

6965

6966

# This library was specified with -dlpreopen.

6967

if test "$pass" = dlpreopen; then

6968

if test -z "$libdir" && test "$linkmode" = prog; then

6969

func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

6970

fi

6971

case "$host" in

6972

# special handling for platforms with PE-DLLs.

6973

*cygwin* | *mingw* | *cegcc* )

6974

# Linker will automatically link against shared library if both

6975

# static and shared are present. Therefore, ensure we extract

6976

# symbols from the import library if a shared library is present

6977

# (otherwise, the dlopen module name will be incorrect). We do

6978

# this by putting the import library name into $newdlprefiles.

6979

# We recover the dlopen module name by 'saving' the la file

6980

# name in a special purpose variable, and (later) extracting the

6981

# dlname from the la file.

6982

if test -n "$dlname"; then

6983

func_tr_sh "$dir/$linklib"

6984

eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"

6985

newdlprefiles+=" $dir/$linklib"

6986

else

6987

newdlprefiles+=" $dir/$old_library"

6988

# Keep a list of preopened convenience libraries to check

6989

# that they are being used correctly in the link pass.

6990

test -z "$libdir" && \

6991

dlpreconveniencelibs+=" $dir/$old_library"

6992

fi

6993

;;

6994

* )

6995

# Prefer using a static library (so that no silly _DYNAMIC symbols

6996

# are required to link).

6997

if test -n "$old_library"; then

6998

newdlprefiles+=" $dir/$old_library"

6999

# Keep a list of preopened convenience libraries to check

7000

# that they are being used correctly in the link pass.

7001

test -z "$libdir" && \

7002

dlpreconveniencelibs+=" $dir/$old_library"

7003

# Otherwise, use the dlname, so that lt_dlopen finds it.

7004

elif test -n "$dlname"; then

7005

newdlprefiles+=" $dir/$dlname"

7006

else

7007

newdlprefiles+=" $dir/$linklib"

7008

fi

7009

;;

7010

esac

7011

fi # $pass = dlpreopen

7012

7013

if test -z "$libdir"; then

7014

# Link the convenience library

7015

if test "$linkmode" = lib; then

7016

deplibs="$dir/$old_library $deplibs"

7017

elif test "$linkmode,$pass" = "prog,link"; then

7018

compile_deplibs="$dir/$old_library $compile_deplibs"

7019

finalize_deplibs="$dir/$old_library $finalize_deplibs"

7020

else

7021

deplibs="$lib $deplibs" # used for prog,scan pass

7022

fi

7023

continue

7024

fi

7025

7026

7027

if test "$linkmode" = prog && test "$pass" != link; then

7028

newlib_search_path+=" $ladir"

7029

deplibs="$lib $deplibs"

7030

7031

linkalldeplibs=no

7032

if test "$link_all_deplibs" != no || test -z "$library_names" ||

7033

test "$build_libtool_libs" = no; then

7034

linkalldeplibs=yes

7035

fi

7036

7037

tmp_libs=

7038

for deplib in $dependency_libs; do

7039

case $deplib in

7040

-L*) func_stripname '-L' '' "$deplib"

7041

func_resolve_sysroot "$func_stripname_result"

7042

newlib_search_path+=" $func_resolve_sysroot_result"

7043

;;

7044

esac

7045

# Need to link against all dependency_libs?

7046

if test "$linkalldeplibs" = yes; then

7047

deplibs="$deplib $deplibs"

7048

else

7049

# Need to hardcode shared library paths

7050

# or/and link against static libraries

7051

newdependency_libs="$deplib $newdependency_libs"

7052

fi

7053

if $opt_preserve_dup_deps ; then

7054

case "$tmp_libs " in

7055

*" $deplib "*) specialdeplibs+=" $deplib" ;;

7056

esac

7057

fi

7058

tmp_libs+=" $deplib"

7059

done # for deplib

7060

continue

7061

fi # $linkmode = prog...

7062

7063

if test "$linkmode,$pass" = "prog,link"; then

7064

if test -n "$library_names" &&

7065

{ { test "$prefer_static_libs" = no ||

7066

test "$prefer_static_libs,$installed" = "built,yes"; } ||

7067

test -z "$old_library"; }; then

7068

# We need to hardcode the library path

7069

if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

7070

# Make sure the rpath contains only unique directories.

7071

case "$temp_rpath:" in

7072

*"$absdir:"*) ;;

7073

*) temp_rpath+="$absdir:" ;;

7074

esac

7075

fi

7076

7077

# Hardcode the library path.

7078

# Skip directories that are in the system default run-time

7079

# search path.

7080

case " $sys_lib_dlsearch_path " in

7081

*" $absdir "*) ;;

7082

*)

7083

case "$compile_rpath " in

7084

*" $absdir "*) ;;

7085

*) compile_rpath+=" $absdir" ;;

7086

esac

7087

;;

7088

esac

7089

case " $sys_lib_dlsearch_path " in

7090

*" $libdir "*) ;;

7091

*)

7092

case "$finalize_rpath " in

7093

*" $libdir "*) ;;

7094

*) finalize_rpath+=" $libdir" ;;

7095

esac

7096

;;

7097

esac

7098

fi # $linkmode,$pass = prog,link...

7099

7100

if test "$alldeplibs" = yes &&

7101

{ test "$deplibs_check_method" = pass_all ||

7102

{ test "$build_libtool_libs" = yes &&

7103

test -n "$library_names"; }; }; then

7104

# We only need to search for static libraries

7105

continue

7106

fi

7107

fi

7108

7109

link_static=no # Whether the deplib will be linked statically

7110

use_static_libs=$prefer_static_libs

7111

if test "$use_static_libs" = built && test "$installed" = yes; then

7112

use_static_libs=no

7113

fi

7114

if test -n "$library_names" &&

7115

{ test "$use_static_libs" = no || test -z "$old_library"; }; then

7116

case $host in

7117

*cygwin* | *mingw* | *cegcc*)

7118

# No point in relinking DLLs because paths are not encoded

7119

notinst_deplibs+=" $lib"

7120

need_relink=no

7121

;;

7122

*)

7123

if test "$installed" = no; then

7124

notinst_deplibs+=" $lib"

7125

need_relink=yes

7126

fi

7127

;;

7128

esac

7129

# This is a shared library

7130

7131

# Warn about portability, can't link against -module's on some

7132

# systems (darwin). Don't bleat about dlopened modules though!

7133

dlopenmodule=""

7134

for dlpremoduletest in $dlprefiles; do

7135

if test "X$dlpremoduletest" = "X$lib"; then

7136

dlopenmodule="$dlpremoduletest"

7137

break

7138

fi

7139

done

7140

if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

7141

echo

7142

if test "$linkmode" = prog; then

7143

$ECHO "*** Warning: Linking the executable $output against the loadable module"

7144

else

7145

$ECHO "*** Warning: Linking the shared library $output against the loadable module"

7146

fi

7147

$ECHO "*** $linklib is not portable!"

7148

fi

7149

if test "$linkmode" = lib &&

7150

test "$hardcode_into_libs" = yes; then

7151

# Hardcode the library path.

7152

# Skip directories that are in the system default run-time

7153

# search path.

7154

case " $sys_lib_dlsearch_path " in

7155

*" $absdir "*) ;;

7156

*)

7157

case "$compile_rpath " in

7158

*" $absdir "*) ;;

7159

*) compile_rpath+=" $absdir" ;;

7160

esac

7161

;;

7162

esac

7163

case " $sys_lib_dlsearch_path " in

7164

*" $libdir "*) ;;

7165

*)

7166

case "$finalize_rpath " in

7167

*" $libdir "*) ;;

7168

*) finalize_rpath+=" $libdir" ;;

7169

esac

7170

;;

7171

esac

7172

fi

7173

7174

if test -n "$old_archive_from_expsyms_cmds"; then

7175

# figure out the soname

7176

set dummy $library_names

7177

shift

7178

realname="$1"

7179

shift

7180

libname=`eval "\\$ECHO \"$libname_spec\""`

7181

# use dlname if we got it. it's perfectly good, no?

7182

if test -n "$dlname"; then

7183

soname="$dlname"

7184

elif test -n "$soname_spec"; then

7185

# bleh windows

7186

case $host in

7187

*cygwin* | mingw* | *cegcc*)

7188

func_arith $current - $age

7189

major=$func_arith_result

7190

versuffix="-$major"

7191

;;

7192

esac

7193

eval soname=\"$soname_spec\"

7194

else

7195

soname="$realname"

7196

fi

7197

7198

# Make a new name for the extract_expsyms_cmds to use

7199

soroot="$soname"

7200

func_basename "$soroot"

7201

soname="$func_basename_result"

7202

func_stripname 'lib' '.dll' "$soname"

7203

newlib=libimp-$func_stripname_result.a

7204

7205

# If the library has no export list, then create one now

7206

if test -f "$output_objdir/$soname-def"; then :

7207

else

7208

func_verbose "extracting exported symbol list from \`$soname'"

7209

func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

7210

fi

7211

7212

# Create $newlib

7213

if test -f "$output_objdir/$newlib"; then :; else

7214

func_verbose "generating import library for \`$soname'"

7215

func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

7216

fi

7217

# make sure the library variables are pointing to the new library

7218

dir=$output_objdir

7219

linklib=$newlib

7220

fi # test -n "$old_archive_from_expsyms_cmds"

7221

7222

if test "$linkmode" = prog || test "$opt_mode" != relink; then

7223

add_shlibpath=

7224

add_dir=

7225

add=

7226

lib_linked=yes

7227

case $hardcode_action in

7228

immediate | unsupported)

7229

if test "$hardcode_direct" = no; then

7230

add="$dir/$linklib"

7231

case $host in

7232

*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

7233

*-*-sysv4*uw2*) add_dir="-L$dir" ;;

7234

*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

7235

*-*-unixware7*) add_dir="-L$dir" ;;

7236

*-*-darwin* )

7237

# if the lib is a (non-dlopened) module then we can not

7238

# link against it, someone is ignoring the earlier warnings

7239

if /usr/bin/file -L $add 2> /dev/null |

7240

$GREP ": [^:]* bundle" >/dev/null ; then

7241

if test "X$dlopenmodule" != "X$lib"; then

7242

$ECHO "*** Warning: lib $linklib is a module, not a shared library"

7243

if test -z "$old_library" ; then

7244

echo

7245

echo "*** And there doesn't seem to be a static archive available"

7246

echo "*** The link will probably fail, sorry"

7247

else

7248

add="$dir/$old_library"

7249

fi

7250

elif test -n "$old_library"; then

7251

add="$dir/$old_library"

7252

fi

7253

fi

7254

esac

7255

elif test "$hardcode_minus_L" = no; then

7256

case $host in

7257

*-*-sunos*) add_shlibpath="$dir" ;;

7258

esac

7259

add_dir="-L$dir"

7260

add="-l$name"

7261

elif test "$hardcode_shlibpath_var" = no; then

7262

add_shlibpath="$dir"

7263

add="-l$name"

7264

else

7265

lib_linked=no

7266

fi

7267

;;

7268

relink)

7269

if test "$hardcode_direct" = yes &&

7270

test "$hardcode_direct_absolute" = no; then

7271

add="$dir/$linklib"

7272

elif test "$hardcode_minus_L" = yes; then

7273

add_dir="-L$absdir"

7274

# Try looking first in the location we're being installed to.

7275

if test -n "$inst_prefix_dir"; then

7276

case $libdir in

7277

[\\/]*)

7278

add_dir+=" -L$inst_prefix_dir$libdir"

7279

;;

7280

esac

7281

fi

7282

add="-l$name"

7283

elif test "$hardcode_shlibpath_var" = yes; then

7284

add_shlibpath="$dir"

7285

add="-l$name"

7286

else

7287

lib_linked=no

7288

fi

7289

;;

7290

*) lib_linked=no ;;

7291

esac

7292

7293

if test "$lib_linked" != yes; then

7294

func_fatal_configuration "unsupported hardcode properties"

7295

fi

7296

7297

if test -n "$add_shlibpath"; then

7298

case :$compile_shlibpath: in

7299

*":$add_shlibpath:"*) ;;

7300

*) compile_shlibpath+="$add_shlibpath:" ;;

7301

esac

7302

fi

7303

if test "$linkmode" = prog; then

7304

test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

7305

test -n "$add" && compile_deplibs="$add $compile_deplibs"

7306

else

7307

test -n "$add_dir" && deplibs="$add_dir $deplibs"

7308

test -n "$add" && deplibs="$add $deplibs"

7309

if test "$hardcode_direct" != yes &&

7310

test "$hardcode_minus_L" != yes &&

7311

test "$hardcode_shlibpath_var" = yes; then

7312

case :$finalize_shlibpath: in

7313

*":$libdir:"*) ;;

7314

*) finalize_shlibpath+="$libdir:" ;;

7315

esac

7316

fi

7317

fi

7318

fi

7319

7320

if test "$linkmode" = prog || test "$opt_mode" = relink; then

7321

add_shlibpath=

7322

add_dir=

7323

add=

7324

# Finalize command for both is simple: just hardcode it.

7325

if test "$hardcode_direct" = yes &&

7326

test "$hardcode_direct_absolute" = no; then

7327

add="$libdir/$linklib"

7328

elif test "$hardcode_minus_L" = yes; then

7329

add_dir="-L$libdir"

7330

add="-l$name"

7331

elif test "$hardcode_shlibpath_var" = yes; then

7332

case :$finalize_shlibpath: in

7333

*":$libdir:"*) ;;

7334

*) finalize_shlibpath+="$libdir:" ;;

7335

esac

7336

add="-l$name"

7337

elif test "$hardcode_automatic" = yes; then

7338

if test -n "$inst_prefix_dir" &&

7339

test -f "$inst_prefix_dir$libdir/$linklib" ; then

7340

add="$inst_prefix_dir$libdir/$linklib"

7341

else

7342

add="$libdir/$linklib"

7343

fi

7344

else

7345

# We cannot seem to hardcode it, guess we'll fake it.

7346

add_dir="-L$libdir"

7347

# Try looking first in the location we're being installed to.

7348

if test -n "$inst_prefix_dir"; then

7349

case $libdir in

7350

[\\/]*)

7351

add_dir+=" -L$inst_prefix_dir$libdir"

7352

;;

7353

esac

7354

fi

7355

add="-l$name"

7356

fi

7357

7358

if test "$linkmode" = prog; then

7359

test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

7360

test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

7361

else

7362

test -n "$add_dir" && deplibs="$add_dir $deplibs"

7363

test -n "$add" && deplibs="$add $deplibs"

7364

fi

7365

fi

7366

elif test "$linkmode" = prog; then

7367

# Here we assume that one of hardcode_direct or hardcode_minus_L

7368

# is not unsupported. This is valid on all known static and

7369

# shared platforms.

7370

if test "$hardcode_direct" != unsupported; then

7371

test -n "$old_library" && linklib="$old_library"

7372

compile_deplibs="$dir/$linklib $compile_deplibs"

7373

finalize_deplibs="$dir/$linklib $finalize_deplibs"

7374

else

7375

compile_deplibs="-l$name -L$dir $compile_deplibs"

7376

finalize_deplibs="-l$name -L$dir $finalize_deplibs"

7377

fi

7378

elif test "$build_libtool_libs" = yes; then

7379

# Not a shared library

7380

if test "$deplibs_check_method" != pass_all; then

7381

# We're trying link a shared library against a static one

7382

# but the system doesn't support it.

7383

7384

# Just print a warning and add the library to dependency_libs so

7385

# that the program can be linked against the static library.

7386

echo

7387

$ECHO "*** Warning: This system can not link to static lib archive $lib."

7388

echo "*** I have the capability to make that library automatically link in when"

7389

echo "*** you link to this library. But I can only do this if you have a"

7390

echo "*** shared version of the library, which you do not appear to have."

7391

if test "$module" = yes; then

7392

echo "*** But as you try to build a module library, libtool will still create "

7393

echo "*** a static module, that should work as long as the dlopening application"

7394

echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

7395

if test -z "$global_symbol_pipe"; then

7396

echo

7397

echo "*** However, this would only work if libtool was able to extract symbol"

7398

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

7399

echo "*** not find such a program. So, this module is probably useless."

7400

echo "*** \`nm' from GNU binutils and a full rebuild may help."

7401

fi

7402

if test "$build_old_libs" = no; then

7403

build_libtool_libs=module

7404

build_old_libs=yes

7405

else

7406

build_libtool_libs=no

7407

fi

7408

fi

7409

else

7410

deplibs="$dir/$old_library $deplibs"

7411

link_static=yes

7412

fi

7413

fi # link shared/static library?

7414

7415

if test "$linkmode" = lib; then

7416

if test -n "$dependency_libs" &&

7417

{ test "$hardcode_into_libs" != yes ||

7418

test "$build_old_libs" = yes ||

7419

test "$link_static" = yes; }; then

7420

# Extract -R from dependency_libs

7421

temp_deplibs=

7422

for libdir in $dependency_libs; do

7423

case $libdir in

7424

-R*) func_stripname '-R' '' "$libdir"

7425

temp_xrpath=$func_stripname_result

7426

case " $xrpath " in

7427

*" $temp_xrpath "*) ;;

7428

*) xrpath+=" $temp_xrpath";;

7429

esac;;

7430

*) temp_deplibs+=" $libdir";;

7431

esac

7432

done

7433

dependency_libs="$temp_deplibs"

7434

fi

7435

7436

newlib_search_path+=" $absdir"

7437

# Link against this library

7438

test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

7439

# ... and its dependency_libs

7440

tmp_libs=

7441

for deplib in $dependency_libs; do

7442

newdependency_libs="$deplib $newdependency_libs"

7443

case $deplib in

7444

-L*) func_stripname '-L' '' "$deplib"

7445

func_resolve_sysroot "$func_stripname_result";;

7446

*) func_resolve_sysroot "$deplib" ;;

7447

esac

7448

if $opt_preserve_dup_deps ; then

7449

case "$tmp_libs " in

7450

*" $func_resolve_sysroot_result "*)

7451

specialdeplibs+=" $func_resolve_sysroot_result" ;;

7452

esac

7453

fi

7454

tmp_libs+=" $func_resolve_sysroot_result"

7455

done

7456

7457

if test "$link_all_deplibs" != no; then

7458

# Add the search paths of all dependency libraries

7459

for deplib in $dependency_libs; do

7460

path=

7461

case $deplib in

7462

-L*) path="$deplib" ;;

7463

*.la)

7464

func_resolve_sysroot "$deplib"

7465

deplib=$func_resolve_sysroot_result

7466

func_dirname "$deplib" "" "."

7467

dir=$func_dirname_result

7468

# We need an absolute path.

7469

case $dir in

7470

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

7471

*)

7472

absdir=`cd "$dir" && pwd`

7473

if test -z "$absdir"; then

7474

func_warning "cannot determine absolute directory name of \`$dir'"

7475

absdir="$dir"

7476

fi

7477

;;

7478

esac

7479

if $GREP "^installed=no" $deplib > /dev/null; then

7480

case $host in

7481

*-*-darwin*)

7482

depdepl=

7483

eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`

7484

if test -n "$deplibrary_names" ; then

7485

for tmp in $deplibrary_names ; do

7486

depdepl=$tmp

7487

done

7488

if test -f "$absdir/$objdir/$depdepl" ; then

7489

depdepl="$absdir/$objdir/$depdepl"

7490

darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7491

if test -z "$darwin_install_name"; then

7492

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7493

fi

7494

compiler_flags+=" ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

7495

linker_flags+=" -dylib_file ${darwin_install_name}:${depdepl}"

7496

path=

7497

fi

7498

fi

7499

;;

7500

*)

7501

path="-L$absdir/$objdir"

7502

;;

7503

esac

7504

else

7505

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

7506

test -z "$libdir" && \

7507

func_fatal_error "\`$deplib' is not a valid libtool archive"

7508

test "$absdir" != "$libdir" && \

7509

func_warning "\`$deplib' seems to be moved"

7510

7511

path="-L$absdir"

7512

fi

7513

;;

7514

esac

7515

case " $deplibs " in

7516

*" $path "*) ;;

7517

*) deplibs="$path $deplibs" ;;

7518

esac

7519

done

7520

fi # link_all_deplibs != no

7521

fi # linkmode = lib

7522

done # for deplib in $libs

7523

if test "$pass" = link; then

7524

if test "$linkmode" = "prog"; then

7525

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

7526

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

7527

else

7528

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7529

fi

7530

fi

7531

dependency_libs="$newdependency_libs"

7532

if test "$pass" = dlpreopen; then

7533

# Link the dlpreopened libraries before other libraries

7534

for deplib in $save_deplibs; do

7535

deplibs="$deplib $deplibs"

7536

done

7537

fi

7538

if test "$pass" != dlopen; then

7539

if test "$pass" != conv; then

7540

# Make sure lib_search_path contains only unique directories.

7541

lib_search_path=

7542

for dir in $newlib_search_path; do

7543

case "$lib_search_path " in

7544

*" $dir "*) ;;

7545

*) lib_search_path+=" $dir" ;;

7546

esac

7547

done

7548

newlib_search_path=

7549

fi

7550

7551

if test "$linkmode,$pass" != "prog,link"; then

7552

vars="deplibs"

7553

else

7554

vars="compile_deplibs finalize_deplibs"

7555

fi

7556

for var in $vars dependency_libs; do

7557

# Add libraries to $var in reverse order

7558

eval tmp_libs=\"\$$var\"

7559

new_libs=

7560

for deplib in $tmp_libs; do

7561

# FIXME: Pedantically, this is the right thing to do, so

7562

# that some nasty dependency loop isn't accidentally

7563

# broken:

7564

#new_libs="$deplib $new_libs"

7565

# Pragmatically, this seems to cause very few problems in

7566

# practice:

7567

case $deplib in

7568

-L*) new_libs="$deplib $new_libs" ;;

7569

-R*) ;;

7570

*)

7571

# And here is the reason: when a library appears more

7572

# than once as an explicit dependence of a library, or

7573

# is implicitly linked in more than once by the

7574

# compiler, it is considered special, and multiple

7575

# occurrences thereof are not removed. Compare this

7576

# with having the same library being listed as a

7577

# dependency of multiple other libraries: in this case,

7578

# we know (pedantically, we assume) the library does not

7579

# need to be listed more than once, so we keep only the

7580

# last copy. This is not always right, but it is rare

7581

# enough that we require users that really mean to play

7582

# such unportable linking tricks to link the library

7583

# using -Wl,-lname, so that libtool does not consider it

7584

# for duplicate removal.

7585

case " $specialdeplibs " in

7586

*" $deplib "*) new_libs="$deplib $new_libs" ;;

7587

*)

7588

case " $new_libs " in

7589

*" $deplib "*) ;;

7590

*) new_libs="$deplib $new_libs" ;;

7591

esac

7592

;;

7593

esac

7594

;;

7595

esac

7596

done

7597

tmp_libs=

7598

for deplib in $new_libs; do

7599

case $deplib in

7600

-L*)

7601

case " $tmp_libs " in

7602

*" $deplib "*) ;;

7603

*) tmp_libs+=" $deplib" ;;

7604

esac

7605

;;

7606

*) tmp_libs+=" $deplib" ;;

7607

esac

7608

done

7609

eval $var=\"$tmp_libs\"

7610

done # for var

7611

fi

7612

# Last step: remove runtime libs from dependency_libs

7613

# (they stay in deplibs)

7614

tmp_libs=

7615

for i in $dependency_libs ; do

7616

case " $predeps $postdeps $compiler_lib_search_path " in

7617

*" $i "*)

7618

i=""

7619

;;

7620

esac

7621

if test -n "$i" ; then

7622

tmp_libs+=" $i"

7623

fi

7624

done

7625

dependency_libs=$tmp_libs

7626

done # for pass

7627

if test "$linkmode" = prog; then

7628

dlfiles="$newdlfiles"

7629

fi

7630

if test "$linkmode" = prog || test "$linkmode" = lib; then

7631

dlprefiles="$newdlprefiles"

7632

fi

7633

7634

case $linkmode in

7635

oldlib)

7636

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

7637

func_warning "\`-dlopen' is ignored for archives"

7638

fi

7639

7640

case " $deplibs" in

7641

*\ -l* | *\ -L*)

7642

func_warning "\`-l' and \`-L' are ignored for archives" ;;

7643

esac

7644

7645

test -n "$rpath" && \

7646

func_warning "\`-rpath' is ignored for archives"

7647

7648

test -n "$xrpath" && \

7649

func_warning "\`-R' is ignored for archives"

7650

7651

test -n "$vinfo" && \

7652

func_warning "\`-version-info/-version-number' is ignored for archives"

7653

7654

test -n "$release" && \

7655

func_warning "\`-release' is ignored for archives"

7656

7657

test -n "$export_symbols$export_symbols_regex" && \

7658

func_warning "\`-export-symbols' is ignored for archives"

7659

7660

# Now set the variables for building old libraries.

7661

build_libtool_libs=no

7662

oldlibs="$output"

7663

objs+="$old_deplibs"

7664

;;

7665

7666

lib)

7667

# Make sure we only generate libraries of the form `libNAME.la'.

7668

case $outputname in

7669

lib*)

7670

func_stripname 'lib' '.la' "$outputname"

7671

name=$func_stripname_result

7672

eval shared_ext=\"$shrext_cmds\"

7673

eval libname=\"$libname_spec\"

7674

;;

7675

*)

7676

test "$module" = no && \

7677

func_fatal_help "libtool library \`$output' must begin with \`lib'"

7678

7679

if test "$need_lib_prefix" != no; then

7680

# Add the "lib" prefix for modules if required

7681

func_stripname '' '.la' "$outputname"

7682

name=$func_stripname_result

7683

eval shared_ext=\"$shrext_cmds\"

7684

eval libname=\"$libname_spec\"

7685

else

7686

func_stripname '' '.la' "$outputname"

7687

libname=$func_stripname_result

7688

fi

7689

;;

7690

esac

7691

7692

if test -n "$objs"; then

7693

if test "$deplibs_check_method" != pass_all; then

7694

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

7695

else

7696

echo

7697

$ECHO "*** Warning: Linking the shared library $output against the non-libtool"

7698

$ECHO "*** objects $objs is not portable!"

7699

libobjs+=" $objs"

7700

fi

7701

fi

7702

7703

test "$dlself" != no && \

7704

func_warning "\`-dlopen self' is ignored for libtool libraries"

7705

7706

set dummy $rpath

7707

shift

7708

test "$#" -gt 1 && \

7709

func_warning "ignoring multiple \`-rpath's for a libtool library"

7710

7711

install_libdir="$1"

7712

7713

oldlibs=

7714

if test -z "$rpath"; then

7715

if test "$build_libtool_libs" = yes; then

7716

# Building a libtool convenience library.

7717

# Some compilers have problems with a `.al' extension so

7718

# convenience libraries should have the same extension an

7719

# archive normally would.

7720

oldlibs="$output_objdir/$libname.$libext $oldlibs"

7721

build_libtool_libs=convenience

7722

build_old_libs=yes

7723

fi

7724

7725

test -n "$vinfo" && \

7726

func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

7727

7728

test -n "$release" && \

7729

func_warning "\`-release' is ignored for convenience libraries"

7730

else

7731

7732

# Parse the version information argument.

7733

save_ifs="$IFS"; IFS=':'

7734

set dummy $vinfo 0 0 0

7735

shift

7736

IFS="$save_ifs"

7737

7738

test -n "$7" && \

7739

func_fatal_help "too many parameters to \`-version-info'"

7740

7741

# convert absolute version numbers to libtool ages

7742

# this retains compatibility with .la files and attempts

7743

# to make the code below a bit more comprehensible

7744

7745

case $vinfo_number in

7746

yes)

7747

number_major="$1"

7748

number_minor="$2"

7749

number_revision="$3"

7750

#

7751

# There are really only two kinds -- those that

7752

# use the current revision as the major version

7753

# and those that subtract age and use age as

7754

# a minor version. But, then there is irix

7755

# which has an extra 1 added just for fun

7756

#

7757

case $version_type in

7758

# correct linux to gnu/linux during the next big refactor

7759

darwin|linux|osf|windows|none)

7760

func_arith $number_major + $number_minor

7761

current=$func_arith_result

7762

age="$number_minor"

7763

revision="$number_revision"

7764

;;

7765

freebsd-aout|freebsd-elf|qnx|sunos)

7766

current="$number_major"

7767

revision="$number_minor"

7768

age="0"

7769

;;

7770

irix|nonstopux)

7771

func_arith $number_major + $number_minor

7772

current=$func_arith_result

7773

age="$number_minor"

7774

revision="$number_minor"

7775

lt_irix_increment=no

7776

;;

7777

*)

7778

func_fatal_configuration "$modename: unknown library version type \`$version_type'"

7779

;;

7780

esac

7781

;;

7782

no)

7783

current="$1"

7784

revision="$2"

7785

age="$3"

7786

;;

7787

esac

7788

7789

# Check that each of the things are valid numbers.

7790

case $current in

7791

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

7792

*)

7793

func_error "CURRENT \`$current' must be a nonnegative integer"

7794

func_fatal_error "\`$vinfo' is not valid version information"

7795

;;

7796

esac

7797

7798

case $revision in

7799

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

7800

*)

7801

func_error "REVISION \`$revision' must be a nonnegative integer"

7802

func_fatal_error "\`$vinfo' is not valid version information"

7803

;;

7804

esac

7805

7806

case $age in

7807

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

7808

*)

7809

func_error "AGE \`$age' must be a nonnegative integer"

7810

func_fatal_error "\`$vinfo' is not valid version information"

7811

;;

7812

esac

7813

7814

if test "$age" -gt "$current"; then

7815

func_error "AGE \`$age' is greater than the current interface number \`$current'"

7816

func_fatal_error "\`$vinfo' is not valid version information"

7817

fi

7818

7819

# Calculate the version variables.

7820

major=

7821

versuffix=

7822

verstring=

7823

case $version_type in

7824

none) ;;

7825

7826

darwin)

7827

# Like Linux, but with the current version available in

7828

# verstring for coding it into the library header

7829

func_arith $current - $age

7830

major=.$func_arith_result

7831

versuffix="$major.$age.$revision"

7832

# Darwin ld doesn't like 0 for these options...

7833

func_arith $current + 1

7834

minor_current=$func_arith_result

7835

xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"

7836

verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

7837

;;

7838

7839

freebsd-aout)

7840

major=".$current"

7841

versuffix=".$current.$revision";

7842

;;

7843

7844

freebsd-elf)

7845

major=".$current"

7846

versuffix=".$current"

7847

;;

7848

7849

irix | nonstopux)

7850

if test "X$lt_irix_increment" = "Xno"; then

7851

func_arith $current - $age

7852

else

7853

func_arith $current - $age + 1

7854

fi

7855

major=$func_arith_result

7856

7857

case $version_type in

7858

nonstopux) verstring_prefix=nonstopux ;;

7859

*) verstring_prefix=sgi ;;

7860

esac

7861

verstring="$verstring_prefix$major.$revision"

7862

7863

# Add in all the interfaces that we are compatible with.

7864

loop=$revision

7865

while test "$loop" -ne 0; do

7866

func_arith $revision - $loop

7867

iface=$func_arith_result

7868

func_arith $loop - 1

7869

loop=$func_arith_result

7870

verstring="$verstring_prefix$major.$iface:$verstring"

7871

done

7872

7873

# Before this point, $major must not contain `.'.

7874

major=.$major

7875

versuffix="$major.$revision"

7876

;;

7877

7878

linux) # correct to gnu/linux during the next big refactor

7879

func_arith $current - $age

7880

major=.$func_arith_result

7881

versuffix="$major.$age.$revision"

7882

;;

7883

7884

osf)

7885

func_arith $current - $age

7886

major=.$func_arith_result

7887

versuffix=".$current.$age.$revision"

7888

verstring="$current.$age.$revision"

7889

7890

# Add in all the interfaces that we are compatible with.

7891

loop=$age

7892

while test "$loop" -ne 0; do

7893

func_arith $current - $loop

7894

iface=$func_arith_result

7895

func_arith $loop - 1

7896

loop=$func_arith_result

7897

verstring="$verstring:${iface}.0"

7898

done

7899

7900

# Make executables depend on our current version.

7901

verstring+=":${current}.0"

7902

;;

7903

7904

qnx)

7905

major=".$current"

7906

versuffix=".$current"

7907

;;

7908

7909

sunos)

7910

major=".$current"

7911

versuffix=".$current.$revision"

7912

;;

7913

7914

windows)

7915

# Use '-' rather than '.', since we only want one

7916

# extension on DOS 8.3 filesystems.

7917

func_arith $current - $age

7918

major=$func_arith_result

7919

versuffix="-$major"

7920

;;

7921

7922

*)

7923

func_fatal_configuration "unknown library version type \`$version_type'"

7924

;;

7925

esac

7926

7927

# Clear the version info if we defaulted, and they specified a release.

7928

if test -z "$vinfo" && test -n "$release"; then

7929

major=

7930

case $version_type in

7931

darwin)

7932

# we can't check for "0.0" in archive_cmds due to quoting

7933

# problems, so we reset it completely

7934

verstring=

7935

;;

7936

*)

7937

verstring="0.0"

7938

;;

7939

esac

7940

if test "$need_version" = no; then

7941

versuffix=

7942

else

7943

versuffix=".0.0"

7944

fi

7945

fi

7946

7947

# Remove version info from name if versioning should be avoided

7948

if test "$avoid_version" = yes && test "$need_version" = no; then

7949

major=

7950

versuffix=

7951

verstring=""

7952

fi

7953

7954

# Check to see if the archive will have undefined symbols.

7955

if test "$allow_undefined" = yes; then

7956

if test "$allow_undefined_flag" = unsupported; then

7957

func_warning "undefined symbols not allowed in $host shared libraries"

7958

build_libtool_libs=no

7959

build_old_libs=yes

7960

fi

7961

else

7962

# Don't allow undefined symbols.

7963

allow_undefined_flag="$no_undefined_flag"

7964

fi

7965

7966

fi

7967

7968

func_generate_dlsyms "$libname" "$libname" "yes"

7969

libobjs+=" $symfileobj"

7970

test "X$libobjs" = "X " && libobjs=

7971

7972

if test "$opt_mode" != relink; then

7973

# Remove our outputs, but don't remove object files since they

7974

# may have been created when compiling PIC objects.

7975

removelist=

7976

tempremovelist=`$ECHO "$output_objdir/*"`

7977

for p in $tempremovelist; do

7978

case $p in

7979

*.$objext | *.gcno)

7980

;;

7981

$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

7982

if test "X$precious_files_regex" != "X"; then

7983

if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

7984

then

7985

continue

7986

fi

7987

fi

7988

removelist+=" $p"

7989

;;

7990

*) ;;

7991

esac

7992

done

7993

test -n "$removelist" && \

7994

func_show_eval "${RM}r \$removelist"

7995

fi

7996

7997

# Now set the variables for building old libraries.

7998

if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

7999

oldlibs+=" $output_objdir/$libname.$libext"

8000

8001

# Transform .lo files to .o files.

8002

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

8003

fi

8004

8005

# Eliminate all temporary directories.

8006

#for path in $notinst_path; do

8007

# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

8008

# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

8009

# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

8010

#done

8011

8012

if test -n "$xrpath"; then

8013

# If the user specified any rpath flags, then add them.

8014

temp_xrpath=

8015

for libdir in $xrpath; do

8016

func_replace_sysroot "$libdir"

8017

temp_xrpath+=" -R$func_replace_sysroot_result"

8018

case "$finalize_rpath " in

8019

*" $libdir "*) ;;

8020

*) finalize_rpath+=" $libdir" ;;

8021

esac

8022

done

8023

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

8024

dependency_libs="$temp_xrpath $dependency_libs"

8025

fi

8026

fi

8027

8028

# Make sure dlfiles contains only unique files that won't be dlpreopened

8029

old_dlfiles="$dlfiles"

8030

dlfiles=

8031

for lib in $old_dlfiles; do

8032

case " $dlprefiles $dlfiles " in

8033

*" $lib "*) ;;

8034

*) dlfiles+=" $lib" ;;

8035

esac

8036

done

8037

8038

# Make sure dlprefiles contains only unique files

8039

old_dlprefiles="$dlprefiles"

8040

dlprefiles=

8041

for lib in $old_dlprefiles; do

8042

case "$dlprefiles " in

8043

*" $lib "*) ;;

8044

*) dlprefiles+=" $lib" ;;

8045

esac

8046

done

8047

8048

if test "$build_libtool_libs" = yes; then

8049

if test -n "$rpath"; then

8050

case $host in

8051

8052

# these systems don't actually have a c library (as such)!

8053

;;

8054

*-*-rhapsody* | *-*-darwin1.[012])

8055

# Rhapsody C library is in the System framework

8056

deplibs+=" System.ltframework"

8057

;;

8058

*-*-netbsd*)

8059

# Don't link with libc until the a.out ld.so is fixed.

8060

;;

8061

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

8062

# Do not include libc due to us having libc/libc_r.

8063

;;

8064

*-*-sco3.2v5* | *-*-sco5v6*)

8065

# Causes problems with __ctype

8066

;;

8067

*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

8068

# Compiler inserts libc in the correct place for threads to work

8069

;;

8070

*)

8071

# Add libc to deplibs on all other systems if necessary.

8072

if test "$build_libtool_need_lc" = "yes"; then

8073

deplibs+=" -lc"

8074

fi

8075

;;

8076

esac

8077

fi

8078

8079

# Transform deplibs into only deplibs that can be linked in shared.

8080

name_save=$name

8081

libname_save=$libname

8082

release_save=$release

8083

versuffix_save=$versuffix

8084

major_save=$major

8085

# I'm not sure if I'm treating the release correctly. I think

8086

# release should show up in the -l (ie -lgmp5) so we don't want to

8087

# add it in twice. Is that correct?

8088

release=""

8089

versuffix=""

8090

major=""

8091

newdeplibs=

8092

droppeddeps=no

8093

case $deplibs_check_method in

8094

pass_all)

8095

# Don't check for shared/static. Everything works.

8096

# This might be a little naive. We might want to check

8097

# whether the library exists or not. But this is on

8098

# osf3 & osf4 and I'm not really sure... Just

8099

# implementing what was already the behavior.

8100

newdeplibs=$deplibs

8101

;;

8102

test_compile)

8103

# This code stresses the "libraries are programs" paradigm to its

8104

# limits. Maybe even breaks it. We compile a program, linking it

8105

# against the deplibs as a proxy for the library. Then we can check

8106

# whether they linked in statically or dynamically with ldd.

8107

$opt_dry_run || $RM conftest.c

8108

cat > conftest.c <<EOF

8109

int main() { return 0; }

8110

EOF

8111

$opt_dry_run || $RM conftest

8112

if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then

8113

ldd_output=`ldd conftest`

8114

for i in $deplibs; do

8115

case $i in

8116

-l*)

8117

func_stripname -l '' "$i"

8118

name=$func_stripname_result

8119

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

8120

case " $predeps $postdeps " in

8121

*" $i "*)

8122

newdeplibs+=" $i"

8123

i=""

8124

;;

8125

esac

8126

fi

8127

if test -n "$i" ; then

8128

libname=`eval "\\$ECHO \"$libname_spec\""`

8129

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

8130

set dummy $deplib_matches; shift

8131

deplib_match=$1

8132

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

8133

newdeplibs+=" $i"

8134

else

8135

droppeddeps=yes

8136

echo

8137

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

8138

echo "*** I have the capability to make that library automatically link in when"

8139

echo "*** you link to this library. But I can only do this if you have a"

8140

echo "*** shared version of the library, which I believe you do not have"

8141

echo "*** because a test_compile did reveal that the linker did not use it for"

8142

echo "*** its dynamic dependency list that programs get resolved with at runtime."

8143

fi

8144

fi

8145

;;

8146

*)

8147

newdeplibs+=" $i"

8148

;;

8149

esac

8150

done

8151

else

8152

# Error occurred in the first compile. Let's try to salvage

8153

# the situation: Compile a separate program for each library.

8154

for i in $deplibs; do

8155

case $i in

8156

-l*)

8157

func_stripname -l '' "$i"

8158

name=$func_stripname_result

8159

$opt_dry_run || $RM conftest

8160

if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

8161

ldd_output=`ldd conftest`

8162

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

8163

case " $predeps $postdeps " in

8164

*" $i "*)

8165

newdeplibs+=" $i"

8166

i=""

8167

;;

8168

esac

8169

fi

8170

if test -n "$i" ; then

8171

libname=`eval "\\$ECHO \"$libname_spec\""`

8172

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

8173

set dummy $deplib_matches; shift

8174

deplib_match=$1

8175

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

8176

newdeplibs+=" $i"

8177

else

8178

droppeddeps=yes

8179

echo

8180

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

8181

echo "*** I have the capability to make that library automatically link in when"

8182

echo "*** you link to this library. But I can only do this if you have a"

8183

echo "*** shared version of the library, which you do not appear to have"

8184

echo "*** because a test_compile did reveal that the linker did not use this one"

8185

echo "*** as a dynamic dependency that programs can get resolved with at runtime."

8186

fi

8187

fi

8188

else

8189

droppeddeps=yes

8190

echo

8191

$ECHO "*** Warning! Library $i is needed by this library but I was not able to"

8192

echo "*** make it link in! You will probably need to install it or some"

8193

echo "*** library that it depends on before this library will be fully"

8194

echo "*** functional. Installing it before continuing would be even better."

8195

fi

8196

;;

8197

*)

8198

newdeplibs+=" $i"

8199

;;

8200

esac

8201

done

8202

fi

8203

;;

8204

file_magic*)

8205

set dummy $deplibs_check_method; shift

8206

file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

8207

for a_deplib in $deplibs; do

8208

case $a_deplib in

8209

-l*)

8210

func_stripname -l '' "$a_deplib"

8211

name=$func_stripname_result

8212

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

8213

case " $predeps $postdeps " in

8214

*" $a_deplib "*)

8215

newdeplibs+=" $a_deplib"

8216

a_deplib=""

8217

;;

8218

esac

8219

fi

8220

if test -n "$a_deplib" ; then

8221

libname=`eval "\\$ECHO \"$libname_spec\""`

8222

if test -n "$file_magic_glob"; then

8223

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

8224

else

8225

libnameglob=$libname

8226

fi

8227

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

8228

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

8229

if test "$want_nocaseglob" = yes; then

8230

shopt -s nocaseglob

8231

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

8232

$nocaseglob

8233

else

8234

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

8235

fi

8236

for potent_lib in $potential_libs; do

8237

# Follow soft links.

8238

if ls -lLd "$potent_lib" 2>/dev/null |

8239

$GREP " -> " >/dev/null; then

8240

continue

8241

fi

8242

# The statement above tries to avoid entering an

8243

# endless loop below, in case of cyclic links.

8244

# We might still enter an endless loop, since a link

8245

# loop can be closed while we follow links,

8246

# but so what?

8247

potlib="$potent_lib"

8248

while test -h "$potlib" 2>/dev/null; do

8249

potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

8250

case $potliblink in

8251

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

8252

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

8253

esac

8254

done

8255

if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

8256

$SED -e 10q |

8257

$EGREP "$file_magic_regex" > /dev/null; then

8258

newdeplibs+=" $a_deplib"

8259

a_deplib=""

8260

break 2

8261

fi

8262

done

8263

done

8264

fi

8265

if test -n "$a_deplib" ; then

8266

droppeddeps=yes

8267

echo

8268

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

8269

echo "*** I have the capability to make that library automatically link in when"

8270

echo "*** you link to this library. But I can only do this if you have a"

8271

echo "*** shared version of the library, which you do not appear to have"

8272

echo "*** because I did check the linker path looking for a file starting"

8273

if test -z "$potlib" ; then

8274

$ECHO "*** with $libname but no candidates were found. (...for file magic test)"

8275

else

8276

$ECHO "*** with $libname and none of the candidates passed a file format test"

8277

$ECHO "*** using a file magic. Last file checked: $potlib"

8278

fi

8279

fi

8280

;;

8281

*)

8282

# Add a -L argument.

8283

newdeplibs+=" $a_deplib"

8284

;;

8285

esac

8286

done # Gone through all deplibs.

8287

;;

8288

match_pattern*)

8289

set dummy $deplibs_check_method; shift

8290

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

8291

for a_deplib in $deplibs; do

8292

case $a_deplib in

8293

-l*)

8294

func_stripname -l '' "$a_deplib"

8295

name=$func_stripname_result

8296

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

8297

case " $predeps $postdeps " in

8298

*" $a_deplib "*)

8299

newdeplibs+=" $a_deplib"

8300

a_deplib=""

8301

;;

8302

esac

8303

fi

8304

if test -n "$a_deplib" ; then

8305

libname=`eval "\\$ECHO \"$libname_spec\""`

8306

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

8307

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

8308

for potent_lib in $potential_libs; do

8309

potlib="$potent_lib" # see symlink-check above in file_magic test

8310

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

8311

$EGREP "$match_pattern_regex" > /dev/null; then

8312

newdeplibs+=" $a_deplib"

8313

a_deplib=""

8314

break 2

8315

fi

8316

done

8317

done

8318

fi

8319

if test -n "$a_deplib" ; then

8320

droppeddeps=yes

8321

echo

8322

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

8323

echo "*** I have the capability to make that library automatically link in when"

8324

echo "*** you link to this library. But I can only do this if you have a"

8325

echo "*** shared version of the library, which you do not appear to have"

8326

echo "*** because I did check the linker path looking for a file starting"

8327

if test -z "$potlib" ; then

8328

$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

8329

else

8330

$ECHO "*** with $libname and none of the candidates passed a file format test"

8331

$ECHO "*** using a regex pattern. Last file checked: $potlib"

8332

fi

8333

fi

8334

;;

8335

*)

8336

# Add a -L argument.

8337

newdeplibs+=" $a_deplib"

8338

;;

8339

esac

8340

done # Gone through all deplibs.

8341

;;

8342

none | unknown | *)

8343

newdeplibs=""

8344

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

8345

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

8346

for i in $predeps $postdeps ; do

8347

# can't use Xsed below, because $i might contain '/'

8348

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

8349

done

8350

fi

8351

case $tmp_deplibs in

8352

*[!\ \ ]*)

8353

echo

8354

if test "X$deplibs_check_method" = "Xnone"; then

8355

echo "*** Warning: inter-library dependencies are not supported in this platform."

8356

else

8357

echo "*** Warning: inter-library dependencies are not known to be supported."

8358

fi

8359

echo "*** All declared inter-library dependencies are being dropped."

8360

droppeddeps=yes

8361

;;

8362

esac

8363

;;

8364

esac

8365

versuffix=$versuffix_save

8366

major=$major_save

8367

release=$release_save

8368

libname=$libname_save

8369

name=$name_save

8370

8371

case $host in

8372

*-*-rhapsody* | *-*-darwin1.[012])

8373

# On Rhapsody replace the C library with the System framework

8374

newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

8375

;;

8376

esac

8377

8378

if test "$droppeddeps" = yes; then

8379

if test "$module" = yes; then

8380

echo

8381

echo "*** Warning: libtool could not satisfy all declared inter-library"

8382

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

8383

echo "*** a static module, that should work as long as the dlopening"

8384

echo "*** application is linked with the -dlopen flag."

8385

if test -z "$global_symbol_pipe"; then

8386

echo

8387

echo "*** However, this would only work if libtool was able to extract symbol"

8388

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

8389

echo "*** not find such a program. So, this module is probably useless."

8390

echo "*** \`nm' from GNU binutils and a full rebuild may help."

8391

fi

8392

if test "$build_old_libs" = no; then

8393

oldlibs="$output_objdir/$libname.$libext"

8394

build_libtool_libs=module

8395

build_old_libs=yes

8396

else

8397

build_libtool_libs=no

8398

fi

8399

else

8400

echo "*** The inter-library dependencies that have been dropped here will be"

8401

echo "*** automatically added whenever a program is linked with this library"

8402

echo "*** or is declared to -dlopen it."

8403

8404

if test "$allow_undefined" = no; then

8405

echo

8406

echo "*** Since this library must not contain undefined symbols,"

8407

echo "*** because either the platform does not support them or"

8408

echo "*** it was explicitly requested with -no-undefined,"

8409

echo "*** libtool will only create a static version of it."

8410

if test "$build_old_libs" = no; then

8411

oldlibs="$output_objdir/$libname.$libext"

8412

build_libtool_libs=module

8413

build_old_libs=yes

8414

else

8415

build_libtool_libs=no

8416

fi

8417

fi

8418

fi

8419

fi

8420

# Done checking deplibs!

8421

deplibs=$newdeplibs

8422

fi

8423

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

8424

case $host in

8425

*-*-darwin*)

8426

newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8427

new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8428

deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8429

;;

8430

esac

8431

8432

# move library search paths that coincide with paths to not yet

8433

# installed libraries to the beginning of the library search list

8434

new_libs=

8435

for path in $notinst_path; do

8436

case " $new_libs " in

8437

*" -L$path/$objdir "*) ;;

8438

*)

8439

case " $deplibs " in

8440

*" -L$path/$objdir "*)

8441

new_libs+=" -L$path/$objdir" ;;

8442

esac

8443

;;

8444

esac

8445

done

8446

for deplib in $deplibs; do

8447

case $deplib in

8448

-L*)

8449

case " $new_libs " in

8450

*" $deplib "*) ;;

8451

*) new_libs+=" $deplib" ;;

8452

esac

8453

;;

8454

*) new_libs+=" $deplib" ;;

8455

esac

8456

done

8457

deplibs="$new_libs"

8458

8459

# All the library-specific variables (install_libdir is set above).

8460

library_names=

8461

old_library=

8462

dlname=

8463

8464

# Test again, we may have decided not to build it any more

8465

if test "$build_libtool_libs" = yes; then

8466

# Remove ${wl} instances when linking with ld.

8467

# FIXME: should test the right _cmds variable.

8468

case $archive_cmds in

8469

*\$LD\ *) wl= ;;

8470

esac

8471

if test "$hardcode_into_libs" = yes; then

8472

# Hardcode the library paths

8473

hardcode_libdirs=

8474

dep_rpath=

8475

rpath="$finalize_rpath"

8476

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

8477

for libdir in $rpath; do

8478

if test -n "$hardcode_libdir_flag_spec"; then

8479

if test -n "$hardcode_libdir_separator"; then

8480

func_replace_sysroot "$libdir"

8481

libdir=$func_replace_sysroot_result

8482

if test -z "$hardcode_libdirs"; then

8483

hardcode_libdirs="$libdir"

8484

else

8485

# Just accumulate the unique libdirs.

8486

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8487

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8488

;;

8489

*)

8490

hardcode_libdirs+="$hardcode_libdir_separator$libdir"

8491

;;

8492

esac

8493

fi

8494

else

8495

eval flag=\"$hardcode_libdir_flag_spec\"

8496

dep_rpath+=" $flag"

8497

fi

8498

elif test -n "$runpath_var"; then

8499

case "$perm_rpath " in

8500

*" $libdir "*) ;;

8501

*) perm_rpath+=" $libdir" ;;

8502

esac

8503

fi

8504

done

8505

# Substitute the hardcoded libdirs into the rpath.

8506

if test -n "$hardcode_libdir_separator" &&

8507

test -n "$hardcode_libdirs"; then

8508

libdir="$hardcode_libdirs"

8509

eval "dep_rpath=\"$hardcode_libdir_flag_spec\""

8510

fi

8511

if test -n "$runpath_var" && test -n "$perm_rpath"; then

8512

# We should set the runpath_var.

8513

rpath=

8514

for dir in $perm_rpath; do

8515

rpath+="$dir:"

8516

done

8517

eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

8518

fi

8519

test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

8520

fi

8521

8522

shlibpath="$finalize_shlibpath"

8523

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

8524

if test -n "$shlibpath"; then

8525

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

8526

fi

8527

8528

# Get the real and link names of the library.

8529

eval shared_ext=\"$shrext_cmds\"

8530

eval library_names=\"$library_names_spec\"

8531

set dummy $library_names

8532

shift

8533

realname="$1"

8534

shift

8535

8536

if test -n "$soname_spec"; then

8537

eval soname=\"$soname_spec\"

8538

else

8539

soname="$realname"

8540

fi

8541

if test -z "$dlname"; then

8542

dlname=$soname

8543

fi

8544

8545

lib="$output_objdir/$realname"

8546

linknames=

8547

for link

8548

do

8549

linknames+=" $link"

8550

done

8551

8552

# Use standard objects if they are pic

8553

test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

8554

test "X$libobjs" = "X " && libobjs=

8555

8556

delfiles=

8557

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8558

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

8559

export_symbols="$output_objdir/$libname.uexp"

8560

delfiles+=" $export_symbols"

8561

fi

8562

8563

orig_export_symbols=

8564

case $host_os in

8565

cygwin* | mingw* | cegcc*)

8566

if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

8567

# exporting using user supplied symfile

8568

if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

8569

# and it's NOT already a .def file. Must figure out

8570

# which of the given symbols are data symbols and tag

8571

# them as such. So, trigger use of export_symbols_cmds.

8572

# export_symbols gets reassigned inside the "prepare

8573

# the list of exported symbols" if statement, so the

8574

# include_expsyms logic still works.

8575

orig_export_symbols="$export_symbols"

8576

export_symbols=

8577

always_export_symbols=yes

8578

fi

8579

fi

8580

;;

8581

esac

8582

8583

# Prepare the list of exported symbols

8584

if test -z "$export_symbols"; then

8585

if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

8586

func_verbose "generating symbol list for \`$libname.la'"

8587

export_symbols="$output_objdir/$libname.exp"

8588

$opt_dry_run || $RM $export_symbols

8589

cmds=$export_symbols_cmds

8590

save_ifs="$IFS"; IFS='~'

8591

for cmd1 in $cmds; do

8592

IFS="$save_ifs"

8593

# Take the normal branch if the nm_file_list_spec branch

8594

# doesn't work or if tool conversion is not needed.

8595

case $nm_file_list_spec~$to_tool_file_cmd in

8596

*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)

8597

try_normal_branch=yes

8598

eval cmd=\"$cmd1\"

8599

func_len " $cmd"

8600

len=$func_len_result

8601

;;

8602

*)

8603

try_normal_branch=no

8604

;;

8605

esac

8606

if test "$try_normal_branch" = yes \

8607

&& { test "$len" -lt "$max_cmd_len" \

8608

|| test "$max_cmd_len" -le -1; }

8609

then

8610

func_show_eval "$cmd" 'exit $?'

8611

skipped_export=false

8612

elif test -n "$nm_file_list_spec"; then

8613

func_basename "$output"

8614

output_la=$func_basename_result

8615

save_libobjs=$libobjs

8616

save_output=$output

8617

output=${output_objdir}/${output_la}.nm

8618

func_to_tool_file "$output"

8619

libobjs=$nm_file_list_spec$func_to_tool_file_result

8620

delfiles+=" $output"

8621

func_verbose "creating $NM input file list: $output"

8622

for obj in $save_libobjs; do

8623

func_to_tool_file "$obj"

8624

$ECHO "$func_to_tool_file_result"

8625

done > "$output"

8626

eval cmd=\"$cmd1\"

8627

func_show_eval "$cmd" 'exit $?'

8628

output=$save_output

8629

libobjs=$save_libobjs

8630

skipped_export=false

8631

else

8632

# The command line is too long to execute in one step.

8633

func_verbose "using reloadable object file for export list..."

8634

skipped_export=:

8635

# Break out early, otherwise skipped_export may be

8636

# set to false by a later but shorter cmd.

8637

break

8638

fi

8639

done

8640

IFS="$save_ifs"

8641

if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

8642

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8643

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8644

fi

8645

fi

8646

fi

8647

8648

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8649

tmp_export_symbols="$export_symbols"

8650

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8651

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8652

fi

8653

8654

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

8655

# The given exports_symbols file has to be filtered, so filter it.

8656

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8657

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8658

# 's' commands which not all seds can handle. GNU sed should be fine

8659

# though. Also, the filter scales superlinearly with the number of

8660

# global variables. join(1) would be nice here, but unfortunately

8661

# isn't a blessed tool.

8662

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8663

delfiles+=" $export_symbols $output_objdir/$libname.filter"

8664

export_symbols=$output_objdir/$libname.def

8665

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8666

fi

8667

8668

tmp_deplibs=

8669

for test_deplib in $deplibs; do

8670

case " $convenience " in

8671

*" $test_deplib "*) ;;

8672

*)

8673

tmp_deplibs+=" $test_deplib"

8674

;;

8675

esac

8676

done

8677

deplibs="$tmp_deplibs"

8678

8679

if test -n "$convenience"; then

8680

if test -n "$whole_archive_flag_spec" &&

8681

test "$compiler_needs_object" = yes &&

8682

test -z "$libobjs"; then

8683

# extract the archives, so we have objects to list.

8684

# TODO: could optimize this to just extract one archive.

8685

whole_archive_flag_spec=

8686

fi

8687

if test -n "$whole_archive_flag_spec"; then

8688

save_libobjs=$libobjs

8689

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8690

test "X$libobjs" = "X " && libobjs=

8691

else

8692

gentop="$output_objdir/${outputname}x"

8693

generated+=" $gentop"

8694

8695

func_extract_archives $gentop $convenience

8696

libobjs+=" $func_extract_archives_result"

8697

test "X$libobjs" = "X " && libobjs=

8698

fi

8699

fi

8700

8701

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

8702

eval flag=\"$thread_safe_flag_spec\"

8703

linker_flags+=" $flag"

8704

fi

8705

8706

# Make a backup of the uninstalled library when relinking

8707

if test "$opt_mode" = relink; then

8708

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

8709

fi

8710

8711

# Do each of the archive commands.

8712

if test "$module" = yes && test -n "$module_cmds" ; then

8713

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8714

eval test_cmds=\"$module_expsym_cmds\"

8715

cmds=$module_expsym_cmds

8716

else

8717

eval test_cmds=\"$module_cmds\"

8718

cmds=$module_cmds

8719

fi

8720

else

8721

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8722

eval test_cmds=\"$archive_expsym_cmds\"

8723

cmds=$archive_expsym_cmds

8724

else

8725

eval test_cmds=\"$archive_cmds\"

8726

cmds=$archive_cmds

8727

fi

8728

fi

8729

8730

if test "X$skipped_export" != "X:" &&

8731

func_len " $test_cmds" &&

8732

len=$func_len_result &&

8733

test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8734

:

8735

else

8736

# The command line is too long to link in one step, link piecewise

8737

# or, if using GNU ld and skipped_export is not :, use a linker

8738

# script.

8739

8740

# Save the value of $output and $libobjs because we want to

8741

# use them later. If we have whole_archive_flag_spec, we

8742

# want to use save_libobjs as it was before

8743

# whole_archive_flag_spec was expanded, because we can't

8744

# assume the linker understands whole_archive_flag_spec.

8745

# This may have to be revisited, in case too many

8746

# convenience libraries get linked in and end up exceeding

8747

# the spec.

8748

if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then

8749

save_libobjs=$libobjs

8750

fi

8751

save_output=$output

8752

func_basename "$output"

8753

output_la=$func_basename_result

8754

8755

# Clear the reloadable object creation command queue and

8756

# initialize k to one.

8757

test_cmds=

8758

concat_cmds=

8759

objlist=

8760

last_robj=

8761

k=1

8762

8763

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

8764

output=${output_objdir}/${output_la}.lnkscript

8765

func_verbose "creating GNU ld script: $output"

8766

echo 'INPUT (' > $output

8767

for obj in $save_libobjs

8768

do

8769

func_to_tool_file "$obj"

8770

$ECHO "$func_to_tool_file_result" >> $output

8771

done

8772

echo ')' >> $output

8773

delfiles+=" $output"

8774

func_to_tool_file "$output"

8775

output=$func_to_tool_file_result

8776

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

8777

output=${output_objdir}/${output_la}.lnk

8778

func_verbose "creating linker input file list: $output"

8779

: > $output

8780

set x $save_libobjs

8781

shift

8782

firstobj=

8783

if test "$compiler_needs_object" = yes; then

8784

firstobj="$1 "

8785

shift

8786

fi

8787

for obj

8788

do

8789

func_to_tool_file "$obj"

8790

$ECHO "$func_to_tool_file_result" >> $output

8791

done

8792

delfiles+=" $output"

8793

func_to_tool_file "$output"

8794

output=$firstobj\"$file_list_spec$func_to_tool_file_result\"

8795

else

8796

if test -n "$save_libobjs"; then

8797

func_verbose "creating reloadable object files..."

8798

output=$output_objdir/$output_la-${k}.$objext

8799

eval test_cmds=\"$reload_cmds\"

8800

func_len " $test_cmds"

8801

len0=$func_len_result

8802

len=$len0

8803

8804

# Loop over the list of objects to be linked.

8805

for obj in $save_libobjs

8806

do

8807

func_len " $obj"

8808

func_arith $len + $func_len_result

8809

len=$func_arith_result

8810

if test "X$objlist" = X ||

8811

test "$len" -lt "$max_cmd_len"; then

8812

objlist+=" $obj"

8813

else

8814

# The command $test_cmds is almost too long, add a

8815

# command to the queue.

8816

if test "$k" -eq 1 ; then

8817

# The first file doesn't have a previous command to add.

8818

reload_objs=$objlist

8819

eval concat_cmds=\"$reload_cmds\"

8820

else

8821

# All subsequent reloadable object files will link in

8822

# the last one created.

8823

reload_objs="$objlist $last_robj"

8824

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

8825

fi

8826

last_robj=$output_objdir/$output_la-${k}.$objext

8827

func_arith $k + 1

8828

k=$func_arith_result

8829

output=$output_objdir/$output_la-${k}.$objext

8830

objlist=" $obj"

8831

func_len " $last_robj"

8832

func_arith $len0 + $func_len_result

8833

len=$func_arith_result

8834

fi

8835

done

8836

# Handle the remaining objects by creating one last

8837

# reloadable object file. All subsequent reloadable object

8838

# files will link in the last one created.

8839

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8840

reload_objs="$objlist $last_robj"

8841

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

8842

if test -n "$last_robj"; then

8843

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

8844

fi

8845

delfiles+=" $output"

8846

8847

else

8848

output=

8849

fi

8850

8851

if ${skipped_export-false}; then

8852

func_verbose "generating symbol list for \`$libname.la'"

8853

export_symbols="$output_objdir/$libname.exp"

8854

$opt_dry_run || $RM $export_symbols

8855

libobjs=$output

8856

# Append the command to create the export file.

8857

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8858

eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"

8859

if test -n "$last_robj"; then

8860

eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

8861

fi

8862

fi

8863

8864

test -n "$save_libobjs" &&

8865

func_verbose "creating a temporary reloadable object file: $output"

8866

8867

# Loop through the commands generated above and execute them.

8868

save_ifs="$IFS"; IFS='~'

8869

for cmd in $concat_cmds; do

8870

IFS="$save_ifs"

8871

$opt_silent || {

8872

func_quote_for_expand "$cmd"

8873

eval "func_echo $func_quote_for_expand_result"

8874

}

8875

$opt_dry_run || eval "$cmd" || {

8876

lt_exit=$?

8877

8878

# Restore the uninstalled library and exit

8879

if test "$opt_mode" = relink; then

8880

( cd "$output_objdir" && \

8881

$RM "${realname}T" && \

8882

$MV "${realname}U" "$realname" )

8883

fi

8884

8885

exit $lt_exit

8886

}

8887

done

8888

IFS="$save_ifs"

8889

8890

if test -n "$export_symbols_regex" && ${skipped_export-false}; then

8891

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8892

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8893

fi

8894

fi

8895

8896

if ${skipped_export-false}; then

8897

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8898

tmp_export_symbols="$export_symbols"

8899

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8900

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8901

fi

8902

8903

if test -n "$orig_export_symbols"; then

8904

# The given exports_symbols file has to be filtered, so filter it.

8905

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8906

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8907

# 's' commands which not all seds can handle. GNU sed should be fine

8908

# though. Also, the filter scales superlinearly with the number of

8909

# global variables. join(1) would be nice here, but unfortunately

8910

# isn't a blessed tool.

8911

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8912

delfiles+=" $export_symbols $output_objdir/$libname.filter"

8913

export_symbols=$output_objdir/$libname.def

8914

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8915

fi

8916

fi

8917

8918

libobjs=$output

8919

# Restore the value of output.

8920

output=$save_output

8921

8922

if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then

8923

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8924

test "X$libobjs" = "X " && libobjs=

8925

fi

8926

# Expand the library linking commands again to reset the

8927

# value of $libobjs for piecewise linking.

8928

8929

# Do each of the archive commands.

8930

if test "$module" = yes && test -n "$module_cmds" ; then

8931

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8932

cmds=$module_expsym_cmds

8933

else

8934

cmds=$module_cmds

8935

fi

8936

else

8937

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8938

cmds=$archive_expsym_cmds

8939

else

8940

cmds=$archive_cmds

8941

fi

8942

fi

8943

fi

8944

8945

if test -n "$delfiles"; then

8946

# Append the command to remove temporary files to $cmds.

8947

eval cmds=\"\$cmds~\$RM $delfiles\"

8948

fi

8949

8950

# Add any objects from preloaded convenience libraries

8951

if test -n "$dlprefiles"; then

8952

gentop="$output_objdir/${outputname}x"

8953

generated+=" $gentop"

8954

8955

func_extract_archives $gentop $dlprefiles

8956

libobjs+=" $func_extract_archives_result"

8957

test "X$libobjs" = "X " && libobjs=

8958

fi

8959

8960

save_ifs="$IFS"; IFS='~'

8961

for cmd in $cmds; do

8962

IFS="$save_ifs"

8963

eval cmd=\"$cmd\"

8964

$opt_silent || {

8965

func_quote_for_expand "$cmd"

8966

eval "func_echo $func_quote_for_expand_result"

8967

}

8968

$opt_dry_run || eval "$cmd" || {

8969

lt_exit=$?

8970

8971

# Restore the uninstalled library and exit

8972

if test "$opt_mode" = relink; then

8973

( cd "$output_objdir" && \

8974

$RM "${realname}T" && \

8975

$MV "${realname}U" "$realname" )

8976

fi

8977

8978

exit $lt_exit

8979

}

8980

done

8981

IFS="$save_ifs"

8982

8983

# Restore the uninstalled library and exit

8984

if test "$opt_mode" = relink; then

8985

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

8986

8987

if test -n "$convenience"; then

8988

if test -z "$whole_archive_flag_spec"; then

8989

func_show_eval '${RM}r "$gentop"'

8990

fi

8991

fi

8992

8993

exit $EXIT_SUCCESS

8994

fi

8995

8996

# Create links to the real library.

8997

for linkname in $linknames; do

8998

if test "$realname" != "$linkname"; then

8999

func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'

9000

fi

9001

done

9002

9003

# If -module or -export-dynamic was specified, set the dlname.

9004

if test "$module" = yes || test "$export_dynamic" = yes; then

9005

# On all known operating systems, these are identical.

9006

dlname="$soname"

9007

fi

9008

fi

9009

;;

9010

9011

obj)

9012

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

9013

func_warning "\`-dlopen' is ignored for objects"

9014

fi

9015

9016

case " $deplibs" in

9017

*\ -l* | *\ -L*)

9018

func_warning "\`-l' and \`-L' are ignored for objects" ;;

9019

esac

9020

9021

test -n "$rpath" && \

9022

func_warning "\`-rpath' is ignored for objects"

9023

9024

test -n "$xrpath" && \

9025

func_warning "\`-R' is ignored for objects"

9026

9027

test -n "$vinfo" && \

9028

func_warning "\`-version-info' is ignored for objects"

9029

9030

test -n "$release" && \

9031

func_warning "\`-release' is ignored for objects"

9032

9033

case $output in

9034

*.lo)

9035

test -n "$objs$old_deplibs" && \

9036

func_fatal_error "cannot build library object \`$output' from non-libtool objects"

9037

9038

libobj=$output

9039

func_lo2o "$libobj"

9040

obj=$func_lo2o_result

9041

;;

9042

*)

9043

libobj=

9044

obj="$output"

9045

;;

9046

esac

9047

9048

# Delete the old objects.

9049

$opt_dry_run || $RM $obj $libobj

9050

9051

# Objects from convenience libraries. This assumes

9052

# single-version convenience libraries. Whenever we create

9053

# different ones for PIC/non-PIC, this we'll have to duplicate

9054

# the extraction.

9055

reload_conv_objs=

9056

gentop=

9057

# reload_cmds runs $LD directly, so let us get rid of

9058

# -Wl from whole_archive_flag_spec and hope we can get by with

9059

# turning comma into space..

9060

wl=

9061

9062

if test -n "$convenience"; then

9063

if test -n "$whole_archive_flag_spec"; then

9064

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

9065

reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

9066

else

9067

gentop="$output_objdir/${obj}x"

9068

generated+=" $gentop"

9069

9070

func_extract_archives $gentop $convenience

9071

reload_conv_objs="$reload_objs $func_extract_archives_result"

9072

fi

9073

fi

9074

9075

# If we're not building shared, we need to use non_pic_objs

9076

test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

9077

9078

# Create the old-style object.

9079

reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

9080

9081

output="$obj"

9082

func_execute_cmds "$reload_cmds" 'exit $?'

9083

9084

# Exit if we aren't doing a library object file.

9085

if test -z "$libobj"; then

9086

if test -n "$gentop"; then

9087

func_show_eval '${RM}r "$gentop"'

9088

fi

9089

9090

exit $EXIT_SUCCESS

9091

fi

9092

9093

if test "$build_libtool_libs" != yes; then

9094

if test -n "$gentop"; then

9095

func_show_eval '${RM}r "$gentop"'

9096

fi

9097

9098

# Create an invalid libtool object if no PIC, so that we don't

9099

# accidentally link it into a program.

9100

# $show "echo timestamp > $libobj"

9101

# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?

9102

exit $EXIT_SUCCESS

9103

fi

9104

9105

if test -n "$pic_flag" || test "$pic_mode" != default; then

9106

# Only do commands if we really have different PIC objects.

9107

reload_objs="$libobjs $reload_conv_objs"

9108

output="$libobj"

9109

func_execute_cmds "$reload_cmds" 'exit $?'

9110

fi

9111

9112

if test -n "$gentop"; then

9113

func_show_eval '${RM}r "$gentop"'

9114

fi

9115

9116

exit $EXIT_SUCCESS

9117

;;

9118

9119

prog)

9120

case $host in

9121

*cygwin*) func_stripname '' '.exe' "$output"

9122

output=$func_stripname_result.exe;;

9123

esac

9124

test -n "$vinfo" && \

9125

func_warning "\`-version-info' is ignored for programs"

9126

9127

test -n "$release" && \

9128

func_warning "\`-release' is ignored for programs"

9129

9130

test "$preload" = yes \

9131

&& test "$dlopen_support" = unknown \

9132

&& test "$dlopen_self" = unknown \

9133

&& test "$dlopen_self_static" = unknown && \

9134

func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

9135

9136

case $host in

9137

*-*-rhapsody* | *-*-darwin1.[012])

9138

# On Rhapsody replace the C library is the System framework

9139

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

9140

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

9141

;;

9142

esac

9143

9144

case $host in

9145

*-*-darwin*)

9146

# Don't allow lazy linking, it breaks C++ global constructors

9147

# But is supposedly fixed on 10.4 or later (yay!).

9148

if test "$tagname" = CXX ; then

9149

case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

9150

10.[0123])

9151

compile_command+=" ${wl}-bind_at_load"

9152

finalize_command+=" ${wl}-bind_at_load"

9153

;;

9154

esac

9155

fi

9156

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

9157

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

9158

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

9159

;;

9160

esac

9161

9162

9163

# move library search paths that coincide with paths to not yet

9164

# installed libraries to the beginning of the library search list

9165

new_libs=

9166

for path in $notinst_path; do

9167

case " $new_libs " in

9168

*" -L$path/$objdir "*) ;;

9169

*)

9170

case " $compile_deplibs " in

9171

*" -L$path/$objdir "*)

9172

new_libs+=" -L$path/$objdir" ;;

9173

esac

9174

;;

9175

esac

9176

done

9177

for deplib in $compile_deplibs; do

9178

case $deplib in

9179

-L*)

9180

case " $new_libs " in

9181

*" $deplib "*) ;;

9182

*) new_libs+=" $deplib" ;;

9183

esac

9184

;;

9185

*) new_libs+=" $deplib" ;;

9186

esac

9187

done

9188

compile_deplibs="$new_libs"

9189

9190

9191

compile_command+=" $compile_deplibs"

9192

finalize_command+=" $finalize_deplibs"

9193

9194

if test -n "$rpath$xrpath"; then

9195

# If the user specified any rpath flags, then add them.

9196

for libdir in $rpath $xrpath; do

9197

# This is the magic to use -rpath.

9198

case "$finalize_rpath " in

9199

*" $libdir "*) ;;

9200

*) finalize_rpath+=" $libdir" ;;

9201

esac

9202

done

9203

fi

9204

9205

# Now hardcode the library paths

9206

rpath=

9207

hardcode_libdirs=

9208

for libdir in $compile_rpath $finalize_rpath; do

9209

if test -n "$hardcode_libdir_flag_spec"; then

9210

if test -n "$hardcode_libdir_separator"; then

9211

if test -z "$hardcode_libdirs"; then

9212

hardcode_libdirs="$libdir"

9213

else

9214

# Just accumulate the unique libdirs.

9215

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

9216

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

9217

;;

9218

*)

9219

hardcode_libdirs+="$hardcode_libdir_separator$libdir"

9220

;;

9221

esac

9222

fi

9223

else

9224

eval flag=\"$hardcode_libdir_flag_spec\"

9225

rpath+=" $flag"

9226

fi

9227

elif test -n "$runpath_var"; then

9228

case "$perm_rpath " in

9229

*" $libdir "*) ;;

9230

*) perm_rpath+=" $libdir" ;;

9231

esac

9232

fi

9233

case $host in

9234

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

9235

testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`

9236

case :$dllsearchpath: in

9237

*":$libdir:"*) ;;

9238

::) dllsearchpath=$libdir;;

9239

*) dllsearchpath+=":$libdir";;

9240

esac

9241

case :$dllsearchpath: in

9242

*":$testbindir:"*) ;;

9243

::) dllsearchpath=$testbindir;;

9244

*) dllsearchpath+=":$testbindir";;

9245

esac

9246

;;

9247

esac

9248

done

9249

# Substitute the hardcoded libdirs into the rpath.

9250

if test -n "$hardcode_libdir_separator" &&

9251

test -n "$hardcode_libdirs"; then

9252

libdir="$hardcode_libdirs"

9253

eval rpath=\" $hardcode_libdir_flag_spec\"

9254

fi

9255

compile_rpath="$rpath"

9256

9257

rpath=

9258

hardcode_libdirs=

9259

for libdir in $finalize_rpath; do

9260

if test -n "$hardcode_libdir_flag_spec"; then

9261

if test -n "$hardcode_libdir_separator"; then

9262

if test -z "$hardcode_libdirs"; then

9263

hardcode_libdirs="$libdir"

9264

else

9265

# Just accumulate the unique libdirs.

9266

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

9267

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

9268

;;

9269

*)

9270

hardcode_libdirs+="$hardcode_libdir_separator$libdir"

9271

;;

9272

esac

9273

fi

9274

else

9275

eval flag=\"$hardcode_libdir_flag_spec\"

9276

rpath+=" $flag"

9277

fi

9278

elif test -n "$runpath_var"; then

9279

case "$finalize_perm_rpath " in

9280

*" $libdir "*) ;;

9281

*) finalize_perm_rpath+=" $libdir" ;;

9282

esac

9283

fi

9284

done

9285

# Substitute the hardcoded libdirs into the rpath.

9286

if test -n "$hardcode_libdir_separator" &&

9287

test -n "$hardcode_libdirs"; then

9288

libdir="$hardcode_libdirs"

9289

eval rpath=\" $hardcode_libdir_flag_spec\"

9290

fi

9291

finalize_rpath="$rpath"

9292

9293

if test -n "$libobjs" && test "$build_old_libs" = yes; then

9294

# Transform all the library objects into standard objects.

9295

compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

9296

finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

9297

fi

9298

9299

func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

9300

9301

# template prelinking step

9302

if test -n "$prelink_cmds"; then

9303

func_execute_cmds "$prelink_cmds" 'exit $?'

9304

fi

9305

9306

wrappers_required=yes

9307

case $host in

9308

*cegcc* | *mingw32ce*)

9309

# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

9310

wrappers_required=no

9311

;;

9312

*cygwin* | *mingw* )

9313

if test "$build_libtool_libs" != yes; then

9314

wrappers_required=no

9315

fi

9316

;;

9317

*)

9318

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

9319

wrappers_required=no

9320

fi

9321

;;

9322

esac

9323

if test "$wrappers_required" = no; then

9324

# Replace the output file specification.

9325

compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

9326

link_command="$compile_command$compile_rpath"

9327

9328

# We have no uninstalled library dependencies, so finalize right now.

9329

exit_status=0

9330

func_show_eval "$link_command" 'exit_status=$?'

9331

9332

if test -n "$postlink_cmds"; then

9333

func_to_tool_file "$output"

9334

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

9335

func_execute_cmds "$postlink_cmds" 'exit $?'

9336

fi

9337

9338

# Delete the generated files.

9339

if test -f "$output_objdir/${outputname}S.${objext}"; then

9340

func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

9341

fi

9342

9343

exit $exit_status

9344

fi

9345

9346

if test -n "$compile_shlibpath$finalize_shlibpath"; then

9347

compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

9348

fi

9349

if test -n "$finalize_shlibpath"; then

9350

finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

9351

fi

9352

9353

compile_var=

9354

finalize_var=

9355

if test -n "$runpath_var"; then

9356

if test -n "$perm_rpath"; then

9357

# We should set the runpath_var.

9358

rpath=

9359

for dir in $perm_rpath; do

9360

rpath+="$dir:"

9361

done

9362

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

9363

fi

9364

if test -n "$finalize_perm_rpath"; then

9365

# We should set the runpath_var.

9366

rpath=

9367

for dir in $finalize_perm_rpath; do

9368

rpath+="$dir:"

9369

done

9370

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

9371

fi

9372

fi

9373

9374

if test "$no_install" = yes; then

9375

# We don't need to create a wrapper script.

9376

link_command="$compile_var$compile_command$compile_rpath"

9377

# Replace the output file specification.

9378

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

9379

# Delete the old output file.

9380

$opt_dry_run || $RM $output

9381

# Link the executable and exit

9382

func_show_eval "$link_command" 'exit $?'

9383

9384

if test -n "$postlink_cmds"; then

9385

func_to_tool_file "$output"

9386

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

9387

func_execute_cmds "$postlink_cmds" 'exit $?'

9388

fi

9389

9390

exit $EXIT_SUCCESS

9391

fi

9392

9393

if test "$hardcode_action" = relink; then

9394

# Fast installation is not supported

9395

link_command="$compile_var$compile_command$compile_rpath"

9396

relink_command="$finalize_var$finalize_command$finalize_rpath"

9397

9398

func_warning "this platform does not like uninstalled shared libraries"

9399

func_warning "\`$output' will be relinked during installation"

9400

else

9401

if test "$fast_install" != no; then

9402

link_command="$finalize_var$compile_command$finalize_rpath"

9403

if test "$fast_install" = yes; then

9404

relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

9405

else

9406

# fast_install is set to needless

9407

relink_command=

9408

fi

9409

else

9410

link_command="$compile_var$compile_command$compile_rpath"

9411

relink_command="$finalize_var$finalize_command$finalize_rpath"

9412

fi

9413

fi

9414

9415

# Replace the output file specification.

9416

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

9417

9418

# Delete the old output files.

9419

$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

9420

9421

func_show_eval "$link_command" 'exit $?'

9422

9423

if test -n "$postlink_cmds"; then

9424

func_to_tool_file "$output_objdir/$outputname"

9425

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

9426

func_execute_cmds "$postlink_cmds" 'exit $?'

9427

fi

9428

9429

# Now create the wrapper script.

9430

func_verbose "creating $output"

9431

9432

# Quote the relink command for shipping.

9433

if test -n "$relink_command"; then

9434

# Preserve any variables that may affect compiler behavior

9435

for var in $variables_saved_for_relink; do

9436

if eval test -z \"\${$var+set}\"; then

9437

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9438

elif eval var_value=\$$var; test -z "$var_value"; then

9439

relink_command="$var=; export $var; $relink_command"

9440

else

9441

func_quote_for_eval "$var_value"

9442

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9443

fi

9444

done

9445

relink_command="(cd `pwd`; $relink_command)"

9446

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9447

fi

9448

9449

# Only actually do things if not in dry run mode.

9450

$opt_dry_run || {

9451

# win32 will think the script is a binary if it has

9452

# a .exe suffix, so we strip it off here.

9453

case $output in

9454

*.exe) func_stripname '' '.exe' "$output"

9455

output=$func_stripname_result ;;

9456

esac

9457

# test for cygwin because mv fails w/o .exe extensions

9458

case $host in

9459

*cygwin*)

9460

exeext=.exe

9461

func_stripname '' '.exe' "$outputname"

9462

outputname=$func_stripname_result ;;

9463

*) exeext= ;;

9464

esac

9465

case $host in

9466

*cygwin* | *mingw* )

9467

func_dirname_and_basename "$output" "" "."

9468

output_name=$func_basename_result

9469

output_path=$func_dirname_result

9470

cwrappersource="$output_path/$objdir/lt-$output_name.c"

9471

cwrapper="$output_path/$output_name.exe"

9472

$RM $cwrappersource $cwrapper

9473

trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

9474

9475

func_emit_cwrapperexe_src > $cwrappersource

9476

9477

# The wrapper executable is built using the $host compiler,

9478

# because it contains $host paths and files. If cross-

9479

# compiling, it, like the target executable, must be

9480

# executed on the $host or under an emulation environment.

9481

$opt_dry_run || {

9482

$LTCC $LTCFLAGS -o $cwrapper $cwrappersource

9483

$STRIP $cwrapper

9484

}

9485

9486

# Now, create the wrapper script for func_source use:

9487

func_ltwrapper_scriptname $cwrapper

9488

$RM $func_ltwrapper_scriptname_result

9489

trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15

9490

$opt_dry_run || {

9491

# note: this script will not be executed, so do not chmod.

9492

if test "x$build" = "x$host" ; then

9493

$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result

9494

else

9495

func_emit_wrapper no > $func_ltwrapper_scriptname_result

9496

fi

9497

}

9498

;;

9499

* )

9500

$RM $output

9501

trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

9502

9503

func_emit_wrapper no > $output

9504

chmod +x $output

9505

;;

9506

esac

9507

}

9508

exit $EXIT_SUCCESS

9509

;;

9510

esac

9511

9512

# See if we need to build an old-fashioned archive.

9513

for oldlib in $oldlibs; do

9514

9515

if test "$build_libtool_libs" = convenience; then

9516

oldobjs="$libobjs_save $symfileobj"

9517

addlibs="$convenience"

9518

build_libtool_libs=no

9519

else

9520

if test "$build_libtool_libs" = module; then

9521

oldobjs="$libobjs_save"

9522

build_libtool_libs=no

9523

else

9524

oldobjs="$old_deplibs $non_pic_objects"

9525

if test "$preload" = yes && test -f "$symfileobj"; then

9526

oldobjs+=" $symfileobj"

9527

fi

9528

fi

9529

addlibs="$old_convenience"

9530

fi

9531

9532

if test -n "$addlibs"; then

9533

gentop="$output_objdir/${outputname}x"

9534

generated+=" $gentop"

9535

9536

func_extract_archives $gentop $addlibs

9537

oldobjs+=" $func_extract_archives_result"

9538

fi

9539

9540

# Do each command in the archive commands.

9541

if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

9542

cmds=$old_archive_from_new_cmds

9543

else

9544

9545

# Add any objects from preloaded convenience libraries

9546

if test -n "$dlprefiles"; then

9547

gentop="$output_objdir/${outputname}x"

9548

generated+=" $gentop"

9549

9550

func_extract_archives $gentop $dlprefiles

9551

oldobjs+=" $func_extract_archives_result"

9552

fi

9553

9554

# POSIX demands no paths to be encoded in archives. We have

9555

# to avoid creating archives with duplicate basenames if we

9556

# might have to extract them afterwards, e.g., when creating a

9557

# static archive out of a convenience library, or when linking

9558

# the entirety of a libtool archive into another (currently

9559

# not supported by libtool).

9560

if (for obj in $oldobjs

9561

do

9562

func_basename "$obj"

9563

$ECHO "$func_basename_result"

9564

done | sort | sort -uc >/dev/null 2>&1); then

9565

:

9566

else

9567

echo "copying selected object files to avoid basename conflicts..."

9568

gentop="$output_objdir/${outputname}x"

9569

generated+=" $gentop"

9570

func_mkdir_p "$gentop"

9571

save_oldobjs=$oldobjs

9572

oldobjs=

9573

counter=1

9574

for obj in $save_oldobjs

9575

do

9576

func_basename "$obj"

9577

objbase="$func_basename_result"

9578

case " $oldobjs " in

9579

" ") oldobjs=$obj ;;

9580

*[\ /]"$objbase "*)

9581

while :; do

9582

# Make sure we don't pick an alternate name that also

9583

# overlaps.

9584

newobj=lt$counter-$objbase

9585

func_arith $counter + 1

9586

counter=$func_arith_result

9587

case " $oldobjs " in

9588

*[\ /]"$newobj "*) ;;

9589

*) if test ! -f "$gentop/$newobj"; then break; fi ;;

9590

esac

9591

done

9592

func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

9593

oldobjs+=" $gentop/$newobj"

9594

;;

9595

*) oldobjs+=" $obj" ;;

9596

esac

9597

done

9598

fi

9599

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

9600

tool_oldlib=$func_to_tool_file_result

9601

eval cmds=\"$old_archive_cmds\"

9602

9603

func_len " $cmds"

9604

len=$func_len_result

9605

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

9606

cmds=$old_archive_cmds

9607

elif test -n "$archiver_list_spec"; then

9608

func_verbose "using command file archive linking..."

9609

for obj in $oldobjs

9610

do

9611

func_to_tool_file "$obj"

9612

$ECHO "$func_to_tool_file_result"

9613

done > $output_objdir/$libname.libcmd

9614

func_to_tool_file "$output_objdir/$libname.libcmd"

9615

oldobjs=" $archiver_list_spec$func_to_tool_file_result"

9616

cmds=$old_archive_cmds

9617

else

9618

# the command line is too long to link in one step, link in parts

9619

func_verbose "using piecewise archive linking..."

9620

save_RANLIB=$RANLIB

9621

RANLIB=:

9622

objlist=

9623

concat_cmds=

9624

save_oldobjs=$oldobjs

9625

oldobjs=

9626

# Is there a better way of finding the last object in the list?

9627

for obj in $save_oldobjs

9628

do

9629

last_oldobj=$obj

9630

done

9631

eval test_cmds=\"$old_archive_cmds\"

9632

func_len " $test_cmds"

9633

len0=$func_len_result

9634

len=$len0

9635

for obj in $save_oldobjs

9636

do

9637

func_len " $obj"

9638

func_arith $len + $func_len_result

9639

len=$func_arith_result

9640

objlist+=" $obj"

9641

if test "$len" -lt "$max_cmd_len"; then

9642

:

9643

else

9644

# the above command should be used before it gets too long

9645

oldobjs=$objlist

9646

if test "$obj" = "$last_oldobj" ; then

9647

RANLIB=$save_RANLIB

9648

fi

9649

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

9650

eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

9651

objlist=

9652

len=$len0

9653

fi

9654

done

9655

RANLIB=$save_RANLIB

9656

oldobjs=$objlist

9657

if test "X$oldobjs" = "X" ; then

9658

eval cmds=\"\$concat_cmds\"

9659

else

9660

eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

9661

fi

9662

fi

9663

fi

9664

func_execute_cmds "$cmds" 'exit $?'

9665

done

9666

9667

test -n "$generated" && \

9668

func_show_eval "${RM}r$generated"

9669

9670

# Now create the libtool archive.

9671

case $output in

9672

*.la)

9673

old_library=

9674

test "$build_old_libs" = yes && old_library="$libname.$libext"

9675

func_verbose "creating $output"

9676

9677

# Preserve any variables that may affect compiler behavior

9678

for var in $variables_saved_for_relink; do

9679

if eval test -z \"\${$var+set}\"; then

9680

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9681

elif eval var_value=\$$var; test -z "$var_value"; then

9682

relink_command="$var=; export $var; $relink_command"

9683

else

9684

func_quote_for_eval "$var_value"

9685

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9686

fi

9687

done

9688

# Quote the link command for shipping.

9689

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

9690

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9691

if test "$hardcode_automatic" = yes ; then

9692

relink_command=

9693

fi

9694

9695

# Only create the output if not a dry run.

9696

$opt_dry_run || {

9697

for installed in no yes; do

9698

if test "$installed" = yes; then

9699

if test -z "$install_libdir"; then

9700

break

9701

fi

9702

output="$output_objdir/$outputname"i

9703

# Replace all uninstalled libtool libraries with the installed ones

9704

newdependency_libs=

9705

for deplib in $dependency_libs; do

9706

case $deplib in

9707

*.la)

9708

func_basename "$deplib"

9709

name="$func_basename_result"

9710

func_resolve_sysroot "$deplib"

9711

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $func_resolve_sysroot_result`

9712

test -z "$libdir" && \

9713

func_fatal_error "\`$deplib' is not a valid libtool archive"

9714

newdependency_libs+=" ${lt_sysroot:+=}$libdir/$name"

9715

;;

9716

-L*)

9717

func_stripname -L '' "$deplib"

9718

func_replace_sysroot "$func_stripname_result"

9719

newdependency_libs+=" -L$func_replace_sysroot_result"

9720

;;

9721

-R*)

9722

func_stripname -R '' "$deplib"

9723

func_replace_sysroot "$func_stripname_result"

9724

newdependency_libs+=" -R$func_replace_sysroot_result"

9725

;;

9726

*) newdependency_libs+=" $deplib" ;;

9727

esac

9728

done

9729

dependency_libs="$newdependency_libs"

9730

newdlfiles=

9731

9732

for lib in $dlfiles; do

9733

case $lib in

9734

*.la)

9735

func_basename "$lib"

9736

name="$func_basename_result"

9737

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9738

test -z "$libdir" && \

9739

func_fatal_error "\`$lib' is not a valid libtool archive"

9740

newdlfiles+=" ${lt_sysroot:+=}$libdir/$name"

9741

;;

9742

*) newdlfiles+=" $lib" ;;

9743

esac

9744

done

9745

dlfiles="$newdlfiles"

9746

newdlprefiles=

9747

for lib in $dlprefiles; do

9748

case $lib in

9749

*.la)

9750

# Only pass preopened files to the pseudo-archive (for

9751

# eventual linking with the app. that links it) if we

9752

# didn't already link the preopened objects directly into

9753

# the library:

9754

func_basename "$lib"

9755

name="$func_basename_result"

9756

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9757

test -z "$libdir" && \

9758

func_fatal_error "\`$lib' is not a valid libtool archive"

9759

newdlprefiles+=" ${lt_sysroot:+=}$libdir/$name"

9760

;;

9761

esac

9762

done

9763

dlprefiles="$newdlprefiles"

9764

else

9765

newdlfiles=

9766

for lib in $dlfiles; do

9767

case $lib in

9768

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9769

*) abs=`pwd`"/$lib" ;;

9770

esac

9771

newdlfiles+=" $abs"

9772

done

9773

dlfiles="$newdlfiles"

9774

newdlprefiles=

9775

for lib in $dlprefiles; do

9776

case $lib in

9777

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9778

*) abs=`pwd`"/$lib" ;;

9779

esac

9780

newdlprefiles+=" $abs"

9781

done

9782

dlprefiles="$newdlprefiles"

9783

fi

9784

$RM $output

9785

# place dlname in correct position for cygwin

9786

# In fact, it would be nice if we could use this code for all target

9787

# systems that can't hard-code library paths into their executables

9788

# and that have no shared library path variable independent of PATH,

9789

# but it turns out we can't easily determine that from inspecting

9790

# libtool variables, so we have to hard-code the OSs to which it

9791

# applies here; at the moment, that means platforms that use the PE

9792

# object format with DLL files. See the long comment at the top of

9793

# tests/bindir.at for full details.

9794

tdlname=$dlname

9795

case $host,$output,$installed,$module,$dlname in

9796

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9797

# If a -bindir argument was supplied, place the dll there.

9798

if test "x$bindir" != x ;

9799

then

9800

func_relative_path "$install_libdir" "$bindir"

9801

tdlname=$func_relative_path_result$dlname

9802

else

9803

# Otherwise fall back on heuristic.

9804

tdlname=../bin/$dlname

9805

fi

9806

;;

9807

esac

9808

$ECHO > $output "\

9809

# $outputname - a libtool library file

9810

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

9811

#

9812

# Please DO NOT delete this file!

9813

# It is necessary for linking the library.

9814

9815

# The name that we can dlopen(3).

9816

dlname='$tdlname'

9817

9818

# Names of this library.

9819

library_names='$library_names'

9820

9821

# The name of the static archive.

9822

old_library='$old_library'

9823

9824

# Linker flags that can not go in dependency_libs.

9825

inherited_linker_flags='$new_inherited_linker_flags'

9826

9827

# Libraries that this one depends upon.

9828

dependency_libs='$dependency_libs'

9829

9830

# Names of additional weak libraries provided by this library

9831

weak_library_names='$weak_libs'

9832

9833

# Version information for $libname.

9834

current=$current

9835

age=$age

9836

revision=$revision

9837

9838

# Is this an already installed library?

9839

installed=$installed

9840

9841

# Should we warn about portability when linking against -modules?

9842

shouldnotlink=$module

9843

9844

# Files to dlopen/dlpreopen

9845

dlopen='$dlfiles'

9846

dlpreopen='$dlprefiles'

9847

9848

# Directory that this library needs to be installed in:

9849

libdir='$install_libdir'"

9850

if test "$installed" = no && test "$need_relink" = yes; then

9851

$ECHO >> $output "\

9852

relink_command=\"$relink_command\""

9853

fi

9854

done

9855

}

9856

9857

# Do a symbolic link so that the libtool archive can be found in

9858

# LD_LIBRARY_PATH before the program is installed.

9859

func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'

9860

;;

9861

esac

9862

exit $EXIT_SUCCESS

9863

}

9864

9865

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&

9866

func_mode_link ${1+"$@"}

9867

9868

9869

# func_mode_uninstall arg...

9870

func_mode_uninstall ()

9871

{

9872

$opt_debug

9873

RM="$nonopt"

9874

files=

9875

rmforce=

9876

exit_status=0

9877

9878

# This variable tells wrapper scripts just to set variables rather

9879

# than running their programs.

9880

libtool_install_magic="$magic"

9881

9882

for arg

9883

do

9884

case $arg in

9885

-f) RM+=" $arg"; rmforce=yes ;;

9886

-*) RM+=" $arg" ;;

9887

*) files+=" $arg" ;;

9888

esac

9889

done

9890

9891

test -z "$RM" && \

9892

func_fatal_help "you must specify an RM program"

9893

9894

rmdirs=

9895

9896

for file in $files; do

9897

func_dirname "$file" "" "."

9898

dir="$func_dirname_result"

9899

if test "X$dir" = X.; then

9900

odir="$objdir"

9901

else

9902

odir="$dir/$objdir"

9903

fi

9904

func_basename "$file"

9905

name="$func_basename_result"

9906

test "$opt_mode" = uninstall && odir="$dir"

9907

9908

# Remember odir for removal later, being careful to avoid duplicates

9909

if test "$opt_mode" = clean; then

9910

case " $rmdirs " in

9911

*" $odir "*) ;;

9912

*) rmdirs+=" $odir" ;;

9913

esac

9914

fi

9915

9916

# Don't error if the file doesn't exist and rm -f was used.

9917

if { test -L "$file"; } >/dev/null 2>&1 ||

9918

{ test -h "$file"; } >/dev/null 2>&1 ||

9919

test -f "$file"; then

9920

:

9921

elif test -d "$file"; then

9922

exit_status=1

9923

continue

9924

elif test "$rmforce" = yes; then

9925

continue

9926

fi

9927

9928

rmfiles="$file"

9929

9930

case $name in

9931

*.la)

9932

# Possibly a libtool archive, so verify it.

9933

if func_lalib_p "$file"; then

9934

func_source $dir/$name

9935

9936

# Delete the libtool libraries and symlinks.

9937

for n in $library_names; do

9938

rmfiles+=" $odir/$n"

9939

done

9940

test -n "$old_library" && rmfiles+=" $odir/$old_library"

9941

9942

case "$opt_mode" in

9943

clean)

9944

case " $library_names " in

9945

*" $dlname "*) ;;

9946

*) test -n "$dlname" && rmfiles+=" $odir/$dlname" ;;

9947

esac

9948

test -n "$libdir" && rmfiles+=" $odir/$name $odir/${name}i"

9949

;;

9950

uninstall)

9951

if test -n "$library_names"; then

9952

# Do each command in the postuninstall commands.

9953

func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9954

fi

9955

9956

if test -n "$old_library"; then

9957

# Do each command in the old_postuninstall commands.

9958

func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9959

fi

9960

# FIXME: should reinstall the best remaining shared library.

9961

;;

9962

esac

9963

fi

9964

;;

9965

9966

*.lo)

9967

# Possibly a libtool object, so verify it.

9968

if func_lalib_p "$file"; then

9969

9970

# Read the .lo file

9971

func_source $dir/$name

9972

9973

# Add PIC object to the list of files to remove.

9974

if test -n "$pic_object" &&

9975

test "$pic_object" != none; then

9976

rmfiles+=" $dir/$pic_object"

9977

fi

9978

9979

# Add non-PIC object to the list of files to remove.

9980

if test -n "$non_pic_object" &&

9981

test "$non_pic_object" != none; then

9982

rmfiles+=" $dir/$non_pic_object"

9983

fi

9984

fi

9985

;;

9986

9987

*)

9988

if test "$opt_mode" = clean ; then

9989

noexename=$name

9990

case $file in

9991

*.exe)

9992

func_stripname '' '.exe' "$file"

9993

file=$func_stripname_result

9994

func_stripname '' '.exe' "$name"

9995

noexename=$func_stripname_result

9996

# $file with .exe has already been added to rmfiles,

9997

# add $file without .exe

9998

rmfiles+=" $file"

9999

;;

10000

esac

10001

# Do a test to see if this is a libtool program.

10002

if func_ltwrapper_p "$file"; then

10003

if func_ltwrapper_executable_p "$file"; then

10004

func_ltwrapper_scriptname "$file"

10005

relink_command=

10006

func_source $func_ltwrapper_scriptname_result

10007

rmfiles+=" $func_ltwrapper_scriptname_result"

10008

else

10009

relink_command=

10010

func_source $dir/$noexename

10011

fi

10012

10013

# note $name still contains .exe if it was in $file originally

10014

# as does the version of $file that was added into $rmfiles

10015

rmfiles+=" $odir/$name $odir/${name}S.${objext}"

10016

if test "$fast_install" = yes && test -n "$relink_command"; then

10017

rmfiles+=" $odir/lt-$name"

10018

fi

10019

if test "X$noexename" != "X$name" ; then

10020

rmfiles+=" $odir/lt-${noexename}.c"

10021

fi

10022

fi

10023

fi

10024

;;

10025

esac

10026

func_show_eval "$RM $rmfiles" 'exit_status=1'

10027

done

10028

10029

# Try to remove the ${objdir}s in the directories where we deleted files

10030

for dir in $rmdirs; do

10031

if test -d "$dir"; then

10032

func_show_eval "rmdir $dir >/dev/null 2>&1"

10033

fi

10034

done

10035

10036

exit $exit_status

10037

}

10038

10039

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&

10040

func_mode_uninstall ${1+"$@"}

10041

10042

test -z "$opt_mode" && {

10043

help="$generic_help"

10044

func_fatal_help "you must specify a MODE"

10045

}

10046

10047

test -z "$exec_cmd" && \

10048

func_fatal_help "invalid operation mode \`$opt_mode'"

10049

10050

if test -n "$exec_cmd"; then

10051

eval exec "$exec_cmd"

10052

exit $EXIT_FAILURE

10053

fi

10054

10055

exit $exit_status

10056

10057

10058

# The TAGs below are defined such that we never get into a situation

10059

# in which we disable both kinds of libraries. Given conflicting

10060

# choices, we go for a static library, that is the most portable,

10061

# since we can't tell whether shared libraries were disabled because

10062

# the user asked for that or because the platform doesn't support

10063

# them. This is particularly important on AIX, because we don't

10064

# support having both static and shared libraries enabled at the same

10065

# time on that platform, so we default to a shared-only configuration.

10066

# If a disable-shared tag is given, we'll fallback to a static-only

10067

# configuration. But we'll never go from static-only to shared-only.

10068

10069

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared

10070

build_libtool_libs=no

10071

build_old_libs=yes

10072

# ### END LIBTOOL TAG CONFIG: disable-shared

10073

10074

# ### BEGIN LIBTOOL TAG CONFIG: disable-static

10075

build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

10076

# ### END LIBTOOL TAG CONFIG: disable-static

10077

10078

# Local Variables:

10079

# mode:shell-script

10080

# sh-indentation:2

10081

# End:

10082

# vi:sw=2

10083