~ubuntu-branches/ubuntu/natty/bind9/natty-security : revision 23

1

# ltmain.sh - Provide generalized library-building support services.

2

# NOTE: Changing this file will not affect anything until you rerun configure.

3

#

4

5

# 2007, 2008 Free Software Foundation, Inc.

6

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

7

#

8

# This program is free software; you can redistribute it and/or modify

9

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

10

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

11

# (at your option) any later version.

12

#

13

# This program is distributed in the hope that it will be useful, but

14

# WITHOUT ANY WARRANTY; without even the implied warranty of

15

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

16

# General Public License for more details.

17

#

18

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

19

# along with this program; if not, write to the Free Software

20

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

21

#

22

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

23

# distribute this file as part of a program that contains a

24

# configuration script generated by Autoconf, you may include it under

25

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

26

27

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

28

29

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

30

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

31

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

32

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

33

# function.

34

progpath="$0"

35

36

# The name of this program:

37

progname=`echo "$progpath" | $SED $basename`

38

modename="$progname"

39

40

# Global variables:

41

EXIT_SUCCESS=0

42

EXIT_FAILURE=1

43

44

PROGRAM=ltmain.sh

45

PACKAGE=libtool

46

VERSION=1.5.26

47

TIMESTAMP=" (1.1220.2.492 2008/01/30 06:40:56)"

48

49

# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).

50

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

51

emulate sh

52

NULLCMD=:

53

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

54

# is contrary to our usage. Disable this feature.

55

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

56

setopt NO_GLOB_SUBST

57

else

58

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

59

fi

60

BIN_SH=xpg4; export BIN_SH # for Tru64

61

DUALCASE=1; export DUALCASE # for MKS sh

62

63

# Check that we have a working $echo.

64

if test "X$1" = X--no-reexec; then

65

# Discard the --no-reexec flag, and continue.

66

shift

67

elif test "X$1" = X--fallback-echo; then

68

# Avoid inline document here, it may be left over

69

:

70

elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then

71

# Yippee, $echo works!

72

:

73

else

74

# Restart under the correct shell, and then maybe $echo will work.

75

exec $SHELL "$progpath" --no-reexec ${1+"$@"}

76

fi

77

78

if test "X$1" = X--fallback-echo; then

79

# used as fallback echo

80

shift

81

cat <<EOF

82

$*

83

EOF

84

exit $EXIT_SUCCESS

85

fi

86

87

default_mode=

88

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

89

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

90

mkdir="mkdir"

91

mv="mv -f"

92

rm="rm -f"

93

94

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

95

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

96

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

97

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

98

# test EBCDIC or ASCII

99

case `echo X|tr X '\101'` in

100

A) # ASCII based system

101

# \n is not interpreted correctly by Solaris 8 /usr/ucb/tr

102

SP2NL='tr \040 \012'

103

NL2SP='tr \015\012 \040\040'

104

;;

105

*) # EBCDIC based system

106

SP2NL='tr \100 \n'

107

NL2SP='tr \r\n \100\100'

108

;;

109

esac

110

111

# NLS nuisances.

112

# Only set LANG and LC_ALL to C if already set.

113

# These must not be set unconditionally because not all systems understand

114

# e.g. LANG=C (notably SCO).

115

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

116

lt_env=

117

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

118

do

119

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

120

save_$lt_var=\$$lt_var

121

lt_env=\"$lt_var=\$$lt_var \$lt_env\"

122

$lt_var=C

123

export $lt_var

124

fi"

125

done

126

127

if test -n "$lt_env"; then

128

lt_env="env $lt_env"

129

fi

130

131

# Make sure IFS has a sensible default

132

lt_nl='

133

'

134

IFS=" $lt_nl"

135

136

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

137

$echo "$modename: not configured to build any kind of library" 1>&2

138

$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2

139

exit $EXIT_FAILURE

140

fi

141

142

# Global variables.

143

mode=$default_mode

144

nonopt=

145

prev=

146

prevopt=

147

run=

148

show="$echo"

149

show_help=

150

execute_dlfiles=

151

duplicate_deps=no

152

preserve_args=

153

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

154

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

155

extracted_archives=

156

extracted_serial=0

157

158

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

159

# Shell function definitions:

160

# This seems to be the best place for them

161

162

# func_mktempdir [string]

163

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

164

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

165

# given, STRING is the basename for that directory.

166

func_mktempdir ()

167

{

168

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

169

170

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

171

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

172

my_tmpdir="${my_template}-$$"

173

else

174

175

# If mktemp works, use that first and foremost

176

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

177

178

if test ! -d "$my_tmpdir"; then

179

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

180

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

181

182

save_mktempdir_umask=`umask`

183

umask 0077

184

$mkdir "$my_tmpdir"

185

umask $save_mktempdir_umask

186

fi

187

188

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

189

test -d "$my_tmpdir" || {

190

$echo "cannot create temporary directory \`$my_tmpdir'" 1>&2

191

exit $EXIT_FAILURE

192

}

193

fi

194

195

$echo "X$my_tmpdir" | $Xsed

196

}

197

198

199

# func_win32_libid arg

200

# return the library type of file 'arg'

201

#

202

# Need a lot of goo to handle *both* DLLs and import libs

203

# Has to be a shell function in order to 'eat' the argument

204

# that is supplied when $file_magic_command is called.

205

func_win32_libid ()

206

{

207

win32_libid_type="unknown"

208

win32_fileres=`file -L $1 2>/dev/null`

209

case $win32_fileres in

210

*ar\ archive\ import\ library*) # definitely import

211

win32_libid_type="x86 archive import"

212

;;

213

*ar\ archive*) # could be an import, or static

214

if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \

215

$EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then

216

win32_nmres=`eval $NM -f posix -A $1 | \

217

$SED -n -e '1,100{

218

/ I /{

219

s,.*,import,

220

p

221

q

222

}

223

}'`

224

case $win32_nmres in

225

import*) win32_libid_type="x86 archive import";;

226

*) win32_libid_type="x86 archive static";;

227

esac

228

fi

229

;;

230

*DLL*)

231

win32_libid_type="x86 DLL"

232

;;

233

*executable*) # but shell scripts are "executable" too...

234

case $win32_fileres in

235

*MS\ Windows\ PE\ Intel*)

236

win32_libid_type="x86 DLL"

237

;;

238

esac

239

;;

240

esac

241

$echo $win32_libid_type

242

}

243

244

245

# func_infer_tag arg

246

# Infer tagged configuration to use if any are available and

247

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

248

# Only attempt this if the compiler in the base compile

249

# command doesn't match the default compiler.

250

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

251

func_infer_tag ()

252

{

253

# FreeBSD-specific: where we install compilers with non-standard names

254

tag_compilers_CC="*cc cc* *gcc gcc*"

255

tag_compilers_CXX="*c++ c++* *g++ g++*"

256

base_compiler=`set -- "$@"; echo $1`

257

258

# If $tagname isn't set, then try to infer if the default "CC" tag applies

259

if test -z "$tagname"; then

260

for zp in $tag_compilers_CC; do

261

case $base_compiler in

262

$zp) tagname="CC"; break;;

263

esac

264

done

265

fi

266

267

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

268

CC_quoted=

269

for arg in $CC; do

270

case $arg in

271

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

272

arg="\"$arg\""

273

;;

274

esac

275

CC_quoted="$CC_quoted $arg"

276

done

277

case $@ in

278

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

279

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

280

281

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

282

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

283

*)

284

for z in $available_tags; do

285

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

286

# Evaluate the configuration.

287

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

288

CC_quoted=

289

for arg in $CC; do

290

# Double-quote args containing other shell metacharacters.

291

case $arg in

292

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

293

arg="\"$arg\""

294

;;

295

esac

296

CC_quoted="$CC_quoted $arg"

297

done

298

case "$@ " in

299

300

# The compiler in the base compile command matches

301

# the one in the tagged configuration.

302

# Assume this is the tagged configuration we want.

303

tagname=$z

304

break

305

;;

306

esac

307

308

# FreeBSD-specific: try compilers based on inferred tag

309

if test -z "$tagname"; then

310

eval "tag_compilers=\$tag_compilers_${z}"

311

if test -n "$tag_compilers"; then

312

for zp in $tag_compilers; do

313

case $base_compiler in

314

$zp) tagname=$z; break;;

315

esac

316

done

317

if test -n "$tagname"; then

318

break

319

fi

320

fi

321

fi

322

fi

323

done

324

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

325

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

326

# line option must be used.

327

if test -z "$tagname"; then

328

$echo "$modename: unable to infer tagged configuration"

329

$echo "$modename: specify a tag with \`--tag'" 1>&2

330

exit $EXIT_FAILURE

331

# else

332

# $echo "$modename: using $tagname tagged configuration"

333

fi

334

;;

335

esac

336

fi

337

}

338

339

340

# func_extract_an_archive dir oldlib

341

func_extract_an_archive ()

342

{

343

f_ex_an_ar_dir="$1"; shift

344

f_ex_an_ar_oldlib="$1"

345

346

$show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"

347

$run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?

348

if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

349

:

350

else

351

$echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2

352

exit $EXIT_FAILURE

353

fi

354

}

355

356

# func_extract_archives gentop oldlib ...

357

func_extract_archives ()

358

{

359

my_gentop="$1"; shift

360

my_oldlibs=${1+"$@"}

361

my_oldobjs=""

362

my_xlib=""

363

my_xabs=""

364

my_xdir=""

365

my_status=""

366

367

$show "${rm}r $my_gentop"

368

$run ${rm}r "$my_gentop"

369

$show "$mkdir $my_gentop"

370

$run $mkdir "$my_gentop"

371

my_status=$?

372

if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then

373

exit $my_status

374

fi

375

376

for my_xlib in $my_oldlibs; do

377

# Extract the objects.

378

case $my_xlib in

379

[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;

380

*) my_xabs=`pwd`"/$my_xlib" ;;

381

esac

382

my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`

383

my_xlib_u=$my_xlib

384

while :; do

385

case " $extracted_archives " in

386

*" $my_xlib_u "*)

387

extracted_serial=`expr $extracted_serial + 1`

388

my_xlib_u=lt$extracted_serial-$my_xlib ;;

389

*) break ;;

390

esac

391

done

392

extracted_archives="$extracted_archives $my_xlib_u"

393

my_xdir="$my_gentop/$my_xlib_u"

394

395

$show "${rm}r $my_xdir"

396

$run ${rm}r "$my_xdir"

397

$show "$mkdir $my_xdir"

398

$run $mkdir "$my_xdir"

399

exit_status=$?

400

if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then

401

exit $exit_status

402

fi

403

case $host in

404

*-darwin*)

405

$show "Extracting $my_xabs"

406

# Do not bother doing anything if just a dry run

407

if test -z "$run"; then

408

darwin_orig_dir=`pwd`

409

cd $my_xdir || exit $?

410

darwin_archive=$my_xabs

411

darwin_curdir=`pwd`

412

darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`

413

darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`

414

if test -n "$darwin_arches"; then

415

darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`

416

darwin_arch=

417

$show "$darwin_base_archive has multiple architectures $darwin_arches"

418

for darwin_arch in $darwin_arches ; do

419

mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

420

lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

421

cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

422

func_extract_an_archive "`pwd`" "${darwin_base_archive}"

423

cd "$darwin_curdir"

424

$rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"

425

done # $darwin_arches

426

## Okay now we have a bunch of thin objects, gotta fatten them up :)

427

darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`

428

darwin_file=

429

darwin_files=

430

for darwin_file in $darwin_filelist; do

431

darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`

432

lipo -create -output "$darwin_file" $darwin_files

433

done # $darwin_filelist

434

${rm}r unfat-$$

435

cd "$darwin_orig_dir"

436

else

437

cd "$darwin_orig_dir"

438

func_extract_an_archive "$my_xdir" "$my_xabs"

439

fi # $darwin_arches

440

fi # $run

441

;;

442

*)

443

func_extract_an_archive "$my_xdir" "$my_xabs"

444

;;

445

esac

446

my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`

447

done

448

func_extract_archives_result="$my_oldobjs"

449

}

450

# End of Shell function definitions

451

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

452

453

# Darwin sucks

454

eval std_shrext=\"$shrext_cmds\"

455

456

disable_libs=no

457

458

# Parse our command line options once, thoroughly.

459

while test "$#" -gt 0

460

do

461

arg="$1"

462

shift

463

464

case $arg in

465

-*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;

466

*) optarg= ;;

467

esac

468

469

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

470

if test -n "$prev"; then

471

case $prev in

472

execute_dlfiles)

473

execute_dlfiles="$execute_dlfiles $arg"

474

;;

475

tag)

476

tagname="$arg"

477

preserve_args="${preserve_args}=$arg"

478

479

# Check whether tagname contains only valid characters

480

case $tagname in

481

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

482

$echo "$progname: invalid tag name: $tagname" 1>&2

483

exit $EXIT_FAILURE

484

;;

485

esac

486

487

case $tagname in

488

CC)

489

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

490

# not specially marked.

491

;;

492

*)

493

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

494

taglist="$taglist $tagname"

495

# Evaluate the configuration.

496

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

497

else

498

$echo "$progname: ignoring unknown tag $tagname" 1>&2

499

fi

500

;;

501

esac

502

;;

503

*)

504

eval "$prev=\$arg"

505

;;

506

esac

507

508

prev=

509

prevopt=

510

continue

511

fi

512

513

# Have we seen a non-optional argument yet?

514

case $arg in

515

--help)

516

show_help=yes

517

;;

518

519

--version)

520

echo "\

521

$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP

522

523

524

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

525

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

526

exit $?

527

;;

528

529

--config)

530

${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath

531

# Now print the configurations for the tags.

532

for tagname in $taglist; do

533

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

534

done

535

exit $?

536

;;

537

538

--debug)

539

$echo "$progname: enabling shell trace mode"

540

set -x

541

preserve_args="$preserve_args $arg"

542

;;

543

544

--dry-run | -n)

545

run=:

546

;;

547

548

--features)

549

$echo "host: $host"

550

if test "$build_libtool_libs" = yes; then

551

$echo "enable shared libraries"

552

else

553

$echo "disable shared libraries"

554

fi

555

if test "$build_old_libs" = yes; then

556

$echo "enable static libraries"

557

else

558

$echo "disable static libraries"

559

fi

560

exit $?

561

;;

562

563

--finish) mode="finish" ;;

564

565

--mode) prevopt="--mode" prev=mode ;;

566

--mode=*) mode="$optarg" ;;

567

568

--preserve-dup-deps) duplicate_deps="yes" ;;

569

570

--quiet | --silent)

571

show=:

572

preserve_args="$preserve_args $arg"

573

;;

574

575

--tag)

576

prevopt="--tag"

577

prev=tag

578

preserve_args="$preserve_args --tag"

579

;;

580

--tag=*)

581

set tag "$optarg" ${1+"$@"}

582

shift

583

prev=tag

584

preserve_args="$preserve_args --tag"

585

;;

586

587

-dlopen)

588

prevopt="-dlopen"

589

prev=execute_dlfiles

590

;;

591

592

-*)

593

$echo "$modename: unrecognized option \`$arg'" 1>&2

594

$echo "$help" 1>&2

595

exit $EXIT_FAILURE

596

;;

597

598

*)

599

nonopt="$arg"

600

break

601

;;

602

esac

603

done

604

605

if test -n "$prevopt"; then

606

$echo "$modename: option \`$prevopt' requires an argument" 1>&2

607

$echo "$help" 1>&2

608

exit $EXIT_FAILURE

609

fi

610

611

case $disable_libs in

612

no)

613

;;

614

shared)

615

build_libtool_libs=no

616

build_old_libs=yes

617

;;

618

static)

619

build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

620

;;

621

esac

622

623

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

624

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

625

# left over by shells.

626

exec_cmd=

627

628

if test -z "$show_help"; then

629

630

# Infer the operation mode.

631

if test -z "$mode"; then

632

$echo "*** Warning: inferring the mode of operation is deprecated." 1>&2

633

$echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2

634

case $nonopt in

635

*cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)

636

mode=link

637

for arg

638

do

639

case $arg in

640

-c)

641

mode=compile

642

break

643

;;

644

esac

645

done

646

;;

647

*db | *dbx | *strace | *truss)

648

mode=execute

649

;;

650

*install*|cp|mv)

651

mode=install

652

;;

653

*rm)

654

mode=uninstall

655

;;

656

*)

657

# If we have no mode, but dlfiles were specified, then do execute mode.

658

test -n "$execute_dlfiles" && mode=execute

659

660

# Just use the default operation mode.

661

if test -z "$mode"; then

662

if test -n "$nonopt"; then

663

$echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2

664

else

665

$echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2

666

fi

667

fi

668

;;

669

esac

670

fi

671

672

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

673

if test -n "$execute_dlfiles" && test "$mode" != execute; then

674

$echo "$modename: unrecognized option \`-dlopen'" 1>&2

675

$echo "$help" 1>&2

676

exit $EXIT_FAILURE

677

fi

678

679

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

680

generic_help="$help"

681

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

682

683

# These modes are in order of execution frequency so that they run quickly.

684

case $mode in

685

# libtool compile mode

686

compile)

687

modename="$modename: compile"

688

# Get the compilation command and the source file.

689

base_compile=

690

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

691

suppress_opt=yes

692

suppress_output=

693

arg_mode=normal

694

libobj=

695

later=

696

697

for arg

698

do

699

case $arg_mode in

700

arg )

701

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

702

lastarg="$arg"

703

arg_mode=normal

704

;;

705

706

target )

707

libobj="$arg"

708

arg_mode=normal

709

continue

710

;;

711

712

normal )

713

# Accept any command-line options.

714

case $arg in

715

-o)

716

if test -n "$libobj" ; then

717

$echo "$modename: you cannot specify \`-o' more than once" 1>&2

718

exit $EXIT_FAILURE

719

fi

720

arg_mode=target

721

continue

722

;;

723

724

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

725

later="$later $arg"

726

continue

727

;;

728

729

-no-suppress)

730

suppress_opt=no

731

continue

732

;;

733

734

-Xcompiler)

735

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

736

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

737

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

738

739

-Wc,*)

740

args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`

741

lastarg=

742

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

743

for arg in $args; do

744

IFS="$save_ifs"

745

746

# Double-quote args containing other shell metacharacters.

747

# Many Bourne shells cannot handle close brackets correctly

748

# in scan sets, so we specify it separately.

749

case $arg in

750

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

751

arg="\"$arg\""

752

;;

753

esac

754

lastarg="$lastarg $arg"

755

done

756

IFS="$save_ifs"

757

lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`

758

759

# Add the arguments to base_compile.

760

base_compile="$base_compile $lastarg"

761

continue

762

;;

763

764

* )

765

# Accept the current argument as the source file.

766

# The previous "srcfile" becomes the current argument.

767

#

768

lastarg="$srcfile"

769

srcfile="$arg"

770

;;

771

esac # case $arg

772

;;

773

esac # case $arg_mode

774

775

# Aesthetically quote the previous argument.

776

lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`

777

778

case $lastarg in

779

# Double-quote args containing other shell metacharacters.

780

# Many Bourne shells cannot handle close brackets correctly

781

# in scan sets, and some SunOS ksh mistreat backslash-escaping

782

# in scan sets (worked around with variable expansion),

783

# and furthermore cannot handle '|' '&' '(' ')' in scan sets

784

# at all, so we specify them separately.

785

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

786

lastarg="\"$lastarg\""

787

;;

788

esac

789

790

base_compile="$base_compile $lastarg"

791

done # for arg

792

793

case $arg_mode in

794

arg)

795

$echo "$modename: you must specify an argument for -Xcompile"

796

exit $EXIT_FAILURE

797

;;

798

target)

799

$echo "$modename: you must specify a target with \`-o'" 1>&2

800

exit $EXIT_FAILURE

801

;;

802

*)

803

# Get the name of the library object.

804

[ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`

805

;;

806

esac

807

808

# Recognize several different file suffixes.

809

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

810

xform='[cCFSifmso]'

811

case $libobj in

812

*.ada) xform=ada ;;

813

*.adb) xform=adb ;;

814

*.ads) xform=ads ;;

815

*.asm) xform=asm ;;

816

*.c++) xform=c++ ;;

817

*.cc) xform=cc ;;

818

*.ii) xform=ii ;;

819

*.class) xform=class ;;

820

*.cpp) xform=cpp ;;

821

*.cxx) xform=cxx ;;

822

*.[fF][09]?) xform=[fF][09]. ;;

823

*.for) xform=for ;;

824

*.java) xform=java ;;

825

*.obj) xform=obj ;;

826

*.sx) xform=sx ;;

827

esac

828

829

libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`

830

831

case $libobj in

832

*.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;

833

*)

834

$echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2

835

exit $EXIT_FAILURE

836

;;

837

esac

838

839

func_infer_tag $base_compile

840

841

for arg in $later; do

842

case $arg in

843

-static)

844

build_old_libs=yes

845

continue

846

;;

847

848

-prefer-pic)

849

pic_mode=yes

850

continue

851

;;

852

853

-prefer-non-pic)

854

pic_mode=no

855

continue

856

;;

857

esac

858

done

859

860

qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`

861

case $qlibobj in

862

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

863

qlibobj="\"$qlibobj\"" ;;

864

esac

865

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

866

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

867

&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."

868

objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`

869

xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`

870

if test "X$xdir" = "X$obj"; then

871

xdir=

872

else

873

xdir=$xdir/

874

fi

875

lobj=${xdir}$objdir/$objname

876

877

if test -z "$base_compile"; then

878

$echo "$modename: you must specify a compilation command" 1>&2

879

$echo "$help" 1>&2

880

exit $EXIT_FAILURE

881

fi

882

883

# Delete any leftover library objects.

884

if test "$build_old_libs" = yes; then

885

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

886

else

887

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

888

fi

889

890

$run $rm $removelist

891

trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15

892

893

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

894

case $host_os in

895

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

896

pic_mode=default

897

;;

898

esac

899

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

900

# non-PIC code in shared libraries is not supported

901

pic_mode=default

902

fi

903

904

# Calculate the filename of the output object if compiler does

905

# not support -o with -c

906

if test "$compiler_c_o" = no; then

907

output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}

908

lockfile="$output_obj.lock"

909

removelist="$removelist $output_obj $lockfile"

910

trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15

911

else

912

output_obj=

913

need_locks=no

914

lockfile=

915

fi

916

917

# Lock this critical section if it is needed

918

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

919

if test "$need_locks" = yes; then

920

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

921

$show "Waiting for $lockfile to be removed"

922

sleep 2

923

done

924

elif test "$need_locks" = warn; then

925

if test -f "$lockfile"; then

926

$echo "\

927

*** ERROR, $lockfile exists and contains:

928

`cat $lockfile 2>/dev/null`

929

930

This indicates that another process is trying to use the same

931

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

932

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

933

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

934

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

935

compiler."

936

937

$run $rm $removelist

938

exit $EXIT_FAILURE

939

fi

940

$echo "$srcfile" > "$lockfile"

941

fi

942

943

if test -n "$fix_srcfile_path"; then

944

eval srcfile=\"$fix_srcfile_path\"

945

fi

946

qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`

947

case $qsrcfile in

948

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

949

qsrcfile="\"$qsrcfile\"" ;;

950

esac

951

952

$run $rm "$libobj" "${libobj}T"

953

954

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

955

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

956

test -z "$run" && cat > ${libobj}T <<EOF

957

# $libobj - a libtool object file

958

# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

959

#

960

# Please DO NOT delete this file!

961

# It is necessary for linking the library.

962

963

# Name of the PIC object.

964

EOF

965

966

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

967

if test "$build_libtool_libs" = yes; then

968

# Without this assignment, base_compile gets emptied.

969

fbsd_hideous_sh_bug=$base_compile

970

971

if test "$pic_mode" != no; then

972

command="$base_compile $qsrcfile $pic_flag"

973

else

974

# Don't build PIC code

975

command="$base_compile $qsrcfile"

976

fi

977

978

if test ! -d "${xdir}$objdir"; then

979

$show "$mkdir ${xdir}$objdir"

980

$run $mkdir ${xdir}$objdir

981

exit_status=$?

982

if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then

983

exit $exit_status

984

fi

985

fi

986

987

if test -z "$output_obj"; then

988

# Place PIC objects in $objdir

989

command="$command -o $lobj"

990

fi

991

992

$run $rm "$lobj" "$output_obj"

993

994

$show "$command"

995

if $run eval $lt_env "$command"; then :

996

else

997

test -n "$output_obj" && $run $rm $removelist

998

exit $EXIT_FAILURE

999

fi

1000

1001

if test "$need_locks" = warn &&

1002

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

1003

$echo "\

1004

*** ERROR, $lockfile contains:

1005

`cat $lockfile 2>/dev/null`

1006

1007

but it should contain:

1008

$srcfile

1009

1010

This indicates that another process is trying to use the same

1011

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

1012

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

1013

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

1014

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

1015

compiler."

1016

1017

$run $rm $removelist

1018

exit $EXIT_FAILURE

1019

fi

1020

1021

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

1022

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

1023

$show "$mv $output_obj $lobj"

1024

if $run $mv $output_obj $lobj; then :

1025

else

1026

error=$?

1027

$run $rm $removelist

1028

exit $error

1029

fi

1030

fi

1031

1032

# Append the name of the PIC object to the libtool object file.

1033

test -z "$run" && cat >> ${libobj}T <<EOF

1034

pic_object='$objdir/$objname'

1035

1036

EOF

1037

1038

# Allow error messages only from the first compilation.

1039

if test "$suppress_opt" = yes; then

1040

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

1041

fi

1042

else

1043

# No PIC object so indicate it doesn't exist in the libtool

1044

# object file.

1045

test -z "$run" && cat >> ${libobj}T <<EOF

1046

pic_object=none

1047

1048

EOF

1049

fi

1050

1051

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

1052

if test "$build_old_libs" = yes; then

1053

if test "$pic_mode" != yes; then

1054

# Don't build PIC code

1055

command="$base_compile $qsrcfile"

1056

else

1057

command="$base_compile $qsrcfile $pic_flag"

1058

fi

1059

if test "$compiler_c_o" = yes; then

1060

command="$command -o $obj"

1061

fi

1062

1063

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

1064

command="$command$suppress_output"

1065

$run $rm "$obj" "$output_obj"

1066

$show "$command"

1067

if $run eval $lt_env "$command"; then :

1068

else

1069

$run $rm $removelist

1070

exit $EXIT_FAILURE

1071

fi

1072

1073

if test "$need_locks" = warn &&

1074

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

1075

$echo "\

1076

*** ERROR, $lockfile contains:

1077

`cat $lockfile 2>/dev/null`

1078

1079

but it should contain:

1080

$srcfile

1081

1082

This indicates that another process is trying to use the same

1083

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

1084

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

1085

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

1086

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

1087

compiler."

1088

1089

$run $rm $removelist

1090

exit $EXIT_FAILURE

1091

fi

1092

1093

# Just move the object if needed

1094

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

1095

$show "$mv $output_obj $obj"

1096

if $run $mv $output_obj $obj; then :

1097

else

1098

error=$?

1099

$run $rm $removelist

1100

exit $error

1101

fi

1102

fi

1103

1104

# Append the name of the non-PIC object the libtool object file.

1105

# Only append if the libtool object file exists.

1106

test -z "$run" && cat >> ${libobj}T <<EOF

1107

# Name of the non-PIC object.

1108

non_pic_object='$objname'

1109

1110

EOF

1111

else

1112

# Append the name of the non-PIC object the libtool object file.

1113

# Only append if the libtool object file exists.

1114

test -z "$run" && cat >> ${libobj}T <<EOF

1115

# Name of the non-PIC object.

1116

non_pic_object=none

1117

1118

EOF

1119

fi

1120

1121

$run $mv "${libobj}T" "${libobj}"

1122

1123

# Unlock the critical section if it was locked

1124

if test "$need_locks" != no; then

1125

$run $rm "$lockfile"

1126

fi

1127

1128

exit $EXIT_SUCCESS

1129

;;

1130

1131

# libtool link mode

1132

link | relink)

1133

modename="$modename: link"

1134

case $host in

1135

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

1136

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

1137

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

1138

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

1139

# flag for every libtool invocation.

1140

# allow_undefined=no

1141

1142

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

1143

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

1144

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

1145

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

1146

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

1147

allow_undefined=yes

1148

;;

1149

*)

1150

allow_undefined=yes

1151

;;

1152

esac

1153

libtool_args="$nonopt"

1154

base_compile="$nonopt $@"

1155

compile_command="$nonopt"

1156

finalize_command="$nonopt"

1157

1158

compile_rpath=

1159

finalize_rpath=

1160

compile_shlibpath=

1161

finalize_shlibpath=

1162

convenience=

1163

old_convenience=

1164

deplibs=

1165

old_deplibs=

1166

compiler_flags=

1167

linker_flags=

1168

dllsearchpath=

1169

lib_search_path=`pwd`

1170

inst_prefix_dir=

1171

1172

avoid_version=no

1173

dlfiles=

1174

dlprefiles=

1175

dlself=no

1176

export_dynamic=no

1177

export_symbols=

1178

export_symbols_regex=

1179

generated=

1180

libobjs=

1181

ltlibs=

1182

module=no

1183

no_install=no

1184

objs=

1185

non_pic_objects=

1186

notinst_path= # paths that contain not-installed libtool libraries

1187

precious_files_regex=

1188

prefer_static_libs=no

1189

preload=no

1190

prev=

1191

prevarg=

1192

release=

1193

rpath=

1194

xrpath=

1195

perm_rpath=

1196

temp_rpath=

1197

thread_safe=no

1198

vinfo=

1199

vinfo_number=no

1200

single_module="${wl}-single_module"

1201

1202

func_infer_tag $base_compile

1203

1204

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

1205

for arg

1206

do

1207

case $arg in

1208

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

1209

case $arg in

1210

-all-static)

1211

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

1212

$echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2

1213

fi

1214

if test -n "$link_static_flag"; then

1215

dlopen_self=$dlopen_self_static

1216

fi

1217

prefer_static_libs=yes

1218

;;

1219

-static)

1220

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

1221

dlopen_self=$dlopen_self_static

1222

fi

1223

prefer_static_libs=built

1224

;;

1225

-static-libtool-libs)

1226

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

1227

dlopen_self=$dlopen_self_static

1228

fi

1229

prefer_static_libs=yes

1230

;;

1231

esac

1232

build_libtool_libs=no

1233

build_old_libs=yes

1234

break

1235

;;

1236

esac

1237

done

1238

1239

# See if our shared archives depend on static archives.

1240

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

1241

1242

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

1243

while test "$#" -gt 0; do

1244

arg="$1"

1245

shift

1246

case $arg in

1247

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

1248

qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test

1249

;;

1250

*) qarg=$arg ;;

1251

esac

1252

libtool_args="$libtool_args $qarg"

1253

1254

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

1255

if test -n "$prev"; then

1256

case $prev in

1257

output)

1258

compile_command="$compile_command @OUTPUT@"

1259

finalize_command="$finalize_command @OUTPUT@"

1260

;;

1261

esac

1262

1263

case $prev in

1264

dlfiles|dlprefiles)

1265

if test "$preload" = no; then

1266

# Add the symbol object into the linking commands.

1267

compile_command="$compile_command @SYMFILE@"

1268

finalize_command="$finalize_command @SYMFILE@"

1269

preload=yes

1270

fi

1271

case $arg in

1272

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

1273

force)

1274

if test "$dlself" = no; then

1275

dlself=needless

1276

export_dynamic=yes

1277

fi

1278

prev=

1279

continue

1280

;;

1281

self)

1282

if test "$prev" = dlprefiles; then

1283

dlself=yes

1284

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

1285

dlself=yes

1286

else

1287

dlself=needless

1288

export_dynamic=yes

1289

fi

1290

prev=

1291

continue

1292

;;

1293

*)

1294

if test "$prev" = dlfiles; then

1295

dlfiles="$dlfiles $arg"

1296

else

1297

dlprefiles="$dlprefiles $arg"

1298

fi

1299

prev=

1300

continue

1301

;;

1302

esac

1303

;;

1304

expsyms)

1305

export_symbols="$arg"

1306

if test ! -f "$arg"; then

1307

$echo "$modename: symbol file \`$arg' does not exist"

1308

exit $EXIT_FAILURE

1309

fi

1310

prev=

1311

continue

1312

;;

1313

expsyms_regex)

1314

export_symbols_regex="$arg"

1315

prev=

1316

continue

1317

;;

1318

inst_prefix)

1319

inst_prefix_dir="$arg"

1320

prev=

1321

continue

1322

;;

1323

precious_regex)

1324

precious_files_regex="$arg"

1325

prev=

1326

continue

1327

;;

1328

release)

1329

release="-$arg"

1330

prev=

1331

continue

1332

;;

1333

objectlist)

1334

if test -f "$arg"; then

1335

save_arg=$arg

1336

moreargs=

1337

for fil in `cat $save_arg`

1338

do

1339

# moreargs="$moreargs $fil"

1340

arg=$fil

1341

# A libtool-controlled object.

1342

1343

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

1344

if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

1345

pic_object=

1346

non_pic_object=

1347

1348

# Read the .lo file

1349

# If there is no directory component, then add one.

1350

case $arg in

1351

*/* | *\\*) . $arg ;;

1352

*) . ./$arg ;;

1353

esac

1354

1355

if test -z "$pic_object" || \

1356

test -z "$non_pic_object" ||

1357

test "$pic_object" = none && \

1358

test "$non_pic_object" = none; then

1359

$echo "$modename: cannot find name of object for \`$arg'" 1>&2

1360

exit $EXIT_FAILURE

1361

fi

1362

1363

# Extract subdirectory from the argument.

1364

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

1365

if test "X$xdir" = "X$arg"; then

1366

xdir=

1367

else

1368

xdir="$xdir/"

1369

fi

1370

1371

if test "$pic_object" != none; then

1372

# Prepend the subdirectory the object is found in.

1373

pic_object="$xdir$pic_object"

1374

1375

if test "$prev" = dlfiles; then

1376

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

1377

dlfiles="$dlfiles $pic_object"

1378

prev=

1379

continue

1380

else

1381

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

1382

prev=dlprefiles

1383

fi

1384

fi

1385

1386

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

1387

if test "$prev" = dlprefiles; then

1388

# Preload the old-style object.

1389

dlprefiles="$dlprefiles $pic_object"

1390

prev=

1391

fi

1392

1393

# A PIC object.

1394

libobjs="$libobjs $pic_object"

1395

arg="$pic_object"

1396

fi

1397

1398

# Non-PIC object.

1399

if test "$non_pic_object" != none; then

1400

# Prepend the subdirectory the object is found in.

1401

non_pic_object="$xdir$non_pic_object"

1402

1403

# A standard non-PIC object

1404

non_pic_objects="$non_pic_objects $non_pic_object"

1405

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

1406

arg="$non_pic_object"

1407

fi

1408

else

1409

# If the PIC object exists, use it instead.

1410

# $xdir was prepended to $pic_object above.

1411

non_pic_object="$pic_object"

1412

non_pic_objects="$non_pic_objects $non_pic_object"

1413

fi

1414

else

1415

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

1416

if test -z "$run"; then

1417

$echo "$modename: \`$arg' is not a valid libtool object" 1>&2

1418

exit $EXIT_FAILURE

1419

else

1420

# Dry-run case.

1421

1422

# Extract subdirectory from the argument.

1423

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

1424

if test "X$xdir" = "X$arg"; then

1425

xdir=

1426

else

1427

xdir="$xdir/"

1428

fi

1429

1430

pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`

1431

non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`

1432

libobjs="$libobjs $pic_object"

1433

non_pic_objects="$non_pic_objects $non_pic_object"

1434

fi

1435

fi

1436

done

1437

else

1438

$echo "$modename: link input file \`$save_arg' does not exist"

1439

exit $EXIT_FAILURE

1440

fi

1441

arg=$save_arg

1442

prev=

1443

continue

1444

;;

1445

rpath | xrpath)

1446

# We need an absolute path.

1447

case $arg in

1448

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

1449

*)

1450

$echo "$modename: only absolute run-paths are allowed" 1>&2

1451

exit $EXIT_FAILURE

1452

;;

1453

esac

1454

if test "$prev" = rpath; then

1455

case "$rpath " in

1456

*" $arg "*) ;;

1457

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

1458

esac

1459

else

1460

case "$xrpath " in

1461

*" $arg "*) ;;

1462

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

1463

esac

1464

fi

1465

prev=

1466

continue

1467

;;

1468

xcompiler)

1469

compiler_flags="$compiler_flags $qarg"

1470

prev=

1471

compile_command="$compile_command $qarg"

1472

finalize_command="$finalize_command $qarg"

1473

continue

1474

;;

1475

xlinker)

1476

linker_flags="$linker_flags $qarg"

1477

compiler_flags="$compiler_flags $wl$qarg"

1478

prev=

1479

compile_command="$compile_command $wl$qarg"

1480

finalize_command="$finalize_command $wl$qarg"

1481

continue

1482

;;

1483

xcclinker)

1484

linker_flags="$linker_flags $qarg"

1485

compiler_flags="$compiler_flags $qarg"

1486

prev=

1487

compile_command="$compile_command $qarg"

1488

finalize_command="$finalize_command $qarg"

1489

continue

1490

;;

1491

shrext)

1492

shrext_cmds="$arg"

1493

prev=

1494

continue

1495

;;

1496

darwin_framework|darwin_framework_skip)

1497

test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"

1498

compile_command="$compile_command $arg"

1499

finalize_command="$finalize_command $arg"

1500

prev=

1501

continue

1502

;;

1503

*)

1504

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

1505

prev=

1506

continue

1507

;;

1508

esac

1509

fi # test -n "$prev"

1510

1511

prevarg="$arg"

1512

1513

case $arg in

1514

-all-static)

1515

if test -n "$link_static_flag"; then

1516

compile_command="$compile_command $link_static_flag"

1517

finalize_command="$finalize_command $link_static_flag"

1518

fi

1519

continue

1520

;;

1521

1522

-allow-undefined)

1523

# FIXME: remove this flag sometime in the future.

1524

$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2

1525

continue

1526

;;

1527

1528

-avoid-version)

1529

avoid_version=yes

1530

continue

1531

;;

1532

1533

-dlopen)

1534

prev=dlfiles

1535

continue

1536

;;

1537

1538

-dlpreopen)

1539

prev=dlprefiles

1540

continue

1541

;;

1542

1543

-export-dynamic)

1544

export_dynamic=yes

1545

continue

1546

;;

1547

1548

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

1549

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

1550

$echo "$modename: more than one -exported-symbols argument is not allowed"

1551

exit $EXIT_FAILURE

1552

fi

1553

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

1554

prev=expsyms

1555

else

1556

prev=expsyms_regex

1557

fi

1558

continue

1559

;;

1560

1561

-framework|-arch|-isysroot)

1562

case " $CC " in

1563

*" ${arg} ${1} "* | *" ${arg} ${1} "*)

1564

prev=darwin_framework_skip ;;

1565

*) compiler_flags="$compiler_flags $arg"

1566

prev=darwin_framework ;;

1567

esac

1568

compile_command="$compile_command $arg"

1569

finalize_command="$finalize_command $arg"

1570

continue

1571

;;

1572

1573

-inst-prefix-dir)

1574

prev=inst_prefix

1575

continue

1576

;;

1577

1578

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

1579

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

1580

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

1581

case $with_gcc/$host in

1582

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

1583

compile_command="$compile_command $arg"

1584

finalize_command="$finalize_command $arg"

1585

;;

1586

esac

1587

continue

1588

;;

1589

1590

-L*)

1591

dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`

1592

# We need an absolute path.

1593

case $dir in

1594

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

1595

*)

1596

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

1597

if test -z "$absdir"; then

1598

$echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2

1599

absdir="$dir"

1600

notinst_path="$notinst_path $dir"

1601

fi

1602

dir="$absdir"

1603

;;

1604

esac

1605

case "$deplibs " in

1606

*" -L$dir "*) ;;

1607

*)

1608

deplibs="$deplibs -L$dir"

1609

lib_search_path="$lib_search_path $dir"

1610

;;

1611

esac

1612

case $host in

1613

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

1614

testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`

1615

case :$dllsearchpath: in

1616

*":$dir:"*) ;;

1617

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

1618

esac

1619

case :$dllsearchpath: in

1620

*":$testbindir:"*) ;;

1621

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

1622

esac

1623

;;

1624

esac

1625

continue

1626

;;

1627

1628

-l*)

1629

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

1630

case $host in

1631

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)

1632

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

1633

continue

1634

;;

1635

*-*-os2*)

1636

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

1637

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

1638

;;

1639

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

1640

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

1641

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

1642

;;

1643

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

1644

# Rhapsody C and math libraries are in the System framework

1645

deplibs="$deplibs -framework System"

1646

continue

1647

;;

1648

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

1649

# Causes problems with __ctype

1650

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

1651

;;

1652

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

1653

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

1654

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

1655

;;

1656

esac

1657

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

1658

case $host in

1659

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

1660

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

1661

continue

1662

;;

1663

esac

1664

fi

1665

deplibs="$deplibs $arg"

1666

continue

1667

;;

1668

1669

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

1670

# classes, name mangling, and exception handling.

1671

-model)

1672

compile_command="$compile_command $arg"

1673

compiler_flags="$compiler_flags $arg"

1674

finalize_command="$finalize_command $arg"

1675

prev=xcompiler

1676

continue

1677

;;

1678

1679

1680

compiler_flags="$compiler_flags $arg"

1681

compile_command="$compile_command $arg"

1682

finalize_command="$finalize_command $arg"

1683

deplibs="$deplibs $arg"

1684

continue

1685

;;

1686

1687

-multi_module)

1688

single_module="${wl}-multi_module"

1689

continue

1690

;;

1691

1692

-module)

1693

module=yes

1694

continue

1695

;;

1696

1697

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

1698

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

1699

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

1700

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

1701

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

1702

# -m* pass through architecture-specific compiler args for GCC

1703

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

1704

# compiler args for GCC

1705

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

1706

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

1707

# @file GCC response files

1708

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

1709

-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)

1710

1711

# Unknown arguments in both finalize_command and compile_command need

1712

# to be aesthetically quoted because they are evaled later.

1713

arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

1714

case $arg in

1715

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

1716

arg="\"$arg\""

1717

;;

1718

esac

1719

compile_command="$compile_command $arg"

1720

finalize_command="$finalize_command $arg"

1721

compiler_flags="$compiler_flags $arg"

1722

continue

1723

;;

1724

1725

-shrext)

1726

prev=shrext

1727

continue

1728

;;

1729

1730

-no-fast-install)

1731

fast_install=no

1732

continue

1733

;;

1734

1735

-no-install)

1736

case $host in

1737

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)

1738

# The PATH hackery in wrapper scripts is required on Windows

1739

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

1740

$echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2

1741

$echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2

1742

fast_install=no

1743

;;

1744

*) no_install=yes ;;

1745

esac

1746

continue

1747

;;

1748

1749

-no-undefined)

1750

allow_undefined=no

1751

continue

1752

;;

1753

1754

-objectlist)

1755

prev=objectlist

1756

continue

1757

;;

1758

1759

-o) prev=output ;;

1760

1761

-precious-files-regex)

1762

prev=precious_regex

1763

continue

1764

;;

1765

1766

-release)

1767

prev=release

1768

continue

1769

;;

1770

1771

-rpath)

1772

prev=rpath

1773

continue

1774

;;

1775

1776

-R)

1777

prev=xrpath

1778

continue

1779

;;

1780

1781

-R*)

1782

dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`

1783

# We need an absolute path.

1784

case $dir in

1785

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

1786

*)

1787

$echo "$modename: only absolute run-paths are allowed" 1>&2

1788

exit $EXIT_FAILURE

1789

;;

1790

esac

1791

case "$xrpath " in

1792

*" $dir "*) ;;

1793

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

1794

esac

1795

continue

1796

;;

1797

1798

-static | -static-libtool-libs)

1799

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

1800

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

1801

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

1802

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

1803

# Digital Unix and AIX.

1804

continue

1805

;;

1806

1807

-thread-safe)

1808

thread_safe=yes

1809

continue

1810

;;

1811

1812

-version-info)

1813

prev=vinfo

1814

continue

1815

;;

1816

-version-number)

1817

prev=vinfo

1818

vinfo_number=yes

1819

continue

1820

;;

1821

1822

-Wc,*)

1823

args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`

1824

arg=

1825

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

1826

for flag in $args; do

1827

IFS="$save_ifs"

1828

case $flag in

1829

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

1830

flag="\"$flag\""

1831

;;

1832

esac

1833

arg="$arg $wl$flag"

1834

compiler_flags="$compiler_flags $flag"

1835

done

1836

IFS="$save_ifs"

1837

arg=`$echo "X$arg" | $Xsed -e "s/^ //"`

1838

;;

1839

1840

-Wl,*)

1841

args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`

1842

arg=

1843

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

1844

for flag in $args; do

1845

IFS="$save_ifs"

1846

case $flag in

1847

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

1848

flag="\"$flag\""

1849

;;

1850

esac

1851

arg="$arg $wl$flag"

1852

compiler_flags="$compiler_flags $wl$flag"

1853

linker_flags="$linker_flags $flag"

1854

done

1855

IFS="$save_ifs"

1856

arg=`$echo "X$arg" | $Xsed -e "s/^ //"`

1857

;;

1858

1859

-Xcompiler)

1860

prev=xcompiler

1861

continue

1862

;;

1863

1864

-Xlinker)

1865

prev=xlinker

1866

continue

1867

;;

1868

1869

-XCClinker)

1870

prev=xcclinker

1871

continue

1872

;;

1873

1874

# Some other compiler flag.

1875

-* | +*)

1876

# Unknown arguments in both finalize_command and compile_command need

1877

# to be aesthetically quoted because they are evaled later.

1878

arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

1879

case $arg in

1880

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

1881

arg="\"$arg\""

1882

;;

1883

esac

1884

;;

1885

1886

*.$objext)

1887

# A standard object.

1888

objs="$objs $arg"

1889

;;

1890

1891

*.lo)

1892

# A libtool-controlled object.

1893

1894

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

1895

if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

1896

pic_object=

1897

non_pic_object=

1898

1899

# Read the .lo file

1900

# If there is no directory component, then add one.

1901

case $arg in

1902

*/* | *\\*) . $arg ;;

1903

*) . ./$arg ;;

1904

esac

1905

1906

if test -z "$pic_object" || \

1907

test -z "$non_pic_object" ||

1908

test "$pic_object" = none && \

1909

test "$non_pic_object" = none; then

1910

$echo "$modename: cannot find name of object for \`$arg'" 1>&2

1911

exit $EXIT_FAILURE

1912

fi

1913

1914

# Extract subdirectory from the argument.

1915

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

1916

if test "X$xdir" = "X$arg"; then

1917

xdir=

1918

else

1919

xdir="$xdir/"

1920

fi

1921

1922

if test "$pic_object" != none; then

1923

# Prepend the subdirectory the object is found in.

1924

pic_object="$xdir$pic_object"

1925

1926

if test "$prev" = dlfiles; then

1927

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

1928

dlfiles="$dlfiles $pic_object"

1929

prev=

1930

continue

1931

else

1932

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

1933

prev=dlprefiles

1934

fi

1935

fi

1936

1937

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

1938

if test "$prev" = dlprefiles; then

1939

# Preload the old-style object.

1940

dlprefiles="$dlprefiles $pic_object"

1941

prev=

1942

fi

1943

1944

# A PIC object.

1945

libobjs="$libobjs $pic_object"

1946

arg="$pic_object"

1947

fi

1948

1949

# Non-PIC object.

1950

if test "$non_pic_object" != none; then

1951

# Prepend the subdirectory the object is found in.

1952

non_pic_object="$xdir$non_pic_object"

1953

1954

# A standard non-PIC object

1955

non_pic_objects="$non_pic_objects $non_pic_object"

1956

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

1957

arg="$non_pic_object"

1958

fi

1959

else

1960

# If the PIC object exists, use it instead.

1961

# $xdir was prepended to $pic_object above.

1962

non_pic_object="$pic_object"

1963

non_pic_objects="$non_pic_objects $non_pic_object"

1964

fi

1965

else

1966

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

1967

if test -z "$run"; then

1968

$echo "$modename: \`$arg' is not a valid libtool object" 1>&2

1969

exit $EXIT_FAILURE

1970

else

1971

# Dry-run case.

1972

1973

# Extract subdirectory from the argument.

1974

xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

1975

if test "X$xdir" = "X$arg"; then

1976

xdir=

1977

else

1978

xdir="$xdir/"

1979

fi

1980

1981

pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`

1982

non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`

1983

libobjs="$libobjs $pic_object"

1984

non_pic_objects="$non_pic_objects $non_pic_object"

1985

fi

1986

fi

1987

;;

1988

1989

*.$libext)

1990

# An archive.

1991

deplibs="$deplibs $arg"

1992

old_deplibs="$old_deplibs $arg"

1993

continue

1994

;;

1995

1996

*.la)

1997

# A libtool-controlled library.

1998

1999

if test "$prev" = dlfiles; then

2000

# This library was specified with -dlopen.

2001

dlfiles="$dlfiles $arg"

2002

prev=

2003

elif test "$prev" = dlprefiles; then

2004

# The library was specified with -dlpreopen.

2005

dlprefiles="$dlprefiles $arg"

2006

prev=

2007

else

2008

deplibs="$deplibs $arg"

2009

fi

2010

continue

2011

;;

2012

2013

# Some other compiler argument.

2014

*)

2015

# Unknown arguments in both finalize_command and compile_command need

2016

# to be aesthetically quoted because they are evaled later.

2017

arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

2018

case $arg in

2019

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

2020

arg="\"$arg\""

2021

;;

2022

esac

2023

;;

2024

esac # arg

2025

2026

# Now actually substitute the argument into the commands.

2027

if test -n "$arg"; then

2028

compile_command="$compile_command $arg"

2029

finalize_command="$finalize_command $arg"

2030

fi

2031

done # argument parsing loop

2032

2033

if test -n "$prev"; then

2034

$echo "$modename: the \`$prevarg' option requires an argument" 1>&2

2035

$echo "$help" 1>&2

2036

exit $EXIT_FAILURE

2037

fi

2038

2039

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

2040

eval arg=\"$export_dynamic_flag_spec\"

2041

compile_command="$compile_command $arg"

2042

finalize_command="$finalize_command $arg"

2043

fi

2044

2045

oldlibs=

2046

# calculate the name of the file, without its directory

2047

outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`

2048

libobjs_save="$libobjs"

2049

2050

if test -n "$shlibpath_var"; then

2051

# get the directories listed in $shlibpath_var

2052

eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`

2053

else

2054

shlib_search_path=

2055

fi

2056

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

2057

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

2058

2059

output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`

2060

if test "X$output_objdir" = "X$output"; then

2061

output_objdir="$objdir"

2062

else

2063

output_objdir="$output_objdir/$objdir"

2064

fi

2065

# Create the object directory.

2066

if test ! -d "$output_objdir"; then

2067

$show "$mkdir $output_objdir"

2068

$run $mkdir $output_objdir

2069

exit_status=$?

2070

if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then

2071

exit $exit_status

2072

fi

2073

fi

2074

2075

# Determine the type of output

2076

case $output in

2077

"")

2078

$echo "$modename: you must specify an output file" 1>&2

2079

$echo "$help" 1>&2

2080

exit $EXIT_FAILURE

2081

;;

2082

*.$libext) linkmode=oldlib ;;

2083

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

2084

*.la) linkmode=lib ;;

2085

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

2086

esac

2087

2088

case $host in

2089

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

2090

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

2091

duplicate_compiler_generated_deps=yes

2092

;;

2093

*)

2094

duplicate_compiler_generated_deps=$duplicate_deps

2095

;;

2096

esac

2097

specialdeplibs=

2098

2099

libs=

2100

# Find all interdependent deplibs by searching for libraries

2101

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

2102

for deplib in $deplibs; do

2103

if test "X$duplicate_deps" = "Xyes" ; then

2104

case "$libs " in

2105

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

2106

esac

2107

fi

2108

libs="$libs $deplib"

2109

done

2110

2111

if test "$linkmode" = lib; then

2112

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

2113

2114

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

2115

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

2116

# not to be eliminated).

2117

pre_post_deps=

2118

if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then

2119

for pre_post_dep in $predeps $postdeps; do

2120

case "$pre_post_deps " in

2121

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

2122

esac

2123

pre_post_deps="$pre_post_deps $pre_post_dep"

2124

done

2125

fi

2126

pre_post_deps=

2127

fi

2128

2129

deplibs=

2130

newdependency_libs=

2131

newlib_search_path=

2132

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

2133

notinst_deplibs= # not-installed libtool libraries

2134

case $linkmode in

2135

lib)

2136

passes="conv link"

2137

for file in $dlfiles $dlprefiles; do

2138

case $file in

2139

*.la) ;;

2140

*)

2141

$echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2

2142

exit $EXIT_FAILURE

2143

;;

2144

esac

2145

done

2146

;;

2147

prog)

2148

compile_deplibs=

2149

finalize_deplibs=

2150

alldeplibs=no

2151

newdlfiles=

2152

newdlprefiles=

2153

passes="conv scan dlopen dlpreopen link"

2154

;;

2155

*) passes="conv"

2156

;;

2157

esac

2158

for pass in $passes; do

2159

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

2160

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

2161

libs="$deplibs"

2162

deplibs=

2163

fi

2164

if test "$linkmode" = prog; then

2165

case $pass in

2166

dlopen) libs="$dlfiles" ;;

2167

dlpreopen) libs="$dlprefiles" ;;

2168

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

2169

esac

2170

fi

2171

if test "$pass" = dlopen; then

2172

# Collect dlpreopened libraries

2173

save_deplibs="$deplibs"

2174

deplibs=

2175

fi

2176

for deplib in $libs; do

2177

lib=

2178

found=no

2179

case $deplib in

2180

2181

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

2182

compile_deplibs="$deplib $compile_deplibs"

2183

finalize_deplibs="$deplib $finalize_deplibs"

2184

else

2185

compiler_flags="$compiler_flags $deplib"

2186

fi

2187

2188

case $linkmode in

2189

lib)

2190

deplibs="$deplib $deplibs"

2191

test "$pass" = conv && continue

2192

newdependency_libs="$deplib $newdependency_libs"

2193

;;

2194

prog)

2195

if test "$pass" = conv; then

2196

deplibs="$deplib $deplibs"

2197

continue

2198

fi

2199

if test "$pass" = scan; then

2200

deplibs="$deplib $deplibs"

2201

else

2202

compile_deplibs="$deplib $compile_deplibs"

2203

finalize_deplibs="$deplib $finalize_deplibs"

2204

fi

2205

;;

2206

*)

2207

;;

2208

esac # linkmode

2209

2210

continue

2211

;;

2212

-l*)

2213

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

2214

$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2

2215

continue

2216

fi

2217

name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`

2218

if test "$linkmode" = lib; then

2219

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

2220

else

2221

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

2222

fi

2223

for searchdir in $searchdirs; do

2224

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

2225

# Search the libtool library

2226

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

2227

if test -f "$lib"; then

2228

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

2229

found=yes

2230

else

2231

found=no

2232

fi

2233

break 2

2234

fi

2235

done

2236

done

2237

if test "$found" != yes; then

2238

# deplib doesn't seem to be a libtool library

2239

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

2240

compile_deplibs="$deplib $compile_deplibs"

2241

finalize_deplibs="$deplib $finalize_deplibs"

2242

else

2243

deplibs="$deplib $deplibs"

2244

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

2245

fi

2246

continue

2247

else # deplib is a libtool library

2248

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

2249

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

2250

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

2251

case " $predeps $postdeps " in

2252

*" $deplib "*)

2253

if (${SED} -e '2q' $lib |

2254

grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

2255

library_names=

2256

old_library=

2257

case $lib in

2258

*/* | *\\*) . $lib ;;

2259

*) . ./$lib ;;

2260

esac

2261

for l in $old_library $library_names; do

2262

ll="$l"

2263

done

2264

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

2265

found=no

2266

ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`

2267

test "X$ladir" = "X$lib" && ladir="."

2268

lib=$ladir/$old_library

2269

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

2270

compile_deplibs="$deplib $compile_deplibs"

2271

finalize_deplibs="$deplib $finalize_deplibs"

2272

else

2273

deplibs="$deplib $deplibs"

2274

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

2275

fi

2276

continue

2277

fi

2278

fi

2279

;;

2280

*) ;;

2281

esac

2282

fi

2283

fi

2284

;; # -l

2285

-L*)

2286

case $linkmode in

2287

lib)

2288

deplibs="$deplib $deplibs"

2289

test "$pass" = conv && continue

2290

newdependency_libs="$deplib $newdependency_libs"

2291

newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

2292

;;

2293

prog)

2294

if test "$pass" = conv; then

2295

deplibs="$deplib $deplibs"

2296

continue

2297

fi

2298

if test "$pass" = scan; then

2299

deplibs="$deplib $deplibs"

2300

else

2301

compile_deplibs="$deplib $compile_deplibs"

2302

finalize_deplibs="$deplib $finalize_deplibs"

2303

fi

2304

newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`

2305

;;

2306

*)

2307

$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2

2308

;;

2309

esac # linkmode

2310

continue

2311

;; # -L

2312

-R*)

2313

if test "$pass" = link; then

2314

dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`

2315

# Make sure the xrpath contains only unique directories.

2316

case "$xrpath " in

2317

*" $dir "*) ;;

2318

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

2319

esac

2320

fi

2321

deplibs="$deplib $deplibs"

2322

continue

2323

;;

2324

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

2325

*.$libext)

2326

if test "$pass" = conv; then

2327

deplibs="$deplib $deplibs"

2328

continue

2329

fi

2330

case $linkmode in

2331

lib)

2332

valid_a_lib=no

2333

case $deplibs_check_method in

2334

match_pattern*)

2335

set dummy $deplibs_check_method

2336

match_pattern_regex=`expr "$deplibs_check_method" : "$2 $.*$"`

2337

if eval $echo \"$deplib\" 2>/dev/null \

2338

| $SED 10q \

2339

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

2340

valid_a_lib=yes

2341

fi

2342

;;

2343

pass_all)

2344

valid_a_lib=yes

2345

;;

2346

esac

2347

if test "$valid_a_lib" != yes; then

2348

$echo

2349

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

2350

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

2351

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

2352

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

2353

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

2354

$echo "*** that it is just a static archive that I should not used here."

2355

else

2356

$echo

2357

$echo "*** Warning: Linking the shared library $output against the"

2358

$echo "*** static library $deplib is not portable!"

2359

deplibs="$deplib $deplibs"

2360

fi

2361

continue

2362

;;

2363

prog)

2364

if test "$pass" != link; then

2365

deplibs="$deplib $deplibs"

2366

else

2367

compile_deplibs="$deplib $compile_deplibs"

2368

finalize_deplibs="$deplib $finalize_deplibs"

2369

fi

2370

continue

2371

;;

2372

esac # linkmode

2373

;; # *.$libext

2374

*.lo | *.$objext)

2375

if test "$pass" = conv; then

2376

deplibs="$deplib $deplibs"

2377

elif test "$linkmode" = prog; then

2378

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

2379

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

2380

# we need to preload.

2381

newdlprefiles="$newdlprefiles $deplib"

2382

compile_deplibs="$deplib $compile_deplibs"

2383

finalize_deplibs="$deplib $finalize_deplibs"

2384

else

2385

newdlfiles="$newdlfiles $deplib"

2386

fi

2387

fi

2388

continue

2389

;;

2390

%DEPLIBS%)

2391

alldeplibs=yes

2392

continue

2393

;;

2394

esac # case $deplib

2395

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

2396

else

2397

$echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2

2398

exit $EXIT_FAILURE

2399

fi

2400

2401

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

2402

if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

2403

else

2404

$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

2405

exit $EXIT_FAILURE

2406

fi

2407

2408

ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`

2409

test "X$ladir" = "X$lib" && ladir="."

2410

2411

dlname=

2412

dlopen=

2413

dlpreopen=

2414

libdir=

2415

library_names=

2416

old_library=

2417

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

2418

# it will not redefine variables installed, or shouldnotlink

2419

installed=yes

2420

shouldnotlink=no

2421

avoidtemprpath=

2422

2423

2424

# Read the .la file

2425

case $lib in

2426

*/* | *\\*) . $lib ;;

2427

*) . ./$lib ;;

2428

esac

2429

2430

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

2431

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

2432

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

2433

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

2434

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

2435

fi

2436

2437

if test "$pass" = conv; then

2438

# Only check for convenience libraries

2439

deplibs="$lib $deplibs"

2440

if test -z "$libdir"; then

2441

if test -z "$old_library"; then

2442

$echo "$modename: cannot find name of link library for \`$lib'" 1>&2

2443

exit $EXIT_FAILURE

2444

fi

2445

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

2446

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

2447

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

2448

tmp_libs=

2449

for deplib in $dependency_libs; do

2450

deplibs="$deplib $deplibs"

2451

if test "X$duplicate_deps" = "Xyes" ; then

2452

case "$tmp_libs " in

2453

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

2454

esac

2455

fi

2456

tmp_libs="$tmp_libs $deplib"

2457

done

2458

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

2459

$echo "$modename: \`$lib' is not a convenience library" 1>&2

2460

exit $EXIT_FAILURE

2461

fi

2462

continue

2463

fi # $pass = conv

2464

2465

2466

# Get the name of the library we link against.

2467

linklib=

2468

for l in $old_library $library_names; do

2469

linklib="$l"

2470

done

2471

if test -z "$linklib"; then

2472

$echo "$modename: cannot find name of link library for \`$lib'" 1>&2

2473

exit $EXIT_FAILURE

2474

fi

2475

2476

# This library was specified with -dlopen.

2477

if test "$pass" = dlopen; then

2478

if test -z "$libdir"; then

2479

$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2

2480

exit $EXIT_FAILURE

2481

fi

2482

if test -z "$dlname" ||

2483

test "$dlopen_support" != yes ||

2484

test "$build_libtool_libs" = no; then

2485

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

2486

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

2487

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

2488

# bomb out in the load deplibs phase.

2489

dlprefiles="$dlprefiles $lib $dependency_libs"

2490

else

2491

newdlfiles="$newdlfiles $lib"

2492

fi

2493

continue

2494

fi # $pass = dlopen

2495

2496

# We need an absolute path.

2497

case $ladir in

2498

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

2499

*)

2500

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

2501

if test -z "$abs_ladir"; then

2502

$echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2

2503

$echo "$modename: passing it literally to the linker, although it might fail" 1>&2

2504

abs_ladir="$ladir"

2505

fi

2506

;;

2507

esac

2508

laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

2509

2510

# Find the relevant object directory and library name.

2511

if test "X$installed" = Xyes; then

2512

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

2513

$echo "$modename: warning: library \`$lib' was moved." 1>&2

2514

dir="$ladir"

2515

absdir="$abs_ladir"

2516

libdir="$abs_ladir"

2517

else

2518

dir="$libdir"

2519

absdir="$libdir"

2520

fi

2521

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

2522

else

2523

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

2524

dir="$ladir"

2525

absdir="$abs_ladir"

2526

# Remove this search path later

2527

notinst_path="$notinst_path $abs_ladir"

2528

else

2529

dir="$ladir/$objdir"

2530

absdir="$abs_ladir/$objdir"

2531

# Remove this search path later

2532

notinst_path="$notinst_path $abs_ladir"

2533

fi

2534

fi # $installed = yes

2535

name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

2536

2537

# This library was specified with -dlpreopen.

2538

if test "$pass" = dlpreopen; then

2539

if test -z "$libdir"; then

2540

$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2

2541

exit $EXIT_FAILURE

2542

fi

2543

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

2544

# are required to link).

2545

if test -n "$old_library"; then

2546

newdlprefiles="$newdlprefiles $dir/$old_library"

2547

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

2548

elif test -n "$dlname"; then

2549

newdlprefiles="$newdlprefiles $dir/$dlname"

2550

else

2551

newdlprefiles="$newdlprefiles $dir/$linklib"

2552

fi

2553

fi # $pass = dlpreopen

2554

2555

if test -z "$libdir"; then

2556

# Link the convenience library

2557

if test "$linkmode" = lib; then

2558

deplibs="$dir/$old_library $deplibs"

2559

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

2560

compile_deplibs="$dir/$old_library $compile_deplibs"

2561

finalize_deplibs="$dir/$old_library $finalize_deplibs"

2562

else

2563

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

2564

fi

2565

continue

2566

fi

2567

2568

2569

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

2570

newlib_search_path="$newlib_search_path $ladir"

2571

deplibs="$lib $deplibs"

2572

2573

linkalldeplibs=no

2574

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

2575

test "$build_libtool_libs" = no; then

2576

linkalldeplibs=yes

2577

fi

2578

2579

tmp_libs=

2580

for deplib in $dependency_libs; do

2581

case $deplib in

2582

-L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test

2583

esac

2584

# Need to link against all dependency_libs?

2585

if test "$linkalldeplibs" = yes; then

2586

deplibs="$deplib $deplibs"

2587

else

2588

# Need to hardcode shared library paths

2589

# or/and link against static libraries

2590

newdependency_libs="$deplib $newdependency_libs"

2591

fi

2592

if test "X$duplicate_deps" = "Xyes" ; then

2593

case "$tmp_libs " in

2594

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

2595

esac

2596

fi

2597

tmp_libs="$tmp_libs $deplib"

2598

done # for deplib

2599

continue

2600

fi # $linkmode = prog...

2601

2602

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

2603

if test -n "$library_names" &&

2604

{ { test "$prefer_static_libs" = no ||

2605

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

2606

test -z "$old_library"; }; then

2607

# We need to hardcode the library path

2608

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

2609

# Make sure the rpath contains only unique directories.

2610

case "$temp_rpath " in

2611

*" $dir "*) ;;

2612

*" $absdir "*) ;;

2613

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

2614

esac

2615

fi

2616

2617

# Hardcode the library path.

2618

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

2619

# search path.

2620

case " $sys_lib_dlsearch_path " in

2621

*" $absdir "*) ;;

2622

*)

2623

case "$compile_rpath " in

2624

*" $absdir "*) ;;

2625

*) compile_rpath="$compile_rpath $absdir"

2626

esac

2627

;;

2628

esac

2629

case " $sys_lib_dlsearch_path " in

2630

*" $libdir "*) ;;

2631

*)

2632

case "$finalize_rpath " in

2633

*" $libdir "*) ;;

2634

*) finalize_rpath="$finalize_rpath $libdir"

2635

esac

2636

;;

2637

esac

2638

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

2639

2640

if test "$alldeplibs" = yes &&

2641

{ test "$deplibs_check_method" = pass_all ||

2642

{ test "$build_libtool_libs" = yes &&

2643

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

2644

# We only need to search for static libraries

2645

continue

2646

fi

2647

fi

2648

2649

link_static=no # Whether the deplib will be linked statically

2650

use_static_libs=$prefer_static_libs

2651

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

2652

use_static_libs=no

2653

fi

2654

if test -n "$library_names" &&

2655

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

2656

if test "$installed" = no; then

2657

notinst_deplibs="$notinst_deplibs $lib"

2658

need_relink=yes

2659

fi

2660

# This is a shared library

2661

2662

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

2663

# some systems (darwin)

2664

if test "$shouldnotlink" = yes && test "$pass" = link ; then

2665

$echo

2666

if test "$linkmode" = prog; then

2667

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

2668

else

2669

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

2670

fi

2671

$echo "*** $linklib is not portable!"

2672

fi

2673

if test "$linkmode" = lib &&

2674

test "$hardcode_into_libs" = yes; then

2675

# Hardcode the library path.

2676

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

2677

# search path.

2678

case " $sys_lib_dlsearch_path " in

2679

*" $absdir "*) ;;

2680

*)

2681

case "$compile_rpath " in

2682

*" $absdir "*) ;;

2683

*) compile_rpath="$compile_rpath $absdir"

2684

esac

2685

;;

2686

esac

2687

case " $sys_lib_dlsearch_path " in

2688

*" $libdir "*) ;;

2689

*)

2690

case "$finalize_rpath " in

2691

*" $libdir "*) ;;

2692

*) finalize_rpath="$finalize_rpath $libdir"

2693

esac

2694

;;

2695

esac

2696

fi

2697

2698

if test -n "$old_archive_from_expsyms_cmds"; then

2699

# figure out the soname

2700

set dummy $library_names

2701

realname="$2"

2702

shift; shift

2703

libname=`eval \\$echo \"$libname_spec\"`

2704

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

2705

if test -n "$dlname"; then

2706

soname="$dlname"

2707

elif test -n "$soname_spec"; then

2708

# bleh windows

2709

case $host in

2710

*cygwin* | mingw*)

2711

major=`expr $current - $age`

2712

versuffix="-$major"

2713

;;

2714

esac

2715

eval soname=\"$soname_spec\"

2716

else

2717

soname="$realname"

2718

fi

2719

2720

# Make a new name for the extract_expsyms_cmds to use

2721

soroot="$soname"

2722

soname=`$echo $soroot | ${SED} -e 's/^.*\///'`

2723

newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"

2724

2725

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

2726

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

2727

else

2728

$show "extracting exported symbol list from \`$soname'"

2729

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

2730

cmds=$extract_expsyms_cmds

2731

for cmd in $cmds; do

2732

IFS="$save_ifs"

2733

eval cmd=\"$cmd\"

2734

$show "$cmd"

2735

$run eval "$cmd" || exit $?

2736

done

2737

IFS="$save_ifs"

2738

fi

2739

2740

# Create $newlib

2741

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

2742

$show "generating import library for \`$soname'"

2743

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

2744

cmds=$old_archive_from_expsyms_cmds

2745

for cmd in $cmds; do

2746

IFS="$save_ifs"

2747

eval cmd=\"$cmd\"

2748

$show "$cmd"

2749

$run eval "$cmd" || exit $?

2750

done

2751

IFS="$save_ifs"

2752

fi

2753

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

2754

dir=$output_objdir

2755

linklib=$newlib

2756

fi # test -n "$old_archive_from_expsyms_cmds"

2757

2758

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

2759

add_shlibpath=

2760

add_dir=

2761

add=

2762

lib_linked=yes

2763

case $hardcode_action in

2764

immediate | unsupported)

2765

if test "$hardcode_direct" = no; then

2766

add="$dir/$linklib"

2767

case $host in

2768

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

2769

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

2770

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

2771

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

2772

*-*-darwin* )

2773

# if the lib is a module then we can not link against

2774

# it, someone is ignoring the new warnings I added

2775

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

2776

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

2777

$echo "** Warning, lib $linklib is a module, not a shared library"

2778

if test -z "$old_library" ; then

2779

$echo

2780

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

2781

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

2782

else

2783

add="$dir/$old_library"

2784

fi

2785

fi

2786

esac

2787

elif test "$hardcode_minus_L" = no; then

2788

case $host in

2789

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

2790

esac

2791

add_dir="-L$dir"

2792

add="-l$name"

2793

elif test "$hardcode_shlibpath_var" = no; then

2794

add_shlibpath="$dir"

2795

add="-l$name"

2796

else

2797

lib_linked=no

2798

fi

2799

;;

2800

relink)

2801

if test "$hardcode_direct" = yes; then

2802

add="$dir/$linklib"

2803

elif test "$hardcode_minus_L" = yes; then

2804

add_dir="-L$dir"

2805

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

2806

if test -n "$inst_prefix_dir"; then

2807

case $libdir in

2808

[\\/]*)

2809

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

2810

;;

2811

esac

2812

fi

2813

add="-l$name"

2814

elif test "$hardcode_shlibpath_var" = yes; then

2815

add_shlibpath="$dir"

2816

add="-l$name"

2817

else

2818

lib_linked=no

2819

fi

2820

;;

2821

*) lib_linked=no ;;

2822

esac

2823

2824

if test "$lib_linked" != yes; then

2825

$echo "$modename: configuration error: unsupported hardcode properties"

2826

exit $EXIT_FAILURE

2827

fi

2828

2829

if test -n "$add_shlibpath"; then

2830

case :$compile_shlibpath: in

2831

*":$add_shlibpath:"*) ;;

2832

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

2833

esac

2834

fi

2835

if test "$linkmode" = prog; then

2836

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

2837

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

2838

else

2839

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

2840

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

2841

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

2842

test "$hardcode_minus_L" != yes && \

2843

test "$hardcode_shlibpath_var" = yes; then

2844

case :$finalize_shlibpath: in

2845

*":$libdir:"*) ;;

2846

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

2847

esac

2848

fi

2849

fi

2850

fi

2851

2852

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

2853

add_shlibpath=

2854

add_dir=

2855

add=

2856

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

2857

if test "$hardcode_direct" = yes; then

2858

add="$libdir/$linklib"

2859

elif test "$hardcode_minus_L" = yes; then

2860

add_dir="-L$libdir"

2861

add="-l$name"

2862

elif test "$hardcode_shlibpath_var" = yes; then

2863

case :$finalize_shlibpath: in

2864

*":$libdir:"*) ;;

2865

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

2866

esac

2867

add="-l$name"

2868

elif test "$hardcode_automatic" = yes; then

2869

if test -n "$inst_prefix_dir" &&

2870

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

2871

add="$inst_prefix_dir$libdir/$linklib"

2872

else

2873

add="$libdir/$linklib"

2874

fi

2875

else

2876

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

2877

add_dir="-L$libdir"

2878

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

2879

if test -n "$inst_prefix_dir"; then

2880

case $libdir in

2881

[\\/]*)

2882

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

2883

;;

2884

esac

2885

fi

2886

add="-l$name"

2887

fi

2888

2889

if test "$linkmode" = prog; then

2890

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

2891

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

2892

else

2893

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

2894

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

2895

fi

2896

fi

2897

elif test "$linkmode" = prog; then

2898

# Here we assume that one of hardcode_direct or hardcode_minus_L

2899

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

2900

# shared platforms.

2901

if test "$hardcode_direct" != unsupported; then

2902

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

2903

compile_deplibs="$dir/$linklib $compile_deplibs"

2904

finalize_deplibs="$dir/$linklib $finalize_deplibs"

2905

else

2906

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

2907

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

2908

fi

2909

elif test "$build_libtool_libs" = yes; then

2910

# Not a shared library

2911

if test "$deplibs_check_method" != pass_all; then

2912

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

2913

# but the system doesn't support it.

2914

2915

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

2916

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

2917

$echo

2918

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

2919

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

2920

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

2921

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

2922

if test "$module" = yes; then

2923

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

2924

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

2925

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

2926

if test -z "$global_symbol_pipe"; then

2927

$echo

2928

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

2929

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

2930

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

2931

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

2932

fi

2933

if test "$build_old_libs" = no; then

2934

build_libtool_libs=module

2935

build_old_libs=yes

2936

else

2937

build_libtool_libs=no

2938

fi

2939

fi

2940

else

2941

deplibs="$dir/$old_library $deplibs"

2942

link_static=yes

2943

fi

2944

fi # link shared/static library?

2945

2946

if test "$linkmode" = lib; then

2947

if test -n "$dependency_libs" &&

2948

{ test "$hardcode_into_libs" != yes ||

2949

test "$build_old_libs" = yes ||

2950

test "$link_static" = yes; }; then

2951

# Extract -R from dependency_libs

2952

temp_deplibs=

2953

for libdir in $dependency_libs; do

2954

case $libdir in

2955

-R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`

2956

case " $xrpath " in

2957

*" $temp_xrpath "*) ;;

2958

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

2959

esac;;

2960

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

2961

esac

2962

done

2963

dependency_libs="$temp_deplibs"

2964

fi

2965

2966

newlib_search_path="$newlib_search_path $absdir"

2967

# Link against this library

2968

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

2969

# ... and its dependency_libs

2970

tmp_libs=

2971

for deplib in $dependency_libs; do

2972

newdependency_libs="$deplib $newdependency_libs"

2973

if test "X$duplicate_deps" = "Xyes" ; then

2974

case "$tmp_libs " in

2975

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

2976

esac

2977

fi

2978

tmp_libs="$tmp_libs $deplib"

2979

done

2980

2981

if test "$link_all_deplibs" != no; then

2982

# Add the search paths of all dependency libraries

2983

for deplib in $dependency_libs; do

2984

case $deplib in

2985

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

2986

*.la)

2987

dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`

2988

test "X$dir" = "X$deplib" && dir="."

2989

# We need an absolute path.

2990

case $dir in

2991

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

2992

*)

2993

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

2994

if test -z "$absdir"; then

2995

$echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2

2996

absdir="$dir"

2997

fi

2998

;;

2999

esac

3000

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

3001

path="$absdir/$objdir"

3002

else

3003

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

3004

if test -z "$libdir"; then

3005

$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2

3006

exit $EXIT_FAILURE

3007

fi

3008

if test "$absdir" != "$libdir"; then

3009

$echo "$modename: warning: \`$deplib' seems to be moved" 1>&2

3010

fi

3011

path="$absdir"

3012

fi

3013

depdepl=

3014

case $host in

3015

*-*-darwin*)

3016

# we do not want to link against static libs,

3017

# but need to link against shared

3018

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

3019

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

3020

if test -n "$deplibrary_names" ; then

3021

for tmp in $deplibrary_names ; do

3022

depdepl=$tmp

3023

done

3024

if test -f "$deplibdir/$depdepl" ; then

3025

depdepl="$deplibdir/$depdepl"

3026

elif test -f "$path/$depdepl" ; then

3027

depdepl="$path/$depdepl"

3028

else

3029

# Can't find it, oh well...

3030

depdepl=

3031

fi

3032

# do not add paths which are already there

3033

case " $newlib_search_path " in

3034

*" $path "*) ;;

3035

*) newlib_search_path="$newlib_search_path $path";;

3036

esac

3037

fi

3038

path=""

3039

;;

3040

*)

3041

path="-L$path"

3042

;;

3043

esac

3044

;;

3045

-l*)

3046

case $host in

3047

*-*-darwin*)

3048

# Again, we only want to link against shared libraries

3049

eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`

3050

for tmp in $newlib_search_path ; do

3051

if test -f "$tmp/lib$tmp_libs.dylib" ; then

3052

eval depdepl="$tmp/lib$tmp_libs.dylib"

3053

break

3054

fi

3055

done

3056

path=""

3057

;;

3058

*) continue ;;

3059

esac

3060

;;

3061

*) continue ;;

3062

esac

3063

case " $deplibs " in

3064

*" $path "*) ;;

3065

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

3066

esac

3067

case " $deplibs " in

3068

*" $depdepl "*) ;;

3069

*) deplibs="$depdepl $deplibs" ;;

3070

esac

3071

done

3072

fi # link_all_deplibs != no

3073

fi # linkmode = lib

3074

done # for deplib in $libs

3075

dependency_libs="$newdependency_libs"

3076

if test "$pass" = dlpreopen; then

3077

# Link the dlpreopened libraries before other libraries

3078

for deplib in $save_deplibs; do

3079

deplibs="$deplib $deplibs"

3080

done

3081

fi

3082

if test "$pass" != dlopen; then

3083

if test "$pass" != conv; then

3084

# Make sure lib_search_path contains only unique directories.

3085

lib_search_path=

3086

for dir in $newlib_search_path; do

3087

case "$lib_search_path " in

3088

*" $dir "*) ;;

3089

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

3090

esac

3091

done

3092

newlib_search_path=

3093

fi

3094

3095

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

3096

vars="deplibs"

3097

else

3098

vars="compile_deplibs finalize_deplibs"

3099

fi

3100

for var in $vars dependency_libs; do

3101

# Add libraries to $var in reverse order

3102

eval tmp_libs=\"\$$var\"

3103

new_libs=

3104

for deplib in $tmp_libs; do

3105

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

3106

# that some nasty dependency loop isn't accidentally

3107

# broken:

3108

#new_libs="$deplib $new_libs"

3109

# Pragmatically, this seems to cause very few problems in

3110

# practice:

3111

case $deplib in

3112

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

3113

-R*) ;;

3114

*)

3115

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

3116

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

3117

# is implicitly linked in more than once by the

3118

# compiler, it is considered special, and multiple

3119

# occurrences thereof are not removed. Compare this

3120

# with having the same library being listed as a

3121

# dependency of multiple other libraries: in this case,

3122

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

3123

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

3124

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

3125

# enough that we require users that really mean to play

3126

# such unportable linking tricks to link the library

3127

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

3128

# for duplicate removal.

3129

case " $specialdeplibs " in

3130

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

3131

*)

3132

case " $new_libs " in

3133

*" $deplib "*) ;;

3134

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

3135

esac

3136

;;

3137

esac

3138

;;

3139

esac

3140

done

3141

tmp_libs=

3142

for deplib in $new_libs; do

3143

case $deplib in

3144

-L*)

3145

case " $tmp_libs " in

3146

*" $deplib "*) ;;

3147

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

3148

esac

3149

;;

3150

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

3151

esac

3152

done

3153

eval $var=\"$tmp_libs\"

3154

done # for var

3155

fi

3156

# Last step: remove runtime libs from dependency_libs

3157

# (they stay in deplibs)

3158

tmp_libs=

3159

for i in $dependency_libs ; do

3160

case " $predeps $postdeps $compiler_lib_search_path " in

3161

*" $i "*)

3162

i=""

3163

;;

3164

esac

3165

if test -n "$i" ; then

3166

tmp_libs="$tmp_libs $i"

3167

fi

3168

done

3169

dependency_libs=$tmp_libs

3170

done # for pass

3171

if test "$linkmode" = prog; then

3172

dlfiles="$newdlfiles"

3173

dlprefiles="$newdlprefiles"

3174

fi

3175

3176

case $linkmode in

3177

oldlib)

3178

case " $deplibs" in

3179

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

3180

$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 ;;

3181

esac

3182

3183

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

3184

$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2

3185

fi

3186

3187

if test -n "$rpath"; then

3188

$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2

3189

fi

3190

3191

if test -n "$xrpath"; then

3192

$echo "$modename: warning: \`-R' is ignored for archives" 1>&2

3193

fi

3194

3195

if test -n "$vinfo"; then

3196

$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2

3197

fi

3198

3199

if test -n "$release"; then

3200

$echo "$modename: warning: \`-release' is ignored for archives" 1>&2

3201

fi

3202

3203

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

3204

$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2

3205

fi

3206

3207

# Now set the variables for building old libraries.

3208

build_libtool_libs=no

3209

oldlibs="$output"

3210

objs="$objs$old_deplibs"

3211

;;

3212

3213

lib)

3214

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

3215

case $outputname in

3216

lib*)

3217

name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

3218

eval shared_ext=\"$shrext_cmds\"

3219

eval libname=\"$libname_spec\"

3220

;;

3221

*)

3222

if test "$module" = no; then

3223

$echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2

3224

$echo "$help" 1>&2

3225

exit $EXIT_FAILURE

3226

fi

3227

if test "$need_lib_prefix" != no; then

3228

# Add the "lib" prefix for modules if required

3229

name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`

3230

eval shared_ext=\"$shrext_cmds\"

3231

eval libname=\"$libname_spec\"

3232

else

3233

libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`

3234

fi

3235

;;

3236

esac

3237

3238

if test -n "$objs"; then

3239

if test "$deplibs_check_method" != pass_all; then

3240

$echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1

3241

exit $EXIT_FAILURE

3242

else

3243

$echo

3244

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

3245

$echo "*** objects $objs is not portable!"

3246

libobjs="$libobjs $objs"

3247

fi

3248

fi

3249

3250

if test "$dlself" != no; then

3251

$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2

3252

fi

3253

3254

set dummy $rpath

3255

if test "$#" -gt 2; then

3256

$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2

3257

fi

3258

install_libdir="$2"

3259

3260

oldlibs=

3261

if test -z "$rpath"; then

3262

if test "$build_libtool_libs" = yes; then

3263

# Building a libtool convenience library.

3264

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

3265

# convenience libraries should have the same extension an

3266

# archive normally would.

3267

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

3268

build_libtool_libs=convenience

3269

build_old_libs=yes

3270

fi

3271

3272

if test -n "$vinfo"; then

3273

$echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2

3274

fi

3275

3276

if test -n "$release"; then

3277

$echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2

3278

fi

3279

else

3280

3281

# Parse the version information argument.

3282

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

3283

set dummy $vinfo 0 0 0

3284

IFS="$save_ifs"

3285

3286

if test -n "$8"; then

3287

$echo "$modename: too many parameters to \`-version-info'" 1>&2

3288

$echo "$help" 1>&2

3289

exit $EXIT_FAILURE

3290

fi

3291

3292

# convert absolute version numbers to libtool ages

3293

# this retains compatibility with .la files and attempts

3294

# to make the code below a bit more comprehensible

3295

3296

case $vinfo_number in

3297

yes)

3298

number_major="$2"

3299

number_minor="$3"

3300

number_revision="$4"

3301

#

3302

# There are really only two kinds -- those that

3303

# use the current revision as the major version

3304

# and those that subtract age and use age as

3305

# a minor version. But, then there is irix

3306

# which has an extra 1 added just for fun

3307

#

3308

case $version_type in

3309

darwin|linux|osf|windows|none)

3310

current=`expr $number_major + $number_minor`

3311

age="$number_minor"

3312

revision="$number_revision"

3313

;;

3314

freebsd-aout|freebsd-elf|sunos)

3315

current="$number_major"

3316

revision="$number_minor"

3317

age="0"

3318

;;

3319

irix|nonstopux)

3320

current=`expr $number_major + $number_minor`

3321

age="$number_minor"

3322

revision="$number_minor"

3323

lt_irix_increment=no

3324

;;

3325

esac

3326

;;

3327

no)

3328

current="$2"

3329

revision="$3"

3330

age="$4"

3331

;;

3332

esac

3333

3334

# Check that each of the things are valid numbers.

3335

case $current in

3336

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

3337

*)

3338

$echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2

3339

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

3340

exit $EXIT_FAILURE

3341

;;

3342

esac

3343

3344

case $revision in

3345

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

3346

*)

3347

$echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2

3348

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

3349

exit $EXIT_FAILURE

3350

;;

3351

esac

3352

3353

case $age in

3354

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

3355

*)

3356

$echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2

3357

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

3358

exit $EXIT_FAILURE

3359

;;

3360

esac

3361

3362

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

3363

$echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2

3364

$echo "$modename: \`$vinfo' is not valid version information" 1>&2

3365

exit $EXIT_FAILURE

3366

fi

3367

3368

# Calculate the version variables.

3369

major=

3370

versuffix=

3371

verstring=

3372

case $version_type in

3373

none) ;;

3374

3375

darwin)

3376

# Like Linux, but with the current version available in

3377

# verstring for coding it into the library header

3378

major=.`expr $current - $age`

3379

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

3380

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

3381

minor_current=`expr $current + 1`

3382

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

3383

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

3384

;;

3385

3386

freebsd-aout)

3387

major=".$current"

3388

versuffix=".$current.$revision";

3389

;;

3390

3391

freebsd-elf)

3392

major=".$current"

3393

versuffix=".$current";

3394

;;

3395

3396

irix | nonstopux)

3397

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

3398

major=`expr $current - $age`

3399

else

3400

major=`expr $current - $age + 1`

3401

fi

3402

case $version_type in

3403

nonstopux) verstring_prefix=nonstopux ;;

3404

*) verstring_prefix=sgi ;;

3405

esac

3406

verstring="$verstring_prefix$major.$revision"

3407

3408

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

3409

loop=$revision

3410

while test "$loop" -ne 0; do

3411

iface=`expr $revision - $loop`

3412

loop=`expr $loop - 1`

3413

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

3414

done

3415

3416

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

3417

major=.$major

3418

versuffix="$major.$revision"

3419

;;

3420

3421

linux)

3422

major=.`expr $current - $age`

3423

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

3424

;;

3425

3426

osf)

3427

major=.`expr $current - $age`

3428

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

3429

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

3430

3431

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

3432

loop=$age

3433

while test "$loop" -ne 0; do

3434

iface=`expr $current - $loop`

3435

loop=`expr $loop - 1`

3436

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

3437

done

3438

3439

# Make executables depend on our current version.

3440

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

3441

;;

3442

3443

sunos)

3444

major=".$current"

3445

versuffix=".$current.$revision"

3446

;;

3447

3448

windows)

3449

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

3450

# extension on DOS 8.3 filesystems.

3451

major=`expr $current - $age`

3452

versuffix="-$major"

3453

;;

3454

3455

*)

3456

$echo "$modename: unknown library version type \`$version_type'" 1>&2

3457

$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2

3458

exit $EXIT_FAILURE

3459

;;

3460

esac

3461

3462

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

3463

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

3464

major=

3465

case $version_type in

3466

darwin)

3467

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

3468

# problems, so we reset it completely

3469

verstring=

3470

;;

3471

*)

3472

verstring="0.0"

3473

;;

3474

esac

3475

if test "$need_version" = no; then

3476

versuffix=

3477

else

3478

versuffix=".0.0"

3479

fi

3480

fi

3481

3482

# Remove version info from name if versioning should be avoided

3483

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

3484

major=

3485

versuffix=

3486

verstring=""

3487

fi

3488

3489

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

3490

if test "$allow_undefined" = yes; then

3491

if test "$allow_undefined_flag" = unsupported; then

3492

$echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2

3493

build_libtool_libs=no

3494

build_old_libs=yes

3495

fi

3496

else

3497

# Don't allow undefined symbols.

3498

allow_undefined_flag="$no_undefined_flag"

3499

fi

3500

fi

3501

3502

if test "$mode" != relink; then

3503

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

3504

# may have been created when compiling PIC objects.

3505

removelist=

3506

tempremovelist=`$echo "$output_objdir/*"`

3507

for p in $tempremovelist; do

3508

case $p in

3509

*.$objext)

3510

;;

3511

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

3512

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

3513

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

3514

then

3515

continue

3516

fi

3517

fi

3518

removelist="$removelist $p"

3519

;;

3520

*) ;;

3521

esac

3522

done

3523

if test -n "$removelist"; then

3524

$show "${rm}r $removelist"

3525

$run ${rm}r $removelist

3526

fi

3527

fi

3528

3529

# Now set the variables for building old libraries.

3530

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

3531

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

3532

3533

# Transform .lo files to .o files.

3534

oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`

3535

fi

3536

3537

# Eliminate all temporary directories.

3538

#for path in $notinst_path; do

3539

# lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`

3540

# deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`

3541

# dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`

3542

#done

3543

3544

if test -n "$xrpath"; then

3545

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

3546

temp_xrpath=

3547

for libdir in $xrpath; do

3548

temp_xrpath="$temp_xrpath -R$libdir"

3549

case "$finalize_rpath " in

3550

*" $libdir "*) ;;

3551

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

3552

esac

3553

done

3554

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

3555

dependency_libs="$temp_xrpath $dependency_libs"

3556

fi

3557

fi

3558

3559

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

3560

old_dlfiles="$dlfiles"

3561

dlfiles=

3562

for lib in $old_dlfiles; do

3563

case " $dlprefiles $dlfiles " in

3564

*" $lib "*) ;;

3565

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

3566

esac

3567

done

3568

3569

# Make sure dlprefiles contains only unique files

3570

old_dlprefiles="$dlprefiles"

3571

dlprefiles=

3572

for lib in $old_dlprefiles; do

3573

case "$dlprefiles " in

3574

*" $lib "*) ;;

3575

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

3576

esac

3577

done

3578

3579

if test "$build_libtool_libs" = yes; then

3580

if test -n "$rpath"; then

3581

case $host in

3582

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)

3583

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

3584

;;

3585

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

3586

# Rhapsody C library is in the System framework

3587

deplibs="$deplibs -framework System"

3588

;;

3589

*-*-netbsd*)

3590

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

3591

;;

3592

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

3593

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

3594

;;

3595

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

3596

# Causes problems with __ctype

3597

;;

3598

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

3599

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

3600

;;

3601

*)

3602

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

3603

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

3604

deplibs="$deplibs -lc"

3605

fi

3606

;;

3607

esac

3608

fi

3609

3610

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

3611

name_save=$name

3612

libname_save=$libname

3613

release_save=$release

3614

versuffix_save=$versuffix

3615

major_save=$major

3616

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

3617

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

3618

# add it in twice. Is that correct?

3619

release=""

3620

versuffix=""

3621

major=""

3622

newdeplibs=

3623

droppeddeps=no

3624

case $deplibs_check_method in

3625

pass_all)

3626

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

3627

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

3628

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

3629

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

3630

# implementing what was already the behavior.

3631

newdeplibs=$deplibs

3632

;;

3633

test_compile)

3634

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

3635

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

3636

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

3637

# whether they linked in statically or dynamically with ldd.

3638

$rm conftest.c

3639

cat > conftest.c <<EOF

3640

int main() { return 0; }

3641

EOF

3642

$rm conftest

3643

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

3644

ldd_output=`ldd conftest`

3645

for i in $deplibs; do

3646

name=`expr $i : '-l$.*$'`

3647

# If $name is empty we are operating on a -L argument.

3648

if test "$name" != "" && test "$name" != "0"; then

3649

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

3650

case " $predeps $postdeps " in

3651

*" $i "*)

3652

newdeplibs="$newdeplibs $i"

3653

i=""

3654

;;

3655

esac

3656

fi

3657

if test -n "$i" ; then

3658

libname=`eval \\$echo \"$libname_spec\"`

3659

deplib_matches=`eval \\$echo \"$library_names_spec\"`

3660

set dummy $deplib_matches

3661

deplib_match=$2

3662

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

3663

newdeplibs="$newdeplibs $i"

3664

else

3665

droppeddeps=yes

3666

$echo

3667

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

3668

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

3669

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

3670

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

3671

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

3672

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

3673

fi

3674

fi

3675

else

3676

newdeplibs="$newdeplibs $i"

3677

fi

3678

done

3679

else

3680

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

3681

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

3682

for i in $deplibs; do

3683

name=`expr $i : '-l$.*$'`

3684

# If $name is empty we are operating on a -L argument.

3685

if test "$name" != "" && test "$name" != "0"; then

3686

$rm conftest

3687

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

3688

ldd_output=`ldd conftest`

3689

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

3690

case " $predeps $postdeps " in

3691

*" $i "*)

3692

newdeplibs="$newdeplibs $i"

3693

i=""

3694

;;

3695

esac

3696

fi

3697

if test -n "$i" ; then

3698

libname=`eval \\$echo \"$libname_spec\"`

3699

deplib_matches=`eval \\$echo \"$library_names_spec\"`

3700

set dummy $deplib_matches

3701

deplib_match=$2

3702

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

3703

newdeplibs="$newdeplibs $i"

3704

else

3705

droppeddeps=yes

3706

$echo

3707

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

3708

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

3709

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

3710

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

3711

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

3712

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

3713

fi

3714

fi

3715

else

3716

droppeddeps=yes

3717

$echo

3718

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

3719

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

3720

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

3721

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

3722

fi

3723

else

3724

newdeplibs="$newdeplibs $i"

3725

fi

3726

done

3727

fi

3728

;;

3729

file_magic*)

3730

set dummy $deplibs_check_method

3731

file_magic_regex=`expr "$deplibs_check_method" : "$2 $.*$"`

3732

for a_deplib in $deplibs; do

3733

name=`expr $a_deplib : '-l$.*$'`

3734

# If $name is empty we are operating on a -L argument.

3735

if test "$name" != "" && test "$name" != "0"; then

3736

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

3737

case " $predeps $postdeps " in

3738

*" $a_deplib "*)

3739

newdeplibs="$newdeplibs $a_deplib"

3740

a_deplib=""

3741

;;

3742

esac

3743

fi

3744

if test -n "$a_deplib" ; then

3745

libname=`eval \\$echo \"$libname_spec\"`

3746

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

3747

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

3748

for potent_lib in $potential_libs; do

3749

# Follow soft links.

3750

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

3751

| grep " -> " >/dev/null; then

3752

continue

3753

fi

3754

# The statement above tries to avoid entering an

3755

# endless loop below, in case of cyclic links.

3756

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

3757

# loop can be closed while we follow links,

3758

# but so what?

3759

potlib="$potent_lib"

3760

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

3761

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

3762

case $potliblink in

3763

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

3764

*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;

3765

esac

3766

done

3767

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

3768

| ${SED} 10q \

3769

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

3770

newdeplibs="$newdeplibs $a_deplib"

3771

a_deplib=""

3772

break 2

3773

fi

3774

done

3775

done

3776

fi

3777

if test -n "$a_deplib" ; then

3778

droppeddeps=yes

3779

$echo

3780

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

3781

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

3782

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

3783

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

3784

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

3785

if test -z "$potlib" ; then

3786

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

3787

else

3788

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

3789

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

3790

fi

3791

fi

3792

else

3793

# Add a -L argument.

3794

newdeplibs="$newdeplibs $a_deplib"

3795

fi

3796

done # Gone through all deplibs.

3797

;;

3798

match_pattern*)

3799

set dummy $deplibs_check_method

3800

match_pattern_regex=`expr "$deplibs_check_method" : "$2 $.*$"`

3801

for a_deplib in $deplibs; do

3802

name=`expr $a_deplib : '-l$.*$'`

3803

# If $name is empty we are operating on a -L argument.

3804

if test -n "$name" && test "$name" != "0"; then

3805

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

3806

case " $predeps $postdeps " in

3807

*" $a_deplib "*)

3808

newdeplibs="$newdeplibs $a_deplib"

3809

a_deplib=""

3810

;;

3811

esac

3812

fi

3813

if test -n "$a_deplib" ; then

3814

libname=`eval \\$echo \"$libname_spec\"`

3815

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

3816

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

3817

for potent_lib in $potential_libs; do

3818

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

3819

if eval $echo \"$potent_lib\" 2>/dev/null \

3820

| ${SED} 10q \

3821

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

3822

newdeplibs="$newdeplibs $a_deplib"

3823

a_deplib=""

3824

break 2

3825

fi

3826

done

3827

done

3828

fi

3829

if test -n "$a_deplib" ; then

3830

droppeddeps=yes

3831

$echo

3832

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

3833

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

3834

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

3835

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

3836

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

3837

if test -z "$potlib" ; then

3838

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

3839

else

3840

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

3841

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

3842

fi

3843

fi

3844

else

3845

# Add a -L argument.

3846

newdeplibs="$newdeplibs $a_deplib"

3847

fi

3848

done # Gone through all deplibs.

3849

;;

3850

none | unknown | *)

3851

newdeplibs=""

3852

tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \

3853

-e 's/ -[LR][^ ]*//g'`

3854

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

3855

for i in $predeps $postdeps ; do

3856

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

3857

tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`

3858

done

3859

fi

3860

if $echo "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' \

3861

| grep . >/dev/null; then

3862

$echo

3863

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

3864

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

3865

else

3866

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

3867

fi

3868

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

3869

droppeddeps=yes

3870

fi

3871

;;

3872

esac

3873

versuffix=$versuffix_save

3874

major=$major_save

3875

release=$release_save

3876

libname=$libname_save

3877

name=$name_save

3878

3879

case $host in

3880

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

3881

# On Rhapsody replace the C library is the System framework

3882

newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`

3883

;;

3884

esac

3885

3886

if test "$droppeddeps" = yes; then

3887

if test "$module" = yes; then

3888

$echo

3889

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

3890

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

3891

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

3892

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

3893

if test -z "$global_symbol_pipe"; then

3894

$echo

3895

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

3896

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

3897

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

3898

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

3899

fi

3900

if test "$build_old_libs" = no; then

3901

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

3902

build_libtool_libs=module

3903

build_old_libs=yes

3904

else

3905

build_libtool_libs=no

3906

fi

3907

else

3908

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

3909

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

3910

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

3911

3912

if test "$allow_undefined" = no; then

3913

$echo

3914

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

3915

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

3916

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

3917

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

3918

if test "$build_old_libs" = no; then

3919

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

3920

build_libtool_libs=module

3921

build_old_libs=yes

3922

else

3923

build_libtool_libs=no

3924

fi

3925

fi

3926

fi

3927

fi

3928

# Done checking deplibs!

3929

deplibs=$newdeplibs

3930

fi

3931

3932

3933

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

3934

# installed libraries to the beginning of the library search list

3935

new_libs=

3936

for path in $notinst_path; do

3937

case " $new_libs " in

3938

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

3939

*)

3940

case " $deplibs " in

3941

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

3942

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

3943

esac

3944

;;

3945

esac

3946

done

3947

for deplib in $deplibs; do

3948

case $deplib in

3949

-L*)

3950

case " $new_libs " in

3951

*" $deplib "*) ;;

3952

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

3953

esac

3954

;;

3955

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

3956

esac

3957

done

3958

deplibs="$new_libs"

3959

3960

3961

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

3962

library_names=

3963

old_library=

3964

dlname=

3965

3966

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

3967

if test "$build_libtool_libs" = yes; then

3968

if test "$hardcode_into_libs" = yes; then

3969

# Hardcode the library paths

3970

hardcode_libdirs=

3971

dep_rpath=

3972

rpath="$finalize_rpath"

3973

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

3974

for libdir in $rpath; do

3975

if test -n "$hardcode_libdir_flag_spec"; then

3976

if test -n "$hardcode_libdir_separator"; then

3977

if test -z "$hardcode_libdirs"; then

3978

hardcode_libdirs="$libdir"

3979

else

3980

# Just accumulate the unique libdirs.

3981

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

3982

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

3983

;;

3984

*)

3985

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

3986

;;

3987

esac

3988

fi

3989

else

3990

eval flag=\"$hardcode_libdir_flag_spec\"

3991

dep_rpath="$dep_rpath $flag"

3992

fi

3993

elif test -n "$runpath_var"; then

3994

case "$perm_rpath " in

3995

*" $libdir "*) ;;

3996

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

3997

esac

3998

fi

3999

done

4000

# Substitute the hardcoded libdirs into the rpath.

4001

if test -n "$hardcode_libdir_separator" &&

4002

test -n "$hardcode_libdirs"; then

4003

libdir="$hardcode_libdirs"

4004

if test -n "$hardcode_libdir_flag_spec_ld"; then

4005

case $archive_cmds in

4006

*\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;

4007

*) eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;

4008

esac

4009

else

4010

eval dep_rpath=\"$hardcode_libdir_flag_spec\"

4011

fi

4012

fi

4013

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

4014

# We should set the runpath_var.

4015

rpath=

4016

for dir in $perm_rpath; do

4017

rpath="$rpath$dir:"

4018

done

4019

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

4020

fi

4021

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

4022

fi

4023

4024

shlibpath="$finalize_shlibpath"

4025

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

4026

if test -n "$shlibpath"; then

4027

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

4028

fi

4029

4030

# Get the real and link names of the library.

4031

eval shared_ext=\"$shrext_cmds\"

4032

eval library_names=\"$library_names_spec\"

4033

set dummy $library_names

4034

realname="$2"

4035

shift; shift

4036

4037

if test -n "$soname_spec"; then

4038

eval soname=\"$soname_spec\"

4039

else

4040

soname="$realname"

4041

fi

4042

if test -z "$dlname"; then

4043

dlname=$soname

4044

fi

4045

4046

lib="$output_objdir/$realname"

4047

linknames=

4048

for link

4049

do

4050

linknames="$linknames $link"

4051

done

4052

4053

# Use standard objects if they are pic

4054

test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4055

4056

# Prepare the list of exported symbols

4057

if test -z "$export_symbols"; then

4058

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

4059

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

4060

export_symbols="$output_objdir/$libname.exp"

4061

$run $rm $export_symbols

4062

cmds=$export_symbols_cmds

4063

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

4064

for cmd in $cmds; do

4065

IFS="$save_ifs"

4066

eval cmd=\"$cmd\"

4067

if len=`expr "X$cmd" : ".*"` &&

4068

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

4069

$show "$cmd"

4070

$run eval "$cmd" || exit $?

4071

skipped_export=false

4072

else

4073

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

4074

$show "using reloadable object file for export list..."

4075

skipped_export=:

4076

# Break out early, otherwise skipped_export may be

4077

# set to false by a later but shorter cmd.

4078

break

4079

fi

4080

done

4081

IFS="$save_ifs"

4082

if test -n "$export_symbols_regex"; then

4083

$show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""

4084

$run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

4085

$show "$mv \"${export_symbols}T\" \"$export_symbols\""

4086

$run eval '$mv "${export_symbols}T" "$export_symbols"'

4087

fi

4088

fi

4089

fi

4090

4091

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

4092

$run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'

4093

fi

4094

4095

tmp_deplibs=

4096

for test_deplib in $deplibs; do

4097

case " $convenience " in

4098

*" $test_deplib "*) ;;

4099

*)

4100

tmp_deplibs="$tmp_deplibs $test_deplib"

4101

;;

4102

esac

4103

done

4104

deplibs="$tmp_deplibs"

4105

4106

if test -n "$convenience"; then

4107

if test -n "$whole_archive_flag_spec"; then

4108

save_libobjs=$libobjs

4109

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

4110

else

4111

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

4112

generated="$generated $gentop"

4113

4114

func_extract_archives $gentop $convenience

4115

libobjs="$libobjs $func_extract_archives_result"

4116

fi

4117

fi

4118

4119

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

4120

eval flag=\"$thread_safe_flag_spec\"

4121

linker_flags="$linker_flags $flag"

4122

fi

4123

4124

# Make a backup of the uninstalled library when relinking

4125

if test "$mode" = relink; then

4126

$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?

4127

fi

4128

4129

# Do each of the archive commands.

4130

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

4131

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

4132

eval test_cmds=\"$module_expsym_cmds\"

4133

cmds=$module_expsym_cmds

4134

else

4135

eval test_cmds=\"$module_cmds\"

4136

cmds=$module_cmds

4137

fi

4138

else

4139

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

4140

eval test_cmds=\"$archive_expsym_cmds\"

4141

cmds=$archive_expsym_cmds

4142

else

4143

eval test_cmds=\"$archive_cmds\"

4144

cmds=$archive_cmds

4145

fi

4146

fi

4147

4148

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

4149

len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

4150

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

4151

:

4152

else

4153

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

4154

$echo "creating reloadable object files..."

4155

4156

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

4157

# use them later. If we have whole_archive_flag_spec, we

4158

# want to use save_libobjs as it was before

4159

# whole_archive_flag_spec was expanded, because we can't

4160

# assume the linker understands whole_archive_flag_spec.

4161

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

4162

# convenience libraries get linked in and end up exceeding

4163

# the spec.

4164

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

4165

save_libobjs=$libobjs

4166

fi

4167

save_output=$output

4168

output_la=`$echo "X$output" | $Xsed -e "$basename"`

4169

4170

# Clear the reloadable object creation command queue and

4171

# initialize k to one.

4172

test_cmds=

4173

concat_cmds=

4174

objlist=

4175

delfiles=

4176

last_robj=

4177

k=1

4178

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

4179

# Loop over the list of objects to be linked.

4180

for obj in $save_libobjs

4181

do

4182

eval test_cmds=\"$reload_cmds $objlist $last_robj\"

4183

if test "X$objlist" = X ||

4184

{ len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

4185

test "$len" -le "$max_cmd_len"; }; then

4186

objlist="$objlist $obj"

4187

else

4188

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

4189

# command to the queue.

4190

if test "$k" -eq 1 ; then

4191

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

4192

eval concat_cmds=\"$reload_cmds $objlist $last_robj\"

4193

else

4194

# All subsequent reloadable object files will link in

4195

# the last one created.

4196

eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"

4197

fi

4198

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

4199

k=`expr $k + 1`

4200

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

4201

objlist=$obj

4202

len=1

4203

fi

4204

done

4205

# Handle the remaining objects by creating one last

4206

# reloadable object file. All subsequent reloadable object

4207

# files will link in the last one created.

4208

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

4209

eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"

4210

4211

if ${skipped_export-false}; then

4212

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

4213

export_symbols="$output_objdir/$libname.exp"

4214

$run $rm $export_symbols

4215

libobjs=$output

4216

# Append the command to create the export file.

4217

eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"

4218

fi

4219

4220

# Set up a command to remove the reloadable object files

4221

# after they are used.

4222

i=0

4223

while test "$i" -lt "$k"

4224

do

4225

i=`expr $i + 1`

4226

delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"

4227

done

4228

4229

$echo "creating a temporary reloadable object file: $output"

4230

4231

# Loop through the commands generated above and execute them.

4232

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

4233

for cmd in $concat_cmds; do

4234

IFS="$save_ifs"

4235

$show "$cmd"

4236

$run eval "$cmd" || exit $?

4237

done

4238

IFS="$save_ifs"

4239

4240

libobjs=$output

4241

# Restore the value of output.

4242

output=$save_output

4243

4244

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

4245

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

4246

fi

4247

# Expand the library linking commands again to reset the

4248

# value of $libobjs for piecewise linking.

4249

4250

# Do each of the archive commands.

4251

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

4252

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

4253

cmds=$module_expsym_cmds

4254

else

4255

cmds=$module_cmds

4256

fi

4257

else

4258

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

4259

cmds=$archive_expsym_cmds

4260

else

4261

cmds=$archive_cmds

4262

fi

4263

fi

4264

4265

# Append the command to remove the reloadable object files

4266

# to the just-reset $cmds.

4267

eval cmds=\"\$cmds~\$rm $delfiles\"

4268

fi

4269

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

4270

for cmd in $cmds; do

4271

IFS="$save_ifs"

4272

eval cmd=\"$cmd\"

4273

$show "$cmd"

4274

$run eval "$cmd" || {

4275

lt_exit=$?

4276

4277

# Restore the uninstalled library and exit

4278

if test "$mode" = relink; then

4279

$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'

4280

fi

4281

4282

exit $lt_exit

4283

}

4284

done

4285

IFS="$save_ifs"

4286

4287

# Restore the uninstalled library and exit

4288

if test "$mode" = relink; then

4289

$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?

4290

4291

if test -n "$convenience"; then

4292

if test -z "$whole_archive_flag_spec"; then

4293

$show "${rm}r $gentop"

4294

$run ${rm}r "$gentop"

4295

fi

4296

fi

4297

4298

exit $EXIT_SUCCESS

4299

fi

4300

4301

# Create links to the real library.

4302

for linkname in $linknames; do

4303

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

4304

$show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"

4305

$run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?

4306

fi

4307

done

4308

4309

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

4310

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

4311

# On all known operating systems, these are identical.

4312

dlname="$soname"

4313

fi

4314

fi

4315

;;

4316

4317

obj)

4318

case " $deplibs" in

4319

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

4320

$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 ;;

4321

esac

4322

4323

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

4324

$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2

4325

fi

4326

4327

if test -n "$rpath"; then

4328

$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2

4329

fi

4330

4331

if test -n "$xrpath"; then

4332

$echo "$modename: warning: \`-R' is ignored for objects" 1>&2

4333

fi

4334

4335

if test -n "$vinfo"; then

4336

$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2

4337

fi

4338

4339

if test -n "$release"; then

4340

$echo "$modename: warning: \`-release' is ignored for objects" 1>&2

4341

fi

4342

4343

case $output in

4344

*.lo)

4345

if test -n "$objs$old_deplibs"; then

4346

$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2

4347

exit $EXIT_FAILURE

4348

fi

4349

libobj="$output"

4350

obj=`$echo "X$output" | $Xsed -e "$lo2o"`

4351

;;

4352

*)

4353

libobj=

4354

obj="$output"

4355

;;

4356

esac

4357

4358

# Delete the old objects.

4359

$run $rm $obj $libobj

4360

4361

# Objects from convenience libraries. This assumes

4362

# single-version convenience libraries. Whenever we create

4363

# different ones for PIC/non-PIC, this we'll have to duplicate

4364

# the extraction.

4365

reload_conv_objs=

4366

gentop=

4367

# reload_cmds runs $LD directly, so let us get rid of

4368

# -Wl from whole_archive_flag_spec and hope we can get by with

4369

# turning comma into space..

4370

wl=

4371

4372

if test -n "$convenience"; then

4373

if test -n "$whole_archive_flag_spec"; then

4374

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

4375

reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`

4376

else

4377

gentop="$output_objdir/${obj}x"

4378

generated="$generated $gentop"

4379

4380

func_extract_archives $gentop $convenience

4381

reload_conv_objs="$reload_objs $func_extract_archives_result"

4382

fi

4383

fi

4384

4385

# Create the old-style object.

4386

reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

4387

4388

output="$obj"

4389

cmds=$reload_cmds

4390

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

4391

for cmd in $cmds; do

4392

IFS="$save_ifs"

4393

eval cmd=\"$cmd\"

4394

$show "$cmd"

4395

$run eval "$cmd" || exit $?

4396

done

4397

IFS="$save_ifs"

4398

4399

# Exit if we aren't doing a library object file.

4400

if test -z "$libobj"; then

4401

if test -n "$gentop"; then

4402

$show "${rm}r $gentop"

4403

$run ${rm}r $gentop

4404

fi

4405

4406

exit $EXIT_SUCCESS

4407

fi

4408

4409

if test "$build_libtool_libs" != yes; then

4410

if test -n "$gentop"; then

4411

$show "${rm}r $gentop"

4412

$run ${rm}r $gentop

4413

fi

4414

4415

# Create an invalid libtool object if no PIC, so that we don't

4416

# accidentally link it into a program.

4417

# $show "echo timestamp > $libobj"

4418

# $run eval "echo timestamp > $libobj" || exit $?

4419

exit $EXIT_SUCCESS

4420

fi

4421

4422

if test -n "$pic_flag" || test "$pic_mode" != default; then

4423

# Only do commands if we really have different PIC objects.

4424

reload_objs="$libobjs $reload_conv_objs"

4425

output="$libobj"

4426

cmds=$reload_cmds

4427

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

4428

for cmd in $cmds; do

4429

IFS="$save_ifs"

4430

eval cmd=\"$cmd\"

4431

$show "$cmd"

4432

$run eval "$cmd" || exit $?

4433

done

4434

IFS="$save_ifs"

4435

fi

4436

4437

if test -n "$gentop"; then

4438

$show "${rm}r $gentop"

4439

$run ${rm}r $gentop

4440

fi

4441

4442

exit $EXIT_SUCCESS

4443

;;

4444

4445

prog)

4446

case $host in

4447

*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;

4448

esac

4449

if test -n "$vinfo"; then

4450

$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2

4451

fi

4452

4453

if test -n "$release"; then

4454

$echo "$modename: warning: \`-release' is ignored for programs" 1>&2

4455

fi

4456

4457

if test "$preload" = yes; then

4458

if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&

4459

test "$dlopen_self_static" = unknown; then

4460

$echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."

4461

fi

4462

fi

4463

4464

case $host in

4465

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

4466

# On Rhapsody replace the C library is the System framework

4467

compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`

4468

finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`

4469

;;

4470

esac

4471

4472

case $host in

4473

*darwin*)

4474

# Don't allow lazy linking, it breaks C++ global constructors

4475

if test "$tagname" = CXX ; then

4476

compile_command="$compile_command ${wl}-bind_at_load"

4477

finalize_command="$finalize_command ${wl}-bind_at_load"

4478

fi

4479

;;

4480

esac

4481

4482

4483

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

4484

# installed libraries to the beginning of the library search list

4485

new_libs=

4486

for path in $notinst_path; do

4487

case " $new_libs " in

4488

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

4489

*)

4490

case " $compile_deplibs " in

4491

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

4492

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

4493

esac

4494

;;

4495

esac

4496

done

4497

for deplib in $compile_deplibs; do

4498

case $deplib in

4499

-L*)

4500

case " $new_libs " in

4501

*" $deplib "*) ;;

4502

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

4503

esac

4504

;;

4505

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

4506

esac

4507

done

4508

compile_deplibs="$new_libs"

4509

4510

4511

compile_command="$compile_command $compile_deplibs"

4512

finalize_command="$finalize_command $finalize_deplibs"

4513

4514

if test -n "$rpath$xrpath"; then

4515

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

4516

for libdir in $rpath $xrpath; do

4517

# This is the magic to use -rpath.

4518

case "$finalize_rpath " in

4519

*" $libdir "*) ;;

4520

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

4521

esac

4522

done

4523

fi

4524

4525

# Now hardcode the library paths

4526

rpath=

4527

hardcode_libdirs=

4528

for libdir in $compile_rpath $finalize_rpath; do

4529

if test -n "$hardcode_libdir_flag_spec"; then

4530

if test -n "$hardcode_libdir_separator"; then

4531

if test -z "$hardcode_libdirs"; then

4532

hardcode_libdirs="$libdir"

4533

else

4534

# Just accumulate the unique libdirs.

4535

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

4536

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

4537

;;

4538

*)

4539

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

4540

;;

4541

esac

4542

fi

4543

else

4544

eval flag=\"$hardcode_libdir_flag_spec\"

4545

rpath="$rpath $flag"

4546

fi

4547

elif test -n "$runpath_var"; then

4548

case "$perm_rpath " in

4549

*" $libdir "*) ;;

4550

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

4551

esac

4552

fi

4553

case $host in

4554

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

4555

testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`

4556

case :$dllsearchpath: in

4557

*":$libdir:"*) ;;

4558

*) dllsearchpath="$dllsearchpath:$libdir";;

4559

esac

4560

case :$dllsearchpath: in

4561

*":$testbindir:"*) ;;

4562

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

4563

esac

4564

;;

4565

esac

4566

done

4567

# Substitute the hardcoded libdirs into the rpath.

4568

if test -n "$hardcode_libdir_separator" &&

4569

test -n "$hardcode_libdirs"; then

4570

libdir="$hardcode_libdirs"

4571

eval rpath=\" $hardcode_libdir_flag_spec\"

4572

fi

4573

compile_rpath="$rpath"

4574

4575

rpath=

4576

hardcode_libdirs=

4577

for libdir in $finalize_rpath; do

4578

if test -n "$hardcode_libdir_flag_spec"; then

4579

if test -n "$hardcode_libdir_separator"; then

4580

if test -z "$hardcode_libdirs"; then

4581

hardcode_libdirs="$libdir"

4582

else

4583

# Just accumulate the unique libdirs.

4584

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

4585

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

4586

;;

4587

*)

4588

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

4589

;;

4590

esac

4591

fi

4592

else

4593

eval flag=\"$hardcode_libdir_flag_spec\"

4594

rpath="$rpath $flag"

4595

fi

4596

elif test -n "$runpath_var"; then

4597

case "$finalize_perm_rpath " in

4598

*" $libdir "*) ;;

4599

*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

4600

esac

4601

fi

4602

done

4603

# Substitute the hardcoded libdirs into the rpath.

4604

if test -n "$hardcode_libdir_separator" &&

4605

test -n "$hardcode_libdirs"; then

4606

libdir="$hardcode_libdirs"

4607

eval rpath=\" $hardcode_libdir_flag_spec\"

4608

fi

4609

finalize_rpath="$rpath"

4610

4611

if test -n "$libobjs" && test "$build_old_libs" = yes; then

4612

# Transform all the library objects into standard objects.

4613

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4614

finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4615

fi

4616

4617

dlsyms=

4618

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

4619

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

4620

dlsyms="${outputname}S.c"

4621

else

4622

$echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2

4623

fi

4624

fi

4625

4626

if test -n "$dlsyms"; then

4627

case $dlsyms in

4628

"") ;;

4629

*.c)

4630

# Discover the nlist of each of the dlfiles.

4631

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

4632

4633

$show "$rm $nlist ${nlist}S ${nlist}T"

4634

$run $rm "$nlist" "${nlist}S" "${nlist}T"

4635

4636

# Parse the name list into a source file.

4637

$show "creating $output_objdir/$dlsyms"

4638

4639

test -z "$run" && $echo > "$output_objdir/$dlsyms" "\

4640

/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */

4641

/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */

4642

4643

#ifdef __cplusplus

4644

extern \"C\" {

4645

#endif

4646

4647

/* Prevent the only kind of declaration conflicts we can make. */

4648

#define lt_preloaded_symbols some_other_symbol

4649

4650

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

4651

"

4652

4653

if test "$dlself" = yes; then

4654

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

4655

4656

test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"

4657

4658

# Add our own program objects to the symbol list.

4659

progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

4660

for arg in $progfiles; do

4661

$show "extracting global C symbols from \`$arg'"

4662

$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"

4663

done

4664

4665

if test -n "$exclude_expsyms"; then

4666

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

4667

$run eval '$mv "$nlist"T "$nlist"'

4668

fi

4669

4670

if test -n "$export_symbols_regex"; then

4671

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

4672

$run eval '$mv "$nlist"T "$nlist"'

4673

fi

4674

4675

# Prepare the list of exported symbols

4676

if test -z "$export_symbols"; then

4677

export_symbols="$output_objdir/$outputname.exp"

4678

$run $rm $export_symbols

4679

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

4680

case $host in

4681

*cygwin* | *mingw* )

4682

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

4683

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

4684

;;

4685

esac

4686

else

4687

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

4688

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

4689

$run eval 'mv "$nlist"T "$nlist"'

4690

case $host in

4691

*cygwin* | *mingw* )

4692

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

4693

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

4694

;;

4695

esac

4696

fi

4697

fi

4698

4699

for arg in $dlprefiles; do

4700

$show "extracting global C symbols from \`$arg'"

4701

name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`

4702

$run eval '$echo ": $name " >> "$nlist"'

4703

$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"

4704

done

4705

4706

if test -z "$run"; then

4707

# Make sure we have at least an empty file.

4708

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

4709

4710

if test -n "$exclude_expsyms"; then

4711

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

4712

$mv "$nlist"T "$nlist"

4713

fi

4714

4715

# Try sorting and uniquifying the output.

4716

if grep -v "^: " < "$nlist" |

4717

if sort -k 3 </dev/null >/dev/null 2>&1; then

4718

sort -k 3

4719

else

4720

sort +2

4721

fi |

4722

uniq > "$nlist"S; then

4723

:

4724

else

4725

grep -v "^: " < "$nlist" > "$nlist"S

4726

fi

4727

4728

if test -f "$nlist"S; then

4729

eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'

4730

else

4731

$echo '/* NONE */' >> "$output_objdir/$dlsyms"

4732

fi

4733

4734

$echo >> "$output_objdir/$dlsyms" "\

4735

4736

#undef lt_preloaded_symbols

4737

4738

#if defined (__STDC__) && __STDC__

4739

# define lt_ptr void *

4740

#else

4741

# define lt_ptr char *

4742

# define const

4743

#endif

4744

4745

/* The mapping between symbol names and symbols. */

4746

"

4747

4748

case $host in

4749

*cygwin* | *mingw* )

4750

$echo >> "$output_objdir/$dlsyms" "\

4751

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

4752

runtime relocations are performed -- see ld's documentation

4753

on pseudo-relocs */

4754

struct {

4755

"

4756

;;

4757

* )

4758

$echo >> "$output_objdir/$dlsyms" "\

4759

const struct {

4760

"

4761

;;

4762

esac

4763

4764

4765

$echo >> "$output_objdir/$dlsyms" "\

4766

const char *name;

4767

lt_ptr address;

4768

}

4769

lt_preloaded_symbols[] =

4770

{\

4771

"

4772

4773

eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"

4774

4775

$echo >> "$output_objdir/$dlsyms" "\

4776

{0, (lt_ptr) 0}

4777

};

4778

4779

/* This works around a problem in FreeBSD linker */

4780

#ifdef FREEBSD_WORKAROUND

4781

static const void *lt_preloaded_setup() {

4782

return lt_preloaded_symbols;

4783

}

4784

#endif

4785

4786

#ifdef __cplusplus

4787

}

4788

#endif\

4789

"

4790

fi

4791

4792

pic_flag_for_symtable=

4793

case $host in

4794

# compiling the symbol table file with pic_flag works around

4795

# a FreeBSD bug that causes programs to crash when -lm is

4796

# linked before any other PIC object. But we must not use

4797

# pic_flag when linking with -static. The problem exists in

4798

# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

4799

*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)

4800

case "$compile_command " in

4801

*" -static "*) ;;

4802

*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;

4803

esac;;

4804

*-*-hpux*)

4805

case "$compile_command " in

4806

*" -static "*) ;;

4807

*) pic_flag_for_symtable=" $pic_flag";;

4808

esac

4809

esac

4810

4811

# Now compile the dynamic symbol file.

4812

$show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"

4813

$run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?

4814

4815

# Clean up the generated files.

4816

$show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"

4817

$run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"

4818

4819

# Transform the symbol file into the correct name.

4820

case $host in

4821

*cygwin* | *mingw* )

4822

if test -f "$output_objdir/${outputname}.def" ; then

4823

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`

4824

finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`

4825

else

4826

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`

4827

finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`

4828

fi

4829

;;

4830

* )

4831

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`

4832

finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`

4833

;;

4834

esac

4835

;;

4836

*-*-freebsd*)

4837

# FreeBSD doesn't need this...

4838

;;

4839

*)

4840

$echo "$modename: unknown suffix for \`$dlsyms'" 1>&2

4841

exit $EXIT_FAILURE

4842

;;

4843

esac

4844

else

4845

# We keep going just in case the user didn't refer to

4846

# lt_preloaded_symbols. The linker will fail if global_symbol_pipe

4847

# really was required.

4848

4849

# Nullify the symbol file.

4850

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`

4851

finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`

4852

fi

4853

4854

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

4855

# Replace the output file specification.

4856

compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`

4857

link_command="$compile_command$compile_rpath"

4858

4859

# We have no uninstalled library dependencies, so finalize right now.

4860

$show "$link_command"

4861

$run eval "$link_command"

4862

exit_status=$?

4863

4864

# Delete the generated files.

4865

if test -n "$dlsyms"; then

4866

$show "$rm $output_objdir/${outputname}S.${objext}"

4867

$run $rm "$output_objdir/${outputname}S.${objext}"

4868

fi

4869

4870

exit $exit_status

4871

fi

4872

4873

if test -n "$shlibpath_var"; then

4874

# We should set the shlibpath_var

4875

rpath=

4876

for dir in $temp_rpath; do

4877

case $dir in

4878

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

4879

# Absolute path.

4880

rpath="$rpath$dir:"

4881

;;

4882

*)

4883

# Relative path: add a thisdir entry.

4884

rpath="$rpath\$thisdir/$dir:"

4885

;;

4886

esac

4887

done

4888

temp_rpath="$rpath"

4889

fi

4890

4891

if test -n "$compile_shlibpath$finalize_shlibpath"; then

4892

compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

4893

fi

4894

if test -n "$finalize_shlibpath"; then

4895

finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

4896

fi

4897

4898

compile_var=

4899

finalize_var=

4900

if test -n "$runpath_var"; then

4901

if test -n "$perm_rpath"; then

4902

# We should set the runpath_var.

4903

rpath=

4904

for dir in $perm_rpath; do

4905

rpath="$rpath$dir:"

4906

done

4907

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

4908

fi

4909

if test -n "$finalize_perm_rpath"; then

4910

# We should set the runpath_var.

4911

rpath=

4912

for dir in $finalize_perm_rpath; do

4913

rpath="$rpath$dir:"

4914

done

4915

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

4916

fi

4917

fi

4918

4919

if test "$no_install" = yes; then

4920

# We don't need to create a wrapper script.

4921

link_command="$compile_var$compile_command$compile_rpath"

4922

# Replace the output file specification.

4923

link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

4924

# Delete the old output file.

4925

$run $rm $output

4926

# Link the executable and exit

4927

$show "$link_command"

4928

$run eval "$link_command" || exit $?

4929

exit $EXIT_SUCCESS

4930

fi

4931

4932

if test "$hardcode_action" = relink; then

4933

# Fast installation is not supported

4934

link_command="$compile_var$compile_command$compile_rpath"

4935

relink_command="$finalize_var$finalize_command$finalize_rpath"

4936

4937

$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2

4938

$echo "$modename: \`$output' will be relinked during installation" 1>&2

4939

else

4940

if test "$fast_install" != no; then

4941

link_command="$finalize_var$compile_command$finalize_rpath"

4942

if test "$fast_install" = yes; then

4943

relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`

4944

else

4945

# fast_install is set to needless

4946

relink_command=

4947

fi

4948

else

4949

link_command="$compile_var$compile_command$compile_rpath"

4950

relink_command="$finalize_var$finalize_command$finalize_rpath"

4951

fi

4952

fi

4953

4954

# Replace the output file specification.

4955

link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

4956

4957

# Delete the old output files.

4958

$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname

4959

4960

$show "$link_command"

4961

$run eval "$link_command" || exit $?

4962

4963

# Now create the wrapper script.

4964

$show "creating $output"

4965

4966

# Quote the relink command for shipping.

4967

if test -n "$relink_command"; then

4968

# Preserve any variables that may affect compiler behavior

4969

for var in $variables_saved_for_relink; do

4970

if eval test -z \"\${$var+set}\"; then

4971

relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"

4972

elif eval var_value=\$$var; test -z "$var_value"; then

4973

relink_command="$var=; export $var; $relink_command"

4974

else

4975

var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`

4976

relink_command="$var=\"$var_value\"; export $var; $relink_command"

4977

fi

4978

done

4979

relink_command="(cd `pwd`; $relink_command)"

4980

relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`

4981

fi

4982

4983

# Quote $echo for shipping.

4984

if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then

4985

case $progpath in

4986

[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;

4987

*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;

4988

esac

4989

qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`

4990

else

4991

qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`

4992

fi

4993

4994

# Only actually do things if our run command is non-null.

4995

if test -z "$run"; then

4996

# win32 will think the script is a binary if it has

4997

# a .exe suffix, so we strip it off here.

4998

case $output in

4999

*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;

5000

esac

5001

# test for cygwin because mv fails w/o .exe extensions

5002

case $host in

5003

*cygwin*)

5004

exeext=.exe

5005

outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;

5006

*) exeext= ;;

5007

esac

5008

case $host in

5009

*cygwin* | *mingw* )

5010

output_name=`basename $output`

5011

output_path=`dirname $output`

5012

cwrappersource="$output_path/$objdir/lt-$output_name.c"

5013

cwrapper="$output_path/$output_name.exe"

5014

$rm $cwrappersource $cwrapper

5015

trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

5016

5017

cat > $cwrappersource <<EOF

5018

5019

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

5020

Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

5021

5022

The $output program cannot be directly executed until all the libtool

5023

libraries that it depends on are installed.

5024

5025

This wrapper executable should never be moved out of the build directory.

5026

If it is, it will not operate correctly.

5027

5028

Currently, it simply execs the wrapper *script* "/bin/sh $output",

5029

but could eventually absorb all of the scripts functionality and

5030

exec $objdir/$outputname directly.

5031

*/

5032

EOF

5033

cat >> $cwrappersource<<"EOF"

5034

#include <stdio.h>

5035

#include <stdlib.h>

5036

#include <unistd.h>

5037

#include <malloc.h>

5038

#include <stdarg.h>

5039

#include <assert.h>

5040

#include <string.h>

5041

#include <ctype.h>

5042

#include <sys/stat.h>

5043

5044

#if defined(PATH_MAX)

5045

# define LT_PATHMAX PATH_MAX

5046

#elif defined(MAXPATHLEN)

5047

# define LT_PATHMAX MAXPATHLEN

5048

#else

5049

# define LT_PATHMAX 1024

5050

#endif

5051

5052

#ifndef DIR_SEPARATOR

5053

# define DIR_SEPARATOR '/'

5054

# define PATH_SEPARATOR ':'

5055

#endif

5056

5057

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

5058

defined (__OS2__)

5059

# define HAVE_DOS_BASED_FILE_SYSTEM

5060

# ifndef DIR_SEPARATOR_2

5061

# define DIR_SEPARATOR_2 '\\'

5062

# endif

5063

# ifndef PATH_SEPARATOR_2

5064

# define PATH_SEPARATOR_2 ';'

5065

# endif

5066

#endif

5067

5068

#ifndef DIR_SEPARATOR_2

5069

# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

5070

#else /* DIR_SEPARATOR_2 */

5071

# define IS_DIR_SEPARATOR(ch) \

5072

(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

5073

#endif /* DIR_SEPARATOR_2 */

5074

5075

#ifndef PATH_SEPARATOR_2

5076

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

5077

#else /* PATH_SEPARATOR_2 */

5078

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

5079

#endif /* PATH_SEPARATOR_2 */

5080

5081

#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

5082

#define XFREE(stale) do { \

5083

if (stale) { free ((void *) stale); stale = 0; } \

5084

} while (0)

5085

5086

/* -DDEBUG is fairly common in CFLAGS. */

5087

#undef DEBUG

5088

#if defined DEBUGWRAPPER

5089

# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)

5090

#else

5091

# define DEBUG(format, ...)

5092

#endif

5093

5094

const char *program_name = NULL;

5095

5096

void * xmalloc (size_t num);

5097

char * xstrdup (const char *string);

5098

const char * base_name (const char *name);

5099

char * find_executable(const char *wrapper);

5100

int check_executable(const char *path);

5101

char * strendzap(char *str, const char *pat);

5102

void lt_fatal (const char *message, ...);

5103

5104

int

5105

main (int argc, char *argv[])

5106

{

5107

char **newargz;

5108

int i;

5109

5110

program_name = (char *) xstrdup (base_name (argv[0]));

5111

DEBUG("(main) argv[0] : %s\n",argv[0]);

5112

DEBUG("(main) program_name : %s\n",program_name);

5113

newargz = XMALLOC(char *, argc+2);

5114

EOF

5115

5116

cat >> $cwrappersource <<EOF

5117

newargz[0] = (char *) xstrdup("$SHELL");

5118

EOF

5119

5120

cat >> $cwrappersource <<"EOF"

5121

newargz[1] = find_executable(argv[0]);

5122

if (newargz[1] == NULL)

5123

lt_fatal("Couldn't find %s", argv[0]);

5124

DEBUG("(main) found exe at : %s\n",newargz[1]);

5125

/* we know the script has the same name, without the .exe */

5126

/* so make sure newargz[1] doesn't end in .exe */

5127

strendzap(newargz[1],".exe");

5128

for (i = 1; i < argc; i++)

5129

newargz[i+1] = xstrdup(argv[i]);

5130

newargz[argc+1] = NULL;

5131

5132

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

5133

{

5134

DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);

5135

;

5136

}

5137

5138

EOF

5139

5140

case $host_os in

5141

mingw*)

5142

cat >> $cwrappersource <<EOF

5143

execv("$SHELL",(char const **)newargz);

5144

EOF

5145

;;

5146

*)

5147

cat >> $cwrappersource <<EOF

5148

execv("$SHELL",newargz);

5149

EOF

5150

;;

5151

esac

5152

5153

cat >> $cwrappersource <<"EOF"

5154

return 127;

5155

}

5156

5157

void *

5158

xmalloc (size_t num)

5159

{

5160

void * p = (void *) malloc (num);

5161

if (!p)

5162

lt_fatal ("Memory exhausted");

5163

5164

return p;

5165

}

5166

5167

char *

5168

xstrdup (const char *string)

5169

{

5170

return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL

5171

;

5172

}

5173

5174

const char *

5175

base_name (const char *name)

5176

{

5177

const char *base;

5178

5179

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5180

/* Skip over the disk name in MSDOS pathnames. */

5181

if (isalpha ((unsigned char)name[0]) && name[1] == ':')

5182

name += 2;

5183

#endif

5184

5185

for (base = name; *name; name++)

5186

if (IS_DIR_SEPARATOR (*name))

5187

base = name + 1;

5188

return base;

5189

}

5190

5191

int

5192

check_executable(const char * path)

5193

{

5194

struct stat st;

5195

5196

DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");

5197

if ((!path) || (!*path))

5198

return 0;

5199

5200

if ((stat (path, &st) >= 0) &&

5201

(

5202

/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */

5203

#if defined (S_IXOTH)

5204

((st.st_mode & S_IXOTH) == S_IXOTH) ||

5205

#endif

5206

#if defined (S_IXGRP)

5207

((st.st_mode & S_IXGRP) == S_IXGRP) ||

5208

#endif

5209

((st.st_mode & S_IXUSR) == S_IXUSR))

5210

)

5211

return 1;

5212

else

5213

return 0;

5214

}

5215

5216

/* Searches for the full path of the wrapper. Returns

5217

newly allocated full path name if found, NULL otherwise */

5218

char *

5219

find_executable (const char* wrapper)

5220

{

5221

int has_slash = 0;

5222

const char* p;

5223

const char* p_next;

5224

/* static buffer for getcwd */

5225

char tmp[LT_PATHMAX + 1];

5226

int tmp_len;

5227

char* concat_name;

5228

5229

DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");

5230

5231

if ((wrapper == NULL) || (*wrapper == '\0'))

5232

return NULL;

5233

5234

/* Absolute path? */

5235

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5236

if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')

5237

{

5238

concat_name = xstrdup (wrapper);

5239

if (check_executable(concat_name))

5240

return concat_name;

5241

XFREE(concat_name);

5242

}

5243

else

5244

{

5245

#endif

5246

if (IS_DIR_SEPARATOR (wrapper[0]))

5247

{

5248

concat_name = xstrdup (wrapper);

5249

if (check_executable(concat_name))

5250

return concat_name;

5251

XFREE(concat_name);

5252

}

5253

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

5254

}

5255

#endif

5256

5257

for (p = wrapper; *p; p++)

5258

if (*p == '/')

5259

{

5260

has_slash = 1;

5261

break;

5262

}

5263

if (!has_slash)

5264

{

5265

/* no slashes; search PATH */

5266

const char* path = getenv ("PATH");

5267

if (path != NULL)

5268

{

5269

for (p = path; *p; p = p_next)

5270

{

5271

const char* q;

5272

size_t p_len;

5273

for (q = p; *q; q++)

5274

if (IS_PATH_SEPARATOR(*q))

5275

break;

5276

p_len = q - p;

5277

p_next = (*q == '\0' ? q : q + 1);

5278

if (p_len == 0)

5279

{

5280

/* empty path: current directory */

5281

if (getcwd (tmp, LT_PATHMAX) == NULL)

5282

lt_fatal ("getcwd failed");

5283

tmp_len = strlen(tmp);

5284

concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

5285

memcpy (concat_name, tmp, tmp_len);

5286

concat_name[tmp_len] = '/';

5287

strcpy (concat_name + tmp_len + 1, wrapper);

5288

}

5289

else

5290

{

5291

concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);

5292

memcpy (concat_name, p, p_len);

5293

concat_name[p_len] = '/';

5294

strcpy (concat_name + p_len + 1, wrapper);

5295

}

5296

if (check_executable(concat_name))

5297

return concat_name;

5298

XFREE(concat_name);

5299

}

5300

}

5301

/* not found in PATH; assume curdir */

5302

}

5303

/* Relative path | not found in path: prepend cwd */

5304

if (getcwd (tmp, LT_PATHMAX) == NULL)

5305

lt_fatal ("getcwd failed");

5306

tmp_len = strlen(tmp);

5307

concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);

5308

memcpy (concat_name, tmp, tmp_len);

5309

concat_name[tmp_len] = '/';

5310

strcpy (concat_name + tmp_len + 1, wrapper);

5311

5312

if (check_executable(concat_name))

5313

return concat_name;

5314

XFREE(concat_name);

5315

return NULL;

5316

}

5317

5318

char *

5319

strendzap(char *str, const char *pat)

5320

{

5321

size_t len, patlen;

5322

5323

assert(str != NULL);

5324

assert(pat != NULL);

5325

5326

len = strlen(str);

5327

patlen = strlen(pat);

5328

5329

if (patlen <= len)

5330

{

5331

str += len - patlen;

5332

if (strcmp(str, pat) == 0)

5333

*str = '\0';

5334

}

5335

return str;

5336

}

5337

5338

static void

5339

lt_error_core (int exit_status, const char * mode,

5340

const char * message, va_list ap)

5341

{

5342

fprintf (stderr, "%s: %s: ", program_name, mode);

5343

vfprintf (stderr, message, ap);

5344

fprintf (stderr, ".\n");

5345

5346

if (exit_status >= 0)

5347

exit (exit_status);

5348

}

5349

5350

void

5351

lt_fatal (const char *message, ...)

5352

{

5353

va_list ap;

5354

va_start (ap, message);

5355

lt_error_core (EXIT_FAILURE, "FATAL", message, ap);

5356

va_end (ap);

5357

}

5358

EOF

5359

# we should really use a build-platform specific compiler

5360

# here, but OTOH, the wrappers (shell script and this C one)

5361

# are only useful if you want to execute the "real" binary.

5362

# Since the "real" binary is built for $host, then this

5363

# wrapper might as well be built for $host, too.

5364

$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource

5365

;;

5366

esac

5367

$rm $output

5368

trap "$rm $output; exit $EXIT_FAILURE" 1 2 15

5369

5370

$echo > $output "\

5371

#! $SHELL

5372

5373

# $output - temporary wrapper script for $objdir/$outputname

5374

# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

5375

#

5376

# The $output program cannot be directly executed until all the libtool

5377

# libraries that it depends on are installed.

5378

#

5379

# This wrapper script should never be moved out of the build directory.

5380

# If it is, it will not operate correctly.

5381

5382

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

5383

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

5384

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

5385

sed_quote_subst='$sed_quote_subst'

5386

5387

# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).

5388

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

5389

emulate sh

5390

NULLCMD=:

5391

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

5392

# is contrary to our usage. Disable this feature.

5393

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

5394

setopt NO_GLOB_SUBST

5395

else

5396

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

5397

fi

5398

BIN_SH=xpg4; export BIN_SH # for Tru64

5399

DUALCASE=1; export DUALCASE # for MKS sh

5400

5401

# The HP-UX ksh and POSIX shell print the target directory to stdout

5402

# if CDPATH is set.

5403

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

5404

5405

relink_command=\"$relink_command\"

5406

5407

# This environment variable determines our operation mode.

5408

if test \"\$libtool_install_magic\" = \"$magic\"; then

5409

# install mode needs the following variable:

5410

notinst_deplibs='$notinst_deplibs'

5411

else

5412

# When we are sourced in execute mode, \$file and \$echo are already set.

5413

if test \"\$libtool_execute_magic\" != \"$magic\"; then

5414

echo=\"$qecho\"

5415

file=\"\$0\"

5416

# Make sure echo works.

5417

if test \"X\$1\" = X--no-reexec; then

5418

# Discard the --no-reexec flag, and continue.

5419

shift

5420

elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then

5421

# Yippee, \$echo works!

5422

:

5423

else

5424

# Restart under the correct shell, and then maybe \$echo will work.

5425

exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}

5426

fi

5427

fi\

5428

"

5429

$echo >> $output "\

5430

5431

# Find the directory that this script lives in.

5432

thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`

5433

test \"x\$thisdir\" = \"x\$file\" && thisdir=.

5434

5435

# Follow symbolic links until we get to the real thisdir.

5436

file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`

5437

while test -n \"\$file\"; do

5438

destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`

5439

5440

# If there was a directory component, then change thisdir.

5441

if test \"x\$destdir\" != \"x\$file\"; then

5442

case \"\$destdir\" in

5443

[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;

5444

*) thisdir=\"\$thisdir/\$destdir\" ;;

5445

esac

5446

fi

5447

5448

file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`

5449

file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`

5450

done

5451

5452

# Try to get the absolute directory name.

5453

absdir=\`cd \"\$thisdir\" && pwd\`

5454

test -n \"\$absdir\" && thisdir=\"\$absdir\"

5455

"

5456

5457

if test "$fast_install" = yes; then

5458

$echo >> $output "\

5459

program=lt-'$outputname'$exeext

5460

progdir=\"\$thisdir/$objdir\"

5461

5462

if test ! -f \"\$progdir/\$program\" || \\

5463

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

5464

test \"X\$file\" != \"X\$progdir/\$program\"; }; then

5465

5466

file=\"\$\$-\$program\"

5467

5468

if test ! -d \"\$progdir\"; then

5469

$mkdir \"\$progdir\"

5470

else

5471

$rm \"\$progdir/\$file\"

5472

fi"

5473

5474

$echo >> $output "\

5475

5476

# relink executable if necessary

5477

if test -n \"\$relink_command\"; then

5478

if relink_command_output=\`eval \$relink_command 2>&1\`; then :

5479

else

5480

$echo \"\$relink_command_output\" >&2

5481

$rm \"\$progdir/\$file\"

5482

exit $EXIT_FAILURE

5483

fi

5484

fi

5485

5486

$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

5487

{ $rm \"\$progdir/\$program\";

5488

$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }

5489

$rm \"\$progdir/\$file\"

5490

fi"

5491

else

5492

$echo >> $output "\

5493

program='$outputname'

5494

progdir=\"\$thisdir/$objdir\"

5495

"

5496

fi

5497

5498

$echo >> $output "\

5499

5500

if test -f \"\$progdir/\$program\"; then"

5501

5502

# Export our shlibpath_var if we have one.

5503

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

5504

$echo >> $output "\

5505

# Add our own library path to $shlibpath_var

5506

$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

5507

5508

# Some systems cannot cope with colon-terminated $shlibpath_var

5509

# The second colon is a workaround for a bug in BeOS R4 sed

5510

$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`

5511

5512

export $shlibpath_var

5513

"

5514

fi

5515

5516

# fixup the dll searchpath if we need to.

5517

if test -n "$dllsearchpath"; then

5518

$echo >> $output "\

5519

# Add the dll search path components to the executable PATH

5520

PATH=$dllsearchpath:\$PATH

5521

"

5522

fi

5523

5524

$echo >> $output "\

5525

if test \"\$libtool_execute_magic\" != \"$magic\"; then

5526

# Run the actual program with our arguments.

5527

"

5528

case $host in

5529

# Backslashes separate directories on plain windows

5530

*-*-mingw | *-*-os2*)

5531

$echo >> $output "\

5532

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

5533

"

5534

;;

5535

5536

*)

5537

$echo >> $output "\

5538

exec \"\$progdir/\$program\" \${1+\"\$@\"}

5539

"

5540

;;

5541

esac

5542

$echo >> $output "\

5543

\$echo \"\$0: cannot exec \$program \$*\"

5544

exit $EXIT_FAILURE

5545

fi

5546

else

5547

# The program doesn't exist.

5548

\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

5549

\$echo \"This script is just a wrapper for \$program.\" 1>&2

5550

$echo \"See the $PACKAGE documentation for more information.\" 1>&2

5551

exit $EXIT_FAILURE

5552

fi

5553

fi\

5554

"

5555

chmod +x $output

5556

fi

5557

exit $EXIT_SUCCESS

5558

;;

5559

esac

5560

5561

# See if we need to build an old-fashioned archive.

5562

for oldlib in $oldlibs; do

5563

5564

if test "$build_libtool_libs" = convenience; then

5565

oldobjs="$libobjs_save"

5566

addlibs="$convenience"

5567

build_libtool_libs=no

5568

else

5569

if test "$build_libtool_libs" = module; then

5570

oldobjs="$libobjs_save"

5571

build_libtool_libs=no

5572

else

5573

oldobjs="$old_deplibs $non_pic_objects"

5574

fi

5575

addlibs="$old_convenience"

5576

fi

5577

5578

if test -n "$addlibs"; then

5579

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

5580

generated="$generated $gentop"

5581

5582

func_extract_archives $gentop $addlibs

5583

oldobjs="$oldobjs $func_extract_archives_result"

5584

fi

5585

5586

# Do each command in the archive commands.

5587

if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

5588

cmds=$old_archive_from_new_cmds

5589

else

5590

# POSIX demands no paths to be encoded in archives. We have

5591

# to avoid creating archives with duplicate basenames if we

5592

# might have to extract them afterwards, e.g., when creating a

5593

# static archive out of a convenience library, or when linking

5594

# the entirety of a libtool archive into another (currently

5595

# not supported by libtool).

5596

if (for obj in $oldobjs

5597

do

5598

$echo "X$obj" | $Xsed -e 's%^.*/%%'

5599

done | sort | sort -uc >/dev/null 2>&1); then

5600

:

5601

else

5602

$echo "copying selected object files to avoid basename conflicts..."

5603

5604

if test -z "$gentop"; then

5605

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

5606

generated="$generated $gentop"

5607

5608

$show "${rm}r $gentop"

5609

$run ${rm}r "$gentop"

5610

$show "$mkdir $gentop"

5611

$run $mkdir "$gentop"

5612

exit_status=$?

5613

if test "$exit_status" -ne 0 && test ! -d "$gentop"; then

5614

exit $exit_status

5615

fi

5616

fi

5617

5618

save_oldobjs=$oldobjs

5619

oldobjs=

5620

counter=1

5621

for obj in $save_oldobjs

5622

do

5623

objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`

5624

case " $oldobjs " in

5625

" ") oldobjs=$obj ;;

5626

*[\ /]"$objbase "*)

5627

while :; do

5628

# Make sure we don't pick an alternate name that also

5629

# overlaps.

5630

newobj=lt$counter-$objbase

5631

counter=`expr $counter + 1`

5632

case " $oldobjs " in

5633

*[\ /]"$newobj "*) ;;

5634

*) if test ! -f "$gentop/$newobj"; then break; fi ;;

5635

esac

5636

done

5637

$show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

5638

$run ln "$obj" "$gentop/$newobj" ||

5639

$run cp "$obj" "$gentop/$newobj"

5640

oldobjs="$oldobjs $gentop/$newobj"

5641

;;

5642

*) oldobjs="$oldobjs $obj" ;;

5643

esac

5644

done

5645

fi

5646

5647

eval cmds=\"$old_archive_cmds\"

5648

5649

if len=`expr "X$cmds" : ".*"` &&

5650

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

5651

cmds=$old_archive_cmds

5652

else

5653

# the command line is too long to link in one step, link in parts

5654

$echo "using piecewise archive linking..."

5655

save_RANLIB=$RANLIB

5656

RANLIB=:

5657

objlist=

5658

concat_cmds=

5659

save_oldobjs=$oldobjs

5660

5661

# Is there a better way of finding the last object in the list?

5662

for obj in $save_oldobjs

5663

do

5664

last_oldobj=$obj

5665

done

5666

for obj in $save_oldobjs

5667

do

5668

oldobjs="$objlist $obj"

5669

objlist="$objlist $obj"

5670

eval test_cmds=\"$old_archive_cmds\"

5671

if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&

5672

test "$len" -le "$max_cmd_len"; then

5673

:

5674

else

5675

# the above command should be used before it gets too long

5676

oldobjs=$objlist

5677

if test "$obj" = "$last_oldobj" ; then

5678

RANLIB=$save_RANLIB

5679

fi

5680

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

5681

eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

5682

objlist=

5683

fi

5684

done

5685

RANLIB=$save_RANLIB

5686

oldobjs=$objlist

5687

if test "X$oldobjs" = "X" ; then

5688

eval cmds=\"\$concat_cmds\"

5689

else

5690

eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

5691

fi

5692

fi

5693

fi

5694

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

5695

for cmd in $cmds; do

5696

eval cmd=\"$cmd\"

5697

IFS="$save_ifs"

5698

$show "$cmd"

5699

$run eval "$cmd" || exit $?

5700

done

5701

IFS="$save_ifs"

5702

done

5703

5704

if test -n "$generated"; then

5705

$show "${rm}r$generated"

5706

$run ${rm}r$generated

5707

fi

5708

5709

# Now create the libtool archive.

5710

case $output in

5711

*.la)

5712

old_library=

5713

test "$build_old_libs" = yes && old_library="$libname.$libext"

5714

$show "creating $output"

5715

5716

# Preserve any variables that may affect compiler behavior

5717

for var in $variables_saved_for_relink; do

5718

if eval test -z \"\${$var+set}\"; then

5719

relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"

5720

elif eval var_value=\$$var; test -z "$var_value"; then

5721

relink_command="$var=; export $var; $relink_command"

5722

else

5723

var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`

5724

relink_command="$var=\"$var_value\"; export $var; $relink_command"

5725

fi

5726

done

5727

# Quote the link command for shipping.

5728

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

5729

relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`

5730

if test "$hardcode_automatic" = yes ; then

5731

relink_command=

5732

fi

5733

5734

5735

# Only create the output if not a dry run.

5736

if test -z "$run"; then

5737

for installed in no yes; do

5738

if test "$installed" = yes; then

5739

if test -z "$install_libdir"; then

5740

break

5741

fi

5742

output="$output_objdir/$outputname"i

5743

# Replace all uninstalled libtool libraries with the installed ones

5744

newdependency_libs=

5745

for deplib in $dependency_libs; do

5746

case $deplib in

5747

*.la)

5748

name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`

5749

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

5750

if test -z "$libdir"; then

5751

$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2

5752

exit $EXIT_FAILURE

5753

fi

5754

newdependency_libs="$newdependency_libs $libdir/$name"

5755

;;

5756

*) newdependency_libs="$newdependency_libs $deplib" ;;

5757

esac

5758

done

5759

dependency_libs="$newdependency_libs"

5760

newdlfiles=

5761

for lib in $dlfiles; do

5762

name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

5763

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

5764

if test -z "$libdir"; then

5765

$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

5766

exit $EXIT_FAILURE

5767

fi

5768

newdlfiles="$newdlfiles $libdir/$name"

5769

done

5770

dlfiles="$newdlfiles"

5771

newdlprefiles=

5772

for lib in $dlprefiles; do

5773

name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`

5774

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

5775

if test -z "$libdir"; then

5776

$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

5777

exit $EXIT_FAILURE

5778

fi

5779

newdlprefiles="$newdlprefiles $libdir/$name"

5780

done

5781

dlprefiles="$newdlprefiles"

5782

else

5783

newdlfiles=

5784

for lib in $dlfiles; do

5785

case $lib in

5786

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

5787

*) abs=`pwd`"/$lib" ;;

5788

esac

5789

newdlfiles="$newdlfiles $abs"

5790

done

5791

dlfiles="$newdlfiles"

5792

newdlprefiles=

5793

for lib in $dlprefiles; do

5794

case $lib in

5795

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

5796

*) abs=`pwd`"/$lib" ;;

5797

esac

5798

newdlprefiles="$newdlprefiles $abs"

5799

done

5800

dlprefiles="$newdlprefiles"

5801

fi

5802

$rm $output

5803

# place dlname in correct position for cygwin

5804

tdlname=$dlname

5805

case $host,$output,$installed,$module,$dlname in

5806

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;

5807

esac

5808

$echo > $output "\

5809

# $outputname - a libtool library file

5810

# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP

5811

#

5812

# Please DO NOT delete this file!

5813

# It is necessary for linking the library.

5814

5815

# The name that we can dlopen(3).

5816

dlname='$tdlname'

5817

5818

# Names of this library.

5819

library_names='$library_names'

5820

5821

# The name of the static archive.

5822

old_library='$old_library'

5823

5824

# Libraries that this one depends upon.

5825

dependency_libs='$dependency_libs'

5826

5827

# Version information for $libname.

5828

current=$current

5829

age=$age

5830

revision=$revision

5831

5832

# Is this an already installed library?

5833

installed=$installed

5834

5835

# Should we warn about portability when linking against -modules?

5836

shouldnotlink=$module

5837

5838

# Files to dlopen/dlpreopen

5839

dlopen='$dlfiles'

5840

dlpreopen='$dlprefiles'

5841

5842

# Directory that this library needs to be installed in:

5843

libdir='$install_libdir'"

5844

if test "$installed" = no && test "$need_relink" = yes; then

5845

$echo >> $output "\

5846

relink_command=\"$relink_command\""

5847

fi

5848

done

5849

fi

5850

5851

# Do a symbolic link so that the libtool archive can be found in

5852

# LD_LIBRARY_PATH before the program is installed.

5853

$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"

5854

$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?

5855

;;

5856

esac

5857

exit $EXIT_SUCCESS

5858

;;

5859

5860

# libtool install mode

5861

install)

5862

modename="$modename: install"

5863

5864

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

5865

# install_prog (especially on Windows NT).

5866

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

5867

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

5868

$echo "X$nonopt" | grep shtool > /dev/null; then

5869

# Aesthetically quote it.

5870

arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`

5871

case $arg in

5872

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

5873

arg="\"$arg\""

5874

;;

5875

esac

5876

install_prog="$arg "

5877

arg="$1"

5878

shift

5879

else

5880

install_prog=

5881

arg=$nonopt

5882

fi

5883

5884

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

5885

# Aesthetically quote it.

5886

arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

5887

case $arg in

5888

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

5889

arg="\"$arg\""

5890

;;

5891

esac

5892

install_prog="$install_prog$arg"

5893

5894

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

5895

dest=

5896

files=

5897

opts=

5898

prev=

5899

install_type=

5900

isdir=no

5901

stripme=

5902

for arg

5903

do

5904

if test -n "$dest"; then

5905

files="$files $dest"

5906

dest=$arg

5907

continue

5908

fi

5909

5910

case $arg in

5911

-d) isdir=yes ;;

5912

-f)

5913

case " $install_prog " in

5914

*[\\\ /]cp\ *) ;;

5915

*) prev=$arg ;;

5916

esac

5917

;;

5918

-g | -m | -o) prev=$arg ;;

5919

-s)

5920

stripme=" -s"

5921

continue

5922

;;

5923

-*)

5924

;;

5925

*)

5926

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

5927

if test -n "$prev"; then

5928

prev=

5929

else

5930

dest=$arg

5931

continue

5932

fi

5933

;;

5934

esac

5935

5936

# Aesthetically quote the argument.

5937

arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

5938

case $arg in

5939

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

5940

arg="\"$arg\""

5941

;;

5942

esac

5943

install_prog="$install_prog $arg"

5944

done

5945

5946

if test -z "$install_prog"; then

5947

$echo "$modename: you must specify an install program" 1>&2

5948

$echo "$help" 1>&2

5949

exit $EXIT_FAILURE

5950

fi

5951

5952

if test -n "$prev"; then

5953

$echo "$modename: the \`$prev' option requires an argument" 1>&2

5954

$echo "$help" 1>&2

5955

exit $EXIT_FAILURE

5956

fi

5957

5958

if test -z "$files"; then

5959

if test -z "$dest"; then

5960

$echo "$modename: no file or destination specified" 1>&2

5961

else

5962

$echo "$modename: you must specify a destination" 1>&2

5963

fi

5964

$echo "$help" 1>&2

5965

exit $EXIT_FAILURE

5966

fi

5967

5968

# Strip any trailing slash from the destination.

5969

dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`

5970

5971

# Check to see that the destination is a directory.

5972

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

5973

if test "$isdir" = yes; then

5974

destdir="$dest"

5975

destname=

5976

else

5977

destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`

5978

test "X$destdir" = "X$dest" && destdir=.

5979

destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`

5980

5981

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

5982

set dummy $files

5983

if test "$#" -gt 2; then

5984

$echo "$modename: \`$dest' is not a directory" 1>&2

5985

$echo "$help" 1>&2

5986

exit $EXIT_FAILURE

5987

fi

5988

fi

5989

case $destdir in

5990

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

5991

*)

5992

for file in $files; do

5993

case $file in

5994

*.lo) ;;

5995

*)

5996

$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2

5997

$echo "$help" 1>&2

5998

exit $EXIT_FAILURE

5999

;;

6000

esac

6001

done

6002

;;

6003

esac

6004

6005

# This variable tells wrapper scripts just to set variables rather

6006

# than running their programs.

6007

libtool_install_magic="$magic"

6008

6009

staticlibs=

6010

future_libdirs=

6011

current_libdirs=

6012

for file in $files; do

6013

6014

# Do each installation.

6015

case $file in

6016

*.$libext)

6017

# Do the static libraries later.

6018

staticlibs="$staticlibs $file"

6019

;;

6020

6021

*.la)

6022

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

6023

if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

6024

else

6025

$echo "$modename: \`$file' is not a valid libtool archive" 1>&2

6026

$echo "$help" 1>&2

6027

exit $EXIT_FAILURE

6028

fi

6029

6030

library_names=

6031

old_library=

6032

relink_command=

6033

# If there is no directory component, then add one.

6034

case $file in

6035

*/* | *\\*) . $file ;;

6036

*) . ./$file ;;

6037

esac

6038

6039

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

6040

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

6041

case "$current_libdirs " in

6042

*" $libdir "*) ;;

6043

*) current_libdirs="$current_libdirs $libdir" ;;

6044

esac

6045

else

6046

# Note the libdir as a future libdir.

6047

case "$future_libdirs " in

6048

*" $libdir "*) ;;

6049

*) future_libdirs="$future_libdirs $libdir" ;;

6050

esac

6051

fi

6052

6053

dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/

6054

test "X$dir" = "X$file/" && dir=

6055

dir="$dir$objdir"

6056

6057

if test -n "$relink_command"; then

6058

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

6059

inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`

6060

6061

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

6062

# location b/c this prevents finding dependent libraries that

6063

# are installed to the same prefix.

6064

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

6065

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

6066

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

6067

if test "$inst_prefix_dir" = "$destdir"; then

6068

$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2

6069

exit $EXIT_FAILURE

6070

fi

6071

6072

if test -n "$inst_prefix_dir"; then

6073

# Stick the inst_prefix_dir data into the link command.

6074

relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`

6075

else

6076

relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`

6077

fi

6078

6079

$echo "$modename: warning: relinking \`$file'" 1>&2

6080

$show "$relink_command"

6081

if $run eval "$relink_command"; then :

6082

else

6083

$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2

6084

exit $EXIT_FAILURE

6085

fi

6086

fi

6087

6088

# See the names of the shared library.

6089

set dummy $library_names

6090

if test -n "$2"; then

6091

realname="$2"

6092

shift

6093

shift

6094

6095

srcname="$realname"

6096

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

6097

6098

# Install the shared library and build the symlinks.

6099

$show "$install_prog $dir/$srcname $destdir/$realname"

6100

$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?

6101

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

6102

$show "$striplib $destdir/$realname"

6103

$run eval "$striplib $destdir/$realname" || exit $?

6104

fi

6105

6106

if test "$#" -gt 0; then

6107

# Delete the old symlinks, and create new ones.

6108

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

6109

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

6110

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

6111

for linkname

6112

do

6113

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

6114

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

6115

$run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"

6116

fi

6117

done

6118

fi

6119

6120

# Do each command in the postinstall commands.

6121

lib="$destdir/$realname"

6122

cmds=$postinstall_cmds

6123

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

6124

for cmd in $cmds; do

6125

IFS="$save_ifs"

6126

eval cmd=\"$cmd\"

6127

$show "$cmd"

6128

$run eval "$cmd" || {

6129

lt_exit=$?

6130

6131

# Restore the uninstalled library and exit

6132

if test "$mode" = relink; then

6133

$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'

6134

fi

6135

6136

exit $lt_exit

6137

}

6138

done

6139

IFS="$save_ifs"

6140

fi

6141

6142

# Install the pseudo-library for information purposes.

6143

name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6144

instname="$dir/$name"i

6145

$show "$install_prog $instname $destdir/$name"

6146

$run eval "$install_prog $instname $destdir/$name" || exit $?

6147

6148

# Maybe install the static library, too.

6149

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

6150

;;

6151

6152

*.lo)

6153

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

6154

6155

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

6156

if test -n "$destname"; then

6157

destfile="$destdir/$destname"

6158

else

6159

destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6160

destfile="$destdir/$destfile"

6161

fi

6162

6163

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

6164

case $destfile in

6165

*.lo)

6166

staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`

6167

;;

6168

*.$objext)

6169

staticdest="$destfile"

6170

destfile=

6171

;;

6172

*)

6173

$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2

6174

$echo "$help" 1>&2

6175

exit $EXIT_FAILURE

6176

;;

6177

esac

6178

6179

# Install the libtool object if requested.

6180

if test -n "$destfile"; then

6181

$show "$install_prog $file $destfile"

6182

$run eval "$install_prog $file $destfile" || exit $?

6183

fi

6184

6185

# Install the old object if enabled.

6186

if test "$build_old_libs" = yes; then

6187

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

6188

staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`

6189

6190

$show "$install_prog $staticobj $staticdest"

6191

$run eval "$install_prog \$staticobj \$staticdest" || exit $?

6192

fi

6193

exit $EXIT_SUCCESS

6194

;;

6195

6196

*)

6197

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

6198

if test -n "$destname"; then

6199

destfile="$destdir/$destname"

6200

else

6201

destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6202

destfile="$destdir/$destfile"

6203

fi

6204

6205

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

6206

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

6207

# install

6208

stripped_ext=""

6209

case $file in

6210

*.exe)

6211

if test ! -f "$file"; then

6212

file=`$echo $file|${SED} 's,.exe$,,'`

6213

stripped_ext=".exe"

6214

fi

6215

;;

6216

esac

6217

6218

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

6219

case $host in

6220

*cygwin*|*mingw*)

6221

wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`

6222

;;

6223

*)

6224

wrapper=$file

6225

;;

6226

esac

6227

if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then

6228

notinst_deplibs=

6229

relink_command=

6230

6231

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

6232

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

6233

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

6234

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

6235

#

6236

# If there is no directory component, then add one.

6237

case $wrapper in

6238

*/* | *\\*) . ${wrapper} ;;

6239

*) . ./${wrapper} ;;

6240

esac

6241

6242

# Check the variables that should have been set.

6243

if test -z "$notinst_deplibs"; then

6244

$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2

6245

exit $EXIT_FAILURE

6246

fi

6247

6248

finalize=yes

6249

for lib in $notinst_deplibs; do

6250

# Check to see that each library is installed.

6251

libdir=

6252

if test -f "$lib"; then

6253

# If there is no directory component, then add one.

6254

case $lib in

6255

*/* | *\\*) . $lib ;;

6256

*) . ./$lib ;;

6257

esac

6258

fi

6259

libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test

6260

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

6261

$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2

6262

finalize=no

6263

fi

6264

done

6265

6266

relink_command=

6267

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

6268

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

6269

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

6270

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

6271

#

6272

# If there is no directory component, then add one.

6273

case $wrapper in

6274

*/* | *\\*) . ${wrapper} ;;

6275

*) . ./${wrapper} ;;

6276

esac

6277

6278

outputname=

6279

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

6280

if test "$finalize" = yes && test -z "$run"; then

6281

tmpdir=`func_mktempdir`

6282

file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`

6283

outputname="$tmpdir/$file"

6284

# Replace the output file specification.

6285

relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`

6286

6287

$show "$relink_command"

6288

if $run eval "$relink_command"; then :

6289

else

6290

$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2

6291

${rm}r "$tmpdir"

6292

continue

6293

fi

6294

file="$outputname"

6295

else

6296

$echo "$modename: warning: cannot relink \`$file'" 1>&2

6297

fi

6298

else

6299

# Install the binary that we compiled earlier.

6300

file=`$echo "X$file$stripped_ext" | $Xsed -e "s%$[^/]*$$%$objdir/\1%"`

6301

fi

6302

fi

6303

6304

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

6305

# one anyway

6306

case $install_prog,$host in

6307

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

6308

case $file:$destfile in

6309

*.exe:*.exe)

6310

# this is ok

6311

;;

6312

*.exe:*)

6313

destfile=$destfile.exe

6314

;;

6315

*:*.exe)

6316

destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`

6317

;;

6318

esac

6319

;;

6320

esac

6321

$show "$install_prog$stripme $file $destfile"

6322

$run eval "$install_prog\$stripme \$file \$destfile" || exit $?

6323

test -n "$outputname" && ${rm}r "$tmpdir"

6324

;;

6325

esac

6326

done

6327

6328

for file in $staticlibs; do

6329

name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6330

6331

# Set up the ranlib parameters.

6332

oldlib="$destdir/$name"

6333

6334

$show "$install_prog $file $oldlib"

6335

$run eval "$install_prog \$file \$oldlib" || exit $?

6336

6337

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

6338

$show "$old_striplib $oldlib"

6339

$run eval "$old_striplib $oldlib" || exit $?

6340

fi

6341

6342

# Do each command in the postinstall commands.

6343

cmds=$old_postinstall_cmds

6344

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

6345

for cmd in $cmds; do

6346

IFS="$save_ifs"

6347

eval cmd=\"$cmd\"

6348

$show "$cmd"

6349

$run eval "$cmd" || exit $?

6350

done

6351

IFS="$save_ifs"

6352

done

6353

6354

if test -n "$future_libdirs"; then

6355

$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2

6356

fi

6357

6358

if test -n "$current_libdirs"; then

6359

# Maybe just do a dry run.

6360

test -n "$run" && current_libdirs=" -n$current_libdirs"

6361

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

6362

else

6363

exit $EXIT_SUCCESS

6364

fi

6365

;;

6366

6367

# libtool finish mode

6368

finish)

6369

modename="$modename: finish"

6370

libdirs="$nonopt"

6371

admincmds=

6372

6373

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

6374

for dir

6375

do

6376

libdirs="$libdirs $dir"

6377

done

6378

6379

for libdir in $libdirs; do

6380

if test -n "$finish_cmds"; then

6381

# Do each command in the finish commands.

6382

cmds=$finish_cmds

6383

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

6384

for cmd in $cmds; do

6385

IFS="$save_ifs"

6386

eval cmd=\"$cmd\"

6387

$show "$cmd"

6388

$run eval "$cmd" || admincmds="$admincmds

6389

$cmd"

6390

done

6391

IFS="$save_ifs"

6392

fi

6393

if test -n "$finish_eval"; then

6394

# Do the single finish_eval.

6395

eval cmds=\"$finish_eval\"

6396

$run eval "$cmds" || admincmds="$admincmds

6397

$cmds"

6398

fi

6399

done

6400

fi

6401

6402

# Exit here if they wanted silent mode.

6403

test "$show" = : && exit $EXIT_SUCCESS

6404

6405

$echo "X----------------------------------------------------------------------" | $Xsed

6406

$echo "Libraries have been installed in:"

6407

for libdir in $libdirs; do

6408

$echo " $libdir"

6409

done

6410

$echo

6411

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

6412

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

6413

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

6414

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

6415

if test -n "$shlibpath_var"; then

6416

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

6417

$echo " during execution"

6418

fi

6419

if test -n "$runpath_var"; then

6420

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

6421

$echo " during linking"

6422

fi

6423

if test -n "$hardcode_libdir_flag_spec"; then

6424

libdir=LIBDIR

6425

eval flag=\"$hardcode_libdir_flag_spec\"

6426

6427

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

6428

fi

6429

if test -n "$admincmds"; then

6430

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

6431

fi

6432

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

6433

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

6434

fi

6435

$echo

6436

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

6437

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

6438

$echo "X----------------------------------------------------------------------" | $Xsed

6439

exit $EXIT_SUCCESS

6440

;;

6441

6442

# libtool execute mode

6443

execute)

6444

modename="$modename: execute"

6445

6446

# The first argument is the command name.

6447

cmd="$nonopt"

6448

if test -z "$cmd"; then

6449

$echo "$modename: you must specify a COMMAND" 1>&2

6450

$echo "$help"

6451

exit $EXIT_FAILURE

6452

fi

6453

6454

# Handle -dlopen flags immediately.

6455

for file in $execute_dlfiles; do

6456

if test ! -f "$file"; then

6457

$echo "$modename: \`$file' is not a file" 1>&2

6458

$echo "$help" 1>&2

6459

exit $EXIT_FAILURE

6460

fi

6461

6462

dir=

6463

case $file in

6464

*.la)

6465

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

6466

if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :

6467

else

6468

$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2

6469

$echo "$help" 1>&2

6470

exit $EXIT_FAILURE

6471

fi

6472

6473

# Read the libtool library.

6474

dlname=

6475

library_names=

6476

6477

# If there is no directory component, then add one.

6478

case $file in

6479

*/* | *\\*) . $file ;;

6480

*) . ./$file ;;

6481

esac

6482

6483

# Skip this library if it cannot be dlopened.

6484

if test -z "$dlname"; then

6485

# Warn if it was a shared library.

6486

test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"

6487

continue

6488

fi

6489

6490

dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`

6491

test "X$dir" = "X$file" && dir=.

6492

6493

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

6494

dir="$dir/$objdir"

6495

else

6496

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

6497

$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2

6498

exit $EXIT_FAILURE

6499

fi

6500

fi

6501

;;

6502

6503

*.lo)

6504

# Just add the directory containing the .lo file.

6505

dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`

6506

test "X$dir" = "X$file" && dir=.

6507

;;

6508

6509

*)

6510

$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2

6511

continue

6512

;;

6513

esac

6514

6515

# Get the absolute pathname.

6516

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

6517

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

6518

6519

# Now add the directory to shlibpath_var.

6520

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

6521

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

6522

else

6523

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

6524

fi

6525

done

6526

6527

# This variable tells wrapper scripts just to set shlibpath_var

6528

# rather than running their programs.

6529

libtool_execute_magic="$magic"

6530

6531

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

6532

args=

6533

for file

6534

do

6535

case $file in

6536

-*) ;;

6537

*)

6538

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

6539

if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6540

# If there is no directory component, then add one.

6541

case $file in

6542

*/* | *\\*) . $file ;;

6543

*) . ./$file ;;

6544

esac

6545

6546

# Transform arg to wrapped name.

6547

file="$progdir/$program"

6548

fi

6549

;;

6550

esac

6551

# Quote arguments (to preserve shell metacharacters).

6552

file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`

6553

args="$args \"$file\""

6554

done

6555

6556

if test -z "$run"; then

6557

if test -n "$shlibpath_var"; then

6558

# Export the shlibpath_var.

6559

eval "export $shlibpath_var"

6560

fi

6561

6562

# Restore saved environment variables

6563

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

6564

do

6565

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

6566

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

6567

fi"

6568

done

6569

6570

# Now prepare to actually exec the command.

6571

exec_cmd="\$cmd$args"

6572

else

6573

# Display what would be done.

6574

if test -n "$shlibpath_var"; then

6575

eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""

6576

$echo "export $shlibpath_var"

6577

fi

6578

$echo "$cmd$args"

6579

exit $EXIT_SUCCESS

6580

fi

6581

;;

6582

6583

# libtool clean and uninstall mode

6584

clean | uninstall)

6585

modename="$modename: $mode"

6586

rm="$nonopt"

6587

files=

6588

rmforce=

6589

exit_status=0

6590

6591

# This variable tells wrapper scripts just to set variables rather

6592

# than running their programs.

6593

libtool_install_magic="$magic"

6594

6595

for arg

6596

do

6597

case $arg in

6598

-f) rm="$rm $arg"; rmforce=yes ;;

6599

-*) rm="$rm $arg" ;;

6600

*) files="$files $arg" ;;

6601

esac

6602

done

6603

6604

if test -z "$rm"; then

6605

$echo "$modename: you must specify an RM program" 1>&2

6606

$echo "$help" 1>&2

6607

exit $EXIT_FAILURE

6608

fi

6609

6610

rmdirs=

6611

6612

origobjdir="$objdir"

6613

for file in $files; do

6614

dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`

6615

if test "X$dir" = "X$file"; then

6616

dir=.

6617

objdir="$origobjdir"

6618

else

6619

objdir="$dir/$origobjdir"

6620

fi

6621

name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`

6622

test "$mode" = uninstall && objdir="$dir"

6623

6624

# Remember objdir for removal later, being careful to avoid duplicates

6625

if test "$mode" = clean; then

6626

case " $rmdirs " in

6627

*" $objdir "*) ;;

6628

*) rmdirs="$rmdirs $objdir" ;;

6629

esac

6630

fi

6631

6632

# Don't error if the file doesn't exist and rm -f was used.

6633

if (test -L "$file") >/dev/null 2>&1 \

6634

|| (test -h "$file") >/dev/null 2>&1 \

6635

|| test -f "$file"; then

6636

:

6637

elif test -d "$file"; then

6638

exit_status=1

6639

continue

6640

elif test "$rmforce" = yes; then

6641

continue

6642

fi

6643

6644

rmfiles="$file"

6645

6646

case $name in

6647

*.la)

6648

# Possibly a libtool archive, so verify it.

6649

if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6650

. $dir/$name

6651

6652

# Delete the libtool libraries and symlinks.

6653

for n in $library_names; do

6654

rmfiles="$rmfiles $objdir/$n"

6655

done

6656

test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

6657

6658

case "$mode" in

6659

clean)

6660

case " $library_names " in

6661

# " " in the beginning catches empty $dlname

6662

*" $dlname "*) ;;

6663

*) rmfiles="$rmfiles $objdir/$dlname" ;;

6664

esac

6665

test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

6666

;;

6667

uninstall)

6668

if test -n "$library_names"; then

6669

# Do each command in the postuninstall commands.

6670

cmds=$postuninstall_cmds

6671

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

6672

for cmd in $cmds; do

6673

IFS="$save_ifs"

6674

eval cmd=\"$cmd\"

6675

$show "$cmd"

6676

$run eval "$cmd"

6677

if test "$?" -ne 0 && test "$rmforce" != yes; then

6678

exit_status=1

6679

fi

6680

done

6681

IFS="$save_ifs"

6682

fi

6683

6684

if test -n "$old_library"; then

6685

# Do each command in the old_postuninstall commands.

6686

cmds=$old_postuninstall_cmds

6687

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

6688

for cmd in $cmds; do

6689

IFS="$save_ifs"

6690

eval cmd=\"$cmd\"

6691

$show "$cmd"

6692

$run eval "$cmd"

6693

if test "$?" -ne 0 && test "$rmforce" != yes; then

6694

exit_status=1

6695

fi

6696

done

6697

IFS="$save_ifs"

6698

fi

6699

# FIXME: should reinstall the best remaining shared library.

6700

;;

6701

esac

6702

fi

6703

;;

6704

6705

*.lo)

6706

# Possibly a libtool object, so verify it.

6707

if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6708

6709

# Read the .lo file

6710

. $dir/$name

6711

6712

# Add PIC object to the list of files to remove.

6713

if test -n "$pic_object" \

6714

&& test "$pic_object" != none; then

6715

rmfiles="$rmfiles $dir/$pic_object"

6716

fi

6717

6718

# Add non-PIC object to the list of files to remove.

6719

if test -n "$non_pic_object" \

6720

&& test "$non_pic_object" != none; then

6721

rmfiles="$rmfiles $dir/$non_pic_object"

6722

fi

6723

fi

6724

;;

6725

6726

*)

6727

if test "$mode" = clean ; then

6728

noexename=$name

6729

case $file in

6730

*.exe)

6731

file=`$echo $file|${SED} 's,.exe$,,'`

6732

noexename=`$echo $name|${SED} 's,.exe$,,'`

6733

# $file with .exe has already been added to rmfiles,

6734

# add $file without .exe

6735

rmfiles="$rmfiles $file"

6736

;;

6737

esac

6738

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

6739

if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then

6740

relink_command=

6741

. $dir/$noexename

6742

6743

# note $name still contains .exe if it was in $file originally

6744

# as does the version of $file that was added into $rmfiles

6745

rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

6746

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

6747

rmfiles="$rmfiles $objdir/lt-$name"

6748

fi

6749

if test "X$noexename" != "X$name" ; then

6750

rmfiles="$rmfiles $objdir/lt-${noexename}.c"

6751

fi

6752

fi

6753

fi

6754

;;

6755

esac

6756

$show "$rm $rmfiles"

6757

$run $rm $rmfiles || exit_status=1

6758

done

6759

objdir="$origobjdir"

6760

6761

# Try to remove the ${objdir}s in the directories where we deleted files

6762

for dir in $rmdirs; do

6763

if test -d "$dir"; then

6764

$show "rmdir $dir"

6765

$run rmdir $dir >/dev/null 2>&1

6766

fi

6767

done

6768

6769

exit $exit_status

6770

;;

6771

6772

"")

6773

$echo "$modename: you must specify a MODE" 1>&2

6774

$echo "$generic_help" 1>&2

6775

exit $EXIT_FAILURE

6776

;;

6777

esac

6778

6779

if test -z "$exec_cmd"; then

6780

$echo "$modename: invalid operation mode \`$mode'" 1>&2

6781

$echo "$generic_help" 1>&2

6782

exit $EXIT_FAILURE

6783

fi

6784

fi # test -z "$show_help"

6785

6786

if test -n "$exec_cmd"; then

6787

eval exec $exec_cmd

6788

exit $EXIT_FAILURE

6789

fi

6790

6791

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

6792

case $mode in

6793

"") $echo \

6794

"Usage: $modename [OPTION]... [MODE-ARG]...

6795

6796

Provide generalized library-building support services.

6797

6798

--config show all configuration variables

6799

--debug enable verbose shell tracing

6800

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

6801

--features display basic configuration information and exit

6802

--finish same as \`--mode=finish'

6803

--help display this help message and exit

6804

--mode=MODE use operation mode MODE [default=inferred from MODE-ARGS]

6805

--quiet same as \`--silent'

6806

--silent don't print informational messages

6807

--tag=TAG use configuration variables from tag TAG

6808

--version print version information

6809

6810

MODE must be one of the following:

6811

6812

clean remove files from the build directory

6813

compile compile a source file into a libtool object

6814

execute automatically set library path, then run a program

6815

finish complete the installation of libtool libraries

6816

install install libraries or executables

6817

link create a library or an executable

6818

uninstall remove libraries from an installed directory

6819

6820

MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for

6821

a more detailed description of MODE.

6822

6823

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

6824

exit $EXIT_SUCCESS

6825

;;

6826

6827

clean)

6828

$echo \

6829

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

6830

6831

Remove files from the build directory.

6832

6833

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

6834

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

6835

to RM.

6836

6837

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

6838

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

6839

;;

6840

6841

compile)

6842

$echo \

6843

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

6844

6845

Compile a source file into a libtool library object.

6846

6847

This mode accepts the following additional options:

6848

6849

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

6850

-prefer-pic try to building PIC objects only

6851

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

6852

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

6853

6854

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

6855

from the given SOURCEFILE.

6856

6857

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

6858

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

6859

library object suffix, \`.lo'."

6860

;;

6861

6862

execute)

6863

$echo \

6864

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

6865

6866

Automatically set library path, then run a program.

6867

6868

This mode accepts the following additional options:

6869

6870

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

6871

6872

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

6873

flags.

6874

6875

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

6876

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

6877

directories are added to the library path.

6878

6879

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

6880

;;

6881

6882

finish)

6883

$echo \

6884

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

6885

6886

Complete the installation of libtool libraries.

6887

6888

Each LIBDIR is a directory that contains libtool libraries.

6889

6890

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

6891

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

6892

;;

6893

6894

install)

6895

$echo \

6896

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

6897

6898

Install executables or libraries.

6899

6900

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

6901

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

6902

6903

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

6904

BSD-compatible install options are recognized)."

6905

;;

6906

6907

link)

6908

$echo \

6909

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

6910

6911

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

6912

create an executable program.

6913

6914

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

6915

a program from several object files.

6916

6917

The following components of LINK-COMMAND are treated specially:

6918

6919

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

6920

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

6921

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

6922

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

6923

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

6924

-export-symbols SYMFILE

6925

try to export only the symbols listed in SYMFILE

6926

-export-symbols-regex REGEX

6927

try to export only the symbols matching REGEX

6928

-LLIBDIR search LIBDIR for required installed libraries

6929

-lNAME OUTPUT-FILE requires the installed library libNAME

6930

-module build a library that can dlopened

6931

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

6932

-no-install link a not-installable executable

6933

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

6934

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

6935

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

6936

-precious-files-regex REGEX

6937

don't remove output files matching REGEX

6938

-release RELEASE specify package release information

6939

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

6940

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

6941

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

6942

-static-libtool-libs

6943

do not do any dynamic linking of libtool libraries

6944

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

6945

specify library version info [each variable defaults to 0]

6946

6947

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

6948

6949

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

6950

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

6951

object files.

6952

6953

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

6954

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

6955

required, except when creating a convenience library.

6956

6957

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

6958

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

6959

6960

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

6961

is created, otherwise an executable program is created."

6962

;;

6963

6964

uninstall)

6965

$echo \

6966

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

6967

6968

Remove libraries from an installation directory.

6969

6970

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

6971

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

6972

to RM.

6973

6974

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

6975

Otherwise, only FILE itself is deleted using RM."

6976

;;

6977

6978

*)

6979

$echo "$modename: invalid operation mode \`$mode'" 1>&2

6980

$echo "$help" 1>&2

6981

exit $EXIT_FAILURE

6982

;;

6983

esac

6984

6985

$echo

6986

$echo "Try \`$modename --help' for more information about other modes."

6987

6988

exit $?

6989

6990

# The TAGs below are defined such that we never get into a situation

6991

# in which we disable both kinds of libraries. Given conflicting

6992

# choices, we go for a static library, that is the most portable,

6993

# since we can't tell whether shared libraries were disabled because

6994

# the user asked for that or because the platform doesn't support

6995

# them. This is particularly important on AIX, because we don't

6996

# support having both static and shared libraries enabled at the same

6997

# time on that platform, so we default to a shared-only configuration.

6998

# If a disable-shared tag is given, we'll fallback to a static-only

6999

# configuration. But we'll never go from static-only to shared-only.

7000

7001

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared

7002

disable_libs=shared

7003

# ### END LIBTOOL TAG CONFIG: disable-shared

7004

7005

# ### BEGIN LIBTOOL TAG CONFIG: disable-static

7006

disable_libs=static

7007

# ### END LIBTOOL TAG CONFIG: disable-static

7008

7009

# Local Variables:

7010

# mode:shell-script

7011

# sh-indentation:2

7012

# End: