~ubuntu-branches/ubuntu/oneiric/gedit-plugins/oneiric : revision 43

1

2

# libtool (GNU libtool) 2.4

3

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

4

5

6

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

7

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

8

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

9

10

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

11

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

12

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

13

# (at your option) any later version.

14

#

15

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

16

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

17

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

18

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

19

#

20

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

21

# WITHOUT ANY WARRANTY; without even the implied warranty of

22

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

23

# General Public License for more details.

24

#

25

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

26

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

27

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

28

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

29

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

30

31

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

32

#

33

# Provide generalized library-building support services.

34

#

35

# --config show all configuration variables

36

# --debug enable verbose shell tracing

37

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

38

# --features display basic configuration information and exit

39

# --mode=MODE use operation mode MODE

40

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

41

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

42

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

43

# print informational messages (default)

44

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

45

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

46

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

47

# --version print version information

48

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

49

#

50

# MODE must be one of the following:

51

#

52

# clean remove files from the build directory

53

# compile compile a source file into a libtool object

54

# execute automatically set library path, then run a program

55

# finish complete the installation of libtool libraries

56

# install install libraries or executables

57

# link create a library or an executable

58

# uninstall remove libraries from an installed directory

59

#

60

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

61

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

62

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

63

#

64

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

65

# include the following information:

66

#

67

# host-triplet: $host

68

# shell: $SHELL

69

# compiler: $LTCC

70

# compiler flags: $LTCFLAGS

71

# linker: $LD (gnu? $with_gnu_ld)

72

# $progname: (GNU libtool) 2.4

73

# automake: $automake_version

74

# autoconf: $autoconf_version

75

#

76

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

77

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

78

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

79

80

PROGRAM=libtool

81

PACKAGE=libtool

82

VERSION=2.4

83

TIMESTAMP=""

84

package_revision=1.3293

85

86

# Be Bourne compatible

87

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

88

emulate sh

89

NULLCMD=:

90

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

91

# is contrary to our usage. Disable this feature.

92

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

93

setopt NO_GLOB_SUBST

94

else

95

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

96

fi

97

BIN_SH=xpg4; export BIN_SH # for Tru64

98

DUALCASE=1; export DUALCASE # for MKS sh

99

100

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

101

func_fallback_echo ()

102

{

103

eval 'cat <<_LTECHO_EOF

104

$1

105

_LTECHO_EOF'

106

}

107

108

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

109

lt_user_locale=

110

lt_safe_locale=

111

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

112

do

113

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

114

save_$lt_var=\$$lt_var

115

$lt_var=C

116

export $lt_var

117

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

118

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

119

fi"

120

done

121

LC_ALL=C

122

LANGUAGE=C

123

export LANGUAGE LC_ALL

124

125

$lt_unset CDPATH

126

127

128

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

129

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

130

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

131

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

132

# function.

133

progpath="$0"

134

135

136

137

: ${CP="cp -f"}

138

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

139

: ${EGREP="/bin/grep -E"}

140

: ${FGREP="/bin/grep -F"}

141

: ${GREP="/bin/grep"}

142

: ${LN_S="ln -s"}

143

: ${MAKE="make"}

144

: ${MKDIR="mkdir"}

145

: ${MV="mv -f"}

146

: ${RM="rm -f"}

147

: ${SED="/bin/sed"}

148

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

149

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

150

151

# Global variables:

152

EXIT_SUCCESS=0

153

EXIT_FAILURE=1

154

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

155

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

156

157

exit_status=$EXIT_SUCCESS

158

159

# Make sure IFS has a sensible default

160

lt_nl='

161

'

162

IFS=" $lt_nl"

163

164

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

165

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

166

167

# func_dirname file append nondir_replacement

168

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

169

# otherwise set result to NONDIR_REPLACEMENT.

170

func_dirname ()

171

{

172

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

173

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

174

func_dirname_result="${3}"

175

else

176

func_dirname_result="$func_dirname_result${2}"

177

fi

178

} # func_dirname may be replaced by extended shell implementation

179

180

181

# func_basename file

182

func_basename ()

183

{

184

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

185

} # func_basename may be replaced by extended shell implementation

186

187

188

# func_dirname_and_basename file append nondir_replacement

189

# perform func_basename and func_dirname in a single function

190

# call:

191

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

192

# add APPEND to the result, otherwise set result

193

# to NONDIR_REPLACEMENT.

194

# value returned in "$func_dirname_result"

195

# basename: Compute filename of FILE.

196

# value retuned in "$func_basename_result"

197

# Implementation must be kept synchronized with func_dirname

198

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

199

# those functions but instead duplicate the functionality here.

200

func_dirname_and_basename ()

201

{

202

# Extract subdirectory from the argument.

203

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

204

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

205

func_dirname_result="${3}"

206

else

207

func_dirname_result="$func_dirname_result${2}"

208

fi

209

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

210

} # func_dirname_and_basename may be replaced by extended shell implementation

211

212

213

# func_stripname prefix suffix name

214

# strip PREFIX and SUFFIX off of NAME.

215

# PREFIX and SUFFIX must not contain globbing or regex special

216

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

217

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

218

# func_strip_suffix prefix name

219

func_stripname ()

220

{

221

case ${2} in

222

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

223

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

224

esac

225

} # func_stripname may be replaced by extended shell implementation

226

227

228

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

229

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

230

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

231

removedotparts=':dotsl

232

s@/\./@/@g

233

t dotsl

234

s,/\.$,/,'

235

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

236

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

237

238

# func_normal_abspath PATH

239

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

240

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

241

# it an absolute path.

242

# value returned in "$func_normal_abspath_result"

243

func_normal_abspath ()

244

{

245

# Start from root dir and reassemble the path.

246

func_normal_abspath_result=

247

func_normal_abspath_tpath=$1

248

func_normal_abspath_altnamespace=

249

case $func_normal_abspath_tpath in

250

"")

251

# Empty path, that just means $cwd.

252

func_stripname '' '/' "`pwd`"

253

func_normal_abspath_result=$func_stripname_result

254

return

255

;;

256

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

257

# two leading slashes without using negated character classes;

258

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

259

///*)

260

# Unusual form of absolute path, do nothing.

261

;;

262

//*)

263

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

264

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

265

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

266

func_normal_abspath_altnamespace=/

267

;;

268

/*)

269

# Absolute path, do nothing.

270

;;

271

*)

272

# Relative path, prepend $cwd.

273

func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

274

;;

275

esac

276

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

277

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

278

# there is one (and only one) here.

279

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

280

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

281

while :; do

282

# Processed it all yet?

283

if test "$func_normal_abspath_tpath" = / ; then

284

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

285

if test -z "$func_normal_abspath_result" ; then

286

func_normal_abspath_result=/

287

fi

288

break

289

fi

290

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

291

-e "$pathcar"`

292

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

293

-e "$pathcdr"`

294

# Figure out what to do with it

295

case $func_normal_abspath_tcomponent in

296

"")

297

# Trailing empty path component, ignore it.

298

;;

299

..)

300

# Parent dir; strip last assembled component from result.

301

func_dirname "$func_normal_abspath_result"

302

func_normal_abspath_result=$func_dirname_result

303

;;

304

*)

305

# Actual path component, append it.

306

func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

307

;;

308

esac

309

done

310

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

311

func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

312

}

313

314

# func_relative_path SRCDIR DSTDIR

315

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

316

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

317

# without needing to append a separator.

318

# value returned in "$func_relative_path_result"

319

func_relative_path ()

320

{

321

func_relative_path_result=

322

func_normal_abspath "$1"

323

func_relative_path_tlibdir=$func_normal_abspath_result

324

func_normal_abspath "$2"

325

func_relative_path_tbindir=$func_normal_abspath_result

326

327

# Ascend the tree starting from libdir

328

while :; do

329

# check if we have found a prefix of bindir

330

case $func_relative_path_tbindir in

331

$func_relative_path_tlibdir)

332

# found an exact match

333

func_relative_path_tcancelled=

334

break

335

;;

336

$func_relative_path_tlibdir*)

337

# found a matching prefix

338

func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

339

func_relative_path_tcancelled=$func_stripname_result

340

if test -z "$func_relative_path_result"; then

341

func_relative_path_result=.

342

fi

343

break

344

;;

345

*)

346

func_dirname $func_relative_path_tlibdir

347

func_relative_path_tlibdir=${func_dirname_result}

348

if test "x$func_relative_path_tlibdir" = x ; then

349

# Have to descend all the way to the root!

350

func_relative_path_result=../$func_relative_path_result

351

func_relative_path_tcancelled=$func_relative_path_tbindir

352

break

353

fi

354

func_relative_path_result=../$func_relative_path_result

355

;;

356

esac

357

done

358

359

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

360

func_stripname '' '/' "$func_relative_path_result"

361

func_relative_path_result=$func_stripname_result

362

func_stripname '/' '/' "$func_relative_path_tcancelled"

363

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

364

func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

365

fi

366

367

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

368

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

369

# file name can be directly appended.

370

if test ! -z "$func_relative_path_result"; then

371

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

372

func_relative_path_result=$func_stripname_result

373

fi

374

}

375

376

# The name of this program:

377

func_dirname_and_basename "$progpath"

378

progname=$func_basename_result

379

380

# Make sure we have an absolute path for reexecution:

381

case $progpath in

382

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

383

*[\\/]*)

384

progdir=$func_dirname_result

385

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

386

progpath="$progdir/$progname"

387

;;

388

*)

389

save_IFS="$IFS"

390

IFS=:

391

for progdir in $PATH; do

392

IFS="$save_IFS"

393

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

394

done

395

IFS="$save_IFS"

396

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

397

progpath="$progdir/$progname"

398

;;

399

esac

400

401

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

402

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

403

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

404

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

405

406

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

407

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

408

409

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

410

# string literally.

411

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

412

413

# Sed substitution that converts a w32 file name or path

414

# which contains forward slashes, into one that contains

415

# (escaped) backslashes. A very naive implementation.

416

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

417

418

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

419

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

420

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

421

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

422

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

423

bs='\\'

424

bs2='\\\\'

425

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

426

dollar='\$'

427

sed_double_backslash="\

428

s/$bs4/&\\

429

/g

430

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

431

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

432

s/\n//g"

433

434

# Standard options:

435

opt_dry_run=false

436

opt_help=false

437

opt_quiet=false

438

opt_verbose=false

439

opt_warning=:

440

441

# func_echo arg...

442

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

443

# name if it has been set yet.

444

func_echo ()

445

{

446

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

447

}

448

449

# func_verbose arg...

450

# Echo program name prefixed message in verbose mode only.

451

func_verbose ()

452

{

453

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

454

455

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

456

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

457

# work around that:

458

:

459

}

460

461

# func_echo_all arg...

462

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

463

func_echo_all ()

464

{

465

$ECHO "$*"

466

}

467

468

# func_error arg...

469

# Echo program name prefixed message to standard error.

470

func_error ()

471

{

472

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

473

}

474

475

# func_warning arg...

476

# Echo program name prefixed warning message to standard error.

477

func_warning ()

478

{

479

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

480

481

# bash bug again:

482

:

483

}

484

485

# func_fatal_error arg...

486

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

487

func_fatal_error ()

488

{

489

func_error ${1+"$@"}

490

exit $EXIT_FAILURE

491

}

492

493

# func_fatal_help arg...

494

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

495

# a help hint, and exit.

496

func_fatal_help ()

497

{

498

func_error ${1+"$@"}

499

func_fatal_error "$help"

500

}

501

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

502

503

504

# func_grep expression filename

505

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

506

func_grep ()

507

{

508

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

509

}

510

511

512

# func_mkdir_p directory-path

513

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

514

func_mkdir_p ()

515

{

516

my_directory_path="$1"

517

my_dir_list=

518

519

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

520

521

# Protect directory names starting with `-'

522

case $my_directory_path in

523

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

524

esac

525

526

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

527

while test ! -d "$my_directory_path"; do

528

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

529

# list incase some portion of path contains whitespace.

530

my_dir_list="$my_directory_path:$my_dir_list"

531

532

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

533

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

534

535

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

536

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

537

done

538

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

539

540

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

541

for my_dir in $my_dir_list; do

542

IFS="$save_mkdir_p_IFS"

543

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

544

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

545

# stop in that case!

546

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

547

done

548

IFS="$save_mkdir_p_IFS"

549

550

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

551

test -d "$my_directory_path" || \

552

func_fatal_error "Failed to create \`$1'"

553

fi

554

}

555

556

557

# func_mktempdir [string]

558

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

559

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

560

# given, STRING is the basename for that directory.

561

func_mktempdir ()

562

{

563

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

564

565

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

566

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

567

my_tmpdir="${my_template}-$$"

568

else

569

570

# If mktemp works, use that first and foremost

571

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

572

573

if test ! -d "$my_tmpdir"; then

574

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

575

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

576

577

save_mktempdir_umask=`umask`

578

umask 0077

579

$MKDIR "$my_tmpdir"

580

umask $save_mktempdir_umask

581

fi

582

583

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

584

test -d "$my_tmpdir" || \

585

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

586

fi

587

588

$ECHO "$my_tmpdir"

589

}

590

591

592

# func_quote_for_eval arg

593

# Aesthetically quote ARG to be evaled later.

594

# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

595

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

596

# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

597

# which are still active within double quotes backslashified.

598

func_quote_for_eval ()

599

{

600

case $1 in

601

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

602

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

603

*)

604

func_quote_for_eval_unquoted_result="$1" ;;

605

esac

606

607

case $func_quote_for_eval_unquoted_result in

608

# Double-quote args containing shell metacharacters to delay

609

# word splitting, command substitution and and variable

610

# expansion for a subsequent eval.

611

# Many Bourne shells cannot handle close brackets correctly

612

# in scan sets, so we specify it separately.

613

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

614

func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

615

;;

616

*)

617

func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

618

esac

619

}

620

621

622

# func_quote_for_expand arg

623

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

624

# but do not quote variable references.

625

func_quote_for_expand ()

626

{

627

case $1 in

628

*[\\\`\"]*)

629

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

630

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

631

*)

632

my_arg="$1" ;;

633

esac

634

635

case $my_arg in

636

# Double-quote args containing shell metacharacters to delay

637

# word splitting and command substitution for a subsequent eval.

638

# Many Bourne shells cannot handle close brackets correctly

639

# in scan sets, so we specify it separately.

640

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

641

my_arg="\"$my_arg\""

642

;;

643

esac

644

645

func_quote_for_expand_result="$my_arg"

646

}

647

648

649

# func_show_eval cmd [fail_exp]

650

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

651

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

652

# is given, then evaluate it.

653

func_show_eval ()

654

{

655

my_cmd="$1"

656

my_fail_exp="${2-:}"

657

658

${opt_silent-false} || {

659

func_quote_for_expand "$my_cmd"

660

eval "func_echo $func_quote_for_expand_result"

661

}

662

663

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

664

eval "$my_cmd"

665

my_status=$?

666

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

667

eval "(exit $my_status); $my_fail_exp"

668

fi

669

fi

670

}

671

672

673

# func_show_eval_locale cmd [fail_exp]

674

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

675

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

676

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

677

func_show_eval_locale ()

678

{

679

my_cmd="$1"

680

my_fail_exp="${2-:}"

681

682

${opt_silent-false} || {

683

func_quote_for_expand "$my_cmd"

684

eval "func_echo $func_quote_for_expand_result"

685

}

686

687

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

688

eval "$lt_user_locale

689

$my_cmd"

690

my_status=$?

691

eval "$lt_safe_locale"

692

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

693

eval "(exit $my_status); $my_fail_exp"

694

fi

695

fi

696

}

697

698

# func_tr_sh

699

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

700

# Result is stored in $func_tr_sh_result. All characters

701

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

702

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

703

func_tr_sh ()

704

{

705

case $1 in

706

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

707

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

708

;;

709

* )

710

func_tr_sh_result=$1

711

;;

712

esac

713

}

714

715

716

# func_version

717

# Echo version message to standard output and exit.

718

func_version ()

719

{

720

$opt_debug

721

722

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

723

:more

724

/\./!{

725

N

726

s/\n# / /

727

b more

728

}

729

:go

730

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

731

s/^# //

732

s/^# *$//

733

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

734

p

735

}' < "$progpath"

736

exit $?

737

}

738

739

# func_usage

740

# Echo short help message to standard output and exit.

741

func_usage ()

742

{

743

$opt_debug

744

745

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

746

s/^# //

747

s/^# *$//

748

s/\$progname/'$progname'/

749

p

750

}' < "$progpath"

751

echo

752

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

753

exit $?

754

}

755

756

# func_help [NOEXIT]

757

# Echo long help message to standard output and exit,

758

# unless 'noexit' is passed as argument.

759

func_help ()

760

{

761

$opt_debug

762

763

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

764

:print

765

s/^# //

766

s/^# *$//

767

s*\$progname*'$progname'*

768

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

769

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

770

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

771

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

772

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

773

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

774

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

775

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

776

p

777

d

778

}

779

/^# .* home page:/b print

780

/^# General help using/b print

781

' < "$progpath"

782

ret=$?

783

if test -z "$1"; then

784

exit $ret

785

fi

786

}

787

788

# func_missing_arg argname

789

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

790

# exit_cmd.

791

func_missing_arg ()

792

{

793

$opt_debug

794

795

func_error "missing argument for $1."

796

exit_cmd=exit

797

}

798

799

800

# func_split_short_opt shortopt

801

# Set func_split_short_opt_name and func_split_short_opt_arg shell

802

# variables after splitting SHORTOPT after the 2nd character.

803

func_split_short_opt ()

804

{

805

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

806

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

807

808

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

809

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

810

} # func_split_short_opt may be replaced by extended shell implementation

811

812

813

# func_split_long_opt longopt

814

# Set func_split_long_opt_name and func_split_long_opt_arg shell

815

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

816

func_split_long_opt ()

817

{

818

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

819

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

820

821

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

822

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

823

} # func_split_long_opt may be replaced by extended shell implementation

824

825

exit_cmd=:

826

827

828

829

830

831

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

832

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

833

834

# Global variables.

835

nonopt=

836

preserve_args=

837

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

838

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

839

extracted_archives=

840

extracted_serial=0

841

842

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

843

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

844

# left over by shells.

845

exec_cmd=

846

847

# func_append var value

848

# Append VALUE to the end of shell variable VAR.

849

func_append ()

850

{

851

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

852

} # func_append may be replaced by extended shell implementation

853

854

# func_append_quoted var value

855

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

856

# by a space.

857

func_append_quoted ()

858

{

859

func_quote_for_eval "${2}"

860

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

861

} # func_append_quoted may be replaced by extended shell implementation

862

863

864

# func_arith arithmetic-term...

865

func_arith ()

866

{

867

func_arith_result=`expr "${@}"`

868

} # func_arith may be replaced by extended shell implementation

869

870

871

# func_len string

872

# STRING may not start with a hyphen.

873

func_len ()

874

{

875

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

876

} # func_len may be replaced by extended shell implementation

877

878

879

# func_lo2o object

880

func_lo2o ()

881

{

882

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

883

} # func_lo2o may be replaced by extended shell implementation

884

885

886

# func_xform libobj-or-source

887

func_xform ()

888

{

889

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

890

} # func_xform may be replaced by extended shell implementation

891

892

893

# func_fatal_configuration arg...

894

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

895

# a configuration failure hint, and exit.

896

func_fatal_configuration ()

897

{

898

func_error ${1+"$@"}

899

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

900

func_fatal_error "Fatal configuration error."

901

}

902

903

904

# func_config

905

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

906

func_config ()

907

{

908

re_begincf='^# ### BEGIN LIBTOOL'

909

re_endcf='^# ### END LIBTOOL'

910

911

# Default configuration.

912

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

913

914

# Now print the configurations for the tags.

915

for tagname in $taglist; do

916

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

917

done

918

919

exit $?

920

}

921

922

# func_features

923

# Display the features supported by this script.

924

func_features ()

925

{

926

echo "host: $host"

927

if test "$build_libtool_libs" = yes; then

928

echo "enable shared libraries"

929

else

930

echo "disable shared libraries"

931

fi

932

if test "$build_old_libs" = yes; then

933

echo "enable static libraries"

934

else

935

echo "disable static libraries"

936

fi

937

938

exit $?

939

}

940

941

# func_enable_tag tagname

942

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

943

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

944

# variable here.

945

func_enable_tag ()

946

{

947

# Global variable:

948

tagname="$1"

949

950

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

951

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

952

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

953

954

# Validate tagname.

955

case $tagname in

956

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

957

func_fatal_error "invalid tag name: $tagname"

958

;;

959

esac

960

961

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

962

# there but not specially marked.

963

case $tagname in

964

CC) ;;

965

*)

966

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

967

taglist="$taglist $tagname"

968

969

# Evaluate the configuration. Be careful to quote the path

970

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

971

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

972

# quotes we have to do it in 2 steps:

973

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

974

eval "$extractedcf"

975

else

976

func_error "ignoring unknown tag $tagname"

977

fi

978

;;

979

esac

980

}

981

982

# func_check_version_match

983

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

984

# release of libtool.

985

func_check_version_match ()

986

{

987

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

988

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

989

if test -z "$macro_version"; then

990

cat >&2 <<_LT_EOF

991

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

992

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

993

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

994

$progname: and run autoconf again.

995

_LT_EOF

996

else

997

cat >&2 <<_LT_EOF

998

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

999

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

1000

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

1001

$progname: and run autoconf again.

1002

_LT_EOF

1003

fi

1004

else

1005

cat >&2 <<_LT_EOF

1006

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

1007

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

1008

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

1009

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

1010

_LT_EOF

1011

fi

1012

1013

exit $EXIT_MISMATCH

1014

fi

1015

}

1016

1017

1018

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

1019

case $1 in

1020

clean|clea|cle|cl)

1021

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

1022

;;

1023

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

1024

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

1025

;;

1026

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

1027

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

1028

;;

1029

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

1030

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

1031

;;

1032

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

1033

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

1034

;;

1035

link|lin|li|l)

1036

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

1037

;;

1038

1039

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

1040

;;

1041

esac

1042

1043

1044

1045

# Option defaults:

1046

opt_debug=:

1047

opt_dry_run=false

1048

opt_config=false

1049

opt_preserve_dup_deps=false

1050

opt_features=false

1051

opt_finish=false

1052

opt_help=false

1053

opt_help_all=false

1054

opt_silent=:

1055

opt_verbose=:

1056

opt_silent=false

1057

opt_verbose=false

1058

1059

1060

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

1061

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

1062

{

1063

# this just eases exit handling

1064

while test $# -gt 0; do

1065

opt="$1"

1066

shift

1067

case $opt in

1068

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

1069

func_echo "enabling shell trace mode"

1070

$opt_debug

1071

;;

1072

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

1073

opt_dry_run=:

1074

;;

1075

--config)

1076

opt_config=:

1077

func_config

1078

;;

1079

--dlopen|-dlopen)

1080

optarg="$1"

1081

opt_dlopen="${opt_dlopen+$opt_dlopen

1082

}$optarg"

1083

shift

1084

;;

1085

--preserve-dup-deps)

1086

opt_preserve_dup_deps=:

1087

;;

1088

--features)

1089

opt_features=:

1090

func_features

1091

;;

1092

--finish)

1093

opt_finish=:

1094

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

1095

;;

1096

--help)

1097

opt_help=:

1098

;;

1099

--help-all)

1100

opt_help_all=:

1101

opt_help=': help-all'

1102

;;

1103

--mode)

1104

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

1105

optarg="$1"

1106

opt_mode="$optarg"

1107

case $optarg in

1108

# Valid mode arguments:

1109

1110

1111

# Catch anything else as an error

1112

*) func_error "invalid argument for $opt"

1113

exit_cmd=exit

1114

break

1115

;;

1116

esac

1117

shift

1118

;;

1119

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

1120

opt_silent=false

1121

func_append preserve_args " $opt"

1122

;;

1123

--no-verbose)

1124

opt_verbose=false

1125

func_append preserve_args " $opt"

1126

;;

1127

--silent|--quiet)

1128

opt_silent=:

1129

func_append preserve_args " $opt"

1130

opt_verbose=false

1131

;;

1132

--verbose|-v)

1133

opt_verbose=:

1134

func_append preserve_args " $opt"

1135

opt_silent=false

1136

;;

1137

--tag)

1138

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

1139

optarg="$1"

1140

opt_tag="$optarg"

1141

func_append preserve_args " $opt $optarg"

1142

func_enable_tag "$optarg"

1143

shift

1144

;;

1145

1146

-\?|-h) func_usage ;;

1147

--help) func_help ;;

1148

--version) func_version ;;

1149

1150

# Separate optargs to long options:

1151

--*=*)

1152

func_split_long_opt "$opt"

1153

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

1154

shift

1155

;;

1156

1157

# Separate non-argument short options:

1158

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

1159

func_split_short_opt "$opt"

1160

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

1161

shift

1162

;;

1163

1164

--) break ;;

1165

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

1166

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

1167

esac

1168

done

1169

1170

# Validate options:

1171

1172

# save first non-option argument

1173

if test "$#" -gt 0; then

1174

nonopt="$opt"

1175

shift

1176

fi

1177

1178

# preserve --debug

1179

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

1180

1181

case $host in

1182

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

1183

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

1184

opt_duplicate_compiler_generated_deps=:

1185

;;

1186

*)

1187

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

1188

;;

1189

esac

1190

1191

$opt_help || {

1192

# Sanity checks first:

1193

func_check_version_match

1194

1195

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

1196

func_fatal_configuration "not configured to build any kind of library"

1197

fi

1198

1199

# Darwin sucks

1200

eval std_shrext=\"$shrext_cmds\"

1201

1202

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

1203

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

1204

func_error "unrecognized option \`-dlopen'"

1205

$ECHO "$help" 1>&2

1206

exit $EXIT_FAILURE

1207

fi

1208

1209

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

1210

generic_help="$help"

1211

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

1212

}

1213

1214

1215

# Bail if the options were screwed

1216

$exit_cmd $EXIT_FAILURE

1217

}

1218

1219

1220

1221

1222

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

1223

## Main. ##

1224

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

1225

1226

# func_lalib_p file

1227

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

1228

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

1229

# determined imposters.

1230

func_lalib_p ()

1231

{

1232

test -f "$1" &&

1233

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

1234

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

1235

}

1236

1237

# func_lalib_unsafe_p file

1238

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

1239

# This function implements the same check as func_lalib_p without

1240

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

1241

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

1242

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

1243

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

1244

func_lalib_unsafe_p ()

1245

{

1246

lalib_p=no

1247

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

1248

for lalib_p_l in 1 2 3 4

1249

do

1250

read lalib_p_line

1251

case "$lalib_p_line" in

1252

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

1253

esac

1254

done

1255

exec 0<&5 5<&-

1256

fi

1257

test "$lalib_p" = yes

1258

}

1259

1260

# func_ltwrapper_script_p file

1261

# True iff FILE is a libtool wrapper script

1262

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

1263

# determined imposters.

1264

func_ltwrapper_script_p ()

1265

{

1266

func_lalib_p "$1"

1267

}

1268

1269

# func_ltwrapper_executable_p file

1270

# True iff FILE is a libtool wrapper executable

1271

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

1272

# determined imposters.

1273

func_ltwrapper_executable_p ()

1274

{

1275

func_ltwrapper_exec_suffix=

1276

case $1 in

1277

*.exe) ;;

1278

*) func_ltwrapper_exec_suffix=.exe ;;

1279

esac

1280

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

1281

}

1282

1283

# func_ltwrapper_scriptname file

1284

# Assumes file is an ltwrapper_executable

1285

# uses $file to determine the appropriate filename for a

1286

# temporary ltwrapper_script.

1287

func_ltwrapper_scriptname ()

1288

{

1289

func_dirname_and_basename "$1" "" "."

1290

func_stripname '' '.exe' "$func_basename_result"

1291

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

1292

}

1293

1294

# func_ltwrapper_p file

1295

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

1296

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

1297

# determined imposters.

1298

func_ltwrapper_p ()

1299

{

1300

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

1301

}

1302

1303

1304

# func_execute_cmds commands fail_cmd

1305

# Execute tilde-delimited COMMANDS.

1306

# If FAIL_CMD is given, eval that upon failure.

1307

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

1308

func_execute_cmds ()

1309

{

1310

$opt_debug

1311

save_ifs=$IFS; IFS='~'

1312

for cmd in $1; do

1313

IFS=$save_ifs

1314

eval cmd=\"$cmd\"

1315

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

1316

done

1317

IFS=$save_ifs

1318

}

1319

1320

1321

# func_source file

1322

# Source FILE, adding directory component if necessary.

1323

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

1324

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

1325

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

1326

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

1327

func_source ()

1328

{

1329

$opt_debug

1330

case $1 in

1331

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

1332

*) . "./$1" ;;

1333

esac

1334

}

1335

1336

1337

# func_resolve_sysroot PATH

1338

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

1339

# func_resolve_sysroot_result

1340

func_resolve_sysroot ()

1341

{

1342

func_resolve_sysroot_result=$1

1343

case $func_resolve_sysroot_result in

1344

=*)

1345

func_stripname '=' '' "$func_resolve_sysroot_result"

1346

func_resolve_sysroot_result=$lt_sysroot$func_stripname_result

1347

;;

1348

esac

1349

}

1350

1351

# func_replace_sysroot PATH

1352

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

1353

# store the result into func_replace_sysroot_result.

1354

func_replace_sysroot ()

1355

{

1356

case "$lt_sysroot:$1" in

1357

?*:"$lt_sysroot"*)

1358

func_stripname "$lt_sysroot" '' "$1"

1359

func_replace_sysroot_result="=$func_stripname_result"

1360

;;

1361

*)

1362

# Including no sysroot.

1363

func_replace_sysroot_result=$1

1364

;;

1365

esac

1366

}

1367

1368

# func_infer_tag arg

1369

# Infer tagged configuration to use if any are available and

1370

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

1371

# Only attempt this if the compiler in the base compile

1372

# command doesn't match the default compiler.

1373

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

1374

func_infer_tag ()

1375

{

1376

$opt_debug

1377

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

1378

CC_quoted=

1379

for arg in $CC; do

1380

func_append_quoted CC_quoted "$arg"

1381

done

1382

CC_expanded=`func_echo_all $CC`

1383

CC_quoted_expanded=`func_echo_all $CC_quoted`

1384

case $@ in

1385

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

1386

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

1387

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

1388

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

1389

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

1390

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

1391

*)

1392

for z in $available_tags; do

1393

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

1394

# Evaluate the configuration.

1395

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

1396

CC_quoted=

1397

for arg in $CC; do

1398

# Double-quote args containing other shell metacharacters.

1399

func_append_quoted CC_quoted "$arg"

1400

done

1401

CC_expanded=`func_echo_all $CC`

1402

CC_quoted_expanded=`func_echo_all $CC_quoted`

1403

case "$@ " in

1404

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

1405

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

1406

# The compiler in the base compile command matches

1407

# the one in the tagged configuration.

1408

# Assume this is the tagged configuration we want.

1409

tagname=$z

1410

break

1411

;;

1412

esac

1413

fi

1414

done

1415

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

1416

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

1417

# line option must be used.

1418

if test -z "$tagname"; then

1419

func_echo "unable to infer tagged configuration"

1420

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

1421

# else

1422

# func_verbose "using $tagname tagged configuration"

1423

fi

1424

;;

1425

esac

1426

fi

1427

}

1428

1429

1430

1431

# func_write_libtool_object output_name pic_name nonpic_name

1432

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

1433

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

1434

func_write_libtool_object ()

1435

{

1436

write_libobj=${1}

1437

if test "$build_libtool_libs" = yes; then

1438

write_lobj=\'${2}\'

1439

else

1440

write_lobj=none

1441

fi

1442

1443

if test "$build_old_libs" = yes; then

1444

write_oldobj=\'${3}\'

1445

else

1446

write_oldobj=none

1447

fi

1448

1449

$opt_dry_run || {

1450

cat >${write_libobj}T <<EOF

1451

# $write_libobj - a libtool object file

1452

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

1453

#

1454

# Please DO NOT delete this file!

1455

# It is necessary for linking the library.

1456

1457

# Name of the PIC object.

1458

pic_object=$write_lobj

1459

1460

# Name of the non-PIC object

1461

non_pic_object=$write_oldobj

1462

1463

EOF

1464

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

1465

}

1466

}

1467

1468

1469

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

1470

# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #

1471

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

1472

1473

# func_convert_core_file_wine_to_w32 ARG

1474

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

1475

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

1476

# correctly configured wine environment available, with the winepath program

1477

# in $build's $PATH.

1478

#

1479

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

1480

# Result is available in $func_convert_core_file_wine_to_w32_result, and will

1481

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

1482

func_convert_core_file_wine_to_w32 ()

1483

{

1484

$opt_debug

1485

func_convert_core_file_wine_to_w32_result="$1"

1486

if test -n "$1"; then

1487

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

1488

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

1489

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

1490

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

1491

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

1492

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

1493

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

1494

func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |

1495

$SED -e "$lt_sed_naive_backslashify"`

1496

else

1497

func_convert_core_file_wine_to_w32_result=

1498

fi

1499

fi

1500

}

1501

# end: func_convert_core_file_wine_to_w32

1502

1503

1504

# func_convert_core_path_wine_to_w32 ARG

1505

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

1506

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

1507

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

1508

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

1509

#

1510

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

1511

# Result is available in $func_convert_core_path_wine_to_w32_result.

1512

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

1513

# are convertible, then the result may be empty.

1514

func_convert_core_path_wine_to_w32 ()

1515

{

1516

$opt_debug

1517

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

1518

func_convert_core_path_wine_to_w32_result=""

1519

if test -n "$1"; then

1520

oldIFS=$IFS

1521

IFS=:

1522

for func_convert_core_path_wine_to_w32_f in $1; do

1523

IFS=$oldIFS

1524

func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"

1525

if test -n "$func_convert_core_file_wine_to_w32_result" ; then

1526

if test -z "$func_convert_core_path_wine_to_w32_result"; then

1527

func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"

1528

else

1529

func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"

1530

fi

1531

fi

1532

done

1533

IFS=$oldIFS

1534

fi

1535

}

1536

# end: func_convert_core_path_wine_to_w32

1537

1538

1539

# func_cygpath ARGS...

1540

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

1541

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

1542

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

1543

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

1544

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

1545

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

1546

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

1547

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

1548

#

1549

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

1550

# be converted.

1551

#

1552

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

1553

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

1554

func_cygpath ()

1555

{

1556

$opt_debug

1557

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

1558

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

1559

if test "$?" -ne 0; then

1560

# on failure, ensure result is empty

1561

func_cygpath_result=

1562

fi

1563

else

1564

func_cygpath_result=

1565

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

1566

fi

1567

}

1568

#end: func_cygpath

1569

1570

1571

# func_convert_core_msys_to_w32 ARG

1572

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

1573

# result in func_convert_core_msys_to_w32_result.

1574

func_convert_core_msys_to_w32 ()

1575

{

1576

$opt_debug

1577

# awkward: cmd appends spaces to result

1578

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

1579

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

1580

}

1581

#end: func_convert_core_msys_to_w32

1582

1583

1584

# func_convert_file_check ARG1 ARG2

1585

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

1586

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

1587

# func_to_host_file_result to ARG1).

1588

func_convert_file_check ()

1589

{

1590

$opt_debug

1591

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

1592

func_error "Could not determine host file name corresponding to"

1593

func_error " \`$1'"

1594

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

1595

# Fallback:

1596

func_to_host_file_result="$1"

1597

fi

1598

}

1599

# end func_convert_file_check

1600

1601

1602

# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH

1603

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

1604

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

1605

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

1606

func_convert_path_check ()

1607

{

1608

$opt_debug

1609

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

1610

func_error "Could not determine the host path corresponding to"

1611

func_error " \`$3'"

1612

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

1613

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

1614

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

1615

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

1616

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

1617

func_to_host_path_result=`echo "$3" |

1618

$SED -e "$lt_replace_pathsep_chars"`

1619

else

1620

func_to_host_path_result="$3"

1621

fi

1622

fi

1623

}

1624

# end func_convert_path_check

1625

1626

1627

# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG

1628

# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT

1629

# and appending REPL if ORIG matches BACKPAT.

1630

func_convert_path_front_back_pathsep ()

1631

{

1632

$opt_debug

1633

case $4 in

1634

$1 ) func_to_host_path_result="$3$func_to_host_path_result"

1635

;;

1636

esac

1637

case $4 in

1638

$2 ) func_append func_to_host_path_result "$3"

1639

;;

1640

esac

1641

}

1642

# end func_convert_path_front_back_pathsep

1643

1644

1645

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

1646

# $build to $host FILE NAME CONVERSION FUNCTIONS #

1647

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

1648

# invoked via `$to_host_file_cmd ARG'

1649

#

1650

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

1651

# Result will be available in $func_to_host_file_result.

1652

1653

1654

# func_to_host_file ARG

1655

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

1656

# in func_to_host_file_result.

1657

func_to_host_file ()

1658

{

1659

$opt_debug

1660

$to_host_file_cmd "$1"

1661

}

1662

# end func_to_host_file

1663

1664

1665

# func_to_tool_file ARG LAZY

1666

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

1667

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

1668

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

1669

func_to_tool_file ()

1670

{

1671

$opt_debug

1672

case ,$2, in

1673

*,"$to_tool_file_cmd",*)

1674

func_to_tool_file_result=$1

1675

;;

1676

*)

1677

$to_tool_file_cmd "$1"

1678

func_to_tool_file_result=$func_to_host_file_result

1679

;;

1680

esac

1681

}

1682

# end func_to_tool_file

1683

1684

1685

# func_convert_file_noop ARG

1686

# Copy ARG to func_to_host_file_result.

1687

func_convert_file_noop ()

1688

{

1689

func_to_host_file_result="$1"

1690

}

1691

# end func_convert_file_noop

1692

1693

1694

# func_convert_file_msys_to_w32 ARG

1695

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

1696

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

1697

# func_to_host_file_result.

1698

func_convert_file_msys_to_w32 ()

1699

{

1700

$opt_debug

1701

func_to_host_file_result="$1"

1702

if test -n "$1"; then

1703

func_convert_core_msys_to_w32 "$1"

1704

func_to_host_file_result="$func_convert_core_msys_to_w32_result"

1705

fi

1706

func_convert_file_check "$1" "$func_to_host_file_result"

1707

}

1708

# end func_convert_file_msys_to_w32

1709

1710

1711

# func_convert_file_cygwin_to_w32 ARG

1712

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

1713

# func_to_host_file_result.

1714

func_convert_file_cygwin_to_w32 ()

1715

{

1716

$opt_debug

1717

func_to_host_file_result="$1"

1718

if test -n "$1"; then

1719

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

1720

# LT_CYGPATH in this case.

1721

func_to_host_file_result=`cygpath -m "$1"`

1722

fi

1723

func_convert_file_check "$1" "$func_to_host_file_result"

1724

}

1725

# end func_convert_file_cygwin_to_w32

1726

1727

1728

# func_convert_file_nix_to_w32 ARG

1729

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

1730

# and a working winepath. Returns result in func_to_host_file_result.

1731

func_convert_file_nix_to_w32 ()

1732

{

1733

$opt_debug

1734

func_to_host_file_result="$1"

1735

if test -n "$1"; then

1736

func_convert_core_file_wine_to_w32 "$1"

1737

func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

1738

fi

1739

func_convert_file_check "$1" "$func_to_host_file_result"

1740

}

1741

# end func_convert_file_nix_to_w32

1742

1743

1744

# func_convert_file_msys_to_cygwin ARG

1745

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

1746

# Returns result in func_to_host_file_result.

1747

func_convert_file_msys_to_cygwin ()

1748

{

1749

$opt_debug

1750

func_to_host_file_result="$1"

1751

if test -n "$1"; then

1752

func_convert_core_msys_to_w32 "$1"

1753

func_cygpath -u "$func_convert_core_msys_to_w32_result"

1754

func_to_host_file_result="$func_cygpath_result"

1755

fi

1756

func_convert_file_check "$1" "$func_to_host_file_result"

1757

}

1758

# end func_convert_file_msys_to_cygwin

1759

1760

1761

# func_convert_file_nix_to_cygwin ARG

1762

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

1763

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

1764

# in func_to_host_file_result.

1765

func_convert_file_nix_to_cygwin ()

1766

{

1767

$opt_debug

1768

func_to_host_file_result="$1"

1769

if test -n "$1"; then

1770

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

1771

func_convert_core_file_wine_to_w32 "$1"

1772

func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

1773

func_to_host_file_result="$func_cygpath_result"

1774

fi

1775

func_convert_file_check "$1" "$func_to_host_file_result"

1776

}

1777

# end func_convert_file_nix_to_cygwin

1778

1779

1780

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

1781

# $build to $host PATH CONVERSION FUNCTIONS #

1782

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

1783

# invoked via `$to_host_path_cmd ARG'

1784

#

1785

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

1786

# The result will be available in $func_to_host_path_result.

1787

#

1788

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

1789

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

1790

# converted to $host format) on output.

1791

#

1792

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

1793

# file name conversion function : func_convert_file_X_to_Y ()

1794

# path conversion function : func_convert_path_X_to_Y ()

1795

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

1796

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

1797

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

1798

# will break.

1799

1800

1801

# func_init_to_host_path_cmd

1802

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

1803

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

1804

to_host_path_cmd=

1805

func_init_to_host_path_cmd ()

1806

{

1807

$opt_debug

1808

if test -z "$to_host_path_cmd"; then

1809

func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

1810

to_host_path_cmd="func_convert_path_${func_stripname_result}"

1811

fi

1812

}

1813

1814

1815

# func_to_host_path ARG

1816

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

1817

# in func_to_host_path_result.

1818

func_to_host_path ()

1819

{

1820

$opt_debug

1821

func_init_to_host_path_cmd

1822

$to_host_path_cmd "$1"

1823

}

1824

# end func_to_host_path

1825

1826

1827

# func_convert_path_noop ARG

1828

# Copy ARG to func_to_host_path_result.

1829

func_convert_path_noop ()

1830

{

1831

func_to_host_path_result="$1"

1832

}

1833

# end func_convert_path_noop

1834

1835

1836

# func_convert_path_msys_to_w32 ARG

1837

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

1838

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

1839

# func_to_host_path_result.

1840

func_convert_path_msys_to_w32 ()

1841

{

1842

$opt_debug

1843

func_to_host_path_result="$1"

1844

if test -n "$1"; then

1845

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

1846

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

1847

# and winepath ignores them completely.

1848

func_stripname : : "$1"

1849

func_to_host_path_tmp1=$func_stripname_result

1850

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1851

func_to_host_path_result="$func_convert_core_msys_to_w32_result"

1852

func_convert_path_check : ";" \

1853

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1854

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

1855

fi

1856

}

1857

# end func_convert_path_msys_to_w32

1858

1859

1860

# func_convert_path_cygwin_to_w32 ARG

1861

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

1862

# func_to_host_file_result.

1863

func_convert_path_cygwin_to_w32 ()

1864

{

1865

$opt_debug

1866

func_to_host_path_result="$1"

1867

if test -n "$1"; then

1868

# See func_convert_path_msys_to_w32:

1869

func_stripname : : "$1"

1870

func_to_host_path_tmp1=$func_stripname_result

1871

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

1872

func_convert_path_check : ";" \

1873

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1874

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

1875

fi

1876

}

1877

# end func_convert_path_cygwin_to_w32

1878

1879

1880

# func_convert_path_nix_to_w32 ARG

1881

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

1882

# a working winepath. Returns result in func_to_host_file_result.

1883

func_convert_path_nix_to_w32 ()

1884

{

1885

$opt_debug

1886

func_to_host_path_result="$1"

1887

if test -n "$1"; then

1888

# See func_convert_path_msys_to_w32:

1889

func_stripname : : "$1"

1890

func_to_host_path_tmp1=$func_stripname_result

1891

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1892

func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

1893

func_convert_path_check : ";" \

1894

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1895

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

1896

fi

1897

}

1898

# end func_convert_path_nix_to_w32

1899

1900

1901

# func_convert_path_msys_to_cygwin ARG

1902

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

1903

# Returns result in func_to_host_file_result.

1904

func_convert_path_msys_to_cygwin ()

1905

{

1906

$opt_debug

1907

func_to_host_path_result="$1"

1908

if test -n "$1"; then

1909

# See func_convert_path_msys_to_w32:

1910

func_stripname : : "$1"

1911

func_to_host_path_tmp1=$func_stripname_result

1912

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1913

func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

1914

func_to_host_path_result="$func_cygpath_result"

1915

func_convert_path_check : : \

1916

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1917

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

1918

fi

1919

}

1920

# end func_convert_path_msys_to_cygwin

1921

1922

1923

# func_convert_path_nix_to_cygwin ARG

1924

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

1925

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

1926

# func_to_host_file_result.

1927

func_convert_path_nix_to_cygwin ()

1928

{

1929

$opt_debug

1930

func_to_host_path_result="$1"

1931

if test -n "$1"; then

1932

# Remove leading and trailing path separator characters from

1933

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

1934

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

1935

func_stripname : : "$1"

1936

func_to_host_path_tmp1=$func_stripname_result

1937

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1938

func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

1939

func_to_host_path_result="$func_cygpath_result"

1940

func_convert_path_check : : \

1941

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1942

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

1943

fi

1944

}

1945

# end func_convert_path_nix_to_cygwin

1946

1947

1948

# func_mode_compile arg...

1949

func_mode_compile ()

1950

{

1951

$opt_debug

1952

# Get the compilation command and the source file.

1953

base_compile=

1954

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

1955

suppress_opt=yes

1956

suppress_output=

1957

arg_mode=normal

1958

libobj=

1959

later=

1960

pie_flag=

1961

1962

for arg

1963

do

1964

case $arg_mode in

1965

arg )

1966

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

1967

lastarg="$arg"

1968

arg_mode=normal

1969

;;

1970

1971

target )

1972

libobj="$arg"

1973

arg_mode=normal

1974

continue

1975

;;

1976

1977

normal )

1978

# Accept any command-line options.

1979

case $arg in

1980

-o)

1981

test -n "$libobj" && \

1982

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

1983

arg_mode=target

1984

continue

1985

;;

1986

1987

-pie | -fpie | -fPIE)

1988

func_append pie_flag " $arg"

1989

continue

1990

;;

1991

1992

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

1993

func_append later " $arg"

1994

continue

1995

;;

1996

1997

-no-suppress)

1998

suppress_opt=no

1999

continue

2000

;;

2001

2002

-Xcompiler)

2003

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

2004

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

2005

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

2006

2007

-Wc,*)

2008

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

2009

args=$func_stripname_result

2010

lastarg=

2011

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

2012

for arg in $args; do

2013

IFS="$save_ifs"

2014

func_append_quoted lastarg "$arg"

2015

done

2016

IFS="$save_ifs"

2017

func_stripname ' ' '' "$lastarg"

2018

lastarg=$func_stripname_result

2019

2020

# Add the arguments to base_compile.

2021

func_append base_compile " $lastarg"

2022

continue

2023

;;

2024

2025

*)

2026

# Accept the current argument as the source file.

2027

# The previous "srcfile" becomes the current argument.

2028

#

2029

lastarg="$srcfile"

2030

srcfile="$arg"

2031

;;

2032

esac # case $arg

2033

;;

2034

esac # case $arg_mode

2035

2036

# Aesthetically quote the previous argument.

2037

func_append_quoted base_compile "$lastarg"

2038

done # for arg

2039

2040

case $arg_mode in

2041

arg)

2042

func_fatal_error "you must specify an argument for -Xcompile"

2043

;;

2044

target)

2045

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

2046

;;

2047

*)

2048

# Get the name of the library object.

2049

test -z "$libobj" && {

2050

func_basename "$srcfile"

2051

libobj="$func_basename_result"

2052

}

2053

;;

2054

esac

2055

2056

# Recognize several different file suffixes.

2057

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

2058

case $libobj in

2059

*.[cCFSifmso] | \

2060

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

2061

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

2062

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

2063

func_xform "$libobj"

2064

libobj=$func_xform_result

2065

;;

2066

esac

2067

2068

case $libobj in

2069

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

2070

*)

2071

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

2072

;;

2073

esac

2074

2075

func_infer_tag $base_compile

2076

2077

for arg in $later; do

2078

case $arg in

2079

-shared)

2080

test "$build_libtool_libs" != yes && \

2081

func_fatal_configuration "can not build a shared library"

2082

build_old_libs=no

2083

continue

2084

;;

2085

2086

-static)

2087

build_libtool_libs=no

2088

build_old_libs=yes

2089

continue

2090

;;

2091

2092

-prefer-pic)

2093

pic_mode=yes

2094

continue

2095

;;

2096

2097

-prefer-non-pic)

2098

pic_mode=no

2099

continue

2100

;;

2101

esac

2102

done

2103

2104

func_quote_for_eval "$libobj"

2105

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

2106

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

2107

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

2108

func_dirname_and_basename "$obj" "/" ""

2109

objname="$func_basename_result"

2110

xdir="$func_dirname_result"

2111

lobj=${xdir}$objdir/$objname

2112

2113

test -z "$base_compile" && \

2114

func_fatal_help "you must specify a compilation command"

2115

2116

# Delete any leftover library objects.

2117

if test "$build_old_libs" = yes; then

2118

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

2119

else

2120

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

2121

fi

2122

2123

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

2124

case $host_os in

2125

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

2126

pic_mode=default

2127

;;

2128

esac

2129

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

2130

# non-PIC code in shared libraries is not supported

2131

pic_mode=default

2132

fi

2133

2134

# Calculate the filename of the output object if compiler does

2135

# not support -o with -c

2136

if test "$compiler_c_o" = no; then

2137

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

2138

lockfile="$output_obj.lock"

2139

else

2140

output_obj=

2141

need_locks=no

2142

lockfile=

2143

fi

2144

2145

# Lock this critical section if it is needed

2146

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

2147

if test "$need_locks" = yes; then

2148

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

2149

func_echo "Waiting for $lockfile to be removed"

2150

sleep 2

2151

done

2152

elif test "$need_locks" = warn; then

2153

if test -f "$lockfile"; then

2154

$ECHO "\

2155

*** ERROR, $lockfile exists and contains:

2156

`cat $lockfile 2>/dev/null`

2157

2158

This indicates that another process is trying to use the same

2159

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

2160

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

2161

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

2162

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

2163

compiler."

2164

2165

$opt_dry_run || $RM $removelist

2166

exit $EXIT_FAILURE

2167

fi

2168

func_append removelist " $output_obj"

2169

$ECHO "$srcfile" > "$lockfile"

2170

fi

2171

2172

$opt_dry_run || $RM $removelist

2173

func_append removelist " $lockfile"

2174

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

2175

2176

func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2177

srcfile=$func_to_tool_file_result

2178

func_quote_for_eval "$srcfile"

2179

qsrcfile=$func_quote_for_eval_result

2180

2181

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

2182

if test "$build_libtool_libs" = yes; then

2183

# Without this assignment, base_compile gets emptied.

2184

fbsd_hideous_sh_bug=$base_compile

2185

2186

if test "$pic_mode" != no; then

2187

command="$base_compile $qsrcfile $pic_flag"

2188

else

2189

# Don't build PIC code

2190

command="$base_compile $qsrcfile"

2191

fi

2192

2193

func_mkdir_p "$xdir$objdir"

2194

2195

if test -z "$output_obj"; then

2196

# Place PIC objects in $objdir

2197

func_append command " -o $lobj"

2198

fi

2199

2200

func_show_eval_locale "$command" \

2201

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

2202

2203

if test "$need_locks" = warn &&

2204

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

2205

$ECHO "\

2206

*** ERROR, $lockfile contains:

2207

`cat $lockfile 2>/dev/null`

2208

2209

but it should contain:

2210

$srcfile

2211

2212

This indicates that another process is trying to use the same

2213

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

2214

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

2215

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

2216

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

2217

compiler."

2218

2219

$opt_dry_run || $RM $removelist

2220

exit $EXIT_FAILURE

2221

fi

2222

2223

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

2224

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

2225

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

2226

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

2227

fi

2228

2229

# Allow error messages only from the first compilation.

2230

if test "$suppress_opt" = yes; then

2231

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

2232

fi

2233

fi

2234

2235

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

2236

if test "$build_old_libs" = yes; then

2237

if test "$pic_mode" != yes; then

2238

# Don't build PIC code

2239

command="$base_compile $qsrcfile$pie_flag"

2240

else

2241

command="$base_compile $qsrcfile $pic_flag"

2242

fi

2243

if test "$compiler_c_o" = yes; then

2244

func_append command " -o $obj"

2245

fi

2246

2247

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

2248

func_append command "$suppress_output"

2249

func_show_eval_locale "$command" \

2250

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

2251

2252

if test "$need_locks" = warn &&

2253

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

2254

$ECHO "\

2255

*** ERROR, $lockfile contains:

2256

`cat $lockfile 2>/dev/null`

2257

2258

but it should contain:

2259

$srcfile

2260

2261

This indicates that another process is trying to use the same

2262

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

2263

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

2264

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

2265

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

2266

compiler."

2267

2268

$opt_dry_run || $RM $removelist

2269

exit $EXIT_FAILURE

2270

fi

2271

2272

# Just move the object if needed

2273

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

2274

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

2275

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

2276

fi

2277

fi

2278

2279

$opt_dry_run || {

2280

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

2281

2282

# Unlock the critical section if it was locked

2283

if test "$need_locks" != no; then

2284

removelist=$lockfile

2285

$RM "$lockfile"

2286

fi

2287

}

2288

2289

exit $EXIT_SUCCESS

2290

}

2291

2292

$opt_help || {

2293

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

2294

}

2295

2296

func_mode_help ()

2297

{

2298

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

2299

case $opt_mode in

2300

"")

2301

# Generic help is extracted from the usage comments

2302

# at the start of this file.

2303

func_help

2304

;;

2305

2306

clean)

2307

$ECHO \

2308

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

2309

2310

Remove files from the build directory.

2311

2312

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

2313

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

2314

to RM.

2315

2316

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

2317

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

2318

;;

2319

2320

compile)

2321

$ECHO \

2322

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

2323

2324

Compile a source file into a libtool library object.

2325

2326

This mode accepts the following additional options:

2327

2328

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

2329

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

2330

-prefer-pic try to build PIC objects only

2331

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

2332

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

2333

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

2334

-Wc,FLAG pass FLAG directly to the compiler

2335

2336

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

2337

from the given SOURCEFILE.

2338

2339

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

2340

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

2341

library object suffix, \`.lo'."

2342

;;

2343

2344

execute)

2345

$ECHO \

2346

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

2347

2348

Automatically set library path, then run a program.

2349

2350

This mode accepts the following additional options:

2351

2352

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

2353

2354

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

2355

flags.

2356

2357

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

2358

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

2359

directories are added to the library path.

2360

2361

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

2362

;;

2363

2364

finish)

2365

$ECHO \

2366

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

2367

2368

Complete the installation of libtool libraries.

2369

2370

Each LIBDIR is a directory that contains libtool libraries.

2371

2372

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

2373

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

2374

;;

2375

2376

install)

2377

$ECHO \

2378

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

2379

2380

Install executables or libraries.

2381

2382

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

2383

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

2384

2385

The following components of INSTALL-COMMAND are treated specially:

2386

2387

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

2388

2389

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

2390

BSD-compatible install options are recognized)."

2391

;;

2392

2393

link)

2394

$ECHO \

2395

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

2396

2397

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

2398

create an executable program.

2399

2400

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

2401

a program from several object files.

2402

2403

The following components of LINK-COMMAND are treated specially:

2404

2405

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

2406

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

2407

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

2408

libraries must be found in the PATH setting at runtime)

2409

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

2410

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

2411

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

2412

-export-symbols SYMFILE

2413

try to export only the symbols listed in SYMFILE

2414

-export-symbols-regex REGEX

2415

try to export only the symbols matching REGEX

2416

-LLIBDIR search LIBDIR for required installed libraries

2417

-lNAME OUTPUT-FILE requires the installed library libNAME

2418

-module build a library that can dlopened

2419

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

2420

-no-install link a not-installable executable

2421

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

2422

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

2423

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

2424

-precious-files-regex REGEX

2425

don't remove output files matching REGEX

2426

-release RELEASE specify package release information

2427

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

2428

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

2429

-shared only do dynamic linking of libtool libraries

2430

-shrext SUFFIX override the standard shared library file extension

2431

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

2432

-static-libtool-libs

2433

do not do any dynamic linking of libtool libraries

2434

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

2435

specify library version info [each variable defaults to 0]

2436

-weak LIBNAME declare that the target provides the LIBNAME interface

2437

-Wc,FLAG

2438

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

2439

-Wl,FLAG

2440

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

2441

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

2442

2443

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

2444

2445

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

2446

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

2447

object files.

2448

2449

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

2450

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

2451

required, except when creating a convenience library.

2452

2453

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

2454

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

2455

2456

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

2457

is created, otherwise an executable program is created."

2458

;;

2459

2460

uninstall)

2461

$ECHO \

2462

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

2463

2464

Remove libraries from an installation directory.

2465

2466

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

2467

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

2468

to RM.

2469

2470

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

2471

Otherwise, only FILE itself is deleted using RM."

2472

;;

2473

2474

*)

2475

func_fatal_help "invalid operation mode \`$opt_mode'"

2476

;;

2477

esac

2478

2479

echo

2480

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

2481

}

2482

2483

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

2484

if $opt_help; then

2485

if test "$opt_help" = :; then

2486

func_mode_help

2487

else

2488

{

2489

func_help noexit

2490

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

2491

func_mode_help

2492

done

2493

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

2494

{

2495

func_help noexit

2496

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

2497

echo

2498

func_mode_help

2499

done

2500

} |

2501

sed '1d

2502

/^When reporting/,/^Report/{

2503

H

2504

d

2505

}

2506

$x

2507

/information about other modes/d

2508

/more detailed .*MODE/d

2509

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

2510

fi

2511

exit $?

2512

fi

2513

2514

2515

# func_mode_execute arg...

2516

func_mode_execute ()

2517

{

2518

$opt_debug

2519

# The first argument is the command name.

2520

cmd="$nonopt"

2521

test -z "$cmd" && \

2522

func_fatal_help "you must specify a COMMAND"

2523

2524

# Handle -dlopen flags immediately.

2525

for file in $opt_dlopen; do

2526

test -f "$file" \

2527

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

2528

2529

dir=

2530

case $file in

2531

*.la)

2532

func_resolve_sysroot "$file"

2533

file=$func_resolve_sysroot_result

2534

2535

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

2536

func_lalib_unsafe_p "$file" \

2537

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

2538

2539

# Read the libtool library.

2540

dlname=

2541

library_names=

2542

func_source "$file"

2543

2544

# Skip this library if it cannot be dlopened.

2545

if test -z "$dlname"; then

2546

# Warn if it was a shared library.

2547

test -n "$library_names" && \

2548

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

2549

continue

2550

fi

2551

2552

func_dirname "$file" "" "."

2553

dir="$func_dirname_result"

2554

2555

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

2556

func_append dir "/$objdir"

2557

else

2558

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

2559

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

2560

fi

2561

fi

2562

;;

2563

2564

*.lo)

2565

# Just add the directory containing the .lo file.

2566

func_dirname "$file" "" "."

2567

dir="$func_dirname_result"

2568

;;

2569

2570

*)

2571

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

2572

continue

2573

;;

2574

esac

2575

2576

# Get the absolute pathname.

2577

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

2578

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

2579

2580

# Now add the directory to shlibpath_var.

2581

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

2582

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

2583

else

2584

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

2585

fi

2586

done

2587

2588

# This variable tells wrapper scripts just to set shlibpath_var

2589

# rather than running their programs.

2590

libtool_execute_magic="$magic"

2591

2592

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

2593

args=

2594

for file

2595

do

2596

case $file in

2597

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

2598

*)

2599

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

2600

if func_ltwrapper_script_p "$file"; then

2601

func_source "$file"

2602

# Transform arg to wrapped name.

2603

file="$progdir/$program"

2604

elif func_ltwrapper_executable_p "$file"; then

2605

func_ltwrapper_scriptname "$file"

2606

func_source "$func_ltwrapper_scriptname_result"

2607

# Transform arg to wrapped name.

2608

file="$progdir/$program"

2609

fi

2610

;;

2611

esac

2612

# Quote arguments (to preserve shell metacharacters).

2613

func_append_quoted args "$file"

2614

done

2615

2616

if test "X$opt_dry_run" = Xfalse; then

2617

if test -n "$shlibpath_var"; then

2618

# Export the shlibpath_var.

2619

eval "export $shlibpath_var"

2620

fi

2621

2622

# Restore saved environment variables

2623

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

2624

do

2625

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

2626

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

2627

else

2628

$lt_unset $lt_var

2629

fi"

2630

done

2631

2632

# Now prepare to actually exec the command.

2633

exec_cmd="\$cmd$args"

2634

else

2635

# Display what would be done.

2636

if test -n "$shlibpath_var"; then

2637

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

2638

echo "export $shlibpath_var"

2639

fi

2640

$ECHO "$cmd$args"

2641

exit $EXIT_SUCCESS

2642

fi

2643

}

2644

2645

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

2646

2647

2648

# func_mode_finish arg...

2649

func_mode_finish ()

2650

{

2651

$opt_debug

2652

libs=

2653

libdirs=

2654

admincmds=

2655

2656

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

2657

do

2658

if test -d "$opt"; then

2659

func_append libdirs " $opt"

2660

2661

elif test -f "$opt"; then

2662

if func_lalib_unsafe_p "$opt"; then

2663

func_append libs " $opt"

2664

else

2665

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

2666

fi

2667

2668

else

2669

func_fatal_error "invalid argument \`$opt'"

2670

fi

2671

done

2672

2673

if test -n "$libs"; then

2674

if test -n "$lt_sysroot"; then

2675

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

2676

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

2677

else

2678

sysroot_cmd=

2679

fi

2680

2681

# Remove sysroot references

2682

if $opt_dry_run; then

2683

for lib in $libs; do

2684

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

2685

done

2686

else

2687

tmpdir=`func_mktempdir`

2688

for lib in $libs; do

2689

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

2690

> $tmpdir/tmp-la

2691

mv -f $tmpdir/tmp-la $lib

2692

done

2693

${RM}r "$tmpdir"

2694

fi

2695

fi

2696

2697

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

2698

for libdir in $libdirs; do

2699

if test -n "$finish_cmds"; then

2700

# Do each command in the finish commands.

2701

func_execute_cmds "$finish_cmds" 'admincmds="$admincmds

2702

'"$cmd"'"'

2703

fi

2704

if test -n "$finish_eval"; then

2705

# Do the single finish_eval.

2706

eval cmds=\"$finish_eval\"

2707

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

2708

$cmds"

2709

fi

2710

done

2711

fi

2712

2713

# Exit here if they wanted silent mode.

2714

$opt_silent && exit $EXIT_SUCCESS

2715

2716

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

2717

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

2718

echo "Libraries have been installed in:"

2719

for libdir in $libdirs; do

2720

$ECHO " $libdir"

2721

done

2722

echo

2723

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

2724

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

2725

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

2726

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

2727

if test -n "$shlibpath_var"; then

2728

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

2729

echo " during execution"

2730

fi

2731

if test -n "$runpath_var"; then

2732

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

2733

echo " during linking"

2734

fi

2735

if test -n "$hardcode_libdir_flag_spec"; then

2736

libdir=LIBDIR

2737

eval flag=\"$hardcode_libdir_flag_spec\"

2738

2739

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

2740

fi

2741

if test -n "$admincmds"; then

2742

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

2743

fi

2744

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

2745

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

2746

fi

2747

echo

2748

2749

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

2750

case $host in

2751

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

2752

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

2753

echo "pages."

2754

;;

2755

*)

2756

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

2757

;;

2758

esac

2759

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

2760

fi

2761

exit $EXIT_SUCCESS

2762

}

2763

2764

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

2765

2766

2767

# func_mode_install arg...

2768

func_mode_install ()

2769

{

2770

$opt_debug

2771

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

2772

# install_prog (especially on Windows NT).

2773

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

2774

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

2775

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

2776

# Aesthetically quote it.

2777

func_quote_for_eval "$nonopt"

2778

install_prog="$func_quote_for_eval_result "

2779

arg=$1

2780

shift

2781

else

2782

install_prog=

2783

arg=$nonopt

2784

fi

2785

2786

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

2787

# Aesthetically quote it.

2788

func_quote_for_eval "$arg"

2789

func_append install_prog "$func_quote_for_eval_result"

2790

install_shared_prog=$install_prog

2791

case " $install_prog " in

2792

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

2793

*) install_cp=false ;;

2794

esac

2795

2796

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

2797

dest=

2798

files=

2799

opts=

2800

prev=

2801

install_type=

2802

isdir=no

2803

stripme=

2804

no_mode=:

2805

for arg

2806

do

2807

arg2=

2808

if test -n "$dest"; then

2809

func_append files " $dest"

2810

dest=$arg

2811

continue

2812

fi

2813

2814

case $arg in

2815

-d) isdir=yes ;;

2816

-f)

2817

if $install_cp; then :; else

2818

prev=$arg

2819

fi

2820

;;

2821

-g | -m | -o)

2822

prev=$arg

2823

;;

2824

-s)

2825

stripme=" -s"

2826

continue

2827

;;

2828

-*)

2829

;;

2830

*)

2831

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

2832

if test -n "$prev"; then

2833

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

2834

arg2=$install_override_mode

2835

no_mode=false

2836

fi

2837

prev=

2838

else

2839

dest=$arg

2840

continue

2841

fi

2842

;;

2843

esac

2844

2845

# Aesthetically quote the argument.

2846

func_quote_for_eval "$arg"

2847

func_append install_prog " $func_quote_for_eval_result"

2848

if test -n "$arg2"; then

2849

func_quote_for_eval "$arg2"

2850

fi

2851

func_append install_shared_prog " $func_quote_for_eval_result"

2852

done

2853

2854

test -z "$install_prog" && \

2855

func_fatal_help "you must specify an install program"

2856

2857

test -n "$prev" && \

2858

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

2859

2860

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

2861

if $install_cp; then :; else

2862

func_quote_for_eval "$install_override_mode"

2863

func_append install_shared_prog " -m $func_quote_for_eval_result"

2864

fi

2865

fi

2866

2867

if test -z "$files"; then

2868

if test -z "$dest"; then

2869

func_fatal_help "no file or destination specified"

2870

else

2871

func_fatal_help "you must specify a destination"

2872

fi

2873

fi

2874

2875

# Strip any trailing slash from the destination.

2876

func_stripname '' '/' "$dest"

2877

dest=$func_stripname_result

2878

2879

# Check to see that the destination is a directory.

2880

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

2881

if test "$isdir" = yes; then

2882

destdir="$dest"

2883

destname=

2884

else

2885

func_dirname_and_basename "$dest" "" "."

2886

destdir="$func_dirname_result"

2887

destname="$func_basename_result"

2888

2889

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

2890

set dummy $files; shift

2891

test "$#" -gt 1 && \

2892

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

2893

fi

2894

case $destdir in

2895

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

2896

*)

2897

for file in $files; do

2898

case $file in

2899

*.lo) ;;

2900

*)

2901

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

2902

;;

2903

esac

2904

done

2905

;;

2906

esac

2907

2908

# This variable tells wrapper scripts just to set variables rather

2909

# than running their programs.

2910

libtool_install_magic="$magic"

2911

2912

staticlibs=

2913

future_libdirs=

2914

current_libdirs=

2915

for file in $files; do

2916

2917

# Do each installation.

2918

case $file in

2919

*.$libext)

2920

# Do the static libraries later.

2921

func_append staticlibs " $file"

2922

;;

2923

2924

*.la)

2925

func_resolve_sysroot "$file"

2926

file=$func_resolve_sysroot_result

2927

2928

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

2929

func_lalib_unsafe_p "$file" \

2930

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

2931

2932

library_names=

2933

old_library=

2934

relink_command=

2935

func_source "$file"

2936

2937

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

2938

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

2939

case "$current_libdirs " in

2940

*" $libdir "*) ;;

2941

*) func_append current_libdirs " $libdir" ;;

2942

esac

2943

else

2944

# Note the libdir as a future libdir.

2945

case "$future_libdirs " in

2946

*" $libdir "*) ;;

2947

*) func_append future_libdirs " $libdir" ;;

2948

esac

2949

fi

2950

2951

func_dirname "$file" "/" ""

2952

dir="$func_dirname_result"

2953

func_append dir "$objdir"

2954

2955

if test -n "$relink_command"; then

2956

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

2957

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

2958

2959

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

2960

# location b/c this prevents finding dependent libraries that

2961

# are installed to the same prefix.

2962

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

2963

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

2964

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

2965

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

2966

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

2967

2968

if test -n "$inst_prefix_dir"; then

2969

# Stick the inst_prefix_dir data into the link command.

2970

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

2971

else

2972

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

2973

fi

2974

2975

func_warning "relinking \`$file'"

2976

func_show_eval "$relink_command" \

2977

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

2978

fi

2979

2980

# See the names of the shared library.

2981

set dummy $library_names; shift

2982

if test -n "$1"; then

2983

realname="$1"

2984

shift

2985

2986

srcname="$realname"

2987

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

2988

2989

# Install the shared library and build the symlinks.

2990

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

2991

'exit $?'

2992

tstripme="$stripme"

2993

case $host_os in

2994

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

2995

case $realname in

2996

*.dll.a)

2997

tstripme=""

2998

;;

2999

esac

3000

;;

3001

esac

3002

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

3003

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

3004

fi

3005

3006

if test "$#" -gt 0; then

3007

# Delete the old symlinks, and create new ones.

3008

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

3009

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

3010

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

3011

for linkname

3012

do

3013

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

3014

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

3015

done

3016

fi

3017

3018

# Do each command in the postinstall commands.

3019

lib="$destdir/$realname"

3020

func_execute_cmds "$postinstall_cmds" 'exit $?'

3021

fi

3022

3023

# Install the pseudo-library for information purposes.

3024

func_basename "$file"

3025

name="$func_basename_result"

3026

instname="$dir/$name"i

3027

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

3028

3029

# Maybe install the static library, too.

3030

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

3031

;;

3032

3033

*.lo)

3034

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

3035

3036

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

3037

if test -n "$destname"; then

3038

destfile="$destdir/$destname"

3039

else

3040

func_basename "$file"

3041

destfile="$func_basename_result"

3042

destfile="$destdir/$destfile"

3043

fi

3044

3045

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

3046

case $destfile in

3047

*.lo)

3048

func_lo2o "$destfile"

3049

staticdest=$func_lo2o_result

3050

;;

3051

*.$objext)

3052

staticdest="$destfile"

3053

destfile=

3054

;;

3055

*)

3056

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

3057

;;

3058

esac

3059

3060

# Install the libtool object if requested.

3061

test -n "$destfile" && \

3062

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

3063

3064

# Install the old object if enabled.

3065

if test "$build_old_libs" = yes; then

3066

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

3067

func_lo2o "$file"

3068

staticobj=$func_lo2o_result

3069

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

3070

fi

3071

exit $EXIT_SUCCESS

3072

;;

3073

3074

*)

3075

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

3076

if test -n "$destname"; then

3077

destfile="$destdir/$destname"

3078

else

3079

func_basename "$file"

3080

destfile="$func_basename_result"

3081

destfile="$destdir/$destfile"

3082

fi

3083

3084

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

3085

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

3086

# install

3087

stripped_ext=""

3088

case $file in

3089

*.exe)

3090

if test ! -f "$file"; then

3091

func_stripname '' '.exe' "$file"

3092

file=$func_stripname_result

3093

stripped_ext=".exe"

3094

fi

3095

;;

3096

esac

3097

3098

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

3099

case $host in

3100

*cygwin* | *mingw*)

3101

if func_ltwrapper_executable_p "$file"; then

3102

func_ltwrapper_scriptname "$file"

3103

wrapper=$func_ltwrapper_scriptname_result

3104

else

3105

func_stripname '' '.exe' "$file"

3106

wrapper=$func_stripname_result

3107

fi

3108

;;

3109

*)

3110

wrapper=$file

3111

;;

3112

esac

3113

if func_ltwrapper_script_p "$wrapper"; then

3114

notinst_deplibs=

3115

relink_command=

3116

3117

func_source "$wrapper"

3118

3119

# Check the variables that should have been set.

3120

test -z "$generated_by_libtool_version" && \

3121

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

3122

3123

finalize=yes

3124

for lib in $notinst_deplibs; do

3125

# Check to see that each library is installed.

3126

libdir=

3127

if test -f "$lib"; then

3128

func_source "$lib"

3129

fi

3130

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

3131

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

3132

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

3133

finalize=no

3134

fi

3135

done

3136

3137

relink_command=

3138

func_source "$wrapper"

3139

3140

outputname=

3141

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

3142

$opt_dry_run || {

3143

if test "$finalize" = yes; then

3144

tmpdir=`func_mktempdir`

3145

func_basename "$file$stripped_ext"

3146

file="$func_basename_result"

3147

outputname="$tmpdir/$file"

3148

# Replace the output file specification.

3149

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

3150

3151

$opt_silent || {

3152

func_quote_for_expand "$relink_command"

3153

eval "func_echo $func_quote_for_expand_result"

3154

}

3155

if eval "$relink_command"; then :

3156

else

3157

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

3158

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

3159

continue

3160

fi

3161

file="$outputname"

3162

else

3163

func_warning "cannot relink \`$file'"

3164

fi

3165

}

3166

else

3167

# Install the binary that we compiled earlier.

3168

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

3169

fi

3170

fi

3171

3172

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

3173

# one anyway

3174

case $install_prog,$host in

3175

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

3176

case $file:$destfile in

3177

*.exe:*.exe)

3178

# this is ok

3179

;;

3180

*.exe:*)

3181

destfile=$destfile.exe

3182

;;

3183

*:*.exe)

3184

func_stripname '' '.exe' "$destfile"

3185

destfile=$func_stripname_result

3186

;;

3187

esac

3188

;;

3189

esac

3190

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

3191

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

3192

${RM}r "$tmpdir"

3193

fi

3194

;;

3195

esac

3196

done

3197

3198

for file in $staticlibs; do

3199

func_basename "$file"

3200

name="$func_basename_result"

3201

3202

# Set up the ranlib parameters.

3203

oldlib="$destdir/$name"

3204

3205

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

3206

3207

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

3208

func_show_eval "$old_striplib $oldlib" 'exit $?'

3209

fi

3210

3211

# Do each command in the postinstall commands.

3212

func_execute_cmds "$old_postinstall_cmds" 'exit $?'

3213

done

3214

3215

test -n "$future_libdirs" && \

3216

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

3217

3218

if test -n "$current_libdirs"; then

3219

# Maybe just do a dry run.

3220

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

3221

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

3222

else

3223

exit $EXIT_SUCCESS

3224

fi

3225

}

3226

3227

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

3228

3229

3230

# func_generate_dlsyms outputname originator pic_p

3231

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

3232

# a dlpreopen symbol table.

3233

func_generate_dlsyms ()

3234

{

3235

$opt_debug

3236

my_outputname="$1"

3237

my_originator="$2"

3238

my_pic_p="${3-no}"

3239

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

3240

my_dlsyms=

3241

3242

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

3243

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

3244

my_dlsyms="${my_outputname}S.c"

3245

else

3246

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

3247

fi

3248

fi

3249

3250

if test -n "$my_dlsyms"; then

3251

case $my_dlsyms in

3252

"") ;;

3253

*.c)

3254

# Discover the nlist of each of the dlfiles.

3255

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

3256

3257

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

3258

3259

# Parse the name list into a source file.

3260

func_verbose "creating $output_objdir/$my_dlsyms"

3261

3262

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

3263

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

3264

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

3265

3266

#ifdef __cplusplus

3267

extern \"C\" {

3268

#endif

3269

3270

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

3271

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

3272

#endif

3273

3274

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

3275

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

3276

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

3277

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

3278

# define LT_DLSYM_CONST

3279

#elif defined(__osf__)

3280

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

3281

# define LT_DLSYM_CONST

3282

#else

3283

# define LT_DLSYM_CONST const

3284

#endif

3285

3286

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

3287

"

3288

3289

if test "$dlself" = yes; then

3290

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

3291

3292

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

3293

3294

# Add our own program objects to the symbol list.

3295

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

3296

for progfile in $progfiles; do

3297

func_to_tool_file "$progfile" func_convert_file_msys_to_w32

3298

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

3299

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

3300

done

3301

3302

if test -n "$exclude_expsyms"; then

3303

$opt_dry_run || {

3304

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

3305

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

3306

}

3307

fi

3308

3309

if test -n "$export_symbols_regex"; then

3310

$opt_dry_run || {

3311

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

3312

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

3313

}

3314

fi

3315

3316

# Prepare the list of exported symbols

3317

if test -z "$export_symbols"; then

3318

export_symbols="$output_objdir/$outputname.exp"

3319

$opt_dry_run || {

3320

$RM $export_symbols

3321

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

3322

case $host in

3323

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

3324

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

3325

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

3326

;;

3327

esac

3328

}

3329

else

3330

$opt_dry_run || {

3331

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

3332

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

3333

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

3334

case $host in

3335

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

3336

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

3337

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

3338

;;

3339

esac

3340

}

3341

fi

3342

fi

3343

3344

for dlprefile in $dlprefiles; do

3345

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

3346

func_basename "$dlprefile"

3347

name="$func_basename_result"

3348

case $host in

3349

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

3350

# if an import library, we need to obtain dlname

3351

if func_win32_import_lib_p "$dlprefile"; then

3352

func_tr_sh "$dlprefile"

3353

eval "curr_lafile=\$libfile_$func_tr_sh_result"

3354

dlprefile_dlbasename=""

3355

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

3356

# Use subshell, to avoid clobbering current variable values

3357

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

3358

if test -n "$dlprefile_dlname" ; then

3359

func_basename "$dlprefile_dlname"

3360

dlprefile_dlbasename="$func_basename_result"

3361

else

3362

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

3363

$sharedlib_from_linklib_cmd "$dlprefile"

3364

dlprefile_dlbasename=$sharedlib_from_linklib_result

3365

fi

3366

fi

3367

$opt_dry_run || {

3368

if test -n "$dlprefile_dlbasename" ; then

3369

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

3370

else

3371

func_warning "Could not compute DLL name from $name"

3372

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

3373

fi

3374

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3375

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

3376

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

3377

}

3378

else # not an import lib

3379

$opt_dry_run || {

3380

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

3381

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3382

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

3383

}

3384

fi

3385

;;

3386

*)

3387

$opt_dry_run || {

3388

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

3389

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3390

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

3391

}

3392

;;

3393

esac

3394

done

3395

3396

$opt_dry_run || {

3397

# Make sure we have at least an empty file.

3398

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

3399

3400

if test -n "$exclude_expsyms"; then

3401

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

3402

$MV "$nlist"T "$nlist"

3403

fi

3404

3405

# Try sorting and uniquifying the output.

3406

if $GREP -v "^: " < "$nlist" |

3407

if sort -k 3 </dev/null >/dev/null 2>&1; then

3408

sort -k 3

3409

else

3410

sort +2

3411

fi |

3412

uniq > "$nlist"S; then

3413

:

3414

else

3415

$GREP -v "^: " < "$nlist" > "$nlist"S

3416

fi

3417

3418

if test -f "$nlist"S; then

3419

eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'

3420

else

3421

echo '/* NONE */' >> "$output_objdir/$my_dlsyms"

3422

fi

3423

3424

echo >> "$output_objdir/$my_dlsyms" "\

3425

3426

/* The mapping between symbol names and symbols. */

3427

typedef struct {

3428

const char *name;

3429

void *address;

3430

} lt_dlsymlist;

3431

extern LT_DLSYM_CONST lt_dlsymlist

3432

lt_${my_prefix}_LTX_preloaded_symbols[];

3433

LT_DLSYM_CONST lt_dlsymlist

3434

lt_${my_prefix}_LTX_preloaded_symbols[] =

3435

{\

3436

{ \"$my_originator\", (void *) 0 },"

3437

3438

case $need_lib_prefix in

3439

no)

3440

eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"

3441

;;

3442

*)

3443

eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"

3444

;;

3445

esac

3446

echo >> "$output_objdir/$my_dlsyms" "\

3447

{0, (void *) 0}

3448

};

3449

3450

/* This works around a problem in FreeBSD linker */

3451

#ifdef FREEBSD_WORKAROUND

3452

static const void *lt_preloaded_setup() {

3453

return lt_${my_prefix}_LTX_preloaded_symbols;

3454

}

3455

#endif

3456

3457

#ifdef __cplusplus

3458

}

3459

#endif\

3460

"

3461

} # !$opt_dry_run

3462

3463

pic_flag_for_symtable=

3464

case "$compile_command " in

3465

*" -static "*) ;;

3466

*)

3467

case $host in

3468

# compiling the symbol table file with pic_flag works around

3469

# a FreeBSD bug that causes programs to crash when -lm is

3470

# linked before any other PIC object. But we must not use

3471

# pic_flag when linking with -static. The problem exists in

3472

# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

3473

*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)

3474

pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;

3475

*-*-hpux*)

3476

pic_flag_for_symtable=" $pic_flag" ;;

3477

*)

3478

if test "X$my_pic_p" != Xno; then

3479

pic_flag_for_symtable=" $pic_flag"

3480

fi

3481

;;

3482

esac

3483

;;

3484

esac

3485

symtab_cflags=

3486

for arg in $LTCFLAGS; do

3487

case $arg in

3488

-pie | -fpie | -fPIE) ;;

3489

*) func_append symtab_cflags " $arg" ;;

3490

esac

3491

done

3492

3493

# Now compile the dynamic symbol file.

3494

func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'

3495

3496

# Clean up the generated files.

3497

func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'

3498

3499

# Transform the symbol file into the correct name.

3500

symfileobj="$output_objdir/${my_outputname}S.$objext"

3501

case $host in

3502

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

3503

if test -f "$output_objdir/$my_outputname.def"; then

3504

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

3505

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

3506

else

3507

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3508

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3509

fi

3510

;;

3511

*)

3512

compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3513

finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`

3514

;;

3515

esac

3516

;;

3517

*)

3518

func_fatal_error "unknown suffix for \`$my_dlsyms'"

3519

;;

3520

esac

3521

else

3522

# We keep going just in case the user didn't refer to

3523

# lt_preloaded_symbols. The linker will fail if global_symbol_pipe

3524

# really was required.

3525

3526

# Nullify the symbol file.

3527

compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`

3528

finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`

3529

fi

3530

}

3531

3532

# func_win32_libid arg

3533

# return the library type of file 'arg'

3534

#

3535

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

3536

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

3537

# that is supplied when $file_magic_command is called.

3538

# Despite the name, also deal with 64 bit binaries.

3539

func_win32_libid ()

3540

{

3541

$opt_debug

3542

win32_libid_type="unknown"

3543

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

3544

case $win32_fileres in

3545

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

3546

win32_libid_type="x86 archive import"

3547

;;

3548

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

3549

# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.

3550

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

3551

$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then

3552

func_to_tool_file "$1" func_convert_file_msys_to_w32

3553

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

3554

$SED -n -e '

3555

1,100{

3556

/ I /{

3557

s,.*,import,

3558

p

3559

q

3560

}

3561

}'`

3562

case $win32_nmres in

3563

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

3564

*) win32_libid_type="x86 archive static";;

3565

esac

3566

fi

3567

;;

3568

*DLL*)

3569

win32_libid_type="x86 DLL"

3570

;;

3571

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

3572

case $win32_fileres in

3573

*MS\ Windows\ PE\ Intel*)

3574

win32_libid_type="x86 DLL"

3575

;;

3576

esac

3577

;;

3578

esac

3579

$ECHO "$win32_libid_type"

3580

}

3581

3582

# func_cygming_dll_for_implib ARG

3583

#

3584

# Platform-specific function to extract the

3585

# name of the DLL associated with the specified

3586

# import library ARG.

3587

# Invoked by eval'ing the libtool variable

3588

# $sharedlib_from_linklib_cmd

3589

# Result is available in the variable

3590

# $sharedlib_from_linklib_result

3591

func_cygming_dll_for_implib ()

3592

{

3593

$opt_debug

3594

sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`

3595

}

3596

3597

# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs

3598

#

3599

# The is the core of a fallback implementation of a

3600

# platform-specific function to extract the name of the

3601

# DLL associated with the specified import library LIBNAME.

3602

#

3603

# SECTION_NAME is either .idata$6 or .idata$7, depending

3604

# on the platform and compiler that created the implib.

3605

#

3606

# Echos the name of the DLL associated with the

3607

# specified import library.

3608

func_cygming_dll_for_implib_fallback_core ()

3609

{

3610

$opt_debug

3611

match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`

3612

$OBJDUMP -s --section "$1" "$2" 2>/dev/null |

3613

$SED '/^Contents of section '"$match_literal"':/{

3614

# Place marker at beginning of archive member dllname section

3615

s/.*/====MARK====/

3616

p

3617

d

3618

}

3619

# These lines can sometimes be longer than 43 characters, but

3620

# are always uninteresting

3621

/:[ ]*file format pe[i]\{,1\}-/d

3622

/^In archive [^:]*:/d

3623

# Ensure marker is printed

3624

/^====MARK====/p

3625

# Remove all lines with less than 43 characters

3626

/^.\{43\}/!d

3627

# From remaining lines, remove first 43 characters

3628

s/^.\{43\}//' |

3629

$SED -n '

3630

# Join marker and all lines until next marker into a single line

3631

/^====MARK====/ b para

3632

H

3633

$ b para

3634

b

3635

:para

3636

x

3637

s/\n//g

3638

# Remove the marker

3639

s/^====MARK====//

3640

# Remove trailing dots and whitespace

3641

s/[\. \t]*$//

3642

# Print

3643

/./p' |

3644

# we now have a list, one entry per line, of the stringified

3645

# contents of the appropriate section of all members of the

3646

# archive which possess that section. Heuristic: eliminate

3647

# all those which have a first or second character that is

3648

# a '.' (that is, objdump's representation of an unprintable

3649

# character.) This should work for all archives with less than

3650

# 0x302f exports -- but will fail for DLLs whose name actually

3651

# begins with a literal '.' or a single character followed by

3652

# a '.'.

3653

#

3654

# Of those that remain, print the first one.

3655

$SED -e '/^\./d;/^.\./d;q'

3656

}

3657

3658

# func_cygming_gnu_implib_p ARG

3659

# This predicate returns with zero status (TRUE) if

3660

# ARG is a GNU/binutils-style import library. Returns

3661

# with nonzero status (FALSE) otherwise.

3662

func_cygming_gnu_implib_p ()

3663

{

3664

$opt_debug

3665

func_to_tool_file "$1" func_convert_file_msys_to_w32

3666

func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`

3667

test -n "$func_cygming_gnu_implib_tmp"

3668

}

3669

3670

# func_cygming_ms_implib_p ARG

3671

# This predicate returns with zero status (TRUE) if

3672

# ARG is an MS-style import library. Returns

3673

# with nonzero status (FALSE) otherwise.

3674

func_cygming_ms_implib_p ()

3675

{

3676

$opt_debug

3677

func_to_tool_file "$1" func_convert_file_msys_to_w32

3678

func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`

3679

test -n "$func_cygming_ms_implib_tmp"

3680

}

3681

3682

# func_cygming_dll_for_implib_fallback ARG

3683

# Platform-specific function to extract the

3684

# name of the DLL associated with the specified

3685

# import library ARG.

3686

#

3687

# This fallback implementation is for use when $DLLTOOL

3688

# does not support the --identify-strict option.

3689

# Invoked by eval'ing the libtool variable

3690

# $sharedlib_from_linklib_cmd

3691

# Result is available in the variable

3692

# $sharedlib_from_linklib_result

3693

func_cygming_dll_for_implib_fallback ()

3694

{

3695

$opt_debug

3696

if func_cygming_gnu_implib_p "$1" ; then

3697

# binutils import library

3698

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`

3699

elif func_cygming_ms_implib_p "$1" ; then

3700

# ms-generated import library

3701

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`

3702

else

3703

# unknown

3704

sharedlib_from_linklib_result=""

3705

fi

3706

}

3707

3708

3709

# func_extract_an_archive dir oldlib

3710

func_extract_an_archive ()

3711

{

3712

$opt_debug

3713

f_ex_an_ar_dir="$1"; shift

3714

f_ex_an_ar_oldlib="$1"

3715

if test "$lock_old_archive_extraction" = yes; then

3716

lockfile=$f_ex_an_ar_oldlib.lock

3717

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

3718

func_echo "Waiting for $lockfile to be removed"

3719

sleep 2

3720

done

3721

fi

3722

func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \

3723

'stat=$?; rm -f "$lockfile"; exit $stat'

3724

if test "$lock_old_archive_extraction" = yes; then

3725

$opt_dry_run || rm -f "$lockfile"

3726

fi

3727

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

3728

:

3729

else

3730

func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"

3731

fi

3732

}

3733

3734

3735

# func_extract_archives gentop oldlib ...

3736

func_extract_archives ()

3737

{

3738

$opt_debug

3739

my_gentop="$1"; shift

3740

my_oldlibs=${1+"$@"}

3741

my_oldobjs=""

3742

my_xlib=""

3743

my_xabs=""

3744

my_xdir=""

3745

3746

for my_xlib in $my_oldlibs; do

3747

# Extract the objects.

3748

case $my_xlib in

3749

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

3750

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

3751

esac

3752

func_basename "$my_xlib"

3753

my_xlib="$func_basename_result"

3754

my_xlib_u=$my_xlib

3755

while :; do

3756

case " $extracted_archives " in

3757

*" $my_xlib_u "*)

3758

func_arith $extracted_serial + 1

3759

extracted_serial=$func_arith_result

3760

my_xlib_u=lt$extracted_serial-$my_xlib ;;

3761

*) break ;;

3762

esac

3763

done

3764

extracted_archives="$extracted_archives $my_xlib_u"

3765

my_xdir="$my_gentop/$my_xlib_u"

3766

3767

func_mkdir_p "$my_xdir"

3768

3769

case $host in

3770

*-darwin*)

3771

func_verbose "Extracting $my_xabs"

3772

# Do not bother doing anything if just a dry run

3773

$opt_dry_run || {

3774

darwin_orig_dir=`pwd`

3775

cd $my_xdir || exit $?

3776

darwin_archive=$my_xabs

3777

darwin_curdir=`pwd`

3778

darwin_base_archive=`basename "$darwin_archive"`

3779

darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`

3780

if test -n "$darwin_arches"; then

3781

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

3782

darwin_arch=

3783

func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"

3784

for darwin_arch in $darwin_arches ; do

3785

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

3786

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

3787

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

3788

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

3789

cd "$darwin_curdir"

3790

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

3791

done # $darwin_arches

3792

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

3793

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

3794

darwin_file=

3795

darwin_files=

3796

for darwin_file in $darwin_filelist; do

3797

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

3798

$LIPO -create -output "$darwin_file" $darwin_files

3799

done # $darwin_filelist

3800

$RM -rf unfat-$$

3801

cd "$darwin_orig_dir"

3802

else

3803

cd $darwin_orig_dir

3804

func_extract_an_archive "$my_xdir" "$my_xabs"

3805

fi # $darwin_arches

3806

} # !$opt_dry_run

3807

;;

3808

*)

3809

func_extract_an_archive "$my_xdir" "$my_xabs"

3810

;;

3811

esac

3812

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

3813

done

3814

3815

func_extract_archives_result="$my_oldobjs"

3816

}

3817

3818

3819

# func_emit_wrapper [arg=no]

3820

#

3821

# Emit a libtool wrapper script on stdout.

3822

# Don't directly open a file because we may want to

3823

# incorporate the script contents within a cygwin/mingw

3824

# wrapper executable. Must ONLY be called from within

3825

# func_mode_link because it depends on a number of variables

3826

# set therein.

3827

#

3828

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

3829

# variable will take. If 'yes', then the emitted script

3830

# will assume that the directory in which it is stored is

3831

# the $objdir directory. This is a cygwin/mingw-specific

3832

# behavior.

3833

func_emit_wrapper ()

3834

{

3835

func_emit_wrapper_arg1=${1-no}

3836

3837

$ECHO "\

3838

#! $SHELL

3839

3840

# $output - temporary wrapper script for $objdir/$outputname

3841

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

3842

#

3843

# The $output program cannot be directly executed until all the libtool

3844

# libraries that it depends on are installed.

3845

#

3846

# This wrapper script should never be moved out of the build directory.

3847

# If it is, it will not operate correctly.

3848

3849

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

3850

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

3851

sed_quote_subst='$sed_quote_subst'

3852

3853

# Be Bourne compatible

3854

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

3855

emulate sh

3856

NULLCMD=:

3857

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

3858

# is contrary to our usage. Disable this feature.

3859

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

3860

setopt NO_GLOB_SUBST

3861

else

3862

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

3863

fi

3864

BIN_SH=xpg4; export BIN_SH # for Tru64

3865

DUALCASE=1; export DUALCASE # for MKS sh

3866

3867

# The HP-UX ksh and POSIX shell print the target directory to stdout

3868

# if CDPATH is set.

3869

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

3870

3871

relink_command=\"$relink_command\"

3872

3873

# This environment variable determines our operation mode.

3874

if test \"\$libtool_install_magic\" = \"$magic\"; then

3875

# install mode needs the following variables:

3876

generated_by_libtool_version='$macro_version'

3877

notinst_deplibs='$notinst_deplibs'

3878

else

3879

# When we are sourced in execute mode, \$file and \$ECHO are already set.

3880

if test \"\$libtool_execute_magic\" != \"$magic\"; then

3881

file=\"\$0\""

3882

3883

qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`

3884

$ECHO "\

3885

3886

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

3887

func_fallback_echo ()

3888

{

3889

eval 'cat <<_LTECHO_EOF

3890

\$1

3891

_LTECHO_EOF'

3892

}

3893

ECHO=\"$qECHO\"

3894

fi

3895

3896

# Very basic option parsing. These options are (a) specific to

3897

# the libtool wrapper, (b) are identical between the wrapper

3898

# /script/ and the wrapper /executable/ which is used only on

3899

# windows platforms, and (c) all begin with the string "--lt-"

3900

# (application programs are unlikely to have options which match

3901

# this pattern).

3902

#

3903

# There are only two supported options: --lt-debug and

3904

# --lt-dump-script. There is, deliberately, no --lt-help.

3905

#

3906

# The first argument to this parsing function should be the

3907

# script's $0 value, followed by "$@".

3908

lt_option_debug=

3909

func_parse_lt_options ()

3910

{

3911

lt_script_arg0=\$0

3912

shift

3913

for lt_opt

3914

do

3915

case \"\$lt_opt\" in

3916

--lt-debug) lt_option_debug=1 ;;

3917

--lt-dump-script)

3918

lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`

3919

test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.

3920

lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`

3921

cat \"\$lt_dump_D/\$lt_dump_F\"

3922

exit 0

3923

;;

3924

--lt-*)

3925

\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2

3926

exit 1

3927

;;

3928

esac

3929

done

3930

3931

# Print the debug banner immediately:

3932

if test -n \"\$lt_option_debug\"; then

3933

echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2

3934

fi

3935

}

3936

3937

# Used when --lt-debug. Prints its arguments to stdout

3938

# (redirection is the responsibility of the caller)

3939

func_lt_dump_args ()

3940

{

3941

lt_dump_args_N=1;

3942

for lt_arg

3943

do

3944

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"

3945

lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`

3946

done

3947

}

3948

3949

# Core function for launching the target application

3950

func_exec_program_core ()

3951

{

3952

"

3953

case $host in

3954

# Backslashes separate directories on plain windows

3955

*-*-mingw | *-*-os2* | *-cegcc*)

3956

$ECHO "\

3957

if test -n \"\$lt_option_debug\"; then

3958

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2

3959

func_lt_dump_args \${1+\"\$@\"} 1>&2

3960

fi

3961

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

3962

"

3963

;;

3964

3965

*)

3966

$ECHO "\

3967

if test -n \"\$lt_option_debug\"; then

3968

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2

3969

func_lt_dump_args \${1+\"\$@\"} 1>&2

3970

fi

3971

exec \"\$progdir/\$program\" \${1+\"\$@\"}

3972

"

3973

;;

3974

esac

3975

$ECHO "\

3976

\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2

3977

exit 1

3978

}

3979

3980

# A function to encapsulate launching the target application

3981

# Strips options in the --lt-* namespace from \$@ and

3982

# launches target application with the remaining arguments.

3983

func_exec_program ()

3984

{

3985

for lt_wr_arg

3986

do

3987

case \$lt_wr_arg in

3988

--lt-*) ;;

3989

*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;

3990

esac

3991

shift

3992

done

3993

func_exec_program_core \${1+\"\$@\"}

3994

}

3995

3996

# Parse options

3997

func_parse_lt_options \"\$0\" \${1+\"\$@\"}

3998

3999

# Find the directory that this script lives in.

4000

thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`

4001

test \"x\$thisdir\" = \"x\$file\" && thisdir=.

4002

4003

# Follow symbolic links until we get to the real thisdir.

4004

file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`

4005

while test -n \"\$file\"; do

4006

destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`

4007

4008

# If there was a directory component, then change thisdir.

4009

if test \"x\$destdir\" != \"x\$file\"; then

4010

case \"\$destdir\" in

4011

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

4012

*) thisdir=\"\$thisdir/\$destdir\" ;;

4013

esac

4014

fi

4015

4016

file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`

4017

file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`

4018

done

4019

4020

# Usually 'no', except on cygwin/mingw when embedded into

4021

# the cwrapper.

4022

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1

4023

if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then

4024

# special case for '.'

4025

if test \"\$thisdir\" = \".\"; then

4026

thisdir=\`pwd\`

4027

fi

4028

# remove .libs from thisdir

4029

case \"\$thisdir\" in

4030

*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;

4031

$objdir ) thisdir=. ;;

4032

esac

4033

fi

4034

4035

# Try to get the absolute directory name.

4036

absdir=\`cd \"\$thisdir\" && pwd\`

4037

test -n \"\$absdir\" && thisdir=\"\$absdir\"

4038

"

4039

4040

if test "$fast_install" = yes; then

4041

$ECHO "\

4042

program=lt-'$outputname'$exeext

4043

progdir=\"\$thisdir/$objdir\"

4044

4045

if test ! -f \"\$progdir/\$program\" ||

4046

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

4047

test \"X\$file\" != \"X\$progdir/\$program\"; }; then

4048

4049

file=\"\$\$-\$program\"

4050

4051

if test ! -d \"\$progdir\"; then

4052

$MKDIR \"\$progdir\"

4053

else

4054

$RM \"\$progdir/\$file\"

4055

fi"

4056

4057

$ECHO "\

4058

4059

# relink executable if necessary

4060

if test -n \"\$relink_command\"; then

4061

if relink_command_output=\`eval \$relink_command 2>&1\`; then :

4062

else

4063

$ECHO \"\$relink_command_output\" >&2

4064

$RM \"\$progdir/\$file\"

4065

exit 1

4066

fi

4067

fi

4068

4069

$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

4070

{ $RM \"\$progdir/\$program\";

4071

$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }

4072

$RM \"\$progdir/\$file\"

4073

fi"

4074

else

4075

$ECHO "\

4076

program='$outputname'

4077

progdir=\"\$thisdir/$objdir\"

4078

"

4079

fi

4080

4081

$ECHO "\

4082

4083

if test -f \"\$progdir/\$program\"; then"

4084

4085

# fixup the dll searchpath if we need to.

4086

#

4087

# Fix the DLL searchpath if we need to. Do this before prepending

4088

# to shlibpath, because on Windows, both are PATH and uninstalled

4089

# libraries must come first.

4090

if test -n "$dllsearchpath"; then

4091

$ECHO "\

4092

# Add the dll search path components to the executable PATH

4093

PATH=$dllsearchpath:\$PATH

4094

"

4095

fi

4096

4097

# Export our shlibpath_var if we have one.

4098

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4099

$ECHO "\

4100

# Add our own library path to $shlibpath_var

4101

$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

4102

4103

# Some systems cannot cope with colon-terminated $shlibpath_var

4104

# The second colon is a workaround for a bug in BeOS R4 sed

4105

$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`

4106

4107

export $shlibpath_var

4108

"

4109

fi

4110

4111

$ECHO "\

4112

if test \"\$libtool_execute_magic\" != \"$magic\"; then

4113

# Run the actual program with our arguments.

4114

func_exec_program \${1+\"\$@\"}

4115

fi

4116

else

4117

# The program doesn't exist.

4118

\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

4119

\$ECHO \"This script is just a wrapper for \$program.\" 1>&2

4120

\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

4121

exit 1

4122

fi

4123

fi\

4124

"

4125

}

4126

4127

4128

# func_emit_cwrapperexe_src

4129

# emit the source code for a wrapper executable on stdout

4130

# Must ONLY be called from within func_mode_link because

4131

# it depends on a number of variable set therein.

4132

func_emit_cwrapperexe_src ()

4133

{

4134

cat <<EOF

4135

4136

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

4137

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

4138

4139

The $output program cannot be directly executed until all the libtool

4140

libraries that it depends on are installed.

4141

4142

This wrapper executable should never be moved out of the build directory.

4143

If it is, it will not operate correctly.

4144

*/

4145

EOF

4146

cat <<"EOF"

4147

#ifdef _MSC_VER

4148

# define _CRT_SECURE_NO_DEPRECATE 1

4149

#endif

4150

#include <stdio.h>

4151

#include <stdlib.h>

4152

#ifdef _MSC_VER

4153

# include <direct.h>

4154

# include <process.h>

4155

# include <io.h>

4156

#else

4157

# include <unistd.h>

4158

# include <stdint.h>

4159

# ifdef __CYGWIN__

4160

# include <io.h>

4161

# endif

4162

#endif

4163

#include <malloc.h>

4164

#include <stdarg.h>

4165

#include <assert.h>

4166

#include <string.h>

4167

#include <ctype.h>

4168

#include <errno.h>

4169

#include <fcntl.h>

4170

#include <sys/stat.h>

4171

4172

/* declarations of non-ANSI functions */

4173

#if defined(__MINGW32__)

4174

# ifdef __STRICT_ANSI__

4175

int _putenv (const char *);

4176

# endif

4177

#elif defined(__CYGWIN__)

4178

# ifdef __STRICT_ANSI__

4179

char *realpath (const char *, char *);

4180

int putenv (char *);

4181

int setenv (const char *, const char *, int);

4182

# endif

4183

/* #elif defined (other platforms) ... */

4184

#endif

4185

4186

/* portability defines, excluding path handling macros */

4187

#if defined(_MSC_VER)

4188

# define setmode _setmode

4189

# define stat _stat

4190

# define chmod _chmod

4191

# define getcwd _getcwd

4192

# define putenv _putenv

4193

# define S_IXUSR _S_IEXEC

4194

# ifndef _INTPTR_T_DEFINED

4195

# define _INTPTR_T_DEFINED

4196

# define intptr_t int

4197

# endif

4198

#elif defined(__MINGW32__)

4199

# define setmode _setmode

4200

# define stat _stat

4201

# define chmod _chmod

4202

# define getcwd _getcwd

4203

# define putenv _putenv

4204

#elif defined(__CYGWIN__)

4205

# define HAVE_SETENV

4206

# define FOPEN_WB "wb"

4207

/* #elif defined (other platforms) ... */

4208

#endif

4209

4210

#if defined(PATH_MAX)

4211

# define LT_PATHMAX PATH_MAX

4212

#elif defined(MAXPATHLEN)

4213

# define LT_PATHMAX MAXPATHLEN

4214

#else

4215

# define LT_PATHMAX 1024

4216

#endif

4217

4218

#ifndef S_IXOTH

4219

# define S_IXOTH 0

4220

#endif

4221

#ifndef S_IXGRP

4222

# define S_IXGRP 0

4223

#endif

4224

4225

/* path handling portability macros */

4226

#ifndef DIR_SEPARATOR

4227

# define DIR_SEPARATOR '/'

4228

# define PATH_SEPARATOR ':'

4229

#endif

4230

4231

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

4232

defined (__OS2__)

4233

# define HAVE_DOS_BASED_FILE_SYSTEM

4234

# define FOPEN_WB "wb"

4235

# ifndef DIR_SEPARATOR_2

4236

# define DIR_SEPARATOR_2 '\\'

4237

# endif

4238

# ifndef PATH_SEPARATOR_2

4239

# define PATH_SEPARATOR_2 ';'

4240

# endif

4241

#endif

4242

4243

#ifndef DIR_SEPARATOR_2

4244

# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

4245

#else /* DIR_SEPARATOR_2 */

4246

# define IS_DIR_SEPARATOR(ch) \

4247

(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

4248

#endif /* DIR_SEPARATOR_2 */

4249

4250

#ifndef PATH_SEPARATOR_2

4251

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

4252

#else /* PATH_SEPARATOR_2 */

4253

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

4254

#endif /* PATH_SEPARATOR_2 */

4255

4256

#ifndef FOPEN_WB

4257

# define FOPEN_WB "w"

4258

#endif

4259

#ifndef _O_BINARY

4260

# define _O_BINARY 0

4261

#endif

4262

4263

#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

4264

#define XFREE(stale) do { \

4265

if (stale) { free ((void *) stale); stale = 0; } \

4266

} while (0)

4267

4268

#if defined(LT_DEBUGWRAPPER)

4269

static int lt_debug = 1;

4270

#else

4271

static int lt_debug = 0;

4272

#endif

4273

4274

const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */

4275

4276

void *xmalloc (size_t num);

4277

char *xstrdup (const char *string);

4278

const char *base_name (const char *name);

4279

char *find_executable (const char *wrapper);

4280

char *chase_symlinks (const char *pathspec);

4281

int make_executable (const char *path);

4282

int check_executable (const char *path);

4283

char *strendzap (char *str, const char *pat);

4284

void lt_debugprintf (const char *file, int line, const char *fmt, ...);

4285

void lt_fatal (const char *file, int line, const char *message, ...);

4286

static const char *nonnull (const char *s);

4287

static const char *nonempty (const char *s);

4288

void lt_setenv (const char *name, const char *value);

4289

char *lt_extend_str (const char *orig_value, const char *add, int to_end);

4290

void lt_update_exe_path (const char *name, const char *value);

4291

void lt_update_lib_path (const char *name, const char *value);

4292

char **prepare_spawn (char **argv);

4293

void lt_dump_script (FILE *f);

4294

EOF

4295

4296

cat <<EOF

4297

volatile const char * MAGIC_EXE = "$magic_exe";

4298

const char * LIB_PATH_VARNAME = "$shlibpath_var";

4299

EOF

4300

4301

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4302

func_to_host_path "$temp_rpath"

4303

cat <<EOF

4304

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

4305

EOF

4306

else

4307

cat <<"EOF"

4308

const char * LIB_PATH_VALUE = "";

4309

EOF

4310

fi

4311

4312

if test -n "$dllsearchpath"; then

4313

func_to_host_path "$dllsearchpath:"

4314

cat <<EOF

4315

const char * EXE_PATH_VARNAME = "PATH";

4316

const char * EXE_PATH_VALUE = "$func_to_host_path_result";

4317

EOF

4318

else

4319

cat <<"EOF"

4320

const char * EXE_PATH_VARNAME = "";

4321

const char * EXE_PATH_VALUE = "";

4322

EOF

4323

fi

4324

4325

if test "$fast_install" = yes; then

4326

cat <<EOF

4327

const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */

4328

EOF

4329

else

4330

cat <<EOF

4331

const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */

4332

EOF

4333

fi

4334

4335

4336

cat <<"EOF"

4337

4338

#define LTWRAPPER_OPTION_PREFIX "--lt-"

4339

4340

static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;

4341

static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";

4342

static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";

4343

4344

int

4345

main (int argc, char *argv[])

4346

{

4347

char **newargz;

4348

int newargc;

4349

char *tmp_pathspec;

4350

char *actual_cwrapper_path;

4351

char *actual_cwrapper_name;

4352

char *target_name;

4353

char *lt_argv_zero;

4354

intptr_t rval = 127;

4355

4356

int i;

4357

4358

program_name = (char *) xstrdup (base_name (argv[0]));

4359

newargz = XMALLOC (char *, argc + 1);

4360

4361

/* very simple arg parsing; don't want to rely on getopt

4362

* also, copy all non cwrapper options to newargz, except

4363

* argz[0], which is handled differently

4364

*/

4365

newargc=0;

4366

for (i = 1; i < argc; i++)

4367

{

4368

if (strcmp (argv[i], dumpscript_opt) == 0)

4369

{

4370

EOF

4371

case "$host" in

4372

*mingw* | *cygwin* )

4373

# make stdout use "unix" line endings

4374

echo " setmode(1,_O_BINARY);"

4375

;;

4376

esac

4377

4378

cat <<"EOF"

4379

lt_dump_script (stdout);

4380

return 0;

4381

}

4382

if (strcmp (argv[i], debug_opt) == 0)

4383

{

4384

lt_debug = 1;

4385

continue;

4386

}

4387

if (strcmp (argv[i], ltwrapper_option_prefix) == 0)

4388

{

4389

/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX

4390

namespace, but it is not one of the ones we know about and

4391

have already dealt with, above (inluding dump-script), then

4392

report an error. Otherwise, targets might begin to believe

4393

they are allowed to use options in the LTWRAPPER_OPTION_PREFIX

4394

namespace. The first time any user complains about this, we'll

4395

need to make LTWRAPPER_OPTION_PREFIX a configure-time option

4396

or a configure.ac-settable value.

4397

*/

4398

lt_fatal (__FILE__, __LINE__,

4399

"unrecognized %s option: '%s'",

4400

ltwrapper_option_prefix, argv[i]);

4401

}

4402

/* otherwise ... */

4403

newargz[++newargc] = xstrdup (argv[i]);

4404

}

4405

newargz[++newargc] = NULL;

4406

4407

EOF

4408

cat <<EOF

4409

/* The GNU banner must be the first non-error debug message */

4410

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");

4411

EOF

4412

cat <<"EOF"

4413

lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);

4414

lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);

4415

4416

tmp_pathspec = find_executable (argv[0]);

4417

if (tmp_pathspec == NULL)

4418

lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);

4419

lt_debugprintf (__FILE__, __LINE__,

4420

"(main) found exe (before symlink chase) at: %s\n",

4421

tmp_pathspec);

4422

4423

actual_cwrapper_path = chase_symlinks (tmp_pathspec);

4424

lt_debugprintf (__FILE__, __LINE__,

4425

"(main) found exe (after symlink chase) at: %s\n",

4426

actual_cwrapper_path);

4427

XFREE (tmp_pathspec);

4428

4429

actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));

4430

strendzap (actual_cwrapper_path, actual_cwrapper_name);

4431

4432

/* wrapper name transforms */

4433

strendzap (actual_cwrapper_name, ".exe");

4434

tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);

4435

XFREE (actual_cwrapper_name);

4436

actual_cwrapper_name = tmp_pathspec;

4437

tmp_pathspec = 0;

4438

4439

/* target_name transforms -- use actual target program name; might have lt- prefix */

4440

target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));

4441

strendzap (target_name, ".exe");

4442

tmp_pathspec = lt_extend_str (target_name, ".exe", 1);

4443

XFREE (target_name);

4444

target_name = tmp_pathspec;

4445

tmp_pathspec = 0;

4446

4447

lt_debugprintf (__FILE__, __LINE__,

4448

"(main) libtool target name: %s\n",

4449

target_name);

4450

EOF

4451

4452

cat <<EOF

4453

newargz[0] =

4454

XMALLOC (char, (strlen (actual_cwrapper_path) +

4455

strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));

4456

strcpy (newargz[0], actual_cwrapper_path);

4457

strcat (newargz[0], "$objdir");

4458

strcat (newargz[0], "/");

4459

EOF

4460

4461

cat <<"EOF"

4462

/* stop here, and copy so we don't have to do this twice */

4463

tmp_pathspec = xstrdup (newargz[0]);

4464

4465

/* do NOT want the lt- prefix here, so use actual_cwrapper_name */

4466

strcat (newargz[0], actual_cwrapper_name);

4467

4468

/* DO want the lt- prefix here if it exists, so use target_name */

4469

lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);

4470

XFREE (tmp_pathspec);

4471

tmp_pathspec = NULL;

4472

EOF

4473

4474

case $host_os in

4475

mingw*)

4476

cat <<"EOF"

4477

{

4478

char* p;

4479

while ((p = strchr (newargz[0], '\\')) != NULL)

4480

{

4481

*p = '/';

4482

}

4483

while ((p = strchr (lt_argv_zero, '\\')) != NULL)

4484

{

4485

*p = '/';

4486

}

4487

}

4488

EOF

4489

;;

4490

esac

4491

4492

cat <<"EOF"

4493

XFREE (target_name);

4494

XFREE (actual_cwrapper_path);

4495

XFREE (actual_cwrapper_name);

4496

4497

lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */

4498

lt_setenv ("DUALCASE", "1"); /* for MSK sh */

4499

/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must

4500

be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)

4501

because on Windows, both *_VARNAMEs are PATH but uninstalled

4502

libraries must come first. */

4503

lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);

4504

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

4505

4506

lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",

4507

nonnull (lt_argv_zero));

4508

for (i = 0; i < newargc; i++)

4509

{

4510

lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",

4511

i, nonnull (newargz[i]));

4512

}

4513

4514

EOF

4515

4516

case $host_os in

4517

mingw*)

4518

cat <<"EOF"

4519

/* execv doesn't actually work on mingw as expected on unix */

4520

newargz = prepare_spawn (newargz);

4521

rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

4522

if (rval == -1)

4523

{

4524

/* failed to start process */

4525

lt_debugprintf (__FILE__, __LINE__,

4526

"(main) failed to launch target \"%s\": %s\n",

4527

lt_argv_zero, nonnull (strerror (errno)));

4528

return 127;

4529

}

4530

return rval;

4531

EOF

4532

;;

4533

*)

4534

cat <<"EOF"

4535

execv (lt_argv_zero, newargz);

4536

return rval; /* =127, but avoids unused variable warning */

4537

EOF

4538

;;

4539

esac

4540

4541

cat <<"EOF"

4542

}

4543

4544

void *

4545

xmalloc (size_t num)

4546

{

4547

void *p = (void *) malloc (num);

4548

if (!p)

4549

lt_fatal (__FILE__, __LINE__, "memory exhausted");

4550

4551

return p;

4552

}

4553

4554

char *

4555

xstrdup (const char *string)

4556

{

4557

return string ? strcpy ((char *) xmalloc (strlen (string) + 1),

4558

string) : NULL;

4559

}

4560

4561

const char *

4562

base_name (const char *name)

4563

{

4564

const char *base;

4565

4566

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4567

/* Skip over the disk name in MSDOS pathnames. */

4568

if (isalpha ((unsigned char) name[0]) && name[1] == ':')

4569

name += 2;

4570

#endif

4571

4572

for (base = name; *name; name++)

4573

if (IS_DIR_SEPARATOR (*name))

4574

base = name + 1;

4575

return base;

4576

}

4577

4578

int

4579

check_executable (const char *path)

4580

{

4581

struct stat st;

4582

4583

lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",

4584

nonempty (path));

4585

if ((!path) || (!*path))

4586

return 0;

4587

4588

if ((stat (path, &st) >= 0)

4589

&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))

4590

return 1;

4591

else

4592

return 0;

4593

}

4594

4595

int

4596

make_executable (const char *path)

4597

{

4598

int rval = 0;

4599

struct stat st;

4600

4601

lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",

4602

nonempty (path));

4603

if ((!path) || (!*path))

4604

return 0;

4605

4606

if (stat (path, &st) >= 0)

4607

{

4608

rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);

4609

}

4610

return rval;

4611

}

4612

4613

/* Searches for the full path of the wrapper. Returns

4614

newly allocated full path name if found, NULL otherwise

4615

Does not chase symlinks, even on platforms that support them.

4616

*/

4617

char *

4618

find_executable (const char *wrapper)

4619

{

4620

int has_slash = 0;

4621

const char *p;

4622

const char *p_next;

4623

/* static buffer for getcwd */

4624

char tmp[LT_PATHMAX + 1];

4625

int tmp_len;

4626

char *concat_name;

4627

4628

lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",

4629

nonempty (wrapper));

4630

4631

if ((wrapper == NULL) || (*wrapper == '\0'))

4632

return NULL;

4633

4634

/* Absolute path? */

4635

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4636

if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')

4637

{

4638

concat_name = xstrdup (wrapper);

4639

if (check_executable (concat_name))

4640

return concat_name;

4641

XFREE (concat_name);

4642

}

4643

else

4644

{

4645

#endif

4646

if (IS_DIR_SEPARATOR (wrapper[0]))

4647

{

4648

concat_name = xstrdup (wrapper);

4649

if (check_executable (concat_name))

4650

return concat_name;

4651

XFREE (concat_name);

4652

}

4653

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4654

}

4655

#endif

4656

4657

for (p = wrapper; *p; p++)

4658

if (*p == '/')

4659

{

4660

has_slash = 1;

4661

break;

4662

}

4663

if (!has_slash)

4664

{

4665

/* no slashes; search PATH */

4666

const char *path = getenv ("PATH");

4667

if (path != NULL)

4668

{

4669

for (p = path; *p; p = p_next)

4670

{

4671

const char *q;

4672

size_t p_len;

4673

for (q = p; *q; q++)

4674

if (IS_PATH_SEPARATOR (*q))

4675

break;

4676

p_len = q - p;

4677

p_next = (*q == '\0' ? q : q + 1);

4678

if (p_len == 0)

4679

{

4680

/* empty path: current directory */

4681

if (getcwd (tmp, LT_PATHMAX) == NULL)

4682

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4683

nonnull (strerror (errno)));

4684

tmp_len = strlen (tmp);

4685

concat_name =

4686

XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

4687

memcpy (concat_name, tmp, tmp_len);

4688

concat_name[tmp_len] = '/';

4689

strcpy (concat_name + tmp_len + 1, wrapper);

4690

}

4691

else

4692

{

4693

concat_name =

4694

XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);

4695

memcpy (concat_name, p, p_len);

4696

concat_name[p_len] = '/';

4697

strcpy (concat_name + p_len + 1, wrapper);

4698

}

4699

if (check_executable (concat_name))

4700

return concat_name;

4701

XFREE (concat_name);

4702

}

4703

}

4704

/* not found in PATH; assume curdir */

4705

}

4706

/* Relative path | not found in path: prepend cwd */

4707

if (getcwd (tmp, LT_PATHMAX) == NULL)

4708

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4709

nonnull (strerror (errno)));

4710

tmp_len = strlen (tmp);

4711

concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

4712

memcpy (concat_name, tmp, tmp_len);

4713

concat_name[tmp_len] = '/';

4714

strcpy (concat_name + tmp_len + 1, wrapper);

4715

4716

if (check_executable (concat_name))

4717

return concat_name;

4718

XFREE (concat_name);

4719

return NULL;

4720

}

4721

4722

char *

4723

chase_symlinks (const char *pathspec)

4724

{

4725

#ifndef S_ISLNK

4726

return xstrdup (pathspec);

4727

#else

4728

char buf[LT_PATHMAX];

4729

struct stat s;

4730

char *tmp_pathspec = xstrdup (pathspec);

4731

char *p;

4732

int has_symlinks = 0;

4733

while (strlen (tmp_pathspec) && !has_symlinks)

4734

{

4735

lt_debugprintf (__FILE__, __LINE__,

4736

"checking path component for symlinks: %s\n",

4737

tmp_pathspec);

4738

if (lstat (tmp_pathspec, &s) == 0)

4739

{

4740

if (S_ISLNK (s.st_mode) != 0)

4741

{

4742

has_symlinks = 1;

4743

break;

4744

}

4745

4746

/* search backwards for last DIR_SEPARATOR */

4747

p = tmp_pathspec + strlen (tmp_pathspec) - 1;

4748

while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

4749

p--;

4750

if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

4751

{

4752

/* no more DIR_SEPARATORS left */

4753

break;

4754

}

4755

*p = '\0';

4756

}

4757

else

4758

{

4759

lt_fatal (__FILE__, __LINE__,

4760

"error accessing file \"%s\": %s",

4761

tmp_pathspec, nonnull (strerror (errno)));

4762

}

4763

}

4764

XFREE (tmp_pathspec);

4765

4766

if (!has_symlinks)

4767

{

4768

return xstrdup (pathspec);

4769

}

4770

4771

tmp_pathspec = realpath (pathspec, buf);

4772

if (tmp_pathspec == 0)

4773

{

4774

lt_fatal (__FILE__, __LINE__,

4775

"could not follow symlinks for %s", pathspec);

4776

}

4777

return xstrdup (tmp_pathspec);

4778

#endif

4779

}

4780

4781

char *

4782

strendzap (char *str, const char *pat)

4783

{

4784

size_t len, patlen;

4785

4786

assert (str != NULL);

4787

assert (pat != NULL);

4788

4789

len = strlen (str);

4790

patlen = strlen (pat);

4791

4792

if (patlen <= len)

4793

{

4794

str += len - patlen;

4795

if (strcmp (str, pat) == 0)

4796

*str = '\0';

4797

}

4798

return str;

4799

}

4800

4801

void

4802

lt_debugprintf (const char *file, int line, const char *fmt, ...)

4803

{

4804

va_list args;

4805

if (lt_debug)

4806

{

4807

(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);

4808

va_start (args, fmt);

4809

(void) vfprintf (stderr, fmt, args);

4810

va_end (args);

4811

}

4812

}

4813

4814

static void

4815

lt_error_core (int exit_status, const char *file,

4816

int line, const char *mode,

4817

const char *message, va_list ap)

4818

{

4819

fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);

4820

vfprintf (stderr, message, ap);

4821

fprintf (stderr, ".\n");

4822

4823

if (exit_status >= 0)

4824

exit (exit_status);

4825

}

4826

4827

void

4828

lt_fatal (const char *file, int line, const char *message, ...)

4829

{

4830

va_list ap;

4831

va_start (ap, message);

4832

lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);

4833

va_end (ap);

4834

}

4835

4836

static const char *

4837

nonnull (const char *s)

4838

{

4839

return s ? s : "(null)";

4840

}

4841

4842

static const char *

4843

nonempty (const char *s)

4844

{

4845

return (s && !*s) ? "(empty)" : nonnull (s);

4846

}

4847

4848

void

4849

lt_setenv (const char *name, const char *value)

4850

{

4851

lt_debugprintf (__FILE__, __LINE__,

4852

"(lt_setenv) setting '%s' to '%s'\n",

4853

nonnull (name), nonnull (value));

4854

{

4855

#ifdef HAVE_SETENV

4856

/* always make a copy, for consistency with !HAVE_SETENV */

4857

char *str = xstrdup (value);

4858

setenv (name, str, 1);

4859

#else

4860

int len = strlen (name) + 1 + strlen (value) + 1;

4861

char *str = XMALLOC (char, len);

4862

sprintf (str, "%s=%s", name, value);

4863

if (putenv (str) != EXIT_SUCCESS)

4864

{

4865

XFREE (str);

4866

}

4867

#endif

4868

}

4869

}

4870

4871

char *

4872

lt_extend_str (const char *orig_value, const char *add, int to_end)

4873

{

4874

char *new_value;

4875

if (orig_value && *orig_value)

4876

{

4877

int orig_value_len = strlen (orig_value);

4878

int add_len = strlen (add);

4879

new_value = XMALLOC (char, add_len + orig_value_len + 1);

4880

if (to_end)

4881

{

4882

strcpy (new_value, orig_value);

4883

strcpy (new_value + orig_value_len, add);

4884

}

4885

else

4886

{

4887

strcpy (new_value, add);

4888

strcpy (new_value + add_len, orig_value);

4889

}

4890

}

4891

else

4892

{

4893

new_value = xstrdup (add);

4894

}

4895

return new_value;

4896

}

4897

4898

void

4899

lt_update_exe_path (const char *name, const char *value)

4900

{

4901

lt_debugprintf (__FILE__, __LINE__,

4902

"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",

4903

nonnull (name), nonnull (value));

4904

4905

if (name && *name && value && *value)

4906

{

4907

char *new_value = lt_extend_str (getenv (name), value, 0);

4908

/* some systems can't cope with a ':'-terminated path #' */

4909

int len = strlen (new_value);

4910

while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))

4911

{

4912

new_value[len-1] = '\0';

4913

}

4914

lt_setenv (name, new_value);

4915

XFREE (new_value);

4916

}

4917

}

4918

4919

void

4920

lt_update_lib_path (const char *name, const char *value)

4921

{

4922

lt_debugprintf (__FILE__, __LINE__,

4923

"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",

4924

nonnull (name), nonnull (value));

4925

4926

if (name && *name && value && *value)

4927

{

4928

char *new_value = lt_extend_str (getenv (name), value, 0);

4929

lt_setenv (name, new_value);

4930

XFREE (new_value);

4931

}

4932

}

4933

4934

EOF

4935

case $host_os in

4936

mingw*)

4937

cat <<"EOF"

4938

4939

/* Prepares an argument vector before calling spawn().

4940

Note that spawn() does not by itself call the command interpreter

4941

(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :

4942

({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

4943

GetVersionEx(&v);

4944

v.dwPlatformId == VER_PLATFORM_WIN32_NT;

4945

}) ? "cmd.exe" : "command.com").

4946

Instead it simply concatenates the arguments, separated by ' ', and calls

4947

CreateProcess(). We must quote the arguments since Win32 CreateProcess()

4948

interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a

4949

special way:

4950

- Space and tab are interpreted as delimiters. They are not treated as

4951

delimiters if they are surrounded by double quotes: "...".

4952

- Unescaped double quotes are removed from the input. Their only effect is

4953

that within double quotes, space and tab are treated like normal

4954

characters.

4955

- Backslashes not followed by double quotes are not special.

4956

- But 2*n+1 backslashes followed by a double quote become

4957

n backslashes followed by a double quote (n >= 0):

4958

\" -> "

4959

\\\" -> \"

4960

\\\\\" -> \\"

4961

*/

4962

#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4963

#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4964

char **

4965

prepare_spawn (char **argv)

4966

{

4967

size_t argc;

4968

char **new_argv;

4969

size_t i;

4970

4971

/* Count number of arguments. */

4972

for (argc = 0; argv[argc] != NULL; argc++)

4973

;

4974

4975

/* Allocate new argument vector. */

4976

new_argv = XMALLOC (char *, argc + 1);

4977

4978

/* Put quoted arguments into the new argument vector. */

4979

for (i = 0; i < argc; i++)

4980

{

4981

const char *string = argv[i];

4982

4983

if (string[0] == '\0')

4984

new_argv[i] = xstrdup ("\"\"");

4985

else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)

4986

{

4987

int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);

4988

size_t length;

4989

unsigned int backslashes;

4990

const char *s;

4991

char *quoted_string;

4992

char *p;

4993

4994

length = 0;

4995

backslashes = 0;

4996

if (quote_around)

4997

length++;

4998

for (s = string; *s != '\0'; s++)

4999

{

5000

char c = *s;

5001

if (c == '"')

5002

length += backslashes + 1;

5003

length++;

5004

if (c == '\\')

5005

backslashes++;

5006

else

5007

backslashes = 0;

5008

}

5009

if (quote_around)

5010

length += backslashes + 1;

5011

5012

quoted_string = XMALLOC (char, length + 1);

5013

5014

p = quoted_string;

5015

backslashes = 0;

5016

if (quote_around)

5017

*p++ = '"';

5018

for (s = string; *s != '\0'; s++)

5019

{

5020

char c = *s;

5021

if (c == '"')

5022

{

5023

unsigned int j;

5024

for (j = backslashes + 1; j > 0; j--)

5025

*p++ = '\\';

5026

}

5027

*p++ = c;

5028

if (c == '\\')

5029

backslashes++;

5030

else

5031

backslashes = 0;

5032

}

5033

if (quote_around)

5034

{

5035

unsigned int j;

5036

for (j = backslashes; j > 0; j--)

5037

*p++ = '\\';

5038

*p++ = '"';

5039

}

5040

*p = '\0';

5041

5042

new_argv[i] = quoted_string;

5043

}

5044

else

5045

new_argv[i] = (char *) string;

5046

}

5047

new_argv[argc] = NULL;

5048

5049

return new_argv;

5050

}

5051

EOF

5052

;;

5053

esac

5054

5055

cat <<"EOF"

5056

void lt_dump_script (FILE* f)

5057

{

5058

EOF

5059

func_emit_wrapper yes |

5060

$SED -e 's/$[\\"]$/\\\1/g' \

5061

-e 's/^/ fputs ("/' -e 's/$/\\n", f);/'

5062

5063

cat <<"EOF"

5064

}

5065

EOF

5066

}

5067

# end: func_emit_cwrapperexe_src

5068

5069

# func_win32_import_lib_p ARG

5070

# True if ARG is an import lib, as indicated by $file_magic_cmd

5071

func_win32_import_lib_p ()

5072

{

5073

$opt_debug

5074

case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in

5075

*import*) : ;;

5076

*) false ;;

5077

esac

5078

}

5079

5080

# func_mode_link arg...

5081

func_mode_link ()

5082

{

5083

$opt_debug

5084

case $host in

5085

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

5086

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

5087

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

5088

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

5089

# flag for every libtool invocation.

5090

# allow_undefined=no

5091

5092

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

5093

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

5094

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

5095

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

5096

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

5097

allow_undefined=yes

5098

;;

5099

*)

5100

allow_undefined=yes

5101

;;

5102

esac

5103

libtool_args=$nonopt

5104

base_compile="$nonopt $@"

5105

compile_command=$nonopt

5106

finalize_command=$nonopt

5107

5108

compile_rpath=

5109

finalize_rpath=

5110

compile_shlibpath=

5111

finalize_shlibpath=

5112

convenience=

5113

old_convenience=

5114

deplibs=

5115

old_deplibs=

5116

compiler_flags=

5117

linker_flags=

5118

dllsearchpath=

5119

lib_search_path=`pwd`

5120

inst_prefix_dir=

5121

new_inherited_linker_flags=

5122

5123

avoid_version=no

5124

bindir=

5125

dlfiles=

5126

dlprefiles=

5127

dlself=no

5128

export_dynamic=no

5129

export_symbols=

5130

export_symbols_regex=

5131

generated=

5132

libobjs=

5133

ltlibs=

5134

module=no

5135

no_install=no

5136

objs=

5137

non_pic_objects=

5138

precious_files_regex=

5139

prefer_static_libs=no

5140

preload=no

5141

prev=

5142

prevarg=

5143

release=

5144

rpath=

5145

xrpath=

5146

perm_rpath=

5147

temp_rpath=

5148

thread_safe=no

5149

vinfo=

5150

vinfo_number=no

5151

weak_libs=

5152

single_module="${wl}-single_module"

5153

func_infer_tag $base_compile

5154

5155

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

5156

for arg

5157

do

5158

case $arg in

5159

-shared)

5160

test "$build_libtool_libs" != yes && \

5161

func_fatal_configuration "can not build a shared library"

5162

build_old_libs=no

5163

break

5164

;;

5165

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

5166

case $arg in

5167

-all-static)

5168

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

5169

func_warning "complete static linking is impossible in this configuration"

5170

fi

5171

if test -n "$link_static_flag"; then

5172

dlopen_self=$dlopen_self_static

5173

fi

5174

prefer_static_libs=yes

5175

;;

5176

-static)

5177

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

5178

dlopen_self=$dlopen_self_static

5179

fi

5180

prefer_static_libs=built

5181

;;

5182

-static-libtool-libs)

5183

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

5184

dlopen_self=$dlopen_self_static

5185

fi

5186

prefer_static_libs=yes

5187

;;

5188

esac

5189

build_libtool_libs=no

5190

build_old_libs=yes

5191

break

5192

;;

5193

esac

5194

done

5195

5196

# See if our shared archives depend on static archives.

5197

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

5198

5199

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

5200

while test "$#" -gt 0; do

5201

arg="$1"

5202

shift

5203

func_quote_for_eval "$arg"

5204

qarg=$func_quote_for_eval_unquoted_result

5205

func_append libtool_args " $func_quote_for_eval_result"

5206

5207

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

5208

if test -n "$prev"; then

5209

case $prev in

5210

output)

5211

func_append compile_command " @OUTPUT@"

5212

func_append finalize_command " @OUTPUT@"

5213

;;

5214

esac

5215

5216

case $prev in

5217

bindir)

5218

bindir="$arg"

5219

prev=

5220

continue

5221

;;

5222

dlfiles|dlprefiles)

5223

if test "$preload" = no; then

5224

# Add the symbol object into the linking commands.

5225

func_append compile_command " @SYMFILE@"

5226

func_append finalize_command " @SYMFILE@"

5227

preload=yes

5228

fi

5229

case $arg in

5230

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

5231

force)

5232

if test "$dlself" = no; then

5233

dlself=needless

5234

export_dynamic=yes

5235

fi

5236

prev=

5237

continue

5238

;;

5239

self)

5240

if test "$prev" = dlprefiles; then

5241

dlself=yes

5242

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

5243

dlself=yes

5244

else

5245

dlself=needless

5246

export_dynamic=yes

5247

fi

5248

prev=

5249

continue

5250

;;

5251

*)

5252

if test "$prev" = dlfiles; then

5253

func_append dlfiles " $arg"

5254

else

5255

func_append dlprefiles " $arg"

5256

fi

5257

prev=

5258

continue

5259

;;

5260

esac

5261

;;

5262

expsyms)

5263

export_symbols="$arg"

5264

test -f "$arg" \

5265

|| func_fatal_error "symbol file \`$arg' does not exist"

5266

prev=

5267

continue

5268

;;

5269

expsyms_regex)

5270

export_symbols_regex="$arg"

5271

prev=

5272

continue

5273

;;

5274

framework)

5275

case $host in

5276

*-*-darwin*)

5277

case "$deplibs " in

5278

*" $qarg.ltframework "*) ;;

5279

*) func_append deplibs " $qarg.ltframework" # this is fixed later

5280

;;

5281

esac

5282

;;

5283

esac

5284

prev=

5285

continue

5286

;;

5287

inst_prefix)

5288

inst_prefix_dir="$arg"

5289

prev=

5290

continue

5291

;;

5292

objectlist)

5293

if test -f "$arg"; then

5294

save_arg=$arg

5295

moreargs=

5296

for fil in `cat "$save_arg"`

5297

do

5298

# func_append moreargs " $fil"

5299

arg=$fil

5300

# A libtool-controlled object.

5301

5302

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

5303

if func_lalib_unsafe_p "$arg"; then

5304

pic_object=

5305

non_pic_object=

5306

5307

# Read the .lo file

5308

func_source "$arg"

5309

5310

if test -z "$pic_object" ||

5311

test -z "$non_pic_object" ||

5312

test "$pic_object" = none &&

5313

test "$non_pic_object" = none; then

5314

func_fatal_error "cannot find name of object for \`$arg'"

5315

fi

5316

5317

# Extract subdirectory from the argument.

5318

func_dirname "$arg" "/" ""

5319

xdir="$func_dirname_result"

5320

5321

if test "$pic_object" != none; then

5322

# Prepend the subdirectory the object is found in.

5323

pic_object="$xdir$pic_object"

5324

5325

if test "$prev" = dlfiles; then

5326

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

5327

func_append dlfiles " $pic_object"

5328

prev=

5329

continue

5330

else

5331

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

5332

prev=dlprefiles

5333

fi

5334

fi

5335

5336

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

5337

if test "$prev" = dlprefiles; then

5338

# Preload the old-style object.

5339

func_append dlprefiles " $pic_object"

5340

prev=

5341

fi

5342

5343

# A PIC object.

5344

func_append libobjs " $pic_object"

5345

arg="$pic_object"

5346

fi

5347

5348

# Non-PIC object.

5349

if test "$non_pic_object" != none; then

5350

# Prepend the subdirectory the object is found in.

5351

non_pic_object="$xdir$non_pic_object"

5352

5353

# A standard non-PIC object

5354

func_append non_pic_objects " $non_pic_object"

5355

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

5356

arg="$non_pic_object"

5357

fi

5358

else

5359

# If the PIC object exists, use it instead.

5360

# $xdir was prepended to $pic_object above.

5361

non_pic_object="$pic_object"

5362

func_append non_pic_objects " $non_pic_object"

5363

fi

5364

else

5365

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

5366

if $opt_dry_run; then

5367

# Extract subdirectory from the argument.

5368

func_dirname "$arg" "/" ""

5369

xdir="$func_dirname_result"

5370

5371

func_lo2o "$arg"

5372

pic_object=$xdir$objdir/$func_lo2o_result

5373

non_pic_object=$xdir$func_lo2o_result

5374

func_append libobjs " $pic_object"

5375

func_append non_pic_objects " $non_pic_object"

5376

else

5377

func_fatal_error "\`$arg' is not a valid libtool object"

5378

fi

5379

fi

5380

done

5381

else

5382

func_fatal_error "link input file \`$arg' does not exist"

5383

fi

5384

arg=$save_arg

5385

prev=

5386

continue

5387

;;

5388

precious_regex)

5389

precious_files_regex="$arg"

5390

prev=

5391

continue

5392

;;

5393

release)

5394

release="-$arg"

5395

prev=

5396

continue

5397

;;

5398

rpath | xrpath)

5399

# We need an absolute path.

5400

case $arg in

5401

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

5402

*)

5403

func_fatal_error "only absolute run-paths are allowed"

5404

;;

5405

esac

5406

if test "$prev" = rpath; then

5407

case "$rpath " in

5408

*" $arg "*) ;;

5409

*) func_append rpath " $arg" ;;

5410

esac

5411

else

5412

case "$xrpath " in

5413

*" $arg "*) ;;

5414

*) func_append xrpath " $arg" ;;

5415

esac

5416

fi

5417

prev=

5418

continue

5419

;;

5420

shrext)

5421

shrext_cmds="$arg"

5422

prev=

5423

continue

5424

;;

5425

weak)

5426

func_append weak_libs " $arg"

5427

prev=

5428

continue

5429

;;

5430

xcclinker)

5431

func_append linker_flags " $qarg"

5432

func_append compiler_flags " $qarg"

5433

prev=

5434

func_append compile_command " $qarg"

5435

func_append finalize_command " $qarg"

5436

continue

5437

;;

5438

xcompiler)

5439

func_append compiler_flags " $qarg"

5440

prev=

5441

func_append compile_command " $qarg"

5442

func_append finalize_command " $qarg"

5443

continue

5444

;;

5445

xlinker)

5446

func_append linker_flags " $qarg"

5447

func_append compiler_flags " $wl$qarg"

5448

prev=

5449

func_append compile_command " $wl$qarg"

5450

func_append finalize_command " $wl$qarg"

5451

continue

5452

;;

5453

*)

5454

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

5455

prev=

5456

continue

5457

;;

5458

esac

5459

fi # test -n "$prev"

5460

5461

prevarg="$arg"

5462

5463

case $arg in

5464

-all-static)

5465

if test -n "$link_static_flag"; then

5466

# See comment for -static flag below, for more details.

5467

func_append compile_command " $link_static_flag"

5468

func_append finalize_command " $link_static_flag"

5469

fi

5470

continue

5471

;;

5472

5473

-allow-undefined)

5474

# FIXME: remove this flag sometime in the future.

5475

func_fatal_error "\`-allow-undefined' must not be used because it is the default"

5476

;;

5477

5478

-avoid-version)

5479

avoid_version=yes

5480

continue

5481

;;

5482

5483

-bindir)

5484

prev=bindir

5485

continue

5486

;;

5487

5488

-dlopen)

5489

prev=dlfiles

5490

continue

5491

;;

5492

5493

-dlpreopen)

5494

prev=dlprefiles

5495

continue

5496

;;

5497

5498

-export-dynamic)

5499

export_dynamic=yes

5500

continue

5501

;;

5502

5503

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

5504

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

5505

func_fatal_error "more than one -exported-symbols argument is not allowed"

5506

fi

5507

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

5508

prev=expsyms

5509

else

5510

prev=expsyms_regex

5511

fi

5512

continue

5513

;;

5514

5515

-framework)

5516

prev=framework

5517

continue

5518

;;

5519

5520

-inst-prefix-dir)

5521

prev=inst_prefix

5522

continue

5523

;;

5524

5525

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

5526

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

5527

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

5528

case $with_gcc/$host in

5529

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

5530

func_append compile_command " $arg"

5531

func_append finalize_command " $arg"

5532

;;

5533

esac

5534

continue

5535

;;

5536

5537

-L*)

5538

func_stripname "-L" '' "$arg"

5539

if test -z "$func_stripname_result"; then

5540

if test "$#" -gt 0; then

5541

func_fatal_error "require no space between \`-L' and \`$1'"

5542

else

5543

func_fatal_error "need path for \`-L' option"

5544

fi

5545

fi

5546

func_resolve_sysroot "$func_stripname_result"

5547

dir=$func_resolve_sysroot_result

5548

# We need an absolute path.

5549

case $dir in

5550

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

5551

*)

5552

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

5553

test -z "$absdir" && \

5554

func_fatal_error "cannot determine absolute directory name of \`$dir'"

5555

dir="$absdir"

5556

;;

5557

esac

5558

case "$deplibs " in

5559

*" -L$dir "* | *" $arg "*)

5560

# Will only happen for absolute or sysroot arguments

5561

;;

5562

*)

5563

# Preserve sysroot, but never include relative directories

5564

case $dir in

5565

[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;

5566

*) func_append deplibs " -L$dir" ;;

5567

esac

5568

func_append lib_search_path " $dir"

5569

;;

5570

esac

5571

case $host in

5572

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

5573

testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`

5574

case :$dllsearchpath: in

5575

*":$dir:"*) ;;

5576

::) dllsearchpath=$dir;;

5577

*) func_append dllsearchpath ":$dir";;

5578

esac

5579

case :$dllsearchpath: in

5580

*":$testbindir:"*) ;;

5581

::) dllsearchpath=$testbindir;;

5582

*) func_append dllsearchpath ":$testbindir";;

5583

esac

5584

;;

5585

esac

5586

continue

5587

;;

5588

5589

-l*)

5590

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

5591

case $host in

5592

5593

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

5594

continue

5595

;;

5596

*-*-os2*)

5597

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

5598

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

5599

;;

5600

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

5601

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

5602

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

5603

;;

5604

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

5605

# Rhapsody C and math libraries are in the System framework

5606

func_append deplibs " System.ltframework"

5607

continue

5608

;;

5609

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

5610

# Causes problems with __ctype

5611

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

5612

;;

5613

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

5614

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

5615

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

5616

;;

5617

esac

5618

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

5619

case $host in

5620

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

5621

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

5622

continue

5623

;;

5624

esac

5625

fi

5626

func_append deplibs " $arg"

5627

continue

5628

;;

5629

5630

-module)

5631

module=yes

5632

continue

5633

;;

5634

5635

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

5636

# classes, name mangling, and exception handling.

5637

# Darwin uses the -arch flag to determine output architecture.

5638

-model|-arch|-isysroot|--sysroot)

5639

func_append compiler_flags " $arg"

5640

func_append compile_command " $arg"

5641

func_append finalize_command " $arg"

5642

prev=xcompiler

5643

continue

5644

;;

5645

5646

5647

func_append compiler_flags " $arg"

5648

func_append compile_command " $arg"

5649

func_append finalize_command " $arg"

5650

case "$new_inherited_linker_flags " in

5651

*" $arg "*) ;;

5652

* ) func_append new_inherited_linker_flags " $arg" ;;

5653

esac

5654

continue

5655

;;

5656

5657

-multi_module)

5658

single_module="${wl}-multi_module"

5659

continue

5660

;;

5661

5662

-no-fast-install)

5663

fast_install=no

5664

continue

5665

;;

5666

5667

-no-install)

5668

case $host in

5669

5670

# The PATH hackery in wrapper scripts is required on Windows

5671

# and Darwin in order for the loader to find any dlls it needs.

5672

func_warning "\`-no-install' is ignored for $host"

5673

func_warning "assuming \`-no-fast-install' instead"

5674

fast_install=no

5675

;;

5676

*) no_install=yes ;;

5677

esac

5678

continue

5679

;;

5680

5681

-no-undefined)

5682

allow_undefined=no

5683

continue

5684

;;

5685

5686

-objectlist)

5687

prev=objectlist

5688

continue

5689

;;

5690

5691

-o) prev=output ;;

5692

5693

-precious-files-regex)

5694

prev=precious_regex

5695

continue

5696

;;

5697

5698

-release)

5699

prev=release

5700

continue

5701

;;

5702

5703

-rpath)

5704

prev=rpath

5705

continue

5706

;;

5707

5708

-R)

5709

prev=xrpath

5710

continue

5711

;;

5712

5713

-R*)

5714

func_stripname '-R' '' "$arg"

5715

dir=$func_stripname_result

5716

# We need an absolute path.

5717

case $dir in

5718

[\\/]* | [A-Za-z]:[\\/]*) ;;

5719

=*)

5720

func_stripname '=' '' "$dir"

5721

dir=$lt_sysroot$func_stripname_result

5722

;;

5723

*)

5724

func_fatal_error "only absolute run-paths are allowed"

5725

;;

5726

esac

5727

case "$xrpath " in

5728

*" $dir "*) ;;

5729

*) func_append xrpath " $dir" ;;

5730

esac

5731

continue

5732

;;

5733

5734

-shared)

5735

# The effects of -shared are defined in a previous loop.

5736

continue

5737

;;

5738

5739

-shrext)

5740

prev=shrext

5741

continue

5742

;;

5743

5744

-static | -static-libtool-libs)

5745

# The effects of -static are defined in a previous loop.

5746

# We used to do the same as -all-static on platforms that

5747

# didn't have a PIC flag, but the assumption that the effects

5748

# would be equivalent was wrong. It would break on at least

5749

# Digital Unix and AIX.

5750

continue

5751

;;

5752

5753

-thread-safe)

5754

thread_safe=yes

5755

continue

5756

;;

5757

5758

-version-info)

5759

prev=vinfo

5760

continue

5761

;;

5762

5763

-version-number)

5764

prev=vinfo

5765

vinfo_number=yes

5766

continue

5767

;;

5768

5769

-weak)

5770

prev=weak

5771

continue

5772

;;

5773

5774

-Wc,*)

5775

func_stripname '-Wc,' '' "$arg"

5776

args=$func_stripname_result

5777

arg=

5778

save_ifs="$IFS"; IFS=','

5779

for flag in $args; do

5780

IFS="$save_ifs"

5781

func_quote_for_eval "$flag"

5782

func_append arg " $func_quote_for_eval_result"

5783

func_append compiler_flags " $func_quote_for_eval_result"

5784

done

5785

IFS="$save_ifs"

5786

func_stripname ' ' '' "$arg"

5787

arg=$func_stripname_result

5788

;;

5789

5790

-Wl,*)

5791

func_stripname '-Wl,' '' "$arg"

5792

args=$func_stripname_result

5793

arg=

5794

save_ifs="$IFS"; IFS=','

5795

for flag in $args; do

5796

IFS="$save_ifs"

5797

func_quote_for_eval "$flag"

5798

func_append arg " $wl$func_quote_for_eval_result"

5799

func_append compiler_flags " $wl$func_quote_for_eval_result"

5800

func_append linker_flags " $func_quote_for_eval_result"

5801

done

5802

IFS="$save_ifs"

5803

func_stripname ' ' '' "$arg"

5804

arg=$func_stripname_result

5805

;;

5806

5807

-Xcompiler)

5808

prev=xcompiler

5809

continue

5810

;;

5811

5812

-Xlinker)

5813

prev=xlinker

5814

continue

5815

;;

5816

5817

-XCClinker)

5818

prev=xcclinker

5819

continue

5820

;;

5821

5822

# -msg_* for osf cc

5823

-msg_*)

5824

func_quote_for_eval "$arg"

5825

arg="$func_quote_for_eval_result"

5826

;;

5827

5828

# Flags to be passed through unchanged, with rationale:

5829

# -64, -mips[0-9] enable 64-bit mode for the SGI compiler

5830

# -r[0-9][0-9]* specify processor for the SGI compiler

5831

# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler

5832

# +DA*, +DD* enable 64-bit mode for the HP compiler

5833

# -q* compiler args for the IBM compiler

5834

# -m*, -t[45]*, -txscale* architecture-specific flags for GCC

5835

# -F/path path to uninstalled frameworks, gcc on darwin

5836

# -p, -pg, --coverage, -fprofile-* profiling flags for GCC

5837

# @file GCC response files

5838

# -tp=* Portland pgcc target processor selection

5839

# --sysroot=* for sysroot support

5840

# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

5841

-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \

5842

-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \

5843

-O*|-flto*|-fwhopr*|-fuse-linker-plugin)

5844

func_quote_for_eval "$arg"

5845

arg="$func_quote_for_eval_result"

5846

func_append compile_command " $arg"

5847

func_append finalize_command " $arg"

5848

func_append compiler_flags " $arg"

5849

continue

5850

;;

5851

5852

# Some other compiler flag.

5853

-* | +*)

5854

func_quote_for_eval "$arg"

5855

arg="$func_quote_for_eval_result"

5856

;;

5857

5858

*.$objext)

5859

# A standard object.

5860

func_append objs " $arg"

5861

;;

5862

5863

*.lo)

5864

# A libtool-controlled object.

5865

5866

# Check to see that this really is a libtool object.

5867

if func_lalib_unsafe_p "$arg"; then

5868

pic_object=

5869

non_pic_object=

5870

5871

# Read the .lo file

5872

func_source "$arg"

5873

5874

if test -z "$pic_object" ||

5875

test -z "$non_pic_object" ||

5876

test "$pic_object" = none &&

5877

test "$non_pic_object" = none; then

5878

func_fatal_error "cannot find name of object for \`$arg'"

5879

fi

5880

5881

# Extract subdirectory from the argument.

5882

func_dirname "$arg" "/" ""

5883

xdir="$func_dirname_result"

5884

5885

if test "$pic_object" != none; then

5886

# Prepend the subdirectory the object is found in.

5887

pic_object="$xdir$pic_object"

5888

5889

if test "$prev" = dlfiles; then

5890

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

5891

func_append dlfiles " $pic_object"

5892

prev=

5893

continue

5894

else

5895

# If libtool objects are unsupported, then we need to preload.

5896

prev=dlprefiles

5897

fi

5898

fi

5899

5900

# CHECK ME: I think I busted this. -Ossama

5901

if test "$prev" = dlprefiles; then

5902

# Preload the old-style object.

5903

func_append dlprefiles " $pic_object"

5904

prev=

5905

fi

5906

5907

# A PIC object.

5908

func_append libobjs " $pic_object"

5909

arg="$pic_object"

5910

fi

5911

5912

# Non-PIC object.

5913

if test "$non_pic_object" != none; then

5914

# Prepend the subdirectory the object is found in.

5915

non_pic_object="$xdir$non_pic_object"

5916

5917

# A standard non-PIC object

5918

func_append non_pic_objects " $non_pic_object"

5919

if test -z "$pic_object" || test "$pic_object" = none ; then

5920

arg="$non_pic_object"

5921

fi

5922

else

5923

# If the PIC object exists, use it instead.

5924

# $xdir was prepended to $pic_object above.

5925

non_pic_object="$pic_object"

5926

func_append non_pic_objects " $non_pic_object"

5927

fi

5928

else

5929

# Only an error if not doing a dry-run.

5930

if $opt_dry_run; then

5931

# Extract subdirectory from the argument.

5932

func_dirname "$arg" "/" ""

5933

xdir="$func_dirname_result"

5934

5935

func_lo2o "$arg"

5936

pic_object=$xdir$objdir/$func_lo2o_result

5937

non_pic_object=$xdir$func_lo2o_result

5938

func_append libobjs " $pic_object"

5939

func_append non_pic_objects " $non_pic_object"

5940

else

5941

func_fatal_error "\`$arg' is not a valid libtool object"

5942

fi

5943

fi

5944

;;

5945

5946

*.$libext)

5947

# An archive.

5948

func_append deplibs " $arg"

5949

func_append old_deplibs " $arg"

5950

continue

5951

;;

5952

5953

*.la)

5954

# A libtool-controlled library.

5955

5956

func_resolve_sysroot "$arg"

5957

if test "$prev" = dlfiles; then

5958

# This library was specified with -dlopen.

5959

func_append dlfiles " $func_resolve_sysroot_result"

5960

prev=

5961

elif test "$prev" = dlprefiles; then

5962

# The library was specified with -dlpreopen.

5963

func_append dlprefiles " $func_resolve_sysroot_result"

5964

prev=

5965

else

5966

func_append deplibs " $func_resolve_sysroot_result"

5967

fi

5968

continue

5969

;;

5970

5971

# Some other compiler argument.

5972

*)

5973

# Unknown arguments in both finalize_command and compile_command need

5974

# to be aesthetically quoted because they are evaled later.

5975

func_quote_for_eval "$arg"

5976

arg="$func_quote_for_eval_result"

5977

;;

5978

esac # arg

5979

5980

# Now actually substitute the argument into the commands.

5981

if test -n "$arg"; then

5982

func_append compile_command " $arg"

5983

func_append finalize_command " $arg"

5984

fi

5985

done # argument parsing loop

5986

5987

test -n "$prev" && \

5988

func_fatal_help "the \`$prevarg' option requires an argument"

5989

5990

if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

5991

eval arg=\"$export_dynamic_flag_spec\"

5992

func_append compile_command " $arg"

5993

func_append finalize_command " $arg"

5994

fi

5995

5996

oldlibs=

5997

# calculate the name of the file, without its directory

5998

func_basename "$output"

5999

outputname="$func_basename_result"

6000

libobjs_save="$libobjs"

6001

6002

if test -n "$shlibpath_var"; then

6003

# get the directories listed in $shlibpath_var

6004

eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`

6005

else

6006

shlib_search_path=

6007

fi

6008

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

6009

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

6010

6011

func_dirname "$output" "/" ""

6012

output_objdir="$func_dirname_result$objdir"

6013

func_to_tool_file "$output_objdir/"

6014

tool_output_objdir=$func_to_tool_file_result

6015

# Create the object directory.

6016

func_mkdir_p "$output_objdir"

6017

6018

# Determine the type of output

6019

case $output in

6020

"")

6021

func_fatal_help "you must specify an output file"

6022

;;

6023

*.$libext) linkmode=oldlib ;;

6024

*.lo | *.$objext) linkmode=obj ;;

6025

*.la) linkmode=lib ;;

6026

*) linkmode=prog ;; # Anything else should be a program.

6027

esac

6028

6029

specialdeplibs=

6030

6031

libs=

6032

# Find all interdependent deplibs by searching for libraries

6033

# that are linked more than once (e.g. -la -lb -la)

6034

for deplib in $deplibs; do

6035

if $opt_preserve_dup_deps ; then

6036

case "$libs " in

6037

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6038

esac

6039

fi

6040

func_append libs " $deplib"

6041

done

6042

6043

if test "$linkmode" = lib; then

6044

libs="$predeps $libs $compiler_lib_search_path $postdeps"

6045

6046

# Compute libraries that are listed more than once in $predeps

6047

# $postdeps and mark them as special (i.e., whose duplicates are

6048

# not to be eliminated).

6049

pre_post_deps=

6050

if $opt_duplicate_compiler_generated_deps; then

6051

for pre_post_dep in $predeps $postdeps; do

6052

case "$pre_post_deps " in

6053

*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;

6054

esac

6055

func_append pre_post_deps " $pre_post_dep"

6056

done

6057

fi

6058

pre_post_deps=

6059

fi

6060

6061

deplibs=

6062

newdependency_libs=

6063

newlib_search_path=

6064

need_relink=no # whether we're linking any uninstalled libtool libraries

6065

notinst_deplibs= # not-installed libtool libraries

6066

notinst_path= # paths that contain not-installed libtool libraries

6067

6068

case $linkmode in

6069

lib)

6070

passes="conv dlpreopen link"

6071

for file in $dlfiles $dlprefiles; do

6072

case $file in

6073

*.la) ;;

6074

*)

6075

func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"

6076

;;

6077

esac

6078

done

6079

;;

6080

prog)

6081

compile_deplibs=

6082

finalize_deplibs=

6083

alldeplibs=no

6084

newdlfiles=

6085

newdlprefiles=

6086

passes="conv scan dlopen dlpreopen link"

6087

;;

6088

*) passes="conv"

6089

;;

6090

esac

6091

6092

for pass in $passes; do

6093

# The preopen pass in lib mode reverses $deplibs; put it back here

6094

# so that -L comes before libs that need it for instance...

6095

if test "$linkmode,$pass" = "lib,link"; then

6096

## FIXME: Find the place where the list is rebuilt in the wrong

6097

## order, and fix it there properly

6098

tmp_deplibs=

6099

for deplib in $deplibs; do

6100

tmp_deplibs="$deplib $tmp_deplibs"

6101

done

6102

deplibs="$tmp_deplibs"

6103

fi

6104

6105

if test "$linkmode,$pass" = "lib,link" ||

6106

test "$linkmode,$pass" = "prog,scan"; then

6107

libs="$deplibs"

6108

deplibs=

6109

fi

6110

if test "$linkmode" = prog; then

6111

case $pass in

6112

dlopen) libs="$dlfiles" ;;

6113

dlpreopen) libs="$dlprefiles" ;;

6114

link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

6115

esac

6116

fi

6117

if test "$linkmode,$pass" = "lib,dlpreopen"; then

6118

# Collect and forward deplibs of preopened libtool libs

6119

for lib in $dlprefiles; do

6120

# Ignore non-libtool-libs

6121

dependency_libs=

6122

func_resolve_sysroot "$lib"

6123

case $lib in

6124

*.la) func_source "$func_resolve_sysroot_result" ;;

6125

esac

6126

6127

# Collect preopened libtool deplibs, except any this library

6128

# has declared as weak libs

6129

for deplib in $dependency_libs; do

6130

func_basename "$deplib"

6131

deplib_base=$func_basename_result

6132

case " $weak_libs " in

6133

*" $deplib_base "*) ;;

6134

*) func_append deplibs " $deplib" ;;

6135

esac

6136

done

6137

done

6138

libs="$dlprefiles"

6139

fi

6140

if test "$pass" = dlopen; then

6141

# Collect dlpreopened libraries

6142

save_deplibs="$deplibs"

6143

deplibs=

6144

fi

6145

6146

for deplib in $libs; do

6147

lib=

6148

found=no

6149

case $deplib in

6150

6151

if test "$linkmode,$pass" = "prog,link"; then

6152

compile_deplibs="$deplib $compile_deplibs"

6153

finalize_deplibs="$deplib $finalize_deplibs"

6154

else

6155

func_append compiler_flags " $deplib"

6156

if test "$linkmode" = lib ; then

6157

case "$new_inherited_linker_flags " in

6158

*" $deplib "*) ;;

6159

* ) func_append new_inherited_linker_flags " $deplib" ;;

6160

esac

6161

fi

6162

fi

6163

continue

6164

;;

6165

-l*)

6166

if test "$linkmode" != lib && test "$linkmode" != prog; then

6167

func_warning "\`-l' is ignored for archives/objects"

6168

continue

6169

fi

6170

func_stripname '-l' '' "$deplib"

6171

name=$func_stripname_result

6172

if test "$linkmode" = lib; then

6173

searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"

6174

else

6175

searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"

6176

fi

6177

for searchdir in $searchdirs; do

6178

for search_ext in .la $std_shrext .so .a; do

6179

# Search the libtool library

6180

lib="$searchdir/lib${name}${search_ext}"

6181

if test -f "$lib"; then

6182

if test "$search_ext" = ".la"; then

6183

found=yes

6184

else

6185

found=no

6186

fi

6187

break 2

6188

fi

6189

done

6190

done

6191

if test "$found" != yes; then

6192

# deplib doesn't seem to be a libtool library

6193

if test "$linkmode,$pass" = "prog,link"; then

6194

compile_deplibs="$deplib $compile_deplibs"

6195

finalize_deplibs="$deplib $finalize_deplibs"

6196

else

6197

deplibs="$deplib $deplibs"

6198

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6199

fi

6200

continue

6201

else # deplib is a libtool library

6202

# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

6203

# We need to do some special things here, and not later.

6204

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

6205

case " $predeps $postdeps " in

6206

*" $deplib "*)

6207

if func_lalib_p "$lib"; then

6208

library_names=

6209

old_library=

6210

func_source "$lib"

6211

for l in $old_library $library_names; do

6212

ll="$l"

6213

done

6214

if test "X$ll" = "X$old_library" ; then # only static version available

6215

found=no

6216

func_dirname "$lib" "" "."

6217

ladir="$func_dirname_result"

6218

lib=$ladir/$old_library

6219

if test "$linkmode,$pass" = "prog,link"; then

6220

compile_deplibs="$deplib $compile_deplibs"

6221

finalize_deplibs="$deplib $finalize_deplibs"

6222

else

6223

deplibs="$deplib $deplibs"

6224

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6225

fi

6226

continue

6227

fi

6228

fi

6229

;;

6230

*) ;;

6231

esac

6232

fi

6233

fi

6234

;; # -l

6235

*.ltframework)

6236

if test "$linkmode,$pass" = "prog,link"; then

6237

compile_deplibs="$deplib $compile_deplibs"

6238

finalize_deplibs="$deplib $finalize_deplibs"

6239

else

6240

deplibs="$deplib $deplibs"

6241

if test "$linkmode" = lib ; then

6242

case "$new_inherited_linker_flags " in

6243

*" $deplib "*) ;;

6244

* ) func_append new_inherited_linker_flags " $deplib" ;;

6245

esac

6246

fi

6247

fi

6248

continue

6249

;;

6250

-L*)

6251

case $linkmode in

6252

lib)

6253

deplibs="$deplib $deplibs"

6254

test "$pass" = conv && continue

6255

newdependency_libs="$deplib $newdependency_libs"

6256

func_stripname '-L' '' "$deplib"

6257

func_resolve_sysroot "$func_stripname_result"

6258

func_append newlib_search_path " $func_resolve_sysroot_result"

6259

;;

6260

prog)

6261

if test "$pass" = conv; then

6262

deplibs="$deplib $deplibs"

6263

continue

6264

fi

6265

if test "$pass" = scan; then

6266

deplibs="$deplib $deplibs"

6267

else

6268

compile_deplibs="$deplib $compile_deplibs"

6269

finalize_deplibs="$deplib $finalize_deplibs"

6270

fi

6271

func_stripname '-L' '' "$deplib"

6272

func_resolve_sysroot "$func_stripname_result"

6273

func_append newlib_search_path " $func_resolve_sysroot_result"

6274

;;

6275

*)

6276

func_warning "\`-L' is ignored for archives/objects"

6277

;;

6278

esac # linkmode

6279

continue

6280

;; # -L

6281

-R*)

6282

if test "$pass" = link; then

6283

func_stripname '-R' '' "$deplib"

6284

func_resolve_sysroot "$func_stripname_result"

6285

dir=$func_resolve_sysroot_result

6286

# Make sure the xrpath contains only unique directories.

6287

case "$xrpath " in

6288

*" $dir "*) ;;

6289

*) func_append xrpath " $dir" ;;

6290

esac

6291

fi

6292

deplibs="$deplib $deplibs"

6293

continue

6294

;;

6295

*.la)

6296

func_resolve_sysroot "$deplib"

6297

lib=$func_resolve_sysroot_result

6298

;;

6299

*.$libext)

6300

if test "$pass" = conv; then

6301

deplibs="$deplib $deplibs"

6302

continue

6303

fi

6304

case $linkmode in

6305

lib)

6306

# Linking convenience modules into shared libraries is allowed,

6307

# but linking other static libraries is non-portable.

6308

case " $dlpreconveniencelibs " in

6309

*" $deplib "*) ;;

6310

*)

6311

valid_a_lib=no

6312

case $deplibs_check_method in

6313

match_pattern*)

6314

set dummy $deplibs_check_method; shift

6315

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

6316

if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \

6317

| $EGREP "$match_pattern_regex" > /dev/null; then

6318

valid_a_lib=yes

6319

fi

6320

;;

6321

pass_all)

6322

valid_a_lib=yes

6323

;;

6324

esac

6325

if test "$valid_a_lib" != yes; then

6326

echo

6327

$ECHO "*** Warning: Trying to link with static lib archive $deplib."

6328

echo "*** I have the capability to make that library automatically link in when"

6329

echo "*** you link to this library. But I can only do this if you have a"

6330

echo "*** shared version of the library, which you do not appear to have"

6331

echo "*** because the file extensions .$libext of this argument makes me believe"

6332

echo "*** that it is just a static archive that I should not use here."

6333

else

6334

echo

6335

$ECHO "*** Warning: Linking the shared library $output against the"

6336

$ECHO "*** static library $deplib is not portable!"

6337

deplibs="$deplib $deplibs"

6338

fi

6339

;;

6340

esac

6341

continue

6342

;;

6343

prog)

6344

if test "$pass" != link; then

6345

deplibs="$deplib $deplibs"

6346

else

6347

compile_deplibs="$deplib $compile_deplibs"

6348

finalize_deplibs="$deplib $finalize_deplibs"

6349

fi

6350

continue

6351

;;

6352

esac # linkmode

6353

;; # *.$libext

6354

*.lo | *.$objext)

6355

if test "$pass" = conv; then

6356

deplibs="$deplib $deplibs"

6357

elif test "$linkmode" = prog; then

6358

if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

6359

# If there is no dlopen support or we're linking statically,

6360

# we need to preload.

6361

func_append newdlprefiles " $deplib"

6362

compile_deplibs="$deplib $compile_deplibs"

6363

finalize_deplibs="$deplib $finalize_deplibs"

6364

else

6365

func_append newdlfiles " $deplib"

6366

fi

6367

fi

6368

continue

6369

;;

6370

%DEPLIBS%)

6371

alldeplibs=yes

6372

continue

6373

;;

6374

esac # case $deplib

6375

6376

if test "$found" = yes || test -f "$lib"; then :

6377

else

6378

func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

6379

fi

6380

6381

# Check to see that this really is a libtool archive.

6382

func_lalib_unsafe_p "$lib" \

6383

|| func_fatal_error "\`$lib' is not a valid libtool archive"

6384

6385

func_dirname "$lib" "" "."

6386

ladir="$func_dirname_result"

6387

6388

dlname=

6389

dlopen=

6390

dlpreopen=

6391

libdir=

6392

library_names=

6393

old_library=

6394

inherited_linker_flags=

6395

# If the library was installed with an old release of libtool,

6396

# it will not redefine variables installed, or shouldnotlink

6397

installed=yes

6398

shouldnotlink=no

6399

avoidtemprpath=

6400

6401

6402

# Read the .la file

6403

func_source "$lib"

6404

6405

# Convert "-framework foo" to "foo.ltframework"

6406

if test -n "$inherited_linker_flags"; then

6407

tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $[^ $]*$/\1.ltframework/g'`

6408

for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

6409

case " $new_inherited_linker_flags " in

6410

*" $tmp_inherited_linker_flag "*) ;;

6411

*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;

6412

esac

6413

done

6414

fi

6415

dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6416

if test "$linkmode,$pass" = "lib,link" ||

6417

test "$linkmode,$pass" = "prog,scan" ||

6418

{ test "$linkmode" != prog && test "$linkmode" != lib; }; then

6419

test -n "$dlopen" && func_append dlfiles " $dlopen"

6420

test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"

6421

fi

6422

6423

if test "$pass" = conv; then

6424

# Only check for convenience libraries

6425

deplibs="$lib $deplibs"

6426

if test -z "$libdir"; then

6427

if test -z "$old_library"; then

6428

func_fatal_error "cannot find name of link library for \`$lib'"

6429

fi

6430

# It is a libtool convenience library, so add in its objects.

6431

func_append convenience " $ladir/$objdir/$old_library"

6432

func_append old_convenience " $ladir/$objdir/$old_library"

6433

elif test "$linkmode" != prog && test "$linkmode" != lib; then

6434

func_fatal_error "\`$lib' is not a convenience library"

6435

fi

6436

tmp_libs=

6437

for deplib in $dependency_libs; do

6438

deplibs="$deplib $deplibs"

6439

if $opt_preserve_dup_deps ; then

6440

case "$tmp_libs " in

6441

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6442

esac

6443

fi

6444

func_append tmp_libs " $deplib"

6445

done

6446

continue

6447

fi # $pass = conv

6448

6449

6450

# Get the name of the library we link against.

6451

linklib=

6452

if test -n "$old_library" &&

6453

{ test "$prefer_static_libs" = yes ||

6454

test "$prefer_static_libs,$installed" = "built,no"; }; then

6455

linklib=$old_library

6456

else

6457

for l in $old_library $library_names; do

6458

linklib="$l"

6459

done

6460

fi

6461

if test -z "$linklib"; then

6462

func_fatal_error "cannot find name of link library for \`$lib'"

6463

fi

6464

6465

# This library was specified with -dlopen.

6466

if test "$pass" = dlopen; then

6467

if test -z "$libdir"; then

6468

func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

6469

fi

6470

if test -z "$dlname" ||

6471

test "$dlopen_support" != yes ||

6472

test "$build_libtool_libs" = no; then

6473

# If there is no dlname, no dlopen support or we're linking

6474

# statically, we need to preload. We also need to preload any

6475

# dependent libraries so libltdl's deplib preloader doesn't

6476

# bomb out in the load deplibs phase.

6477

func_append dlprefiles " $lib $dependency_libs"

6478

else

6479

func_append newdlfiles " $lib"

6480

fi

6481

continue

6482

fi # $pass = dlopen

6483

6484

# We need an absolute path.

6485

case $ladir in

6486

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

6487

*)

6488

abs_ladir=`cd "$ladir" && pwd`

6489

if test -z "$abs_ladir"; then

6490

func_warning "cannot determine absolute directory name of \`$ladir'"

6491

func_warning "passing it literally to the linker, although it might fail"

6492

abs_ladir="$ladir"

6493

fi

6494

;;

6495

esac

6496

func_basename "$lib"

6497

laname="$func_basename_result"

6498

6499

# Find the relevant object directory and library name.

6500

if test "X$installed" = Xyes; then

6501

if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6502

func_warning "library \`$lib' was moved."

6503

dir="$ladir"

6504

absdir="$abs_ladir"

6505

libdir="$abs_ladir"

6506

else

6507

dir="$lt_sysroot$libdir"

6508

absdir="$lt_sysroot$libdir"

6509

fi

6510

test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

6511

else

6512

if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6513

dir="$ladir"

6514

absdir="$abs_ladir"

6515

# Remove this search path later

6516

func_append notinst_path " $abs_ladir"

6517

else

6518

dir="$ladir/$objdir"

6519

absdir="$abs_ladir/$objdir"

6520

# Remove this search path later

6521

func_append notinst_path " $abs_ladir"

6522

fi

6523

fi # $installed = yes

6524

func_stripname 'lib' '.la' "$laname"

6525

name=$func_stripname_result

6526

6527

# This library was specified with -dlpreopen.

6528

if test "$pass" = dlpreopen; then

6529

if test -z "$libdir" && test "$linkmode" = prog; then

6530

func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

6531

fi

6532

case "$host" in

6533

# special handling for platforms with PE-DLLs.

6534

*cygwin* | *mingw* | *cegcc* )

6535

# Linker will automatically link against shared library if both

6536

# static and shared are present. Therefore, ensure we extract

6537

# symbols from the import library if a shared library is present

6538

# (otherwise, the dlopen module name will be incorrect). We do

6539

# this by putting the import library name into $newdlprefiles.

6540

# We recover the dlopen module name by 'saving' the la file

6541

# name in a special purpose variable, and (later) extracting the

6542

# dlname from the la file.

6543

if test -n "$dlname"; then

6544

func_tr_sh "$dir/$linklib"

6545

eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"

6546

func_append newdlprefiles " $dir/$linklib"

6547

else

6548

func_append newdlprefiles " $dir/$old_library"

6549

# Keep a list of preopened convenience libraries to check

6550

# that they are being used correctly in the link pass.

6551

test -z "$libdir" && \

6552

func_append dlpreconveniencelibs " $dir/$old_library"

6553

fi

6554

;;

6555

* )

6556

# Prefer using a static library (so that no silly _DYNAMIC symbols

6557

# are required to link).

6558

if test -n "$old_library"; then

6559

func_append newdlprefiles " $dir/$old_library"

6560

# Keep a list of preopened convenience libraries to check

6561

# that they are being used correctly in the link pass.

6562

test -z "$libdir" && \

6563

func_append dlpreconveniencelibs " $dir/$old_library"

6564

# Otherwise, use the dlname, so that lt_dlopen finds it.

6565

elif test -n "$dlname"; then

6566

func_append newdlprefiles " $dir/$dlname"

6567

else

6568

func_append newdlprefiles " $dir/$linklib"

6569

fi

6570

;;

6571

esac

6572

fi # $pass = dlpreopen

6573

6574

if test -z "$libdir"; then

6575

# Link the convenience library

6576

if test "$linkmode" = lib; then

6577

deplibs="$dir/$old_library $deplibs"

6578

elif test "$linkmode,$pass" = "prog,link"; then

6579

compile_deplibs="$dir/$old_library $compile_deplibs"

6580

finalize_deplibs="$dir/$old_library $finalize_deplibs"

6581

else

6582

deplibs="$lib $deplibs" # used for prog,scan pass

6583

fi

6584

continue

6585

fi

6586

6587

6588

if test "$linkmode" = prog && test "$pass" != link; then

6589

func_append newlib_search_path " $ladir"

6590

deplibs="$lib $deplibs"

6591

6592

linkalldeplibs=no

6593

if test "$link_all_deplibs" != no || test -z "$library_names" ||

6594

test "$build_libtool_libs" = no; then

6595

linkalldeplibs=yes

6596

fi

6597

6598

tmp_libs=

6599

for deplib in $dependency_libs; do

6600

case $deplib in

6601

-L*) func_stripname '-L' '' "$deplib"

6602

func_resolve_sysroot "$func_stripname_result"

6603

func_append newlib_search_path " $func_resolve_sysroot_result"

6604

;;

6605

esac

6606

# Need to link against all dependency_libs?

6607

if test "$linkalldeplibs" = yes; then

6608

deplibs="$deplib $deplibs"

6609

else

6610

# Need to hardcode shared library paths

6611

# or/and link against static libraries

6612

newdependency_libs="$deplib $newdependency_libs"

6613

fi

6614

if $opt_preserve_dup_deps ; then

6615

case "$tmp_libs " in

6616

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6617

esac

6618

fi

6619

func_append tmp_libs " $deplib"

6620

done # for deplib

6621

continue

6622

fi # $linkmode = prog...

6623

6624

if test "$linkmode,$pass" = "prog,link"; then

6625

if test -n "$library_names" &&

6626

{ { test "$prefer_static_libs" = no ||

6627

test "$prefer_static_libs,$installed" = "built,yes"; } ||

6628

test -z "$old_library"; }; then

6629

# We need to hardcode the library path

6630

if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

6631

# Make sure the rpath contains only unique directories.

6632

case "$temp_rpath:" in

6633

*"$absdir:"*) ;;

6634

*) func_append temp_rpath "$absdir:" ;;

6635

esac

6636

fi

6637

6638

# Hardcode the library path.

6639

# Skip directories that are in the system default run-time

6640

# search path.

6641

case " $sys_lib_dlsearch_path " in

6642

*" $absdir "*) ;;

6643

*)

6644

case "$compile_rpath " in

6645

*" $absdir "*) ;;

6646

*) func_append compile_rpath " $absdir" ;;

6647

esac

6648

;;

6649

esac

6650

case " $sys_lib_dlsearch_path " in

6651

*" $libdir "*) ;;

6652

*)

6653

case "$finalize_rpath " in

6654

*" $libdir "*) ;;

6655

*) func_append finalize_rpath " $libdir" ;;

6656

esac

6657

;;

6658

esac

6659

fi # $linkmode,$pass = prog,link...

6660

6661

if test "$alldeplibs" = yes &&

6662

{ test "$deplibs_check_method" = pass_all ||

6663

{ test "$build_libtool_libs" = yes &&

6664

test -n "$library_names"; }; }; then

6665

# We only need to search for static libraries

6666

continue

6667

fi

6668

fi

6669

6670

link_static=no # Whether the deplib will be linked statically

6671

use_static_libs=$prefer_static_libs

6672

if test "$use_static_libs" = built && test "$installed" = yes; then

6673

use_static_libs=no

6674

fi

6675

if test -n "$library_names" &&

6676

{ test "$use_static_libs" = no || test -z "$old_library"; }; then

6677

case $host in

6678

*cygwin* | *mingw* | *cegcc*)

6679

# No point in relinking DLLs because paths are not encoded

6680

func_append notinst_deplibs " $lib"

6681

need_relink=no

6682

;;

6683

*)

6684

if test "$installed" = no; then

6685

func_append notinst_deplibs " $lib"

6686

need_relink=yes

6687

fi

6688

;;

6689

esac

6690

# This is a shared library

6691

6692

# Warn about portability, can't link against -module's on some

6693

# systems (darwin). Don't bleat about dlopened modules though!

6694

dlopenmodule=""

6695

for dlpremoduletest in $dlprefiles; do

6696

if test "X$dlpremoduletest" = "X$lib"; then

6697

dlopenmodule="$dlpremoduletest"

6698

break

6699

fi

6700

done

6701

if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

6702

echo

6703

if test "$linkmode" = prog; then

6704

$ECHO "*** Warning: Linking the executable $output against the loadable module"

6705

else

6706

$ECHO "*** Warning: Linking the shared library $output against the loadable module"

6707

fi

6708

$ECHO "*** $linklib is not portable!"

6709

fi

6710

if test "$linkmode" = lib &&

6711

test "$hardcode_into_libs" = yes; then

6712

# Hardcode the library path.

6713

# Skip directories that are in the system default run-time

6714

# search path.

6715

case " $sys_lib_dlsearch_path " in

6716

*" $absdir "*) ;;

6717

*)

6718

case "$compile_rpath " in

6719

*" $absdir "*) ;;

6720

*) func_append compile_rpath " $absdir" ;;

6721

esac

6722

;;

6723

esac

6724

case " $sys_lib_dlsearch_path " in

6725

*" $libdir "*) ;;

6726

*)

6727

case "$finalize_rpath " in

6728

*" $libdir "*) ;;

6729

*) func_append finalize_rpath " $libdir" ;;

6730

esac

6731

;;

6732

esac

6733

fi

6734

6735

if test -n "$old_archive_from_expsyms_cmds"; then

6736

# figure out the soname

6737

set dummy $library_names

6738

shift

6739

realname="$1"

6740

shift

6741

libname=`eval "\\$ECHO \"$libname_spec\""`

6742

# use dlname if we got it. it's perfectly good, no?

6743

if test -n "$dlname"; then

6744

soname="$dlname"

6745

elif test -n "$soname_spec"; then

6746

# bleh windows

6747

case $host in

6748

*cygwin* | mingw* | *cegcc*)

6749

func_arith $current - $age

6750

major=$func_arith_result

6751

versuffix="-$major"

6752

;;

6753

esac

6754

eval soname=\"$soname_spec\"

6755

else

6756

soname="$realname"

6757

fi

6758

6759

# Make a new name for the extract_expsyms_cmds to use

6760

soroot="$soname"

6761

func_basename "$soroot"

6762

soname="$func_basename_result"

6763

func_stripname 'lib' '.dll' "$soname"

6764

newlib=libimp-$func_stripname_result.a

6765

6766

# If the library has no export list, then create one now

6767

if test -f "$output_objdir/$soname-def"; then :

6768

else

6769

func_verbose "extracting exported symbol list from \`$soname'"

6770

func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

6771

fi

6772

6773

# Create $newlib

6774

if test -f "$output_objdir/$newlib"; then :; else

6775

func_verbose "generating import library for \`$soname'"

6776

func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

6777

fi

6778

# make sure the library variables are pointing to the new library

6779

dir=$output_objdir

6780

linklib=$newlib

6781

fi # test -n "$old_archive_from_expsyms_cmds"

6782

6783

if test "$linkmode" = prog || test "$opt_mode" != relink; then

6784

add_shlibpath=

6785

add_dir=

6786

add=

6787

lib_linked=yes

6788

case $hardcode_action in

6789

immediate | unsupported)

6790

if test "$hardcode_direct" = no; then

6791

add="$dir/$linklib"

6792

case $host in

6793

*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

6794

*-*-sysv4*uw2*) add_dir="-L$dir" ;;

6795

*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

6796

*-*-unixware7*) add_dir="-L$dir" ;;

6797

*-*-darwin* )

6798

# if the lib is a (non-dlopened) module then we can not

6799

# link against it, someone is ignoring the earlier warnings

6800

if /usr/bin/file -L $add 2> /dev/null |

6801

$GREP ": [^:]* bundle" >/dev/null ; then

6802

if test "X$dlopenmodule" != "X$lib"; then

6803

$ECHO "*** Warning: lib $linklib is a module, not a shared library"

6804

if test -z "$old_library" ; then

6805

echo

6806

echo "*** And there doesn't seem to be a static archive available"

6807

echo "*** The link will probably fail, sorry"

6808

else

6809

add="$dir/$old_library"

6810

fi

6811

elif test -n "$old_library"; then

6812

add="$dir/$old_library"

6813

fi

6814

fi

6815

esac

6816

elif test "$hardcode_minus_L" = no; then

6817

case $host in

6818

*-*-sunos*) add_shlibpath="$dir" ;;

6819

esac

6820

add_dir="-L$dir"

6821

add="-l$name"

6822

elif test "$hardcode_shlibpath_var" = no; then

6823

add_shlibpath="$dir"

6824

add="-l$name"

6825

else

6826

lib_linked=no

6827

fi

6828

;;

6829

relink)

6830

if test "$hardcode_direct" = yes &&

6831

test "$hardcode_direct_absolute" = no; then

6832

add="$dir/$linklib"

6833

elif test "$hardcode_minus_L" = yes; then

6834

add_dir="-L$dir"

6835

# Try looking first in the location we're being installed to.

6836

if test -n "$inst_prefix_dir"; then

6837

case $libdir in

6838

[\\/]*)

6839

func_append add_dir " -L$inst_prefix_dir$libdir"

6840

;;

6841

esac

6842

fi

6843

add="-l$name"

6844

elif test "$hardcode_shlibpath_var" = yes; then

6845

add_shlibpath="$dir"

6846

add="-l$name"

6847

else

6848

lib_linked=no

6849

fi

6850

;;

6851

*) lib_linked=no ;;

6852

esac

6853

6854

if test "$lib_linked" != yes; then

6855

func_fatal_configuration "unsupported hardcode properties"

6856

fi

6857

6858

if test -n "$add_shlibpath"; then

6859

case :$compile_shlibpath: in

6860

*":$add_shlibpath:"*) ;;

6861

*) func_append compile_shlibpath "$add_shlibpath:" ;;

6862

esac

6863

fi

6864

if test "$linkmode" = prog; then

6865

test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

6866

test -n "$add" && compile_deplibs="$add $compile_deplibs"

6867

else

6868

test -n "$add_dir" && deplibs="$add_dir $deplibs"

6869

test -n "$add" && deplibs="$add $deplibs"

6870

if test "$hardcode_direct" != yes &&

6871

test "$hardcode_minus_L" != yes &&

6872

test "$hardcode_shlibpath_var" = yes; then

6873

case :$finalize_shlibpath: in

6874

*":$libdir:"*) ;;

6875

*) func_append finalize_shlibpath "$libdir:" ;;

6876

esac

6877

fi

6878

fi

6879

fi

6880

6881

if test "$linkmode" = prog || test "$opt_mode" = relink; then

6882

add_shlibpath=

6883

add_dir=

6884

add=

6885

# Finalize command for both is simple: just hardcode it.

6886

if test "$hardcode_direct" = yes &&

6887

test "$hardcode_direct_absolute" = no; then

6888

add="$libdir/$linklib"

6889

elif test "$hardcode_minus_L" = yes; then

6890

add_dir="-L$libdir"

6891

add="-l$name"

6892

elif test "$hardcode_shlibpath_var" = yes; then

6893

case :$finalize_shlibpath: in

6894

*":$libdir:"*) ;;

6895

*) func_append finalize_shlibpath "$libdir:" ;;

6896

esac

6897

add="-l$name"

6898

elif test "$hardcode_automatic" = yes; then

6899

if test -n "$inst_prefix_dir" &&

6900

test -f "$inst_prefix_dir$libdir/$linklib" ; then

6901

add="$inst_prefix_dir$libdir/$linklib"

6902

else

6903

add="$libdir/$linklib"

6904

fi

6905

else

6906

# We cannot seem to hardcode it, guess we'll fake it.

6907

add_dir="-L$libdir"

6908

# Try looking first in the location we're being installed to.

6909

if test -n "$inst_prefix_dir"; then

6910

case $libdir in

6911

[\\/]*)

6912

func_append add_dir " -L$inst_prefix_dir$libdir"

6913

;;

6914

esac

6915

fi

6916

add="-l$name"

6917

fi

6918

6919

if test "$linkmode" = prog; then

6920

test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

6921

test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

6922

else

6923

test -n "$add_dir" && deplibs="$add_dir $deplibs"

6924

test -n "$add" && deplibs="$add $deplibs"

6925

fi

6926

fi

6927

elif test "$linkmode" = prog; then

6928

# Here we assume that one of hardcode_direct or hardcode_minus_L

6929

# is not unsupported. This is valid on all known static and

6930

# shared platforms.

6931

if test "$hardcode_direct" != unsupported; then

6932

test -n "$old_library" && linklib="$old_library"

6933

compile_deplibs="$dir/$linklib $compile_deplibs"

6934

finalize_deplibs="$dir/$linklib $finalize_deplibs"

6935

else

6936

compile_deplibs="-l$name -L$dir $compile_deplibs"

6937

finalize_deplibs="-l$name -L$dir $finalize_deplibs"

6938

fi

6939

elif test "$build_libtool_libs" = yes; then

6940

# Not a shared library

6941

if test "$deplibs_check_method" != pass_all; then

6942

# We're trying link a shared library against a static one

6943

# but the system doesn't support it.

6944

6945

# Just print a warning and add the library to dependency_libs so

6946

# that the program can be linked against the static library.

6947

echo

6948

$ECHO "*** Warning: This system can not link to static lib archive $lib."

6949

echo "*** I have the capability to make that library automatically link in when"

6950

echo "*** you link to this library. But I can only do this if you have a"

6951

echo "*** shared version of the library, which you do not appear to have."

6952

if test "$module" = yes; then

6953

echo "*** But as you try to build a module library, libtool will still create "

6954

echo "*** a static module, that should work as long as the dlopening application"

6955

echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

6956

if test -z "$global_symbol_pipe"; then

6957

echo

6958

echo "*** However, this would only work if libtool was able to extract symbol"

6959

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

6960

echo "*** not find such a program. So, this module is probably useless."

6961

echo "*** \`nm' from GNU binutils and a full rebuild may help."

6962

fi

6963

if test "$build_old_libs" = no; then

6964

build_libtool_libs=module

6965

build_old_libs=yes

6966

else

6967

build_libtool_libs=no

6968

fi

6969

fi

6970

else

6971

deplibs="$dir/$old_library $deplibs"

6972

link_static=yes

6973

fi

6974

fi # link shared/static library?

6975

6976

if test "$linkmode" = lib; then

6977

if test -n "$dependency_libs" &&

6978

{ test "$hardcode_into_libs" != yes ||

6979

test "$build_old_libs" = yes ||

6980

test "$link_static" = yes; }; then

6981

# Extract -R from dependency_libs

6982

temp_deplibs=

6983

for libdir in $dependency_libs; do

6984

case $libdir in

6985

-R*) func_stripname '-R' '' "$libdir"

6986

temp_xrpath=$func_stripname_result

6987

case " $xrpath " in

6988

*" $temp_xrpath "*) ;;

6989

*) func_append xrpath " $temp_xrpath";;

6990

esac;;

6991

*) func_append temp_deplibs " $libdir";;

6992

esac

6993

done

6994

dependency_libs="$temp_deplibs"

6995

fi

6996

6997

func_append newlib_search_path " $absdir"

6998

# Link against this library

6999

test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

7000

# ... and its dependency_libs

7001

tmp_libs=

7002

for deplib in $dependency_libs; do

7003

newdependency_libs="$deplib $newdependency_libs"

7004

case $deplib in

7005

-L*) func_stripname '-L' '' "$deplib"

7006

func_resolve_sysroot "$func_stripname_result";;

7007

*) func_resolve_sysroot "$deplib" ;;

7008

esac

7009

if $opt_preserve_dup_deps ; then

7010

case "$tmp_libs " in

7011

*" $func_resolve_sysroot_result "*)

7012

func_append specialdeplibs " $func_resolve_sysroot_result" ;;

7013

esac

7014

fi

7015

func_append tmp_libs " $func_resolve_sysroot_result"

7016

done

7017

7018

if test "$link_all_deplibs" != no; then

7019

# Add the search paths of all dependency libraries

7020

for deplib in $dependency_libs; do

7021

path=

7022

case $deplib in

7023

-L*) path="$deplib" ;;

7024

*.la)

7025

func_resolve_sysroot "$deplib"

7026

deplib=$func_resolve_sysroot_result

7027

func_dirname "$deplib" "" "."

7028

dir=$func_dirname_result

7029

# We need an absolute path.

7030

case $dir in

7031

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

7032

*)

7033

absdir=`cd "$dir" && pwd`

7034

if test -z "$absdir"; then

7035

func_warning "cannot determine absolute directory name of \`$dir'"

7036

absdir="$dir"

7037

fi

7038

;;

7039

esac

7040

if $GREP "^installed=no" $deplib > /dev/null; then

7041

case $host in

7042

*-*-darwin*)

7043

depdepl=

7044

eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`

7045

if test -n "$deplibrary_names" ; then

7046

for tmp in $deplibrary_names ; do

7047

depdepl=$tmp

7048

done

7049

if test -f "$absdir/$objdir/$depdepl" ; then

7050

depdepl="$absdir/$objdir/$depdepl"

7051

darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7052

if test -z "$darwin_install_name"; then

7053

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7054

fi

7055

func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

7056

func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"

7057

path=

7058

fi

7059

fi

7060

;;

7061

*)

7062

path="-L$absdir/$objdir"

7063

;;

7064

esac

7065

else

7066

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

7067

test -z "$libdir" && \

7068

func_fatal_error "\`$deplib' is not a valid libtool archive"

7069

test "$absdir" != "$libdir" && \

7070

func_warning "\`$deplib' seems to be moved"

7071

7072

path="-L$absdir"

7073

fi

7074

;;

7075

esac

7076

case " $deplibs " in

7077

*" $path "*) ;;

7078

*) deplibs="$path $deplibs" ;;

7079

esac

7080

done

7081

fi # link_all_deplibs != no

7082

fi # linkmode = lib

7083

done # for deplib in $libs

7084

if test "$pass" = link; then

7085

if test "$linkmode" = "prog"; then

7086

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

7087

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

7088

else

7089

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7090

fi

7091

fi

7092

dependency_libs="$newdependency_libs"

7093

if test "$pass" = dlpreopen; then

7094

# Link the dlpreopened libraries before other libraries

7095

for deplib in $save_deplibs; do

7096

deplibs="$deplib $deplibs"

7097

done

7098

fi

7099

if test "$pass" != dlopen; then

7100

if test "$pass" != conv; then

7101

# Make sure lib_search_path contains only unique directories.

7102

lib_search_path=

7103

for dir in $newlib_search_path; do

7104

case "$lib_search_path " in

7105

*" $dir "*) ;;

7106

*) func_append lib_search_path " $dir" ;;

7107

esac

7108

done

7109

newlib_search_path=

7110

fi

7111

7112

if test "$linkmode,$pass" != "prog,link"; then

7113

vars="deplibs"

7114

else

7115

vars="compile_deplibs finalize_deplibs"

7116

fi

7117

for var in $vars dependency_libs; do

7118

# Add libraries to $var in reverse order

7119

eval tmp_libs=\"\$$var\"

7120

new_libs=

7121

for deplib in $tmp_libs; do

7122

# FIXME: Pedantically, this is the right thing to do, so

7123

# that some nasty dependency loop isn't accidentally

7124

# broken:

7125

#new_libs="$deplib $new_libs"

7126

# Pragmatically, this seems to cause very few problems in

7127

# practice:

7128

case $deplib in

7129

-L*) new_libs="$deplib $new_libs" ;;

7130

-R*) ;;

7131

*)

7132

# And here is the reason: when a library appears more

7133

# than once as an explicit dependence of a library, or

7134

# is implicitly linked in more than once by the

7135

# compiler, it is considered special, and multiple

7136

# occurrences thereof are not removed. Compare this

7137

# with having the same library being listed as a

7138

# dependency of multiple other libraries: in this case,

7139

# we know (pedantically, we assume) the library does not

7140

# need to be listed more than once, so we keep only the

7141

# last copy. This is not always right, but it is rare

7142

# enough that we require users that really mean to play

7143

# such unportable linking tricks to link the library

7144

# using -Wl,-lname, so that libtool does not consider it

7145

# for duplicate removal.

7146

case " $specialdeplibs " in

7147

*" $deplib "*) new_libs="$deplib $new_libs" ;;

7148

*)

7149

case " $new_libs " in

7150

*" $deplib "*) ;;

7151

*) new_libs="$deplib $new_libs" ;;

7152

esac

7153

;;

7154

esac

7155

;;

7156

esac

7157

done

7158

tmp_libs=

7159

for deplib in $new_libs; do

7160

case $deplib in

7161

-L*)

7162

case " $tmp_libs " in

7163

*" $deplib "*) ;;

7164

*) func_append tmp_libs " $deplib" ;;

7165

esac

7166

;;

7167

*) func_append tmp_libs " $deplib" ;;

7168

esac

7169

done

7170

eval $var=\"$tmp_libs\"

7171

done # for var

7172

fi

7173

# Last step: remove runtime libs from dependency_libs

7174

# (they stay in deplibs)

7175

tmp_libs=

7176

for i in $dependency_libs ; do

7177

case " $predeps $postdeps $compiler_lib_search_path " in

7178

*" $i "*)

7179

i=""

7180

;;

7181

esac

7182

if test -n "$i" ; then

7183

func_append tmp_libs " $i"

7184

fi

7185

done

7186

dependency_libs=$tmp_libs

7187

done # for pass

7188

if test "$linkmode" = prog; then

7189

dlfiles="$newdlfiles"

7190

fi

7191

if test "$linkmode" = prog || test "$linkmode" = lib; then

7192

dlprefiles="$newdlprefiles"

7193

fi

7194

7195

case $linkmode in

7196

oldlib)

7197

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

7198

func_warning "\`-dlopen' is ignored for archives"

7199

fi

7200

7201

case " $deplibs" in

7202

*\ -l* | *\ -L*)

7203

func_warning "\`-l' and \`-L' are ignored for archives" ;;

7204

esac

7205

7206

test -n "$rpath" && \

7207

func_warning "\`-rpath' is ignored for archives"

7208

7209

test -n "$xrpath" && \

7210

func_warning "\`-R' is ignored for archives"

7211

7212

test -n "$vinfo" && \

7213

func_warning "\`-version-info/-version-number' is ignored for archives"

7214

7215

test -n "$release" && \

7216

func_warning "\`-release' is ignored for archives"

7217

7218

test -n "$export_symbols$export_symbols_regex" && \

7219

func_warning "\`-export-symbols' is ignored for archives"

7220

7221

# Now set the variables for building old libraries.

7222

build_libtool_libs=no

7223

oldlibs="$output"

7224

func_append objs "$old_deplibs"

7225

;;

7226

7227

lib)

7228

# Make sure we only generate libraries of the form `libNAME.la'.

7229

case $outputname in

7230

lib*)

7231

func_stripname 'lib' '.la' "$outputname"

7232

name=$func_stripname_result

7233

eval shared_ext=\"$shrext_cmds\"

7234

eval libname=\"$libname_spec\"

7235

;;

7236

*)

7237

test "$module" = no && \

7238

func_fatal_help "libtool library \`$output' must begin with \`lib'"

7239

7240

if test "$need_lib_prefix" != no; then

7241

# Add the "lib" prefix for modules if required

7242

func_stripname '' '.la' "$outputname"

7243

name=$func_stripname_result

7244

eval shared_ext=\"$shrext_cmds\"

7245

eval libname=\"$libname_spec\"

7246

else

7247

func_stripname '' '.la' "$outputname"

7248

libname=$func_stripname_result

7249

fi

7250

;;

7251

esac

7252

7253

if test -n "$objs"; then

7254

if test "$deplibs_check_method" != pass_all; then

7255

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

7256

else

7257

echo

7258

$ECHO "*** Warning: Linking the shared library $output against the non-libtool"

7259

$ECHO "*** objects $objs is not portable!"

7260

func_append libobjs " $objs"

7261

fi

7262

fi

7263

7264

test "$dlself" != no && \

7265

func_warning "\`-dlopen self' is ignored for libtool libraries"

7266

7267

set dummy $rpath

7268

shift

7269

test "$#" -gt 1 && \

7270

func_warning "ignoring multiple \`-rpath's for a libtool library"

7271

7272

install_libdir="$1"

7273

7274

oldlibs=

7275

if test -z "$rpath"; then

7276

if test "$build_libtool_libs" = yes; then

7277

# Building a libtool convenience library.

7278

# Some compilers have problems with a `.al' extension so

7279

# convenience libraries should have the same extension an

7280

# archive normally would.

7281

oldlibs="$output_objdir/$libname.$libext $oldlibs"

7282

build_libtool_libs=convenience

7283

build_old_libs=yes

7284

fi

7285

7286

test -n "$vinfo" && \

7287

func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

7288

7289

test -n "$release" && \

7290

func_warning "\`-release' is ignored for convenience libraries"

7291

else

7292

7293

# Parse the version information argument.

7294

save_ifs="$IFS"; IFS=':'

7295

set dummy $vinfo 0 0 0

7296

shift

7297

IFS="$save_ifs"

7298

7299

test -n "$7" && \

7300

func_fatal_help "too many parameters to \`-version-info'"

7301

7302

# convert absolute version numbers to libtool ages

7303

# this retains compatibility with .la files and attempts

7304

# to make the code below a bit more comprehensible

7305

7306

case $vinfo_number in

7307

yes)

7308

number_major="$1"

7309

number_minor="$2"

7310

number_revision="$3"

7311

#

7312

# There are really only two kinds -- those that

7313

# use the current revision as the major version

7314

# and those that subtract age and use age as

7315

# a minor version. But, then there is irix

7316

# which has an extra 1 added just for fun

7317

#

7318

case $version_type in

7319

darwin|linux|osf|windows|none)

7320

func_arith $number_major + $number_minor

7321

current=$func_arith_result

7322

age="$number_minor"

7323

revision="$number_revision"

7324

;;

7325

freebsd-aout|freebsd-elf|qnx|sunos)

7326

current="$number_major"

7327

revision="$number_minor"

7328

age="0"

7329

;;

7330

irix|nonstopux)

7331

func_arith $number_major + $number_minor

7332

current=$func_arith_result

7333

age="$number_minor"

7334

revision="$number_minor"

7335

lt_irix_increment=no

7336

;;

7337

esac

7338

;;

7339

no)

7340

current="$1"

7341

revision="$2"

7342

age="$3"

7343

;;

7344

esac

7345

7346

# Check that each of the things are valid numbers.

7347

case $current in

7348

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]) ;;

7349

*)

7350

func_error "CURRENT \`$current' must be a nonnegative integer"

7351

func_fatal_error "\`$vinfo' is not valid version information"

7352

;;

7353

esac

7354

7355

case $revision in

7356

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]) ;;

7357

*)

7358

func_error "REVISION \`$revision' must be a nonnegative integer"

7359

func_fatal_error "\`$vinfo' is not valid version information"

7360

;;

7361

esac

7362

7363

case $age in

7364

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]) ;;

7365

*)

7366

func_error "AGE \`$age' must be a nonnegative integer"

7367

func_fatal_error "\`$vinfo' is not valid version information"

7368

;;

7369

esac

7370

7371

if test "$age" -gt "$current"; then

7372

func_error "AGE \`$age' is greater than the current interface number \`$current'"

7373

func_fatal_error "\`$vinfo' is not valid version information"

7374

fi

7375

7376

# Calculate the version variables.

7377

major=

7378

versuffix=

7379

verstring=

7380

case $version_type in

7381

none) ;;

7382

7383

darwin)

7384

# Like Linux, but with the current version available in

7385

# verstring for coding it into the library header

7386

func_arith $current - $age

7387

major=.$func_arith_result

7388

versuffix="$major.$age.$revision"

7389

# Darwin ld doesn't like 0 for these options...

7390

func_arith $current + 1

7391

minor_current=$func_arith_result

7392

xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"

7393

verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

7394

;;

7395

7396

freebsd-aout)

7397

major=".$current"

7398

versuffix=".$current.$revision";

7399

;;

7400

7401

freebsd-elf)

7402

major=".$current"

7403

versuffix=".$current"

7404

;;

7405

7406

irix | nonstopux)

7407

if test "X$lt_irix_increment" = "Xno"; then

7408

func_arith $current - $age

7409

else

7410

func_arith $current - $age + 1

7411

fi

7412

major=$func_arith_result

7413

7414

case $version_type in

7415

nonstopux) verstring_prefix=nonstopux ;;

7416

*) verstring_prefix=sgi ;;

7417

esac

7418

verstring="$verstring_prefix$major.$revision"

7419

7420

# Add in all the interfaces that we are compatible with.

7421

loop=$revision

7422

while test "$loop" -ne 0; do

7423

func_arith $revision - $loop

7424

iface=$func_arith_result

7425

func_arith $loop - 1

7426

loop=$func_arith_result

7427

verstring="$verstring_prefix$major.$iface:$verstring"

7428

done

7429

7430

# Before this point, $major must not contain `.'.

7431

major=.$major

7432

versuffix="$major.$revision"

7433

;;

7434

7435

linux)

7436

func_arith $current - $age

7437

major=.$func_arith_result

7438

versuffix="$major.$age.$revision"

7439

;;

7440

7441

osf)

7442

func_arith $current - $age

7443

major=.$func_arith_result

7444

versuffix=".$current.$age.$revision"

7445

verstring="$current.$age.$revision"

7446

7447

# Add in all the interfaces that we are compatible with.

7448

loop=$age

7449

while test "$loop" -ne 0; do

7450

func_arith $current - $loop

7451

iface=$func_arith_result

7452

func_arith $loop - 1

7453

loop=$func_arith_result

7454

verstring="$verstring:${iface}.0"

7455

done

7456

7457

# Make executables depend on our current version.

7458

func_append verstring ":${current}.0"

7459

;;

7460

7461

qnx)

7462

major=".$current"

7463

versuffix=".$current"

7464

;;

7465

7466

sunos)

7467

major=".$current"

7468

versuffix=".$current.$revision"

7469

;;

7470

7471

windows)

7472

# Use '-' rather than '.', since we only want one

7473

# extension on DOS 8.3 filesystems.

7474

func_arith $current - $age

7475

major=$func_arith_result

7476

versuffix="-$major"

7477

;;

7478

7479

*)

7480

func_fatal_configuration "unknown library version type \`$version_type'"

7481

;;

7482

esac

7483

7484

# Clear the version info if we defaulted, and they specified a release.

7485

if test -z "$vinfo" && test -n "$release"; then

7486

major=

7487

case $version_type in

7488

darwin)

7489

# we can't check for "0.0" in archive_cmds due to quoting

7490

# problems, so we reset it completely

7491

verstring=

7492

;;

7493

*)

7494

verstring="0.0"

7495

;;

7496

esac

7497

if test "$need_version" = no; then

7498

versuffix=

7499

else

7500

versuffix=".0.0"

7501

fi

7502

fi

7503

7504

# Remove version info from name if versioning should be avoided

7505

if test "$avoid_version" = yes && test "$need_version" = no; then

7506

major=

7507

versuffix=

7508

verstring=""

7509

fi

7510

7511

# Check to see if the archive will have undefined symbols.

7512

if test "$allow_undefined" = yes; then

7513

if test "$allow_undefined_flag" = unsupported; then

7514

func_warning "undefined symbols not allowed in $host shared libraries"

7515

build_libtool_libs=no

7516

build_old_libs=yes

7517

fi

7518

else

7519

# Don't allow undefined symbols.

7520

allow_undefined_flag="$no_undefined_flag"

7521

fi

7522

7523

fi

7524

7525

func_generate_dlsyms "$libname" "$libname" "yes"

7526

func_append libobjs " $symfileobj"

7527

test "X$libobjs" = "X " && libobjs=

7528

7529

if test "$opt_mode" != relink; then

7530

# Remove our outputs, but don't remove object files since they

7531

# may have been created when compiling PIC objects.

7532

removelist=

7533

tempremovelist=`$ECHO "$output_objdir/*"`

7534

for p in $tempremovelist; do

7535

case $p in

7536

*.$objext | *.gcno)

7537

;;

7538

$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

7539

if test "X$precious_files_regex" != "X"; then

7540

if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

7541

then

7542

continue

7543

fi

7544

fi

7545

func_append removelist " $p"

7546

;;

7547

*) ;;

7548

esac

7549

done

7550

test -n "$removelist" && \

7551

func_show_eval "${RM}r \$removelist"

7552

fi

7553

7554

# Now set the variables for building old libraries.

7555

if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

7556

func_append oldlibs " $output_objdir/$libname.$libext"

7557

7558

# Transform .lo files to .o files.

7559

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

7560

fi

7561

7562

# Eliminate all temporary directories.

7563

#for path in $notinst_path; do

7564

# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

7565

# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

7566

# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

7567

#done

7568

7569

if test -n "$xrpath"; then

7570

# If the user specified any rpath flags, then add them.

7571

temp_xrpath=

7572

for libdir in $xrpath; do

7573

func_replace_sysroot "$libdir"

7574

func_append temp_xrpath " -R$func_replace_sysroot_result"

7575

case "$finalize_rpath " in

7576

*" $libdir "*) ;;

7577

*) func_append finalize_rpath " $libdir" ;;

7578

esac

7579

done

7580

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

7581

dependency_libs="$temp_xrpath $dependency_libs"

7582

fi

7583

fi

7584

7585

# Make sure dlfiles contains only unique files that won't be dlpreopened

7586

old_dlfiles="$dlfiles"

7587

dlfiles=

7588

for lib in $old_dlfiles; do

7589

case " $dlprefiles $dlfiles " in

7590

*" $lib "*) ;;

7591

*) func_append dlfiles " $lib" ;;

7592

esac

7593

done

7594

7595

# Make sure dlprefiles contains only unique files

7596

old_dlprefiles="$dlprefiles"

7597

dlprefiles=

7598

for lib in $old_dlprefiles; do

7599

case "$dlprefiles " in

7600

*" $lib "*) ;;

7601

*) func_append dlprefiles " $lib" ;;

7602

esac

7603

done

7604

7605

if test "$build_libtool_libs" = yes; then

7606

if test -n "$rpath"; then

7607

case $host in

7608

7609

# these systems don't actually have a c library (as such)!

7610

;;

7611

*-*-rhapsody* | *-*-darwin1.[012])

7612

# Rhapsody C library is in the System framework

7613

func_append deplibs " System.ltframework"

7614

;;

7615

*-*-netbsd*)

7616

# Don't link with libc until the a.out ld.so is fixed.

7617

;;

7618

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

7619

# Do not include libc due to us having libc/libc_r.

7620

;;

7621

*-*-sco3.2v5* | *-*-sco5v6*)

7622

# Causes problems with __ctype

7623

;;

7624

*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

7625

# Compiler inserts libc in the correct place for threads to work

7626

;;

7627

*)

7628

# Add libc to deplibs on all other systems if necessary.

7629

if test "$build_libtool_need_lc" = "yes"; then

7630

func_append deplibs " -lc"

7631

fi

7632

;;

7633

esac

7634

fi

7635

7636

# Transform deplibs into only deplibs that can be linked in shared.

7637

name_save=$name

7638

libname_save=$libname

7639

release_save=$release

7640

versuffix_save=$versuffix

7641

major_save=$major

7642

# I'm not sure if I'm treating the release correctly. I think

7643

# release should show up in the -l (ie -lgmp5) so we don't want to

7644

# add it in twice. Is that correct?

7645

release=""

7646

versuffix=""

7647

major=""

7648

newdeplibs=

7649

droppeddeps=no

7650

case $deplibs_check_method in

7651

pass_all)

7652

# Don't check for shared/static. Everything works.

7653

# This might be a little naive. We might want to check

7654

# whether the library exists or not. But this is on

7655

# osf3 & osf4 and I'm not really sure... Just

7656

# implementing what was already the behavior.

7657

newdeplibs=$deplibs

7658

;;

7659

test_compile)

7660

# This code stresses the "libraries are programs" paradigm to its

7661

# limits. Maybe even breaks it. We compile a program, linking it

7662

# against the deplibs as a proxy for the library. Then we can check

7663

# whether they linked in statically or dynamically with ldd.

7664

$opt_dry_run || $RM conftest.c

7665

cat > conftest.c <<EOF

7666

int main() { return 0; }

7667

EOF

7668

$opt_dry_run || $RM conftest

7669

if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then

7670

ldd_output=`ldd conftest`

7671

for i in $deplibs; do

7672

case $i in

7673

-l*)

7674

func_stripname -l '' "$i"

7675

name=$func_stripname_result

7676

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7677

case " $predeps $postdeps " in

7678

*" $i "*)

7679

func_append newdeplibs " $i"

7680

i=""

7681

;;

7682

esac

7683

fi

7684

if test -n "$i" ; then

7685

libname=`eval "\\$ECHO \"$libname_spec\""`

7686

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7687

set dummy $deplib_matches; shift

7688

deplib_match=$1

7689

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7690

func_append newdeplibs " $i"

7691

else

7692

droppeddeps=yes

7693

echo

7694

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7695

echo "*** I have the capability to make that library automatically link in when"

7696

echo "*** you link to this library. But I can only do this if you have a"

7697

echo "*** shared version of the library, which I believe you do not have"

7698

echo "*** because a test_compile did reveal that the linker did not use it for"

7699

echo "*** its dynamic dependency list that programs get resolved with at runtime."

7700

fi

7701

fi

7702

;;

7703

*)

7704

func_append newdeplibs " $i"

7705

;;

7706

esac

7707

done

7708

else

7709

# Error occurred in the first compile. Let's try to salvage

7710

# the situation: Compile a separate program for each library.

7711

for i in $deplibs; do

7712

case $i in

7713

-l*)

7714

func_stripname -l '' "$i"

7715

name=$func_stripname_result

7716

$opt_dry_run || $RM conftest

7717

if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

7718

ldd_output=`ldd conftest`

7719

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7720

case " $predeps $postdeps " in

7721

*" $i "*)

7722

func_append newdeplibs " $i"

7723

i=""

7724

;;

7725

esac

7726

fi

7727

if test -n "$i" ; then

7728

libname=`eval "\\$ECHO \"$libname_spec\""`

7729

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7730

set dummy $deplib_matches; shift

7731

deplib_match=$1

7732

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7733

func_append newdeplibs " $i"

7734

else

7735

droppeddeps=yes

7736

echo

7737

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7738

echo "*** I have the capability to make that library automatically link in when"

7739

echo "*** you link to this library. But I can only do this if you have a"

7740

echo "*** shared version of the library, which you do not appear to have"

7741

echo "*** because a test_compile did reveal that the linker did not use this one"

7742

echo "*** as a dynamic dependency that programs can get resolved with at runtime."

7743

fi

7744

fi

7745

else

7746

droppeddeps=yes

7747

echo

7748

$ECHO "*** Warning! Library $i is needed by this library but I was not able to"

7749

echo "*** make it link in! You will probably need to install it or some"

7750

echo "*** library that it depends on before this library will be fully"

7751

echo "*** functional. Installing it before continuing would be even better."

7752

fi

7753

;;

7754

*)

7755

func_append newdeplibs " $i"

7756

;;

7757

esac

7758

done

7759

fi

7760

;;

7761

file_magic*)

7762

set dummy $deplibs_check_method; shift

7763

file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7764

for a_deplib in $deplibs; do

7765

case $a_deplib in

7766

-l*)

7767

func_stripname -l '' "$a_deplib"

7768

name=$func_stripname_result

7769

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7770

case " $predeps $postdeps " in

7771

*" $a_deplib "*)

7772

func_append newdeplibs " $a_deplib"

7773

a_deplib=""

7774

;;

7775

esac

7776

fi

7777

if test -n "$a_deplib" ; then

7778

libname=`eval "\\$ECHO \"$libname_spec\""`

7779

if test -n "$file_magic_glob"; then

7780

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

7781

else

7782

libnameglob=$libname

7783

fi

7784

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

7785

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7786

if test "$want_nocaseglob" = yes; then

7787

shopt -s nocaseglob

7788

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7789

$nocaseglob

7790

else

7791

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7792

fi

7793

for potent_lib in $potential_libs; do

7794

# Follow soft links.

7795

if ls -lLd "$potent_lib" 2>/dev/null |

7796

$GREP " -> " >/dev/null; then

7797

continue

7798

fi

7799

# The statement above tries to avoid entering an

7800

# endless loop below, in case of cyclic links.

7801

# We might still enter an endless loop, since a link

7802

# loop can be closed while we follow links,

7803

# but so what?

7804

potlib="$potent_lib"

7805

while test -h "$potlib" 2>/dev/null; do

7806

potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

7807

case $potliblink in

7808

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

7809

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

7810

esac

7811

done

7812

if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

7813

$SED -e 10q |

7814

$EGREP "$file_magic_regex" > /dev/null; then

7815

func_append newdeplibs " $a_deplib"

7816

a_deplib=""

7817

break 2

7818

fi

7819

done

7820

done

7821

fi

7822

if test -n "$a_deplib" ; then

7823

droppeddeps=yes

7824

echo

7825

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7826

echo "*** I have the capability to make that library automatically link in when"

7827

echo "*** you link to this library. But I can only do this if you have a"

7828

echo "*** shared version of the library, which you do not appear to have"

7829

echo "*** because I did check the linker path looking for a file starting"

7830

if test -z "$potlib" ; then

7831

$ECHO "*** with $libname but no candidates were found. (...for file magic test)"

7832

else

7833

$ECHO "*** with $libname and none of the candidates passed a file format test"

7834

$ECHO "*** using a file magic. Last file checked: $potlib"

7835

fi

7836

fi

7837

;;

7838

*)

7839

# Add a -L argument.

7840

func_append newdeplibs " $a_deplib"

7841

;;

7842

esac

7843

done # Gone through all deplibs.

7844

;;

7845

match_pattern*)

7846

set dummy $deplibs_check_method; shift

7847

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7848

for a_deplib in $deplibs; do

7849

case $a_deplib in

7850

-l*)

7851

func_stripname -l '' "$a_deplib"

7852

name=$func_stripname_result

7853

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7854

case " $predeps $postdeps " in

7855

*" $a_deplib "*)

7856

func_append newdeplibs " $a_deplib"

7857

a_deplib=""

7858

;;

7859

esac

7860

fi

7861

if test -n "$a_deplib" ; then

7862

libname=`eval "\\$ECHO \"$libname_spec\""`

7863

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7864

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7865

for potent_lib in $potential_libs; do

7866

potlib="$potent_lib" # see symlink-check above in file_magic test

7867

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

7868

$EGREP "$match_pattern_regex" > /dev/null; then

7869

func_append newdeplibs " $a_deplib"

7870

a_deplib=""

7871

break 2

7872

fi

7873

done

7874

done

7875

fi

7876

if test -n "$a_deplib" ; then

7877

droppeddeps=yes

7878

echo

7879

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7880

echo "*** I have the capability to make that library automatically link in when"

7881

echo "*** you link to this library. But I can only do this if you have a"

7882

echo "*** shared version of the library, which you do not appear to have"

7883

echo "*** because I did check the linker path looking for a file starting"

7884

if test -z "$potlib" ; then

7885

$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

7886

else

7887

$ECHO "*** with $libname and none of the candidates passed a file format test"

7888

$ECHO "*** using a regex pattern. Last file checked: $potlib"

7889

fi

7890

fi

7891

;;

7892

*)

7893

# Add a -L argument.

7894

func_append newdeplibs " $a_deplib"

7895

;;

7896

esac

7897

done # Gone through all deplibs.

7898

;;

7899

none | unknown | *)

7900

newdeplibs=""

7901

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

7902

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7903

for i in $predeps $postdeps ; do

7904

# can't use Xsed below, because $i might contain '/'

7905

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

7906

done

7907

fi

7908

case $tmp_deplibs in

7909

*[!\ \ ]*)

7910

echo

7911

if test "X$deplibs_check_method" = "Xnone"; then

7912

echo "*** Warning: inter-library dependencies are not supported in this platform."

7913

else

7914

echo "*** Warning: inter-library dependencies are not known to be supported."

7915

fi

7916

echo "*** All declared inter-library dependencies are being dropped."

7917

droppeddeps=yes

7918

;;

7919

esac

7920

;;

7921

esac

7922

versuffix=$versuffix_save

7923

major=$major_save

7924

release=$release_save

7925

libname=$libname_save

7926

name=$name_save

7927

7928

case $host in

7929

*-*-rhapsody* | *-*-darwin1.[012])

7930

# On Rhapsody replace the C library with the System framework

7931

newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

7932

;;

7933

esac

7934

7935

if test "$droppeddeps" = yes; then

7936

if test "$module" = yes; then

7937

echo

7938

echo "*** Warning: libtool could not satisfy all declared inter-library"

7939

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

7940

echo "*** a static module, that should work as long as the dlopening"

7941

echo "*** application is linked with the -dlopen flag."

7942

if test -z "$global_symbol_pipe"; then

7943

echo

7944

echo "*** However, this would only work if libtool was able to extract symbol"

7945

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

7946

echo "*** not find such a program. So, this module is probably useless."

7947

echo "*** \`nm' from GNU binutils and a full rebuild may help."

7948

fi

7949

if test "$build_old_libs" = no; then

7950

oldlibs="$output_objdir/$libname.$libext"

7951

build_libtool_libs=module

7952

build_old_libs=yes

7953

else

7954

build_libtool_libs=no

7955

fi

7956

else

7957

echo "*** The inter-library dependencies that have been dropped here will be"

7958

echo "*** automatically added whenever a program is linked with this library"

7959

echo "*** or is declared to -dlopen it."

7960

7961

if test "$allow_undefined" = no; then

7962

echo

7963

echo "*** Since this library must not contain undefined symbols,"

7964

echo "*** because either the platform does not support them or"

7965

echo "*** it was explicitly requested with -no-undefined,"

7966

echo "*** libtool will only create a static version of it."

7967

if test "$build_old_libs" = no; then

7968

oldlibs="$output_objdir/$libname.$libext"

7969

build_libtool_libs=module

7970

build_old_libs=yes

7971

else

7972

build_libtool_libs=no

7973

fi

7974

fi

7975

fi

7976

fi

7977

# Done checking deplibs!

7978

deplibs=$newdeplibs

7979

fi

7980

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

7981

case $host in

7982

*-*-darwin*)

7983

newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7984

new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7985

deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7986

;;

7987

esac

7988

7989

# move library search paths that coincide with paths to not yet

7990

# installed libraries to the beginning of the library search list

7991

new_libs=

7992

for path in $notinst_path; do

7993

case " $new_libs " in

7994

*" -L$path/$objdir "*) ;;

7995

*)

7996

case " $deplibs " in

7997

*" -L$path/$objdir "*)

7998

func_append new_libs " -L$path/$objdir" ;;

7999

esac

8000

;;

8001

esac

8002

done

8003

for deplib in $deplibs; do

8004

case $deplib in

8005

-L*)

8006

case " $new_libs " in

8007

*" $deplib "*) ;;

8008

*) func_append new_libs " $deplib" ;;

8009

esac

8010

;;

8011

*) func_append new_libs " $deplib" ;;

8012

esac

8013

done

8014

deplibs="$new_libs"

8015

8016

# All the library-specific variables (install_libdir is set above).

8017

library_names=

8018

old_library=

8019

dlname=

8020

8021

# Test again, we may have decided not to build it any more

8022

if test "$build_libtool_libs" = yes; then

8023

if test "$hardcode_into_libs" = yes; then

8024

# Hardcode the library paths

8025

hardcode_libdirs=

8026

dep_rpath=

8027

rpath="$finalize_rpath"

8028

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

8029

for libdir in $rpath; do

8030

if test -n "$hardcode_libdir_flag_spec"; then

8031

if test -n "$hardcode_libdir_separator"; then

8032

func_replace_sysroot "$libdir"

8033

libdir=$func_replace_sysroot_result

8034

if test -z "$hardcode_libdirs"; then

8035

hardcode_libdirs="$libdir"

8036

else

8037

# Just accumulate the unique libdirs.

8038

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8039

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8040

;;

8041

*)

8042

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8043

;;

8044

esac

8045

fi

8046

else

8047

eval flag=\"$hardcode_libdir_flag_spec\"

8048

func_append dep_rpath " $flag"

8049

fi

8050

elif test -n "$runpath_var"; then

8051

case "$perm_rpath " in

8052

*" $libdir "*) ;;

8053

*) func_apped perm_rpath " $libdir" ;;

8054

esac

8055

fi

8056

done

8057

# Substitute the hardcoded libdirs into the rpath.

8058

if test -n "$hardcode_libdir_separator" &&

8059

test -n "$hardcode_libdirs"; then

8060

libdir="$hardcode_libdirs"

8061

if test -n "$hardcode_libdir_flag_spec_ld"; then

8062

eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"

8063

else

8064

eval dep_rpath=\"$hardcode_libdir_flag_spec\"

8065

fi

8066

fi

8067

if test -n "$runpath_var" && test -n "$perm_rpath"; then

8068

# We should set the runpath_var.

8069

rpath=

8070

for dir in $perm_rpath; do

8071

func_append rpath "$dir:"

8072

done

8073

eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

8074

fi

8075

test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

8076

fi

8077

8078

shlibpath="$finalize_shlibpath"

8079

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

8080

if test -n "$shlibpath"; then

8081

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

8082

fi

8083

8084

# Get the real and link names of the library.

8085

eval shared_ext=\"$shrext_cmds\"

8086

eval library_names=\"$library_names_spec\"

8087

set dummy $library_names

8088

shift

8089

realname="$1"

8090

shift

8091

8092

if test -n "$soname_spec"; then

8093

eval soname=\"$soname_spec\"

8094

else

8095

soname="$realname"

8096

fi

8097

if test -z "$dlname"; then

8098

dlname=$soname

8099

fi

8100

8101

lib="$output_objdir/$realname"

8102

linknames=

8103

for link

8104

do

8105

func_append linknames " $link"

8106

done

8107

8108

# Use standard objects if they are pic

8109

test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

8110

test "X$libobjs" = "X " && libobjs=

8111

8112

delfiles=

8113

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8114

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

8115

export_symbols="$output_objdir/$libname.uexp"

8116

func_append delfiles " $export_symbols"

8117

fi

8118

8119

orig_export_symbols=

8120

case $host_os in

8121

cygwin* | mingw* | cegcc*)

8122

if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

8123

# exporting using user supplied symfile

8124

if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

8125

# and it's NOT already a .def file. Must figure out

8126

# which of the given symbols are data symbols and tag

8127

# them as such. So, trigger use of export_symbols_cmds.

8128

# export_symbols gets reassigned inside the "prepare

8129

# the list of exported symbols" if statement, so the

8130

# include_expsyms logic still works.

8131

orig_export_symbols="$export_symbols"

8132

export_symbols=

8133

always_export_symbols=yes

8134

fi

8135

fi

8136

;;

8137

esac

8138

8139

# Prepare the list of exported symbols

8140

if test -z "$export_symbols"; then

8141

if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

8142

func_verbose "generating symbol list for \`$libname.la'"

8143

export_symbols="$output_objdir/$libname.exp"

8144

$opt_dry_run || $RM $export_symbols

8145

cmds=$export_symbols_cmds

8146

save_ifs="$IFS"; IFS='~'

8147

for cmd1 in $cmds; do

8148

IFS="$save_ifs"

8149

# Take the normal branch if the nm_file_list_spec branch

8150

# doesn't work or if tool conversion is not needed.

8151

case $nm_file_list_spec~$to_tool_file_cmd in

8152

*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)

8153

try_normal_branch=yes

8154

eval cmd=\"$cmd1\"

8155

func_len " $cmd"

8156

len=$func_len_result

8157

;;

8158

*)

8159

try_normal_branch=no

8160

;;

8161

esac

8162

if test "$try_normal_branch" = yes \

8163

&& { test "$len" -lt "$max_cmd_len" \

8164

|| test "$max_cmd_len" -le -1; }

8165

then

8166

func_show_eval "$cmd" 'exit $?'

8167

skipped_export=false

8168

elif test -n "$nm_file_list_spec"; then

8169

func_basename "$output"

8170

output_la=$func_basename_result

8171

save_libobjs=$libobjs

8172

save_output=$output

8173

output=${output_objdir}/${output_la}.nm

8174

func_to_tool_file "$output"

8175

libobjs=$nm_file_list_spec$func_to_tool_file_result

8176

func_append delfiles " $output"

8177

func_verbose "creating $NM input file list: $output"

8178

for obj in $save_libobjs; do

8179

func_to_tool_file "$obj"

8180

$ECHO "$func_to_tool_file_result"

8181

done > "$output"

8182

eval cmd=\"$cmd1\"

8183

func_show_eval "$cmd" 'exit $?'

8184

output=$save_output

8185

libobjs=$save_libobjs

8186

skipped_export=false

8187

else

8188

# The command line is too long to execute in one step.

8189

func_verbose "using reloadable object file for export list..."

8190

skipped_export=:

8191

# Break out early, otherwise skipped_export may be

8192

# set to false by a later but shorter cmd.

8193

break

8194

fi

8195

done

8196

IFS="$save_ifs"

8197

if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

8198

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8199

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8200

fi

8201

fi

8202

fi

8203

8204

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8205

tmp_export_symbols="$export_symbols"

8206

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8207

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8208

fi

8209

8210

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

8211

# The given exports_symbols file has to be filtered, so filter it.

8212

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8213

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8214

# 's' commands which not all seds can handle. GNU sed should be fine

8215

# though. Also, the filter scales superlinearly with the number of

8216

# global variables. join(1) would be nice here, but unfortunately

8217

# isn't a blessed tool.

8218

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8219

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

8220

export_symbols=$output_objdir/$libname.def

8221

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8222

fi

8223

8224

tmp_deplibs=

8225

for test_deplib in $deplibs; do

8226

case " $convenience " in

8227

*" $test_deplib "*) ;;

8228

*)

8229

func_append tmp_deplibs " $test_deplib"

8230

;;

8231

esac

8232

done

8233

deplibs="$tmp_deplibs"

8234

8235

if test -n "$convenience"; then

8236

if test -n "$whole_archive_flag_spec" &&

8237

test "$compiler_needs_object" = yes &&

8238

test -z "$libobjs"; then

8239

# extract the archives, so we have objects to list.

8240

# TODO: could optimize this to just extract one archive.

8241

whole_archive_flag_spec=

8242

fi

8243

if test -n "$whole_archive_flag_spec"; then

8244

save_libobjs=$libobjs

8245

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8246

test "X$libobjs" = "X " && libobjs=

8247

else

8248

gentop="$output_objdir/${outputname}x"

8249

func_append generated " $gentop"

8250

8251

func_extract_archives $gentop $convenience

8252

func_append libobjs " $func_extract_archives_result"

8253

test "X$libobjs" = "X " && libobjs=

8254

fi

8255

fi

8256

8257

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

8258

eval flag=\"$thread_safe_flag_spec\"

8259

func_append linker_flags " $flag"

8260

fi

8261

8262

# Make a backup of the uninstalled library when relinking

8263

if test "$opt_mode" = relink; then

8264

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

8265

fi

8266

8267

# Do each of the archive commands.

8268

if test "$module" = yes && test -n "$module_cmds" ; then

8269

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8270

eval test_cmds=\"$module_expsym_cmds\"

8271

cmds=$module_expsym_cmds

8272

else

8273

eval test_cmds=\"$module_cmds\"

8274

cmds=$module_cmds

8275

fi

8276

else

8277

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8278

eval test_cmds=\"$archive_expsym_cmds\"

8279

cmds=$archive_expsym_cmds

8280

else

8281

eval test_cmds=\"$archive_cmds\"

8282

cmds=$archive_cmds

8283

fi

8284

fi

8285

8286

if test "X$skipped_export" != "X:" &&

8287

func_len " $test_cmds" &&

8288

len=$func_len_result &&

8289

test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8290

:

8291

else

8292

# The command line is too long to link in one step, link piecewise

8293

# or, if using GNU ld and skipped_export is not :, use a linker

8294

# script.

8295

8296

# Save the value of $output and $libobjs because we want to

8297

# use them later. If we have whole_archive_flag_spec, we

8298

# want to use save_libobjs as it was before

8299

# whole_archive_flag_spec was expanded, because we can't

8300

# assume the linker understands whole_archive_flag_spec.

8301

# This may have to be revisited, in case too many

8302

# convenience libraries get linked in and end up exceeding

8303

# the spec.

8304

if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then

8305

save_libobjs=$libobjs

8306

fi

8307

save_output=$output

8308

func_basename "$output"

8309

output_la=$func_basename_result

8310

8311

# Clear the reloadable object creation command queue and

8312

# initialize k to one.

8313

test_cmds=

8314

concat_cmds=

8315

objlist=

8316

last_robj=

8317

k=1

8318

8319

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

8320

output=${output_objdir}/${output_la}.lnkscript

8321

func_verbose "creating GNU ld script: $output"

8322

echo 'INPUT (' > $output

8323

for obj in $save_libobjs

8324

do

8325

func_to_tool_file "$obj"

8326

$ECHO "$func_to_tool_file_result" >> $output

8327

done

8328

echo ')' >> $output

8329

func_append delfiles " $output"

8330

func_to_tool_file "$output"

8331

output=$func_to_tool_file_result

8332

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

8333

output=${output_objdir}/${output_la}.lnk

8334

func_verbose "creating linker input file list: $output"

8335

: > $output

8336

set x $save_libobjs

8337

shift

8338

firstobj=

8339

if test "$compiler_needs_object" = yes; then

8340

firstobj="$1 "

8341

shift

8342

fi

8343

for obj

8344

do

8345

func_to_tool_file "$obj"

8346

$ECHO "$func_to_tool_file_result" >> $output

8347

done

8348

func_append delfiles " $output"

8349

func_to_tool_file "$output"

8350

output=$firstobj\"$file_list_spec$func_to_tool_file_result\"

8351

else

8352

if test -n "$save_libobjs"; then

8353

func_verbose "creating reloadable object files..."

8354

output=$output_objdir/$output_la-${k}.$objext

8355

eval test_cmds=\"$reload_cmds\"

8356

func_len " $test_cmds"

8357

len0=$func_len_result

8358

len=$len0

8359

8360

# Loop over the list of objects to be linked.

8361

for obj in $save_libobjs

8362

do

8363

func_len " $obj"

8364

func_arith $len + $func_len_result

8365

len=$func_arith_result

8366

if test "X$objlist" = X ||

8367

test "$len" -lt "$max_cmd_len"; then

8368

func_append objlist " $obj"

8369

else

8370

# The command $test_cmds is almost too long, add a

8371

# command to the queue.

8372

if test "$k" -eq 1 ; then

8373

# The first file doesn't have a previous command to add.

8374

reload_objs=$objlist

8375

eval concat_cmds=\"$reload_cmds\"

8376

else

8377

# All subsequent reloadable object files will link in

8378

# the last one created.

8379

reload_objs="$objlist $last_robj"

8380

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

8381

fi

8382

last_robj=$output_objdir/$output_la-${k}.$objext

8383

func_arith $k + 1

8384

k=$func_arith_result

8385

output=$output_objdir/$output_la-${k}.$objext

8386

objlist=" $obj"

8387

func_len " $last_robj"

8388

func_arith $len0 + $func_len_result

8389

len=$func_arith_result

8390

fi

8391

done

8392

# Handle the remaining objects by creating one last

8393

# reloadable object file. All subsequent reloadable object

8394

# files will link in the last one created.

8395

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8396

reload_objs="$objlist $last_robj"

8397

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

8398

if test -n "$last_robj"; then

8399

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

8400

fi

8401

func_append delfiles " $output"

8402

8403

else

8404

output=

8405

fi

8406

8407

if ${skipped_export-false}; then

8408

func_verbose "generating symbol list for \`$libname.la'"

8409

export_symbols="$output_objdir/$libname.exp"

8410

$opt_dry_run || $RM $export_symbols

8411

libobjs=$output

8412

# Append the command to create the export file.

8413

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8414

eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"

8415

if test -n "$last_robj"; then

8416

eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

8417

fi

8418

fi

8419

8420

test -n "$save_libobjs" &&

8421

func_verbose "creating a temporary reloadable object file: $output"

8422

8423

# Loop through the commands generated above and execute them.

8424

save_ifs="$IFS"; IFS='~'

8425

for cmd in $concat_cmds; do

8426

IFS="$save_ifs"

8427

$opt_silent || {

8428

func_quote_for_expand "$cmd"

8429

eval "func_echo $func_quote_for_expand_result"

8430

}

8431

$opt_dry_run || eval "$cmd" || {

8432

lt_exit=$?

8433

8434

# Restore the uninstalled library and exit

8435

if test "$opt_mode" = relink; then

8436

( cd "$output_objdir" && \

8437

$RM "${realname}T" && \

8438

$MV "${realname}U" "$realname" )

8439

fi

8440

8441

exit $lt_exit

8442

}

8443

done

8444

IFS="$save_ifs"

8445

8446

if test -n "$export_symbols_regex" && ${skipped_export-false}; then

8447

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8448

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8449

fi

8450

fi

8451

8452

if ${skipped_export-false}; then

8453

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8454

tmp_export_symbols="$export_symbols"

8455

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8456

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8457

fi

8458

8459

if test -n "$orig_export_symbols"; then

8460

# The given exports_symbols file has to be filtered, so filter it.

8461

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8462

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8463

# 's' commands which not all seds can handle. GNU sed should be fine

8464

# though. Also, the filter scales superlinearly with the number of

8465

# global variables. join(1) would be nice here, but unfortunately

8466

# isn't a blessed tool.

8467

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8468

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

8469

export_symbols=$output_objdir/$libname.def

8470

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8471

fi

8472

fi

8473

8474

libobjs=$output

8475

# Restore the value of output.

8476

output=$save_output

8477

8478

if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then

8479

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8480

test "X$libobjs" = "X " && libobjs=

8481

fi

8482

# Expand the library linking commands again to reset the

8483

# value of $libobjs for piecewise linking.

8484

8485

# Do each of the archive commands.

8486

if test "$module" = yes && test -n "$module_cmds" ; then

8487

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8488

cmds=$module_expsym_cmds

8489

else

8490

cmds=$module_cmds

8491

fi

8492

else

8493

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8494

cmds=$archive_expsym_cmds

8495

else

8496

cmds=$archive_cmds

8497

fi

8498

fi

8499

fi

8500

8501

if test -n "$delfiles"; then

8502

# Append the command to remove temporary files to $cmds.

8503

eval cmds=\"\$cmds~\$RM $delfiles\"

8504

fi

8505

8506

# Add any objects from preloaded convenience libraries

8507

if test -n "$dlprefiles"; then

8508

gentop="$output_objdir/${outputname}x"

8509

func_append generated " $gentop"

8510

8511

func_extract_archives $gentop $dlprefiles

8512

func_append libobjs " $func_extract_archives_result"

8513

test "X$libobjs" = "X " && libobjs=

8514

fi

8515

8516

save_ifs="$IFS"; IFS='~'

8517

for cmd in $cmds; do

8518

IFS="$save_ifs"

8519

eval cmd=\"$cmd\"

8520

$opt_silent || {

8521

func_quote_for_expand "$cmd"

8522

eval "func_echo $func_quote_for_expand_result"

8523

}

8524

$opt_dry_run || eval "$cmd" || {

8525

lt_exit=$?

8526

8527

# Restore the uninstalled library and exit

8528

if test "$opt_mode" = relink; then

8529

( cd "$output_objdir" && \

8530

$RM "${realname}T" && \

8531

$MV "${realname}U" "$realname" )

8532

fi

8533

8534

exit $lt_exit

8535

}

8536

done

8537

IFS="$save_ifs"

8538

8539

# Restore the uninstalled library and exit

8540

if test "$opt_mode" = relink; then

8541

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

8542

8543

if test -n "$convenience"; then

8544

if test -z "$whole_archive_flag_spec"; then

8545

func_show_eval '${RM}r "$gentop"'

8546

fi

8547

fi

8548

8549

exit $EXIT_SUCCESS

8550

fi

8551

8552

# Create links to the real library.

8553

for linkname in $linknames; do

8554

if test "$realname" != "$linkname"; then

8555

func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'

8556

fi

8557

done

8558

8559

# If -module or -export-dynamic was specified, set the dlname.

8560

if test "$module" = yes || test "$export_dynamic" = yes; then

8561

# On all known operating systems, these are identical.

8562

dlname="$soname"

8563

fi

8564

fi

8565

;;

8566

8567

obj)

8568

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

8569

func_warning "\`-dlopen' is ignored for objects"

8570

fi

8571

8572

case " $deplibs" in

8573

*\ -l* | *\ -L*)

8574

func_warning "\`-l' and \`-L' are ignored for objects" ;;

8575

esac

8576

8577

test -n "$rpath" && \

8578

func_warning "\`-rpath' is ignored for objects"

8579

8580

test -n "$xrpath" && \

8581

func_warning "\`-R' is ignored for objects"

8582

8583

test -n "$vinfo" && \

8584

func_warning "\`-version-info' is ignored for objects"

8585

8586

test -n "$release" && \

8587

func_warning "\`-release' is ignored for objects"

8588

8589

case $output in

8590

*.lo)

8591

test -n "$objs$old_deplibs" && \

8592

func_fatal_error "cannot build library object \`$output' from non-libtool objects"

8593

8594

libobj=$output

8595

func_lo2o "$libobj"

8596

obj=$func_lo2o_result

8597

;;

8598

*)

8599

libobj=

8600

obj="$output"

8601

;;

8602

esac

8603

8604

# Delete the old objects.

8605

$opt_dry_run || $RM $obj $libobj

8606

8607

# Objects from convenience libraries. This assumes

8608

# single-version convenience libraries. Whenever we create

8609

# different ones for PIC/non-PIC, this we'll have to duplicate

8610

# the extraction.

8611

reload_conv_objs=

8612

gentop=

8613

# reload_cmds runs $LD directly, so let us get rid of

8614

# -Wl from whole_archive_flag_spec and hope we can get by with

8615

# turning comma into space..

8616

wl=

8617

8618

if test -n "$convenience"; then

8619

if test -n "$whole_archive_flag_spec"; then

8620

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

8621

reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

8622

else

8623

gentop="$output_objdir/${obj}x"

8624

func_append generated " $gentop"

8625

8626

func_extract_archives $gentop $convenience

8627

reload_conv_objs="$reload_objs $func_extract_archives_result"

8628

fi

8629

fi

8630

8631

# If we're not building shared, we need to use non_pic_objs

8632

test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

8633

8634

# Create the old-style object.

8635

reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

8636

8637

output="$obj"

8638

func_execute_cmds "$reload_cmds" 'exit $?'

8639

8640

# Exit if we aren't doing a library object file.

8641

if test -z "$libobj"; then

8642

if test -n "$gentop"; then

8643

func_show_eval '${RM}r "$gentop"'

8644

fi

8645

8646

exit $EXIT_SUCCESS

8647

fi

8648

8649

if test "$build_libtool_libs" != yes; then

8650

if test -n "$gentop"; then

8651

func_show_eval '${RM}r "$gentop"'

8652

fi

8653

8654

# Create an invalid libtool object if no PIC, so that we don't

8655

# accidentally link it into a program.

8656

# $show "echo timestamp > $libobj"

8657

# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?

8658

exit $EXIT_SUCCESS

8659

fi

8660

8661

if test -n "$pic_flag" || test "$pic_mode" != default; then

8662

# Only do commands if we really have different PIC objects.

8663

reload_objs="$libobjs $reload_conv_objs"

8664

output="$libobj"

8665

func_execute_cmds "$reload_cmds" 'exit $?'

8666

fi

8667

8668

if test -n "$gentop"; then

8669

func_show_eval '${RM}r "$gentop"'

8670

fi

8671

8672

exit $EXIT_SUCCESS

8673

;;

8674

8675

prog)

8676

case $host in

8677

*cygwin*) func_stripname '' '.exe' "$output"

8678

output=$func_stripname_result.exe;;

8679

esac

8680

test -n "$vinfo" && \

8681

func_warning "\`-version-info' is ignored for programs"

8682

8683

test -n "$release" && \

8684

func_warning "\`-release' is ignored for programs"

8685

8686

test "$preload" = yes \

8687

&& test "$dlopen_support" = unknown \

8688

&& test "$dlopen_self" = unknown \

8689

&& test "$dlopen_self_static" = unknown && \

8690

func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

8691

8692

case $host in

8693

*-*-rhapsody* | *-*-darwin1.[012])

8694

# On Rhapsody replace the C library is the System framework

8695

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

8696

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

8697

;;

8698

esac

8699

8700

case $host in

8701

*-*-darwin*)

8702

# Don't allow lazy linking, it breaks C++ global constructors

8703

# But is supposedly fixed on 10.4 or later (yay!).

8704

if test "$tagname" = CXX ; then

8705

case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

8706

10.[0123])

8707

func_append compile_command " ${wl}-bind_at_load"

8708

func_append finalize_command " ${wl}-bind_at_load"

8709

;;

8710

esac

8711

fi

8712

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

8713

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8714

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8715

;;

8716

esac

8717

8718

8719

# move library search paths that coincide with paths to not yet

8720

# installed libraries to the beginning of the library search list

8721

new_libs=

8722

for path in $notinst_path; do

8723

case " $new_libs " in

8724

*" -L$path/$objdir "*) ;;

8725

*)

8726

case " $compile_deplibs " in

8727

*" -L$path/$objdir "*)

8728

func_append new_libs " -L$path/$objdir" ;;

8729

esac

8730

;;

8731

esac

8732

done

8733

for deplib in $compile_deplibs; do

8734

case $deplib in

8735

-L*)

8736

case " $new_libs " in

8737

*" $deplib "*) ;;

8738

*) func_append new_libs " $deplib" ;;

8739

esac

8740

;;

8741

*) func_append new_libs " $deplib" ;;

8742

esac

8743

done

8744

compile_deplibs="$new_libs"

8745

8746

8747

func_append compile_command " $compile_deplibs"

8748

func_append finalize_command " $finalize_deplibs"

8749

8750

if test -n "$rpath$xrpath"; then

8751

# If the user specified any rpath flags, then add them.

8752

for libdir in $rpath $xrpath; do

8753

# This is the magic to use -rpath.

8754

case "$finalize_rpath " in

8755

*" $libdir "*) ;;

8756

*) func_append finalize_rpath " $libdir" ;;

8757

esac

8758

done

8759

fi

8760

8761

# Now hardcode the library paths

8762

rpath=

8763

hardcode_libdirs=

8764

for libdir in $compile_rpath $finalize_rpath; do

8765

if test -n "$hardcode_libdir_flag_spec"; then

8766

if test -n "$hardcode_libdir_separator"; then

8767

if test -z "$hardcode_libdirs"; then

8768

hardcode_libdirs="$libdir"

8769

else

8770

# Just accumulate the unique libdirs.

8771

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8772

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8773

;;

8774

*)

8775

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8776

;;

8777

esac

8778

fi

8779

else

8780

eval flag=\"$hardcode_libdir_flag_spec\"

8781

func_append rpath " $flag"

8782

fi

8783

elif test -n "$runpath_var"; then

8784

case "$perm_rpath " in

8785

*" $libdir "*) ;;

8786

*) func_append perm_rpath " $libdir" ;;

8787

esac

8788

fi

8789

case $host in

8790

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

8791

testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`

8792

case :$dllsearchpath: in

8793

*":$libdir:"*) ;;

8794

::) dllsearchpath=$libdir;;

8795

*) func_append dllsearchpath ":$libdir";;

8796

esac

8797

case :$dllsearchpath: in

8798

*":$testbindir:"*) ;;

8799

::) dllsearchpath=$testbindir;;

8800

*) func_append dllsearchpath ":$testbindir";;

8801

esac

8802

;;

8803

esac

8804

done

8805

# Substitute the hardcoded libdirs into the rpath.

8806

if test -n "$hardcode_libdir_separator" &&

8807

test -n "$hardcode_libdirs"; then

8808

libdir="$hardcode_libdirs"

8809

eval rpath=\" $hardcode_libdir_flag_spec\"

8810

fi

8811

compile_rpath="$rpath"

8812

8813

rpath=

8814

hardcode_libdirs=

8815

for libdir in $finalize_rpath; do

8816

if test -n "$hardcode_libdir_flag_spec"; then

8817

if test -n "$hardcode_libdir_separator"; then

8818

if test -z "$hardcode_libdirs"; then

8819

hardcode_libdirs="$libdir"

8820

else

8821

# Just accumulate the unique libdirs.

8822

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8823

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8824

;;

8825

*)

8826

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8827

;;

8828

esac

8829

fi

8830

else

8831

eval flag=\"$hardcode_libdir_flag_spec\"

8832

func_append rpath " $flag"

8833

fi

8834

elif test -n "$runpath_var"; then

8835

case "$finalize_perm_rpath " in

8836

*" $libdir "*) ;;

8837

*) func_append finalize_perm_rpath " $libdir" ;;

8838

esac

8839

fi

8840

done

8841

# Substitute the hardcoded libdirs into the rpath.

8842

if test -n "$hardcode_libdir_separator" &&

8843

test -n "$hardcode_libdirs"; then

8844

libdir="$hardcode_libdirs"

8845

eval rpath=\" $hardcode_libdir_flag_spec\"

8846

fi

8847

finalize_rpath="$rpath"

8848

8849

if test -n "$libobjs" && test "$build_old_libs" = yes; then

8850

# Transform all the library objects into standard objects.

8851

compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8852

finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8853

fi

8854

8855

func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

8856

8857

# template prelinking step

8858

if test -n "$prelink_cmds"; then

8859

func_execute_cmds "$prelink_cmds" 'exit $?'

8860

fi

8861

8862

wrappers_required=yes

8863

case $host in

8864

*cegcc* | *mingw32ce*)

8865

# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

8866

wrappers_required=no

8867

;;

8868

*cygwin* | *mingw* )

8869

if test "$build_libtool_libs" != yes; then

8870

wrappers_required=no

8871

fi

8872

;;

8873

*)

8874

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

8875

wrappers_required=no

8876

fi

8877

;;

8878

esac

8879

if test "$wrappers_required" = no; then

8880

# Replace the output file specification.

8881

compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8882

link_command="$compile_command$compile_rpath"

8883

8884

# We have no uninstalled library dependencies, so finalize right now.

8885

exit_status=0

8886

func_show_eval "$link_command" 'exit_status=$?'

8887

8888

if test -n "$postlink_cmds"; then

8889

func_to_tool_file "$output"

8890

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8891

func_execute_cmds "$postlink_cmds" 'exit $?'

8892

fi

8893

8894

# Delete the generated files.

8895

if test -f "$output_objdir/${outputname}S.${objext}"; then

8896

func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

8897

fi

8898

8899

exit $exit_status

8900

fi

8901

8902

if test -n "$compile_shlibpath$finalize_shlibpath"; then

8903

compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

8904

fi

8905

if test -n "$finalize_shlibpath"; then

8906

finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

8907

fi

8908

8909

compile_var=

8910

finalize_var=

8911

if test -n "$runpath_var"; then

8912

if test -n "$perm_rpath"; then

8913

# We should set the runpath_var.

8914

rpath=

8915

for dir in $perm_rpath; do

8916

func_append rpath "$dir:"

8917

done

8918

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

8919

fi

8920

if test -n "$finalize_perm_rpath"; then

8921

# We should set the runpath_var.

8922

rpath=

8923

for dir in $finalize_perm_rpath; do

8924

func_append rpath "$dir:"

8925

done

8926

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

8927

fi

8928

fi

8929

8930

if test "$no_install" = yes; then

8931

# We don't need to create a wrapper script.

8932

link_command="$compile_var$compile_command$compile_rpath"

8933

# Replace the output file specification.

8934

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8935

# Delete the old output file.

8936

$opt_dry_run || $RM $output

8937

# Link the executable and exit

8938

func_show_eval "$link_command" 'exit $?'

8939

8940

if test -n "$postlink_cmds"; then

8941

func_to_tool_file "$output"

8942

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8943

func_execute_cmds "$postlink_cmds" 'exit $?'

8944

fi

8945

8946

exit $EXIT_SUCCESS

8947

fi

8948

8949

if test "$hardcode_action" = relink; then

8950

# Fast installation is not supported

8951

link_command="$compile_var$compile_command$compile_rpath"

8952

relink_command="$finalize_var$finalize_command$finalize_rpath"

8953

8954

func_warning "this platform does not like uninstalled shared libraries"

8955

func_warning "\`$output' will be relinked during installation"

8956

else

8957

if test "$fast_install" != no; then

8958

link_command="$finalize_var$compile_command$finalize_rpath"

8959

if test "$fast_install" = yes; then

8960

relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

8961

else

8962

# fast_install is set to needless

8963

relink_command=

8964

fi

8965

else

8966

link_command="$compile_var$compile_command$compile_rpath"

8967

relink_command="$finalize_var$finalize_command$finalize_rpath"

8968

fi

8969

fi

8970

8971

# Replace the output file specification.

8972

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

8973

8974

# Delete the old output files.

8975

$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

8976

8977

func_show_eval "$link_command" 'exit $?'

8978

8979

if test -n "$postlink_cmds"; then

8980

func_to_tool_file "$output_objdir/$outputname"

8981

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8982

func_execute_cmds "$postlink_cmds" 'exit $?'

8983

fi

8984

8985

# Now create the wrapper script.

8986

func_verbose "creating $output"

8987

8988

# Quote the relink command for shipping.

8989

if test -n "$relink_command"; then

8990

# Preserve any variables that may affect compiler behavior

8991

for var in $variables_saved_for_relink; do

8992

if eval test -z \"\${$var+set}\"; then

8993

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

8994

elif eval var_value=\$$var; test -z "$var_value"; then

8995

relink_command="$var=; export $var; $relink_command"

8996

else

8997

func_quote_for_eval "$var_value"

8998

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

8999

fi

9000

done

9001

relink_command="(cd `pwd`; $relink_command)"

9002

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9003

fi

9004

9005

# Only actually do things if not in dry run mode.

9006

$opt_dry_run || {

9007

# win32 will think the script is a binary if it has

9008

# a .exe suffix, so we strip it off here.

9009

case $output in

9010

*.exe) func_stripname '' '.exe' "$output"

9011

output=$func_stripname_result ;;

9012

esac

9013

# test for cygwin because mv fails w/o .exe extensions

9014

case $host in

9015

*cygwin*)

9016

exeext=.exe

9017

func_stripname '' '.exe' "$outputname"

9018

outputname=$func_stripname_result ;;

9019

*) exeext= ;;

9020

esac

9021

case $host in

9022

*cygwin* | *mingw* )

9023

func_dirname_and_basename "$output" "" "."

9024

output_name=$func_basename_result

9025

output_path=$func_dirname_result

9026

cwrappersource="$output_path/$objdir/lt-$output_name.c"

9027

cwrapper="$output_path/$output_name.exe"

9028

$RM $cwrappersource $cwrapper

9029

trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

9030

9031

func_emit_cwrapperexe_src > $cwrappersource

9032

9033

# The wrapper executable is built using the $host compiler,

9034

# because it contains $host paths and files. If cross-

9035

# compiling, it, like the target executable, must be

9036

# executed on the $host or under an emulation environment.

9037

$opt_dry_run || {

9038

$LTCC $LTCFLAGS -o $cwrapper $cwrappersource

9039

$STRIP $cwrapper

9040

}

9041

9042

# Now, create the wrapper script for func_source use:

9043

func_ltwrapper_scriptname $cwrapper

9044

$RM $func_ltwrapper_scriptname_result

9045

trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15

9046

$opt_dry_run || {

9047

# note: this script will not be executed, so do not chmod.

9048

if test "x$build" = "x$host" ; then

9049

$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result

9050

else

9051

func_emit_wrapper no > $func_ltwrapper_scriptname_result

9052

fi

9053

}

9054

;;

9055

* )

9056

$RM $output

9057

trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

9058

9059

func_emit_wrapper no > $output

9060

chmod +x $output

9061

;;

9062

esac

9063

}

9064

exit $EXIT_SUCCESS

9065

;;

9066

esac

9067

9068

# See if we need to build an old-fashioned archive.

9069

for oldlib in $oldlibs; do

9070

9071

if test "$build_libtool_libs" = convenience; then

9072

oldobjs="$libobjs_save $symfileobj"

9073

addlibs="$convenience"

9074

build_libtool_libs=no

9075

else

9076

if test "$build_libtool_libs" = module; then

9077

oldobjs="$libobjs_save"

9078

build_libtool_libs=no

9079

else

9080

oldobjs="$old_deplibs $non_pic_objects"

9081

if test "$preload" = yes && test -f "$symfileobj"; then

9082

func_append oldobjs " $symfileobj"

9083

fi

9084

fi

9085

addlibs="$old_convenience"

9086

fi

9087

9088

if test -n "$addlibs"; then

9089

gentop="$output_objdir/${outputname}x"

9090

func_append generated " $gentop"

9091

9092

func_extract_archives $gentop $addlibs

9093

func_append oldobjs " $func_extract_archives_result"

9094

fi

9095

9096

# Do each command in the archive commands.

9097

if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

9098

cmds=$old_archive_from_new_cmds

9099

else

9100

9101

# Add any objects from preloaded convenience libraries

9102

if test -n "$dlprefiles"; then

9103

gentop="$output_objdir/${outputname}x"

9104

func_append generated " $gentop"

9105

9106

func_extract_archives $gentop $dlprefiles

9107

func_append oldobjs " $func_extract_archives_result"

9108

fi

9109

9110

# POSIX demands no paths to be encoded in archives. We have

9111

# to avoid creating archives with duplicate basenames if we

9112

# might have to extract them afterwards, e.g., when creating a

9113

# static archive out of a convenience library, or when linking

9114

# the entirety of a libtool archive into another (currently

9115

# not supported by libtool).

9116

if (for obj in $oldobjs

9117

do

9118

func_basename "$obj"

9119

$ECHO "$func_basename_result"

9120

done | sort | sort -uc >/dev/null 2>&1); then

9121

:

9122

else

9123

echo "copying selected object files to avoid basename conflicts..."

9124

gentop="$output_objdir/${outputname}x"

9125

func_append generated " $gentop"

9126

func_mkdir_p "$gentop"

9127

save_oldobjs=$oldobjs

9128

oldobjs=

9129

counter=1

9130

for obj in $save_oldobjs

9131

do

9132

func_basename "$obj"

9133

objbase="$func_basename_result"

9134

case " $oldobjs " in

9135

" ") oldobjs=$obj ;;

9136

*[\ /]"$objbase "*)

9137

while :; do

9138

# Make sure we don't pick an alternate name that also

9139

# overlaps.

9140

newobj=lt$counter-$objbase

9141

func_arith $counter + 1

9142

counter=$func_arith_result

9143

case " $oldobjs " in

9144

*[\ /]"$newobj "*) ;;

9145

*) if test ! -f "$gentop/$newobj"; then break; fi ;;

9146

esac

9147

done

9148

func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

9149

func_append oldobjs " $gentop/$newobj"

9150

;;

9151

*) func_append oldobjs " $obj" ;;

9152

esac

9153

done

9154

fi

9155

eval cmds=\"$old_archive_cmds\"

9156

9157

func_len " $cmds"

9158

len=$func_len_result

9159

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

9160

cmds=$old_archive_cmds

9161

elif test -n "$archiver_list_spec"; then

9162

func_verbose "using command file archive linking..."

9163

for obj in $oldobjs

9164

do

9165

func_to_tool_file "$obj"

9166

$ECHO "$func_to_tool_file_result"

9167

done > $output_objdir/$libname.libcmd

9168

func_to_tool_file "$output_objdir/$libname.libcmd"

9169

oldobjs=" $archiver_list_spec$func_to_tool_file_result"

9170

cmds=$old_archive_cmds

9171

else

9172

# the command line is too long to link in one step, link in parts

9173

func_verbose "using piecewise archive linking..."

9174

save_RANLIB=$RANLIB

9175

RANLIB=:

9176

objlist=

9177

concat_cmds=

9178

save_oldobjs=$oldobjs

9179

oldobjs=

9180

# Is there a better way of finding the last object in the list?

9181

for obj in $save_oldobjs

9182

do

9183

last_oldobj=$obj

9184

done

9185

eval test_cmds=\"$old_archive_cmds\"

9186

func_len " $test_cmds"

9187

len0=$func_len_result

9188

len=$len0

9189

for obj in $save_oldobjs

9190

do

9191

func_len " $obj"

9192

func_arith $len + $func_len_result

9193

len=$func_arith_result

9194

func_append objlist " $obj"

9195

if test "$len" -lt "$max_cmd_len"; then

9196

:

9197

else

9198

# the above command should be used before it gets too long

9199

oldobjs=$objlist

9200

if test "$obj" = "$last_oldobj" ; then

9201

RANLIB=$save_RANLIB

9202

fi

9203

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

9204

eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

9205

objlist=

9206

len=$len0

9207

fi

9208

done

9209

RANLIB=$save_RANLIB

9210

oldobjs=$objlist

9211

if test "X$oldobjs" = "X" ; then

9212

eval cmds=\"\$concat_cmds\"

9213

else

9214

eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

9215

fi

9216

fi

9217

fi

9218

func_execute_cmds "$cmds" 'exit $?'

9219

done

9220

9221

test -n "$generated" && \

9222

func_show_eval "${RM}r$generated"

9223

9224

# Now create the libtool archive.

9225

case $output in

9226

*.la)

9227

old_library=

9228

test "$build_old_libs" = yes && old_library="$libname.$libext"

9229

func_verbose "creating $output"

9230

9231

# Preserve any variables that may affect compiler behavior

9232

for var in $variables_saved_for_relink; do

9233

if eval test -z \"\${$var+set}\"; then

9234

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9235

elif eval var_value=\$$var; test -z "$var_value"; then

9236

relink_command="$var=; export $var; $relink_command"

9237

else

9238

func_quote_for_eval "$var_value"

9239

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9240

fi

9241

done

9242

# Quote the link command for shipping.

9243

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

9244

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9245

if test "$hardcode_automatic" = yes ; then

9246

relink_command=

9247

fi

9248

9249

# Only create the output if not a dry run.

9250

$opt_dry_run || {

9251

for installed in no yes; do

9252

if test "$installed" = yes; then

9253

if test -z "$install_libdir"; then

9254

break

9255

fi

9256

output="$output_objdir/$outputname"i

9257

# Replace all uninstalled libtool libraries with the installed ones

9258

newdependency_libs=

9259

for deplib in $dependency_libs; do

9260

case $deplib in

9261

*.la)

9262

func_basename "$deplib"

9263

name="$func_basename_result"

9264

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

9265

test -z "$libdir" && \

9266

func_fatal_error "\`$deplib' is not a valid libtool archive"

9267

func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"

9268

;;

9269

-L*)

9270

func_stripname -L '' "$deplib"

9271

func_replace_sysroot "$func_stripname_result"

9272

func_append newdependency_libs " -L$func_replace_sysroot_result"

9273

;;

9274

-R*)

9275

func_stripname -R '' "$deplib"

9276

func_replace_sysroot "$func_stripname_result"

9277

func_append newdependency_libs " -R$func_replace_sysroot_result"

9278

;;

9279

*) func_append newdependency_libs " $deplib" ;;

9280

esac

9281

done

9282

dependency_libs="$newdependency_libs"

9283

newdlfiles=

9284

9285

for lib in $dlfiles; do

9286

case $lib in

9287

*.la)

9288

func_basename "$lib"

9289

name="$func_basename_result"

9290

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9291

test -z "$libdir" && \

9292

func_fatal_error "\`$lib' is not a valid libtool archive"

9293

func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"

9294

;;

9295

*) func_append newdlfiles " $lib" ;;

9296

esac

9297

done

9298

dlfiles="$newdlfiles"

9299

newdlprefiles=

9300

for lib in $dlprefiles; do

9301

case $lib in

9302

*.la)

9303

# Only pass preopened files to the pseudo-archive (for

9304

# eventual linking with the app. that links it) if we

9305

# didn't already link the preopened objects directly into

9306

# the library:

9307

func_basename "$lib"

9308

name="$func_basename_result"

9309

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9310

test -z "$libdir" && \

9311

func_fatal_error "\`$lib' is not a valid libtool archive"

9312

func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"

9313

;;

9314

esac

9315

done

9316

dlprefiles="$newdlprefiles"

9317

else

9318

newdlfiles=

9319

for lib in $dlfiles; do

9320

case $lib in

9321

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9322

*) abs=`pwd`"/$lib" ;;

9323

esac

9324

func_append newdlfiles " $abs"

9325

done

9326

dlfiles="$newdlfiles"

9327

newdlprefiles=

9328

for lib in $dlprefiles; do

9329

case $lib in

9330

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9331

*) abs=`pwd`"/$lib" ;;

9332

esac

9333

func_append newdlprefiles " $abs"

9334

done

9335

dlprefiles="$newdlprefiles"

9336

fi

9337

$RM $output

9338

# place dlname in correct position for cygwin

9339

# In fact, it would be nice if we could use this code for all target

9340

# systems that can't hard-code library paths into their executables

9341

# and that have no shared library path variable independent of PATH,

9342

# but it turns out we can't easily determine that from inspecting

9343

# libtool variables, so we have to hard-code the OSs to which it

9344

# applies here; at the moment, that means platforms that use the PE

9345

# object format with DLL files. See the long comment at the top of

9346

# tests/bindir.at for full details.

9347

tdlname=$dlname

9348

case $host,$output,$installed,$module,$dlname in

9349

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9350

# If a -bindir argument was supplied, place the dll there.

9351

if test "x$bindir" != x ;

9352

then

9353

func_relative_path "$install_libdir" "$bindir"

9354

tdlname=$func_relative_path_result$dlname

9355

else

9356

# Otherwise fall back on heuristic.

9357

tdlname=../bin/$dlname

9358

fi

9359

;;

9360

esac

9361

$ECHO > $output "\

9362

# $outputname - a libtool library file

9363

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

9364

#

9365

# Please DO NOT delete this file!

9366

# It is necessary for linking the library.

9367

9368

# The name that we can dlopen(3).

9369

dlname='$tdlname'

9370

9371

# Names of this library.

9372

library_names='$library_names'

9373

9374

# The name of the static archive.

9375

old_library='$old_library'

9376

9377

# Linker flags that can not go in dependency_libs.

9378

inherited_linker_flags='$new_inherited_linker_flags'

9379

9380

# Libraries that this one depends upon.

9381

dependency_libs='$dependency_libs'

9382

9383

# Names of additional weak libraries provided by this library

9384

weak_library_names='$weak_libs'

9385

9386

# Version information for $libname.

9387

current=$current

9388

age=$age

9389

revision=$revision

9390

9391

# Is this an already installed library?

9392

installed=$installed

9393

9394

# Should we warn about portability when linking against -modules?

9395

shouldnotlink=$module

9396

9397

# Files to dlopen/dlpreopen

9398

dlopen='$dlfiles'

9399

dlpreopen='$dlprefiles'

9400

9401

# Directory that this library needs to be installed in:

9402

libdir='$install_libdir'"

9403

if test "$installed" = no && test "$need_relink" = yes; then

9404

$ECHO >> $output "\

9405

relink_command=\"$relink_command\""

9406

fi

9407

done

9408

}

9409

9410

# Do a symbolic link so that the libtool archive can be found in

9411

# LD_LIBRARY_PATH before the program is installed.

9412

func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'

9413

;;

9414

esac

9415

exit $EXIT_SUCCESS

9416

}

9417

9418

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&

9419

func_mode_link ${1+"$@"}

9420

9421

9422

# func_mode_uninstall arg...

9423

func_mode_uninstall ()

9424

{

9425

$opt_debug

9426

RM="$nonopt"

9427

files=

9428

rmforce=

9429

exit_status=0

9430

9431

# This variable tells wrapper scripts just to set variables rather

9432

# than running their programs.

9433

libtool_install_magic="$magic"

9434

9435

for arg

9436

do

9437

case $arg in

9438

-f) func_append RM " $arg"; rmforce=yes ;;

9439

-*) func_append RM " $arg" ;;

9440

*) func_append files " $arg" ;;

9441

esac

9442

done

9443

9444

test -z "$RM" && \

9445

func_fatal_help "you must specify an RM program"

9446

9447

rmdirs=

9448

9449

for file in $files; do

9450

func_dirname "$file" "" "."

9451

dir="$func_dirname_result"

9452

if test "X$dir" = X.; then

9453

odir="$objdir"

9454

else

9455

odir="$dir/$objdir"

9456

fi

9457

func_basename "$file"

9458

name="$func_basename_result"

9459

test "$opt_mode" = uninstall && odir="$dir"

9460

9461

# Remember odir for removal later, being careful to avoid duplicates

9462

if test "$opt_mode" = clean; then

9463

case " $rmdirs " in

9464

*" $odir "*) ;;

9465

*) func_append rmdirs " $odir" ;;

9466

esac

9467

fi

9468

9469

# Don't error if the file doesn't exist and rm -f was used.

9470

if { test -L "$file"; } >/dev/null 2>&1 ||

9471

{ test -h "$file"; } >/dev/null 2>&1 ||

9472

test -f "$file"; then

9473

:

9474

elif test -d "$file"; then

9475

exit_status=1

9476

continue

9477

elif test "$rmforce" = yes; then

9478

continue

9479

fi

9480

9481

rmfiles="$file"

9482

9483

case $name in

9484

*.la)

9485

# Possibly a libtool archive, so verify it.

9486

if func_lalib_p "$file"; then

9487

func_source $dir/$name

9488

9489

# Delete the libtool libraries and symlinks.

9490

for n in $library_names; do

9491

func_append rmfiles " $odir/$n"

9492

done

9493

test -n "$old_library" && func_append rmfiles " $odir/$old_library"

9494

9495

case "$opt_mode" in

9496

clean)

9497

case " $library_names " in

9498

*" $dlname "*) ;;

9499

*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;

9500

esac

9501

test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"

9502

;;

9503

uninstall)

9504

if test -n "$library_names"; then

9505

# Do each command in the postuninstall commands.

9506

func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9507

fi

9508

9509

if test -n "$old_library"; then

9510

# Do each command in the old_postuninstall commands.

9511

func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9512

fi

9513

# FIXME: should reinstall the best remaining shared library.

9514

;;

9515

esac

9516

fi

9517

;;

9518

9519

*.lo)

9520

# Possibly a libtool object, so verify it.

9521

if func_lalib_p "$file"; then

9522

9523

# Read the .lo file

9524

func_source $dir/$name

9525

9526

# Add PIC object to the list of files to remove.

9527

if test -n "$pic_object" &&

9528

test "$pic_object" != none; then

9529

func_append rmfiles " $dir/$pic_object"

9530

fi

9531

9532

# Add non-PIC object to the list of files to remove.

9533

if test -n "$non_pic_object" &&

9534

test "$non_pic_object" != none; then

9535

func_append rmfiles " $dir/$non_pic_object"

9536

fi

9537

fi

9538

;;

9539

9540

*)

9541

if test "$opt_mode" = clean ; then

9542

noexename=$name

9543

case $file in

9544

*.exe)

9545

func_stripname '' '.exe' "$file"

9546

file=$func_stripname_result

9547

func_stripname '' '.exe' "$name"

9548

noexename=$func_stripname_result

9549

# $file with .exe has already been added to rmfiles,

9550

# add $file without .exe

9551

func_append rmfiles " $file"

9552

;;

9553

esac

9554

# Do a test to see if this is a libtool program.

9555

if func_ltwrapper_p "$file"; then

9556

if func_ltwrapper_executable_p "$file"; then

9557

func_ltwrapper_scriptname "$file"

9558

relink_command=

9559

func_source $func_ltwrapper_scriptname_result

9560

func_append rmfiles " $func_ltwrapper_scriptname_result"

9561

else

9562

relink_command=

9563

func_source $dir/$noexename

9564

fi

9565

9566

# note $name still contains .exe if it was in $file originally

9567

# as does the version of $file that was added into $rmfiles

9568

func_append rmfiles " $odir/$name $odir/${name}S.${objext}"

9569

if test "$fast_install" = yes && test -n "$relink_command"; then

9570

func_append rmfiles " $odir/lt-$name"

9571

fi

9572

if test "X$noexename" != "X$name" ; then

9573

func_append rmfiles " $odir/lt-${noexename}.c"

9574

fi

9575

fi

9576

fi

9577

;;

9578

esac

9579

func_show_eval "$RM $rmfiles" 'exit_status=1'

9580

done

9581

9582

# Try to remove the ${objdir}s in the directories where we deleted files

9583

for dir in $rmdirs; do

9584

if test -d "$dir"; then

9585

func_show_eval "rmdir $dir >/dev/null 2>&1"

9586

fi

9587

done

9588

9589

exit $exit_status

9590

}

9591

9592

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&

9593

func_mode_uninstall ${1+"$@"}

9594

9595

test -z "$opt_mode" && {

9596

help="$generic_help"

9597

func_fatal_help "you must specify a MODE"

9598

}

9599

9600

test -z "$exec_cmd" && \

9601

func_fatal_help "invalid operation mode \`$opt_mode'"

9602

9603

if test -n "$exec_cmd"; then

9604

eval exec "$exec_cmd"

9605

exit $EXIT_FAILURE

9606

fi

9607

9608

exit $exit_status

9609

9610

9611

# The TAGs below are defined such that we never get into a situation

9612

# in which we disable both kinds of libraries. Given conflicting

9613

# choices, we go for a static library, that is the most portable,

9614

# since we can't tell whether shared libraries were disabled because

9615

# the user asked for that or because the platform doesn't support

9616

# them. This is particularly important on AIX, because we don't

9617

# support having both static and shared libraries enabled at the same

9618

# time on that platform, so we default to a shared-only configuration.

9619

# If a disable-shared tag is given, we'll fallback to a static-only

9620

# configuration. But we'll never go from static-only to shared-only.

9621

9622

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared

9623

build_libtool_libs=no

9624

build_old_libs=yes

9625

# ### END LIBTOOL TAG CONFIG: disable-shared

9626

9627

# ### BEGIN LIBTOOL TAG CONFIG: disable-static

9628

build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

9629

# ### END LIBTOOL TAG CONFIG: disable-static

9630

9631

# Local Variables:

9632

# mode:shell-script

9633

# sh-indentation:2

9634

# End:

9635

# vi:sw=2

9636