~kaozilon/totem/test : revision 25

1

2

# libtool (GNU libtool) 2.4.2

3

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

4

5

6

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

7

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

8

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

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

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

45

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

46

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

47

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

48

# --version print version information

49

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

50

#

51

# MODE must be one of the following:

52

#

53

# clean remove files from the build directory

54

# compile compile a source file into a libtool object

55

# execute automatically set library path, then run a program

56

# finish complete the installation of libtool libraries

57

# install install libraries or executables

58

# link create a library or an executable

59

# uninstall remove libraries from an installed directory

60

#

61

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

62

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

63

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

64

#

65

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

66

# include the following information:

67

#

68

# host-triplet: $host

69

# shell: $SHELL

70

# compiler: $LTCC

71

# compiler flags: $LTCFLAGS

72

# linker: $LD (gnu? $with_gnu_ld)

73

# $progname: (GNU libtool) 2.4.2

74

# automake: $automake_version

75

# autoconf: $autoconf_version

76

#

77

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

78

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

79

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

80

81

PROGRAM=libtool

82

PACKAGE=libtool

83

VERSION=2.4.2

84

TIMESTAMP=""

85

package_revision=1.3337

86

87

# Be Bourne compatible

88

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

89

emulate sh

90

NULLCMD=:

91

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

92

# is contrary to our usage. Disable this feature.

93

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

94

setopt NO_GLOB_SUBST

95

else

96

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

97

fi

98

BIN_SH=xpg4; export BIN_SH # for Tru64

99

DUALCASE=1; export DUALCASE # for MKS sh

100

101

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

102

func_fallback_echo ()

103

{

104

eval 'cat <<_LTECHO_EOF

105

$1

106

_LTECHO_EOF'

107

}

108

109

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

110

lt_user_locale=

111

lt_safe_locale=

112

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

113

do

114

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

115

save_$lt_var=\$$lt_var

116

$lt_var=C

117

export $lt_var

118

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

119

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

120

fi"

121

done

122

LC_ALL=C

123

LANGUAGE=C

124

export LANGUAGE LC_ALL

125

126

$lt_unset CDPATH

127

128

129

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

130

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

131

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

132

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

133

# function.

134

progpath="$0"

135

136

137

138

: ${CP="cp -f"}

139

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

140

: ${MAKE="make"}

141

: ${MKDIR="mkdir"}

142

: ${MV="mv -f"}

143

: ${RM="rm -f"}

144

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

145

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

146

147

# Global variables:

148

EXIT_SUCCESS=0

149

EXIT_FAILURE=1

150

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

151

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

152

153

exit_status=$EXIT_SUCCESS

154

155

# Make sure IFS has a sensible default

156

lt_nl='

157

'

158

IFS=" $lt_nl"

159

160

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

161

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

162

163

# func_dirname file append nondir_replacement

164

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

165

# otherwise set result to NONDIR_REPLACEMENT.

166

func_dirname ()

167

{

168

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

169

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

170

func_dirname_result="${3}"

171

else

172

func_dirname_result="$func_dirname_result${2}"

173

fi

174

} # func_dirname may be replaced by extended shell implementation

175

176

177

# func_basename file

178

func_basename ()

179

{

180

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

181

} # func_basename may be replaced by extended shell implementation

182

183

184

# func_dirname_and_basename file append nondir_replacement

185

# perform func_basename and func_dirname in a single function

186

# call:

187

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

188

# add APPEND to the result, otherwise set result

189

# to NONDIR_REPLACEMENT.

190

# value returned in "$func_dirname_result"

191

# basename: Compute filename of FILE.

192

# value retuned in "$func_basename_result"

193

# Implementation must be kept synchronized with func_dirname

194

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

195

# those functions but instead duplicate the functionality here.

196

func_dirname_and_basename ()

197

{

198

# Extract subdirectory from the argument.

199

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

200

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

201

func_dirname_result="${3}"

202

else

203

func_dirname_result="$func_dirname_result${2}"

204

fi

205

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

206

} # func_dirname_and_basename may be replaced by extended shell implementation

207

208

209

# func_stripname prefix suffix name

210

# strip PREFIX and SUFFIX off of NAME.

211

# PREFIX and SUFFIX must not contain globbing or regex special

212

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

213

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

214

# func_strip_suffix prefix name

215

func_stripname ()

216

{

217

case ${2} in

218

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

219

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

220

esac

221

} # func_stripname may be replaced by extended shell implementation

222

223

224

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

225

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

226

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

227

removedotparts=':dotsl

228

s@/\./@/@g

229

t dotsl

230

s,/\.$,/,'

231

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

232

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

233

234

# func_normal_abspath PATH

235

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

236

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

237

# it an absolute path.

238

# value returned in "$func_normal_abspath_result"

239

func_normal_abspath ()

240

{

241

# Start from root dir and reassemble the path.

242

func_normal_abspath_result=

243

func_normal_abspath_tpath=$1

244

func_normal_abspath_altnamespace=

245

case $func_normal_abspath_tpath in

246

"")

247

# Empty path, that just means $cwd.

248

func_stripname '' '/' "`pwd`"

249

func_normal_abspath_result=$func_stripname_result

250

return

251

;;

252

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

253

# two leading slashes without using negated character classes;

254

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

255

///*)

256

# Unusual form of absolute path, do nothing.

257

;;

258

//*)

259

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

260

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

261

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

262

func_normal_abspath_altnamespace=/

263

;;

264

/*)

265

# Absolute path, do nothing.

266

;;

267

*)

268

# Relative path, prepend $cwd.

269

func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

270

;;

271

esac

272

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

273

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

274

# there is one (and only one) here.

275

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

276

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

277

while :; do

278

# Processed it all yet?

279

if test "$func_normal_abspath_tpath" = / ; then

280

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

281

if test -z "$func_normal_abspath_result" ; then

282

func_normal_abspath_result=/

283

fi

284

break

285

fi

286

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

287

-e "$pathcar"`

288

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

289

-e "$pathcdr"`

290

# Figure out what to do with it

291

case $func_normal_abspath_tcomponent in

292

"")

293

# Trailing empty path component, ignore it.

294

;;

295

..)

296

# Parent dir; strip last assembled component from result.

297

func_dirname "$func_normal_abspath_result"

298

func_normal_abspath_result=$func_dirname_result

299

;;

300

*)

301

# Actual path component, append it.

302

func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

303

;;

304

esac

305

done

306

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

307

func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

308

}

309

310

# func_relative_path SRCDIR DSTDIR

311

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

312

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

313

# without needing to append a separator.

314

# value returned in "$func_relative_path_result"

315

func_relative_path ()

316

{

317

func_relative_path_result=

318

func_normal_abspath "$1"

319

func_relative_path_tlibdir=$func_normal_abspath_result

320

func_normal_abspath "$2"

321

func_relative_path_tbindir=$func_normal_abspath_result

322

323

# Ascend the tree starting from libdir

324

while :; do

325

# check if we have found a prefix of bindir

326

case $func_relative_path_tbindir in

327

$func_relative_path_tlibdir)

328

# found an exact match

329

func_relative_path_tcancelled=

330

break

331

;;

332

$func_relative_path_tlibdir*)

333

# found a matching prefix

334

func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

335

func_relative_path_tcancelled=$func_stripname_result

336

if test -z "$func_relative_path_result"; then

337

func_relative_path_result=.

338

fi

339

break

340

;;

341

*)

342

func_dirname $func_relative_path_tlibdir

343

func_relative_path_tlibdir=${func_dirname_result}

344

if test "x$func_relative_path_tlibdir" = x ; then

345

# Have to descend all the way to the root!

346

func_relative_path_result=../$func_relative_path_result

347

func_relative_path_tcancelled=$func_relative_path_tbindir

348

break

349

fi

350

func_relative_path_result=../$func_relative_path_result

351

;;

352

esac

353

done

354

355

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

356

func_stripname '' '/' "$func_relative_path_result"

357

func_relative_path_result=$func_stripname_result

358

func_stripname '/' '/' "$func_relative_path_tcancelled"

359

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

360

func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

361

fi

362

363

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

364

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

365

# file name can be directly appended.

366

if test ! -z "$func_relative_path_result"; then

367

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

368

func_relative_path_result=$func_stripname_result

369

fi

370

}

371

372

# The name of this program:

373

func_dirname_and_basename "$progpath"

374

progname=$func_basename_result

375

376

# Make sure we have an absolute path for reexecution:

377

case $progpath in

378

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

379

*[\\/]*)

380

progdir=$func_dirname_result

381

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

382

progpath="$progdir/$progname"

383

;;

384

*)

385

save_IFS="$IFS"

386

IFS=${PATH_SEPARATOR-:}

387

for progdir in $PATH; do

388

IFS="$save_IFS"

389

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

390

done

391

IFS="$save_IFS"

392

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

393

progpath="$progdir/$progname"

394

;;

395

esac

396

397

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

398

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

399

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

400

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

401

402

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

403

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

404

405

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

406

# string literally.

407

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

408

409

# Sed substitution that converts a w32 file name or path

410

# which contains forward slashes, into one that contains

411

# (escaped) backslashes. A very naive implementation.

412

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

413

414

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

415

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

416

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

417

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

418

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

419

bs='\\'

420

bs2='\\\\'

421

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

422

dollar='\$'

423

sed_double_backslash="\

424

s/$bs4/&\\

425

/g

426

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

427

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

428

s/\n//g"

429

430

# Standard options:

431

opt_dry_run=false

432

opt_help=false

433

opt_quiet=false

434

opt_verbose=false

435

opt_warning=:

436

437

# func_echo arg...

438

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

439

# name if it has been set yet.

440

func_echo ()

441

{

442

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

443

}

444

445

# func_verbose arg...

446

# Echo program name prefixed message in verbose mode only.

447

func_verbose ()

448

{

449

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

450

451

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

452

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

453

# work around that:

454

:

455

}

456

457

# func_echo_all arg...

458

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

459

func_echo_all ()

460

{

461

$ECHO "$*"

462

}

463

464

# func_error arg...

465

# Echo program name prefixed message to standard error.

466

func_error ()

467

{

468

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

469

}

470

471

# func_warning arg...

472

# Echo program name prefixed warning message to standard error.

473

func_warning ()

474

{

475

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

476

477

# bash bug again:

478

:

479

}

480

481

# func_fatal_error arg...

482

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

483

func_fatal_error ()

484

{

485

func_error ${1+"$@"}

486

exit $EXIT_FAILURE

487

}

488

489

# func_fatal_help arg...

490

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

491

# a help hint, and exit.

492

func_fatal_help ()

493

{

494

func_error ${1+"$@"}

495

func_fatal_error "$help"

496

}

497

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

498

499

500

# func_grep expression filename

501

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

502

func_grep ()

503

{

504

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

505

}

506

507

508

# func_mkdir_p directory-path

509

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

510

func_mkdir_p ()

511

{

512

my_directory_path="$1"

513

my_dir_list=

514

515

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

516

517

# Protect directory names starting with `-'

518

case $my_directory_path in

519

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

520

esac

521

522

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

523

while test ! -d "$my_directory_path"; do

524

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

525

# list incase some portion of path contains whitespace.

526

my_dir_list="$my_directory_path:$my_dir_list"

527

528

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

529

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

530

531

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

532

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

533

done

534

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

535

536

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

537

for my_dir in $my_dir_list; do

538

IFS="$save_mkdir_p_IFS"

539

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

540

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

541

# stop in that case!

542

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

543

done

544

IFS="$save_mkdir_p_IFS"

545

546

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

547

test -d "$my_directory_path" || \

548

func_fatal_error "Failed to create \`$1'"

549

fi

550

}

551

552

553

# func_mktempdir [string]

554

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

555

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

556

# given, STRING is the basename for that directory.

557

func_mktempdir ()

558

{

559

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

560

561

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

562

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

563

my_tmpdir="${my_template}-$$"

564

else

565

566

# If mktemp works, use that first and foremost

567

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

568

569

if test ! -d "$my_tmpdir"; then

570

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

571

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

572

573

save_mktempdir_umask=`umask`

574

umask 0077

575

$MKDIR "$my_tmpdir"

576

umask $save_mktempdir_umask

577

fi

578

579

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

580

test -d "$my_tmpdir" || \

581

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

582

fi

583

584

$ECHO "$my_tmpdir"

585

}

586

587

588

# func_quote_for_eval arg

589

# Aesthetically quote ARG to be evaled later.

590

# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

591

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

592

# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

593

# which are still active within double quotes backslashified.

594

func_quote_for_eval ()

595

{

596

case $1 in

597

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

598

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

599

*)

600

func_quote_for_eval_unquoted_result="$1" ;;

601

esac

602

603

case $func_quote_for_eval_unquoted_result in

604

# Double-quote args containing shell metacharacters to delay

605

# word splitting, command substitution and and variable

606

# expansion for a subsequent eval.

607

# Many Bourne shells cannot handle close brackets correctly

608

# in scan sets, so we specify it separately.

609

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

610

func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

611

;;

612

*)

613

func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

614

esac

615

}

616

617

618

# func_quote_for_expand arg

619

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

620

# but do not quote variable references.

621

func_quote_for_expand ()

622

{

623

case $1 in

624

*[\\\`\"]*)

625

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

626

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

627

*)

628

my_arg="$1" ;;

629

esac

630

631

case $my_arg in

632

# Double-quote args containing shell metacharacters to delay

633

# word splitting and command substitution for a subsequent eval.

634

# Many Bourne shells cannot handle close brackets correctly

635

# in scan sets, so we specify it separately.

636

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

637

my_arg="\"$my_arg\""

638

;;

639

esac

640

641

func_quote_for_expand_result="$my_arg"

642

}

643

644

645

# func_show_eval cmd [fail_exp]

646

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

647

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

648

# is given, then evaluate it.

649

func_show_eval ()

650

{

651

my_cmd="$1"

652

my_fail_exp="${2-:}"

653

654

${opt_silent-false} || {

655

func_quote_for_expand "$my_cmd"

656

eval "func_echo $func_quote_for_expand_result"

657

}

658

659

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

660

eval "$my_cmd"

661

my_status=$?

662

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

663

eval "(exit $my_status); $my_fail_exp"

664

fi

665

fi

666

}

667

668

669

# func_show_eval_locale cmd [fail_exp]

670

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

671

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

672

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

673

func_show_eval_locale ()

674

{

675

my_cmd="$1"

676

my_fail_exp="${2-:}"

677

678

${opt_silent-false} || {

679

func_quote_for_expand "$my_cmd"

680

eval "func_echo $func_quote_for_expand_result"

681

}

682

683

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

684

eval "$lt_user_locale

685

$my_cmd"

686

my_status=$?

687

eval "$lt_safe_locale"

688

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

689

eval "(exit $my_status); $my_fail_exp"

690

fi

691

fi

692

}

693

694

# func_tr_sh

695

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

696

# Result is stored in $func_tr_sh_result. All characters

697

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

698

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

699

func_tr_sh ()

700

{

701

case $1 in

702

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

703

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

704

;;

705

* )

706

func_tr_sh_result=$1

707

;;

708

esac

709

}

710

711

712

# func_version

713

# Echo version message to standard output and exit.

714

func_version ()

715

{

716

$opt_debug

717

718

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

719

:more

720

/\./!{

721

N

722

s/\n# / /

723

b more

724

}

725

:go

726

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

727

s/^# //

728

s/^# *$//

729

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

730

p

731

}' < "$progpath"

732

exit $?

733

}

734

735

# func_usage

736

# Echo short help message to standard output and exit.

737

func_usage ()

738

{

739

$opt_debug

740

741

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

742

s/^# //

743

s/^# *$//

744

s/\$progname/'$progname'/

745

p

746

}' < "$progpath"

747

echo

748

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

749

exit $?

750

}

751

752

# func_help [NOEXIT]

753

# Echo long help message to standard output and exit,

754

# unless 'noexit' is passed as argument.

755

func_help ()

756

{

757

$opt_debug

758

759

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

760

:print

761

s/^# //

762

s/^# *$//

763

s*\$progname*'$progname'*

764

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

765

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

766

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

767

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

768

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

769

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

770

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

771

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

772

p

773

d

774

}

775

/^# .* home page:/b print

776

/^# General help using/b print

777

' < "$progpath"

778

ret=$?

779

if test -z "$1"; then

780

exit $ret

781

fi

782

}

783

784

# func_missing_arg argname

785

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

786

# exit_cmd.

787

func_missing_arg ()

788

{

789

$opt_debug

790

791

func_error "missing argument for $1."

792

exit_cmd=exit

793

}

794

795

796

# func_split_short_opt shortopt

797

# Set func_split_short_opt_name and func_split_short_opt_arg shell

798

# variables after splitting SHORTOPT after the 2nd character.

799

func_split_short_opt ()

800

{

801

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

802

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

803

804

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

805

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

806

} # func_split_short_opt may be replaced by extended shell implementation

807

808

809

# func_split_long_opt longopt

810

# Set func_split_long_opt_name and func_split_long_opt_arg shell

811

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

812

func_split_long_opt ()

813

{

814

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

815

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

816

817

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

818

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

819

} # func_split_long_opt may be replaced by extended shell implementation

820

821

exit_cmd=:

822

823

824

825

826

827

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

828

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

829

830

# Global variables.

831

nonopt=

832

preserve_args=

833

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

834

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

835

extracted_archives=

836

extracted_serial=0

837

838

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

839

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

840

# left over by shells.

841

exec_cmd=

842

843

# func_append var value

844

# Append VALUE to the end of shell variable VAR.

845

func_append ()

846

{

847

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

848

} # func_append may be replaced by extended shell implementation

849

850

# func_append_quoted var value

851

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

852

# by a space.

853

func_append_quoted ()

854

{

855

func_quote_for_eval "${2}"

856

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

857

} # func_append_quoted may be replaced by extended shell implementation

858

859

860

# func_arith arithmetic-term...

861

func_arith ()

862

{

863

func_arith_result=`expr "${@}"`

864

} # func_arith may be replaced by extended shell implementation

865

866

867

# func_len string

868

# STRING may not start with a hyphen.

869

func_len ()

870

{

871

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

872

} # func_len may be replaced by extended shell implementation

873

874

875

# func_lo2o object

876

func_lo2o ()

877

{

878

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

879

} # func_lo2o may be replaced by extended shell implementation

880

881

882

# func_xform libobj-or-source

883

func_xform ()

884

{

885

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

886

} # func_xform may be replaced by extended shell implementation

887

888

889

# func_fatal_configuration arg...

890

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

891

# a configuration failure hint, and exit.

892

func_fatal_configuration ()

893

{

894

func_error ${1+"$@"}

895

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

896

func_fatal_error "Fatal configuration error."

897

}

898

899

900

# func_config

901

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

902

func_config ()

903

{

904

re_begincf='^# ### BEGIN LIBTOOL'

905

re_endcf='^# ### END LIBTOOL'

906

907

# Default configuration.

908

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

909

910

# Now print the configurations for the tags.

911

for tagname in $taglist; do

912

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

913

done

914

915

exit $?

916

}

917

918

# func_features

919

# Display the features supported by this script.

920

func_features ()

921

{

922

echo "host: $host"

923

if test "$build_libtool_libs" = yes; then

924

echo "enable shared libraries"

925

else

926

echo "disable shared libraries"

927

fi

928

if test "$build_old_libs" = yes; then

929

echo "enable static libraries"

930

else

931

echo "disable static libraries"

932

fi

933

934

exit $?

935

}

936

937

# func_enable_tag tagname

938

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

939

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

940

# variable here.

941

func_enable_tag ()

942

{

943

# Global variable:

944

tagname="$1"

945

946

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

947

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

948

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

949

950

# Validate tagname.

951

case $tagname in

952

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

953

func_fatal_error "invalid tag name: $tagname"

954

;;

955

esac

956

957

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

958

# there but not specially marked.

959

case $tagname in

960

CC) ;;

961

*)

962

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

963

taglist="$taglist $tagname"

964

965

# Evaluate the configuration. Be careful to quote the path

966

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

967

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

968

# quotes we have to do it in 2 steps:

969

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

970

eval "$extractedcf"

971

else

972

func_error "ignoring unknown tag $tagname"

973

fi

974

;;

975

esac

976

}

977

978

# func_check_version_match

979

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

980

# release of libtool.

981

func_check_version_match ()

982

{

983

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

984

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

985

if test -z "$macro_version"; then

986

cat >&2 <<_LT_EOF

987

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

988

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

989

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

990

$progname: and run autoconf again.

991

_LT_EOF

992

else

993

cat >&2 <<_LT_EOF

994

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

995

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

996

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

997

$progname: and run autoconf again.

998

_LT_EOF

999

fi

1000

else

1001

cat >&2 <<_LT_EOF

1002

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

1003

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

1004

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

1005

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

1006

_LT_EOF

1007

fi

1008

1009

exit $EXIT_MISMATCH

1010

fi

1011

}

1012

1013

1014

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

1015

case $1 in

1016

clean|clea|cle|cl)

1017

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

1018

;;

1019

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

1020

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

1021

;;

1022

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

1023

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

1024

;;

1025

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

1026

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

1027

;;

1028

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

1029

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

1030

;;

1031

link|lin|li|l)

1032

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

1033

;;

1034

1035

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

1036

;;

1037

esac

1038

1039

1040

1041

# Option defaults:

1042

opt_debug=:

1043

opt_dry_run=false

1044

opt_config=false

1045

opt_preserve_dup_deps=false

1046

opt_features=false

1047

opt_finish=false

1048

opt_help=false

1049

opt_help_all=false

1050

opt_silent=:

1051

opt_warning=:

1052

opt_verbose=:

1053

opt_silent=false

1054

opt_verbose=false

1055

1056

1057

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

1058

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

1059

{

1060

# this just eases exit handling

1061

while test $# -gt 0; do

1062

opt="$1"

1063

shift

1064

case $opt in

1065

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

1066

func_echo "enabling shell trace mode"

1067

$opt_debug

1068

;;

1069

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

1070

opt_dry_run=:

1071

;;

1072

--config)

1073

opt_config=:

1074

func_config

1075

;;

1076

--dlopen|-dlopen)

1077

optarg="$1"

1078

opt_dlopen="${opt_dlopen+$opt_dlopen

1079

}$optarg"

1080

shift

1081

;;

1082

--preserve-dup-deps)

1083

opt_preserve_dup_deps=:

1084

;;

1085

--features)

1086

opt_features=:

1087

func_features

1088

;;

1089

--finish)

1090

opt_finish=:

1091

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

1092

;;

1093

--help)

1094

opt_help=:

1095

;;

1096

--help-all)

1097

opt_help_all=:

1098

opt_help=': help-all'

1099

;;

1100

--mode)

1101

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

1102

optarg="$1"

1103

opt_mode="$optarg"

1104

case $optarg in

1105

# Valid mode arguments:

1106

1107

1108

# Catch anything else as an error

1109

*) func_error "invalid argument for $opt"

1110

exit_cmd=exit

1111

break

1112

;;

1113

esac

1114

shift

1115

;;

1116

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

1117

opt_silent=false

1118

func_append preserve_args " $opt"

1119

;;

1120

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

1121

opt_warning=false

1122

func_append preserve_args " $opt"

1123

;;

1124

--no-verbose)

1125

opt_verbose=false

1126

func_append preserve_args " $opt"

1127

;;

1128

--silent|--quiet)

1129

opt_silent=:

1130

func_append preserve_args " $opt"

1131

opt_verbose=false

1132

;;

1133

--verbose|-v)

1134

opt_verbose=:

1135

func_append preserve_args " $opt"

1136

opt_silent=false

1137

;;

1138

--tag)

1139

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

1140

optarg="$1"

1141

opt_tag="$optarg"

1142

func_append preserve_args " $opt $optarg"

1143

func_enable_tag "$optarg"

1144

shift

1145

;;

1146

1147

-\?|-h) func_usage ;;

1148

--help) func_help ;;

1149

--version) func_version ;;

1150

1151

# Separate optargs to long options:

1152

--*=*)

1153

func_split_long_opt "$opt"

1154

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

1155

shift

1156

;;

1157

1158

# Separate non-argument short options:

1159

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

1160

func_split_short_opt "$opt"

1161

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

1162

shift

1163

;;

1164

1165

--) break ;;

1166

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

1167

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

1168

esac

1169

done

1170

1171

# Validate options:

1172

1173

# save first non-option argument

1174

if test "$#" -gt 0; then

1175

nonopt="$opt"

1176

shift

1177

fi

1178

1179

# preserve --debug

1180

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

1181

1182

case $host in

1183

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

1184

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

1185

opt_duplicate_compiler_generated_deps=:

1186

;;

1187

*)

1188

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

1189

;;

1190

esac

1191

1192

$opt_help || {

1193

# Sanity checks first:

1194

func_check_version_match

1195

1196

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

1197

func_fatal_configuration "not configured to build any kind of library"

1198

fi

1199

1200

# Darwin sucks

1201

eval std_shrext=\"$shrext_cmds\"

1202

1203

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

1204

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

1205

func_error "unrecognized option \`-dlopen'"

1206

$ECHO "$help" 1>&2

1207

exit $EXIT_FAILURE

1208

fi

1209

1210

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

1211

generic_help="$help"

1212

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

1213

}

1214

1215

1216

# Bail if the options were screwed

1217

$exit_cmd $EXIT_FAILURE

1218

}

1219

1220

1221

1222

1223

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

1224

## Main. ##

1225

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

1226

1227

# func_lalib_p file

1228

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

1229

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

1230

# determined imposters.

1231

func_lalib_p ()

1232

{

1233

test -f "$1" &&

1234

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

1235

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

1236

}

1237

1238

# func_lalib_unsafe_p file

1239

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

1240

# This function implements the same check as func_lalib_p without

1241

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

1242

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

1243

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

1244

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

1245

func_lalib_unsafe_p ()

1246

{

1247

lalib_p=no

1248

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

1249

for lalib_p_l in 1 2 3 4

1250

do

1251

read lalib_p_line

1252

case "$lalib_p_line" in

1253

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

1254

esac

1255

done

1256

exec 0<&5 5<&-

1257

fi

1258

test "$lalib_p" = yes

1259

}

1260

1261

# func_ltwrapper_script_p file

1262

# True iff FILE is a libtool wrapper script

1263

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

1264

# determined imposters.

1265

func_ltwrapper_script_p ()

1266

{

1267

func_lalib_p "$1"

1268

}

1269

1270

# func_ltwrapper_executable_p file

1271

# True iff FILE is a libtool wrapper executable

1272

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

1273

# determined imposters.

1274

func_ltwrapper_executable_p ()

1275

{

1276

func_ltwrapper_exec_suffix=

1277

case $1 in

1278

*.exe) ;;

1279

*) func_ltwrapper_exec_suffix=.exe ;;

1280

esac

1281

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

1282

}

1283

1284

# func_ltwrapper_scriptname file

1285

# Assumes file is an ltwrapper_executable

1286

# uses $file to determine the appropriate filename for a

1287

# temporary ltwrapper_script.

1288

func_ltwrapper_scriptname ()

1289

{

1290

func_dirname_and_basename "$1" "" "."

1291

func_stripname '' '.exe' "$func_basename_result"

1292

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

1293

}

1294

1295

# func_ltwrapper_p file

1296

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

1297

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

1298

# determined imposters.

1299

func_ltwrapper_p ()

1300

{

1301

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

1302

}

1303

1304

1305

# func_execute_cmds commands fail_cmd

1306

# Execute tilde-delimited COMMANDS.

1307

# If FAIL_CMD is given, eval that upon failure.

1308

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

1309

func_execute_cmds ()

1310

{

1311

$opt_debug

1312

save_ifs=$IFS; IFS='~'

1313

for cmd in $1; do

1314

IFS=$save_ifs

1315

eval cmd=\"$cmd\"

1316

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

1317

done

1318

IFS=$save_ifs

1319

}

1320

1321

1322

# func_source file

1323

# Source FILE, adding directory component if necessary.

1324

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

1325

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

1326

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

1327

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

1328

func_source ()

1329

{

1330

$opt_debug

1331

case $1 in

1332

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

1333

*) . "./$1" ;;

1334

esac

1335

}

1336

1337

1338

# func_resolve_sysroot PATH

1339

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

1340

# func_resolve_sysroot_result

1341

func_resolve_sysroot ()

1342

{

1343

func_resolve_sysroot_result=$1

1344

case $func_resolve_sysroot_result in

1345

=*)

1346

func_stripname '=' '' "$func_resolve_sysroot_result"

1347

func_resolve_sysroot_result=$lt_sysroot$func_stripname_result

1348

;;

1349

esac

1350

}

1351

1352

# func_replace_sysroot PATH

1353

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

1354

# store the result into func_replace_sysroot_result.

1355

func_replace_sysroot ()

1356

{

1357

case "$lt_sysroot:$1" in

1358

?*:"$lt_sysroot"*)

1359

func_stripname "$lt_sysroot" '' "$1"

1360

func_replace_sysroot_result="=$func_stripname_result"

1361

;;

1362

*)

1363

# Including no sysroot.

1364

func_replace_sysroot_result=$1

1365

;;

1366

esac

1367

}

1368

1369

# func_infer_tag arg

1370

# Infer tagged configuration to use if any are available and

1371

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

1372

# Only attempt this if the compiler in the base compile

1373

# command doesn't match the default compiler.

1374

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

1375

func_infer_tag ()

1376

{

1377

$opt_debug

1378

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

1379

CC_quoted=

1380

for arg in $CC; do

1381

func_append_quoted CC_quoted "$arg"

1382

done

1383

CC_expanded=`func_echo_all $CC`

1384

CC_quoted_expanded=`func_echo_all $CC_quoted`

1385

case $@ in

1386

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

1387

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

1388

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

1389

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

1390

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

1391

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

1392

*)

1393

for z in $available_tags; do

1394

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

1395

# Evaluate the configuration.

1396

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

1397

CC_quoted=

1398

for arg in $CC; do

1399

# Double-quote args containing other shell metacharacters.

1400

func_append_quoted CC_quoted "$arg"

1401

done

1402

CC_expanded=`func_echo_all $CC`

1403

CC_quoted_expanded=`func_echo_all $CC_quoted`

1404

case "$@ " in

1405

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

1406

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

1407

# The compiler in the base compile command matches

1408

# the one in the tagged configuration.

1409

# Assume this is the tagged configuration we want.

1410

tagname=$z

1411

break

1412

;;

1413

esac

1414

fi

1415

done

1416

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

1417

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

1418

# line option must be used.

1419

if test -z "$tagname"; then

1420

func_echo "unable to infer tagged configuration"

1421

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

1422

# else

1423

# func_verbose "using $tagname tagged configuration"

1424

fi

1425

;;

1426

esac

1427

fi

1428

}

1429

1430

1431

1432

# func_write_libtool_object output_name pic_name nonpic_name

1433

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

1434

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

1435

func_write_libtool_object ()

1436

{

1437

write_libobj=${1}

1438

if test "$build_libtool_libs" = yes; then

1439

write_lobj=\'${2}\'

1440

else

1441

write_lobj=none

1442

fi

1443

1444

if test "$build_old_libs" = yes; then

1445

write_oldobj=\'${3}\'

1446

else

1447

write_oldobj=none

1448

fi

1449

1450

$opt_dry_run || {

1451

cat >${write_libobj}T <<EOF

1452

# $write_libobj - a libtool object file

1453

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

1454

#

1455

# Please DO NOT delete this file!

1456

# It is necessary for linking the library.

1457

1458

# Name of the PIC object.

1459

pic_object=$write_lobj

1460

1461

# Name of the non-PIC object

1462

non_pic_object=$write_oldobj

1463

1464

EOF

1465

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

1466

}

1467

}

1468

1469

1470

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

1471

# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #

1472

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

1473

1474

# func_convert_core_file_wine_to_w32 ARG

1475

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

1476

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

1477

# correctly configured wine environment available, with the winepath program

1478

# in $build's $PATH.

1479

#

1480

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

1481

# Result is available in $func_convert_core_file_wine_to_w32_result, and will

1482

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

1483

func_convert_core_file_wine_to_w32 ()

1484

{

1485

$opt_debug

1486

func_convert_core_file_wine_to_w32_result="$1"

1487

if test -n "$1"; then

1488

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

1489

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

1490

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

1491

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

1492

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

1493

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

1494

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

1495

func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |

1496

$SED -e "$lt_sed_naive_backslashify"`

1497

else

1498

func_convert_core_file_wine_to_w32_result=

1499

fi

1500

fi

1501

}

1502

# end: func_convert_core_file_wine_to_w32

1503

1504

1505

# func_convert_core_path_wine_to_w32 ARG

1506

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

1507

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

1508

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

1509

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

1510

#

1511

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

1512

# Result is available in $func_convert_core_path_wine_to_w32_result.

1513

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

1514

# are convertible, then the result may be empty.

1515

func_convert_core_path_wine_to_w32 ()

1516

{

1517

$opt_debug

1518

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

1519

func_convert_core_path_wine_to_w32_result=""

1520

if test -n "$1"; then

1521

oldIFS=$IFS

1522

IFS=:

1523

for func_convert_core_path_wine_to_w32_f in $1; do

1524

IFS=$oldIFS

1525

func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"

1526

if test -n "$func_convert_core_file_wine_to_w32_result" ; then

1527

if test -z "$func_convert_core_path_wine_to_w32_result"; then

1528

func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"

1529

else

1530

func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"

1531

fi

1532

fi

1533

done

1534

IFS=$oldIFS

1535

fi

1536

}

1537

# end: func_convert_core_path_wine_to_w32

1538

1539

1540

# func_cygpath ARGS...

1541

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

1542

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

1543

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

1544

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

1545

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

1546

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

1547

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

1548

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

1549

#

1550

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

1551

# be converted.

1552

#

1553

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

1554

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

1555

func_cygpath ()

1556

{

1557

$opt_debug

1558

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

1559

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

1560

if test "$?" -ne 0; then

1561

# on failure, ensure result is empty

1562

func_cygpath_result=

1563

fi

1564

else

1565

func_cygpath_result=

1566

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

1567

fi

1568

}

1569

#end: func_cygpath

1570

1571

1572

# func_convert_core_msys_to_w32 ARG

1573

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

1574

# result in func_convert_core_msys_to_w32_result.

1575

func_convert_core_msys_to_w32 ()

1576

{

1577

$opt_debug

1578

# awkward: cmd appends spaces to result

1579

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

1580

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

1581

}

1582

#end: func_convert_core_msys_to_w32

1583

1584

1585

# func_convert_file_check ARG1 ARG2

1586

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

1587

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

1588

# func_to_host_file_result to ARG1).

1589

func_convert_file_check ()

1590

{

1591

$opt_debug

1592

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

1593

func_error "Could not determine host file name corresponding to"

1594

func_error " \`$1'"

1595

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

1596

# Fallback:

1597

func_to_host_file_result="$1"

1598

fi

1599

}

1600

# end func_convert_file_check

1601

1602

1603

# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH

1604

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

1605

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

1606

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

1607

func_convert_path_check ()

1608

{

1609

$opt_debug

1610

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

1611

func_error "Could not determine the host path corresponding to"

1612

func_error " \`$3'"

1613

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

1614

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

1615

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

1616

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

1617

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

1618

func_to_host_path_result=`echo "$3" |

1619

$SED -e "$lt_replace_pathsep_chars"`

1620

else

1621

func_to_host_path_result="$3"

1622

fi

1623

fi

1624

}

1625

# end func_convert_path_check

1626

1627

1628

# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG

1629

# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT

1630

# and appending REPL if ORIG matches BACKPAT.

1631

func_convert_path_front_back_pathsep ()

1632

{

1633

$opt_debug

1634

case $4 in

1635

$1 ) func_to_host_path_result="$3$func_to_host_path_result"

1636

;;

1637

esac

1638

case $4 in

1639

$2 ) func_append func_to_host_path_result "$3"

1640

;;

1641

esac

1642

}

1643

# end func_convert_path_front_back_pathsep

1644

1645

1646

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

1647

# $build to $host FILE NAME CONVERSION FUNCTIONS #

1648

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

1649

# invoked via `$to_host_file_cmd ARG'

1650

#

1651

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

1652

# Result will be available in $func_to_host_file_result.

1653

1654

1655

# func_to_host_file ARG

1656

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

1657

# in func_to_host_file_result.

1658

func_to_host_file ()

1659

{

1660

$opt_debug

1661

$to_host_file_cmd "$1"

1662

}

1663

# end func_to_host_file

1664

1665

1666

# func_to_tool_file ARG LAZY

1667

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

1668

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

1669

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

1670

func_to_tool_file ()

1671

{

1672

$opt_debug

1673

case ,$2, in

1674

*,"$to_tool_file_cmd",*)

1675

func_to_tool_file_result=$1

1676

;;

1677

*)

1678

$to_tool_file_cmd "$1"

1679

func_to_tool_file_result=$func_to_host_file_result

1680

;;

1681

esac

1682

}

1683

# end func_to_tool_file

1684

1685

1686

# func_convert_file_noop ARG

1687

# Copy ARG to func_to_host_file_result.

1688

func_convert_file_noop ()

1689

{

1690

func_to_host_file_result="$1"

1691

}

1692

# end func_convert_file_noop

1693

1694

1695

# func_convert_file_msys_to_w32 ARG

1696

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

1697

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

1698

# func_to_host_file_result.

1699

func_convert_file_msys_to_w32 ()

1700

{

1701

$opt_debug

1702

func_to_host_file_result="$1"

1703

if test -n "$1"; then

1704

func_convert_core_msys_to_w32 "$1"

1705

func_to_host_file_result="$func_convert_core_msys_to_w32_result"

1706

fi

1707

func_convert_file_check "$1" "$func_to_host_file_result"

1708

}

1709

# end func_convert_file_msys_to_w32

1710

1711

1712

# func_convert_file_cygwin_to_w32 ARG

1713

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

1714

# func_to_host_file_result.

1715

func_convert_file_cygwin_to_w32 ()

1716

{

1717

$opt_debug

1718

func_to_host_file_result="$1"

1719

if test -n "$1"; then

1720

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

1721

# LT_CYGPATH in this case.

1722

func_to_host_file_result=`cygpath -m "$1"`

1723

fi

1724

func_convert_file_check "$1" "$func_to_host_file_result"

1725

}

1726

# end func_convert_file_cygwin_to_w32

1727

1728

1729

# func_convert_file_nix_to_w32 ARG

1730

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

1731

# and a working winepath. Returns result in func_to_host_file_result.

1732

func_convert_file_nix_to_w32 ()

1733

{

1734

$opt_debug

1735

func_to_host_file_result="$1"

1736

if test -n "$1"; then

1737

func_convert_core_file_wine_to_w32 "$1"

1738

func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

1739

fi

1740

func_convert_file_check "$1" "$func_to_host_file_result"

1741

}

1742

# end func_convert_file_nix_to_w32

1743

1744

1745

# func_convert_file_msys_to_cygwin ARG

1746

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

1747

# Returns result in func_to_host_file_result.

1748

func_convert_file_msys_to_cygwin ()

1749

{

1750

$opt_debug

1751

func_to_host_file_result="$1"

1752

if test -n "$1"; then

1753

func_convert_core_msys_to_w32 "$1"

1754

func_cygpath -u "$func_convert_core_msys_to_w32_result"

1755

func_to_host_file_result="$func_cygpath_result"

1756

fi

1757

func_convert_file_check "$1" "$func_to_host_file_result"

1758

}

1759

# end func_convert_file_msys_to_cygwin

1760

1761

1762

# func_convert_file_nix_to_cygwin ARG

1763

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

1764

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

1765

# in func_to_host_file_result.

1766

func_convert_file_nix_to_cygwin ()

1767

{

1768

$opt_debug

1769

func_to_host_file_result="$1"

1770

if test -n "$1"; then

1771

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

1772

func_convert_core_file_wine_to_w32 "$1"

1773

func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

1774

func_to_host_file_result="$func_cygpath_result"

1775

fi

1776

func_convert_file_check "$1" "$func_to_host_file_result"

1777

}

1778

# end func_convert_file_nix_to_cygwin

1779

1780

1781

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

1782

# $build to $host PATH CONVERSION FUNCTIONS #

1783

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

1784

# invoked via `$to_host_path_cmd ARG'

1785

#

1786

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

1787

# The result will be available in $func_to_host_path_result.

1788

#

1789

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

1790

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

1791

# converted to $host format) on output.

1792

#

1793

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

1794

# file name conversion function : func_convert_file_X_to_Y ()

1795

# path conversion function : func_convert_path_X_to_Y ()

1796

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

1797

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

1798

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

1799

# will break.

1800

1801

1802

# func_init_to_host_path_cmd

1803

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

1804

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

1805

to_host_path_cmd=

1806

func_init_to_host_path_cmd ()

1807

{

1808

$opt_debug

1809

if test -z "$to_host_path_cmd"; then

1810

func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

1811

to_host_path_cmd="func_convert_path_${func_stripname_result}"

1812

fi

1813

}

1814

1815

1816

# func_to_host_path ARG

1817

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

1818

# in func_to_host_path_result.

1819

func_to_host_path ()

1820

{

1821

$opt_debug

1822

func_init_to_host_path_cmd

1823

$to_host_path_cmd "$1"

1824

}

1825

# end func_to_host_path

1826

1827

1828

# func_convert_path_noop ARG

1829

# Copy ARG to func_to_host_path_result.

1830

func_convert_path_noop ()

1831

{

1832

func_to_host_path_result="$1"

1833

}

1834

# end func_convert_path_noop

1835

1836

1837

# func_convert_path_msys_to_w32 ARG

1838

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

1839

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

1840

# func_to_host_path_result.

1841

func_convert_path_msys_to_w32 ()

1842

{

1843

$opt_debug

1844

func_to_host_path_result="$1"

1845

if test -n "$1"; then

1846

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

1847

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

1848

# and winepath ignores them completely.

1849

func_stripname : : "$1"

1850

func_to_host_path_tmp1=$func_stripname_result

1851

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1852

func_to_host_path_result="$func_convert_core_msys_to_w32_result"

1853

func_convert_path_check : ";" \

1854

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1855

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

1856

fi

1857

}

1858

# end func_convert_path_msys_to_w32

1859

1860

1861

# func_convert_path_cygwin_to_w32 ARG

1862

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

1863

# func_to_host_file_result.

1864

func_convert_path_cygwin_to_w32 ()

1865

{

1866

$opt_debug

1867

func_to_host_path_result="$1"

1868

if test -n "$1"; then

1869

# See func_convert_path_msys_to_w32:

1870

func_stripname : : "$1"

1871

func_to_host_path_tmp1=$func_stripname_result

1872

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

1873

func_convert_path_check : ";" \

1874

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1875

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

1876

fi

1877

}

1878

# end func_convert_path_cygwin_to_w32

1879

1880

1881

# func_convert_path_nix_to_w32 ARG

1882

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

1883

# a working winepath. Returns result in func_to_host_file_result.

1884

func_convert_path_nix_to_w32 ()

1885

{

1886

$opt_debug

1887

func_to_host_path_result="$1"

1888

if test -n "$1"; then

1889

# See func_convert_path_msys_to_w32:

1890

func_stripname : : "$1"

1891

func_to_host_path_tmp1=$func_stripname_result

1892

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1893

func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

1894

func_convert_path_check : ";" \

1895

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1896

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

1897

fi

1898

}

1899

# end func_convert_path_nix_to_w32

1900

1901

1902

# func_convert_path_msys_to_cygwin ARG

1903

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

1904

# Returns result in func_to_host_file_result.

1905

func_convert_path_msys_to_cygwin ()

1906

{

1907

$opt_debug

1908

func_to_host_path_result="$1"

1909

if test -n "$1"; then

1910

# See func_convert_path_msys_to_w32:

1911

func_stripname : : "$1"

1912

func_to_host_path_tmp1=$func_stripname_result

1913

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1914

func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

1915

func_to_host_path_result="$func_cygpath_result"

1916

func_convert_path_check : : \

1917

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1918

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

1919

fi

1920

}

1921

# end func_convert_path_msys_to_cygwin

1922

1923

1924

# func_convert_path_nix_to_cygwin ARG

1925

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

1926

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

1927

# func_to_host_file_result.

1928

func_convert_path_nix_to_cygwin ()

1929

{

1930

$opt_debug

1931

func_to_host_path_result="$1"

1932

if test -n "$1"; then

1933

# Remove leading and trailing path separator characters from

1934

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

1935

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

1936

func_stripname : : "$1"

1937

func_to_host_path_tmp1=$func_stripname_result

1938

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1939

func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

1940

func_to_host_path_result="$func_cygpath_result"

1941

func_convert_path_check : : \

1942

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1943

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

1944

fi

1945

}

1946

# end func_convert_path_nix_to_cygwin

1947

1948

1949

# func_mode_compile arg...

1950

func_mode_compile ()

1951

{

1952

$opt_debug

1953

# Get the compilation command and the source file.

1954

base_compile=

1955

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

1956

suppress_opt=yes

1957

suppress_output=

1958

arg_mode=normal

1959

libobj=

1960

later=

1961

pie_flag=

1962

1963

for arg

1964

do

1965

case $arg_mode in

1966

arg )

1967

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

1968

lastarg="$arg"

1969

arg_mode=normal

1970

;;

1971

1972

target )

1973

libobj="$arg"

1974

arg_mode=normal

1975

continue

1976

;;

1977

1978

normal )

1979

# Accept any command-line options.

1980

case $arg in

1981

-o)

1982

test -n "$libobj" && \

1983

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

1984

arg_mode=target

1985

continue

1986

;;

1987

1988

-pie | -fpie | -fPIE)

1989

func_append pie_flag " $arg"

1990

continue

1991

;;

1992

1993

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

1994

func_append later " $arg"

1995

continue

1996

;;

1997

1998

-no-suppress)

1999

suppress_opt=no

2000

continue

2001

;;

2002

2003

-Xcompiler)

2004

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

2005

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

2006

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

2007

2008

-Wc,*)

2009

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

2010

args=$func_stripname_result

2011

lastarg=

2012

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

2013

for arg in $args; do

2014

IFS="$save_ifs"

2015

func_append_quoted lastarg "$arg"

2016

done

2017

IFS="$save_ifs"

2018

func_stripname ' ' '' "$lastarg"

2019

lastarg=$func_stripname_result

2020

2021

# Add the arguments to base_compile.

2022

func_append base_compile " $lastarg"

2023

continue

2024

;;

2025

2026

*)

2027

# Accept the current argument as the source file.

2028

# The previous "srcfile" becomes the current argument.

2029

#

2030

lastarg="$srcfile"

2031

srcfile="$arg"

2032

;;

2033

esac # case $arg

2034

;;

2035

esac # case $arg_mode

2036

2037

# Aesthetically quote the previous argument.

2038

func_append_quoted base_compile "$lastarg"

2039

done # for arg

2040

2041

case $arg_mode in

2042

arg)

2043

func_fatal_error "you must specify an argument for -Xcompile"

2044

;;

2045

target)

2046

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

2047

;;

2048

*)

2049

# Get the name of the library object.

2050

test -z "$libobj" && {

2051

func_basename "$srcfile"

2052

libobj="$func_basename_result"

2053

}

2054

;;

2055

esac

2056

2057

# Recognize several different file suffixes.

2058

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

2059

case $libobj in

2060

*.[cCFSifmso] | \

2061

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

2062

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

2063

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

2064

func_xform "$libobj"

2065

libobj=$func_xform_result

2066

;;

2067

esac

2068

2069

case $libobj in

2070

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

2071

*)

2072

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

2073

;;

2074

esac

2075

2076

func_infer_tag $base_compile

2077

2078

for arg in $later; do

2079

case $arg in

2080

-shared)

2081

test "$build_libtool_libs" != yes && \

2082

func_fatal_configuration "can not build a shared library"

2083

build_old_libs=no

2084

continue

2085

;;

2086

2087

-static)

2088

build_libtool_libs=no

2089

build_old_libs=yes

2090

continue

2091

;;

2092

2093

-prefer-pic)

2094

pic_mode=yes

2095

continue

2096

;;

2097

2098

-prefer-non-pic)

2099

pic_mode=no

2100

continue

2101

;;

2102

esac

2103

done

2104

2105

func_quote_for_eval "$libobj"

2106

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

2107

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

2108

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

2109

func_dirname_and_basename "$obj" "/" ""

2110

objname="$func_basename_result"

2111

xdir="$func_dirname_result"

2112

lobj=${xdir}$objdir/$objname

2113

2114

test -z "$base_compile" && \

2115

func_fatal_help "you must specify a compilation command"

2116

2117

# Delete any leftover library objects.

2118

if test "$build_old_libs" = yes; then

2119

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

2120

else

2121

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

2122

fi

2123

2124

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

2125

case $host_os in

2126

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

2127

pic_mode=default

2128

;;

2129

esac

2130

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

2131

# non-PIC code in shared libraries is not supported

2132

pic_mode=default

2133

fi

2134

2135

# Calculate the filename of the output object if compiler does

2136

# not support -o with -c

2137

if test "$compiler_c_o" = no; then

2138

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

2139

lockfile="$output_obj.lock"

2140

else

2141

output_obj=

2142

need_locks=no

2143

lockfile=

2144

fi

2145

2146

# Lock this critical section if it is needed

2147

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

2148

if test "$need_locks" = yes; then

2149

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

2150

func_echo "Waiting for $lockfile to be removed"

2151

sleep 2

2152

done

2153

elif test "$need_locks" = warn; then

2154

if test -f "$lockfile"; then

2155

$ECHO "\

2156

*** ERROR, $lockfile exists and contains:

2157

`cat $lockfile 2>/dev/null`

2158

2159

This indicates that another process is trying to use the same

2160

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

2161

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

2162

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

2163

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

2164

compiler."

2165

2166

$opt_dry_run || $RM $removelist

2167

exit $EXIT_FAILURE

2168

fi

2169

func_append removelist " $output_obj"

2170

$ECHO "$srcfile" > "$lockfile"

2171

fi

2172

2173

$opt_dry_run || $RM $removelist

2174

func_append removelist " $lockfile"

2175

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

2176

2177

func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2178

srcfile=$func_to_tool_file_result

2179

func_quote_for_eval "$srcfile"

2180

qsrcfile=$func_quote_for_eval_result

2181

2182

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

2183

if test "$build_libtool_libs" = yes; then

2184

# Without this assignment, base_compile gets emptied.

2185

fbsd_hideous_sh_bug=$base_compile

2186

2187

if test "$pic_mode" != no; then

2188

command="$base_compile $qsrcfile $pic_flag"

2189

else

2190

# Don't build PIC code

2191

command="$base_compile $qsrcfile"

2192

fi

2193

2194

func_mkdir_p "$xdir$objdir"

2195

2196

if test -z "$output_obj"; then

2197

# Place PIC objects in $objdir

2198

func_append command " -o $lobj"

2199

fi

2200

2201

func_show_eval_locale "$command" \

2202

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

2203

2204

if test "$need_locks" = warn &&

2205

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

2206

$ECHO "\

2207

*** ERROR, $lockfile contains:

2208

`cat $lockfile 2>/dev/null`

2209

2210

but it should contain:

2211

$srcfile

2212

2213

This indicates that another process is trying to use the same

2214

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

2215

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

2216

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

2217

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

2218

compiler."

2219

2220

$opt_dry_run || $RM $removelist

2221

exit $EXIT_FAILURE

2222

fi

2223

2224

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

2225

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

2226

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

2227

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

2228

fi

2229

2230

# Allow error messages only from the first compilation.

2231

if test "$suppress_opt" = yes; then

2232

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

2233

fi

2234

fi

2235

2236

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

2237

if test "$build_old_libs" = yes; then

2238

if test "$pic_mode" != yes; then

2239

# Don't build PIC code

2240

command="$base_compile $qsrcfile$pie_flag"

2241

else

2242

command="$base_compile $qsrcfile $pic_flag"

2243

fi

2244

if test "$compiler_c_o" = yes; then

2245

func_append command " -o $obj"

2246

fi

2247

2248

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

2249

func_append command "$suppress_output"

2250

func_show_eval_locale "$command" \

2251

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

2252

2253

if test "$need_locks" = warn &&

2254

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

2255

$ECHO "\

2256

*** ERROR, $lockfile contains:

2257

`cat $lockfile 2>/dev/null`

2258

2259

but it should contain:

2260

$srcfile

2261

2262

This indicates that another process is trying to use the same

2263

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

2264

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

2265

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

2266

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

2267

compiler."

2268

2269

$opt_dry_run || $RM $removelist

2270

exit $EXIT_FAILURE

2271

fi

2272

2273

# Just move the object if needed

2274

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

2275

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

2276

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

2277

fi

2278

fi

2279

2280

$opt_dry_run || {

2281

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

2282

2283

# Unlock the critical section if it was locked

2284

if test "$need_locks" != no; then

2285

removelist=$lockfile

2286

$RM "$lockfile"

2287

fi

2288

}

2289

2290

exit $EXIT_SUCCESS

2291

}

2292

2293

$opt_help || {

2294

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

2295

}

2296

2297

func_mode_help ()

2298

{

2299

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

2300

case $opt_mode in

2301

"")

2302

# Generic help is extracted from the usage comments

2303

# at the start of this file.

2304

func_help

2305

;;

2306

2307

clean)

2308

$ECHO \

2309

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

2310

2311

Remove files from the build directory.

2312

2313

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

2314

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

2315

to RM.

2316

2317

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

2318

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

2319

;;

2320

2321

compile)

2322

$ECHO \

2323

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

2324

2325

Compile a source file into a libtool library object.

2326

2327

This mode accepts the following additional options:

2328

2329

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

2330

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

2331

-prefer-pic try to build PIC objects only

2332

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

2333

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

2334

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

2335

-Wc,FLAG pass FLAG directly to the compiler

2336

2337

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

2338

from the given SOURCEFILE.

2339

2340

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

2341

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

2342

library object suffix, \`.lo'."

2343

;;

2344

2345

execute)

2346

$ECHO \

2347

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

2348

2349

Automatically set library path, then run a program.

2350

2351

This mode accepts the following additional options:

2352

2353

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

2354

2355

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

2356

flags.

2357

2358

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

2359

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

2360

directories are added to the library path.

2361

2362

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

2363

;;

2364

2365

finish)

2366

$ECHO \

2367

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

2368

2369

Complete the installation of libtool libraries.

2370

2371

Each LIBDIR is a directory that contains libtool libraries.

2372

2373

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

2374

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

2375

;;

2376

2377

install)

2378

$ECHO \

2379

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

2380

2381

Install executables or libraries.

2382

2383

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

2384

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

2385

2386

The following components of INSTALL-COMMAND are treated specially:

2387

2388

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

2389

2390

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

2391

BSD-compatible install options are recognized)."

2392

;;

2393

2394

link)

2395

$ECHO \

2396

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

2397

2398

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

2399

create an executable program.

2400

2401

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

2402

a program from several object files.

2403

2404

The following components of LINK-COMMAND are treated specially:

2405

2406

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

2407

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

2408

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

2409

libraries must be found in the PATH setting at runtime)

2410

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

2411

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

2412

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

2413

-export-symbols SYMFILE

2414

try to export only the symbols listed in SYMFILE

2415

-export-symbols-regex REGEX

2416

try to export only the symbols matching REGEX

2417

-LLIBDIR search LIBDIR for required installed libraries

2418

-lNAME OUTPUT-FILE requires the installed library libNAME

2419

-module build a library that can dlopened

2420

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

2421

-no-install link a not-installable executable

2422

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

2423

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

2424

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

2425

-precious-files-regex REGEX

2426

don't remove output files matching REGEX

2427

-release RELEASE specify package release information

2428

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

2429

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

2430

-shared only do dynamic linking of libtool libraries

2431

-shrext SUFFIX override the standard shared library file extension

2432

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

2433

-static-libtool-libs

2434

do not do any dynamic linking of libtool libraries

2435

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

2436

specify library version info [each variable defaults to 0]

2437

-weak LIBNAME declare that the target provides the LIBNAME interface

2438

-Wc,FLAG

2439

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

2440

-Wl,FLAG

2441

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

2442

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

2443

2444

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

2445

2446

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

2447

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

2448

object files.

2449

2450

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

2451

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

2452

required, except when creating a convenience library.

2453

2454

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

2455

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

2456

2457

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

2458

is created, otherwise an executable program is created."

2459

;;

2460

2461

uninstall)

2462

$ECHO \

2463

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

2464

2465

Remove libraries from an installation directory.

2466

2467

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

2468

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

2469

to RM.

2470

2471

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

2472

Otherwise, only FILE itself is deleted using RM."

2473

;;

2474

2475

*)

2476

func_fatal_help "invalid operation mode \`$opt_mode'"

2477

;;

2478

esac

2479

2480

echo

2481

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

2482

}

2483

2484

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

2485

if $opt_help; then

2486

if test "$opt_help" = :; then

2487

func_mode_help

2488

else

2489

{

2490

func_help noexit

2491

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

2492

func_mode_help

2493

done

2494

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

2495

{

2496

func_help noexit

2497

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

2498

echo

2499

func_mode_help

2500

done

2501

} |

2502

sed '1d

2503

/^When reporting/,/^Report/{

2504

H

2505

d

2506

}

2507

$x

2508

/information about other modes/d

2509

/more detailed .*MODE/d

2510

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

2511

fi

2512

exit $?

2513

fi

2514

2515

2516

# func_mode_execute arg...

2517

func_mode_execute ()

2518

{

2519

$opt_debug

2520

# The first argument is the command name.

2521

cmd="$nonopt"

2522

test -z "$cmd" && \

2523

func_fatal_help "you must specify a COMMAND"

2524

2525

# Handle -dlopen flags immediately.

2526

for file in $opt_dlopen; do

2527

test -f "$file" \

2528

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

2529

2530

dir=

2531

case $file in

2532

*.la)

2533

func_resolve_sysroot "$file"

2534

file=$func_resolve_sysroot_result

2535

2536

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

2537

func_lalib_unsafe_p "$file" \

2538

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

2539

2540

# Read the libtool library.

2541

dlname=

2542

library_names=

2543

func_source "$file"

2544

2545

# Skip this library if it cannot be dlopened.

2546

if test -z "$dlname"; then

2547

# Warn if it was a shared library.

2548

test -n "$library_names" && \

2549

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

2550

continue

2551

fi

2552

2553

func_dirname "$file" "" "."

2554

dir="$func_dirname_result"

2555

2556

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

2557

func_append dir "/$objdir"

2558

else

2559

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

2560

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

2561

fi

2562

fi

2563

;;

2564

2565

*.lo)

2566

# Just add the directory containing the .lo file.

2567

func_dirname "$file" "" "."

2568

dir="$func_dirname_result"

2569

;;

2570

2571

*)

2572

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

2573

continue

2574

;;

2575

esac

2576

2577

# Get the absolute pathname.

2578

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

2579

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

2580

2581

# Now add the directory to shlibpath_var.

2582

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

2583

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

2584

else

2585

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

2586

fi

2587

done

2588

2589

# This variable tells wrapper scripts just to set shlibpath_var

2590

# rather than running their programs.

2591

libtool_execute_magic="$magic"

2592

2593

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

2594

args=

2595

for file

2596

do

2597

case $file in

2598

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

2599

*)

2600

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

2601

if func_ltwrapper_script_p "$file"; then

2602

func_source "$file"

2603

# Transform arg to wrapped name.

2604

file="$progdir/$program"

2605

elif func_ltwrapper_executable_p "$file"; then

2606

func_ltwrapper_scriptname "$file"

2607

func_source "$func_ltwrapper_scriptname_result"

2608

# Transform arg to wrapped name.

2609

file="$progdir/$program"

2610

fi

2611

;;

2612

esac

2613

# Quote arguments (to preserve shell metacharacters).

2614

func_append_quoted args "$file"

2615

done

2616

2617

if test "X$opt_dry_run" = Xfalse; then

2618

if test -n "$shlibpath_var"; then

2619

# Export the shlibpath_var.

2620

eval "export $shlibpath_var"

2621

fi

2622

2623

# Restore saved environment variables

2624

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

2625

do

2626

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

2627

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

2628

else

2629

$lt_unset $lt_var

2630

fi"

2631

done

2632

2633

# Now prepare to actually exec the command.

2634

exec_cmd="\$cmd$args"

2635

else

2636

# Display what would be done.

2637

if test -n "$shlibpath_var"; then

2638

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

2639

echo "export $shlibpath_var"

2640

fi

2641

$ECHO "$cmd$args"

2642

exit $EXIT_SUCCESS

2643

fi

2644

}

2645

2646

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

2647

2648

2649

# func_mode_finish arg...

2650

func_mode_finish ()

2651

{

2652

$opt_debug

2653

libs=

2654

libdirs=

2655

admincmds=

2656

2657

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

2658

do

2659

if test -d "$opt"; then

2660

func_append libdirs " $opt"

2661

2662

elif test -f "$opt"; then

2663

if func_lalib_unsafe_p "$opt"; then

2664

func_append libs " $opt"

2665

else

2666

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

2667

fi

2668

2669

else

2670

func_fatal_error "invalid argument \`$opt'"

2671

fi

2672

done

2673

2674

if test -n "$libs"; then

2675

if test -n "$lt_sysroot"; then

2676

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

2677

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

2678

else

2679

sysroot_cmd=

2680

fi

2681

2682

# Remove sysroot references

2683

if $opt_dry_run; then

2684

for lib in $libs; do

2685

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

2686

done

2687

else

2688

tmpdir=`func_mktempdir`

2689

for lib in $libs; do

2690

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

2691

> $tmpdir/tmp-la

2692

mv -f $tmpdir/tmp-la $lib

2693

done

2694

${RM}r "$tmpdir"

2695

fi

2696

fi

2697

2698

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

2699

for libdir in $libdirs; do

2700

if test -n "$finish_cmds"; then

2701

# Do each command in the finish commands.

2702

func_execute_cmds "$finish_cmds" 'admincmds="$admincmds

2703

'"$cmd"'"'

2704

fi

2705

if test -n "$finish_eval"; then

2706

# Do the single finish_eval.

2707

eval cmds=\"$finish_eval\"

2708

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

2709

$cmds"

2710

fi

2711

done

2712

fi

2713

2714

# Exit here if they wanted silent mode.

2715

$opt_silent && exit $EXIT_SUCCESS

2716

2717

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

2718

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

2719

echo "Libraries have been installed in:"

2720

for libdir in $libdirs; do

2721

$ECHO " $libdir"

2722

done

2723

echo

2724

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

2725

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

2726

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

2727

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

2728

if test -n "$shlibpath_var"; then

2729

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

2730

echo " during execution"

2731

fi

2732

if test -n "$runpath_var"; then

2733

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

2734

echo " during linking"

2735

fi

2736

if test -n "$hardcode_libdir_flag_spec"; then

2737

libdir=LIBDIR

2738

eval flag=\"$hardcode_libdir_flag_spec\"

2739

2740

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

2741

fi

2742

if test -n "$admincmds"; then

2743

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

2744

fi

2745

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

2746

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

2747

fi

2748

echo

2749

2750

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

2751

case $host in

2752

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

2753

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

2754

echo "pages."

2755

;;

2756

*)

2757

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

2758

;;

2759

esac

2760

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

2761

fi

2762

exit $EXIT_SUCCESS

2763

}

2764

2765

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

2766

2767

2768

# func_mode_install arg...

2769

func_mode_install ()

2770

{

2771

$opt_debug

2772

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

2773

# install_prog (especially on Windows NT).

2774

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

2775

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

2776

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

2777

# Aesthetically quote it.

2778

func_quote_for_eval "$nonopt"

2779

install_prog="$func_quote_for_eval_result "

2780

arg=$1

2781

shift

2782

else

2783

install_prog=

2784

arg=$nonopt

2785

fi

2786

2787

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

2788

# Aesthetically quote it.

2789

func_quote_for_eval "$arg"

2790

func_append install_prog "$func_quote_for_eval_result"

2791

install_shared_prog=$install_prog

2792

case " $install_prog " in

2793

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

2794

*) install_cp=false ;;

2795

esac

2796

2797

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

2798

dest=

2799

files=

2800

opts=

2801

prev=

2802

install_type=

2803

isdir=no

2804

stripme=

2805

no_mode=:

2806

for arg

2807

do

2808

arg2=

2809

if test -n "$dest"; then

2810

func_append files " $dest"

2811

dest=$arg

2812

continue

2813

fi

2814

2815

case $arg in

2816

-d) isdir=yes ;;

2817

-f)

2818

if $install_cp; then :; else

2819

prev=$arg

2820

fi

2821

;;

2822

-g | -m | -o)

2823

prev=$arg

2824

;;

2825

-s)

2826

stripme=" -s"

2827

continue

2828

;;

2829

-*)

2830

;;

2831

*)

2832

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

2833

if test -n "$prev"; then

2834

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

2835

arg2=$install_override_mode

2836

no_mode=false

2837

fi

2838

prev=

2839

else

2840

dest=$arg

2841

continue

2842

fi

2843

;;

2844

esac

2845

2846

# Aesthetically quote the argument.

2847

func_quote_for_eval "$arg"

2848

func_append install_prog " $func_quote_for_eval_result"

2849

if test -n "$arg2"; then

2850

func_quote_for_eval "$arg2"

2851

fi

2852

func_append install_shared_prog " $func_quote_for_eval_result"

2853

done

2854

2855

test -z "$install_prog" && \

2856

func_fatal_help "you must specify an install program"

2857

2858

test -n "$prev" && \

2859

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

2860

2861

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

2862

if $install_cp; then :; else

2863

func_quote_for_eval "$install_override_mode"

2864

func_append install_shared_prog " -m $func_quote_for_eval_result"

2865

fi

2866

fi

2867

2868

if test -z "$files"; then

2869

if test -z "$dest"; then

2870

func_fatal_help "no file or destination specified"

2871

else

2872

func_fatal_help "you must specify a destination"

2873

fi

2874

fi

2875

2876

# Strip any trailing slash from the destination.

2877

func_stripname '' '/' "$dest"

2878

dest=$func_stripname_result

2879

2880

# Check to see that the destination is a directory.

2881

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

2882

if test "$isdir" = yes; then

2883

destdir="$dest"

2884

destname=

2885

else

2886

func_dirname_and_basename "$dest" "" "."

2887

destdir="$func_dirname_result"

2888

destname="$func_basename_result"

2889

2890

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

2891

set dummy $files; shift

2892

test "$#" -gt 1 && \

2893

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

2894

fi

2895

case $destdir in

2896

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

2897

*)

2898

for file in $files; do

2899

case $file in

2900

*.lo) ;;

2901

*)

2902

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

2903

;;

2904

esac

2905

done

2906

;;

2907

esac

2908

2909

# This variable tells wrapper scripts just to set variables rather

2910

# than running their programs.

2911

libtool_install_magic="$magic"

2912

2913

staticlibs=

2914

future_libdirs=

2915

current_libdirs=

2916

for file in $files; do

2917

2918

# Do each installation.

2919

case $file in

2920

*.$libext)

2921

# Do the static libraries later.

2922

func_append staticlibs " $file"

2923

;;

2924

2925

*.la)

2926

func_resolve_sysroot "$file"

2927

file=$func_resolve_sysroot_result

2928

2929

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

2930

func_lalib_unsafe_p "$file" \

2931

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

2932

2933

library_names=

2934

old_library=

2935

relink_command=

2936

func_source "$file"

2937

2938

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

2939

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

2940

case "$current_libdirs " in

2941

*" $libdir "*) ;;

2942

*) func_append current_libdirs " $libdir" ;;

2943

esac

2944

else

2945

# Note the libdir as a future libdir.

2946

case "$future_libdirs " in

2947

*" $libdir "*) ;;

2948

*) func_append future_libdirs " $libdir" ;;

2949

esac

2950

fi

2951

2952

func_dirname "$file" "/" ""

2953

dir="$func_dirname_result"

2954

func_append dir "$objdir"

2955

2956

if test -n "$relink_command"; then

2957

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

2958

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

2959

2960

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

2961

# location b/c this prevents finding dependent libraries that

2962

# are installed to the same prefix.

2963

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

2964

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

2965

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

2966

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

2967

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

2968

2969

if test -n "$inst_prefix_dir"; then

2970

# Stick the inst_prefix_dir data into the link command.

2971

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

2972

else

2973

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

2974

fi

2975

2976

func_warning "relinking \`$file'"

2977

func_show_eval "$relink_command" \

2978

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

2979

fi

2980

2981

# See the names of the shared library.

2982

set dummy $library_names; shift

2983

if test -n "$1"; then

2984

realname="$1"

2985

shift

2986

2987

srcname="$realname"

2988

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

2989

2990

# Install the shared library and build the symlinks.

2991

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

2992

'exit $?'

2993

tstripme="$stripme"

2994

case $host_os in

2995

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

2996

case $realname in

2997

*.dll.a)

2998

tstripme=""

2999

;;

3000

esac

3001

;;

3002

esac

3003

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

3004

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

3005

fi

3006

3007

if test "$#" -gt 0; then

3008

# Delete the old symlinks, and create new ones.

3009

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

3010

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

3011

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

3012

for linkname

3013

do

3014

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

3015

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

3016

done

3017

fi

3018

3019

# Do each command in the postinstall commands.

3020

lib="$destdir/$realname"

3021

func_execute_cmds "$postinstall_cmds" 'exit $?'

3022

fi

3023

3024

# Install the pseudo-library for information purposes.

3025

func_basename "$file"

3026

name="$func_basename_result"

3027

instname="$dir/$name"i

3028

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

3029

3030

# Maybe install the static library, too.

3031

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

3032

;;

3033

3034

*.lo)

3035

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

3036

3037

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

3038

if test -n "$destname"; then

3039

destfile="$destdir/$destname"

3040

else

3041

func_basename "$file"

3042

destfile="$func_basename_result"

3043

destfile="$destdir/$destfile"

3044

fi

3045

3046

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

3047

case $destfile in

3048

*.lo)

3049

func_lo2o "$destfile"

3050

staticdest=$func_lo2o_result

3051

;;

3052

*.$objext)

3053

staticdest="$destfile"

3054

destfile=

3055

;;

3056

*)

3057

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

3058

;;

3059

esac

3060

3061

# Install the libtool object if requested.

3062

test -n "$destfile" && \

3063

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

3064

3065

# Install the old object if enabled.

3066

if test "$build_old_libs" = yes; then

3067

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

3068

func_lo2o "$file"

3069

staticobj=$func_lo2o_result

3070

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

3071

fi

3072

exit $EXIT_SUCCESS

3073

;;

3074

3075

*)

3076

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

3077

if test -n "$destname"; then

3078

destfile="$destdir/$destname"

3079

else

3080

func_basename "$file"

3081

destfile="$func_basename_result"

3082

destfile="$destdir/$destfile"

3083

fi

3084

3085

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

3086

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

3087

# install

3088

stripped_ext=""

3089

case $file in

3090

*.exe)

3091

if test ! -f "$file"; then

3092

func_stripname '' '.exe' "$file"

3093

file=$func_stripname_result

3094

stripped_ext=".exe"

3095

fi

3096

;;

3097

esac

3098

3099

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

3100

case $host in

3101

*cygwin* | *mingw*)

3102

if func_ltwrapper_executable_p "$file"; then

3103

func_ltwrapper_scriptname "$file"

3104

wrapper=$func_ltwrapper_scriptname_result

3105

else

3106

func_stripname '' '.exe' "$file"

3107

wrapper=$func_stripname_result

3108

fi

3109

;;

3110

*)

3111

wrapper=$file

3112

;;

3113

esac

3114

if func_ltwrapper_script_p "$wrapper"; then

3115

notinst_deplibs=

3116

relink_command=

3117

3118

func_source "$wrapper"

3119

3120

# Check the variables that should have been set.

3121

test -z "$generated_by_libtool_version" && \

3122

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

3123

3124

finalize=yes

3125

for lib in $notinst_deplibs; do

3126

# Check to see that each library is installed.

3127

libdir=

3128

if test -f "$lib"; then

3129

func_source "$lib"

3130

fi

3131

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

3132

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

3133

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

3134

finalize=no

3135

fi

3136

done

3137

3138

relink_command=

3139

func_source "$wrapper"

3140

3141

outputname=

3142

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

3143

$opt_dry_run || {

3144

if test "$finalize" = yes; then

3145

tmpdir=`func_mktempdir`

3146

func_basename "$file$stripped_ext"

3147

file="$func_basename_result"

3148

outputname="$tmpdir/$file"

3149

# Replace the output file specification.

3150

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

3151

3152

$opt_silent || {

3153

func_quote_for_expand "$relink_command"

3154

eval "func_echo $func_quote_for_expand_result"

3155

}

3156

if eval "$relink_command"; then :

3157

else

3158

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

3159

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

3160

continue

3161

fi

3162

file="$outputname"

3163

else

3164

func_warning "cannot relink \`$file'"

3165

fi

3166

}

3167

else

3168

# Install the binary that we compiled earlier.

3169

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

3170

fi

3171

fi

3172

3173

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

3174

# one anyway

3175

case $install_prog,$host in

3176

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

3177

case $file:$destfile in

3178

*.exe:*.exe)

3179

# this is ok

3180

;;

3181

*.exe:*)

3182

destfile=$destfile.exe

3183

;;

3184

*:*.exe)

3185

func_stripname '' '.exe' "$destfile"

3186

destfile=$func_stripname_result

3187

;;

3188

esac

3189

;;

3190

esac

3191

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

3192

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

3193

${RM}r "$tmpdir"

3194

fi

3195

;;

3196

esac

3197

done

3198

3199

for file in $staticlibs; do

3200

func_basename "$file"

3201

name="$func_basename_result"

3202

3203

# Set up the ranlib parameters.

3204

oldlib="$destdir/$name"

3205

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

3206

tool_oldlib=$func_to_tool_file_result

3207

3208

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

3209

3210

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

3211

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

3212

fi

3213

3214

# Do each command in the postinstall commands.

3215

func_execute_cmds "$old_postinstall_cmds" 'exit $?'

3216

done

3217

3218

test -n "$future_libdirs" && \

3219

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

3220

3221

if test -n "$current_libdirs"; then

3222

# Maybe just do a dry run.

3223

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

3224

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

3225

else

3226

exit $EXIT_SUCCESS

3227

fi

3228

}

3229

3230

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

3231

3232

3233

# func_generate_dlsyms outputname originator pic_p

3234

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

3235

# a dlpreopen symbol table.

3236

func_generate_dlsyms ()

3237

{

3238

$opt_debug

3239

my_outputname="$1"

3240

my_originator="$2"

3241

my_pic_p="${3-no}"

3242

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

3243

my_dlsyms=

3244

3245

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

3246

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

3247

my_dlsyms="${my_outputname}S.c"

3248

else

3249

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

3250

fi

3251

fi

3252

3253

if test -n "$my_dlsyms"; then

3254

case $my_dlsyms in

3255

"") ;;

3256

*.c)

3257

# Discover the nlist of each of the dlfiles.

3258

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

3259

3260

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

3261

3262

# Parse the name list into a source file.

3263

func_verbose "creating $output_objdir/$my_dlsyms"

3264

3265

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

3266

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

3267

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

3268

3269

#ifdef __cplusplus

3270

extern \"C\" {

3271

#endif

3272

3273

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

3274

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

3275

#endif

3276

3277

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

3278

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

3279

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

3280

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

3281

# define LT_DLSYM_CONST

3282

#elif defined(__osf__)

3283

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

3284

# define LT_DLSYM_CONST

3285

#else

3286

# define LT_DLSYM_CONST const

3287

#endif

3288

3289

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

3290

"

3291

3292

if test "$dlself" = yes; then

3293

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

3294

3295

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

3296

3297

# Add our own program objects to the symbol list.

3298

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

3299

for progfile in $progfiles; do

3300

func_to_tool_file "$progfile" func_convert_file_msys_to_w32

3301

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

3302

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

3303

done

3304

3305

if test -n "$exclude_expsyms"; then

3306

$opt_dry_run || {

3307

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

3308

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

3309

}

3310

fi

3311

3312

if test -n "$export_symbols_regex"; then

3313

$opt_dry_run || {

3314

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

3315

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

3316

}

3317

fi

3318

3319

# Prepare the list of exported symbols

3320

if test -z "$export_symbols"; then

3321

export_symbols="$output_objdir/$outputname.exp"

3322

$opt_dry_run || {

3323

$RM $export_symbols

3324

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

3325

case $host in

3326

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

3327

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

3328

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

3329

;;

3330

esac

3331

}

3332

else

3333

$opt_dry_run || {

3334

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

3335

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

3336

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

3337

case $host in

3338

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

3339

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

3340

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

3341

;;

3342

esac

3343

}

3344

fi

3345

fi

3346

3347

for dlprefile in $dlprefiles; do

3348

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

3349

func_basename "$dlprefile"

3350

name="$func_basename_result"

3351

case $host in

3352

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

3353

# if an import library, we need to obtain dlname

3354

if func_win32_import_lib_p "$dlprefile"; then

3355

func_tr_sh "$dlprefile"

3356

eval "curr_lafile=\$libfile_$func_tr_sh_result"

3357

dlprefile_dlbasename=""

3358

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

3359

# Use subshell, to avoid clobbering current variable values

3360

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

3361

if test -n "$dlprefile_dlname" ; then

3362

func_basename "$dlprefile_dlname"

3363

dlprefile_dlbasename="$func_basename_result"

3364

else

3365

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

3366

$sharedlib_from_linklib_cmd "$dlprefile"

3367

dlprefile_dlbasename=$sharedlib_from_linklib_result

3368

fi

3369

fi

3370

$opt_dry_run || {

3371

if test -n "$dlprefile_dlbasename" ; then

3372

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

3373

else

3374

func_warning "Could not compute DLL name from $name"

3375

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

3376

fi

3377

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3378

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

3379

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

3380

}

3381

else # not an import lib

3382

$opt_dry_run || {

3383

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

3384

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3385

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

3386

}

3387

fi

3388

;;

3389

*)

3390

$opt_dry_run || {

3391

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

3392

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3393

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

3394

}

3395

;;

3396

esac

3397

done

3398

3399

$opt_dry_run || {

3400

# Make sure we have at least an empty file.

3401

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

3402

3403

if test -n "$exclude_expsyms"; then

3404

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

3405

$MV "$nlist"T "$nlist"

3406

fi

3407

3408

# Try sorting and uniquifying the output.

3409

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

3410

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

3411

sort -k 3

3412

else

3413

sort +2

3414

fi |

3415

uniq > "$nlist"S; then

3416

:

3417

else

3418

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

3419

fi

3420

3421

if test -f "$nlist"S; then

3422

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

3423

else

3424

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

3425

fi

3426

3427

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

3428

3429

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

3430

typedef struct {

3431

const char *name;

3432

void *address;

3433

} lt_dlsymlist;

3434

extern LT_DLSYM_CONST lt_dlsymlist

3435

lt_${my_prefix}_LTX_preloaded_symbols[];

3436

LT_DLSYM_CONST lt_dlsymlist

3437

lt_${my_prefix}_LTX_preloaded_symbols[] =

3438

{\

3439

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

3440

3441

case $need_lib_prefix in

3442

no)

3443

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

3444

;;

3445

*)

3446

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

3447

;;

3448

esac

3449

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

3450

{0, (void *) 0}

3451

};

3452

3453

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

3454

#ifdef FREEBSD_WORKAROUND

3455

static const void *lt_preloaded_setup() {

3456

return lt_${my_prefix}_LTX_preloaded_symbols;

3457

}

3458

#endif

3459

3460

#ifdef __cplusplus

3461

}

3462

#endif\

3463

"

3464

} # !$opt_dry_run

3465

3466

pic_flag_for_symtable=

3467

case "$compile_command " in

3468

*" -static "*) ;;

3469

*)

3470

case $host in

3471

# compiling the symbol table file with pic_flag works around

3472

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

3473

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

3474

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

3475

# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

3476

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

3477

pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;

3478

*-*-hpux*)

3479

pic_flag_for_symtable=" $pic_flag" ;;

3480

*)

3481

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

3482

pic_flag_for_symtable=" $pic_flag"

3483

fi

3484

;;

3485

esac

3486

;;

3487

esac

3488

symtab_cflags=

3489

for arg in $LTCFLAGS; do

3490

case $arg in

3491

-pie | -fpie | -fPIE) ;;

3492

*) func_append symtab_cflags " $arg" ;;

3493

esac

3494

done

3495

3496

# Now compile the dynamic symbol file.

3497

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

3498

3499

# Clean up the generated files.

3500

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

3501

3502

# Transform the symbol file into the correct name.

3503

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

3504

case $host in

3505

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

3506

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

3507

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

3508

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

3509

else

3510

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

3511

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

3512

fi

3513

;;

3514

*)

3515

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

3516

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

3517

;;

3518

esac

3519

;;

3520

*)

3521

func_fatal_error "unknown suffix for \`$my_dlsyms'"

3522

;;

3523

esac

3524

else

3525

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

3526

# lt_preloaded_symbols. The linker will fail if global_symbol_pipe

3527

# really was required.

3528

3529

# Nullify the symbol file.

3530

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

3531

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

3532

fi

3533

}

3534

3535

# func_win32_libid arg

3536

# return the library type of file 'arg'

3537

#

3538

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

3539

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

3540

# that is supplied when $file_magic_command is called.

3541

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

3542

func_win32_libid ()

3543

{

3544

$opt_debug

3545

win32_libid_type="unknown"

3546

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

3547

case $win32_fileres in

3548

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

3549

win32_libid_type="x86 archive import"

3550

;;

3551

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

3552

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

3553

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

3554

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

3555

func_to_tool_file "$1" func_convert_file_msys_to_w32

3556

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

3557

$SED -n -e '

3558

1,100{

3559

/ I /{

3560

s,.*,import,

3561

p

3562

q

3563

}

3564

}'`

3565

case $win32_nmres in

3566

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

3567

*) win32_libid_type="x86 archive static";;

3568

esac

3569

fi

3570

;;

3571

*DLL*)

3572

win32_libid_type="x86 DLL"

3573

;;

3574

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

3575

case $win32_fileres in

3576

*MS\ Windows\ PE\ Intel*)

3577

win32_libid_type="x86 DLL"

3578

;;

3579

esac

3580

;;

3581

esac

3582

$ECHO "$win32_libid_type"

3583

}

3584

3585

# func_cygming_dll_for_implib ARG

3586

#

3587

# Platform-specific function to extract the

3588

# name of the DLL associated with the specified

3589

# import library ARG.

3590

# Invoked by eval'ing the libtool variable

3591

# $sharedlib_from_linklib_cmd

3592

# Result is available in the variable

3593

# $sharedlib_from_linklib_result

3594

func_cygming_dll_for_implib ()

3595

{

3596

$opt_debug

3597

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

3598

}

3599

3600

# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs

3601

#

3602

# The is the core of a fallback implementation of a

3603

# platform-specific function to extract the name of the

3604

# DLL associated with the specified import library LIBNAME.

3605

#

3606

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

3607

# on the platform and compiler that created the implib.

3608

#

3609

# Echos the name of the DLL associated with the

3610

# specified import library.

3611

func_cygming_dll_for_implib_fallback_core ()

3612

{

3613

$opt_debug

3614

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

3615

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

3616

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

3617

# Place marker at beginning of archive member dllname section

3618

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

3619

p

3620

d

3621

}

3622

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

3623

# are always uninteresting

3624

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

3625

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

3626

# Ensure marker is printed

3627

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

3628

# Remove all lines with less than 43 characters

3629

/^.\{43\}/!d

3630

# From remaining lines, remove first 43 characters

3631

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

3632

$SED -n '

3633

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

3634

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

3635

H

3636

$ b para

3637

b

3638

:para

3639

x

3640

s/\n//g

3641

# Remove the marker

3642

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

3643

# Remove trailing dots and whitespace

3644

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

3645

# Print

3646

/./p' |

3647

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

3648

# contents of the appropriate section of all members of the

3649

# archive which possess that section. Heuristic: eliminate

3650

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

3651

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

3652

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

3653

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

3654

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

3655

# a '.'.

3656

#

3657

# Of those that remain, print the first one.

3658

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

3659

}

3660

3661

# func_cygming_gnu_implib_p ARG

3662

# This predicate returns with zero status (TRUE) if

3663

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

3664

# with nonzero status (FALSE) otherwise.

3665

func_cygming_gnu_implib_p ()

3666

{

3667

$opt_debug

3668

func_to_tool_file "$1" func_convert_file_msys_to_w32

3669

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)$'`

3670

test -n "$func_cygming_gnu_implib_tmp"

3671

}

3672

3673

# func_cygming_ms_implib_p ARG

3674

# This predicate returns with zero status (TRUE) if

3675

# ARG is an MS-style import library. Returns

3676

# with nonzero status (FALSE) otherwise.

3677

func_cygming_ms_implib_p ()

3678

{

3679

$opt_debug

3680

func_to_tool_file "$1" func_convert_file_msys_to_w32

3681

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

3682

test -n "$func_cygming_ms_implib_tmp"

3683

}

3684

3685

# func_cygming_dll_for_implib_fallback ARG

3686

# Platform-specific function to extract the

3687

# name of the DLL associated with the specified

3688

# import library ARG.

3689

#

3690

# This fallback implementation is for use when $DLLTOOL

3691

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

3692

# Invoked by eval'ing the libtool variable

3693

# $sharedlib_from_linklib_cmd

3694

# Result is available in the variable

3695

# $sharedlib_from_linklib_result

3696

func_cygming_dll_for_implib_fallback ()

3697

{

3698

$opt_debug

3699

if func_cygming_gnu_implib_p "$1" ; then

3700

# binutils import library

3701

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

3702

elif func_cygming_ms_implib_p "$1" ; then

3703

# ms-generated import library

3704

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

3705

else

3706

# unknown

3707

sharedlib_from_linklib_result=""

3708

fi

3709

}

3710

3711

3712

# func_extract_an_archive dir oldlib

3713

func_extract_an_archive ()

3714

{

3715

$opt_debug

3716

f_ex_an_ar_dir="$1"; shift

3717

f_ex_an_ar_oldlib="$1"

3718

if test "$lock_old_archive_extraction" = yes; then

3719

lockfile=$f_ex_an_ar_oldlib.lock

3720

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

3721

func_echo "Waiting for $lockfile to be removed"

3722

sleep 2

3723

done

3724

fi

3725

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

3726

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

3727

if test "$lock_old_archive_extraction" = yes; then

3728

$opt_dry_run || rm -f "$lockfile"

3729

fi

3730

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

3731

:

3732

else

3733

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

3734

fi

3735

}

3736

3737

3738

# func_extract_archives gentop oldlib ...

3739

func_extract_archives ()

3740

{

3741

$opt_debug

3742

my_gentop="$1"; shift

3743

my_oldlibs=${1+"$@"}

3744

my_oldobjs=""

3745

my_xlib=""

3746

my_xabs=""

3747

my_xdir=""

3748

3749

for my_xlib in $my_oldlibs; do

3750

# Extract the objects.

3751

case $my_xlib in

3752

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

3753

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

3754

esac

3755

func_basename "$my_xlib"

3756

my_xlib="$func_basename_result"

3757

my_xlib_u=$my_xlib

3758

while :; do

3759

case " $extracted_archives " in

3760

*" $my_xlib_u "*)

3761

func_arith $extracted_serial + 1

3762

extracted_serial=$func_arith_result

3763

my_xlib_u=lt$extracted_serial-$my_xlib ;;

3764

*) break ;;

3765

esac

3766

done

3767

extracted_archives="$extracted_archives $my_xlib_u"

3768

my_xdir="$my_gentop/$my_xlib_u"

3769

3770

func_mkdir_p "$my_xdir"

3771

3772

case $host in

3773

*-darwin*)

3774

func_verbose "Extracting $my_xabs"

3775

# Do not bother doing anything if just a dry run

3776

$opt_dry_run || {

3777

darwin_orig_dir=`pwd`

3778

cd $my_xdir || exit $?

3779

darwin_archive=$my_xabs

3780

darwin_curdir=`pwd`

3781

darwin_base_archive=`basename "$darwin_archive"`

3782

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

3783

if test -n "$darwin_arches"; then

3784

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

3785

darwin_arch=

3786

func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"

3787

for darwin_arch in $darwin_arches ; do

3788

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

3789

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

3790

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

3791

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

3792

cd "$darwin_curdir"

3793

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

3794

done # $darwin_arches

3795

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

3796

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

3797

darwin_file=

3798

darwin_files=

3799

for darwin_file in $darwin_filelist; do

3800

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

3801

$LIPO -create -output "$darwin_file" $darwin_files

3802

done # $darwin_filelist

3803

$RM -rf unfat-$$

3804

cd "$darwin_orig_dir"

3805

else

3806

cd $darwin_orig_dir

3807

func_extract_an_archive "$my_xdir" "$my_xabs"

3808

fi # $darwin_arches

3809

} # !$opt_dry_run

3810

;;

3811

*)

3812

func_extract_an_archive "$my_xdir" "$my_xabs"

3813

;;

3814

esac

3815

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

3816

done

3817

3818

func_extract_archives_result="$my_oldobjs"

3819

}

3820

3821

3822

# func_emit_wrapper [arg=no]

3823

#

3824

# Emit a libtool wrapper script on stdout.

3825

# Don't directly open a file because we may want to

3826

# incorporate the script contents within a cygwin/mingw

3827

# wrapper executable. Must ONLY be called from within

3828

# func_mode_link because it depends on a number of variables

3829

# set therein.

3830

#

3831

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

3832

# variable will take. If 'yes', then the emitted script

3833

# will assume that the directory in which it is stored is

3834

# the $objdir directory. This is a cygwin/mingw-specific

3835

# behavior.

3836

func_emit_wrapper ()

3837

{

3838

func_emit_wrapper_arg1=${1-no}

3839

3840

$ECHO "\

3841

#! $SHELL

3842

3843

# $output - temporary wrapper script for $objdir/$outputname

3844

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

3845

#

3846

# The $output program cannot be directly executed until all the libtool

3847

# libraries that it depends on are installed.

3848

#

3849

# This wrapper script should never be moved out of the build directory.

3850

# If it is, it will not operate correctly.

3851

3852

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

3853

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

3854

sed_quote_subst='$sed_quote_subst'

3855

3856

# Be Bourne compatible

3857

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

3858

emulate sh

3859

NULLCMD=:

3860

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

3861

# is contrary to our usage. Disable this feature.

3862

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

3863

setopt NO_GLOB_SUBST

3864

else

3865

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

3866

fi

3867

BIN_SH=xpg4; export BIN_SH # for Tru64

3868

DUALCASE=1; export DUALCASE # for MKS sh

3869

3870

# The HP-UX ksh and POSIX shell print the target directory to stdout

3871

# if CDPATH is set.

3872

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

3873

3874

relink_command=\"$relink_command\"

3875

3876

# This environment variable determines our operation mode.

3877

if test \"\$libtool_install_magic\" = \"$magic\"; then

3878

# install mode needs the following variables:

3879

generated_by_libtool_version='$macro_version'

3880

notinst_deplibs='$notinst_deplibs'

3881

else

3882

# When we are sourced in execute mode, \$file and \$ECHO are already set.

3883

if test \"\$libtool_execute_magic\" != \"$magic\"; then

3884

file=\"\$0\""

3885

3886

qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`

3887

$ECHO "\

3888

3889

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

3890

func_fallback_echo ()

3891

{

3892

eval 'cat <<_LTECHO_EOF

3893

\$1

3894

_LTECHO_EOF'

3895

}

3896

ECHO=\"$qECHO\"

3897

fi

3898

3899

# Very basic option parsing. These options are (a) specific to

3900

# the libtool wrapper, (b) are identical between the wrapper

3901

# /script/ and the wrapper /executable/ which is used only on

3902

# windows platforms, and (c) all begin with the string "--lt-"

3903

# (application programs are unlikely to have options which match

3904

# this pattern).

3905

#

3906

# There are only two supported options: --lt-debug and

3907

# --lt-dump-script. There is, deliberately, no --lt-help.

3908

#

3909

# The first argument to this parsing function should be the

3910

# script's $0 value, followed by "$@".

3911

lt_option_debug=

3912

func_parse_lt_options ()

3913

{

3914

lt_script_arg0=\$0

3915

shift

3916

for lt_opt

3917

do

3918

case \"\$lt_opt\" in

3919

--lt-debug) lt_option_debug=1 ;;

3920

--lt-dump-script)

3921

lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`

3922

test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.

3923

lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`

3924

cat \"\$lt_dump_D/\$lt_dump_F\"

3925

exit 0

3926

;;

3927

--lt-*)

3928

\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2

3929

exit 1

3930

;;

3931

esac

3932

done

3933

3934

# Print the debug banner immediately:

3935

if test -n \"\$lt_option_debug\"; then

3936

echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2

3937

fi

3938

}

3939

3940

# Used when --lt-debug. Prints its arguments to stdout

3941

# (redirection is the responsibility of the caller)

3942

func_lt_dump_args ()

3943

{

3944

lt_dump_args_N=1;

3945

for lt_arg

3946

do

3947

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"

3948

lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`

3949

done

3950

}

3951

3952

# Core function for launching the target application

3953

func_exec_program_core ()

3954

{

3955

"

3956

case $host in

3957

# Backslashes separate directories on plain windows

3958

*-*-mingw | *-*-os2* | *-cegcc*)

3959

$ECHO "\

3960

if test -n \"\$lt_option_debug\"; then

3961

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2

3962

func_lt_dump_args \${1+\"\$@\"} 1>&2

3963

fi

3964

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

3965

"

3966

;;

3967

3968

*)

3969

$ECHO "\

3970

if test -n \"\$lt_option_debug\"; then

3971

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2

3972

func_lt_dump_args \${1+\"\$@\"} 1>&2

3973

fi

3974

exec \"\$progdir/\$program\" \${1+\"\$@\"}

3975

"

3976

;;

3977

esac

3978

$ECHO "\

3979

\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2

3980

exit 1

3981

}

3982

3983

# A function to encapsulate launching the target application

3984

# Strips options in the --lt-* namespace from \$@ and

3985

# launches target application with the remaining arguments.

3986

func_exec_program ()

3987

{

3988

case \" \$* \" in

3989

*\\ --lt-*)

3990

for lt_wr_arg

3991

do

3992

case \$lt_wr_arg in

3993

--lt-*) ;;

3994

*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;

3995

esac

3996

shift

3997

done ;;

3998

esac

3999

func_exec_program_core \${1+\"\$@\"}

4000

}

4001

4002

# Parse options

4003

func_parse_lt_options \"\$0\" \${1+\"\$@\"}

4004

4005

# Find the directory that this script lives in.

4006

thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`

4007

test \"x\$thisdir\" = \"x\$file\" && thisdir=.

4008

4009

# Follow symbolic links until we get to the real thisdir.

4010

file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`

4011

while test -n \"\$file\"; do

4012

destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`

4013

4014

# If there was a directory component, then change thisdir.

4015

if test \"x\$destdir\" != \"x\$file\"; then

4016

case \"\$destdir\" in

4017

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

4018

*) thisdir=\"\$thisdir/\$destdir\" ;;

4019

esac

4020

fi

4021

4022

file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`

4023

file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`

4024

done

4025

4026

# Usually 'no', except on cygwin/mingw when embedded into

4027

# the cwrapper.

4028

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1

4029

if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then

4030

# special case for '.'

4031

if test \"\$thisdir\" = \".\"; then

4032

thisdir=\`pwd\`

4033

fi

4034

# remove .libs from thisdir

4035

case \"\$thisdir\" in

4036

*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;

4037

$objdir ) thisdir=. ;;

4038

esac

4039

fi

4040

4041

# Try to get the absolute directory name.

4042

absdir=\`cd \"\$thisdir\" && pwd\`

4043

test -n \"\$absdir\" && thisdir=\"\$absdir\"

4044

"

4045

4046

if test "$fast_install" = yes; then

4047

$ECHO "\

4048

program=lt-'$outputname'$exeext

4049

progdir=\"\$thisdir/$objdir\"

4050

4051

if test ! -f \"\$progdir/\$program\" ||

4052

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

4053

test \"X\$file\" != \"X\$progdir/\$program\"; }; then

4054

4055

file=\"\$\$-\$program\"

4056

4057

if test ! -d \"\$progdir\"; then

4058

$MKDIR \"\$progdir\"

4059

else

4060

$RM \"\$progdir/\$file\"

4061

fi"

4062

4063

$ECHO "\

4064

4065

# relink executable if necessary

4066

if test -n \"\$relink_command\"; then

4067

if relink_command_output=\`eval \$relink_command 2>&1\`; then :

4068

else

4069

$ECHO \"\$relink_command_output\" >&2

4070

$RM \"\$progdir/\$file\"

4071

exit 1

4072

fi

4073

fi

4074

4075

$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||

4076

{ $RM \"\$progdir/\$program\";

4077

$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }

4078

$RM \"\$progdir/\$file\"

4079

fi"

4080

else

4081

$ECHO "\

4082

program='$outputname'

4083

progdir=\"\$thisdir/$objdir\"

4084

"

4085

fi

4086

4087

$ECHO "\

4088

4089

if test -f \"\$progdir/\$program\"; then"

4090

4091

# fixup the dll searchpath if we need to.

4092

#

4093

# Fix the DLL searchpath if we need to. Do this before prepending

4094

# to shlibpath, because on Windows, both are PATH and uninstalled

4095

# libraries must come first.

4096

if test -n "$dllsearchpath"; then

4097

$ECHO "\

4098

# Add the dll search path components to the executable PATH

4099

PATH=$dllsearchpath:\$PATH

4100

"

4101

fi

4102

4103

# Export our shlibpath_var if we have one.

4104

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4105

$ECHO "\

4106

# Add our own library path to $shlibpath_var

4107

$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

4108

4109

# Some systems cannot cope with colon-terminated $shlibpath_var

4110

# The second colon is a workaround for a bug in BeOS R4 sed

4111

$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`

4112

4113

export $shlibpath_var

4114

"

4115

fi

4116

4117

$ECHO "\

4118

if test \"\$libtool_execute_magic\" != \"$magic\"; then

4119

# Run the actual program with our arguments.

4120

func_exec_program \${1+\"\$@\"}

4121

fi

4122

else

4123

# The program doesn't exist.

4124

\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

4125

\$ECHO \"This script is just a wrapper for \$program.\" 1>&2

4126

\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

4127

exit 1

4128

fi

4129

fi\

4130

"

4131

}

4132

4133

4134

# func_emit_cwrapperexe_src

4135

# emit the source code for a wrapper executable on stdout

4136

# Must ONLY be called from within func_mode_link because

4137

# it depends on a number of variable set therein.

4138

func_emit_cwrapperexe_src ()

4139

{

4140

cat <<EOF

4141

4142

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

4143

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

4144

4145

The $output program cannot be directly executed until all the libtool

4146

libraries that it depends on are installed.

4147

4148

This wrapper executable should never be moved out of the build directory.

4149

If it is, it will not operate correctly.

4150

*/

4151

EOF

4152

cat <<"EOF"

4153

#ifdef _MSC_VER

4154

# define _CRT_SECURE_NO_DEPRECATE 1

4155

#endif

4156

#include <stdio.h>

4157

#include <stdlib.h>

4158

#ifdef _MSC_VER

4159

# include <direct.h>

4160

# include <process.h>

4161

# include <io.h>

4162

#else

4163

# include <unistd.h>

4164

# include <stdint.h>

4165

# ifdef __CYGWIN__

4166

# include <io.h>

4167

# endif

4168

#endif

4169

#include <malloc.h>

4170

#include <stdarg.h>

4171

#include <assert.h>

4172

#include <string.h>

4173

#include <ctype.h>

4174

#include <errno.h>

4175

#include <fcntl.h>

4176

#include <sys/stat.h>

4177

4178

/* declarations of non-ANSI functions */

4179

#if defined(__MINGW32__)

4180

# ifdef __STRICT_ANSI__

4181

int _putenv (const char *);

4182

# endif

4183

#elif defined(__CYGWIN__)

4184

# ifdef __STRICT_ANSI__

4185

char *realpath (const char *, char *);

4186

int putenv (char *);

4187

int setenv (const char *, const char *, int);

4188

# endif

4189

/* #elif defined (other platforms) ... */

4190

#endif

4191

4192

/* portability defines, excluding path handling macros */

4193

#if defined(_MSC_VER)

4194

# define setmode _setmode

4195

# define stat _stat

4196

# define chmod _chmod

4197

# define getcwd _getcwd

4198

# define putenv _putenv

4199

# define S_IXUSR _S_IEXEC

4200

# ifndef _INTPTR_T_DEFINED

4201

# define _INTPTR_T_DEFINED

4202

# define intptr_t int

4203

# endif

4204

#elif defined(__MINGW32__)

4205

# define setmode _setmode

4206

# define stat _stat

4207

# define chmod _chmod

4208

# define getcwd _getcwd

4209

# define putenv _putenv

4210

#elif defined(__CYGWIN__)

4211

# define HAVE_SETENV

4212

# define FOPEN_WB "wb"

4213

/* #elif defined (other platforms) ... */

4214

#endif

4215

4216

#if defined(PATH_MAX)

4217

# define LT_PATHMAX PATH_MAX

4218

#elif defined(MAXPATHLEN)

4219

# define LT_PATHMAX MAXPATHLEN

4220

#else

4221

# define LT_PATHMAX 1024

4222

#endif

4223

4224

#ifndef S_IXOTH

4225

# define S_IXOTH 0

4226

#endif

4227

#ifndef S_IXGRP

4228

# define S_IXGRP 0

4229

#endif

4230

4231

/* path handling portability macros */

4232

#ifndef DIR_SEPARATOR

4233

# define DIR_SEPARATOR '/'

4234

# define PATH_SEPARATOR ':'

4235

#endif

4236

4237

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

4238

defined (__OS2__)

4239

# define HAVE_DOS_BASED_FILE_SYSTEM

4240

# define FOPEN_WB "wb"

4241

# ifndef DIR_SEPARATOR_2

4242

# define DIR_SEPARATOR_2 '\\'

4243

# endif

4244

# ifndef PATH_SEPARATOR_2

4245

# define PATH_SEPARATOR_2 ';'

4246

# endif

4247

#endif

4248

4249

#ifndef DIR_SEPARATOR_2

4250

# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)

4251

#else /* DIR_SEPARATOR_2 */

4252

# define IS_DIR_SEPARATOR(ch) \

4253

(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))

4254

#endif /* DIR_SEPARATOR_2 */

4255

4256

#ifndef PATH_SEPARATOR_2

4257

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)

4258

#else /* PATH_SEPARATOR_2 */

4259

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

4260

#endif /* PATH_SEPARATOR_2 */

4261

4262

#ifndef FOPEN_WB

4263

# define FOPEN_WB "w"

4264

#endif

4265

#ifndef _O_BINARY

4266

# define _O_BINARY 0

4267

#endif

4268

4269

#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

4270

#define XFREE(stale) do { \

4271

if (stale) { free ((void *) stale); stale = 0; } \

4272

} while (0)

4273

4274

#if defined(LT_DEBUGWRAPPER)

4275

static int lt_debug = 1;

4276

#else

4277

static int lt_debug = 0;

4278

#endif

4279

4280

const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */

4281

4282

void *xmalloc (size_t num);

4283

char *xstrdup (const char *string);

4284

const char *base_name (const char *name);

4285

char *find_executable (const char *wrapper);

4286

char *chase_symlinks (const char *pathspec);

4287

int make_executable (const char *path);

4288

int check_executable (const char *path);

4289

char *strendzap (char *str, const char *pat);

4290

void lt_debugprintf (const char *file, int line, const char *fmt, ...);

4291

void lt_fatal (const char *file, int line, const char *message, ...);

4292

static const char *nonnull (const char *s);

4293

static const char *nonempty (const char *s);

4294

void lt_setenv (const char *name, const char *value);

4295

char *lt_extend_str (const char *orig_value, const char *add, int to_end);

4296

void lt_update_exe_path (const char *name, const char *value);

4297

void lt_update_lib_path (const char *name, const char *value);

4298

char **prepare_spawn (char **argv);

4299

void lt_dump_script (FILE *f);

4300

EOF

4301

4302

cat <<EOF

4303

volatile const char * MAGIC_EXE = "$magic_exe";

4304

const char * LIB_PATH_VARNAME = "$shlibpath_var";

4305

EOF

4306

4307

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

4308

func_to_host_path "$temp_rpath"

4309

cat <<EOF

4310

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

4311

EOF

4312

else

4313

cat <<"EOF"

4314

const char * LIB_PATH_VALUE = "";

4315

EOF

4316

fi

4317

4318

if test -n "$dllsearchpath"; then

4319

func_to_host_path "$dllsearchpath:"

4320

cat <<EOF

4321

const char * EXE_PATH_VARNAME = "PATH";

4322

const char * EXE_PATH_VALUE = "$func_to_host_path_result";

4323

EOF

4324

else

4325

cat <<"EOF"

4326

const char * EXE_PATH_VARNAME = "";

4327

const char * EXE_PATH_VALUE = "";

4328

EOF

4329

fi

4330

4331

if test "$fast_install" = yes; then

4332

cat <<EOF

4333

const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */

4334

EOF

4335

else

4336

cat <<EOF

4337

const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */

4338

EOF

4339

fi

4340

4341

4342

cat <<"EOF"

4343

4344

#define LTWRAPPER_OPTION_PREFIX "--lt-"

4345

4346

static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;

4347

static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";

4348

static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";

4349

4350

int

4351

main (int argc, char *argv[])

4352

{

4353

char **newargz;

4354

int newargc;

4355

char *tmp_pathspec;

4356

char *actual_cwrapper_path;

4357

char *actual_cwrapper_name;

4358

char *target_name;

4359

char *lt_argv_zero;

4360

intptr_t rval = 127;

4361

4362

int i;

4363

4364

program_name = (char *) xstrdup (base_name (argv[0]));

4365

newargz = XMALLOC (char *, argc + 1);

4366

4367

/* very simple arg parsing; don't want to rely on getopt

4368

* also, copy all non cwrapper options to newargz, except

4369

* argz[0], which is handled differently

4370

*/

4371

newargc=0;

4372

for (i = 1; i < argc; i++)

4373

{

4374

if (strcmp (argv[i], dumpscript_opt) == 0)

4375

{

4376

EOF

4377

case "$host" in

4378

*mingw* | *cygwin* )

4379

# make stdout use "unix" line endings

4380

echo " setmode(1,_O_BINARY);"

4381

;;

4382

esac

4383

4384

cat <<"EOF"

4385

lt_dump_script (stdout);

4386

return 0;

4387

}

4388

if (strcmp (argv[i], debug_opt) == 0)

4389

{

4390

lt_debug = 1;

4391

continue;

4392

}

4393

if (strcmp (argv[i], ltwrapper_option_prefix) == 0)

4394

{

4395

/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX

4396

namespace, but it is not one of the ones we know about and

4397

have already dealt with, above (inluding dump-script), then

4398

report an error. Otherwise, targets might begin to believe

4399

they are allowed to use options in the LTWRAPPER_OPTION_PREFIX

4400

namespace. The first time any user complains about this, we'll

4401

need to make LTWRAPPER_OPTION_PREFIX a configure-time option

4402

or a configure.ac-settable value.

4403

*/

4404

lt_fatal (__FILE__, __LINE__,

4405

"unrecognized %s option: '%s'",

4406

ltwrapper_option_prefix, argv[i]);

4407

}

4408

/* otherwise ... */

4409

newargz[++newargc] = xstrdup (argv[i]);

4410

}

4411

newargz[++newargc] = NULL;

4412

4413

EOF

4414

cat <<EOF

4415

/* The GNU banner must be the first non-error debug message */

4416

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");

4417

EOF

4418

cat <<"EOF"

4419

lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);

4420

lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);

4421

4422

tmp_pathspec = find_executable (argv[0]);

4423

if (tmp_pathspec == NULL)

4424

lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);

4425

lt_debugprintf (__FILE__, __LINE__,

4426

"(main) found exe (before symlink chase) at: %s\n",

4427

tmp_pathspec);

4428

4429

actual_cwrapper_path = chase_symlinks (tmp_pathspec);

4430

lt_debugprintf (__FILE__, __LINE__,

4431

"(main) found exe (after symlink chase) at: %s\n",

4432

actual_cwrapper_path);

4433

XFREE (tmp_pathspec);

4434

4435

actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));

4436

strendzap (actual_cwrapper_path, actual_cwrapper_name);

4437

4438

/* wrapper name transforms */

4439

strendzap (actual_cwrapper_name, ".exe");

4440

tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);

4441

XFREE (actual_cwrapper_name);

4442

actual_cwrapper_name = tmp_pathspec;

4443

tmp_pathspec = 0;

4444

4445

/* target_name transforms -- use actual target program name; might have lt- prefix */

4446

target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));

4447

strendzap (target_name, ".exe");

4448

tmp_pathspec = lt_extend_str (target_name, ".exe", 1);

4449

XFREE (target_name);

4450

target_name = tmp_pathspec;

4451

tmp_pathspec = 0;

4452

4453

lt_debugprintf (__FILE__, __LINE__,

4454

"(main) libtool target name: %s\n",

4455

target_name);

4456

EOF

4457

4458

cat <<EOF

4459

newargz[0] =

4460

XMALLOC (char, (strlen (actual_cwrapper_path) +

4461

strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));

4462

strcpy (newargz[0], actual_cwrapper_path);

4463

strcat (newargz[0], "$objdir");

4464

strcat (newargz[0], "/");

4465

EOF

4466

4467

cat <<"EOF"

4468

/* stop here, and copy so we don't have to do this twice */

4469

tmp_pathspec = xstrdup (newargz[0]);

4470

4471

/* do NOT want the lt- prefix here, so use actual_cwrapper_name */

4472

strcat (newargz[0], actual_cwrapper_name);

4473

4474

/* DO want the lt- prefix here if it exists, so use target_name */

4475

lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);

4476

XFREE (tmp_pathspec);

4477

tmp_pathspec = NULL;

4478

EOF

4479

4480

case $host_os in

4481

mingw*)

4482

cat <<"EOF"

4483

{

4484

char* p;

4485

while ((p = strchr (newargz[0], '\\')) != NULL)

4486

{

4487

*p = '/';

4488

}

4489

while ((p = strchr (lt_argv_zero, '\\')) != NULL)

4490

{

4491

*p = '/';

4492

}

4493

}

4494

EOF

4495

;;

4496

esac

4497

4498

cat <<"EOF"

4499

XFREE (target_name);

4500

XFREE (actual_cwrapper_path);

4501

XFREE (actual_cwrapper_name);

4502

4503

lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */

4504

lt_setenv ("DUALCASE", "1"); /* for MSK sh */

4505

/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must

4506

be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)

4507

because on Windows, both *_VARNAMEs are PATH but uninstalled

4508

libraries must come first. */

4509

lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);

4510

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

4511

4512

lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",

4513

nonnull (lt_argv_zero));

4514

for (i = 0; i < newargc; i++)

4515

{

4516

lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",

4517

i, nonnull (newargz[i]));

4518

}

4519

4520

EOF

4521

4522

case $host_os in

4523

mingw*)

4524

cat <<"EOF"

4525

/* execv doesn't actually work on mingw as expected on unix */

4526

newargz = prepare_spawn (newargz);

4527

rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

4528

if (rval == -1)

4529

{

4530

/* failed to start process */

4531

lt_debugprintf (__FILE__, __LINE__,

4532

"(main) failed to launch target \"%s\": %s\n",

4533

lt_argv_zero, nonnull (strerror (errno)));

4534

return 127;

4535

}

4536

return rval;

4537

EOF

4538

;;

4539

*)

4540

cat <<"EOF"

4541

execv (lt_argv_zero, newargz);

4542

return rval; /* =127, but avoids unused variable warning */

4543

EOF

4544

;;

4545

esac

4546

4547

cat <<"EOF"

4548

}

4549

4550

void *

4551

xmalloc (size_t num)

4552

{

4553

void *p = (void *) malloc (num);

4554

if (!p)

4555

lt_fatal (__FILE__, __LINE__, "memory exhausted");

4556

4557

return p;

4558

}

4559

4560

char *

4561

xstrdup (const char *string)

4562

{

4563

return string ? strcpy ((char *) xmalloc (strlen (string) + 1),

4564

string) : NULL;

4565

}

4566

4567

const char *

4568

base_name (const char *name)

4569

{

4570

const char *base;

4571

4572

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4573

/* Skip over the disk name in MSDOS pathnames. */

4574

if (isalpha ((unsigned char) name[0]) && name[1] == ':')

4575

name += 2;

4576

#endif

4577

4578

for (base = name; *name; name++)

4579

if (IS_DIR_SEPARATOR (*name))

4580

base = name + 1;

4581

return base;

4582

}

4583

4584

int

4585

check_executable (const char *path)

4586

{

4587

struct stat st;

4588

4589

lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",

4590

nonempty (path));

4591

if ((!path) || (!*path))

4592

return 0;

4593

4594

if ((stat (path, &st) >= 0)

4595

&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))

4596

return 1;

4597

else

4598

return 0;

4599

}

4600

4601

int

4602

make_executable (const char *path)

4603

{

4604

int rval = 0;

4605

struct stat st;

4606

4607

lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",

4608

nonempty (path));

4609

if ((!path) || (!*path))

4610

return 0;

4611

4612

if (stat (path, &st) >= 0)

4613

{

4614

rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);

4615

}

4616

return rval;

4617

}

4618

4619

/* Searches for the full path of the wrapper. Returns

4620

newly allocated full path name if found, NULL otherwise

4621

Does not chase symlinks, even on platforms that support them.

4622

*/

4623

char *

4624

find_executable (const char *wrapper)

4625

{

4626

int has_slash = 0;

4627

const char *p;

4628

const char *p_next;

4629

/* static buffer for getcwd */

4630

char tmp[LT_PATHMAX + 1];

4631

int tmp_len;

4632

char *concat_name;

4633

4634

lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",

4635

nonempty (wrapper));

4636

4637

if ((wrapper == NULL) || (*wrapper == '\0'))

4638

return NULL;

4639

4640

/* Absolute path? */

4641

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4642

if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')

4643

{

4644

concat_name = xstrdup (wrapper);

4645

if (check_executable (concat_name))

4646

return concat_name;

4647

XFREE (concat_name);

4648

}

4649

else

4650

{

4651

#endif

4652

if (IS_DIR_SEPARATOR (wrapper[0]))

4653

{

4654

concat_name = xstrdup (wrapper);

4655

if (check_executable (concat_name))

4656

return concat_name;

4657

XFREE (concat_name);

4658

}

4659

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

4660

}

4661

#endif

4662

4663

for (p = wrapper; *p; p++)

4664

if (*p == '/')

4665

{

4666

has_slash = 1;

4667

break;

4668

}

4669

if (!has_slash)

4670

{

4671

/* no slashes; search PATH */

4672

const char *path = getenv ("PATH");

4673

if (path != NULL)

4674

{

4675

for (p = path; *p; p = p_next)

4676

{

4677

const char *q;

4678

size_t p_len;

4679

for (q = p; *q; q++)

4680

if (IS_PATH_SEPARATOR (*q))

4681

break;

4682

p_len = q - p;

4683

p_next = (*q == '\0' ? q : q + 1);

4684

if (p_len == 0)

4685

{

4686

/* empty path: current directory */

4687

if (getcwd (tmp, LT_PATHMAX) == NULL)

4688

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4689

nonnull (strerror (errno)));

4690

tmp_len = strlen (tmp);

4691

concat_name =

4692

XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

4693

memcpy (concat_name, tmp, tmp_len);

4694

concat_name[tmp_len] = '/';

4695

strcpy (concat_name + tmp_len + 1, wrapper);

4696

}

4697

else

4698

{

4699

concat_name =

4700

XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);

4701

memcpy (concat_name, p, p_len);

4702

concat_name[p_len] = '/';

4703

strcpy (concat_name + p_len + 1, wrapper);

4704

}

4705

if (check_executable (concat_name))

4706

return concat_name;

4707

XFREE (concat_name);

4708

}

4709

}

4710

/* not found in PATH; assume curdir */

4711

}

4712

/* Relative path | not found in path: prepend cwd */

4713

if (getcwd (tmp, LT_PATHMAX) == NULL)

4714

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4715

nonnull (strerror (errno)));

4716

tmp_len = strlen (tmp);

4717

concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

4718

memcpy (concat_name, tmp, tmp_len);

4719

concat_name[tmp_len] = '/';

4720

strcpy (concat_name + tmp_len + 1, wrapper);

4721

4722

if (check_executable (concat_name))

4723

return concat_name;

4724

XFREE (concat_name);

4725

return NULL;

4726

}

4727

4728

char *

4729

chase_symlinks (const char *pathspec)

4730

{

4731

#ifndef S_ISLNK

4732

return xstrdup (pathspec);

4733

#else

4734

char buf[LT_PATHMAX];

4735

struct stat s;

4736

char *tmp_pathspec = xstrdup (pathspec);

4737

char *p;

4738

int has_symlinks = 0;

4739

while (strlen (tmp_pathspec) && !has_symlinks)

4740

{

4741

lt_debugprintf (__FILE__, __LINE__,

4742

"checking path component for symlinks: %s\n",

4743

tmp_pathspec);

4744

if (lstat (tmp_pathspec, &s) == 0)

4745

{

4746

if (S_ISLNK (s.st_mode) != 0)

4747

{

4748

has_symlinks = 1;

4749

break;

4750

}

4751

4752

/* search backwards for last DIR_SEPARATOR */

4753

p = tmp_pathspec + strlen (tmp_pathspec) - 1;

4754

while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

4755

p--;

4756

if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))

4757

{

4758

/* no more DIR_SEPARATORS left */

4759

break;

4760

}

4761

*p = '\0';

4762

}

4763

else

4764

{

4765

lt_fatal (__FILE__, __LINE__,

4766

"error accessing file \"%s\": %s",

4767

tmp_pathspec, nonnull (strerror (errno)));

4768

}

4769

}

4770

XFREE (tmp_pathspec);

4771

4772

if (!has_symlinks)

4773

{

4774

return xstrdup (pathspec);

4775

}

4776

4777

tmp_pathspec = realpath (pathspec, buf);

4778

if (tmp_pathspec == 0)

4779

{

4780

lt_fatal (__FILE__, __LINE__,

4781

"could not follow symlinks for %s", pathspec);

4782

}

4783

return xstrdup (tmp_pathspec);

4784

#endif

4785

}

4786

4787

char *

4788

strendzap (char *str, const char *pat)

4789

{

4790

size_t len, patlen;

4791

4792

assert (str != NULL);

4793

assert (pat != NULL);

4794

4795

len = strlen (str);

4796

patlen = strlen (pat);

4797

4798

if (patlen <= len)

4799

{

4800

str += len - patlen;

4801

if (strcmp (str, pat) == 0)

4802

*str = '\0';

4803

}

4804

return str;

4805

}

4806

4807

void

4808

lt_debugprintf (const char *file, int line, const char *fmt, ...)

4809

{

4810

va_list args;

4811

if (lt_debug)

4812

{

4813

(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);

4814

va_start (args, fmt);

4815

(void) vfprintf (stderr, fmt, args);

4816

va_end (args);

4817

}

4818

}

4819

4820

static void

4821

lt_error_core (int exit_status, const char *file,

4822

int line, const char *mode,

4823

const char *message, va_list ap)

4824

{

4825

fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);

4826

vfprintf (stderr, message, ap);

4827

fprintf (stderr, ".\n");

4828

4829

if (exit_status >= 0)

4830

exit (exit_status);

4831

}

4832

4833

void

4834

lt_fatal (const char *file, int line, const char *message, ...)

4835

{

4836

va_list ap;

4837

va_start (ap, message);

4838

lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);

4839

va_end (ap);

4840

}

4841

4842

static const char *

4843

nonnull (const char *s)

4844

{

4845

return s ? s : "(null)";

4846

}

4847

4848

static const char *

4849

nonempty (const char *s)

4850

{

4851

return (s && !*s) ? "(empty)" : nonnull (s);

4852

}

4853

4854

void

4855

lt_setenv (const char *name, const char *value)

4856

{

4857

lt_debugprintf (__FILE__, __LINE__,

4858

"(lt_setenv) setting '%s' to '%s'\n",

4859

nonnull (name), nonnull (value));

4860

{

4861

#ifdef HAVE_SETENV

4862

/* always make a copy, for consistency with !HAVE_SETENV */

4863

char *str = xstrdup (value);

4864

setenv (name, str, 1);

4865

#else

4866

int len = strlen (name) + 1 + strlen (value) + 1;

4867

char *str = XMALLOC (char, len);

4868

sprintf (str, "%s=%s", name, value);

4869

if (putenv (str) != EXIT_SUCCESS)

4870

{

4871

XFREE (str);

4872

}

4873

#endif

4874

}

4875

}

4876

4877

char *

4878

lt_extend_str (const char *orig_value, const char *add, int to_end)

4879

{

4880

char *new_value;

4881

if (orig_value && *orig_value)

4882

{

4883

int orig_value_len = strlen (orig_value);

4884

int add_len = strlen (add);

4885

new_value = XMALLOC (char, add_len + orig_value_len + 1);

4886

if (to_end)

4887

{

4888

strcpy (new_value, orig_value);

4889

strcpy (new_value + orig_value_len, add);

4890

}

4891

else

4892

{

4893

strcpy (new_value, add);

4894

strcpy (new_value + add_len, orig_value);

4895

}

4896

}

4897

else

4898

{

4899

new_value = xstrdup (add);

4900

}

4901

return new_value;

4902

}

4903

4904

void

4905

lt_update_exe_path (const char *name, const char *value)

4906

{

4907

lt_debugprintf (__FILE__, __LINE__,

4908

"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",

4909

nonnull (name), nonnull (value));

4910

4911

if (name && *name && value && *value)

4912

{

4913

char *new_value = lt_extend_str (getenv (name), value, 0);

4914

/* some systems can't cope with a ':'-terminated path #' */

4915

int len = strlen (new_value);

4916

while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))

4917

{

4918

new_value[len-1] = '\0';

4919

}

4920

lt_setenv (name, new_value);

4921

XFREE (new_value);

4922

}

4923

}

4924

4925

void

4926

lt_update_lib_path (const char *name, const char *value)

4927

{

4928

lt_debugprintf (__FILE__, __LINE__,

4929

"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",

4930

nonnull (name), nonnull (value));

4931

4932

if (name && *name && value && *value)

4933

{

4934

char *new_value = lt_extend_str (getenv (name), value, 0);

4935

lt_setenv (name, new_value);

4936

XFREE (new_value);

4937

}

4938

}

4939

4940

EOF

4941

case $host_os in

4942

mingw*)

4943

cat <<"EOF"

4944

4945

/* Prepares an argument vector before calling spawn().

4946

Note that spawn() does not by itself call the command interpreter

4947

(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :

4948

({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

4949

GetVersionEx(&v);

4950

v.dwPlatformId == VER_PLATFORM_WIN32_NT;

4951

}) ? "cmd.exe" : "command.com").

4952

Instead it simply concatenates the arguments, separated by ' ', and calls

4953

CreateProcess(). We must quote the arguments since Win32 CreateProcess()

4954

interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a

4955

special way:

4956

- Space and tab are interpreted as delimiters. They are not treated as

4957

delimiters if they are surrounded by double quotes: "...".

4958

- Unescaped double quotes are removed from the input. Their only effect is

4959

that within double quotes, space and tab are treated like normal

4960

characters.

4961

- Backslashes not followed by double quotes are not special.

4962

- But 2*n+1 backslashes followed by a double quote become

4963

n backslashes followed by a double quote (n >= 0):

4964

\" -> "

4965

\\\" -> \"

4966

\\\\\" -> \\"

4967

*/

4968

#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"

4969

#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"

4970

char **

4971

prepare_spawn (char **argv)

4972

{

4973

size_t argc;

4974

char **new_argv;

4975

size_t i;

4976

4977

/* Count number of arguments. */

4978

for (argc = 0; argv[argc] != NULL; argc++)

4979

;

4980

4981

/* Allocate new argument vector. */

4982

new_argv = XMALLOC (char *, argc + 1);

4983

4984

/* Put quoted arguments into the new argument vector. */

4985

for (i = 0; i < argc; i++)

4986

{

4987

const char *string = argv[i];

4988

4989

if (string[0] == '\0')

4990

new_argv[i] = xstrdup ("\"\"");

4991

else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)

4992

{

4993

int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);

4994

size_t length;

4995

unsigned int backslashes;

4996

const char *s;

4997

char *quoted_string;

4998

char *p;

4999

5000

length = 0;

5001

backslashes = 0;

5002

if (quote_around)

5003

length++;

5004

for (s = string; *s != '\0'; s++)

5005

{

5006

char c = *s;

5007

if (c == '"')

5008

length += backslashes + 1;

5009

length++;

5010

if (c == '\\')

5011

backslashes++;

5012

else

5013

backslashes = 0;

5014

}

5015

if (quote_around)

5016

length += backslashes + 1;

5017

5018

quoted_string = XMALLOC (char, length + 1);

5019

5020

p = quoted_string;

5021

backslashes = 0;

5022

if (quote_around)

5023

*p++ = '"';

5024

for (s = string; *s != '\0'; s++)

5025

{

5026

char c = *s;

5027

if (c == '"')

5028

{

5029

unsigned int j;

5030

for (j = backslashes + 1; j > 0; j--)

5031

*p++ = '\\';

5032

}

5033

*p++ = c;

5034

if (c == '\\')

5035

backslashes++;

5036

else

5037

backslashes = 0;

5038

}

5039

if (quote_around)

5040

{

5041

unsigned int j;

5042

for (j = backslashes; j > 0; j--)

5043

*p++ = '\\';

5044

*p++ = '"';

5045

}

5046

*p = '\0';

5047

5048

new_argv[i] = quoted_string;

5049

}

5050

else

5051

new_argv[i] = (char *) string;

5052

}

5053

new_argv[argc] = NULL;

5054

5055

return new_argv;

5056

}

5057

EOF

5058

;;

5059

esac

5060

5061

cat <<"EOF"

5062

void lt_dump_script (FILE* f)

5063

{

5064

EOF

5065

func_emit_wrapper yes |

5066

$SED -n -e '

5067

s/^$.\{79\}$$..*$/\1\

5068

\2/

5069

h

5070

s/$[\\"]$/\\\1/g

5071

s/$/\\n/

5072

s/$[^\n]*$.*/ fputs ("\1", f);/p

5073

g

5074

D'

5075

cat <<"EOF"

5076

}

5077

EOF

5078

}

5079

# end: func_emit_cwrapperexe_src

5080

5081

# func_win32_import_lib_p ARG

5082

# True if ARG is an import lib, as indicated by $file_magic_cmd

5083

func_win32_import_lib_p ()

5084

{

5085

$opt_debug

5086

case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in

5087

*import*) : ;;

5088

*) false ;;

5089

esac

5090

}

5091

5092

# func_mode_link arg...

5093

func_mode_link ()

5094

{

5095

$opt_debug

5096

case $host in

5097

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

5098

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

5099

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

5100

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

5101

# flag for every libtool invocation.

5102

# allow_undefined=no

5103

5104

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

5105

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

5106

# even a static library is built. For now, we need to specify

5107

# -no-undefined on the libtool link line when we can be certain

5108

# that all symbols are satisfied, otherwise we get a static library.

5109

allow_undefined=yes

5110

;;

5111

*)

5112

allow_undefined=yes

5113

;;

5114

esac

5115

libtool_args=$nonopt

5116

base_compile="$nonopt $@"

5117

compile_command=$nonopt

5118

finalize_command=$nonopt

5119

5120

compile_rpath=

5121

finalize_rpath=

5122

compile_shlibpath=

5123

finalize_shlibpath=

5124

convenience=

5125

old_convenience=

5126

deplibs=

5127

old_deplibs=

5128

compiler_flags=

5129

linker_flags=

5130

dllsearchpath=

5131

lib_search_path=`pwd`

5132

inst_prefix_dir=

5133

new_inherited_linker_flags=

5134

5135

avoid_version=no

5136

bindir=

5137

dlfiles=

5138

dlprefiles=

5139

dlself=no

5140

export_dynamic=no

5141

export_symbols=

5142

export_symbols_regex=

5143

generated=

5144

libobjs=

5145

ltlibs=

5146

module=no

5147

no_install=no

5148

objs=

5149

non_pic_objects=

5150

precious_files_regex=

5151

prefer_static_libs=no

5152

preload=no

5153

prev=

5154

prevarg=

5155

release=

5156

rpath=

5157

xrpath=

5158

perm_rpath=

5159

temp_rpath=

5160

thread_safe=no

5161

vinfo=

5162

vinfo_number=no

5163

weak_libs=

5164

single_module="${wl}-single_module"

5165

func_infer_tag $base_compile

5166

5167

# We need to know -static, to get the right output filenames.

5168

for arg

5169

do

5170

case $arg in

5171

-shared)

5172

test "$build_libtool_libs" != yes && \

5173

func_fatal_configuration "can not build a shared library"

5174

build_old_libs=no

5175

break

5176

;;

5177

-all-static | -static | -static-libtool-libs)

5178

case $arg in

5179

-all-static)

5180

if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

5181

func_warning "complete static linking is impossible in this configuration"

5182

fi

5183

if test -n "$link_static_flag"; then

5184

dlopen_self=$dlopen_self_static

5185

fi

5186

prefer_static_libs=yes

5187

;;

5188

-static)

5189

if test -z "$pic_flag" && test -n "$link_static_flag"; then

5190

dlopen_self=$dlopen_self_static

5191

fi

5192

prefer_static_libs=built

5193

;;

5194

-static-libtool-libs)

5195

if test -z "$pic_flag" && test -n "$link_static_flag"; then

5196

dlopen_self=$dlopen_self_static

5197

fi

5198

prefer_static_libs=yes

5199

;;

5200

esac

5201

build_libtool_libs=no

5202

build_old_libs=yes

5203

break

5204

;;

5205

esac

5206

done

5207

5208

# See if our shared archives depend on static archives.

5209

test -n "$old_archive_from_new_cmds" && build_old_libs=yes

5210

5211

# Go through the arguments, transforming them on the way.

5212

while test "$#" -gt 0; do

5213

arg="$1"

5214

shift

5215

func_quote_for_eval "$arg"

5216

qarg=$func_quote_for_eval_unquoted_result

5217

func_append libtool_args " $func_quote_for_eval_result"

5218

5219

# If the previous option needs an argument, assign it.

5220

if test -n "$prev"; then

5221

case $prev in

5222

output)

5223

func_append compile_command " @OUTPUT@"

5224

func_append finalize_command " @OUTPUT@"

5225

;;

5226

esac

5227

5228

case $prev in

5229

bindir)

5230

bindir="$arg"

5231

prev=

5232

continue

5233

;;

5234

dlfiles|dlprefiles)

5235

if test "$preload" = no; then

5236

# Add the symbol object into the linking commands.

5237

func_append compile_command " @SYMFILE@"

5238

func_append finalize_command " @SYMFILE@"

5239

preload=yes

5240

fi

5241

case $arg in

5242

*.la | *.lo) ;; # We handle these cases below.

5243

force)

5244

if test "$dlself" = no; then

5245

dlself=needless

5246

export_dynamic=yes

5247

fi

5248

prev=

5249

continue

5250

;;

5251

self)

5252

if test "$prev" = dlprefiles; then

5253

dlself=yes

5254

elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

5255

dlself=yes

5256

else

5257

dlself=needless

5258

export_dynamic=yes

5259

fi

5260

prev=

5261

continue

5262

;;

5263

*)

5264

if test "$prev" = dlfiles; then

5265

func_append dlfiles " $arg"

5266

else

5267

func_append dlprefiles " $arg"

5268

fi

5269

prev=

5270

continue

5271

;;

5272

esac

5273

;;

5274

expsyms)

5275

export_symbols="$arg"

5276

test -f "$arg" \

5277

|| func_fatal_error "symbol file \`$arg' does not exist"

5278

prev=

5279

continue

5280

;;

5281

expsyms_regex)

5282

export_symbols_regex="$arg"

5283

prev=

5284

continue

5285

;;

5286

framework)

5287

case $host in

5288

*-*-darwin*)

5289

case "$deplibs " in

5290

*" $qarg.ltframework "*) ;;

5291

*) func_append deplibs " $qarg.ltframework" # this is fixed later

5292

;;

5293

esac

5294

;;

5295

esac

5296

prev=

5297

continue

5298

;;

5299

inst_prefix)

5300

inst_prefix_dir="$arg"

5301

prev=

5302

continue

5303

;;

5304

objectlist)

5305

if test -f "$arg"; then

5306

save_arg=$arg

5307

moreargs=

5308

for fil in `cat "$save_arg"`

5309

do

5310

# func_append moreargs " $fil"

5311

arg=$fil

5312

# A libtool-controlled object.

5313

5314

# Check to see that this really is a libtool object.

5315

if func_lalib_unsafe_p "$arg"; then

5316

pic_object=

5317

non_pic_object=

5318

5319

# Read the .lo file

5320

func_source "$arg"

5321

5322

if test -z "$pic_object" ||

5323

test -z "$non_pic_object" ||

5324

test "$pic_object" = none &&

5325

test "$non_pic_object" = none; then

5326

func_fatal_error "cannot find name of object for \`$arg'"

5327

fi

5328

5329

# Extract subdirectory from the argument.

5330

func_dirname "$arg" "/" ""

5331

xdir="$func_dirname_result"

5332

5333

if test "$pic_object" != none; then

5334

# Prepend the subdirectory the object is found in.

5335

pic_object="$xdir$pic_object"

5336

5337

if test "$prev" = dlfiles; then

5338

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

5339

func_append dlfiles " $pic_object"

5340

prev=

5341

continue

5342

else

5343

# If libtool objects are unsupported, then we need to preload.

5344

prev=dlprefiles

5345

fi

5346

fi

5347

5348

# CHECK ME: I think I busted this. -Ossama

5349

if test "$prev" = dlprefiles; then

5350

# Preload the old-style object.

5351

func_append dlprefiles " $pic_object"

5352

prev=

5353

fi

5354

5355

# A PIC object.

5356

func_append libobjs " $pic_object"

5357

arg="$pic_object"

5358

fi

5359

5360

# Non-PIC object.

5361

if test "$non_pic_object" != none; then

5362

# Prepend the subdirectory the object is found in.

5363

non_pic_object="$xdir$non_pic_object"

5364

5365

# A standard non-PIC object

5366

func_append non_pic_objects " $non_pic_object"

5367

if test -z "$pic_object" || test "$pic_object" = none ; then

5368

arg="$non_pic_object"

5369

fi

5370

else

5371

# If the PIC object exists, use it instead.

5372

# $xdir was prepended to $pic_object above.

5373

non_pic_object="$pic_object"

5374

func_append non_pic_objects " $non_pic_object"

5375

fi

5376

else

5377

# Only an error if not doing a dry-run.

5378

if $opt_dry_run; then

5379

# Extract subdirectory from the argument.

5380

func_dirname "$arg" "/" ""

5381

xdir="$func_dirname_result"

5382

5383

func_lo2o "$arg"

5384

pic_object=$xdir$objdir/$func_lo2o_result

5385

non_pic_object=$xdir$func_lo2o_result

5386

func_append libobjs " $pic_object"

5387

func_append non_pic_objects " $non_pic_object"

5388

else

5389

func_fatal_error "\`$arg' is not a valid libtool object"

5390

fi

5391

fi

5392

done

5393

else

5394

func_fatal_error "link input file \`$arg' does not exist"

5395

fi

5396

arg=$save_arg

5397

prev=

5398

continue

5399

;;

5400

precious_regex)

5401

precious_files_regex="$arg"

5402

prev=

5403

continue

5404

;;

5405

release)

5406

release="-$arg"

5407

prev=

5408

continue

5409

;;

5410

rpath | xrpath)

5411

# We need an absolute path.

5412

case $arg in

5413

[\\/]* | [A-Za-z]:[\\/]*) ;;

5414

*)

5415

func_fatal_error "only absolute run-paths are allowed"

5416

;;

5417

esac

5418

if test "$prev" = rpath; then

5419

case "$rpath " in

5420

*" $arg "*) ;;

5421

*) func_append rpath " $arg" ;;

5422

esac

5423

else

5424

case "$xrpath " in

5425

*" $arg "*) ;;

5426

*) func_append xrpath " $arg" ;;

5427

esac

5428

fi

5429

prev=

5430

continue

5431

;;

5432

shrext)

5433

shrext_cmds="$arg"

5434

prev=

5435

continue

5436

;;

5437

weak)

5438

func_append weak_libs " $arg"

5439

prev=

5440

continue

5441

;;

5442

xcclinker)

5443

func_append linker_flags " $qarg"

5444

func_append compiler_flags " $qarg"

5445

prev=

5446

func_append compile_command " $qarg"

5447

func_append finalize_command " $qarg"

5448

continue

5449

;;

5450

xcompiler)

5451

func_append compiler_flags " $qarg"

5452

prev=

5453

func_append compile_command " $qarg"

5454

func_append finalize_command " $qarg"

5455

continue

5456

;;

5457

xlinker)

5458

func_append linker_flags " $qarg"

5459

func_append compiler_flags " $wl$qarg"

5460

prev=

5461

func_append compile_command " $wl$qarg"

5462

func_append finalize_command " $wl$qarg"

5463

continue

5464

;;

5465

*)

5466

eval "$prev=\"\$arg\""

5467

prev=

5468

continue

5469

;;

5470

esac

5471

fi # test -n "$prev"

5472

5473

prevarg="$arg"

5474

5475

case $arg in

5476

-all-static)

5477

if test -n "$link_static_flag"; then

5478

# See comment for -static flag below, for more details.

5479

func_append compile_command " $link_static_flag"

5480

func_append finalize_command " $link_static_flag"

5481

fi

5482

continue

5483

;;

5484

5485

-allow-undefined)

5486

# FIXME: remove this flag sometime in the future.

5487

func_fatal_error "\`-allow-undefined' must not be used because it is the default"

5488

;;

5489

5490

-avoid-version)

5491

avoid_version=yes

5492

continue

5493

;;

5494

5495

-bindir)

5496

prev=bindir

5497

continue

5498

;;

5499

5500

-dlopen)

5501

prev=dlfiles

5502

continue

5503

;;

5504

5505

-dlpreopen)

5506

prev=dlprefiles

5507

continue

5508

;;

5509

5510

-export-dynamic)

5511

export_dynamic=yes

5512

continue

5513

;;

5514

5515

-export-symbols | -export-symbols-regex)

5516

if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

5517

func_fatal_error "more than one -exported-symbols argument is not allowed"

5518

fi

5519

if test "X$arg" = "X-export-symbols"; then

5520

prev=expsyms

5521

else

5522

prev=expsyms_regex

5523

fi

5524

continue

5525

;;

5526

5527

-framework)

5528

prev=framework

5529

continue

5530

;;

5531

5532

-inst-prefix-dir)

5533

prev=inst_prefix

5534

continue

5535

;;

5536

5537

# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*

5538

# so, if we see these flags be careful not to treat them like -L

5539

-L[A-Z][A-Z]*:*)

5540

case $with_gcc/$host in

5541

no/*-*-irix* | /*-*-irix*)

5542

func_append compile_command " $arg"

5543

func_append finalize_command " $arg"

5544

;;

5545

esac

5546

continue

5547

;;

5548

5549

-L*)

5550

func_stripname "-L" '' "$arg"

5551

if test -z "$func_stripname_result"; then

5552

if test "$#" -gt 0; then

5553

func_fatal_error "require no space between \`-L' and \`$1'"

5554

else

5555

func_fatal_error "need path for \`-L' option"

5556

fi

5557

fi

5558

func_resolve_sysroot "$func_stripname_result"

5559

dir=$func_resolve_sysroot_result

5560

# We need an absolute path.

5561

case $dir in

5562

[\\/]* | [A-Za-z]:[\\/]*) ;;

5563

*)

5564

absdir=`cd "$dir" && pwd`

5565

test -z "$absdir" && \

5566

func_fatal_error "cannot determine absolute directory name of \`$dir'"

5567

dir="$absdir"

5568

;;

5569

esac

5570

case "$deplibs " in

5571

*" -L$dir "* | *" $arg "*)

5572

# Will only happen for absolute or sysroot arguments

5573

;;

5574

*)

5575

# Preserve sysroot, but never include relative directories

5576

case $dir in

5577

[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;

5578

*) func_append deplibs " -L$dir" ;;

5579

esac

5580

func_append lib_search_path " $dir"

5581

;;

5582

esac

5583

case $host in

5584

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

5585

testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`

5586

case :$dllsearchpath: in

5587

*":$dir:"*) ;;

5588

::) dllsearchpath=$dir;;

5589

*) func_append dllsearchpath ":$dir";;

5590

esac

5591

case :$dllsearchpath: in

5592

*":$testbindir:"*) ;;

5593

::) dllsearchpath=$testbindir;;

5594

*) func_append dllsearchpath ":$testbindir";;

5595

esac

5596

;;

5597

esac

5598

continue

5599

;;

5600

5601

-l*)

5602

if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

5603

case $host in

5604

5605

# These systems don't actually have a C or math library (as such)

5606

continue

5607

;;

5608

*-*-os2*)

5609

# These systems don't actually have a C library (as such)

5610

test "X$arg" = "X-lc" && continue

5611

;;

5612

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

5613

# Do not include libc due to us having libc/libc_r.

5614

test "X$arg" = "X-lc" && continue

5615

;;

5616

*-*-rhapsody* | *-*-darwin1.[012])

5617

# Rhapsody C and math libraries are in the System framework

5618

func_append deplibs " System.ltframework"

5619

continue

5620

;;

5621

*-*-sco3.2v5* | *-*-sco5v6*)

5622

# Causes problems with __ctype

5623

test "X$arg" = "X-lc" && continue

5624

;;

5625

*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

5626

# Compiler inserts libc in the correct place for threads to work

5627

test "X$arg" = "X-lc" && continue

5628

;;

5629

esac

5630

elif test "X$arg" = "X-lc_r"; then

5631

case $host in

5632

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

5633

# Do not include libc_r directly, use -pthread flag.

5634

continue

5635

;;

5636

esac

5637

fi

5638

func_append deplibs " $arg"

5639

continue

5640

;;

5641

5642

-module)

5643

module=yes

5644

continue

5645

;;

5646

5647

# Tru64 UNIX uses -model [arg] to determine the layout of C++

5648

# classes, name mangling, and exception handling.

5649

# Darwin uses the -arch flag to determine output architecture.

5650

-model|-arch|-isysroot|--sysroot)

5651

func_append compiler_flags " $arg"

5652

func_append compile_command " $arg"

5653

func_append finalize_command " $arg"

5654

prev=xcompiler

5655

continue

5656

;;

5657

5658

5659

5660

func_append compiler_flags " $arg"

5661

func_append compile_command " $arg"

5662

func_append finalize_command " $arg"

5663

case "$new_inherited_linker_flags " in

5664

*" $arg "*) ;;

5665

* ) func_append new_inherited_linker_flags " $arg" ;;

5666

esac

5667

continue

5668

;;

5669

5670

-multi_module)

5671

single_module="${wl}-multi_module"

5672

continue

5673

;;

5674

5675

-no-fast-install)

5676

fast_install=no

5677

continue

5678

;;

5679

5680

-no-install)

5681

case $host in

5682

5683

# The PATH hackery in wrapper scripts is required on Windows

5684

# and Darwin in order for the loader to find any dlls it needs.

5685

func_warning "\`-no-install' is ignored for $host"

5686

func_warning "assuming \`-no-fast-install' instead"

5687

fast_install=no

5688

;;

5689

*) no_install=yes ;;

5690

esac

5691

continue

5692

;;

5693

5694

-no-undefined)

5695

allow_undefined=no

5696

continue

5697

;;

5698

5699

-objectlist)

5700

prev=objectlist

5701

continue

5702

;;

5703

5704

-o) prev=output ;;

5705

5706

-precious-files-regex)

5707

prev=precious_regex

5708

continue

5709

;;

5710

5711

-release)

5712

prev=release

5713

continue

5714

;;

5715

5716

-rpath)

5717

prev=rpath

5718

continue

5719

;;

5720

5721

-R)

5722

prev=xrpath

5723

continue

5724

;;

5725

5726

-R*)

5727

func_stripname '-R' '' "$arg"

5728

dir=$func_stripname_result

5729

# We need an absolute path.

5730

case $dir in

5731

[\\/]* | [A-Za-z]:[\\/]*) ;;

5732

=*)

5733

func_stripname '=' '' "$dir"

5734

dir=$lt_sysroot$func_stripname_result

5735

;;

5736

*)

5737

func_fatal_error "only absolute run-paths are allowed"

5738

;;

5739

esac

5740

case "$xrpath " in

5741

*" $dir "*) ;;

5742

*) func_append xrpath " $dir" ;;

5743

esac

5744

continue

5745

;;

5746

5747

-shared)

5748

# The effects of -shared are defined in a previous loop.

5749

continue

5750

;;

5751

5752

-shrext)

5753

prev=shrext

5754

continue

5755

;;

5756

5757

-static | -static-libtool-libs)

5758

# The effects of -static are defined in a previous loop.

5759

# We used to do the same as -all-static on platforms that

5760

# didn't have a PIC flag, but the assumption that the effects

5761

# would be equivalent was wrong. It would break on at least

5762

# Digital Unix and AIX.

5763

continue

5764

;;

5765

5766

-thread-safe)

5767

thread_safe=yes

5768

continue

5769

;;

5770

5771

-version-info)

5772

prev=vinfo

5773

continue

5774

;;

5775

5776

-version-number)

5777

prev=vinfo

5778

vinfo_number=yes

5779

continue

5780

;;

5781

5782

-weak)

5783

prev=weak

5784

continue

5785

;;

5786

5787

-Wc,*)

5788

func_stripname '-Wc,' '' "$arg"

5789

args=$func_stripname_result

5790

arg=

5791

save_ifs="$IFS"; IFS=','

5792

for flag in $args; do

5793

IFS="$save_ifs"

5794

func_quote_for_eval "$flag"

5795

func_append arg " $func_quote_for_eval_result"

5796

func_append compiler_flags " $func_quote_for_eval_result"

5797

done

5798

IFS="$save_ifs"

5799

func_stripname ' ' '' "$arg"

5800

arg=$func_stripname_result

5801

;;

5802

5803

-Wl,*)

5804

func_stripname '-Wl,' '' "$arg"

5805

args=$func_stripname_result

5806

arg=

5807

save_ifs="$IFS"; IFS=','

5808

for flag in $args; do

5809

IFS="$save_ifs"

5810

func_quote_for_eval "$flag"

5811

func_append arg " $wl$func_quote_for_eval_result"

5812

func_append compiler_flags " $wl$func_quote_for_eval_result"

5813

func_append linker_flags " $func_quote_for_eval_result"

5814

done

5815

IFS="$save_ifs"

5816

func_stripname ' ' '' "$arg"

5817

arg=$func_stripname_result

5818

;;

5819

5820

-Xcompiler)

5821

prev=xcompiler

5822

continue

5823

;;

5824

5825

-Xlinker)

5826

prev=xlinker

5827

continue

5828

;;

5829

5830

-XCClinker)

5831

prev=xcclinker

5832

continue

5833

;;

5834

5835

# -msg_* for osf cc

5836

-msg_*)

5837

func_quote_for_eval "$arg"

5838

arg="$func_quote_for_eval_result"

5839

;;

5840

5841

# Flags to be passed through unchanged, with rationale:

5842

# -64, -mips[0-9] enable 64-bit mode for the SGI compiler

5843

# -r[0-9][0-9]* specify processor for the SGI compiler

5844

# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler

5845

# +DA*, +DD* enable 64-bit mode for the HP compiler

5846

# -q* compiler args for the IBM compiler

5847

# -m*, -t[45]*, -txscale* architecture-specific flags for GCC

5848

# -F/path path to uninstalled frameworks, gcc on darwin

5849

# -p, -pg, --coverage, -fprofile-* profiling flags for GCC

5850

# @file GCC response files

5851

# -tp=* Portland pgcc target processor selection

5852

# --sysroot=* for sysroot support

5853

# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

5854

-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \

5855

-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \

5856

-O*|-flto*|-fwhopr*|-fuse-linker-plugin)

5857

func_quote_for_eval "$arg"

5858

arg="$func_quote_for_eval_result"

5859

func_append compile_command " $arg"

5860

func_append finalize_command " $arg"

5861

func_append compiler_flags " $arg"

5862

continue

5863

;;

5864

5865

# Some other compiler flag.

5866

-* | +*)

5867

func_quote_for_eval "$arg"

5868

arg="$func_quote_for_eval_result"

5869

;;

5870

5871

*.$objext)

5872

# A standard object.

5873

func_append objs " $arg"

5874

;;

5875

5876

*.lo)

5877

# A libtool-controlled object.

5878

5879

# Check to see that this really is a libtool object.

5880

if func_lalib_unsafe_p "$arg"; then

5881

pic_object=

5882

non_pic_object=

5883

5884

# Read the .lo file

5885

func_source "$arg"

5886

5887

if test -z "$pic_object" ||

5888

test -z "$non_pic_object" ||

5889

test "$pic_object" = none &&

5890

test "$non_pic_object" = none; then

5891

func_fatal_error "cannot find name of object for \`$arg'"

5892

fi

5893

5894

# Extract subdirectory from the argument.

5895

func_dirname "$arg" "/" ""

5896

xdir="$func_dirname_result"

5897

5898

if test "$pic_object" != none; then

5899

# Prepend the subdirectory the object is found in.

5900

pic_object="$xdir$pic_object"

5901

5902

if test "$prev" = dlfiles; then

5903

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

5904

func_append dlfiles " $pic_object"

5905

prev=

5906

continue

5907

else

5908

# If libtool objects are unsupported, then we need to preload.

5909

prev=dlprefiles

5910

fi

5911

fi

5912

5913

# CHECK ME: I think I busted this. -Ossama

5914

if test "$prev" = dlprefiles; then

5915

# Preload the old-style object.

5916

func_append dlprefiles " $pic_object"

5917

prev=

5918

fi

5919

5920

# A PIC object.

5921

func_append libobjs " $pic_object"

5922

arg="$pic_object"

5923

fi

5924

5925

# Non-PIC object.

5926

if test "$non_pic_object" != none; then

5927

# Prepend the subdirectory the object is found in.

5928

non_pic_object="$xdir$non_pic_object"

5929

5930

# A standard non-PIC object

5931

func_append non_pic_objects " $non_pic_object"

5932

if test -z "$pic_object" || test "$pic_object" = none ; then

5933

arg="$non_pic_object"

5934

fi

5935

else

5936

# If the PIC object exists, use it instead.

5937

# $xdir was prepended to $pic_object above.

5938

non_pic_object="$pic_object"

5939

func_append non_pic_objects " $non_pic_object"

5940

fi

5941

else

5942

# Only an error if not doing a dry-run.

5943

if $opt_dry_run; then

5944

# Extract subdirectory from the argument.

5945

func_dirname "$arg" "/" ""

5946

xdir="$func_dirname_result"

5947

5948

func_lo2o "$arg"

5949

pic_object=$xdir$objdir/$func_lo2o_result

5950

non_pic_object=$xdir$func_lo2o_result

5951

func_append libobjs " $pic_object"

5952

func_append non_pic_objects " $non_pic_object"

5953

else

5954

func_fatal_error "\`$arg' is not a valid libtool object"

5955

fi

5956

fi

5957

;;

5958

5959

*.$libext)

5960

# An archive.

5961

func_append deplibs " $arg"

5962

func_append old_deplibs " $arg"

5963

continue

5964

;;

5965

5966

*.la)

5967

# A libtool-controlled library.

5968

5969

func_resolve_sysroot "$arg"

5970

if test "$prev" = dlfiles; then

5971

# This library was specified with -dlopen.

5972

func_append dlfiles " $func_resolve_sysroot_result"

5973

prev=

5974

elif test "$prev" = dlprefiles; then

5975

# The library was specified with -dlpreopen.

5976

func_append dlprefiles " $func_resolve_sysroot_result"

5977

prev=

5978

else

5979

func_append deplibs " $func_resolve_sysroot_result"

5980

fi

5981

continue

5982

;;

5983

5984

# Some other compiler argument.

5985

*)

5986

# Unknown arguments in both finalize_command and compile_command need

5987

# to be aesthetically quoted because they are evaled later.

5988

func_quote_for_eval "$arg"

5989

arg="$func_quote_for_eval_result"

5990

;;

5991

esac # arg

5992

5993

# Now actually substitute the argument into the commands.

5994

if test -n "$arg"; then

5995

func_append compile_command " $arg"

5996

func_append finalize_command " $arg"

5997

fi

5998

done # argument parsing loop

5999

6000

test -n "$prev" && \

6001

func_fatal_help "the \`$prevarg' option requires an argument"

6002

6003

if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

6004

eval arg=\"$export_dynamic_flag_spec\"

6005

func_append compile_command " $arg"

6006

func_append finalize_command " $arg"

6007

fi

6008

6009

oldlibs=

6010

# calculate the name of the file, without its directory

6011

func_basename "$output"

6012

outputname="$func_basename_result"

6013

libobjs_save="$libobjs"

6014

6015

if test -n "$shlibpath_var"; then

6016

# get the directories listed in $shlibpath_var

6017

eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`

6018

else

6019

shlib_search_path=

6020

fi

6021

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

6022

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

6023

6024

func_dirname "$output" "/" ""

6025

output_objdir="$func_dirname_result$objdir"

6026

func_to_tool_file "$output_objdir/"

6027

tool_output_objdir=$func_to_tool_file_result

6028

# Create the object directory.

6029

func_mkdir_p "$output_objdir"

6030

6031

# Determine the type of output

6032

case $output in

6033

"")

6034

func_fatal_help "you must specify an output file"

6035

;;

6036

*.$libext) linkmode=oldlib ;;

6037

*.lo | *.$objext) linkmode=obj ;;

6038

*.la) linkmode=lib ;;

6039

*) linkmode=prog ;; # Anything else should be a program.

6040

esac

6041

6042

specialdeplibs=

6043

6044

libs=

6045

# Find all interdependent deplibs by searching for libraries

6046

# that are linked more than once (e.g. -la -lb -la)

6047

for deplib in $deplibs; do

6048

if $opt_preserve_dup_deps ; then

6049

case "$libs " in

6050

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6051

esac

6052

fi

6053

func_append libs " $deplib"

6054

done

6055

6056

if test "$linkmode" = lib; then

6057

libs="$predeps $libs $compiler_lib_search_path $postdeps"

6058

6059

# Compute libraries that are listed more than once in $predeps

6060

# $postdeps and mark them as special (i.e., whose duplicates are

6061

# not to be eliminated).

6062

pre_post_deps=

6063

if $opt_duplicate_compiler_generated_deps; then

6064

for pre_post_dep in $predeps $postdeps; do

6065

case "$pre_post_deps " in

6066

*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;

6067

esac

6068

func_append pre_post_deps " $pre_post_dep"

6069

done

6070

fi

6071

pre_post_deps=

6072

fi

6073

6074

deplibs=

6075

newdependency_libs=

6076

newlib_search_path=

6077

need_relink=no # whether we're linking any uninstalled libtool libraries

6078

notinst_deplibs= # not-installed libtool libraries

6079

notinst_path= # paths that contain not-installed libtool libraries

6080

6081

case $linkmode in

6082

lib)

6083

passes="conv dlpreopen link"

6084

for file in $dlfiles $dlprefiles; do

6085

case $file in

6086

*.la) ;;

6087

*)

6088

func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"

6089

;;

6090

esac

6091

done

6092

;;

6093

prog)

6094

compile_deplibs=

6095

finalize_deplibs=

6096

alldeplibs=no

6097

newdlfiles=

6098

newdlprefiles=

6099

passes="conv scan dlopen dlpreopen link"

6100

;;

6101

*) passes="conv"

6102

;;

6103

esac

6104

6105

for pass in $passes; do

6106

# The preopen pass in lib mode reverses $deplibs; put it back here

6107

# so that -L comes before libs that need it for instance...

6108

if test "$linkmode,$pass" = "lib,link"; then

6109

## FIXME: Find the place where the list is rebuilt in the wrong

6110

## order, and fix it there properly

6111

tmp_deplibs=

6112

for deplib in $deplibs; do

6113

tmp_deplibs="$deplib $tmp_deplibs"

6114

done

6115

deplibs="$tmp_deplibs"

6116

fi

6117

6118

if test "$linkmode,$pass" = "lib,link" ||

6119

test "$linkmode,$pass" = "prog,scan"; then

6120

libs="$deplibs"

6121

deplibs=

6122

fi

6123

if test "$linkmode" = prog; then

6124

case $pass in

6125

dlopen) libs="$dlfiles" ;;

6126

dlpreopen) libs="$dlprefiles" ;;

6127

link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

6128

esac

6129

fi

6130

if test "$linkmode,$pass" = "lib,dlpreopen"; then

6131

# Collect and forward deplibs of preopened libtool libs

6132

for lib in $dlprefiles; do

6133

# Ignore non-libtool-libs

6134

dependency_libs=

6135

func_resolve_sysroot "$lib"

6136

case $lib in

6137

*.la) func_source "$func_resolve_sysroot_result" ;;

6138

esac

6139

6140

# Collect preopened libtool deplibs, except any this library

6141

# has declared as weak libs

6142

for deplib in $dependency_libs; do

6143

func_basename "$deplib"

6144

deplib_base=$func_basename_result

6145

case " $weak_libs " in

6146

*" $deplib_base "*) ;;

6147

*) func_append deplibs " $deplib" ;;

6148

esac

6149

done

6150

done

6151

libs="$dlprefiles"

6152

fi

6153

if test "$pass" = dlopen; then

6154

# Collect dlpreopened libraries

6155

save_deplibs="$deplibs"

6156

deplibs=

6157

fi

6158

6159

for deplib in $libs; do

6160

lib=

6161

found=no

6162

case $deplib in

6163

6164

6165

if test "$linkmode,$pass" = "prog,link"; then

6166

compile_deplibs="$deplib $compile_deplibs"

6167

finalize_deplibs="$deplib $finalize_deplibs"

6168

else

6169

func_append compiler_flags " $deplib"

6170

if test "$linkmode" = lib ; then

6171

case "$new_inherited_linker_flags " in

6172

*" $deplib "*) ;;

6173

* ) func_append new_inherited_linker_flags " $deplib" ;;

6174

esac

6175

fi

6176

fi

6177

continue

6178

;;

6179

-l*)

6180

if test "$linkmode" != lib && test "$linkmode" != prog; then

6181

func_warning "\`-l' is ignored for archives/objects"

6182

continue

6183

fi

6184

func_stripname '-l' '' "$deplib"

6185

name=$func_stripname_result

6186

if test "$linkmode" = lib; then

6187

searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"

6188

else

6189

searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"

6190

fi

6191

for searchdir in $searchdirs; do

6192

for search_ext in .la $std_shrext .so .a; do

6193

# Search the libtool library

6194

lib="$searchdir/lib${name}${search_ext}"

6195

if test -f "$lib"; then

6196

if test "$search_ext" = ".la"; then

6197

found=yes

6198

else

6199

found=no

6200

fi

6201

break 2

6202

fi

6203

done

6204

done

6205

if test "$found" != yes; then

6206

# deplib doesn't seem to be a libtool library

6207

if test "$linkmode,$pass" = "prog,link"; then

6208

compile_deplibs="$deplib $compile_deplibs"

6209

finalize_deplibs="$deplib $finalize_deplibs"

6210

else

6211

deplibs="$deplib $deplibs"

6212

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6213

fi

6214

continue

6215

else # deplib is a libtool library

6216

# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

6217

# We need to do some special things here, and not later.

6218

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

6219

case " $predeps $postdeps " in

6220

*" $deplib "*)

6221

if func_lalib_p "$lib"; then

6222

library_names=

6223

old_library=

6224

func_source "$lib"

6225

for l in $old_library $library_names; do

6226

ll="$l"

6227

done

6228

if test "X$ll" = "X$old_library" ; then # only static version available

6229

found=no

6230

func_dirname "$lib" "" "."

6231

ladir="$func_dirname_result"

6232

lib=$ladir/$old_library

6233

if test "$linkmode,$pass" = "prog,link"; then

6234

compile_deplibs="$deplib $compile_deplibs"

6235

finalize_deplibs="$deplib $finalize_deplibs"

6236

else

6237

deplibs="$deplib $deplibs"

6238

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

6239

fi

6240

continue

6241

fi

6242

fi

6243

;;

6244

*) ;;

6245

esac

6246

fi

6247

fi

6248

;; # -l

6249

*.ltframework)

6250

if test "$linkmode,$pass" = "prog,link"; then

6251

compile_deplibs="$deplib $compile_deplibs"

6252

finalize_deplibs="$deplib $finalize_deplibs"

6253

else

6254

deplibs="$deplib $deplibs"

6255

if test "$linkmode" = lib ; then

6256

case "$new_inherited_linker_flags " in

6257

*" $deplib "*) ;;

6258

* ) func_append new_inherited_linker_flags " $deplib" ;;

6259

esac

6260

fi

6261

fi

6262

continue

6263

;;

6264

-L*)

6265

case $linkmode in

6266

lib)

6267

deplibs="$deplib $deplibs"

6268

test "$pass" = conv && continue

6269

newdependency_libs="$deplib $newdependency_libs"

6270

func_stripname '-L' '' "$deplib"

6271

func_resolve_sysroot "$func_stripname_result"

6272

func_append newlib_search_path " $func_resolve_sysroot_result"

6273

;;

6274

prog)

6275

if test "$pass" = conv; then

6276

deplibs="$deplib $deplibs"

6277

continue

6278

fi

6279

if test "$pass" = scan; then

6280

deplibs="$deplib $deplibs"

6281

else

6282

compile_deplibs="$deplib $compile_deplibs"

6283

finalize_deplibs="$deplib $finalize_deplibs"

6284

fi

6285

func_stripname '-L' '' "$deplib"

6286

func_resolve_sysroot "$func_stripname_result"

6287

func_append newlib_search_path " $func_resolve_sysroot_result"

6288

;;

6289

*)

6290

func_warning "\`-L' is ignored for archives/objects"

6291

;;

6292

esac # linkmode

6293

continue

6294

;; # -L

6295

-R*)

6296

if test "$pass" = link; then

6297

func_stripname '-R' '' "$deplib"

6298

func_resolve_sysroot "$func_stripname_result"

6299

dir=$func_resolve_sysroot_result

6300

# Make sure the xrpath contains only unique directories.

6301

case "$xrpath " in

6302

*" $dir "*) ;;

6303

*) func_append xrpath " $dir" ;;

6304

esac

6305

fi

6306

deplibs="$deplib $deplibs"

6307

continue

6308

;;

6309

*.la)

6310

func_resolve_sysroot "$deplib"

6311

lib=$func_resolve_sysroot_result

6312

;;

6313

*.$libext)

6314

if test "$pass" = conv; then

6315

deplibs="$deplib $deplibs"

6316

continue

6317

fi

6318

case $linkmode in

6319

lib)

6320

# Linking convenience modules into shared libraries is allowed,

6321

# but linking other static libraries is non-portable.

6322

case " $dlpreconveniencelibs " in

6323

*" $deplib "*) ;;

6324

*)

6325

valid_a_lib=no

6326

case $deplibs_check_method in

6327

match_pattern*)

6328

set dummy $deplibs_check_method; shift

6329

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

6330

if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \

6331

| $EGREP "$match_pattern_regex" > /dev/null; then

6332

valid_a_lib=yes

6333

fi

6334

;;

6335

pass_all)

6336

valid_a_lib=yes

6337

;;

6338

esac

6339

if test "$valid_a_lib" != yes; then

6340

echo

6341

$ECHO "*** Warning: Trying to link with static lib archive $deplib."

6342

echo "*** I have the capability to make that library automatically link in when"

6343

echo "*** you link to this library. But I can only do this if you have a"

6344

echo "*** shared version of the library, which you do not appear to have"

6345

echo "*** because the file extensions .$libext of this argument makes me believe"

6346

echo "*** that it is just a static archive that I should not use here."

6347

else

6348

echo

6349

$ECHO "*** Warning: Linking the shared library $output against the"

6350

$ECHO "*** static library $deplib is not portable!"

6351

deplibs="$deplib $deplibs"

6352

fi

6353

;;

6354

esac

6355

continue

6356

;;

6357

prog)

6358

if test "$pass" != link; then

6359

deplibs="$deplib $deplibs"

6360

else

6361

compile_deplibs="$deplib $compile_deplibs"

6362

finalize_deplibs="$deplib $finalize_deplibs"

6363

fi

6364

continue

6365

;;

6366

esac # linkmode

6367

;; # *.$libext

6368

*.lo | *.$objext)

6369

if test "$pass" = conv; then

6370

deplibs="$deplib $deplibs"

6371

elif test "$linkmode" = prog; then

6372

if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

6373

# If there is no dlopen support or we're linking statically,

6374

# we need to preload.

6375

func_append newdlprefiles " $deplib"

6376

compile_deplibs="$deplib $compile_deplibs"

6377

finalize_deplibs="$deplib $finalize_deplibs"

6378

else

6379

func_append newdlfiles " $deplib"

6380

fi

6381

fi

6382

continue

6383

;;

6384

%DEPLIBS%)

6385

alldeplibs=yes

6386

continue

6387

;;

6388

esac # case $deplib

6389

6390

if test "$found" = yes || test -f "$lib"; then :

6391

else

6392

func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

6393

fi

6394

6395

# Check to see that this really is a libtool archive.

6396

func_lalib_unsafe_p "$lib" \

6397

|| func_fatal_error "\`$lib' is not a valid libtool archive"

6398

6399

func_dirname "$lib" "" "."

6400

ladir="$func_dirname_result"

6401

6402

dlname=

6403

dlopen=

6404

dlpreopen=

6405

libdir=

6406

library_names=

6407

old_library=

6408

inherited_linker_flags=

6409

# If the library was installed with an old release of libtool,

6410

# it will not redefine variables installed, or shouldnotlink

6411

installed=yes

6412

shouldnotlink=no

6413

avoidtemprpath=

6414

6415

6416

# Read the .la file

6417

func_source "$lib"

6418

6419

# Convert "-framework foo" to "foo.ltframework"

6420

if test -n "$inherited_linker_flags"; then

6421

tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $[^ $]*$/\1.ltframework/g'`

6422

for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

6423

case " $new_inherited_linker_flags " in

6424

*" $tmp_inherited_linker_flag "*) ;;

6425

*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;

6426

esac

6427

done

6428

fi

6429

dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6430

if test "$linkmode,$pass" = "lib,link" ||

6431

test "$linkmode,$pass" = "prog,scan" ||

6432

{ test "$linkmode" != prog && test "$linkmode" != lib; }; then

6433

test -n "$dlopen" && func_append dlfiles " $dlopen"

6434

test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"

6435

fi

6436

6437

if test "$pass" = conv; then

6438

# Only check for convenience libraries

6439

deplibs="$lib $deplibs"

6440

if test -z "$libdir"; then

6441

if test -z "$old_library"; then

6442

func_fatal_error "cannot find name of link library for \`$lib'"

6443

fi

6444

# It is a libtool convenience library, so add in its objects.

6445

func_append convenience " $ladir/$objdir/$old_library"

6446

func_append old_convenience " $ladir/$objdir/$old_library"

6447

elif test "$linkmode" != prog && test "$linkmode" != lib; then

6448

func_fatal_error "\`$lib' is not a convenience library"

6449

fi

6450

tmp_libs=

6451

for deplib in $dependency_libs; do

6452

deplibs="$deplib $deplibs"

6453

if $opt_preserve_dup_deps ; then

6454

case "$tmp_libs " in

6455

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6456

esac

6457

fi

6458

func_append tmp_libs " $deplib"

6459

done

6460

continue

6461

fi # $pass = conv

6462

6463

6464

# Get the name of the library we link against.

6465

linklib=

6466

if test -n "$old_library" &&

6467

{ test "$prefer_static_libs" = yes ||

6468

test "$prefer_static_libs,$installed" = "built,no"; }; then

6469

linklib=$old_library

6470

else

6471

for l in $old_library $library_names; do

6472

linklib="$l"

6473

done

6474

fi

6475

if test -z "$linklib"; then

6476

func_fatal_error "cannot find name of link library for \`$lib'"

6477

fi

6478

6479

# This library was specified with -dlopen.

6480

if test "$pass" = dlopen; then

6481

if test -z "$libdir"; then

6482

func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

6483

fi

6484

if test -z "$dlname" ||

6485

test "$dlopen_support" != yes ||

6486

test "$build_libtool_libs" = no; then

6487

# If there is no dlname, no dlopen support or we're linking

6488

# statically, we need to preload. We also need to preload any

6489

# dependent libraries so libltdl's deplib preloader doesn't

6490

# bomb out in the load deplibs phase.

6491

func_append dlprefiles " $lib $dependency_libs"

6492

else

6493

func_append newdlfiles " $lib"

6494

fi

6495

continue

6496

fi # $pass = dlopen

6497

6498

# We need an absolute path.

6499

case $ladir in

6500

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

6501

*)

6502

abs_ladir=`cd "$ladir" && pwd`

6503

if test -z "$abs_ladir"; then

6504

func_warning "cannot determine absolute directory name of \`$ladir'"

6505

func_warning "passing it literally to the linker, although it might fail"

6506

abs_ladir="$ladir"

6507

fi

6508

;;

6509

esac

6510

func_basename "$lib"

6511

laname="$func_basename_result"

6512

6513

# Find the relevant object directory and library name.

6514

if test "X$installed" = Xyes; then

6515

if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6516

func_warning "library \`$lib' was moved."

6517

dir="$ladir"

6518

absdir="$abs_ladir"

6519

libdir="$abs_ladir"

6520

else

6521

dir="$lt_sysroot$libdir"

6522

absdir="$lt_sysroot$libdir"

6523

fi

6524

test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

6525

else

6526

if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

6527

dir="$ladir"

6528

absdir="$abs_ladir"

6529

# Remove this search path later

6530

func_append notinst_path " $abs_ladir"

6531

else

6532

dir="$ladir/$objdir"

6533

absdir="$abs_ladir/$objdir"

6534

# Remove this search path later

6535

func_append notinst_path " $abs_ladir"

6536

fi

6537

fi # $installed = yes

6538

func_stripname 'lib' '.la' "$laname"

6539

name=$func_stripname_result

6540

6541

# This library was specified with -dlpreopen.

6542

if test "$pass" = dlpreopen; then

6543

if test -z "$libdir" && test "$linkmode" = prog; then

6544

func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

6545

fi

6546

case "$host" in

6547

# special handling for platforms with PE-DLLs.

6548

*cygwin* | *mingw* | *cegcc* )

6549

# Linker will automatically link against shared library if both

6550

# static and shared are present. Therefore, ensure we extract

6551

# symbols from the import library if a shared library is present

6552

# (otherwise, the dlopen module name will be incorrect). We do

6553

# this by putting the import library name into $newdlprefiles.

6554

# We recover the dlopen module name by 'saving' the la file

6555

# name in a special purpose variable, and (later) extracting the

6556

# dlname from the la file.

6557

if test -n "$dlname"; then

6558

func_tr_sh "$dir/$linklib"

6559

eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"

6560

func_append newdlprefiles " $dir/$linklib"

6561

else

6562

func_append newdlprefiles " $dir/$old_library"

6563

# Keep a list of preopened convenience libraries to check

6564

# that they are being used correctly in the link pass.

6565

test -z "$libdir" && \

6566

func_append dlpreconveniencelibs " $dir/$old_library"

6567

fi

6568

;;

6569

* )

6570

# Prefer using a static library (so that no silly _DYNAMIC symbols

6571

# are required to link).

6572

if test -n "$old_library"; then

6573

func_append newdlprefiles " $dir/$old_library"

6574

# Keep a list of preopened convenience libraries to check

6575

# that they are being used correctly in the link pass.

6576

test -z "$libdir" && \

6577

func_append dlpreconveniencelibs " $dir/$old_library"

6578

# Otherwise, use the dlname, so that lt_dlopen finds it.

6579

elif test -n "$dlname"; then

6580

func_append newdlprefiles " $dir/$dlname"

6581

else

6582

func_append newdlprefiles " $dir/$linklib"

6583

fi

6584

;;

6585

esac

6586

fi # $pass = dlpreopen

6587

6588

if test -z "$libdir"; then

6589

# Link the convenience library

6590

if test "$linkmode" = lib; then

6591

deplibs="$dir/$old_library $deplibs"

6592

elif test "$linkmode,$pass" = "prog,link"; then

6593

compile_deplibs="$dir/$old_library $compile_deplibs"

6594

finalize_deplibs="$dir/$old_library $finalize_deplibs"

6595

else

6596

deplibs="$lib $deplibs" # used for prog,scan pass

6597

fi

6598

continue

6599

fi

6600

6601

6602

if test "$linkmode" = prog && test "$pass" != link; then

6603

func_append newlib_search_path " $ladir"

6604

deplibs="$lib $deplibs"

6605

6606

linkalldeplibs=no

6607

if test "$link_all_deplibs" != no || test -z "$library_names" ||

6608

test "$build_libtool_libs" = no; then

6609

linkalldeplibs=yes

6610

fi

6611

6612

tmp_libs=

6613

for deplib in $dependency_libs; do

6614

case $deplib in

6615

-L*) func_stripname '-L' '' "$deplib"

6616

func_resolve_sysroot "$func_stripname_result"

6617

func_append newlib_search_path " $func_resolve_sysroot_result"

6618

;;

6619

esac

6620

# Need to link against all dependency_libs?

6621

if test "$linkalldeplibs" = yes; then

6622

deplibs="$deplib $deplibs"

6623

else

6624

# Need to hardcode shared library paths

6625

# or/and link against static libraries

6626

newdependency_libs="$deplib $newdependency_libs"

6627

fi

6628

if $opt_preserve_dup_deps ; then

6629

case "$tmp_libs " in

6630

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

6631

esac

6632

fi

6633

func_append tmp_libs " $deplib"

6634

done # for deplib

6635

continue

6636

fi # $linkmode = prog...

6637

6638

if test "$linkmode,$pass" = "prog,link"; then

6639

if test -n "$library_names" &&

6640

{ { test "$prefer_static_libs" = no ||

6641

test "$prefer_static_libs,$installed" = "built,yes"; } ||

6642

test -z "$old_library"; }; then

6643

# We need to hardcode the library path

6644

if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

6645

# Make sure the rpath contains only unique directories.

6646

case "$temp_rpath:" in

6647

*"$absdir:"*) ;;

6648

*) func_append temp_rpath "$absdir:" ;;

6649

esac

6650

fi

6651

6652

# Hardcode the library path.

6653

# Skip directories that are in the system default run-time

6654

# search path.

6655

case " $sys_lib_dlsearch_path " in

6656

*" $absdir "*) ;;

6657

*)

6658

case "$compile_rpath " in

6659

*" $absdir "*) ;;

6660

*) func_append compile_rpath " $absdir" ;;

6661

esac

6662

;;

6663

esac

6664

case " $sys_lib_dlsearch_path " in

6665

*" $libdir "*) ;;

6666

*)

6667

case "$finalize_rpath " in

6668

*" $libdir "*) ;;

6669

*) func_append finalize_rpath " $libdir" ;;

6670

esac

6671

;;

6672

esac

6673

fi # $linkmode,$pass = prog,link...

6674

6675

if test "$alldeplibs" = yes &&

6676

{ test "$deplibs_check_method" = pass_all ||

6677

{ test "$build_libtool_libs" = yes &&

6678

test -n "$library_names"; }; }; then

6679

# We only need to search for static libraries

6680

continue

6681

fi

6682

fi

6683

6684

link_static=no # Whether the deplib will be linked statically

6685

use_static_libs=$prefer_static_libs

6686

if test "$use_static_libs" = built && test "$installed" = yes; then

6687

use_static_libs=no

6688

fi

6689

if test -n "$library_names" &&

6690

{ test "$use_static_libs" = no || test -z "$old_library"; }; then

6691

case $host in

6692

*cygwin* | *mingw* | *cegcc*)

6693

# No point in relinking DLLs because paths are not encoded

6694

func_append notinst_deplibs " $lib"

6695

need_relink=no

6696

;;

6697

*)

6698

if test "$installed" = no; then

6699

func_append notinst_deplibs " $lib"

6700

need_relink=yes

6701

fi

6702

;;

6703

esac

6704

# This is a shared library

6705

6706

# Warn about portability, can't link against -module's on some

6707

# systems (darwin). Don't bleat about dlopened modules though!

6708

dlopenmodule=""

6709

for dlpremoduletest in $dlprefiles; do

6710

if test "X$dlpremoduletest" = "X$lib"; then

6711

dlopenmodule="$dlpremoduletest"

6712

break

6713

fi

6714

done

6715

if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

6716

echo

6717

if test "$linkmode" = prog; then

6718

$ECHO "*** Warning: Linking the executable $output against the loadable module"

6719

else

6720

$ECHO "*** Warning: Linking the shared library $output against the loadable module"

6721

fi

6722

$ECHO "*** $linklib is not portable!"

6723

fi

6724

if test "$linkmode" = lib &&

6725

test "$hardcode_into_libs" = yes; then

6726

# Hardcode the library path.

6727

# Skip directories that are in the system default run-time

6728

# search path.

6729

case " $sys_lib_dlsearch_path " in

6730

*" $absdir "*) ;;

6731

*)

6732

case "$compile_rpath " in

6733

*" $absdir "*) ;;

6734

*) func_append compile_rpath " $absdir" ;;

6735

esac

6736

;;

6737

esac

6738

case " $sys_lib_dlsearch_path " in

6739

*" $libdir "*) ;;

6740

*)

6741

case "$finalize_rpath " in

6742

*" $libdir "*) ;;

6743

*) func_append finalize_rpath " $libdir" ;;

6744

esac

6745

;;

6746

esac

6747

fi

6748

6749

if test -n "$old_archive_from_expsyms_cmds"; then

6750

# figure out the soname

6751

set dummy $library_names

6752

shift

6753

realname="$1"

6754

shift

6755

libname=`eval "\\$ECHO \"$libname_spec\""`

6756

# use dlname if we got it. it's perfectly good, no?

6757

if test -n "$dlname"; then

6758

soname="$dlname"

6759

elif test -n "$soname_spec"; then

6760

# bleh windows

6761

case $host in

6762

*cygwin* | mingw* | *cegcc*)

6763

func_arith $current - $age

6764

major=$func_arith_result

6765

versuffix="-$major"

6766

;;

6767

esac

6768

eval soname=\"$soname_spec\"

6769

else

6770

soname="$realname"

6771

fi

6772

6773

# Make a new name for the extract_expsyms_cmds to use

6774

soroot="$soname"

6775

func_basename "$soroot"

6776

soname="$func_basename_result"

6777

func_stripname 'lib' '.dll' "$soname"

6778

newlib=libimp-$func_stripname_result.a

6779

6780

# If the library has no export list, then create one now

6781

if test -f "$output_objdir/$soname-def"; then :

6782

else

6783

func_verbose "extracting exported symbol list from \`$soname'"

6784

func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

6785

fi

6786

6787

# Create $newlib

6788

if test -f "$output_objdir/$newlib"; then :; else

6789

func_verbose "generating import library for \`$soname'"

6790

func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

6791

fi

6792

# make sure the library variables are pointing to the new library

6793

dir=$output_objdir

6794

linklib=$newlib

6795

fi # test -n "$old_archive_from_expsyms_cmds"

6796

6797

if test "$linkmode" = prog || test "$opt_mode" != relink; then

6798

add_shlibpath=

6799

add_dir=

6800

add=

6801

lib_linked=yes

6802

case $hardcode_action in

6803

immediate | unsupported)

6804

if test "$hardcode_direct" = no; then

6805

add="$dir/$linklib"

6806

case $host in

6807

*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

6808

*-*-sysv4*uw2*) add_dir="-L$dir" ;;

6809

*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

6810

*-*-unixware7*) add_dir="-L$dir" ;;

6811

*-*-darwin* )

6812

# if the lib is a (non-dlopened) module then we can not

6813

# link against it, someone is ignoring the earlier warnings

6814

if /usr/bin/file -L $add 2> /dev/null |

6815

$GREP ": [^:]* bundle" >/dev/null ; then

6816

if test "X$dlopenmodule" != "X$lib"; then

6817

$ECHO "*** Warning: lib $linklib is a module, not a shared library"

6818

if test -z "$old_library" ; then

6819

echo

6820

echo "*** And there doesn't seem to be a static archive available"

6821

echo "*** The link will probably fail, sorry"

6822

else

6823

add="$dir/$old_library"

6824

fi

6825

elif test -n "$old_library"; then

6826

add="$dir/$old_library"

6827

fi

6828

fi

6829

esac

6830

elif test "$hardcode_minus_L" = no; then

6831

case $host in

6832

*-*-sunos*) add_shlibpath="$dir" ;;

6833

esac

6834

add_dir="-L$dir"

6835

add="-l$name"

6836

elif test "$hardcode_shlibpath_var" = no; then

6837

add_shlibpath="$dir"

6838

add="-l$name"

6839

else

6840

lib_linked=no

6841

fi

6842

;;

6843

relink)

6844

if test "$hardcode_direct" = yes &&

6845

test "$hardcode_direct_absolute" = no; then

6846

add="$dir/$linklib"

6847

elif test "$hardcode_minus_L" = yes; then

6848

add_dir="-L$absdir"

6849

# Try looking first in the location we're being installed to.

6850

if test -n "$inst_prefix_dir"; then

6851

case $libdir in

6852

[\\/]*)

6853

func_append add_dir " -L$inst_prefix_dir$libdir"

6854

;;

6855

esac

6856

fi

6857

add="-l$name"

6858

elif test "$hardcode_shlibpath_var" = yes; then

6859

add_shlibpath="$dir"

6860

add="-l$name"

6861

else

6862

lib_linked=no

6863

fi

6864

;;

6865

*) lib_linked=no ;;

6866

esac

6867

6868

if test "$lib_linked" != yes; then

6869

func_fatal_configuration "unsupported hardcode properties"

6870

fi

6871

6872

if test -n "$add_shlibpath"; then

6873

case :$compile_shlibpath: in

6874

*":$add_shlibpath:"*) ;;

6875

*) func_append compile_shlibpath "$add_shlibpath:" ;;

6876

esac

6877

fi

6878

if test "$linkmode" = prog; then

6879

test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

6880

test -n "$add" && compile_deplibs="$add $compile_deplibs"

6881

else

6882

test -n "$add_dir" && deplibs="$add_dir $deplibs"

6883

test -n "$add" && deplibs="$add $deplibs"

6884

if test "$hardcode_direct" != yes &&

6885

test "$hardcode_minus_L" != yes &&

6886

test "$hardcode_shlibpath_var" = yes; then

6887

case :$finalize_shlibpath: in

6888

*":$libdir:"*) ;;

6889

*) func_append finalize_shlibpath "$libdir:" ;;

6890

esac

6891

fi

6892

fi

6893

fi

6894

6895

if test "$linkmode" = prog || test "$opt_mode" = relink; then

6896

add_shlibpath=

6897

add_dir=

6898

add=

6899

# Finalize command for both is simple: just hardcode it.

6900

if test "$hardcode_direct" = yes &&

6901

test "$hardcode_direct_absolute" = no; then

6902

add="$libdir/$linklib"

6903

elif test "$hardcode_minus_L" = yes; then

6904

add_dir="-L$libdir"

6905

add="-l$name"

6906

elif test "$hardcode_shlibpath_var" = yes; then

6907

case :$finalize_shlibpath: in

6908

*":$libdir:"*) ;;

6909

*) func_append finalize_shlibpath "$libdir:" ;;

6910

esac

6911

add="-l$name"

6912

elif test "$hardcode_automatic" = yes; then

6913

if test -n "$inst_prefix_dir" &&

6914

test -f "$inst_prefix_dir$libdir/$linklib" ; then

6915

add="$inst_prefix_dir$libdir/$linklib"

6916

else

6917

add="$libdir/$linklib"

6918

fi

6919

else

6920

# We cannot seem to hardcode it, guess we'll fake it.

6921

add_dir="-L$libdir"

6922

# Try looking first in the location we're being installed to.

6923

if test -n "$inst_prefix_dir"; then

6924

case $libdir in

6925

[\\/]*)

6926

func_append add_dir " -L$inst_prefix_dir$libdir"

6927

;;

6928

esac

6929

fi

6930

add="-l$name"

6931

fi

6932

6933

if test "$linkmode" = prog; then

6934

test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

6935

test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

6936

else

6937

test -n "$add_dir" && deplibs="$add_dir $deplibs"

6938

test -n "$add" && deplibs="$add $deplibs"

6939

fi

6940

fi

6941

elif test "$linkmode" = prog; then

6942

# Here we assume that one of hardcode_direct or hardcode_minus_L

6943

# is not unsupported. This is valid on all known static and

6944

# shared platforms.

6945

if test "$hardcode_direct" != unsupported; then

6946

test -n "$old_library" && linklib="$old_library"

6947

compile_deplibs="$dir/$linklib $compile_deplibs"

6948

finalize_deplibs="$dir/$linklib $finalize_deplibs"

6949

else

6950

compile_deplibs="-l$name -L$dir $compile_deplibs"

6951

finalize_deplibs="-l$name -L$dir $finalize_deplibs"

6952

fi

6953

elif test "$build_libtool_libs" = yes; then

6954

# Not a shared library

6955

if test "$deplibs_check_method" != pass_all; then

6956

# We're trying link a shared library against a static one

6957

# but the system doesn't support it.

6958

6959

# Just print a warning and add the library to dependency_libs so

6960

# that the program can be linked against the static library.

6961

echo

6962

$ECHO "*** Warning: This system can not link to static lib archive $lib."

6963

echo "*** I have the capability to make that library automatically link in when"

6964

echo "*** you link to this library. But I can only do this if you have a"

6965

echo "*** shared version of the library, which you do not appear to have."

6966

if test "$module" = yes; then

6967

echo "*** But as you try to build a module library, libtool will still create "

6968

echo "*** a static module, that should work as long as the dlopening application"

6969

echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

6970

if test -z "$global_symbol_pipe"; then

6971

echo

6972

echo "*** However, this would only work if libtool was able to extract symbol"

6973

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

6974

echo "*** not find such a program. So, this module is probably useless."

6975

echo "*** \`nm' from GNU binutils and a full rebuild may help."

6976

fi

6977

if test "$build_old_libs" = no; then

6978

build_libtool_libs=module

6979

build_old_libs=yes

6980

else

6981

build_libtool_libs=no

6982

fi

6983

fi

6984

else

6985

deplibs="$dir/$old_library $deplibs"

6986

link_static=yes

6987

fi

6988

fi # link shared/static library?

6989

6990

if test "$linkmode" = lib; then

6991

if test -n "$dependency_libs" &&

6992

{ test "$hardcode_into_libs" != yes ||

6993

test "$build_old_libs" = yes ||

6994

test "$link_static" = yes; }; then

6995

# Extract -R from dependency_libs

6996

temp_deplibs=

6997

for libdir in $dependency_libs; do

6998

case $libdir in

6999

-R*) func_stripname '-R' '' "$libdir"

7000

temp_xrpath=$func_stripname_result

7001

case " $xrpath " in

7002

*" $temp_xrpath "*) ;;

7003

*) func_append xrpath " $temp_xrpath";;

7004

esac;;

7005

*) func_append temp_deplibs " $libdir";;

7006

esac

7007

done

7008

dependency_libs="$temp_deplibs"

7009

fi

7010

7011

func_append newlib_search_path " $absdir"

7012

# Link against this library

7013

test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

7014

# ... and its dependency_libs

7015

tmp_libs=

7016

for deplib in $dependency_libs; do

7017

newdependency_libs="$deplib $newdependency_libs"

7018

case $deplib in

7019

-L*) func_stripname '-L' '' "$deplib"

7020

func_resolve_sysroot "$func_stripname_result";;

7021

*) func_resolve_sysroot "$deplib" ;;

7022

esac

7023

if $opt_preserve_dup_deps ; then

7024

case "$tmp_libs " in

7025

*" $func_resolve_sysroot_result "*)

7026

func_append specialdeplibs " $func_resolve_sysroot_result" ;;

7027

esac

7028

fi

7029

func_append tmp_libs " $func_resolve_sysroot_result"

7030

done

7031

7032

if test "$link_all_deplibs" != no; then

7033

# Add the search paths of all dependency libraries

7034

for deplib in $dependency_libs; do

7035

path=

7036

case $deplib in

7037

-L*) path="$deplib" ;;

7038

*.la)

7039

func_resolve_sysroot "$deplib"

7040

deplib=$func_resolve_sysroot_result

7041

func_dirname "$deplib" "" "."

7042

dir=$func_dirname_result

7043

# We need an absolute path.

7044

case $dir in

7045

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

7046

*)

7047

absdir=`cd "$dir" && pwd`

7048

if test -z "$absdir"; then

7049

func_warning "cannot determine absolute directory name of \`$dir'"

7050

absdir="$dir"

7051

fi

7052

;;

7053

esac

7054

if $GREP "^installed=no" $deplib > /dev/null; then

7055

case $host in

7056

*-*-darwin*)

7057

depdepl=

7058

eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`

7059

if test -n "$deplibrary_names" ; then

7060

for tmp in $deplibrary_names ; do

7061

depdepl=$tmp

7062

done

7063

if test -f "$absdir/$objdir/$depdepl" ; then

7064

depdepl="$absdir/$objdir/$depdepl"

7065

darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7066

if test -z "$darwin_install_name"; then

7067

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7068

fi

7069

func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

7070

func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"

7071

path=

7072

fi

7073

fi

7074

;;

7075

*)

7076

path="-L$absdir/$objdir"

7077

;;

7078

esac

7079

else

7080

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

7081

test -z "$libdir" && \

7082

func_fatal_error "\`$deplib' is not a valid libtool archive"

7083

test "$absdir" != "$libdir" && \

7084

func_warning "\`$deplib' seems to be moved"

7085

7086

path="-L$absdir"

7087

fi

7088

;;

7089

esac

7090

case " $deplibs " in

7091

*" $path "*) ;;

7092

*) deplibs="$path $deplibs" ;;

7093

esac

7094

done

7095

fi # link_all_deplibs != no

7096

fi # linkmode = lib

7097

done # for deplib in $libs

7098

if test "$pass" = link; then

7099

if test "$linkmode" = "prog"; then

7100

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

7101

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

7102

else

7103

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7104

fi

7105

fi

7106

dependency_libs="$newdependency_libs"

7107

if test "$pass" = dlpreopen; then

7108

# Link the dlpreopened libraries before other libraries

7109

for deplib in $save_deplibs; do

7110

deplibs="$deplib $deplibs"

7111

done

7112

fi

7113

if test "$pass" != dlopen; then

7114

if test "$pass" != conv; then

7115

# Make sure lib_search_path contains only unique directories.

7116

lib_search_path=

7117

for dir in $newlib_search_path; do

7118

case "$lib_search_path " in

7119

*" $dir "*) ;;

7120

*) func_append lib_search_path " $dir" ;;

7121

esac

7122

done

7123

newlib_search_path=

7124

fi

7125

7126

if test "$linkmode,$pass" != "prog,link"; then

7127

vars="deplibs"

7128

else

7129

vars="compile_deplibs finalize_deplibs"

7130

fi

7131

for var in $vars dependency_libs; do

7132

# Add libraries to $var in reverse order

7133

eval tmp_libs=\"\$$var\"

7134

new_libs=

7135

for deplib in $tmp_libs; do

7136

# FIXME: Pedantically, this is the right thing to do, so

7137

# that some nasty dependency loop isn't accidentally

7138

# broken:

7139

#new_libs="$deplib $new_libs"

7140

# Pragmatically, this seems to cause very few problems in

7141

# practice:

7142

case $deplib in

7143

-L*) new_libs="$deplib $new_libs" ;;

7144

-R*) ;;

7145

*)

7146

# And here is the reason: when a library appears more

7147

# than once as an explicit dependence of a library, or

7148

# is implicitly linked in more than once by the

7149

# compiler, it is considered special, and multiple

7150

# occurrences thereof are not removed. Compare this

7151

# with having the same library being listed as a

7152

# dependency of multiple other libraries: in this case,

7153

# we know (pedantically, we assume) the library does not

7154

# need to be listed more than once, so we keep only the

7155

# last copy. This is not always right, but it is rare

7156

# enough that we require users that really mean to play

7157

# such unportable linking tricks to link the library

7158

# using -Wl,-lname, so that libtool does not consider it

7159

# for duplicate removal.

7160

case " $specialdeplibs " in

7161

*" $deplib "*) new_libs="$deplib $new_libs" ;;

7162

*)

7163

case " $new_libs " in

7164

*" $deplib "*) ;;

7165

*) new_libs="$deplib $new_libs" ;;

7166

esac

7167

;;

7168

esac

7169

;;

7170

esac

7171

done

7172

tmp_libs=

7173

for deplib in $new_libs; do

7174

case $deplib in

7175

-L*)

7176

case " $tmp_libs " in

7177

*" $deplib "*) ;;

7178

*) func_append tmp_libs " $deplib" ;;

7179

esac

7180

;;

7181

*) func_append tmp_libs " $deplib" ;;

7182

esac

7183

done

7184

eval $var=\"$tmp_libs\"

7185

done # for var

7186

fi

7187

# Last step: remove runtime libs from dependency_libs

7188

# (they stay in deplibs)

7189

tmp_libs=

7190

for i in $dependency_libs ; do

7191

case " $predeps $postdeps $compiler_lib_search_path " in

7192

*" $i "*)

7193

i=""

7194

;;

7195

esac

7196

if test -n "$i" ; then

7197

func_append tmp_libs " $i"

7198

fi

7199

done

7200

dependency_libs=$tmp_libs

7201

done # for pass

7202

if test "$linkmode" = prog; then

7203

dlfiles="$newdlfiles"

7204

fi

7205

if test "$linkmode" = prog || test "$linkmode" = lib; then

7206

dlprefiles="$newdlprefiles"

7207

fi

7208

7209

case $linkmode in

7210

oldlib)

7211

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

7212

func_warning "\`-dlopen' is ignored for archives"

7213

fi

7214

7215

case " $deplibs" in

7216

*\ -l* | *\ -L*)

7217

func_warning "\`-l' and \`-L' are ignored for archives" ;;

7218

esac

7219

7220

test -n "$rpath" && \

7221

func_warning "\`-rpath' is ignored for archives"

7222

7223

test -n "$xrpath" && \

7224

func_warning "\`-R' is ignored for archives"

7225

7226

test -n "$vinfo" && \

7227

func_warning "\`-version-info/-version-number' is ignored for archives"

7228

7229

test -n "$release" && \

7230

func_warning "\`-release' is ignored for archives"

7231

7232

test -n "$export_symbols$export_symbols_regex" && \

7233

func_warning "\`-export-symbols' is ignored for archives"

7234

7235

# Now set the variables for building old libraries.

7236

build_libtool_libs=no

7237

oldlibs="$output"

7238

func_append objs "$old_deplibs"

7239

;;

7240

7241

lib)

7242

# Make sure we only generate libraries of the form `libNAME.la'.

7243

case $outputname in

7244

lib*)

7245

func_stripname 'lib' '.la' "$outputname"

7246

name=$func_stripname_result

7247

eval shared_ext=\"$shrext_cmds\"

7248

eval libname=\"$libname_spec\"

7249

;;

7250

*)

7251

test "$module" = no && \

7252

func_fatal_help "libtool library \`$output' must begin with \`lib'"

7253

7254

if test "$need_lib_prefix" != no; then

7255

# Add the "lib" prefix for modules if required

7256

func_stripname '' '.la' "$outputname"

7257

name=$func_stripname_result

7258

eval shared_ext=\"$shrext_cmds\"

7259

eval libname=\"$libname_spec\"

7260

else

7261

func_stripname '' '.la' "$outputname"

7262

libname=$func_stripname_result

7263

fi

7264

;;

7265

esac

7266

7267

if test -n "$objs"; then

7268

if test "$deplibs_check_method" != pass_all; then

7269

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

7270

else

7271

echo

7272

$ECHO "*** Warning: Linking the shared library $output against the non-libtool"

7273

$ECHO "*** objects $objs is not portable!"

7274

func_append libobjs " $objs"

7275

fi

7276

fi

7277

7278

test "$dlself" != no && \

7279

func_warning "\`-dlopen self' is ignored for libtool libraries"

7280

7281

set dummy $rpath

7282

shift

7283

test "$#" -gt 1 && \

7284

func_warning "ignoring multiple \`-rpath's for a libtool library"

7285

7286

install_libdir="$1"

7287

7288

oldlibs=

7289

if test -z "$rpath"; then

7290

if test "$build_libtool_libs" = yes; then

7291

# Building a libtool convenience library.

7292

# Some compilers have problems with a `.al' extension so

7293

# convenience libraries should have the same extension an

7294

# archive normally would.

7295

oldlibs="$output_objdir/$libname.$libext $oldlibs"

7296

build_libtool_libs=convenience

7297

build_old_libs=yes

7298

fi

7299

7300

test -n "$vinfo" && \

7301

func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

7302

7303

test -n "$release" && \

7304

func_warning "\`-release' is ignored for convenience libraries"

7305

else

7306

7307

# Parse the version information argument.

7308

save_ifs="$IFS"; IFS=':'

7309

set dummy $vinfo 0 0 0

7310

shift

7311

IFS="$save_ifs"

7312

7313

test -n "$7" && \

7314

func_fatal_help "too many parameters to \`-version-info'"

7315

7316

# convert absolute version numbers to libtool ages

7317

# this retains compatibility with .la files and attempts

7318

# to make the code below a bit more comprehensible

7319

7320

case $vinfo_number in

7321

yes)

7322

number_major="$1"

7323

number_minor="$2"

7324

number_revision="$3"

7325

#

7326

# There are really only two kinds -- those that

7327

# use the current revision as the major version

7328

# and those that subtract age and use age as

7329

# a minor version. But, then there is irix

7330

# which has an extra 1 added just for fun

7331

#

7332

case $version_type in

7333

# correct linux to gnu/linux during the next big refactor

7334

darwin|linux|osf|windows|none)

7335

func_arith $number_major + $number_minor

7336

current=$func_arith_result

7337

age="$number_minor"

7338

revision="$number_revision"

7339

;;

7340

freebsd-aout|freebsd-elf|qnx|sunos)

7341

current="$number_major"

7342

revision="$number_minor"

7343

age="0"

7344

;;

7345

irix|nonstopux)

7346

func_arith $number_major + $number_minor

7347

current=$func_arith_result

7348

age="$number_minor"

7349

revision="$number_minor"

7350

lt_irix_increment=no

7351

;;

7352

esac

7353

;;

7354

no)

7355

current="$1"

7356

revision="$2"

7357

age="$3"

7358

;;

7359

esac

7360

7361

# Check that each of the things are valid numbers.

7362

case $current in

7363

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]) ;;

7364

*)

7365

func_error "CURRENT \`$current' must be a nonnegative integer"

7366

func_fatal_error "\`$vinfo' is not valid version information"

7367

;;

7368

esac

7369

7370

case $revision in

7371

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]) ;;

7372

*)

7373

func_error "REVISION \`$revision' must be a nonnegative integer"

7374

func_fatal_error "\`$vinfo' is not valid version information"

7375

;;

7376

esac

7377

7378

case $age in

7379

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]) ;;

7380

*)

7381

func_error "AGE \`$age' must be a nonnegative integer"

7382

func_fatal_error "\`$vinfo' is not valid version information"

7383

;;

7384

esac

7385

7386

if test "$age" -gt "$current"; then

7387

func_error "AGE \`$age' is greater than the current interface number \`$current'"

7388

func_fatal_error "\`$vinfo' is not valid version information"

7389

fi

7390

7391

# Calculate the version variables.

7392

major=

7393

versuffix=

7394

verstring=

7395

case $version_type in

7396

none) ;;

7397

7398

darwin)

7399

# Like Linux, but with the current version available in

7400

# verstring for coding it into the library header

7401

func_arith $current - $age

7402

major=.$func_arith_result

7403

versuffix="$major.$age.$revision"

7404

# Darwin ld doesn't like 0 for these options...

7405

func_arith $current + 1

7406

minor_current=$func_arith_result

7407

xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"

7408

verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

7409

;;

7410

7411

freebsd-aout)

7412

major=".$current"

7413

versuffix=".$current.$revision";

7414

;;

7415

7416

freebsd-elf)

7417

major=".$current"

7418

versuffix=".$current"

7419

;;

7420

7421

irix | nonstopux)

7422

if test "X$lt_irix_increment" = "Xno"; then

7423

func_arith $current - $age

7424

else

7425

func_arith $current - $age + 1

7426

fi

7427

major=$func_arith_result

7428

7429

case $version_type in

7430

nonstopux) verstring_prefix=nonstopux ;;

7431

*) verstring_prefix=sgi ;;

7432

esac

7433

verstring="$verstring_prefix$major.$revision"

7434

7435

# Add in all the interfaces that we are compatible with.

7436

loop=$revision

7437

while test "$loop" -ne 0; do

7438

func_arith $revision - $loop

7439

iface=$func_arith_result

7440

func_arith $loop - 1

7441

loop=$func_arith_result

7442

verstring="$verstring_prefix$major.$iface:$verstring"

7443

done

7444

7445

# Before this point, $major must not contain `.'.

7446

major=.$major

7447

versuffix="$major.$revision"

7448

;;

7449

7450

linux) # correct to gnu/linux during the next big refactor

7451

func_arith $current - $age

7452

major=.$func_arith_result

7453

versuffix="$major.$age.$revision"

7454

;;

7455

7456

osf)

7457

func_arith $current - $age

7458

major=.$func_arith_result

7459

versuffix=".$current.$age.$revision"

7460

verstring="$current.$age.$revision"

7461

7462

# Add in all the interfaces that we are compatible with.

7463

loop=$age

7464

while test "$loop" -ne 0; do

7465

func_arith $current - $loop

7466

iface=$func_arith_result

7467

func_arith $loop - 1

7468

loop=$func_arith_result

7469

verstring="$verstring:${iface}.0"

7470

done

7471

7472

# Make executables depend on our current version.

7473

func_append verstring ":${current}.0"

7474

;;

7475

7476

qnx)

7477

major=".$current"

7478

versuffix=".$current"

7479

;;

7480

7481

sunos)

7482

major=".$current"

7483

versuffix=".$current.$revision"

7484

;;

7485

7486

windows)

7487

# Use '-' rather than '.', since we only want one

7488

# extension on DOS 8.3 filesystems.

7489

func_arith $current - $age

7490

major=$func_arith_result

7491

versuffix="-$major"

7492

;;

7493

7494

*)

7495

func_fatal_configuration "unknown library version type \`$version_type'"

7496

;;

7497

esac

7498

7499

# Clear the version info if we defaulted, and they specified a release.

7500

if test -z "$vinfo" && test -n "$release"; then

7501

major=

7502

case $version_type in

7503

darwin)

7504

# we can't check for "0.0" in archive_cmds due to quoting

7505

# problems, so we reset it completely

7506

verstring=

7507

;;

7508

*)

7509

verstring="0.0"

7510

;;

7511

esac

7512

if test "$need_version" = no; then

7513

versuffix=

7514

else

7515

versuffix=".0.0"

7516

fi

7517

fi

7518

7519

# Remove version info from name if versioning should be avoided

7520

if test "$avoid_version" = yes && test "$need_version" = no; then

7521

major=

7522

versuffix=

7523

verstring=""

7524

fi

7525

7526

# Check to see if the archive will have undefined symbols.

7527

if test "$allow_undefined" = yes; then

7528

if test "$allow_undefined_flag" = unsupported; then

7529

func_warning "undefined symbols not allowed in $host shared libraries"

7530

build_libtool_libs=no

7531

build_old_libs=yes

7532

fi

7533

else

7534

# Don't allow undefined symbols.

7535

allow_undefined_flag="$no_undefined_flag"

7536

fi

7537

7538

fi

7539

7540

func_generate_dlsyms "$libname" "$libname" "yes"

7541

func_append libobjs " $symfileobj"

7542

test "X$libobjs" = "X " && libobjs=

7543

7544

if test "$opt_mode" != relink; then

7545

# Remove our outputs, but don't remove object files since they

7546

# may have been created when compiling PIC objects.

7547

removelist=

7548

tempremovelist=`$ECHO "$output_objdir/*"`

7549

for p in $tempremovelist; do

7550

case $p in

7551

*.$objext | *.gcno)

7552

;;

7553

$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

7554

if test "X$precious_files_regex" != "X"; then

7555

if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

7556

then

7557

continue

7558

fi

7559

fi

7560

func_append removelist " $p"

7561

;;

7562

*) ;;

7563

esac

7564

done

7565

test -n "$removelist" && \

7566

func_show_eval "${RM}r \$removelist"

7567

fi

7568

7569

# Now set the variables for building old libraries.

7570

if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

7571

func_append oldlibs " $output_objdir/$libname.$libext"

7572

7573

# Transform .lo files to .o files.

7574

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

7575

fi

7576

7577

# Eliminate all temporary directories.

7578

#for path in $notinst_path; do

7579

# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

7580

# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

7581

# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

7582

#done

7583

7584

if test -n "$xrpath"; then

7585

# If the user specified any rpath flags, then add them.

7586

temp_xrpath=

7587

for libdir in $xrpath; do

7588

func_replace_sysroot "$libdir"

7589

func_append temp_xrpath " -R$func_replace_sysroot_result"

7590

case "$finalize_rpath " in

7591

*" $libdir "*) ;;

7592

*) func_append finalize_rpath " $libdir" ;;

7593

esac

7594

done

7595

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

7596

dependency_libs="$temp_xrpath $dependency_libs"

7597

fi

7598

fi

7599

7600

# Make sure dlfiles contains only unique files that won't be dlpreopened

7601

old_dlfiles="$dlfiles"

7602

dlfiles=

7603

for lib in $old_dlfiles; do

7604

case " $dlprefiles $dlfiles " in

7605

*" $lib "*) ;;

7606

*) func_append dlfiles " $lib" ;;

7607

esac

7608

done

7609

7610

# Make sure dlprefiles contains only unique files

7611

old_dlprefiles="$dlprefiles"

7612

dlprefiles=

7613

for lib in $old_dlprefiles; do

7614

case "$dlprefiles " in

7615

*" $lib "*) ;;

7616

*) func_append dlprefiles " $lib" ;;

7617

esac

7618

done

7619

7620

if test "$build_libtool_libs" = yes; then

7621

if test -n "$rpath"; then

7622

case $host in

7623

7624

# these systems don't actually have a c library (as such)!

7625

;;

7626

*-*-rhapsody* | *-*-darwin1.[012])

7627

# Rhapsody C library is in the System framework

7628

func_append deplibs " System.ltframework"

7629

;;

7630

*-*-netbsd*)

7631

# Don't link with libc until the a.out ld.so is fixed.

7632

;;

7633

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

7634

# Do not include libc due to us having libc/libc_r.

7635

;;

7636

*-*-sco3.2v5* | *-*-sco5v6*)

7637

# Causes problems with __ctype

7638

;;

7639

*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

7640

# Compiler inserts libc in the correct place for threads to work

7641

;;

7642

*)

7643

# Add libc to deplibs on all other systems if necessary.

7644

if test "$build_libtool_need_lc" = "yes"; then

7645

func_append deplibs " -lc"

7646

fi

7647

;;

7648

esac

7649

fi

7650

7651

# Transform deplibs into only deplibs that can be linked in shared.

7652

name_save=$name

7653

libname_save=$libname

7654

release_save=$release

7655

versuffix_save=$versuffix

7656

major_save=$major

7657

# I'm not sure if I'm treating the release correctly. I think

7658

# release should show up in the -l (ie -lgmp5) so we don't want to

7659

# add it in twice. Is that correct?

7660

release=""

7661

versuffix=""

7662

major=""

7663

newdeplibs=

7664

droppeddeps=no

7665

case $deplibs_check_method in

7666

pass_all)

7667

# Don't check for shared/static. Everything works.

7668

# This might be a little naive. We might want to check

7669

# whether the library exists or not. But this is on

7670

# osf3 & osf4 and I'm not really sure... Just

7671

# implementing what was already the behavior.

7672

newdeplibs=$deplibs

7673

;;

7674

test_compile)

7675

# This code stresses the "libraries are programs" paradigm to its

7676

# limits. Maybe even breaks it. We compile a program, linking it

7677

# against the deplibs as a proxy for the library. Then we can check

7678

# whether they linked in statically or dynamically with ldd.

7679

$opt_dry_run || $RM conftest.c

7680

cat > conftest.c <<EOF

7681

int main() { return 0; }

7682

EOF

7683

$opt_dry_run || $RM conftest

7684

if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then

7685

ldd_output=`ldd conftest`

7686

for i in $deplibs; do

7687

case $i in

7688

-l*)

7689

func_stripname -l '' "$i"

7690

name=$func_stripname_result

7691

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7692

case " $predeps $postdeps " in

7693

*" $i "*)

7694

func_append newdeplibs " $i"

7695

i=""

7696

;;

7697

esac

7698

fi

7699

if test -n "$i" ; then

7700

libname=`eval "\\$ECHO \"$libname_spec\""`

7701

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7702

set dummy $deplib_matches; shift

7703

deplib_match=$1

7704

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7705

func_append newdeplibs " $i"

7706

else

7707

droppeddeps=yes

7708

echo

7709

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7710

echo "*** I have the capability to make that library automatically link in when"

7711

echo "*** you link to this library. But I can only do this if you have a"

7712

echo "*** shared version of the library, which I believe you do not have"

7713

echo "*** because a test_compile did reveal that the linker did not use it for"

7714

echo "*** its dynamic dependency list that programs get resolved with at runtime."

7715

fi

7716

fi

7717

;;

7718

*)

7719

func_append newdeplibs " $i"

7720

;;

7721

esac

7722

done

7723

else

7724

# Error occurred in the first compile. Let's try to salvage

7725

# the situation: Compile a separate program for each library.

7726

for i in $deplibs; do

7727

case $i in

7728

-l*)

7729

func_stripname -l '' "$i"

7730

name=$func_stripname_result

7731

$opt_dry_run || $RM conftest

7732

if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

7733

ldd_output=`ldd conftest`

7734

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7735

case " $predeps $postdeps " in

7736

*" $i "*)

7737

func_append newdeplibs " $i"

7738

i=""

7739

;;

7740

esac

7741

fi

7742

if test -n "$i" ; then

7743

libname=`eval "\\$ECHO \"$libname_spec\""`

7744

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

7745

set dummy $deplib_matches; shift

7746

deplib_match=$1

7747

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7748

func_append newdeplibs " $i"

7749

else

7750

droppeddeps=yes

7751

echo

7752

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7753

echo "*** I have the capability to make that library automatically link in when"

7754

echo "*** you link to this library. But I can only do this if you have a"

7755

echo "*** shared version of the library, which you do not appear to have"

7756

echo "*** because a test_compile did reveal that the linker did not use this one"

7757

echo "*** as a dynamic dependency that programs can get resolved with at runtime."

7758

fi

7759

fi

7760

else

7761

droppeddeps=yes

7762

echo

7763

$ECHO "*** Warning! Library $i is needed by this library but I was not able to"

7764

echo "*** make it link in! You will probably need to install it or some"

7765

echo "*** library that it depends on before this library will be fully"

7766

echo "*** functional. Installing it before continuing would be even better."

7767

fi

7768

;;

7769

*)

7770

func_append newdeplibs " $i"

7771

;;

7772

esac

7773

done

7774

fi

7775

;;

7776

file_magic*)

7777

set dummy $deplibs_check_method; shift

7778

file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7779

for a_deplib in $deplibs; do

7780

case $a_deplib in

7781

-l*)

7782

func_stripname -l '' "$a_deplib"

7783

name=$func_stripname_result

7784

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7785

case " $predeps $postdeps " in

7786

*" $a_deplib "*)

7787

func_append newdeplibs " $a_deplib"

7788

a_deplib=""

7789

;;

7790

esac

7791

fi

7792

if test -n "$a_deplib" ; then

7793

libname=`eval "\\$ECHO \"$libname_spec\""`

7794

if test -n "$file_magic_glob"; then

7795

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

7796

else

7797

libnameglob=$libname

7798

fi

7799

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

7800

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7801

if test "$want_nocaseglob" = yes; then

7802

shopt -s nocaseglob

7803

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7804

$nocaseglob

7805

else

7806

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7807

fi

7808

for potent_lib in $potential_libs; do

7809

# Follow soft links.

7810

if ls -lLd "$potent_lib" 2>/dev/null |

7811

$GREP " -> " >/dev/null; then

7812

continue

7813

fi

7814

# The statement above tries to avoid entering an

7815

# endless loop below, in case of cyclic links.

7816

# We might still enter an endless loop, since a link

7817

# loop can be closed while we follow links,

7818

# but so what?

7819

potlib="$potent_lib"

7820

while test -h "$potlib" 2>/dev/null; do

7821

potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

7822

case $potliblink in

7823

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

7824

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

7825

esac

7826

done

7827

if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

7828

$SED -e 10q |

7829

$EGREP "$file_magic_regex" > /dev/null; then

7830

func_append newdeplibs " $a_deplib"

7831

a_deplib=""

7832

break 2

7833

fi

7834

done

7835

done

7836

fi

7837

if test -n "$a_deplib" ; then

7838

droppeddeps=yes

7839

echo

7840

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7841

echo "*** I have the capability to make that library automatically link in when"

7842

echo "*** you link to this library. But I can only do this if you have a"

7843

echo "*** shared version of the library, which you do not appear to have"

7844

echo "*** because I did check the linker path looking for a file starting"

7845

if test -z "$potlib" ; then

7846

$ECHO "*** with $libname but no candidates were found. (...for file magic test)"

7847

else

7848

$ECHO "*** with $libname and none of the candidates passed a file format test"

7849

$ECHO "*** using a file magic. Last file checked: $potlib"

7850

fi

7851

fi

7852

;;

7853

*)

7854

# Add a -L argument.

7855

func_append newdeplibs " $a_deplib"

7856

;;

7857

esac

7858

done # Gone through all deplibs.

7859

;;

7860

match_pattern*)

7861

set dummy $deplibs_check_method; shift

7862

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

7863

for a_deplib in $deplibs; do

7864

case $a_deplib in

7865

-l*)

7866

func_stripname -l '' "$a_deplib"

7867

name=$func_stripname_result

7868

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7869

case " $predeps $postdeps " in

7870

*" $a_deplib "*)

7871

func_append newdeplibs " $a_deplib"

7872

a_deplib=""

7873

;;

7874

esac

7875

fi

7876

if test -n "$a_deplib" ; then

7877

libname=`eval "\\$ECHO \"$libname_spec\""`

7878

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7879

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7880

for potent_lib in $potential_libs; do

7881

potlib="$potent_lib" # see symlink-check above in file_magic test

7882

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

7883

$EGREP "$match_pattern_regex" > /dev/null; then

7884

func_append newdeplibs " $a_deplib"

7885

a_deplib=""

7886

break 2

7887

fi

7888

done

7889

done

7890

fi

7891

if test -n "$a_deplib" ; then

7892

droppeddeps=yes

7893

echo

7894

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7895

echo "*** I have the capability to make that library automatically link in when"

7896

echo "*** you link to this library. But I can only do this if you have a"

7897

echo "*** shared version of the library, which you do not appear to have"

7898

echo "*** because I did check the linker path looking for a file starting"

7899

if test -z "$potlib" ; then

7900

$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

7901

else

7902

$ECHO "*** with $libname and none of the candidates passed a file format test"

7903

$ECHO "*** using a regex pattern. Last file checked: $potlib"

7904

fi

7905

fi

7906

;;

7907

*)

7908

# Add a -L argument.

7909

func_append newdeplibs " $a_deplib"

7910

;;

7911

esac

7912

done # Gone through all deplibs.

7913

;;

7914

none | unknown | *)

7915

newdeplibs=""

7916

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

7917

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7918

for i in $predeps $postdeps ; do

7919

# can't use Xsed below, because $i might contain '/'

7920

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

7921

done

7922

fi

7923

case $tmp_deplibs in

7924

*[!\ \ ]*)

7925

echo

7926

if test "X$deplibs_check_method" = "Xnone"; then

7927

echo "*** Warning: inter-library dependencies are not supported in this platform."

7928

else

7929

echo "*** Warning: inter-library dependencies are not known to be supported."

7930

fi

7931

echo "*** All declared inter-library dependencies are being dropped."

7932

droppeddeps=yes

7933

;;

7934

esac

7935

;;

7936

esac

7937

versuffix=$versuffix_save

7938

major=$major_save

7939

release=$release_save

7940

libname=$libname_save

7941

name=$name_save

7942

7943

case $host in

7944

*-*-rhapsody* | *-*-darwin1.[012])

7945

# On Rhapsody replace the C library with the System framework

7946

newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

7947

;;

7948

esac

7949

7950

if test "$droppeddeps" = yes; then

7951

if test "$module" = yes; then

7952

echo

7953

echo "*** Warning: libtool could not satisfy all declared inter-library"

7954

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

7955

echo "*** a static module, that should work as long as the dlopening"

7956

echo "*** application is linked with the -dlopen flag."

7957

if test -z "$global_symbol_pipe"; then

7958

echo

7959

echo "*** However, this would only work if libtool was able to extract symbol"

7960

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

7961

echo "*** not find such a program. So, this module is probably useless."

7962

echo "*** \`nm' from GNU binutils and a full rebuild may help."

7963

fi

7964

if test "$build_old_libs" = no; then

7965

oldlibs="$output_objdir/$libname.$libext"

7966

build_libtool_libs=module

7967

build_old_libs=yes

7968

else

7969

build_libtool_libs=no

7970

fi

7971

else

7972

echo "*** The inter-library dependencies that have been dropped here will be"

7973

echo "*** automatically added whenever a program is linked with this library"

7974

echo "*** or is declared to -dlopen it."

7975

7976

if test "$allow_undefined" = no; then

7977

echo

7978

echo "*** Since this library must not contain undefined symbols,"

7979

echo "*** because either the platform does not support them or"

7980

echo "*** it was explicitly requested with -no-undefined,"

7981

echo "*** libtool will only create a static version of it."

7982

if test "$build_old_libs" = no; then

7983

oldlibs="$output_objdir/$libname.$libext"

7984

build_libtool_libs=module

7985

build_old_libs=yes

7986

else

7987

build_libtool_libs=no

7988

fi

7989

fi

7990

fi

7991

fi

7992

# Done checking deplibs!

7993

deplibs=$newdeplibs

7994

fi

7995

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

7996

case $host in

7997

*-*-darwin*)

7998

newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7999

new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8000

deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8001

;;

8002

esac

8003

8004

# move library search paths that coincide with paths to not yet

8005

# installed libraries to the beginning of the library search list

8006

new_libs=

8007

for path in $notinst_path; do

8008

case " $new_libs " in

8009

*" -L$path/$objdir "*) ;;

8010

*)

8011

case " $deplibs " in

8012

*" -L$path/$objdir "*)

8013

func_append new_libs " -L$path/$objdir" ;;

8014

esac

8015

;;

8016

esac

8017

done

8018

for deplib in $deplibs; do

8019

case $deplib in

8020

-L*)

8021

case " $new_libs " in

8022

*" $deplib "*) ;;

8023

*) func_append new_libs " $deplib" ;;

8024

esac

8025

;;

8026

*) func_append new_libs " $deplib" ;;

8027

esac

8028

done

8029

deplibs="$new_libs"

8030

8031

# All the library-specific variables (install_libdir is set above).

8032

library_names=

8033

old_library=

8034

dlname=

8035

8036

# Test again, we may have decided not to build it any more

8037

if test "$build_libtool_libs" = yes; then

8038

# Remove ${wl} instances when linking with ld.

8039

# FIXME: should test the right _cmds variable.

8040

case $archive_cmds in

8041

*\$LD\ *) wl= ;;

8042

esac

8043

if test "$hardcode_into_libs" = yes; then

8044

# Hardcode the library paths

8045

hardcode_libdirs=

8046

dep_rpath=

8047

rpath="$finalize_rpath"

8048

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

8049

for libdir in $rpath; do

8050

if test -n "$hardcode_libdir_flag_spec"; then

8051

if test -n "$hardcode_libdir_separator"; then

8052

func_replace_sysroot "$libdir"

8053

libdir=$func_replace_sysroot_result

8054

if test -z "$hardcode_libdirs"; then

8055

hardcode_libdirs="$libdir"

8056

else

8057

# Just accumulate the unique libdirs.

8058

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8059

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8060

;;

8061

*)

8062

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8063

;;

8064

esac

8065

fi

8066

else

8067

eval flag=\"$hardcode_libdir_flag_spec\"

8068

func_append dep_rpath " $flag"

8069

fi

8070

elif test -n "$runpath_var"; then

8071

case "$perm_rpath " in

8072

*" $libdir "*) ;;

8073

*) func_append perm_rpath " $libdir" ;;

8074

esac

8075

fi

8076

done

8077

# Substitute the hardcoded libdirs into the rpath.

8078

if test -n "$hardcode_libdir_separator" &&

8079

test -n "$hardcode_libdirs"; then

8080

libdir="$hardcode_libdirs"

8081

eval "dep_rpath=\"$hardcode_libdir_flag_spec\""

8082

fi

8083

if test -n "$runpath_var" && test -n "$perm_rpath"; then

8084

# We should set the runpath_var.

8085

rpath=

8086

for dir in $perm_rpath; do

8087

func_append rpath "$dir:"

8088

done

8089

eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

8090

fi

8091

test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

8092

fi

8093

8094

shlibpath="$finalize_shlibpath"

8095

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

8096

if test -n "$shlibpath"; then

8097

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

8098

fi

8099

8100

# Get the real and link names of the library.

8101

eval shared_ext=\"$shrext_cmds\"

8102

eval library_names=\"$library_names_spec\"

8103

set dummy $library_names

8104

shift

8105

realname="$1"

8106

shift

8107

8108

if test -n "$soname_spec"; then

8109

eval soname=\"$soname_spec\"

8110

else

8111

soname="$realname"

8112

fi

8113

if test -z "$dlname"; then

8114

dlname=$soname

8115

fi

8116

8117

lib="$output_objdir/$realname"

8118

linknames=

8119

for link

8120

do

8121

func_append linknames " $link"

8122

done

8123

8124

# Use standard objects if they are pic

8125

test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

8126

test "X$libobjs" = "X " && libobjs=

8127

8128

delfiles=

8129

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8130

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

8131

export_symbols="$output_objdir/$libname.uexp"

8132

func_append delfiles " $export_symbols"

8133

fi

8134

8135

orig_export_symbols=

8136

case $host_os in

8137

cygwin* | mingw* | cegcc*)

8138

if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

8139

# exporting using user supplied symfile

8140

if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

8141

# and it's NOT already a .def file. Must figure out

8142

# which of the given symbols are data symbols and tag

8143

# them as such. So, trigger use of export_symbols_cmds.

8144

# export_symbols gets reassigned inside the "prepare

8145

# the list of exported symbols" if statement, so the

8146

# include_expsyms logic still works.

8147

orig_export_symbols="$export_symbols"

8148

export_symbols=

8149

always_export_symbols=yes

8150

fi

8151

fi

8152

;;

8153

esac

8154

8155

# Prepare the list of exported symbols

8156

if test -z "$export_symbols"; then

8157

if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

8158

func_verbose "generating symbol list for \`$libname.la'"

8159

export_symbols="$output_objdir/$libname.exp"

8160

$opt_dry_run || $RM $export_symbols

8161

cmds=$export_symbols_cmds

8162

save_ifs="$IFS"; IFS='~'

8163

for cmd1 in $cmds; do

8164

IFS="$save_ifs"

8165

# Take the normal branch if the nm_file_list_spec branch

8166

# doesn't work or if tool conversion is not needed.

8167

case $nm_file_list_spec~$to_tool_file_cmd in

8168

*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)

8169

try_normal_branch=yes

8170

eval cmd=\"$cmd1\"

8171

func_len " $cmd"

8172

len=$func_len_result

8173

;;

8174

*)

8175

try_normal_branch=no

8176

;;

8177

esac

8178

if test "$try_normal_branch" = yes \

8179

&& { test "$len" -lt "$max_cmd_len" \

8180

|| test "$max_cmd_len" -le -1; }

8181

then

8182

func_show_eval "$cmd" 'exit $?'

8183

skipped_export=false

8184

elif test -n "$nm_file_list_spec"; then

8185

func_basename "$output"

8186

output_la=$func_basename_result

8187

save_libobjs=$libobjs

8188

save_output=$output

8189

output=${output_objdir}/${output_la}.nm

8190

func_to_tool_file "$output"

8191

libobjs=$nm_file_list_spec$func_to_tool_file_result

8192

func_append delfiles " $output"

8193

func_verbose "creating $NM input file list: $output"

8194

for obj in $save_libobjs; do

8195

func_to_tool_file "$obj"

8196

$ECHO "$func_to_tool_file_result"

8197

done > "$output"

8198

eval cmd=\"$cmd1\"

8199

func_show_eval "$cmd" 'exit $?'

8200

output=$save_output

8201

libobjs=$save_libobjs

8202

skipped_export=false

8203

else

8204

# The command line is too long to execute in one step.

8205

func_verbose "using reloadable object file for export list..."

8206

skipped_export=:

8207

# Break out early, otherwise skipped_export may be

8208

# set to false by a later but shorter cmd.

8209

break

8210

fi

8211

done

8212

IFS="$save_ifs"

8213

if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

8214

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8215

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8216

fi

8217

fi

8218

fi

8219

8220

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8221

tmp_export_symbols="$export_symbols"

8222

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8223

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8224

fi

8225

8226

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

8227

# The given exports_symbols file has to be filtered, so filter it.

8228

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8229

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8230

# 's' commands which not all seds can handle. GNU sed should be fine

8231

# though. Also, the filter scales superlinearly with the number of

8232

# global variables. join(1) would be nice here, but unfortunately

8233

# isn't a blessed tool.

8234

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8235

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

8236

export_symbols=$output_objdir/$libname.def

8237

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8238

fi

8239

8240

tmp_deplibs=

8241

for test_deplib in $deplibs; do

8242

case " $convenience " in

8243

*" $test_deplib "*) ;;

8244

*)

8245

func_append tmp_deplibs " $test_deplib"

8246

;;

8247

esac

8248

done

8249

deplibs="$tmp_deplibs"

8250

8251

if test -n "$convenience"; then

8252

if test -n "$whole_archive_flag_spec" &&

8253

test "$compiler_needs_object" = yes &&

8254

test -z "$libobjs"; then

8255

# extract the archives, so we have objects to list.

8256

# TODO: could optimize this to just extract one archive.

8257

whole_archive_flag_spec=

8258

fi

8259

if test -n "$whole_archive_flag_spec"; then

8260

save_libobjs=$libobjs

8261

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8262

test "X$libobjs" = "X " && libobjs=

8263

else

8264

gentop="$output_objdir/${outputname}x"

8265

func_append generated " $gentop"

8266

8267

func_extract_archives $gentop $convenience

8268

func_append libobjs " $func_extract_archives_result"

8269

test "X$libobjs" = "X " && libobjs=

8270

fi

8271

fi

8272

8273

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

8274

eval flag=\"$thread_safe_flag_spec\"

8275

func_append linker_flags " $flag"

8276

fi

8277

8278

# Make a backup of the uninstalled library when relinking

8279

if test "$opt_mode" = relink; then

8280

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

8281

fi

8282

8283

# Do each of the archive commands.

8284

if test "$module" = yes && test -n "$module_cmds" ; then

8285

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8286

eval test_cmds=\"$module_expsym_cmds\"

8287

cmds=$module_expsym_cmds

8288

else

8289

eval test_cmds=\"$module_cmds\"

8290

cmds=$module_cmds

8291

fi

8292

else

8293

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8294

eval test_cmds=\"$archive_expsym_cmds\"

8295

cmds=$archive_expsym_cmds

8296

else

8297

eval test_cmds=\"$archive_cmds\"

8298

cmds=$archive_cmds

8299

fi

8300

fi

8301

8302

if test "X$skipped_export" != "X:" &&

8303

func_len " $test_cmds" &&

8304

len=$func_len_result &&

8305

test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

8306

:

8307

else

8308

# The command line is too long to link in one step, link piecewise

8309

# or, if using GNU ld and skipped_export is not :, use a linker

8310

# script.

8311

8312

# Save the value of $output and $libobjs because we want to

8313

# use them later. If we have whole_archive_flag_spec, we

8314

# want to use save_libobjs as it was before

8315

# whole_archive_flag_spec was expanded, because we can't

8316

# assume the linker understands whole_archive_flag_spec.

8317

# This may have to be revisited, in case too many

8318

# convenience libraries get linked in and end up exceeding

8319

# the spec.

8320

if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then

8321

save_libobjs=$libobjs

8322

fi

8323

save_output=$output

8324

func_basename "$output"

8325

output_la=$func_basename_result

8326

8327

# Clear the reloadable object creation command queue and

8328

# initialize k to one.

8329

test_cmds=

8330

concat_cmds=

8331

objlist=

8332

last_robj=

8333

k=1

8334

8335

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

8336

output=${output_objdir}/${output_la}.lnkscript

8337

func_verbose "creating GNU ld script: $output"

8338

echo 'INPUT (' > $output

8339

for obj in $save_libobjs

8340

do

8341

func_to_tool_file "$obj"

8342

$ECHO "$func_to_tool_file_result" >> $output

8343

done

8344

echo ')' >> $output

8345

func_append delfiles " $output"

8346

func_to_tool_file "$output"

8347

output=$func_to_tool_file_result

8348

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

8349

output=${output_objdir}/${output_la}.lnk

8350

func_verbose "creating linker input file list: $output"

8351

: > $output

8352

set x $save_libobjs

8353

shift

8354

firstobj=

8355

if test "$compiler_needs_object" = yes; then

8356

firstobj="$1 "

8357

shift

8358

fi

8359

for obj

8360

do

8361

func_to_tool_file "$obj"

8362

$ECHO "$func_to_tool_file_result" >> $output

8363

done

8364

func_append delfiles " $output"

8365

func_to_tool_file "$output"

8366

output=$firstobj\"$file_list_spec$func_to_tool_file_result\"

8367

else

8368

if test -n "$save_libobjs"; then

8369

func_verbose "creating reloadable object files..."

8370

output=$output_objdir/$output_la-${k}.$objext

8371

eval test_cmds=\"$reload_cmds\"

8372

func_len " $test_cmds"

8373

len0=$func_len_result

8374

len=$len0

8375

8376

# Loop over the list of objects to be linked.

8377

for obj in $save_libobjs

8378

do

8379

func_len " $obj"

8380

func_arith $len + $func_len_result

8381

len=$func_arith_result

8382

if test "X$objlist" = X ||

8383

test "$len" -lt "$max_cmd_len"; then

8384

func_append objlist " $obj"

8385

else

8386

# The command $test_cmds is almost too long, add a

8387

# command to the queue.

8388

if test "$k" -eq 1 ; then

8389

# The first file doesn't have a previous command to add.

8390

reload_objs=$objlist

8391

eval concat_cmds=\"$reload_cmds\"

8392

else

8393

# All subsequent reloadable object files will link in

8394

# the last one created.

8395

reload_objs="$objlist $last_robj"

8396

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

8397

fi

8398

last_robj=$output_objdir/$output_la-${k}.$objext

8399

func_arith $k + 1

8400

k=$func_arith_result

8401

output=$output_objdir/$output_la-${k}.$objext

8402

objlist=" $obj"

8403

func_len " $last_robj"

8404

func_arith $len0 + $func_len_result

8405

len=$func_arith_result

8406

fi

8407

done

8408

# Handle the remaining objects by creating one last

8409

# reloadable object file. All subsequent reloadable object

8410

# files will link in the last one created.

8411

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8412

reload_objs="$objlist $last_robj"

8413

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

8414

if test -n "$last_robj"; then

8415

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

8416

fi

8417

func_append delfiles " $output"

8418

8419

else

8420

output=

8421

fi

8422

8423

if ${skipped_export-false}; then

8424

func_verbose "generating symbol list for \`$libname.la'"

8425

export_symbols="$output_objdir/$libname.exp"

8426

$opt_dry_run || $RM $export_symbols

8427

libobjs=$output

8428

# Append the command to create the export file.

8429

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8430

eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"

8431

if test -n "$last_robj"; then

8432

eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

8433

fi

8434

fi

8435

8436

test -n "$save_libobjs" &&

8437

func_verbose "creating a temporary reloadable object file: $output"

8438

8439

# Loop through the commands generated above and execute them.

8440

save_ifs="$IFS"; IFS='~'

8441

for cmd in $concat_cmds; do

8442

IFS="$save_ifs"

8443

$opt_silent || {

8444

func_quote_for_expand "$cmd"

8445

eval "func_echo $func_quote_for_expand_result"

8446

}

8447

$opt_dry_run || eval "$cmd" || {

8448

lt_exit=$?

8449

8450

# Restore the uninstalled library and exit

8451

if test "$opt_mode" = relink; then

8452

( cd "$output_objdir" && \

8453

$RM "${realname}T" && \

8454

$MV "${realname}U" "$realname" )

8455

fi

8456

8457

exit $lt_exit

8458

}

8459

done

8460

IFS="$save_ifs"

8461

8462

if test -n "$export_symbols_regex" && ${skipped_export-false}; then

8463

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

8464

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

8465

fi

8466

fi

8467

8468

if ${skipped_export-false}; then

8469

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8470

tmp_export_symbols="$export_symbols"

8471

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8472

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

8473

fi

8474

8475

if test -n "$orig_export_symbols"; then

8476

# The given exports_symbols file has to be filtered, so filter it.

8477

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

8478

# FIXME: $output_objdir/$libname.filter potentially contains lots of

8479

# 's' commands which not all seds can handle. GNU sed should be fine

8480

# though. Also, the filter scales superlinearly with the number of

8481

# global variables. join(1) would be nice here, but unfortunately

8482

# isn't a blessed tool.

8483

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8484

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

8485

export_symbols=$output_objdir/$libname.def

8486

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8487

fi

8488

fi

8489

8490

libobjs=$output

8491

# Restore the value of output.

8492

output=$save_output

8493

8494

if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then

8495

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

8496

test "X$libobjs" = "X " && libobjs=

8497

fi

8498

# Expand the library linking commands again to reset the

8499

# value of $libobjs for piecewise linking.

8500

8501

# Do each of the archive commands.

8502

if test "$module" = yes && test -n "$module_cmds" ; then

8503

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

8504

cmds=$module_expsym_cmds

8505

else

8506

cmds=$module_cmds

8507

fi

8508

else

8509

if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then

8510

cmds=$archive_expsym_cmds

8511

else

8512

cmds=$archive_cmds

8513

fi

8514

fi

8515

fi

8516

8517

if test -n "$delfiles"; then

8518

# Append the command to remove temporary files to $cmds.

8519

eval cmds=\"\$cmds~\$RM $delfiles\"

8520

fi

8521

8522

# Add any objects from preloaded convenience libraries

8523

if test -n "$dlprefiles"; then

8524

gentop="$output_objdir/${outputname}x"

8525

func_append generated " $gentop"

8526

8527

func_extract_archives $gentop $dlprefiles

8528

func_append libobjs " $func_extract_archives_result"

8529

test "X$libobjs" = "X " && libobjs=

8530

fi

8531

8532

save_ifs="$IFS"; IFS='~'

8533

for cmd in $cmds; do

8534

IFS="$save_ifs"

8535

eval cmd=\"$cmd\"

8536

$opt_silent || {

8537

func_quote_for_expand "$cmd"

8538

eval "func_echo $func_quote_for_expand_result"

8539

}

8540

$opt_dry_run || eval "$cmd" || {

8541

lt_exit=$?

8542

8543

# Restore the uninstalled library and exit

8544

if test "$opt_mode" = relink; then

8545

( cd "$output_objdir" && \

8546

$RM "${realname}T" && \

8547

$MV "${realname}U" "$realname" )

8548

fi

8549

8550

exit $lt_exit

8551

}

8552

done

8553

IFS="$save_ifs"

8554

8555

# Restore the uninstalled library and exit

8556

if test "$opt_mode" = relink; then

8557

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

8558

8559

if test -n "$convenience"; then

8560

if test -z "$whole_archive_flag_spec"; then

8561

func_show_eval '${RM}r "$gentop"'

8562

fi

8563

fi

8564

8565

exit $EXIT_SUCCESS

8566

fi

8567

8568

# Create links to the real library.

8569

for linkname in $linknames; do

8570

if test "$realname" != "$linkname"; then

8571

func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'

8572

fi

8573

done

8574

8575

# If -module or -export-dynamic was specified, set the dlname.

8576

if test "$module" = yes || test "$export_dynamic" = yes; then

8577

# On all known operating systems, these are identical.

8578

dlname="$soname"

8579

fi

8580

fi

8581

;;

8582

8583

obj)

8584

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

8585

func_warning "\`-dlopen' is ignored for objects"

8586

fi

8587

8588

case " $deplibs" in

8589

*\ -l* | *\ -L*)

8590

func_warning "\`-l' and \`-L' are ignored for objects" ;;

8591

esac

8592

8593

test -n "$rpath" && \

8594

func_warning "\`-rpath' is ignored for objects"

8595

8596

test -n "$xrpath" && \

8597

func_warning "\`-R' is ignored for objects"

8598

8599

test -n "$vinfo" && \

8600

func_warning "\`-version-info' is ignored for objects"

8601

8602

test -n "$release" && \

8603

func_warning "\`-release' is ignored for objects"

8604

8605

case $output in

8606

*.lo)

8607

test -n "$objs$old_deplibs" && \

8608

func_fatal_error "cannot build library object \`$output' from non-libtool objects"

8609

8610

libobj=$output

8611

func_lo2o "$libobj"

8612

obj=$func_lo2o_result

8613

;;

8614

*)

8615

libobj=

8616

obj="$output"

8617

;;

8618

esac

8619

8620

# Delete the old objects.

8621

$opt_dry_run || $RM $obj $libobj

8622

8623

# Objects from convenience libraries. This assumes

8624

# single-version convenience libraries. Whenever we create

8625

# different ones for PIC/non-PIC, this we'll have to duplicate

8626

# the extraction.

8627

reload_conv_objs=

8628

gentop=

8629

# reload_cmds runs $LD directly, so let us get rid of

8630

# -Wl from whole_archive_flag_spec and hope we can get by with

8631

# turning comma into space..

8632

wl=

8633

8634

if test -n "$convenience"; then

8635

if test -n "$whole_archive_flag_spec"; then

8636

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

8637

reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

8638

else

8639

gentop="$output_objdir/${obj}x"

8640

func_append generated " $gentop"

8641

8642

func_extract_archives $gentop $convenience

8643

reload_conv_objs="$reload_objs $func_extract_archives_result"

8644

fi

8645

fi

8646

8647

# If we're not building shared, we need to use non_pic_objs

8648

test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

8649

8650

# Create the old-style object.

8651

reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

8652

8653

output="$obj"

8654

func_execute_cmds "$reload_cmds" 'exit $?'

8655

8656

# Exit if we aren't doing a library object file.

8657

if test -z "$libobj"; then

8658

if test -n "$gentop"; then

8659

func_show_eval '${RM}r "$gentop"'

8660

fi

8661

8662

exit $EXIT_SUCCESS

8663

fi

8664

8665

if test "$build_libtool_libs" != yes; then

8666

if test -n "$gentop"; then

8667

func_show_eval '${RM}r "$gentop"'

8668

fi

8669

8670

# Create an invalid libtool object if no PIC, so that we don't

8671

# accidentally link it into a program.

8672

# $show "echo timestamp > $libobj"

8673

# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?

8674

exit $EXIT_SUCCESS

8675

fi

8676

8677

if test -n "$pic_flag" || test "$pic_mode" != default; then

8678

# Only do commands if we really have different PIC objects.

8679

reload_objs="$libobjs $reload_conv_objs"

8680

output="$libobj"

8681

func_execute_cmds "$reload_cmds" 'exit $?'

8682

fi

8683

8684

if test -n "$gentop"; then

8685

func_show_eval '${RM}r "$gentop"'

8686

fi

8687

8688

exit $EXIT_SUCCESS

8689

;;

8690

8691

prog)

8692

case $host in

8693

*cygwin*) func_stripname '' '.exe' "$output"

8694

output=$func_stripname_result.exe;;

8695

esac

8696

test -n "$vinfo" && \

8697

func_warning "\`-version-info' is ignored for programs"

8698

8699

test -n "$release" && \

8700

func_warning "\`-release' is ignored for programs"

8701

8702

test "$preload" = yes \

8703

&& test "$dlopen_support" = unknown \

8704

&& test "$dlopen_self" = unknown \

8705

&& test "$dlopen_self_static" = unknown && \

8706

func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

8707

8708

case $host in

8709

*-*-rhapsody* | *-*-darwin1.[012])

8710

# On Rhapsody replace the C library is the System framework

8711

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

8712

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

8713

;;

8714

esac

8715

8716

case $host in

8717

*-*-darwin*)

8718

# Don't allow lazy linking, it breaks C++ global constructors

8719

# But is supposedly fixed on 10.4 or later (yay!).

8720

if test "$tagname" = CXX ; then

8721

case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

8722

10.[0123])

8723

func_append compile_command " ${wl}-bind_at_load"

8724

func_append finalize_command " ${wl}-bind_at_load"

8725

;;

8726

esac

8727

fi

8728

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

8729

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8730

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8731

;;

8732

esac

8733

8734

8735

# move library search paths that coincide with paths to not yet

8736

# installed libraries to the beginning of the library search list

8737

new_libs=

8738

for path in $notinst_path; do

8739

case " $new_libs " in

8740

*" -L$path/$objdir "*) ;;

8741

*)

8742

case " $compile_deplibs " in

8743

*" -L$path/$objdir "*)

8744

func_append new_libs " -L$path/$objdir" ;;

8745

esac

8746

;;

8747

esac

8748

done

8749

for deplib in $compile_deplibs; do

8750

case $deplib in

8751

-L*)

8752

case " $new_libs " in

8753

*" $deplib "*) ;;

8754

*) func_append new_libs " $deplib" ;;

8755

esac

8756

;;

8757

*) func_append new_libs " $deplib" ;;

8758

esac

8759

done

8760

compile_deplibs="$new_libs"

8761

8762

8763

func_append compile_command " $compile_deplibs"

8764

func_append finalize_command " $finalize_deplibs"

8765

8766

if test -n "$rpath$xrpath"; then

8767

# If the user specified any rpath flags, then add them.

8768

for libdir in $rpath $xrpath; do

8769

# This is the magic to use -rpath.

8770

case "$finalize_rpath " in

8771

*" $libdir "*) ;;

8772

*) func_append finalize_rpath " $libdir" ;;

8773

esac

8774

done

8775

fi

8776

8777

# Now hardcode the library paths

8778

rpath=

8779

hardcode_libdirs=

8780

for libdir in $compile_rpath $finalize_rpath; do

8781

if test -n "$hardcode_libdir_flag_spec"; then

8782

if test -n "$hardcode_libdir_separator"; then

8783

if test -z "$hardcode_libdirs"; then

8784

hardcode_libdirs="$libdir"

8785

else

8786

# Just accumulate the unique libdirs.

8787

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8788

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8789

;;

8790

*)

8791

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8792

;;

8793

esac

8794

fi

8795

else

8796

eval flag=\"$hardcode_libdir_flag_spec\"

8797

func_append rpath " $flag"

8798

fi

8799

elif test -n "$runpath_var"; then

8800

case "$perm_rpath " in

8801

*" $libdir "*) ;;

8802

*) func_append perm_rpath " $libdir" ;;

8803

esac

8804

fi

8805

case $host in

8806

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

8807

testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`

8808

case :$dllsearchpath: in

8809

*":$libdir:"*) ;;

8810

::) dllsearchpath=$libdir;;

8811

*) func_append dllsearchpath ":$libdir";;

8812

esac

8813

case :$dllsearchpath: in

8814

*":$testbindir:"*) ;;

8815

::) dllsearchpath=$testbindir;;

8816

*) func_append dllsearchpath ":$testbindir";;

8817

esac

8818

;;

8819

esac

8820

done

8821

# Substitute the hardcoded libdirs into the rpath.

8822

if test -n "$hardcode_libdir_separator" &&

8823

test -n "$hardcode_libdirs"; then

8824

libdir="$hardcode_libdirs"

8825

eval rpath=\" $hardcode_libdir_flag_spec\"

8826

fi

8827

compile_rpath="$rpath"

8828

8829

rpath=

8830

hardcode_libdirs=

8831

for libdir in $finalize_rpath; do

8832

if test -n "$hardcode_libdir_flag_spec"; then

8833

if test -n "$hardcode_libdir_separator"; then

8834

if test -z "$hardcode_libdirs"; then

8835

hardcode_libdirs="$libdir"

8836

else

8837

# Just accumulate the unique libdirs.

8838

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

8839

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8840

;;

8841

*)

8842

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

8843

;;

8844

esac

8845

fi

8846

else

8847

eval flag=\"$hardcode_libdir_flag_spec\"

8848

func_append rpath " $flag"

8849

fi

8850

elif test -n "$runpath_var"; then

8851

case "$finalize_perm_rpath " in

8852

*" $libdir "*) ;;

8853

*) func_append finalize_perm_rpath " $libdir" ;;

8854

esac

8855

fi

8856

done

8857

# Substitute the hardcoded libdirs into the rpath.

8858

if test -n "$hardcode_libdir_separator" &&

8859

test -n "$hardcode_libdirs"; then

8860

libdir="$hardcode_libdirs"

8861

eval rpath=\" $hardcode_libdir_flag_spec\"

8862

fi

8863

finalize_rpath="$rpath"

8864

8865

if test -n "$libobjs" && test "$build_old_libs" = yes; then

8866

# Transform all the library objects into standard objects.

8867

compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8868

finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8869

fi

8870

8871

func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

8872

8873

# template prelinking step

8874

if test -n "$prelink_cmds"; then

8875

func_execute_cmds "$prelink_cmds" 'exit $?'

8876

fi

8877

8878

wrappers_required=yes

8879

case $host in

8880

*cegcc* | *mingw32ce*)

8881

# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

8882

wrappers_required=no

8883

;;

8884

*cygwin* | *mingw* )

8885

if test "$build_libtool_libs" != yes; then

8886

wrappers_required=no

8887

fi

8888

;;

8889

*)

8890

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

8891

wrappers_required=no

8892

fi

8893

;;

8894

esac

8895

if test "$wrappers_required" = no; then

8896

# Replace the output file specification.

8897

compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8898

link_command="$compile_command$compile_rpath"

8899

8900

# We have no uninstalled library dependencies, so finalize right now.

8901

exit_status=0

8902

func_show_eval "$link_command" 'exit_status=$?'

8903

8904

if test -n "$postlink_cmds"; then

8905

func_to_tool_file "$output"

8906

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8907

func_execute_cmds "$postlink_cmds" 'exit $?'

8908

fi

8909

8910

# Delete the generated files.

8911

if test -f "$output_objdir/${outputname}S.${objext}"; then

8912

func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

8913

fi

8914

8915

exit $exit_status

8916

fi

8917

8918

if test -n "$compile_shlibpath$finalize_shlibpath"; then

8919

compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"

8920

fi

8921

if test -n "$finalize_shlibpath"; then

8922

finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"

8923

fi

8924

8925

compile_var=

8926

finalize_var=

8927

if test -n "$runpath_var"; then

8928

if test -n "$perm_rpath"; then

8929

# We should set the runpath_var.

8930

rpath=

8931

for dir in $perm_rpath; do

8932

func_append rpath "$dir:"

8933

done

8934

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

8935

fi

8936

if test -n "$finalize_perm_rpath"; then

8937

# We should set the runpath_var.

8938

rpath=

8939

for dir in $finalize_perm_rpath; do

8940

func_append rpath "$dir:"

8941

done

8942

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

8943

fi

8944

fi

8945

8946

if test "$no_install" = yes; then

8947

# We don't need to create a wrapper script.

8948

link_command="$compile_var$compile_command$compile_rpath"

8949

# Replace the output file specification.

8950

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

8951

# Delete the old output file.

8952

$opt_dry_run || $RM $output

8953

# Link the executable and exit

8954

func_show_eval "$link_command" 'exit $?'

8955

8956

if test -n "$postlink_cmds"; then

8957

func_to_tool_file "$output"

8958

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8959

func_execute_cmds "$postlink_cmds" 'exit $?'

8960

fi

8961

8962

exit $EXIT_SUCCESS

8963

fi

8964

8965

if test "$hardcode_action" = relink; then

8966

# Fast installation is not supported

8967

link_command="$compile_var$compile_command$compile_rpath"

8968

relink_command="$finalize_var$finalize_command$finalize_rpath"

8969

8970

func_warning "this platform does not like uninstalled shared libraries"

8971

func_warning "\`$output' will be relinked during installation"

8972

else

8973

if test "$fast_install" != no; then

8974

link_command="$finalize_var$compile_command$finalize_rpath"

8975

if test "$fast_install" = yes; then

8976

relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

8977

else

8978

# fast_install is set to needless

8979

relink_command=

8980

fi

8981

else

8982

link_command="$compile_var$compile_command$compile_rpath"

8983

relink_command="$finalize_var$finalize_command$finalize_rpath"

8984

fi

8985

fi

8986

8987

# Replace the output file specification.

8988

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

8989

8990

# Delete the old output files.

8991

$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

8992

8993

func_show_eval "$link_command" 'exit $?'

8994

8995

if test -n "$postlink_cmds"; then

8996

func_to_tool_file "$output_objdir/$outputname"

8997

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'`

8998

func_execute_cmds "$postlink_cmds" 'exit $?'

8999

fi

9000

9001

# Now create the wrapper script.

9002

func_verbose "creating $output"

9003

9004

# Quote the relink command for shipping.

9005

if test -n "$relink_command"; then

9006

# Preserve any variables that may affect compiler behavior

9007

for var in $variables_saved_for_relink; do

9008

if eval test -z \"\${$var+set}\"; then

9009

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9010

elif eval var_value=\$$var; test -z "$var_value"; then

9011

relink_command="$var=; export $var; $relink_command"

9012

else

9013

func_quote_for_eval "$var_value"

9014

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9015

fi

9016

done

9017

relink_command="(cd `pwd`; $relink_command)"

9018

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9019

fi

9020

9021

# Only actually do things if not in dry run mode.

9022

$opt_dry_run || {

9023

# win32 will think the script is a binary if it has

9024

# a .exe suffix, so we strip it off here.

9025

case $output in

9026

*.exe) func_stripname '' '.exe' "$output"

9027

output=$func_stripname_result ;;

9028

esac

9029

# test for cygwin because mv fails w/o .exe extensions

9030

case $host in

9031

*cygwin*)

9032

exeext=.exe

9033

func_stripname '' '.exe' "$outputname"

9034

outputname=$func_stripname_result ;;

9035

*) exeext= ;;

9036

esac

9037

case $host in

9038

*cygwin* | *mingw* )

9039

func_dirname_and_basename "$output" "" "."

9040

output_name=$func_basename_result

9041

output_path=$func_dirname_result

9042

cwrappersource="$output_path/$objdir/lt-$output_name.c"

9043

cwrapper="$output_path/$output_name.exe"

9044

$RM $cwrappersource $cwrapper

9045

trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

9046

9047

func_emit_cwrapperexe_src > $cwrappersource

9048

9049

# The wrapper executable is built using the $host compiler,

9050

# because it contains $host paths and files. If cross-

9051

# compiling, it, like the target executable, must be

9052

# executed on the $host or under an emulation environment.

9053

$opt_dry_run || {

9054

$LTCC $LTCFLAGS -o $cwrapper $cwrappersource

9055

$STRIP $cwrapper

9056

}

9057

9058

# Now, create the wrapper script for func_source use:

9059

func_ltwrapper_scriptname $cwrapper

9060

$RM $func_ltwrapper_scriptname_result

9061

trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15

9062

$opt_dry_run || {

9063

# note: this script will not be executed, so do not chmod.

9064

if test "x$build" = "x$host" ; then

9065

$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result

9066

else

9067

func_emit_wrapper no > $func_ltwrapper_scriptname_result

9068

fi

9069

}

9070

;;

9071

* )

9072

$RM $output

9073

trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

9074

9075

func_emit_wrapper no > $output

9076

chmod +x $output

9077

;;

9078

esac

9079

}

9080

exit $EXIT_SUCCESS

9081

;;

9082

esac

9083

9084

# See if we need to build an old-fashioned archive.

9085

for oldlib in $oldlibs; do

9086

9087

if test "$build_libtool_libs" = convenience; then

9088

oldobjs="$libobjs_save $symfileobj"

9089

addlibs="$convenience"

9090

build_libtool_libs=no

9091

else

9092

if test "$build_libtool_libs" = module; then

9093

oldobjs="$libobjs_save"

9094

build_libtool_libs=no

9095

else

9096

oldobjs="$old_deplibs $non_pic_objects"

9097

if test "$preload" = yes && test -f "$symfileobj"; then

9098

func_append oldobjs " $symfileobj"

9099

fi

9100

fi

9101

addlibs="$old_convenience"

9102

fi

9103

9104

if test -n "$addlibs"; then

9105

gentop="$output_objdir/${outputname}x"

9106

func_append generated " $gentop"

9107

9108

func_extract_archives $gentop $addlibs

9109

func_append oldobjs " $func_extract_archives_result"

9110

fi

9111

9112

# Do each command in the archive commands.

9113

if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then

9114

cmds=$old_archive_from_new_cmds

9115

else

9116

9117

# Add any objects from preloaded convenience libraries

9118

if test -n "$dlprefiles"; then

9119

gentop="$output_objdir/${outputname}x"

9120

func_append generated " $gentop"

9121

9122

func_extract_archives $gentop $dlprefiles

9123

func_append oldobjs " $func_extract_archives_result"

9124

fi

9125

9126

# POSIX demands no paths to be encoded in archives. We have

9127

# to avoid creating archives with duplicate basenames if we

9128

# might have to extract them afterwards, e.g., when creating a

9129

# static archive out of a convenience library, or when linking

9130

# the entirety of a libtool archive into another (currently

9131

# not supported by libtool).

9132

if (for obj in $oldobjs

9133

do

9134

func_basename "$obj"

9135

$ECHO "$func_basename_result"

9136

done | sort | sort -uc >/dev/null 2>&1); then

9137

:

9138

else

9139

echo "copying selected object files to avoid basename conflicts..."

9140

gentop="$output_objdir/${outputname}x"

9141

func_append generated " $gentop"

9142

func_mkdir_p "$gentop"

9143

save_oldobjs=$oldobjs

9144

oldobjs=

9145

counter=1

9146

for obj in $save_oldobjs

9147

do

9148

func_basename "$obj"

9149

objbase="$func_basename_result"

9150

case " $oldobjs " in

9151

" ") oldobjs=$obj ;;

9152

*[\ /]"$objbase "*)

9153

while :; do

9154

# Make sure we don't pick an alternate name that also

9155

# overlaps.

9156

newobj=lt$counter-$objbase

9157

func_arith $counter + 1

9158

counter=$func_arith_result

9159

case " $oldobjs " in

9160

*[\ /]"$newobj "*) ;;

9161

*) if test ! -f "$gentop/$newobj"; then break; fi ;;

9162

esac

9163

done

9164

func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

9165

func_append oldobjs " $gentop/$newobj"

9166

;;

9167

*) func_append oldobjs " $obj" ;;

9168

esac

9169

done

9170

fi

9171

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

9172

tool_oldlib=$func_to_tool_file_result

9173

eval cmds=\"$old_archive_cmds\"

9174

9175

func_len " $cmds"

9176

len=$func_len_result

9177

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

9178

cmds=$old_archive_cmds

9179

elif test -n "$archiver_list_spec"; then

9180

func_verbose "using command file archive linking..."

9181

for obj in $oldobjs

9182

do

9183

func_to_tool_file "$obj"

9184

$ECHO "$func_to_tool_file_result"

9185

done > $output_objdir/$libname.libcmd

9186

func_to_tool_file "$output_objdir/$libname.libcmd"

9187

oldobjs=" $archiver_list_spec$func_to_tool_file_result"

9188

cmds=$old_archive_cmds

9189

else

9190

# the command line is too long to link in one step, link in parts

9191

func_verbose "using piecewise archive linking..."

9192

save_RANLIB=$RANLIB

9193

RANLIB=:

9194

objlist=

9195

concat_cmds=

9196

save_oldobjs=$oldobjs

9197

oldobjs=

9198

# Is there a better way of finding the last object in the list?

9199

for obj in $save_oldobjs

9200

do

9201

last_oldobj=$obj

9202

done

9203

eval test_cmds=\"$old_archive_cmds\"

9204

func_len " $test_cmds"

9205

len0=$func_len_result

9206

len=$len0

9207

for obj in $save_oldobjs

9208

do

9209

func_len " $obj"

9210

func_arith $len + $func_len_result

9211

len=$func_arith_result

9212

func_append objlist " $obj"

9213

if test "$len" -lt "$max_cmd_len"; then

9214

:

9215

else

9216

# the above command should be used before it gets too long

9217

oldobjs=$objlist

9218

if test "$obj" = "$last_oldobj" ; then

9219

RANLIB=$save_RANLIB

9220

fi

9221

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

9222

eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"

9223

objlist=

9224

len=$len0

9225

fi

9226

done

9227

RANLIB=$save_RANLIB

9228

oldobjs=$objlist

9229

if test "X$oldobjs" = "X" ; then

9230

eval cmds=\"\$concat_cmds\"

9231

else

9232

eval cmds=\"\$concat_cmds~\$old_archive_cmds\"

9233

fi

9234

fi

9235

fi

9236

func_execute_cmds "$cmds" 'exit $?'

9237

done

9238

9239

test -n "$generated" && \

9240

func_show_eval "${RM}r$generated"

9241

9242

# Now create the libtool archive.

9243

case $output in

9244

*.la)

9245

old_library=

9246

test "$build_old_libs" = yes && old_library="$libname.$libext"

9247

func_verbose "creating $output"

9248

9249

# Preserve any variables that may affect compiler behavior

9250

for var in $variables_saved_for_relink; do

9251

if eval test -z \"\${$var+set}\"; then

9252

relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"

9253

elif eval var_value=\$$var; test -z "$var_value"; then

9254

relink_command="$var=; export $var; $relink_command"

9255

else

9256

func_quote_for_eval "$var_value"

9257

relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"

9258

fi

9259

done

9260

# Quote the link command for shipping.

9261

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

9262

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

9263

if test "$hardcode_automatic" = yes ; then

9264

relink_command=

9265

fi

9266

9267

# Only create the output if not a dry run.

9268

$opt_dry_run || {

9269

for installed in no yes; do

9270

if test "$installed" = yes; then

9271

if test -z "$install_libdir"; then

9272

break

9273

fi

9274

output="$output_objdir/$outputname"i

9275

# Replace all uninstalled libtool libraries with the installed ones

9276

newdependency_libs=

9277

for deplib in $dependency_libs; do

9278

case $deplib in

9279

*.la)

9280

func_basename "$deplib"

9281

name="$func_basename_result"

9282

func_resolve_sysroot "$deplib"

9283

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $func_resolve_sysroot_result`

9284

test -z "$libdir" && \

9285

func_fatal_error "\`$deplib' is not a valid libtool archive"

9286

func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"

9287

;;

9288

-L*)

9289

func_stripname -L '' "$deplib"

9290

func_replace_sysroot "$func_stripname_result"

9291

func_append newdependency_libs " -L$func_replace_sysroot_result"

9292

;;

9293

-R*)

9294

func_stripname -R '' "$deplib"

9295

func_replace_sysroot "$func_stripname_result"

9296

func_append newdependency_libs " -R$func_replace_sysroot_result"

9297

;;

9298

*) func_append newdependency_libs " $deplib" ;;

9299

esac

9300

done

9301

dependency_libs="$newdependency_libs"

9302

newdlfiles=

9303

9304

for lib in $dlfiles; do

9305

case $lib in

9306

*.la)

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 newdlfiles " ${lt_sysroot:+=}$libdir/$name"

9313

;;

9314

*) func_append newdlfiles " $lib" ;;

9315

esac

9316

done

9317

dlfiles="$newdlfiles"

9318

newdlprefiles=

9319

for lib in $dlprefiles; do

9320

case $lib in

9321

*.la)

9322

# Only pass preopened files to the pseudo-archive (for

9323

# eventual linking with the app. that links it) if we

9324

# didn't already link the preopened objects directly into

9325

# the library:

9326

func_basename "$lib"

9327

name="$func_basename_result"

9328

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9329

test -z "$libdir" && \

9330

func_fatal_error "\`$lib' is not a valid libtool archive"

9331

func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"

9332

;;

9333

esac

9334

done

9335

dlprefiles="$newdlprefiles"

9336

else

9337

newdlfiles=

9338

for lib in $dlfiles; do

9339

case $lib in

9340

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9341

*) abs=`pwd`"/$lib" ;;

9342

esac

9343

func_append newdlfiles " $abs"

9344

done

9345

dlfiles="$newdlfiles"

9346

newdlprefiles=

9347

for lib in $dlprefiles; do

9348

case $lib in

9349

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9350

*) abs=`pwd`"/$lib" ;;

9351

esac

9352

func_append newdlprefiles " $abs"

9353

done

9354

dlprefiles="$newdlprefiles"

9355

fi

9356

$RM $output

9357

# place dlname in correct position for cygwin

9358

# In fact, it would be nice if we could use this code for all target

9359

# systems that can't hard-code library paths into their executables

9360

# and that have no shared library path variable independent of PATH,

9361

# but it turns out we can't easily determine that from inspecting

9362

# libtool variables, so we have to hard-code the OSs to which it

9363

# applies here; at the moment, that means platforms that use the PE

9364

# object format with DLL files. See the long comment at the top of

9365

# tests/bindir.at for full details.

9366

tdlname=$dlname

9367

case $host,$output,$installed,$module,$dlname in

9368

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9369

# If a -bindir argument was supplied, place the dll there.

9370

if test "x$bindir" != x ;

9371

then

9372

func_relative_path "$install_libdir" "$bindir"

9373

tdlname=$func_relative_path_result$dlname

9374

else

9375

# Otherwise fall back on heuristic.

9376

tdlname=../bin/$dlname

9377

fi

9378

;;

9379

esac

9380

$ECHO > $output "\

9381

# $outputname - a libtool library file

9382

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

9383

#

9384

# Please DO NOT delete this file!

9385

# It is necessary for linking the library.

9386

9387

# The name that we can dlopen(3).

9388

dlname='$tdlname'

9389

9390

# Names of this library.

9391

library_names='$library_names'

9392

9393

# The name of the static archive.

9394

old_library='$old_library'

9395

9396

# Linker flags that can not go in dependency_libs.

9397

inherited_linker_flags='$new_inherited_linker_flags'

9398

9399

# Libraries that this one depends upon.

9400

dependency_libs='$dependency_libs'

9401

9402

# Names of additional weak libraries provided by this library

9403

weak_library_names='$weak_libs'

9404

9405

# Version information for $libname.

9406

current=$current

9407

age=$age

9408

revision=$revision

9409

9410

# Is this an already installed library?

9411

installed=$installed

9412

9413

# Should we warn about portability when linking against -modules?

9414

shouldnotlink=$module

9415

9416

# Files to dlopen/dlpreopen

9417

dlopen='$dlfiles'

9418

dlpreopen='$dlprefiles'

9419

9420

# Directory that this library needs to be installed in:

9421

libdir='$install_libdir'"

9422

if test "$installed" = no && test "$need_relink" = yes; then

9423

$ECHO >> $output "\

9424

relink_command=\"$relink_command\""

9425

fi

9426

done

9427

}

9428

9429

# Do a symbolic link so that the libtool archive can be found in

9430

# LD_LIBRARY_PATH before the program is installed.

9431

func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'

9432

;;

9433

esac

9434

exit $EXIT_SUCCESS

9435

}

9436

9437

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&

9438

func_mode_link ${1+"$@"}

9439

9440

9441

# func_mode_uninstall arg...

9442

func_mode_uninstall ()

9443

{

9444

$opt_debug

9445

RM="$nonopt"

9446

files=

9447

rmforce=

9448

exit_status=0

9449

9450

# This variable tells wrapper scripts just to set variables rather

9451

# than running their programs.

9452

libtool_install_magic="$magic"

9453

9454

for arg

9455

do

9456

case $arg in

9457

-f) func_append RM " $arg"; rmforce=yes ;;

9458

-*) func_append RM " $arg" ;;

9459

*) func_append files " $arg" ;;

9460

esac

9461

done

9462

9463

test -z "$RM" && \

9464

func_fatal_help "you must specify an RM program"

9465

9466

rmdirs=

9467

9468

for file in $files; do

9469

func_dirname "$file" "" "."

9470

dir="$func_dirname_result"

9471

if test "X$dir" = X.; then

9472

odir="$objdir"

9473

else

9474

odir="$dir/$objdir"

9475

fi

9476

func_basename "$file"

9477

name="$func_basename_result"

9478

test "$opt_mode" = uninstall && odir="$dir"

9479

9480

# Remember odir for removal later, being careful to avoid duplicates

9481

if test "$opt_mode" = clean; then

9482

case " $rmdirs " in

9483

*" $odir "*) ;;

9484

*) func_append rmdirs " $odir" ;;

9485

esac

9486

fi

9487

9488

# Don't error if the file doesn't exist and rm -f was used.

9489

if { test -L "$file"; } >/dev/null 2>&1 ||

9490

{ test -h "$file"; } >/dev/null 2>&1 ||

9491

test -f "$file"; then

9492

:

9493

elif test -d "$file"; then

9494

exit_status=1

9495

continue

9496

elif test "$rmforce" = yes; then

9497

continue

9498

fi

9499

9500

rmfiles="$file"

9501

9502

case $name in

9503

*.la)

9504

# Possibly a libtool archive, so verify it.

9505

if func_lalib_p "$file"; then

9506

func_source $dir/$name

9507

9508

# Delete the libtool libraries and symlinks.

9509

for n in $library_names; do

9510

func_append rmfiles " $odir/$n"

9511

done

9512

test -n "$old_library" && func_append rmfiles " $odir/$old_library"

9513

9514

case "$opt_mode" in

9515

clean)

9516

case " $library_names " in

9517

*" $dlname "*) ;;

9518

*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;

9519

esac

9520

test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"

9521

;;

9522

uninstall)

9523

if test -n "$library_names"; then

9524

# Do each command in the postuninstall commands.

9525

func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9526

fi

9527

9528

if test -n "$old_library"; then

9529

# Do each command in the old_postuninstall commands.

9530

func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'

9531

fi

9532

# FIXME: should reinstall the best remaining shared library.

9533

;;

9534

esac

9535

fi

9536

;;

9537

9538

*.lo)

9539

# Possibly a libtool object, so verify it.

9540

if func_lalib_p "$file"; then

9541

9542

# Read the .lo file

9543

func_source $dir/$name

9544

9545

# Add PIC object to the list of files to remove.

9546

if test -n "$pic_object" &&

9547

test "$pic_object" != none; then

9548

func_append rmfiles " $dir/$pic_object"

9549

fi

9550

9551

# Add non-PIC object to the list of files to remove.

9552

if test -n "$non_pic_object" &&

9553

test "$non_pic_object" != none; then

9554

func_append rmfiles " $dir/$non_pic_object"

9555

fi

9556

fi

9557

;;

9558

9559

*)

9560

if test "$opt_mode" = clean ; then

9561

noexename=$name

9562

case $file in

9563

*.exe)

9564

func_stripname '' '.exe' "$file"

9565

file=$func_stripname_result

9566

func_stripname '' '.exe' "$name"

9567

noexename=$func_stripname_result

9568

# $file with .exe has already been added to rmfiles,

9569

# add $file without .exe

9570

func_append rmfiles " $file"

9571

;;

9572

esac

9573

# Do a test to see if this is a libtool program.

9574

if func_ltwrapper_p "$file"; then

9575

if func_ltwrapper_executable_p "$file"; then

9576

func_ltwrapper_scriptname "$file"

9577

relink_command=

9578

func_source $func_ltwrapper_scriptname_result

9579

func_append rmfiles " $func_ltwrapper_scriptname_result"

9580

else

9581

relink_command=

9582

func_source $dir/$noexename

9583

fi

9584

9585

# note $name still contains .exe if it was in $file originally

9586

# as does the version of $file that was added into $rmfiles

9587

func_append rmfiles " $odir/$name $odir/${name}S.${objext}"

9588

if test "$fast_install" = yes && test -n "$relink_command"; then

9589

func_append rmfiles " $odir/lt-$name"

9590

fi

9591

if test "X$noexename" != "X$name" ; then

9592

func_append rmfiles " $odir/lt-${noexename}.c"

9593

fi

9594

fi

9595

fi

9596

;;

9597

esac

9598

func_show_eval "$RM $rmfiles" 'exit_status=1'

9599

done

9600

9601

# Try to remove the ${objdir}s in the directories where we deleted files

9602

for dir in $rmdirs; do

9603

if test -d "$dir"; then

9604

func_show_eval "rmdir $dir >/dev/null 2>&1"

9605

fi

9606

done

9607

9608

exit $exit_status

9609

}

9610

9611

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&

9612

func_mode_uninstall ${1+"$@"}

9613

9614

test -z "$opt_mode" && {

9615

help="$generic_help"

9616

func_fatal_help "you must specify a MODE"

9617

}

9618

9619

test -z "$exec_cmd" && \

9620

func_fatal_help "invalid operation mode \`$opt_mode'"

9621

9622

if test -n "$exec_cmd"; then

9623

eval exec "$exec_cmd"

9624

exit $EXIT_FAILURE

9625

fi

9626

9627

exit $exit_status

9628

9629

9630

# The TAGs below are defined such that we never get into a situation

9631

# in which we disable both kinds of libraries. Given conflicting

9632

# choices, we go for a static library, that is the most portable,

9633

# since we can't tell whether shared libraries were disabled because

9634

# the user asked for that or because the platform doesn't support

9635

# them. This is particularly important on AIX, because we don't

9636

# support having both static and shared libraries enabled at the same

9637

# time on that platform, so we default to a shared-only configuration.

9638

# If a disable-shared tag is given, we'll fallback to a static-only

9639

# configuration. But we'll never go from static-only to shared-only.

9640

9641

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared

9642

build_libtool_libs=no

9643

build_old_libs=yes

9644

# ### END LIBTOOL TAG CONFIG: disable-shared

9645

9646

# ### BEGIN LIBTOOL TAG CONFIG: disable-static

9647

build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`

9648

# ### END LIBTOOL TAG CONFIG: disable-static

9649

9650

# Local Variables:

9651

# mode:shell-script

9652

# sh-indentation:2

9653

# End:

9654

# vi:sw=2

9655