~ubuntu-branches/ubuntu/vivid/liferea/vivid-proposed : revision 122

1

# Generated from ltmain.m4sh.

2

1

3

# ltmain.sh (GNU libtool) 2.2.6b

2

# libtool (GNU libtool) 2.4.2

4

3

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

5

4

6

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

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

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

43

# -v, --verbose print informational messages (default)

44

# --version print version information

45

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

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

46

50

#

47

51

# MODE must be one of the following:

48

52

#

49

# clean remove files from the build directory

50

# compile compile a source file into a libtool object

51

# execute automatically set library path, then run a program

52

# finish complete the installation of libtool libraries

53

# install install libraries or executables

54

# link create a library or an executable

55

# uninstall remove libraries from an installed directory

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

56

60

#

57

# MODE-ARGS vary depending on the MODE.

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.

58

63

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

59

64

#

60

65

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

61

66

# include the following information:

62

67

#

63

# host-triplet: $host

64

# shell: $SHELL

65

# compiler: $LTCC

66

# compiler flags: $LTCFLAGS

67

# linker: $LD (gnu? $with_gnu_ld)

68

# $progname: (GNU libtool) 2.2.6b Debian-2.2.6b-2ubuntu3

69

# automake: $automake_version

70

# autoconf: $autoconf_version

68

# host-triplet: $host

69

# shell: $SHELL

70

# compiler: $LTCC

71

# compiler flags: $LTCFLAGS

72

# linker: $LD (gnu? $with_gnu_ld)

73

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

74

# automake: $automake_version

75

# autoconf: $autoconf_version

71

76

#

72

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/>.

73

80

74

PROGRAM=ltmain.sh

81

PROGRAM=libtool

75

82

PACKAGE=libtool

76

VERSION="2.2.6b Debian-2.2.6b-2ubuntu3"

83

VERSION="2.4.2 Debian-2.4.2-1"

77

84

TIMESTAMP=""

78

package_revision=1.3017

85

package_revision=1.3337

79

86

80

87

# Be Bourne compatible

81

88

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

91

98

BIN_SH=xpg4; export BIN_SH # for Tru64

92

99

DUALCASE=1; export DUALCASE # for MKS sh

93

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

94

109

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

95

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

96

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

97

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

98

110

lt_user_locale=

99

111

lt_safe_locale=

100

112

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

107

119

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

108

120

fi"

109

121

done

122

LC_ALL=C

123

LANGUAGE=C

124

export LANGUAGE LC_ALL

110

125

111

126

$lt_unset CDPATH

112

127

113

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"

114

135

115

136

116

137

117

138

: ${CP="cp -f"}

118

: ${ECHO="echo"}

119

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

120

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

121

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

122

: ${LN_S="ln -s"}

139

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

123

140

: ${MAKE="make"}

124

141

: ${MKDIR="mkdir"}

125

142

: ${MV="mv -f"}

126

143

: ${RM="rm -f"}

127

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

128

144

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

129

145

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

130

146

144

160

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

145

161

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

146

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

147

184

# func_dirname_and_basename file append nondir_replacement

148

185

# perform func_basename and func_dirname in a single function

149

186

# call:

158

195

# those functions but instead duplicate the functionality here.

159

196

func_dirname_and_basename ()

160

197

{

161

# Extract subdirectory from the argument.

162

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

163

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

164

func_dirname_result="${3}"

165

else

166

func_dirname_result="$func_dirname_result${2}"

167

fi

168

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

169

}

170

171

# Generated shell functions inserted here.

172

173

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

174

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

175

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

176

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

177

# function.

178

progpath="$0"

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

}

179

371

180

372

# The name of this program:

181

# In the unlikely event $progname began with a '-', it would play havoc with

182

# func_echo (imagine progname=-n), so we prepend ./ in that case:

183

373

func_dirname_and_basename "$progpath"

184

374

progname=$func_basename_result

185

case $progname in

186

-*) progname=./$progname ;;

187

esac

188

375

189

376

# Make sure we have an absolute path for reexecution:

190

377

case $progpath in

196

383

;;

197

384

*)

198

385

save_IFS="$IFS"

199

IFS=:

386

IFS=${PATH_SEPARATOR-:}

200

387

for progdir in $PATH; do

201

388

IFS="$save_IFS"

202

389

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

215

402

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

216

403

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

217

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

218

414

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

219

415

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

220

416

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

243

439

# name if it has been set yet.

244

440

func_echo ()

245

441

{

246

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

442

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

247

443

}

248

444

249

445

# func_verbose arg...

258

454

:

259

455

}

260

456

457

# func_echo_all arg...

458

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

459

func_echo_all ()

460

{

461

$ECHO "$*"

462

}

463

261

464

# func_error arg...

262

465

# Echo program name prefixed message to standard error.

263

466

func_error ()

264

467

{

265

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

468

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

266

469

}

267

470

268

471

# func_warning arg...

269

472

# Echo program name prefixed warning message to standard error.

270

473

func_warning ()

271

474

{

272

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

475

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

273

476

274

477

# bash bug again:

275

478

:

326

529

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

327

530

328

531

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

329

my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`

532

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

330

533

done

331

my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`

534

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

332

535

333

536

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

334

537

for my_dir in $my_dir_list; do

378

581

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

379

582

fi

380

583

381

$ECHO "X$my_tmpdir" | $Xsed

584

$ECHO "$my_tmpdir"

382

585

}

383

586

384

587

392

595

{

393

596

case $1 in

394

597

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

395

func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;

598

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

396

599

*)

397

600

func_quote_for_eval_unquoted_result="$1" ;;

398

601

esac

419

622

{

420

623

case $1 in

421

624

*[\\\`\"]*)

422

my_arg=`$ECHO "X$1" | $Xsed \

625

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

423

626

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

424

627

*)

425

628

my_arg="$1" ;;

488

691

fi

489

692

}

490

693

491

492

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

}

493

710

494

711

495

712

# func_version

496

713

# Echo version message to standard output and exit.

497

714

func_version ()

498

715

{

499

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

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; / {

500

727

s/^# //

501

728

s/^# *$//

502

729

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

509

736

# Echo short help message to standard output and exit.

510

737

func_usage ()

511

738

{

512

$SED -n '/^# Usage:/,/# -h/ {

739

$opt_debug

740

741

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

513

742

s/^# //

514

743

s/^# *$//

515

744

s/\$progname/'$progname'/

516

745

p

517

746

}' < "$progpath"

518

$ECHO

747

echo

519

748

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

520

749

exit $?

521

750

}

522

751

523

# func_help

524

# Echo long help message to standard output and exit.

752

# func_help [NOEXIT]

753

# Echo long help message to standard output and exit,

754

# unless 'noexit' is passed as argument.

525

755

func_help ()

526

756

{

757

$opt_debug

758

527

759

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

760

:print

528

761

s/^# //

529

762

s/^# *$//

530

763

s*\$progname*'$progname'*

534

767

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

535

768

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

536

769

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

537

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

538

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

770

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

771

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

539

772

p

540

}' < "$progpath"

541

exit $?

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

542

782

}

543

783

544

784

# func_missing_arg argname

546

786

# exit_cmd.

547

787

func_missing_arg ()

548

788

{

549

func_error "missing argument for $1"

789

$opt_debug

790

791

func_error "missing argument for $1."

550

792

exit_cmd=exit

551

793

}

552

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

553

821

exit_cmd=:

554

822

555

823

556

824

557

825

558

826

559

# Check that we have a working $ECHO.

560

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

561

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

562

shift

563

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

564

# Avoid inline document here, it may be left over

565

:

566

elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then

567

# Yippee, $ECHO works!

568

:

569

else

570

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

571

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

572

fi

573

574

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

575

# used as fallback echo

576

shift

577

cat <<EOF

578

$*

579

EOF

580

exit $EXIT_SUCCESS

581

fi

582

583

827

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

584

828

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

585

829

586

830

# Global variables.

587

# $mode is unset

588

831

nonopt=

589

execute_dlfiles=

590

832

preserve_args=

591

833

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

592

834

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

593

835

extracted_archives=

594

836

extracted_serial=0

595

837

596

opt_dry_run=false

597

opt_duplicate_deps=false

598

opt_silent=false

599

opt_debug=:

600

601

838

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

602

839

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

603

840

# left over by shells.

604

841

exec_cmd=

605

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

606

889

# func_fatal_configuration arg...

607

890

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

608

891

# a configuration failure hint, and exit.

636

919

# Display the features supported by this script.

637

920

func_features ()

638

921

{

639

$ECHO "host: $host"

922

echo "host: $host"

640

923

if test "$build_libtool_libs" = yes; then

641

$ECHO "enable shared libraries"

924

echo "enable shared libraries"

642

925

else

643

$ECHO "disable shared libraries"

926

echo "disable shared libraries"

644

927

fi

645

928

if test "$build_old_libs" = yes; then

646

$ECHO "enable static libraries"

929

echo "enable static libraries"

647

930

else

648

$ECHO "disable static libraries"

931

echo "disable static libraries"

649

932

fi

650

933

651

934

exit $?

692

975

esac

693

976

}

694

977

695

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

696

# the script to make things like `libtool --version' happen quickly.

697

{

698

699

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

700

case $1 in

701

clean|clea|cle|cl)

702

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

703

;;

704

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

705

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

706

;;

707

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

708

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

709

;;

710

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

711

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

712

;;

713

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

714

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

715

;;

716

link|lin|li|l)

717

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

718

;;

719

720

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

721

;;

722

esac

723

724

# Parse non-mode specific arguments:

725

while test "$#" -gt 0; do

726

opt="$1"

727

shift

728

729

case $opt in

730

--config) func_config ;;

731

732

--debug) preserve_args="$preserve_args $opt"

733

func_echo "enabling shell trace mode"

734

opt_debug='set -x'

735

$opt_debug

736

;;

737

738

-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break

739

execute_dlfiles="$execute_dlfiles $1"

740

shift

741

;;

742

743

--dry-run | -n) opt_dry_run=: ;;

744

--features) func_features ;;

745

--finish) mode="finish" ;;

746

747

--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break

748

case $1 in

749

# Valid mode arguments:

750

clean) ;;

751

compile) ;;

752

execute) ;;

753

finish) ;;

754

install) ;;

755

link) ;;

756

relink) ;;

757

uninstall) ;;

758

759

# Catch anything else as an error

760

*) func_error "invalid argument for $opt"

761

exit_cmd=exit

762

break

763

;;

764

esac

765

766

mode="$1"

767

shift

768

;;

769

770

--preserve-dup-deps)

771

opt_duplicate_deps=: ;;

772

773

--quiet|--silent) preserve_args="$preserve_args $opt"

774

opt_silent=:

775

;;

776

777

--verbose| -v) preserve_args="$preserve_args $opt"

778

opt_silent=false

779

;;

780

781

--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break

782

preserve_args="$preserve_args $opt $1"

783

func_enable_tag "$1" # tagname is set here

784

shift

785

;;

786

787

# Separate optargs to long options:

788

-dlopen=*|--mode=*|--tag=*)

789

func_opt_split "$opt"

790

set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}

791

shift

792

;;

793

794

-\?|-h) func_usage ;;

795

--help) opt_help=: ;;

796

--version) func_version ;;

797

798

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

799

800

*) nonopt="$opt"

801

break

802

;;

803

esac

804

done

805

806

807

case $host in

808

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

809

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

810

opt_duplicate_compiler_generated_deps=:

811

;;

812

*)

813

opt_duplicate_compiler_generated_deps=$opt_duplicate_deps

814

;;

815

esac

816

817

# Having warned about all mis-specified options, bail out if

818

# anything was wrong.

819

$exit_cmd $EXIT_FAILURE

820

}

821

822

978

# func_check_version_match

823

979

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

824

980

# release of libtool.

855

1011

}

856

1012

857

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

858

1223

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

859

1224

## Main. ##

860

1225

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

861

1226

862

$opt_help || {

863

# Sanity checks first:

864

func_check_version_match

865

866

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

867

func_fatal_configuration "not configured to build any kind of library"

868

fi

869

870

test -z "$mode" && func_fatal_error "error: you must specify a MODE."

871

872

873

# Darwin sucks

874

eval std_shrext=\"$shrext_cmds\"

875

876

877

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

878

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

879

func_error "unrecognized option \`-dlopen'"

880

$ECHO "$help" 1>&2

881

exit $EXIT_FAILURE

882

fi

883

884

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

885

generic_help="$help"

886

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

887

}

888

889

890

1227

# func_lalib_p file

891

1228

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

892

1229

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

950

1287

# temporary ltwrapper_script.

951

1288

func_ltwrapper_scriptname ()

952

1289

{

953

func_ltwrapper_scriptname_result=""

954

if func_ltwrapper_executable_p "$1"; then

955

func_dirname_and_basename "$1" "" "."

956

func_stripname '' '.exe' "$func_basename_result"

957

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

958

fi

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"

959

1293

}

960

1294

961

1295

# func_ltwrapper_p file

1001

1335

}

1002

1336

1003

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

1004

1369

# func_infer_tag arg

1005

1370

# Infer tagged configuration to use if any are available and

1006

1371

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

1013

1378

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

1014

1379

CC_quoted=

1015

1380

for arg in $CC; do

1016

func_quote_for_eval "$arg"

1017

CC_quoted="$CC_quoted $func_quote_for_eval_result"

1381

func_append_quoted CC_quoted "$arg"

1018

1382

done

1383

CC_expanded=`func_echo_all $CC`

1384

CC_quoted_expanded=`func_echo_all $CC_quoted`

1019

1385

case $@ in

1020

1386

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

1021

1387

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

1022

1388

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

1389

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

1023

1390

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

1024

1391

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

1025

1392

*)

1030

1397

CC_quoted=

1031

1398

for arg in $CC; do

1032

1399

# Double-quote args containing other shell metacharacters.

1033

func_quote_for_eval "$arg"

1034

CC_quoted="$CC_quoted $func_quote_for_eval_result"

1400

func_append_quoted CC_quoted "$arg"

1035

1401

done

1402

CC_expanded=`func_echo_all $CC`

1403

CC_quoted_expanded=`func_echo_all $CC_quoted`

1036

1404

case "$@ " in

1037

1405

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

1406

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

1038

1407

# The compiler in the base compile command matches

1039

1408

# the one in the tagged configuration.

1040

1409

# Assume this is the tagged configuration we want.

1097

1466

}

1098

1467

}

1099

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

1100

1949

# func_mode_compile arg...

1101

1950

func_mode_compile ()

1102

1951

{

1137

1986

;;

1138

1987

1139

1988

-pie | -fpie | -fPIE)

1140

pie_flag="$pie_flag $arg"

1989

func_append pie_flag " $arg"

1141

1990

continue

1142

1991

;;

1143

1992

1144

1993

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

1145

later="$later $arg"

1994

func_append later " $arg"

1146

1995

continue

1147

1996

;;

1148

1997

1163

2012

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

1164

2013

for arg in $args; do

1165

2014

IFS="$save_ifs"

1166

func_quote_for_eval "$arg"

1167

lastarg="$lastarg $func_quote_for_eval_result"

2015

func_append_quoted lastarg "$arg"

1168

2016

done

1169

2017

IFS="$save_ifs"

1170

2018

func_stripname ' ' '' "$lastarg"

1171

2019

lastarg=$func_stripname_result

1172

2020

1173

2021

# Add the arguments to base_compile.

1174

base_compile="$base_compile $lastarg"

2022

func_append base_compile " $lastarg"

1175

2023

continue

1176

2024

;;

1177

2025

1187

2035

esac # case $arg_mode

1188

2036

1189

2037

# Aesthetically quote the previous argument.

1190

func_quote_for_eval "$lastarg"

1191

base_compile="$base_compile $func_quote_for_eval_result"

2038

func_append_quoted base_compile "$lastarg"

1192

2039

done # for arg

1193

2040

1194

2041

case $arg_mode in

1213

2060

*.[cCFSifmso] | \

1214

2061

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

1215

2062

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

1216

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

2063

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

1217

2064

func_xform "$libobj"

1218

2065

libobj=$func_xform_result

1219

2066

;;

1288

2135

# Calculate the filename of the output object if compiler does

1289

2136

# not support -o with -c

1290

2137

if test "$compiler_c_o" = no; then

1291

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

2138

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

1292

2139

lockfile="$output_obj.lock"

1293

2140

else

1294

2141

output_obj=

1319

2166

$opt_dry_run || $RM $removelist

1320

2167

exit $EXIT_FAILURE

1321

2168

fi

1322

removelist="$removelist $output_obj"

2169

func_append removelist " $output_obj"

1323

2170

$ECHO "$srcfile" > "$lockfile"

1324

2171

fi

1325

2172

1326

2173

$opt_dry_run || $RM $removelist

1327

removelist="$removelist $lockfile"

2174

func_append removelist " $lockfile"

1328

2175

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

1329

2176

1330

if test -n "$fix_srcfile_path"; then

1331

eval srcfile=\"$fix_srcfile_path\"

1332

fi

2177

func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2178

srcfile=$func_to_tool_file_result

1333

2179

func_quote_for_eval "$srcfile"

1334

2180

qsrcfile=$func_quote_for_eval_result

1335

2181

1349

2195

1350

2196

if test -z "$output_obj"; then

1351

2197

# Place PIC objects in $objdir

1352

command="$command -o $lobj"

2198

func_append command " -o $lobj"

1353

2199

fi

1354

2200

1355

2201

func_show_eval_locale "$command" \

1396

2242

command="$base_compile $qsrcfile $pic_flag"

1397

2243

fi

1398

2244

if test "$compiler_c_o" = yes; then

1399

command="$command -o $obj"

2245

func_append command " -o $obj"

1400

2246

fi

1401

2247

1402

2248

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

1403

command="$command$suppress_output"

2249

func_append command "$suppress_output"

1404

2250

func_show_eval_locale "$command" \

1405

2251

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

1406

2252

1445

2291

}

1446

2292

1447

2293

$opt_help || {

1448

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

2294

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

1449

2295

}

1450

2296

1451

2297

func_mode_help ()

1452

2298

{

1453

2299

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

1454

case $mode in

2300

case $opt_mode in

1455

2301

"")

1456

2302

# Generic help is extracted from the usage comments

1457

2303

# at the start of this file.

1482

2328

1483

2329

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

1484

2330

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

1485

-prefer-pic try to building PIC objects only

1486

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

2331

-prefer-pic try to build PIC objects only

2332

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

1487

2333

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

1488

2334

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

2335

-Wc,FLAG pass FLAG directly to the compiler

1489

2336

1490

2337

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

1491

2338

from the given SOURCEFILE.

1538

2385

1539

2386

The following components of INSTALL-COMMAND are treated specially:

1540

2387

1541

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

2388

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

1542

2389

1543

2390

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

1544

2391

BSD-compatible install options are recognized)."

1558

2405

1559

2406

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

1560

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)

1561

2410

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

1562

2411

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

1563

2412

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

1586

2435

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

1587

2436

specify library version info [each variable defaults to 0]

1588

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)

1589

2443

1590

2444

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

1591

2445

1619

2473

;;

1620

2474

1621

2475

*)

1622

func_fatal_help "invalid operation mode \`$mode'"

2476

func_fatal_help "invalid operation mode \`$opt_mode'"

1623

2477

;;

1624

2478

esac

1625

2479

1626

$ECHO

2480

echo

1627

2481

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

1628

1629

exit $?

1630

2482

}

1631

2483

1632

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

1633

$opt_help && func_mode_help

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

1634

2514

1635

2515

1636

2516

# func_mode_execute arg...

1643

2523

func_fatal_help "you must specify a COMMAND"

1644

2524

1645

2525

# Handle -dlopen flags immediately.

1646

for file in $execute_dlfiles; do

2526

for file in $opt_dlopen; do

1647

2527

test -f "$file" \

1648

2528

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

1649

2529

1650

2530

dir=

1651

2531

case $file in

1652

2532

*.la)

2533

func_resolve_sysroot "$file"

2534

file=$func_resolve_sysroot_result

2535

1653

2536

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

1654

2537

func_lalib_unsafe_p "$file" \

1655

2538

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

1671

2554

dir="$func_dirname_result"

1672

2555

1673

2556

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

1674

dir="$dir/$objdir"

2557

func_append dir "/$objdir"

1675

2558

else

1676

2559

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

1677

2560

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

1712

2595

for file

1713

2596

do

1714

2597

case $file in

1715

-*) ;;

2598

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

1716

2599

*)

1717

2600

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

1718

2601

if func_ltwrapper_script_p "$file"; then

1728

2611

;;

1729

2612

esac

1730

2613

# Quote arguments (to preserve shell metacharacters).

1731

func_quote_for_eval "$file"

1732

args="$args $func_quote_for_eval_result"

2614

func_append_quoted args "$file"

1733

2615

done

1734

2616

1735

2617

if test "X$opt_dry_run" = Xfalse; then

1754

2636

# Display what would be done.

1755

2637

if test -n "$shlibpath_var"; then

1756

2638

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

1757

$ECHO "export $shlibpath_var"

2639

echo "export $shlibpath_var"

1758

2640

fi

1759

2641

$ECHO "$cmd$args"

1760

2642

exit $EXIT_SUCCESS

1761

2643

fi

1762

2644

}

1763

2645

1764

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

2646

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

1765

2647

1766

2648

1767

2649

# func_mode_finish arg...

1768

2650

func_mode_finish ()

1769

2651

{

1770

2652

$opt_debug

1771

libdirs="$nonopt"

2653

libs=

2654

libdirs=

1772

2655

admincmds=

1773

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

1774

2698

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

1775

for dir

1776

do

1777

libdirs="$libdirs $dir"

1778

done

1779

1780

2699

for libdir in $libdirs; do

1781

2700

if test -n "$finish_cmds"; then

1782

2701

# Do each command in the finish commands.

1786

2705

if test -n "$finish_eval"; then

1787

2706

# Do the single finish_eval.

1788

2707

eval cmds=\"$finish_eval\"

1789

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

2708

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

1790

2709

$cmds"

1791

2710

fi

1792

2711

done

1795

2714

# Exit here if they wanted silent mode.

1796

2715

$opt_silent && exit $EXIT_SUCCESS

1797

2716

1798

$ECHO "X----------------------------------------------------------------------" | $Xsed

1799

$ECHO "Libraries have been installed in:"

1800

for libdir in $libdirs; do

1801

$ECHO " $libdir"

1802

done

1803

$ECHO

1804

$ECHO "If you ever happen to want to link against installed libraries"

1805

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

1806

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

1807

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

1808

if test -n "$shlibpath_var"; then

1809

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

1810

$ECHO " during execution"

1811

fi

1812

if test -n "$runpath_var"; then

1813

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

1814

$ECHO " during linking"

1815

fi

1816

if test -n "$hardcode_libdir_flag_spec"; then

1817

libdir=LIBDIR

1818

eval flag=\"$hardcode_libdir_flag_spec\"

1819

1820

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

1821

fi

1822

if test -n "$admincmds"; then

1823

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

1824

fi

1825

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

1826

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

1827

fi

1828

$ECHO

1829

1830

$ECHO "See any operating system documentation about shared libraries for"

1831

case $host in

1832

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

1833

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

1834

$ECHO "pages."

1835

;;

1836

*)

1837

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

1838

;;

1839

esac

1840

$ECHO "X----------------------------------------------------------------------" | $Xsed

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

1841

2762

exit $EXIT_SUCCESS

1842

2763

}

1843

2764

1844

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

2765

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

1845

2766

1846

2767

1847

2768

# func_mode_install arg...

1852

2773

# install_prog (especially on Windows NT).

1853

2774

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

1854

2775

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

1855

$ECHO "X$nonopt" | $GREP shtool >/dev/null; then

2776

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

1856

2777

# Aesthetically quote it.

1857

2778

func_quote_for_eval "$nonopt"

1858

2779

install_prog="$func_quote_for_eval_result "

1866

2787

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

1867

2788

# Aesthetically quote it.

1868

2789

func_quote_for_eval "$arg"

1869

install_prog="$install_prog$func_quote_for_eval_result"

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

1870

2796

1871

2797

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

1872

2798

dest=

1876

2802

install_type=

1877

2803

isdir=no

1878

2804

stripme=

2805

no_mode=:

1879

2806

for arg

1880

2807

do

2808

arg2=

1881

2809

if test -n "$dest"; then

1882

files="$files $dest"

2810

func_append files " $dest"

1883

2811

dest=$arg

1884

2812

continue

1885

2813

fi

1887

2815

case $arg in

1888

2816

-d) isdir=yes ;;

1889

2817

-f)

1890

case " $install_prog " in

1891

*[\\\ /]cp\ *) ;;

1892

*) prev=$arg ;;

1893

esac

2818

if $install_cp; then :; else

2819

prev=$arg

2820

fi

1894

2821

;;

1895

2822

-g | -m | -o)

1896

2823

prev=$arg

1904

2831

*)

1905

2832

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

1906

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

1907

2838

prev=

1908

2839

else

1909

2840

dest=$arg

1914

2845

1915

2846

# Aesthetically quote the argument.

1916

2847

func_quote_for_eval "$arg"

1917

install_prog="$install_prog $func_quote_for_eval_result"

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"

1918

2853

done

1919

2854

1920

2855

test -z "$install_prog" && \

1923

2858

test -n "$prev" && \

1924

2859

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

1925

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

1926

2868

if test -z "$files"; then

1927

2869

if test -z "$dest"; then

1928

2870

func_fatal_help "no file or destination specified"

1977

2919

case $file in

1978

2920

*.$libext)

1979

2921

# Do the static libraries later.

1980

staticlibs="$staticlibs $file"

2922

func_append staticlibs " $file"

1981

2923

;;

1982

2924

1983

2925

*.la)

2926

func_resolve_sysroot "$file"

2927

file=$func_resolve_sysroot_result

2928

1984

2929

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

1985

2930

func_lalib_unsafe_p "$file" \

1986

2931

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

1994

2939

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

1995

2940

case "$current_libdirs " in

1996

2941

*" $libdir "*) ;;

1997

*) current_libdirs="$current_libdirs $libdir" ;;

2942

*) func_append current_libdirs " $libdir" ;;

1998

2943

esac

1999

2944

else

2000

2945

# Note the libdir as a future libdir.

2001

2946

case "$future_libdirs " in

2002

2947

*" $libdir "*) ;;

2003

*) future_libdirs="$future_libdirs $libdir" ;;

2948

*) func_append future_libdirs " $libdir" ;;

2004

2949

esac

2005

2950

fi

2006

2951

2007

2952

func_dirname "$file" "/" ""

2008

2953

dir="$func_dirname_result"

2009

dir="$dir$objdir"

2954

func_append dir "$objdir"

2010

2955

2011

2956

if test -n "$relink_command"; then

2012

2957

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

2013

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

2958

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

2014

2959

2015

2960

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

2016

2961

# location b/c this prevents finding dependent libraries that

2023

2968

2024

2969

if test -n "$inst_prefix_dir"; then

2025

2970

# Stick the inst_prefix_dir data into the link command.

2026

relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`

2971

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

2027

2972

else

2028

relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`

2973

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

2029

2974

fi

2030

2975

2031

2976

func_warning "relinking \`$file'"

2043

2988

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

2044

2989

2045

2990

# Install the shared library and build the symlinks.

2046

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

2991

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

2047

2992

'exit $?'

2048

2993

tstripme="$stripme"

2049

2994

case $host_os in

2083

3028

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

2084

3029

2085

3030

# Maybe install the static library, too.

2086

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

3031

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

2087

3032

;;

2088

3033

2089

3034

*.lo)

2183

3128

if test -f "$lib"; then

2184

3129

func_source "$lib"

2185

3130

fi

2186

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

3131

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

2187

3132

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

2188

3133

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

2189

3134

finalize=no

2202

3147

file="$func_basename_result"

2203

3148

outputname="$tmpdir/$file"

2204

3149

# Replace the output file specification.

2205

relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`

3150

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

2206

3151

2207

3152

$opt_silent || {

2208

3153

func_quote_for_expand "$relink_command"

2221

3166

}

2222

3167

else

2223

3168

# Install the binary that we compiled earlier.

2224

file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%$[^/]*$$%$objdir/\1%"`

3169

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

2225

3170

fi

2226

3171

fi

2227

3172

2257

3202

2258

3203

# Set up the ranlib parameters.

2259

3204

oldlib="$destdir/$name"

3205

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

3206

tool_oldlib=$func_to_tool_file_result

2260

3207

2261

3208

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

2262

3209

2263

3210

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

2264

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

3211

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

2265

3212

fi

2266

3213

2267

3214

# Do each command in the postinstall commands.

2280

3227

fi

2281

3228

}

2282

3229

2283

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

3230

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

2284

3231

2285

3232

2286

3233

# func_generate_dlsyms outputname originator pic_p

2323

3270

extern \"C\" {

2324

3271

#endif

2325

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

2326

3289

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

2327

3290

"

2328

3291

2332

3295

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

2333

3296

2334

3297

# Add our own program objects to the symbol list.

2335

progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

3298

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

2336

3299

for progfile in $progfiles; do

2337

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

2338

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

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'"

2339

3303

done

2340

3304

2341

3305

if test -n "$exclude_expsyms"; then

2371

3335

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

2372

3336

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

2373

3337

case $host in

2374

*cygwin | *mingw* | *cegcc* )

3338

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

2375

3339

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

2376

3340

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

2377

3341

;;

2384

3348

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

2385

3349

func_basename "$dlprefile"

2386

3350

name="$func_basename_result"

2387

$opt_dry_run || {

2388

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

2389

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

2390

}

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

2391

3397

done

2392

3398

2393

3399

$opt_dry_run || {

2415

3421

if test -f "$nlist"S; then

2416

3422

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

2417

3423

else

2418

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

3424

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

2419

3425

fi

2420

3426

2421

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

3427

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

2422

3428

2423

3429

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

2424

3430

typedef struct {

2425

3431

const char *name;

2426

3432

void *address;

2427

3433

} lt_dlsymlist;

2428

"

2429

case $host in

2430

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

2431

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

2432

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

2433

runtime relocations are performed -- see ld's documentation

2434

on pseudo-relocs. */"

2435

lt_dlsym_const= ;;

2436

*osf5*)

2437

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

2438

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

2439

lt_dlsym_const= ;;

2440

*)

2441

lt_dlsym_const=const ;;

2442

esac

2443

2444

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

2445

extern $lt_dlsym_const lt_dlsymlist

3434

extern LT_DLSYM_CONST lt_dlsymlist

2446

3435

lt_${my_prefix}_LTX_preloaded_symbols[];

2447

$lt_dlsym_const lt_dlsymlist

3436

LT_DLSYM_CONST lt_dlsymlist

2448

3437

lt_${my_prefix}_LTX_preloaded_symbols[] =

2449

3438

{\

2450

3439

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

2457

3446

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

2458

3447

;;

2459

3448

esac

2460

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

3449

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

2461

3450

{0, (void *) 0}

2462

3451

};

2463

3452

2484

3473

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

2485

3474

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

2486

3475

# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.

2487

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

3476

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

2488

3477

pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;

2489

3478

*-*-hpux*)

2490

3479

pic_flag_for_symtable=" $pic_flag" ;;

2500

3489

for arg in $LTCFLAGS; do

2501

3490

case $arg in

2502

3491

-pie | -fpie | -fPIE) ;;

2503

*) symtab_cflags="$symtab_cflags $arg" ;;

3492

*) func_append symtab_cflags " $arg" ;;

2504

3493

esac

2505

3494

done

2506

3495

2515

3504

case $host in

2516

3505

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

2517

3506

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

2518

compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

2519

finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`

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%"`

2520

3509

else

2521

compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

2522

finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

3510

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

3511

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

2523

3512

fi

2524

3513

;;

2525

3514

*)

2526

compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

2527

finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`

3515

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

3516

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

2528

3517

;;

2529

3518

esac

2530

3519

;;

2538

3527

# really was required.

2539

3528

2540

3529

# Nullify the symbol file.

2541

compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`

2542

finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`

3530

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

3531

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

2543

3532

fi

2544

3533

}

2545

3534

2549

3538

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

2550

3539

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

2551

3540

# that is supplied when $file_magic_command is called.

3541

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

2552

3542

func_win32_libid ()

2553

3543

{

2554

3544

$opt_debug

2559

3549

win32_libid_type="x86 archive import"

2560

3550

;;

2561

3551

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

3552

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

2562

3553

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

2563

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

2564

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

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\" |

2565

3557

$SED -n -e '

2566

3558

1,100{

2567

3559

/ I /{

2590

3582

$ECHO "$win32_libid_type"

2591

3583

}

2592

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

}

2593

3710

2594

3711

2595

3712

# func_extract_an_archive dir oldlib

2598

3715

$opt_debug

2599

3716

f_ex_an_ar_dir="$1"; shift

2600

3717

f_ex_an_ar_oldlib="$1"

2601

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

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

2602

3730

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

2603

3731

:

2604

3732

else

2669

3797

darwin_file=

2670

3798

darwin_files=

2671

3799

for darwin_file in $darwin_filelist; do

2672

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

3800

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

2673

3801

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

2674

3802

done # $darwin_filelist

2675

3803

$RM -rf unfat-$$

2684

3812

func_extract_an_archive "$my_xdir" "$my_xabs"

2685

3813

;;

2686

3814

esac

2687

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

3815

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

2688

3816

done

2689

3817

2690

3818

func_extract_archives_result="$my_oldobjs"

2691

3819

}

2692

3820

2693

3821

2694

2695

# func_emit_wrapper_part1 [arg=no]

2696

#

2697

# Emit the first part of a libtool wrapper script on stdout.

2698

# For more information, see the description associated with

2699

# func_emit_wrapper(), below.

2700

func_emit_wrapper_part1 ()

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 ()

2701

3837

{

2702

func_emit_wrapper_part1_arg1=no

2703

if test -n "$1" ; then

2704

func_emit_wrapper_part1_arg1=$1

2705

fi

3838

func_emit_wrapper_arg1=${1-no}

2706

3839

2707

3840

$ECHO "\

2708

3841

#! $SHELL

2718

3851

2719

3852

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

2720

3853

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

2721

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

2722

3854

sed_quote_subst='$sed_quote_subst'

2723

3855

2724

3856

# Be Bourne compatible

2749

3881

else

2750

3882

# When we are sourced in execute mode, \$file and \$ECHO are already set.

2751

3883

if test \"\$libtool_execute_magic\" != \"$magic\"; then

2752

ECHO=\"$qecho\"

2753

file=\"\$0\"

2754

# Make sure echo works.

2755

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

2756

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

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

2757

3996

shift

2758

elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then

2759

# Yippee, \$ECHO works!

2760

:

2761

else

2762

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

2763

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

2764

fi

2765

fi\

2766

"

2767

$ECHO "\

3997

done ;;

3998

esac

3999

func_exec_program_core \${1+\"\$@\"}

4000

}

4001

4002

# Parse options

4003

func_parse_lt_options \"\$0\" \${1+\"\$@\"}

2768

4004

2769

4005

# Find the directory that this script lives in.

2770

thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`

4006

thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`

2771

4007

test \"x\$thisdir\" = \"x\$file\" && thisdir=.

2772

4008

2773

4009

# Follow symbolic links until we get to the real thisdir.

2774

file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`

4010

file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`

2775

4011

while test -n \"\$file\"; do

2776

destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`

4012

destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`

2777

4013

2778

4014

# If there was a directory component, then change thisdir.

2779

4015

if test \"x\$destdir\" != \"x\$file\"; then

2783

4019

esac

2784

4020

fi

2785

4021

2786

file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`

2787

file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`

4022

file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`

4023

file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`

2788

4024

done

2789

"

2790

}

2791

# end: func_emit_wrapper_part1

2792

2793

# func_emit_wrapper_part2 [arg=no]

2794

#

2795

# Emit the second part of a libtool wrapper script on stdout.

2796

# For more information, see the description associated with

2797

# func_emit_wrapper(), below.

2798

func_emit_wrapper_part2 ()

2799

{

2800

func_emit_wrapper_part2_arg1=no

2801

if test -n "$1" ; then

2802

func_emit_wrapper_part2_arg1=$1

2803

fi

2804

2805

$ECHO "\

2806

4025

2807

4026

# Usually 'no', except on cygwin/mingw when embedded into

2808

4027

# the cwrapper.

2809

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1

4028

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1

2810

4029

if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then

2811

4030

# special case for '.'

2812

4031

if test \"\$thisdir\" = \".\"; then

2814

4033

fi

2815

4034

# remove .libs from thisdir

2816

4035

case \"\$thisdir\" in

2817

*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;

4036

*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;

2818

4037

$objdir ) thisdir=. ;;

2819

4038

esac

2820

4039

fi

2869

4088

2870

4089

if test -f \"\$progdir/\$program\"; then"

2871

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

2872

4103

# Export our shlibpath_var if we have one.

2873

4104

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

2874

4105

$ECHO "\

2877

4108

2878

4109

# Some systems cannot cope with colon-terminated $shlibpath_var

2879

4110

# The second colon is a workaround for a bug in BeOS R4 sed

2880

$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`

4111

$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`

2881

4112

2882

4113

export $shlibpath_var

2883

4114

"

2884

4115

fi

2885

4116

2886

# fixup the dll searchpath if we need to.

2887

if test -n "$dllsearchpath"; then

2888

$ECHO "\

2889

# Add the dll search path components to the executable PATH

2890

PATH=$dllsearchpath:\$PATH

2891

"

2892

fi

2893

2894

4117

$ECHO "\

2895

4118

if test \"\$libtool_execute_magic\" != \"$magic\"; then

2896

4119

# Run the actual program with our arguments.

2897

"

2898

case $host in

2899

# Backslashes separate directories on plain windows

2900

*-*-mingw | *-*-os2* | *-cegcc*)

2901

$ECHO "\

2902

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

2903

"

2904

;;

2905

2906

*)

2907

$ECHO "\

2908

exec \"\$progdir/\$program\" \${1+\"\$@\"}

2909

"

2910

;;

2911

esac

2912

$ECHO "\

2913

\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2

2914

exit 1

4120

func_exec_program \${1+\"\$@\"}

2915

4121

fi

2916

4122

else

2917

4123

# The program doesn't exist.

2918

4124

\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

2919

4125

\$ECHO \"This script is just a wrapper for \$program.\" 1>&2

2920

$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

4126

\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

2921

4127

exit 1

2922

4128

fi

2923

4129

fi\

2924

4130

"

2925

4131

}

2926

# end: func_emit_wrapper_part2

2927

2928

2929

# func_emit_wrapper [arg=no]

2930

#

2931

# Emit a libtool wrapper script on stdout.

2932

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

2933

# incorporate the script contents within a cygwin/mingw

2934

# wrapper executable. Must ONLY be called from within

2935

# func_mode_link because it depends on a number of variables

2936

# set therein.

2937

#

2938

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

2939

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

2940

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

2941

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

2942

# behavior.

2943

func_emit_wrapper ()

2944

{

2945

func_emit_wrapper_arg1=no

2946

if test -n "$1" ; then

2947

func_emit_wrapper_arg1=$1

2948

fi

2949

2950

# split this up so that func_emit_cwrapperexe_src

2951

# can call each part independently.

2952

func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"

2953

func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"

2954

}

2955

2956

2957

# func_to_host_path arg

2958

#

2959

# Convert paths to host format when used with build tools.

2960

# Intended for use with "native" mingw (where libtool itself

2961

# is running under the msys shell), or in the following cross-

2962

# build environments:

2963

# $build $host

2964

# mingw (msys) mingw [e.g. native]

2965

# cygwin mingw

2966

# *nix + wine mingw

2967

# where wine is equipped with the `winepath' executable.

2968

# In the native mingw case, the (msys) shell automatically

2969

# converts paths for any non-msys applications it launches,

2970

# but that facility isn't available from inside the cwrapper.

2971

# Similar accommodations are necessary for $host mingw and

2972

# $build cygwin. Calling this function does no harm for other

2973

# $host/$build combinations not listed above.

2974

#

2975

# ARG is the path (on $build) that should be converted to

2976

# the proper representation for $host. The result is stored

2977

# in $func_to_host_path_result.

2978

func_to_host_path ()

2979

{

2980

func_to_host_path_result="$1"

2981

if test -n "$1" ; then

2982

case $host in

2983

*mingw* )

2984

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

2985

case $build in

2986

*mingw* ) # actually, msys

2987

# awkward: cmd appends spaces to result

2988

lt_sed_strip_trailing_spaces="s/[ ]*\$//"

2989

func_to_host_path_tmp1=`( cmd //c echo "$1" |\

2990

$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`

2991

func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\

2992

$SED -e "$lt_sed_naive_backslashify"`

2993

;;

2994

*cygwin* )

2995

func_to_host_path_tmp1=`cygpath -w "$1"`

2996

func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\

2997

$SED -e "$lt_sed_naive_backslashify"`

2998

;;

2999

* )

3000

# Unfortunately, winepath does not exit with a non-zero

3001

# error code, so we are forced to check the contents of

3002

# stdout. On the other hand, if the command is not

3003

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

3004

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

3005

# error code of zero AND non-empty stdout, which explains

3006

# the odd construction:

3007

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

3008

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

3009

func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\

3010

$SED -e "$lt_sed_naive_backslashify"`

3011

else

3012

# Allow warning below.

3013

func_to_host_path_result=""

3014

fi

3015

;;

3016

esac

3017

if test -z "$func_to_host_path_result" ; then

3018

func_error "Could not determine host path corresponding to"

3019

func_error " '$1'"

3020

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

3021

# Fallback:

3022

func_to_host_path_result="$1"

3023

fi

3024

;;

3025

esac

3026

fi

3027

}

3028

# end: func_to_host_path

3029

3030

# func_to_host_pathlist arg

3031

#

3032

# Convert pathlists to host format when used with build tools.

3033

# See func_to_host_path(), above. This function supports the

3034

# following $build/$host combinations (but does no harm for

3035

# combinations not listed here):

3036

# $build $host

3037

# mingw (msys) mingw [e.g. native]

3038

# cygwin mingw

3039

# *nix + wine mingw

3040

#

3041

# Path separators are also converted from $build format to

3042

# $host format. If ARG begins or ends with a path separator

3043

# character, it is preserved (but converted to $host format)

3044

# on output.

3045

#

3046

# ARG is a pathlist (on $build) that should be converted to

3047

# the proper representation on $host. The result is stored

3048

# in $func_to_host_pathlist_result.

3049

func_to_host_pathlist ()

3050

{

3051

func_to_host_pathlist_result="$1"

3052

if test -n "$1" ; then

3053

case $host in

3054

*mingw* )

3055

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

3056

# Remove leading and trailing path separator characters from

3057

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

3058

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

3059

func_to_host_pathlist_tmp2="$1"

3060

# Once set for this call, this variable should not be

3061

# reassigned. It is used in tha fallback case.

3062

func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\

3063

$SED -e 's|^:*||' -e 's|:*$||'`

3064

case $build in

3065

*mingw* ) # Actually, msys.

3066

# Awkward: cmd appends spaces to result.

3067

lt_sed_strip_trailing_spaces="s/[ ]*\$//"

3068

func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\

3069

$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`

3070

func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\

3071

$SED -e "$lt_sed_naive_backslashify"`

3072

;;

3073

*cygwin* )

3074

func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`

3075

func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\

3076

$SED -e "$lt_sed_naive_backslashify"`

3077

;;

3078

* )

3079

# unfortunately, winepath doesn't convert pathlists

3080

func_to_host_pathlist_result=""

3081

func_to_host_pathlist_oldIFS=$IFS

3082

IFS=:

3083

for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do

3084

IFS=$func_to_host_pathlist_oldIFS

3085

if test -n "$func_to_host_pathlist_f" ; then

3086

func_to_host_path "$func_to_host_pathlist_f"

3087

if test -n "$func_to_host_path_result" ; then

3088

if test -z "$func_to_host_pathlist_result" ; then

3089

func_to_host_pathlist_result="$func_to_host_path_result"

3090

else

3091

func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"

3092

fi

3093

fi

3094

fi

3095

IFS=:

3096

done

3097

IFS=$func_to_host_pathlist_oldIFS

3098

;;

3099

esac

3100

if test -z "$func_to_host_pathlist_result" ; then

3101

func_error "Could not determine the host path(s) corresponding to"

3102

func_error " '$1'"

3103

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

3104

# Fallback. This may break if $1 contains DOS-style drive

3105

# specifications. The fix is not to complicate the expression

3106

# below, but for the user to provide a working wine installation

3107

# with winepath so that path translation in the cross-to-mingw

3108

# case works properly.

3109

lt_replace_pathsep_nix_to_dos="s|:|;|g"

3110

func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\

3111

$SED -e "$lt_replace_pathsep_nix_to_dos"`

3112

fi

3113

# Now, add the leading and trailing path separators back

3114

case "$1" in

3115

:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"

3116

;;

3117

esac

3118

case "$1" in

3119

*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"

3120

;;

3121

esac

3122

;;

3123

esac

3124

fi

3125

}

3126

# end: func_to_host_pathlist

4132

3127

4133

3128

4134

# func_emit_cwrapperexe_src

3129

4135

# emit the source code for a wrapper executable on stdout

3141

4147

3142

4148

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

3143

4149

If it is, it will not operate correctly.

3144

3145

Currently, it simply execs the wrapper *script* "$SHELL $output",

3146

but could eventually absorb all of the scripts functionality and

3147

exec $objdir/$outputname directly.

3148

4150

*/

3149

4151

EOF

3150

4152

cat <<"EOF"

4153

#ifdef _MSC_VER

4154

# define _CRT_SECURE_NO_DEPRECATE 1

4155

#endif

3151

4156

#include <stdio.h>

3152

4157

#include <stdlib.h>

3153

4158

#ifdef _MSC_VER

3154

4159

# include <direct.h>

3155

4160

# include <process.h>

3156

4161

# include <io.h>

3157

# define setmode _setmode

3158

4162

#else

3159

4163

# include <unistd.h>

3160

4164

# include <stdint.h>

3161

4165

# ifdef __CYGWIN__

3162

4166

# include <io.h>

3163

# define HAVE_SETENV

3164

# ifdef __STRICT_ANSI__

3165

char *realpath (const char *, char *);

3166

int putenv (char *);

3167

int setenv (const char *, const char *, int);

3168

# endif

3169

4167

# endif

3170

4168

#endif

3171

4169

#include <malloc.h>

3177

4175

#include <fcntl.h>

3178

4176

#include <sys/stat.h>

3179

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

3180

4216

#if defined(PATH_MAX)

3181

4217

# define LT_PATHMAX PATH_MAX

3182

4218

#elif defined(MAXPATHLEN)

3192

4228

# define S_IXGRP 0

3193

4229

#endif

3194

4230

3195

#ifdef _MSC_VER

3196

# define S_IXUSR _S_IEXEC

3197

# define stat _stat

3198

# ifndef _INTPTR_T_DEFINED

3199

# define intptr_t int

3200

# endif

3201

#endif

3202

4231

/* path handling portability macros */

3203

4232

#ifndef DIR_SEPARATOR

3204

4233

# define DIR_SEPARATOR '/'

3205

4234

# define PATH_SEPARATOR ':'

3230

4259

# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)

3231

4260

#endif /* PATH_SEPARATOR_2 */

3232

4261

3233

#ifdef __CYGWIN__

3234

# define FOPEN_WB "wb"

3235

#endif

3236

3237

4262

#ifndef FOPEN_WB

3238

4263

# define FOPEN_WB "w"

3239

4264

#endif

3246

4271

if (stale) { free ((void *) stale); stale = 0; } \

3247

4272

} while (0)

3248

4273

3249

#undef LTWRAPPER_DEBUGPRINTF

3250

#if defined DEBUGWRAPPER

3251

# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args

3252

static void

3253

ltwrapper_debugprintf (const char *fmt, ...)

3254

{

3255

va_list args;

3256

va_start (args, fmt);

3257

(void) vfprintf (stderr, fmt, args);

3258

va_end (args);

3259

}

4274

#if defined(LT_DEBUGWRAPPER)

4275

static int lt_debug = 1;

3260

4276

#else

3261

# define LTWRAPPER_DEBUGPRINTF(args)

4277

static int lt_debug = 0;

3262

4278

#endif

3263

4279

3264

const char *program_name = NULL;

4280

const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */

3265

4281

3266

4282

void *xmalloc (size_t num);

3267

4283

char *xstrdup (const char *string);

3271

4287

int make_executable (const char *path);

3272

4288

int check_executable (const char *path);

3273

4289

char *strendzap (char *str, const char *pat);

3274

void lt_fatal (const char *message, ...);

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

3275

4294

void lt_setenv (const char *name, const char *value);

3276

4295

char *lt_extend_str (const char *orig_value, const char *add, int to_end);

3277

void lt_opt_process_env_set (const char *arg);

3278

void lt_opt_process_env_prepend (const char *arg);

3279

void lt_opt_process_env_append (const char *arg);

3280

int lt_split_name_value (const char *arg, char** name, char** value);

3281

4296

void lt_update_exe_path (const char *name, const char *value);

3282

4297

void lt_update_lib_path (const char *name, const char *value);

3283

3284

static const char *script_text_part1 =

3285

EOF

3286

3287

func_emit_wrapper_part1 yes |

3288

$SED -e 's/$[\\"]$/\\\1/g' \

3289

-e 's/^/ "/' -e 's/$/\\n"/'

3290

echo ";"

3291

cat <<EOF

3292

3293

static const char *script_text_part2 =

3294

EOF

3295

func_emit_wrapper_part2 yes |

3296

$SED -e 's/$[\\"]$/\\\1/g' \

3297

-e 's/^/ "/' -e 's/$/\\n"/'

3298

echo ";"

3299

3300

cat <<EOF

3301

const char * MAGIC_EXE = "$magic_exe";

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";

3302

4304

const char * LIB_PATH_VARNAME = "$shlibpath_var";

3303

4305

EOF

3304

4306

3305

4307

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

3306

func_to_host_pathlist "$temp_rpath"

4308

func_to_host_path "$temp_rpath"

3307

4309

cat <<EOF

3308

const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";

4310

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

3309

4311

EOF

3310

4312

else

3311

4313

cat <<"EOF"

3314

4316

fi

3315

4317

3316

4318

if test -n "$dllsearchpath"; then

3317

func_to_host_pathlist "$dllsearchpath:"

4319

func_to_host_path "$dllsearchpath:"

3318

4320

cat <<EOF

3319

4321

const char * EXE_PATH_VARNAME = "PATH";

3320

const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";

4322

const char * EXE_PATH_VALUE = "$func_to_host_path_result";

3321

4323

EOF

3322

4324

else

3323

4325

cat <<"EOF"

3340

4342

cat <<"EOF"

3341

4343

3342

4344

#define LTWRAPPER_OPTION_PREFIX "--lt-"

3343

#define LTWRAPPER_OPTION_PREFIX_LENGTH 5

3344

4345

3345

static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;

3346

4346

static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;

3347

3348

4347

static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";

3349

3350

static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;

3351

static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";

3352

/* argument is putenv-style "foo=bar", value of foo is set to bar */

3353

3354

static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;

3355

static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";

3356

/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */

3357

3358

static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;

3359

static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";

3360

/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */

4348

static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";

3361

4349

3362

4350

int

3363

4351

main (int argc, char *argv[])

3374

4362

int i;

3375

4363

3376

4364

program_name = (char *) xstrdup (base_name (argv[0]));

3377

LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));

3378

LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));

4365

newargz = XMALLOC (char *, argc + 1);

3379

4366

3380

/* very simple arg parsing; don't want to rely on getopt */

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;

3381

4372

for (i = 1; i < argc; i++)

3382

4373

{

3383

4374

if (strcmp (argv[i], dumpscript_opt) == 0)

3391

4382

esac

3392

4383

3393

4384

cat <<"EOF"

3394

printf ("%s", script_text_part1);

3395

printf ("%s", script_text_part2);

4385

lt_dump_script (stdout);

3396

4386

return 0;

3397

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

3398

4410

}

3399

3400

newargz = XMALLOC (char *, argc + 1);

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

3401

4422

tmp_pathspec = find_executable (argv[0]);

3402

4423

if (tmp_pathspec == NULL)

3403

lt_fatal ("Couldn't find %s", argv[0]);

3404

LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",

3405

tmp_pathspec));

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

3406

4428

3407

4429

actual_cwrapper_path = chase_symlinks (tmp_pathspec);

3408

LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",

3409

actual_cwrapper_path));

4430

lt_debugprintf (__FILE__, __LINE__,

4431

"(main) found exe (after symlink chase) at: %s\n",

4432

actual_cwrapper_path);

3410

4433

XFREE (tmp_pathspec);

3411

4434

3412

actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));

4435

actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));

3413

4436

strendzap (actual_cwrapper_path, actual_cwrapper_name);

3414

4437

3415

4438

/* wrapper name transforms */

3427

4450

target_name = tmp_pathspec;

3428

4451

tmp_pathspec = 0;

3429

4452

3430

LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",

3431

target_name));

4453

lt_debugprintf (__FILE__, __LINE__,

4454

"(main) libtool target name: %s\n",

4455

target_name);

3432

4456

EOF

3433

4457

3434

4458

cat <<EOF

3478

4502

3479

4503

lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */

3480

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

3481

4510

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

3482

lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);

3483

3484

newargc=0;

3485

for (i = 1; i < argc; i++)

3486

{

3487

if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)

3488

{

3489

if (argv[i][env_set_opt_len] == '=')

3490

{

3491

const char *p = argv[i] + env_set_opt_len + 1;

3492

lt_opt_process_env_set (p);

3493

}

3494

else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)

3495

{

3496

lt_opt_process_env_set (argv[++i]); /* don't copy */

3497

}

3498

else

3499

lt_fatal ("%s missing required argument", env_set_opt);

3500

continue;

3501

}

3502

if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)

3503

{

3504

if (argv[i][env_prepend_opt_len] == '=')

3505

{

3506

const char *p = argv[i] + env_prepend_opt_len + 1;

3507

lt_opt_process_env_prepend (p);

3508

}

3509

else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)

3510

{

3511

lt_opt_process_env_prepend (argv[++i]); /* don't copy */

3512

}

3513

else

3514

lt_fatal ("%s missing required argument", env_prepend_opt);

3515

continue;

3516

}

3517

if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)

3518

{

3519

if (argv[i][env_append_opt_len] == '=')

3520

{

3521

const char *p = argv[i] + env_append_opt_len + 1;

3522

lt_opt_process_env_append (p);

3523

}

3524

else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)

3525

{

3526

lt_opt_process_env_append (argv[++i]); /* don't copy */

3527

}

3528

else

3529

lt_fatal ("%s missing required argument", env_append_opt);

3530

continue;

3531

}

3532

if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)

3533

{

3534

/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX

3535

namespace, but it is not one of the ones we know about and

3536

have already dealt with, above (inluding dump-script), then

3537

report an error. Otherwise, targets might begin to believe

3538

they are allowed to use options in the LTWRAPPER_OPTION_PREFIX

3539

namespace. The first time any user complains about this, we'll

3540

need to make LTWRAPPER_OPTION_PREFIX a configure-time option

3541

or a configure.ac-settable value.

3542

*/

3543

lt_fatal ("Unrecognized option in %s namespace: '%s'",

3544

ltwrapper_option_prefix, argv[i]);

3545

}

3546

/* otherwise ... */

3547

newargz[++newargc] = xstrdup (argv[i]);

3548

}

3549

newargz[++newargc] = NULL;

3550

3551

LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));

4511

4512

lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",

4513

nonnull (lt_argv_zero));

3552

4514

for (i = 0; i < newargc; i++)

3553

4515

{

3554

LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));

4516

lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",

4517

i, nonnull (newargz[i]));

3555

4518

}

3556

4519

3557

4520

EOF

3560

4523

mingw*)

3561

4524

cat <<"EOF"

3562

4525

/* execv doesn't actually work on mingw as expected on unix */

4526

newargz = prepare_spawn (newargz);

3563

4527

rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

3564

4528

if (rval == -1)

3565

4529

{

3566

4530

/* failed to start process */

3567

LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));

4531

lt_debugprintf (__FILE__, __LINE__,

4532

"(main) failed to launch target \"%s\": %s\n",

4533

lt_argv_zero, nonnull (strerror (errno)));

3568

4534

return 127;

3569

4535

}

3570

4536

return rval;

3586

4552

{

3587

4553

void *p = (void *) malloc (num);

3588

4554

if (!p)

3589

lt_fatal ("Memory exhausted");

4555

lt_fatal (__FILE__, __LINE__, "memory exhausted");

3590

4556

3591

4557

return p;

3592

4558

}

3620

4586

{

3621

4587

struct stat st;

3622

4588

3623

LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",

3624

path ? (*path ? path : "EMPTY!") : "NULL!"));

4589

lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",

4590

nonempty (path));

3625

4591

if ((!path) || (!*path))

3626

4592

return 0;

3627

4593

3638

4604

int rval = 0;

3639

4605

struct stat st;

3640

4606

3641

LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",

3642

path ? (*path ? path : "EMPTY!") : "NULL!"));

4607

lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",

4608

nonempty (path));

3643

4609

if ((!path) || (!*path))

3644

4610

return 0;

3645

4611

3665

4631

int tmp_len;

3666

4632

char *concat_name;

3667

4633

3668

LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",

3669

wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));

4634

lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",

4635

nonempty (wrapper));

3670

4636

3671

4637

if ((wrapper == NULL) || (*wrapper == '\0'))

3672

4638

return NULL;

3719

4685

{

3720

4686

/* empty path: current directory */

3721

4687

if (getcwd (tmp, LT_PATHMAX) == NULL)

3722

lt_fatal ("getcwd failed");

4688

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4689

nonnull (strerror (errno)));

3723

4690

tmp_len = strlen (tmp);

3724

4691

concat_name =

3725

4692

XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

3744

4711

}

3745

4712

/* Relative path | not found in path: prepend cwd */

3746

4713

if (getcwd (tmp, LT_PATHMAX) == NULL)

3747

lt_fatal ("getcwd failed");

4714

lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",

4715

nonnull (strerror (errno)));

3748

4716

tmp_len = strlen (tmp);

3749

4717

concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);

3750

4718

memcpy (concat_name, tmp, tmp_len);

3770

4738

int has_symlinks = 0;

3771

4739

while (strlen (tmp_pathspec) && !has_symlinks)

3772

4740

{

3773

LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",

3774

tmp_pathspec));

4741

lt_debugprintf (__FILE__, __LINE__,

4742

"checking path component for symlinks: %s\n",

4743

tmp_pathspec);

3775

4744

if (lstat (tmp_pathspec, &s) == 0)

3776

4745

{

3777

4746

if (S_ISLNK (s.st_mode) != 0)

3793

4762

}

3794

4763

else

3795

4764

{

3796

char *errstr = strerror (errno);

3797

lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);

4765

lt_fatal (__FILE__, __LINE__,

4766

"error accessing file \"%s\": %s",

4767

tmp_pathspec, nonnull (strerror (errno)));

3798

4768

}

3799

4769

}

3800

4770

XFREE (tmp_pathspec);

3807

4777

tmp_pathspec = realpath (pathspec, buf);

3808

4778

if (tmp_pathspec == 0)

3809

4779

{

3810

lt_fatal ("Could not follow symlinks for %s", pathspec);

4780

lt_fatal (__FILE__, __LINE__,

4781

"could not follow symlinks for %s", pathspec);

3811

4782

}

3812

4783

return xstrdup (tmp_pathspec);

3813

4784

#endif

3833

4804

return str;

3834

4805

}

3835

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

3836

4820

static void

3837

lt_error_core (int exit_status, const char *mode,

4821

lt_error_core (int exit_status, const char *file,

4822

int line, const char *mode,

3838

4823

const char *message, va_list ap)

3839

4824

{

3840

fprintf (stderr, "%s: %s: ", program_name, mode);

4825

fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);

3841

4826

vfprintf (stderr, message, ap);

3842

4827

fprintf (stderr, ".\n");

3843

4828

3846

4831

}

3847

4832

3848

4833

void

3849

lt_fatal (const char *message, ...)

4834

lt_fatal (const char *file, int line, const char *message, ...)

3850

4835

{

3851

4836

va_list ap;

3852

4837

va_start (ap, message);

3853

lt_error_core (EXIT_FAILURE, "FATAL", message, ap);

4838

lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);

3854

4839

va_end (ap);

3855

4840

}

3856

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

3857

4854

void

3858

4855

lt_setenv (const char *name, const char *value)

3859

4856

{

3860

LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",

3861

(name ? name : "<NULL>"),

3862

(value ? value : "<NULL>")));

4857

lt_debugprintf (__FILE__, __LINE__,

4858

"(lt_setenv) setting '%s' to '%s'\n",

4859

nonnull (name), nonnull (value));

3863

4860

{

3864

4861

#ifdef HAVE_SETENV

3865

4862

/* always make a copy, for consistency with !HAVE_SETENV */

3904

4901

return new_value;

3905

4902

}

3906

4903

3907

int

3908

lt_split_name_value (const char *arg, char** name, char** value)

3909

{

3910

const char *p;

3911

int len;

3912

if (!arg || !*arg)

3913

return 1;

3914

3915

p = strchr (arg, (int)'=');

3916

3917

if (!p)

3918

return 1;

3919

3920

*value = xstrdup (++p);

3921

3922

len = strlen (arg) - strlen (*value);

3923

*name = XMALLOC (char, len);

3924

strncpy (*name, arg, len-1);

3925

(*name)[len - 1] = '\0';

3926

3927

return 0;

3928

}

3929

3930

void

3931

lt_opt_process_env_set (const char *arg)

3932

{

3933

char *name = NULL;

3934

char *value = NULL;

3935

3936

if (lt_split_name_value (arg, &name, &value) != 0)

3937

{

3938

XFREE (name);

3939

XFREE (value);

3940

lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);

3941

}

3942

3943

lt_setenv (name, value);

3944

XFREE (name);

3945

XFREE (value);

3946

}

3947

3948

void

3949

lt_opt_process_env_prepend (const char *arg)

3950

{

3951

char *name = NULL;

3952

char *value = NULL;

3953

char *new_value = NULL;

3954

3955

if (lt_split_name_value (arg, &name, &value) != 0)

3956

{

3957

XFREE (name);

3958

XFREE (value);

3959

lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);

3960

}

3961

3962

new_value = lt_extend_str (getenv (name), value, 0);

3963

lt_setenv (name, new_value);

3964

XFREE (new_value);

3965

XFREE (name);

3966

XFREE (value);

3967

}

3968

3969

void

3970

lt_opt_process_env_append (const char *arg)

3971

{

3972

char *name = NULL;

3973

char *value = NULL;

3974

char *new_value = NULL;

3975

3976

if (lt_split_name_value (arg, &name, &value) != 0)

3977

{

3978

XFREE (name);

3979

XFREE (value);

3980

lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);

3981

}

3982

3983

new_value = lt_extend_str (getenv (name), value, 1);

3984

lt_setenv (name, new_value);

3985

XFREE (new_value);

3986

XFREE (name);

3987

XFREE (value);

3988

}

3989

3990

4904

void

3991

4905

lt_update_exe_path (const char *name, const char *value)

3992

4906

{

3993

LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",

3994

(name ? name : "<NULL>"),

3995

(value ? value : "<NULL>")));

4907

lt_debugprintf (__FILE__, __LINE__,

4908

"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",

4909

nonnull (name), nonnull (value));

3996

4910

3997

4911

if (name && *name && value && *value)

3998

4912

{

4011

4925

void

4012

4926

lt_update_lib_path (const char *name, const char *value)

4013

4927

{

4014

LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",

4015

(name ? name : "<NULL>"),

4016

(value ? value : "<NULL>")));

4928

lt_debugprintf (__FILE__, __LINE__,

4929

"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",

4930

nonnull (name), nonnull (value));

4017

4931

4018

4932

if (name && *name && value && *value)

4019

4933

{

4023

4937

}

4024

4938

}

4025

4939

4026

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

}

4027

5077

EOF

4028

5078

}

4029

5079

# end: func_emit_cwrapperexe_src

4030

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

4031

5092

# func_mode_link arg...

4032

5093

func_mode_link ()

4033

5094

{

4072

5133

new_inherited_linker_flags=

4073

5134

4074

5135

avoid_version=no

5136

bindir=

4075

5137

dlfiles=

4076

5138

dlprefiles=

4077

5139

dlself=no

4164

5226

esac

4165

5227

4166

5228

case $prev in

5229

bindir)

5230

bindir="$arg"

5231

prev=

5232

continue

5233

;;

4167

5234

dlfiles|dlprefiles)

4168

5235

if test "$preload" = no; then

4169

5236

# Add the symbol object into the linking commands.

4195

5262

;;

4196

5263

*)

4197

5264

if test "$prev" = dlfiles; then

4198

dlfiles="$dlfiles $arg"

5265

func_append dlfiles " $arg"

4199

5266

else

4200

dlprefiles="$dlprefiles $arg"

5267

func_append dlprefiles " $arg"

4201

5268

fi

4202

5269

prev=

4203

5270

continue

4221

5288

*-*-darwin*)

4222

5289

case "$deplibs " in

4223

5290

*" $qarg.ltframework "*) ;;

4224

*) deplibs="$deplibs $qarg.ltframework" # this is fixed later

5291

*) func_append deplibs " $qarg.ltframework" # this is fixed later

4225

5292

;;

4226

5293

esac

4227

5294

;;

4240

5307

moreargs=

4241

5308

for fil in `cat "$save_arg"`

4242

5309

do

4243

# moreargs="$moreargs $fil"

5310

# func_append moreargs " $fil"

4244

5311

arg=$fil

4245

5312

# A libtool-controlled object.

4246

5313

4269

5336

4270

5337

if test "$prev" = dlfiles; then

4271

5338

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

4272

dlfiles="$dlfiles $pic_object"

5339

func_append dlfiles " $pic_object"

4273

5340

prev=

4274

5341

continue

4275

5342

else

4281

5348

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

4282

5349

if test "$prev" = dlprefiles; then

4283

5350

# Preload the old-style object.

4284

dlprefiles="$dlprefiles $pic_object"

5351

func_append dlprefiles " $pic_object"

4285

5352

prev=

4286

5353

fi

4287

5354

4351

5418

if test "$prev" = rpath; then

4352

5419

case "$rpath " in

4353

5420

*" $arg "*) ;;

4354

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

5421

*) func_append rpath " $arg" ;;

4355

5422

esac

4356

5423

else

4357

5424

case "$xrpath " in

4358

5425

*" $arg "*) ;;

4359

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

5426

*) func_append xrpath " $arg" ;;

4360

5427

esac

4361

5428

fi

4362

5429

prev=

4368

5435

continue

4369

5436

;;

4370

5437

weak)

4371

weak_libs="$weak_libs $arg"

5438

func_append weak_libs " $arg"

4372

5439

prev=

4373

5440

continue

4374

5441

;;

4375

5442

xcclinker)

4376

linker_flags="$linker_flags $qarg"

4377

compiler_flags="$compiler_flags $qarg"

5443

func_append linker_flags " $qarg"

5444

func_append compiler_flags " $qarg"

4378

5445

prev=

4379

5446

func_append compile_command " $qarg"

4380

5447

func_append finalize_command " $qarg"

4381

5448

continue

4382

5449

;;

4383

5450

xcompiler)

4384

compiler_flags="$compiler_flags $qarg"

5451

func_append compiler_flags " $qarg"

4385

5452

prev=

4386

5453

func_append compile_command " $qarg"

4387

5454

func_append finalize_command " $qarg"

4388

5455

continue

4389

5456

;;

4390

5457

xlinker)

4391

linker_flags="$linker_flags $qarg"

4392

compiler_flags="$compiler_flags $wl$qarg"

5458

func_append linker_flags " $qarg"

5459

func_append compiler_flags " $wl$qarg"

4393

5460

prev=

4394

5461

func_append compile_command " $wl$qarg"

4395

5462

func_append finalize_command " $wl$qarg"

4425

5492

continue

4426

5493

;;

4427

5494

5495

-bindir)

5496

prev=bindir

5497

continue

5498

;;

5499

4428

5500

-dlopen)

4429

5501

prev=dlfiles

4430

5502

continue

4475

5547

;;

4476

5548

4477

5549

-L*)

4478

func_stripname '-L' '' "$arg"

4479

dir=$func_stripname_result

4480

if test -z "$dir"; then

5550

func_stripname "-L" '' "$arg"

5551

if test -z "$func_stripname_result"; then

4481

5552

if test "$#" -gt 0; then

4482

5553

func_fatal_error "require no space between \`-L' and \`$1'"

4483

5554

else

4484

5555

func_fatal_error "need path for \`-L' option"

4485

5556

fi

4486

5557

fi

5558

func_resolve_sysroot "$func_stripname_result"

5559

dir=$func_resolve_sysroot_result

4487

5560

# We need an absolute path.

4488

5561

case $dir in

4489

5562

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

4495

5568

;;

4496

5569

esac

4497

5570

case "$deplibs " in

4498

*" -L$dir "*) ;;

5571

*" -L$dir "* | *" $arg "*)

5572

# Will only happen for absolute or sysroot arguments

5573

;;

4499

5574

*)

4500

deplibs="$deplibs -L$dir"

4501

lib_search_path="$lib_search_path $dir"

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"

4502

5581

;;

4503

5582

esac

4504

5583

case $host in

4505

5584

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

4506

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

5585

testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`

4507

5586

case :$dllsearchpath: in

4508

5587

*":$dir:"*) ;;

4509

5588

::) dllsearchpath=$dir;;

4510

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

5589

*) func_append dllsearchpath ":$dir";;

4511

5590

esac

4512

5591

case :$dllsearchpath: in

4513

5592

*":$testbindir:"*) ;;

4514

5593

::) dllsearchpath=$testbindir;;

4515

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

5594

*) func_append dllsearchpath ":$testbindir";;

4516

5595

esac

4517

5596

;;

4518

5597

esac

4522

5601

-l*)

4523

5602

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

4524

5603

case $host in

4525

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

5604

4526

5605

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

4527

5606

continue

4528

5607

;;

4536

5615

;;

4537

5616

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

4538

5617

# Rhapsody C and math libraries are in the System framework

4539

deplibs="$deplibs System.ltframework"

5618

func_append deplibs " System.ltframework"

4540

5619

continue

4541

5620

;;

4542

5621

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

4556

5635

;;

4557

5636

esac

4558

5637

fi

4559

deplibs="$deplibs $arg"

5638

func_append deplibs " $arg"

4560

5639

continue

4561

5640

;;

4562

5641

4568

5647

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

4569

5648

# classes, name mangling, and exception handling.

4570

5649

# Darwin uses the -arch flag to determine output architecture.

4571

-model|-arch|-isysroot)

4572

compiler_flags="$compiler_flags $arg"

5650

-model|-arch|-isysroot|--sysroot)

5651

func_append compiler_flags " $arg"

4573

5652

func_append compile_command " $arg"

4574

5653

func_append finalize_command " $arg"

4575

5654

prev=xcompiler

4576

5655

continue

4577

5656

;;

4578

5657

4579

4580

compiler_flags="$compiler_flags $arg"

5658

5659

5660

func_append compiler_flags " $arg"

4581

5661

func_append compile_command " $arg"

4582

5662

func_append finalize_command " $arg"

4583

5663

case "$new_inherited_linker_flags " in

4584

5664

*" $arg "*) ;;

4585

* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;

5665

* ) func_append new_inherited_linker_flags " $arg" ;;

4586

5666

esac

4587

5667

continue

4588

5668

;;

4649

5729

# We need an absolute path.

4650

5730

case $dir in

4651

5731

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

5732

=*)

5733

func_stripname '=' '' "$dir"

5734

dir=$lt_sysroot$func_stripname_result

5735

;;

4652

5736

*)

4653

5737

func_fatal_error "only absolute run-paths are allowed"

4654

5738

;;

4655

5739

esac

4656

5740

case "$xrpath " in

4657

5741

*" $dir "*) ;;

4658

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

5742

*) func_append xrpath " $dir" ;;

4659

5743

esac

4660

5744

continue

4661

5745

;;

4708

5792

for flag in $args; do

4709

5793

IFS="$save_ifs"

4710

5794

func_quote_for_eval "$flag"

4711

arg="$arg $wl$func_quote_for_eval_result"

4712

compiler_flags="$compiler_flags $func_quote_for_eval_result"

5795

func_append arg " $func_quote_for_eval_result"

5796

func_append compiler_flags " $func_quote_for_eval_result"

4713

5797

done

4714

5798

IFS="$save_ifs"

4715

5799

func_stripname ' ' '' "$arg"

4729

5813

for flag in $args; do

4730

5814

IFS="$save_ifs"

4731

5815

func_quote_for_eval "$flag"

4732

arg="$arg $wl$func_quote_for_eval_result"

4733

compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"

4734

linker_flags="$linker_flags $func_quote_for_eval_result"

5816

func_append arg " $wl$func_quote_for_eval_result"

5817

func_append compiler_flags " $wl$func_quote_for_eval_result"

5818

func_append linker_flags " $func_quote_for_eval_result"

4735

5819

done

4736

5820

IFS="$save_ifs"

4737

5821

func_stripname ' ' '' "$arg"

4759

5843

arg="$func_quote_for_eval_result"

4760

5844

;;

4761

5845

4762

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

4763

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

4764

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

4765

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

4766

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

4767

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

4768

# compiler args for GCC

4769

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

4770

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

4771

# @file GCC response files

5846

# Flags to be passed through unchanged, with rationale:

5847

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

5848

# -r[0-9][0-9]* specify processor for the SGI compiler

5849

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

5850

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

5851

# -q* compiler args for the IBM compiler

5852

# -m*, -t[45]*, -txscale* architecture-specific flags for GCC

5853

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

5854

# -p, -pg, --coverage, -fprofile-* profiling flags for GCC

5855

# @file GCC response files

5856

# -tp=* Portland pgcc target processor selection

5857

# --sysroot=* for sysroot support

5858

# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

4772

5859

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

4773

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

5860

-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \

5861

-O*|-flto*|-fwhopr*|-fuse-linker-plugin)

4774

5862

func_quote_for_eval "$arg"

4775

5863

arg="$func_quote_for_eval_result"

4776

5864

func_append compile_command " $arg"

4777

5865

func_append finalize_command " $arg"

4778

compiler_flags="$compiler_flags $arg"

5866

func_append compiler_flags " $arg"

4779

5867

continue

4780

5868

;;

4781

5869

4787

5875

4788

5876

*.$objext)

4789

5877

# A standard object.

4790

objs="$objs $arg"

5878

func_append objs " $arg"

4791

5879

;;

4792

5880

4793

5881

*.lo)

4818

5906

4819

5907

if test "$prev" = dlfiles; then

4820

5908

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

4821

dlfiles="$dlfiles $pic_object"

5909

func_append dlfiles " $pic_object"

4822

5910

prev=

4823

5911

continue

4824

5912

else

4830

5918

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

4831

5919

if test "$prev" = dlprefiles; then

4832

5920

# Preload the old-style object.

4833

dlprefiles="$dlprefiles $pic_object"

5921

func_append dlprefiles " $pic_object"

4834

5922

prev=

4835

5923

fi

4836

5924

4875

5963

4876

5964

*.$libext)

4877

5965

# An archive.

4878

deplibs="$deplibs $arg"

4879

old_deplibs="$old_deplibs $arg"

5966

func_append deplibs " $arg"

5967

func_append old_deplibs " $arg"

4880

5968

continue

4881

5969

;;

4882

5970

4883

5971

*.la)

4884

5972

# A libtool-controlled library.

4885

5973

5974

func_resolve_sysroot "$arg"

4886

5975

if test "$prev" = dlfiles; then

4887

5976

# This library was specified with -dlopen.

4888

dlfiles="$dlfiles $arg"

5977

func_append dlfiles " $func_resolve_sysroot_result"

4889

5978

prev=

4890

5979

elif test "$prev" = dlprefiles; then

4891

5980

# The library was specified with -dlpreopen.

4892

dlprefiles="$dlprefiles $arg"

5981

func_append dlprefiles " $func_resolve_sysroot_result"

4893

5982

prev=

4894

5983

else

4895

deplibs="$deplibs $arg"

5984

func_append deplibs " $func_resolve_sysroot_result"

4896

5985

fi

4897

5986

continue

4898

5987

;;

4930

6019

4931

6020

if test -n "$shlibpath_var"; then

4932

6021

# get the directories listed in $shlibpath_var

4933

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

6022

eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`

4934

6023

else

4935

6024

shlib_search_path=

4936

6025

fi

4939

6028

4940

6029

func_dirname "$output" "/" ""

4941

6030

output_objdir="$func_dirname_result$objdir"

6031

func_to_tool_file "$output_objdir/"

6032

tool_output_objdir=$func_to_tool_file_result

4942

6033

# Create the object directory.

4943

6034

func_mkdir_p "$output_objdir"

4944

6035

4959

6050

# Find all interdependent deplibs by searching for libraries

4960

6051

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

4961

6052

for deplib in $deplibs; do

4962

if $opt_duplicate_deps ; then

6053

if $opt_preserve_dup_deps ; then

4963

6054

case "$libs " in

4964

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

6055

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

4965

6056

esac

4966

6057

fi

4967

libs="$libs $deplib"

6058

func_append libs " $deplib"

4968

6059

done

4969

6060

4970

6061

if test "$linkmode" = lib; then

4977

6068

if $opt_duplicate_compiler_generated_deps; then

4978

6069

for pre_post_dep in $predeps $postdeps; do

4979

6070

case "$pre_post_deps " in

4980

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

6071

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

4981

6072

esac

4982

pre_post_deps="$pre_post_deps $pre_post_dep"

6073

func_append pre_post_deps " $pre_post_dep"

4983

6074

done

4984

6075

fi

4985

6076

pre_post_deps=

5049

6140

for lib in $dlprefiles; do

5050

6141

# Ignore non-libtool-libs

5051

6142

dependency_libs=

6143

func_resolve_sysroot "$lib"

5052

6144

case $lib in

5053

*.la) func_source "$lib" ;;

6145

*.la) func_source "$func_resolve_sysroot_result" ;;

5054

6146

esac

5055

6147

5056

6148

# Collect preopened libtool deplibs, except any this library

5057

6149

# has declared as weak libs

5058

6150

for deplib in $dependency_libs; do

5059

deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`

6151

func_basename "$deplib"

6152

deplib_base=$func_basename_result

5060

6153

case " $weak_libs " in

5061

6154

*" $deplib_base "*) ;;

5062

*) deplibs="$deplibs $deplib" ;;

6155

*) func_append deplibs " $deplib" ;;

5063

6156

esac

5064

6157

done

5065

6158

done

5084

6177

fi

5085

6178

continue

5086

6179

;;

5087

6180

6181

5088

6182

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

5089

6183

compile_deplibs="$deplib $compile_deplibs"

5090

6184

finalize_deplibs="$deplib $finalize_deplibs"

5091

6185

else

5092

compiler_flags="$compiler_flags $deplib"

6186

func_append compiler_flags " $deplib"

5093

6187

if test "$linkmode" = lib ; then

5094

6188

case "$new_inherited_linker_flags " in

5095

6189

*" $deplib "*) ;;

5096

* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

6190

* ) func_append new_inherited_linker_flags " $deplib" ;;

5097

6191

esac

5098

6192

fi

5099

6193

fi

5178

6272

if test "$linkmode" = lib ; then

5179

6273

case "$new_inherited_linker_flags " in

5180

6274

*" $deplib "*) ;;

5181

* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;

6275

* ) func_append new_inherited_linker_flags " $deplib" ;;

5182

6276

esac

5183

6277

fi

5184

6278

fi

5191

6285

test "$pass" = conv && continue

5192

6286

newdependency_libs="$deplib $newdependency_libs"

5193

6287

func_stripname '-L' '' "$deplib"

5194

newlib_search_path="$newlib_search_path $func_stripname_result"

6288

func_resolve_sysroot "$func_stripname_result"

6289

func_append newlib_search_path " $func_resolve_sysroot_result"

5195

6290

;;

5196

6291

prog)

5197

6292

if test "$pass" = conv; then

5205

6300

finalize_deplibs="$deplib $finalize_deplibs"

5206

6301

fi

5207

6302

func_stripname '-L' '' "$deplib"

5208

newlib_search_path="$newlib_search_path $func_stripname_result"

6303

func_resolve_sysroot "$func_stripname_result"

6304

func_append newlib_search_path " $func_resolve_sysroot_result"

5209

6305

;;

5210

6306

*)

5211

6307

func_warning "\`-L' is ignored for archives/objects"

5216

6312

-R*)

5217

6313

if test "$pass" = link; then

5218

6314

func_stripname '-R' '' "$deplib"

5219

dir=$func_stripname_result

6315

func_resolve_sysroot "$func_stripname_result"

6316

dir=$func_resolve_sysroot_result

5220

6317

# Make sure the xrpath contains only unique directories.

5221

6318

case "$xrpath " in

5222

6319

*" $dir "*) ;;

5223

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

6320

*) func_append xrpath " $dir" ;;

5224

6321

esac

5225

6322

fi

5226

6323

deplibs="$deplib $deplibs"

5227

6324

continue

5228

6325

;;

5229

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

6326

*.la)

6327

func_resolve_sysroot "$deplib"

6328

lib=$func_resolve_sysroot_result

6329

;;

5230

6330

*.$libext)

5231

6331

if test "$pass" = conv; then

5232

6332

deplibs="$deplib $deplibs"

5244

6344

match_pattern*)

5245

6345

set dummy $deplibs_check_method; shift

5246

6346

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

5247

if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \

6347

if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \

5248

6348

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

5249

6349

valid_a_lib=yes

5250

6350

fi

5254

6354

;;

5255

6355

esac

5256

6356

if test "$valid_a_lib" != yes; then

5257

$ECHO

6357

echo

5258

6358

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

5259

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

5260

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

5261

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

5262

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

5263

$ECHO "*** that it is just a static archive that I should not use here."

6359

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

6360

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

6361

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

6362

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

6363

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

5264

6364

else

5265

$ECHO

6365

echo

5266

6366

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

5267

6367

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

5268

6368

deplibs="$deplib $deplibs"

5289

6389

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

5290

6390

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

5291

6391

# we need to preload.

5292

newdlprefiles="$newdlprefiles $deplib"

6392

func_append newdlprefiles " $deplib"

5293

6393

compile_deplibs="$deplib $compile_deplibs"

5294

6394

finalize_deplibs="$deplib $finalize_deplibs"

5295

6395

else

5296

newdlfiles="$newdlfiles $deplib"

6396

func_append newdlfiles " $deplib"

5297

6397

fi

5298

6398

fi

5299

6399

continue

5335

6435

5336

6436

# Convert "-framework foo" to "foo.ltframework"

5337

6437

if test -n "$inherited_linker_flags"; then

5338

tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework $[^ $]*$/\1.ltframework/g'`

6438

tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $[^ $]*$/\1.ltframework/g'`

5339

6439

for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

5340

6440

case " $new_inherited_linker_flags " in

5341

6441

*" $tmp_inherited_linker_flag "*) ;;

5342

*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;

6442

*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;

5343

6443

esac

5344

6444

done

5345

6445

fi

5346

dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

6446

dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

5347

6447

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

5348

6448

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

5349

6449

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

5350

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

5351

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

6450

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

6451

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

5352

6452

fi

5353

6453

5354

6454

if test "$pass" = conv; then

5359

6459

func_fatal_error "cannot find name of link library for \`$lib'"

5360

6460

fi

5361

6461

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

5362

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

5363

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

6462

func_append convenience " $ladir/$objdir/$old_library"

6463

func_append old_convenience " $ladir/$objdir/$old_library"

5364

6464

tmp_libs=

5365

6465

for deplib in $dependency_libs; do

5366

6466

deplibs="$deplib $deplibs"

5367

if $opt_duplicate_deps ; then

6467

if $opt_preserve_dup_deps ; then

5368

6468

case "$tmp_libs " in

5369

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

6469

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

5370

6470

esac

5371

6471

fi

5372

tmp_libs="$tmp_libs $deplib"

6472

func_append tmp_libs " $deplib"

5373

6473

done

5374

6474

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

5375

6475

func_fatal_error "\`$lib' is not a convenience library"

5380

6480

5381

6481

# Get the name of the library we link against.

5382

6482

linklib=

5383

for l in $old_library $library_names; do

5384

linklib="$l"

5385

done

6483

if test -n "$old_library" &&

6484

{ test "$prefer_static_libs" = yes ||

6485

test "$prefer_static_libs,$installed" = "built,no"; }; then

6486

linklib=$old_library

6487

else

6488

for l in $old_library $library_names; do

6489

linklib="$l"

6490

done

6491

fi

5386

6492

if test -z "$linklib"; then

5387

6493

func_fatal_error "cannot find name of link library for \`$lib'"

5388

6494

fi

5399

6505

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

5400

6506

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

5401

6507

# bomb out in the load deplibs phase.

5402

dlprefiles="$dlprefiles $lib $dependency_libs"

6508

func_append dlprefiles " $lib $dependency_libs"

5403

6509

else

5404

newdlfiles="$newdlfiles $lib"

6510

func_append newdlfiles " $lib"

5405

6511

fi

5406

6512

continue

5407

6513

fi # $pass = dlopen

5423

6529

5424

6530

# Find the relevant object directory and library name.

5425

6531

if test "X$installed" = Xyes; then

5426

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

6532

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

5427

6533

func_warning "library \`$lib' was moved."

5428

6534

dir="$ladir"

5429

6535

absdir="$abs_ladir"

5430

6536

libdir="$abs_ladir"

5431

6537

else

5432

dir="$libdir"

5433

absdir="$libdir"

6538

dir="$lt_sysroot$libdir"

6539

absdir="$lt_sysroot$libdir"

5434

6540

fi

5435

6541

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

5436

6542

else

5438

6544

dir="$ladir"

5439

6545

absdir="$abs_ladir"

5440

6546

# Remove this search path later

5441

notinst_path="$notinst_path $abs_ladir"

6547

func_append notinst_path " $abs_ladir"

5442

6548

else

5443

6549

dir="$ladir/$objdir"

5444

6550

absdir="$abs_ladir/$objdir"

5445

6551

# Remove this search path later

5446

notinst_path="$notinst_path $abs_ladir"

6552

func_append notinst_path " $abs_ladir"

5447

6553

fi

5448

6554

fi # $installed = yes

5449

6555

func_stripname 'lib' '.la' "$laname"

5454

6560

if test -z "$libdir" && test "$linkmode" = prog; then

5455

6561

func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

5456

6562

fi

5457

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

5458

# are required to link).

5459

if test -n "$old_library"; then

5460

newdlprefiles="$newdlprefiles $dir/$old_library"

5461

# Keep a list of preopened convenience libraries to check

5462

# that they are being used correctly in the link pass.

5463

test -z "$libdir" && \

5464

dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"

5465

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

5466

elif test -n "$dlname"; then

5467

newdlprefiles="$newdlprefiles $dir/$dlname"

5468

else

5469

newdlprefiles="$newdlprefiles $dir/$linklib"

5470

fi

6563

case "$host" in

6564

# special handling for platforms with PE-DLLs.

6565

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

6566

# Linker will automatically link against shared library if both

6567

# static and shared are present. Therefore, ensure we extract

6568

# symbols from the import library if a shared library is present

6569

# (otherwise, the dlopen module name will be incorrect). We do

6570

# this by putting the import library name into $newdlprefiles.

6571

# We recover the dlopen module name by 'saving' the la file

6572

# name in a special purpose variable, and (later) extracting the

6573

# dlname from the la file.

6574

if test -n "$dlname"; then

6575

func_tr_sh "$dir/$linklib"

6576

eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"

6577

func_append newdlprefiles " $dir/$linklib"

6578

else

6579

func_append newdlprefiles " $dir/$old_library"

6580

# Keep a list of preopened convenience libraries to check

6581

# that they are being used correctly in the link pass.

6582

test -z "$libdir" && \

6583

func_append dlpreconveniencelibs " $dir/$old_library"

6584

fi

6585

;;

6586

* )

6587

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

6588

# are required to link).

6589

if test -n "$old_library"; then

6590

func_append newdlprefiles " $dir/$old_library"

6591

# Keep a list of preopened convenience libraries to check

6592

# that they are being used correctly in the link pass.

6593

test -z "$libdir" && \

6594

func_append dlpreconveniencelibs " $dir/$old_library"

6595

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

6596

elif test -n "$dlname"; then

6597

func_append newdlprefiles " $dir/$dlname"

6598

else

6599

func_append newdlprefiles " $dir/$linklib"

6600

fi

6601

;;

6602

esac

5471

6603

fi # $pass = dlpreopen

5472

6604

5473

6605

if test -z "$libdir"; then

5485

6617

5486

6618

5487

6619

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

5488

newlib_search_path="$newlib_search_path $ladir"

6620

func_append newlib_search_path " $ladir"

5489

6621

deplibs="$lib $deplibs"

5490

6622

5491

6623

linkalldeplibs=no

5498

6630

for deplib in $dependency_libs; do

5499

6631

case $deplib in

5500

6632

-L*) func_stripname '-L' '' "$deplib"

5501

newlib_search_path="$newlib_search_path $func_stripname_result"

6633

func_resolve_sysroot "$func_stripname_result"

6634

func_append newlib_search_path " $func_resolve_sysroot_result"

5502

6635

;;

5503

6636

esac

5504

6637

# Need to link against all dependency_libs?

5509

6642

# or/and link against static libraries

5510

6643

newdependency_libs="$deplib $newdependency_libs"

5511

6644

fi

5512

if $opt_duplicate_deps ; then

6645

if $opt_preserve_dup_deps ; then

5513

6646

case "$tmp_libs " in

5514

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

6647

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

5515

6648

esac

5516

6649

fi

5517

tmp_libs="$tmp_libs $deplib"

6650

func_append tmp_libs " $deplib"

5518

6651

done # for deplib

5519

6652

continue

5520

6653

fi # $linkmode = prog...

5529

6662

# Make sure the rpath contains only unique directories.

5530

6663

case "$temp_rpath:" in

5531

6664

*"$absdir:"*) ;;

5532

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

6665

*) func_append temp_rpath "$absdir:" ;;

5533

6666

esac

5534

6667

fi

5535

6668

5541

6674

*)

5542

6675

case "$compile_rpath " in

5543

6676

*" $absdir "*) ;;

5544

*) compile_rpath="$compile_rpath $absdir"

6677

*) func_append compile_rpath " $absdir" ;;

5545

6678

esac

5546

6679

;;

5547

6680

esac

5550

6683

*)

5551

6684

case "$finalize_rpath " in

5552

6685

*" $libdir "*) ;;

5553

*) finalize_rpath="$finalize_rpath $libdir"

6686

*) func_append finalize_rpath " $libdir" ;;

5554

6687

esac

5555

6688

;;

5556

6689

esac

5575

6708

case $host in

5576

6709

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

5577

6710

# No point in relinking DLLs because paths are not encoded

5578

notinst_deplibs="$notinst_deplibs $lib"

6711

func_append notinst_deplibs " $lib"

5579

6712

need_relink=no

5580

6713

;;

5581

6714

*)

5582

6715

if test "$installed" = no; then

5583

notinst_deplibs="$notinst_deplibs $lib"

6716

func_append notinst_deplibs " $lib"

5584

6717

need_relink=yes

5585

6718

fi

5586

6719

;;

5597

6730

fi

5598

6731

done

5599

6732

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

5600

$ECHO

6733

echo

5601

6734

if test "$linkmode" = prog; then

5602

6735

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

5603

6736

else

5615

6748

*)

5616

6749

case "$compile_rpath " in

5617

6750

*" $absdir "*) ;;

5618

*) compile_rpath="$compile_rpath $absdir"

6751

*) func_append compile_rpath " $absdir" ;;

5619

6752

esac

5620

6753

;;

5621

6754

esac

5624

6757

*)

5625

6758

case "$finalize_rpath " in

5626

6759

*" $libdir "*) ;;

5627

*) finalize_rpath="$finalize_rpath $libdir"

6760

*) func_append finalize_rpath " $libdir" ;;

5628

6761

esac

5629

6762

;;

5630

6763

esac

5678

6811

linklib=$newlib

5679

6812

fi # test -n "$old_archive_from_expsyms_cmds"

5680

6813

5681

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

6814

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

5682

6815

add_shlibpath=

5683

6816

add_dir=

5684

6817

add=

5700

6833

if test "X$dlopenmodule" != "X$lib"; then

5701

6834

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

5702

6835

if test -z "$old_library" ; then

5703

$ECHO

5704

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

5705

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

6836

echo

6837

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

6838

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

5706

6839

else

5707

6840

add="$dir/$old_library"

5708

6841

fi

5729

6862

test "$hardcode_direct_absolute" = no; then

5730

6863

add="$dir/$linklib"

5731

6864

elif test "$hardcode_minus_L" = yes; then

5732

add_dir="-L$dir"

6865

add_dir="-L$absdir"

5733

6866

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

5734

6867

if test -n "$inst_prefix_dir"; then

5735

6868

case $libdir in

5736

6869

[\\/]*)

5737

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

6870

func_append add_dir " -L$inst_prefix_dir$libdir"

5738

6871

;;

5739

6872

esac

5740

6873

fi

5756

6889

if test -n "$add_shlibpath"; then

5757

6890

case :$compile_shlibpath: in

5758

6891

*":$add_shlibpath:"*) ;;

5759

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

6892

*) func_append compile_shlibpath "$add_shlibpath:" ;;

5760

6893

esac

5761

6894

fi

5762

6895

if test "$linkmode" = prog; then

5770

6903

test "$hardcode_shlibpath_var" = yes; then

5771

6904

case :$finalize_shlibpath: in

5772

6905

*":$libdir:"*) ;;

5773

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

6906

*) func_append finalize_shlibpath "$libdir:" ;;

5774

6907

esac

5775

6908

fi

5776

6909

fi

5777

6910

fi

5778

6911

5779

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

6912

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

5780

6913

add_shlibpath=

5781

6914

add_dir=

5782

6915

add=

5790

6923

elif test "$hardcode_shlibpath_var" = yes; then

5791

6924

case :$finalize_shlibpath: in

5792

6925

*":$libdir:"*) ;;

5793

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

6926

*) func_append finalize_shlibpath "$libdir:" ;;

5794

6927

esac

5795

6928

add="-l$name"

5796

6929

elif test "$hardcode_automatic" = yes; then

5807

6940

if test -n "$inst_prefix_dir"; then

5808

6941

case $libdir in

5809

6942

[\\/]*)

5810

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

6943

func_append add_dir " -L$inst_prefix_dir$libdir"

5811

6944

;;

5812

6945

esac

5813

6946

fi

5842

6975

5843

6976

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

5844

6977

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

5845

$ECHO

6978

echo

5846

6979

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

5847

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

5848

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

5849

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

6980

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

6981

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

6982

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

5850

6983

if test "$module" = yes; then

5851

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

5852

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

5853

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

6984

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

6985

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

6986

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

5854

6987

if test -z "$global_symbol_pipe"; then

5855

$ECHO

5856

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

5857

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

5858

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

5859

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

6988

echo

6989

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

6990

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

6991

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

6992

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

5860

6993

fi

5861

6994

if test "$build_old_libs" = no; then

5862

6995

build_libtool_libs=module

5884

7017

temp_xrpath=$func_stripname_result

5885

7018

case " $xrpath " in

5886

7019

*" $temp_xrpath "*) ;;

5887

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

7020

*) func_append xrpath " $temp_xrpath";;

5888

7021

esac;;

5889

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

7022

*) func_append temp_deplibs " $libdir";;

5890

7023

esac

5891

7024

done

5892

7025

dependency_libs="$temp_deplibs"

5893

7026

fi

5894

7027

5895

newlib_search_path="$newlib_search_path $absdir"

7028

func_append newlib_search_path " $absdir"

5896

7029

# Link against this library

5897

7030

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

5898

7031

# ... and its dependency_libs

5899

7032

tmp_libs=

5900

7033

for deplib in $dependency_libs; do

5901

7034

newdependency_libs="$deplib $newdependency_libs"

5902

if $opt_duplicate_deps ; then

7035

case $deplib in

7036

-L*) func_stripname '-L' '' "$deplib"

7037

func_resolve_sysroot "$func_stripname_result";;

7038

*) func_resolve_sysroot "$deplib" ;;

7039

esac

7040

if $opt_preserve_dup_deps ; then

5903

7041

case "$tmp_libs " in

5904

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

7042

*" $func_resolve_sysroot_result "*)

7043

func_append specialdeplibs " $func_resolve_sysroot_result" ;;

5905

7044

esac

5906

7045

fi

5907

tmp_libs="$tmp_libs $deplib"

7046

func_append tmp_libs " $func_resolve_sysroot_result"

5908

7047

done

5909

7048

5910

7049

if test "$link_all_deplibs" != no; then

5914

7053

case $deplib in

5915

7054

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

5916

7055

*.la)

7056

func_resolve_sysroot "$deplib"

7057

deplib=$func_resolve_sysroot_result

5917

7058

func_dirname "$deplib" "" "."

5918

dir="$func_dirname_result"

7059

dir=$func_dirname_result

5919

7060

# We need an absolute path.

5920

7061

case $dir in

5921

7062

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

5942

7083

if test -z "$darwin_install_name"; then

5943

7084

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

5944

7085

fi

5945

compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

5946

linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"

7086

func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

7087

func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"

5947

7088

path=

5948

7089

fi

5949

7090

fi

5976

7117

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

5977

7118

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

5978

7119

else

5979

compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

7120

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

5980

7121

fi

5981

7122

fi

5982

7123

dependency_libs="$newdependency_libs"

5993

7134

for dir in $newlib_search_path; do

5994

7135

case "$lib_search_path " in

5995

7136

*" $dir "*) ;;

5996

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

7137

*) func_append lib_search_path " $dir" ;;

5997

7138

esac

5998

7139

done

5999

7140

newlib_search_path=

6051

7192

-L*)

6052

7193

case " $tmp_libs " in

6053

7194

*" $deplib "*) ;;

6054

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

7195

*) func_append tmp_libs " $deplib" ;;

6055

7196

esac

6056

7197

;;

6057

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

7198

*) func_append tmp_libs " $deplib" ;;

6058

7199

esac

6059

7200

done

6060

7201

eval $var=\"$tmp_libs\"

6070

7211

;;

6071

7212

esac

6072

7213

if test -n "$i" ; then

6073

tmp_libs="$tmp_libs $i"

7214

func_append tmp_libs " $i"

6074

7215

fi

6075

7216

done

6076

7217

dependency_libs=$tmp_libs

6111

7252

# Now set the variables for building old libraries.

6112

7253

build_libtool_libs=no

6113

7254

oldlibs="$output"

6114

objs="$objs$old_deplibs"

7255

func_append objs "$old_deplibs"

6115

7256

;;

6116

7257

6117

7258

lib)

6144

7285

if test "$deplibs_check_method" != pass_all; then

6145

7286

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

6146

7287

else

6147

$ECHO

7288

echo

6148

7289

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

6149

7290

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

6150

libobjs="$libobjs $objs"

7291

func_append libobjs " $objs"

6151

7292

fi

6152

7293

fi

6153

7294

6206

7347

# which has an extra 1 added just for fun

6207

7348

#

6208

7349

case $version_type in

7350

# correct linux to gnu/linux during the next big refactor

6209

7351

darwin|linux|osf|windows|none)

6210

7352

func_arith $number_major + $number_minor

6211

7353

current=$func_arith_result

6212

7354

age="$number_minor"

6213

7355

revision="$number_revision"

6214

7356

;;

6215

freebsd-aout|freebsd-elf|sunos)

7357

freebsd-aout|freebsd-elf|qnx|sunos)

6216

7358

current="$number_major"

6217

7359

revision="$number_minor"

6218

7360

age="0"

6325

7467

versuffix="$major.$revision"

6326

7468

;;

6327

7469

6328

linux)

7470

linux) # correct to gnu/linux during the next big refactor

6329

7471

func_arith $current - $age

6330

7472

major=.$func_arith_result

6331

7473

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

6348

7490

done

6349

7491

6350

7492

# Make executables depend on our current version.

6351

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

7493

func_append verstring ":${current}.0"

6352

7494

;;

6353

7495

6354

7496

qnx)

6416

7558

fi

6417

7559

6418

7560

func_generate_dlsyms "$libname" "$libname" "yes"

6419

libobjs="$libobjs $symfileobj"

7561

func_append libobjs " $symfileobj"

6420

7562

test "X$libobjs" = "X " && libobjs=

6421

7563

6422

if test "$mode" != relink; then

7564

if test "$opt_mode" != relink; then

6423

7565

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

6424

7566

# may have been created when compiling PIC objects.

6425

7567

removelist=

6435

7577

continue

6436

7578

fi

6437

7579

fi

6438

removelist="$removelist $p"

7580

func_append removelist " $p"

6439

7581

;;

6440

7582

*) ;;

6441

7583

esac

6446

7588

6447

7589

# Now set the variables for building old libraries.

6448

7590

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

6449

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

7591

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

6450

7592

6451

7593

# Transform .lo files to .o files.

6452

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

7594

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

6453

7595

fi

6454

7596

6455

7597

# Eliminate all temporary directories.

6456

7598

#for path in $notinst_path; do

6457

# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`

6458

# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`

6459

# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`

7599

# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

7600

# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

7601

# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

6460

7602

#done

6461

7603

6462

7604

if test -n "$xrpath"; then

6463

7605

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

6464

7606

temp_xrpath=

6465

7607

for libdir in $xrpath; do

6466

temp_xrpath="$temp_xrpath -R$libdir"

7608

func_replace_sysroot "$libdir"

7609

func_append temp_xrpath " -R$func_replace_sysroot_result"

6467

7610

case "$finalize_rpath " in

6468

7611

*" $libdir "*) ;;

6469

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

7612

*) func_append finalize_rpath " $libdir" ;;

6470

7613

esac

6471

7614

done

6472

7615

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

6480

7623

for lib in $old_dlfiles; do

6481

7624

case " $dlprefiles $dlfiles " in

6482

7625

*" $lib "*) ;;

6483

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

7626

*) func_append dlfiles " $lib" ;;

6484

7627

esac

6485

7628

done

6486

7629

6490

7633

for lib in $old_dlprefiles; do

6491

7634

case "$dlprefiles " in

6492

7635

*" $lib "*) ;;

6493

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

7636

*) func_append dlprefiles " $lib" ;;

6494

7637

esac

6495

7638

done

6496

7639

6497

7640

if test "$build_libtool_libs" = yes; then

6498

7641

if test -n "$rpath"; then

6499

7642

case $host in

6500

7643

6501

7644

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

6502

7645

;;

6503

7646

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

6504

7647

# Rhapsody C library is in the System framework

6505

deplibs="$deplibs System.ltframework"

7648

func_append deplibs " System.ltframework"

6506

7649

;;

6507

7650

*-*-netbsd*)

6508

7651

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

6519

7662

*)

6520

7663

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

6521

7664

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

6522

deplibs="$deplibs -lc"

7665

func_append deplibs " -lc"

6523

7666

fi

6524

7667

;;

6525

7668

esac

6568

7711

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

6569

7712

case " $predeps $postdeps " in

6570

7713

*" $i "*)

6571

newdeplibs="$newdeplibs $i"

7714

func_append newdeplibs " $i"

6572

7715

i=""

6573

7716

;;

6574

7717

esac

6579

7722

set dummy $deplib_matches; shift

6580

7723

deplib_match=$1

6581

7724

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

6582

newdeplibs="$newdeplibs $i"

7725

func_append newdeplibs " $i"

6583

7726

else

6584

7727

droppeddeps=yes

6585

$ECHO

7728

echo

6586

7729

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

6587

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

6588

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

6589

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

6590

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

6591

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

7730

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

7731

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

7732

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

7733

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

7734

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

6592

7735

fi

6593

7736

fi

6594

7737

;;

6595

7738

*)

6596

newdeplibs="$newdeplibs $i"

7739

func_append newdeplibs " $i"

6597

7740

;;

6598

7741

esac

6599

7742

done

6611

7754

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

6612

7755

case " $predeps $postdeps " in

6613

7756

*" $i "*)

6614

newdeplibs="$newdeplibs $i"

7757

func_append newdeplibs " $i"

6615

7758

i=""

6616

7759

;;

6617

7760

esac

6622

7765

set dummy $deplib_matches; shift

6623

7766

deplib_match=$1

6624

7767

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

6625

newdeplibs="$newdeplibs $i"

7768

func_append newdeplibs " $i"

6626

7769

else

6627

7770

droppeddeps=yes

6628

$ECHO

7771

echo

6629

7772

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

6630

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

6631

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

6632

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

6633

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

6634

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

7773

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

7774

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

7775

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

7776

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

7777

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

6635

7778

fi

6636

7779

fi

6637

7780

else

6638

7781

droppeddeps=yes

6639

$ECHO

7782

echo

6640

7783

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

6641

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

6642

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

6643

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

7784

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

7785

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

7786

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

6644

7787

fi

6645

7788

;;

6646

7789

*)

6647

newdeplibs="$newdeplibs $i"

7790

func_append newdeplibs " $i"

6648

7791

;;

6649

7792

esac

6650

7793

done

6661

7804

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

6662

7805

case " $predeps $postdeps " in

6663

7806

*" $a_deplib "*)

6664

newdeplibs="$newdeplibs $a_deplib"

7807

func_append newdeplibs " $a_deplib"

6665

7808

a_deplib=""

6666

7809

;;

6667

7810

esac

6668

7811

fi

6669

7812

if test -n "$a_deplib" ; then

6670

7813

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

7814

if test -n "$file_magic_glob"; then

7815

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

7816

else

7817

libnameglob=$libname

7818

fi

7819

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

6671

7820

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

6672

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

7821

if test "$want_nocaseglob" = yes; then

7822

shopt -s nocaseglob

7823

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

7824

$nocaseglob

7825

else

7826

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

7827

fi

6673

7828

for potent_lib in $potential_libs; do

6674

7829

# Follow soft links.

6675

7830

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

6686

7841

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

6687

7842

case $potliblink in

6688

7843

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

6689

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

7844

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

6690

7845

esac

6691

7846

done

6692

7847

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

6693

7848

$SED -e 10q |

6694

7849

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

6695

newdeplibs="$newdeplibs $a_deplib"

7850

func_append newdeplibs " $a_deplib"

6696

7851

a_deplib=""

6697

7852

break 2

6698

7853

fi

6701

7856

fi

6702

7857

if test -n "$a_deplib" ; then

6703

7858

droppeddeps=yes

6704

$ECHO

7859

echo

6705

7860

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

6706

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

6707

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

6708

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

6709

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

7861

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

7862

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

7863

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

7864

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

6710

7865

if test -z "$potlib" ; then

6711

7866

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

6712

7867

else

6717

7872

;;

6718

7873

*)

6719

7874

# Add a -L argument.

6720

newdeplibs="$newdeplibs $a_deplib"

7875

func_append newdeplibs " $a_deplib"

6721

7876

;;

6722

7877

esac

6723

7878

done # Gone through all deplibs.

6733

7888

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

6734

7889

case " $predeps $postdeps " in

6735

7890

*" $a_deplib "*)

6736

newdeplibs="$newdeplibs $a_deplib"

7891

func_append newdeplibs " $a_deplib"

6737

7892

a_deplib=""

6738

7893

;;

6739

7894

esac

6744

7899

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

6745

7900

for potent_lib in $potential_libs; do

6746

7901

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

6747

if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \

7902

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

6748

7903

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

6749

newdeplibs="$newdeplibs $a_deplib"

7904

func_append newdeplibs " $a_deplib"

6750

7905

a_deplib=""

6751

7906

break 2

6752

7907

fi

6755

7910

fi

6756

7911

if test -n "$a_deplib" ; then

6757

7912

droppeddeps=yes

6758

$ECHO

7913

echo

6759

7914

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

6760

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

6761

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

6762

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

6763

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

7915

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

7916

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

7917

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

7918

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

6764

7919

if test -z "$potlib" ; then

6765

7920

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

6766

7921

else

6771

7926

;;

6772

7927

*)

6773

7928

# Add a -L argument.

6774

newdeplibs="$newdeplibs $a_deplib"

7929

func_append newdeplibs " $a_deplib"

6775

7930

;;

6776

7931

esac

6777

7932

done # Gone through all deplibs.

6778

7933

;;

6779

7934

none | unknown | *)

6780

7935

newdeplibs=""

6781

tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \

6782

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

7936

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

6783

7937

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

6784

7938

for i in $predeps $postdeps ; do

6785

7939

# can't use Xsed below, because $i might contain '/'

6786

tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`

7940

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

6787

7941

done

6788

7942

fi

6789

if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |

6790

$GREP . >/dev/null; then

6791

$ECHO

7943

case $tmp_deplibs in

7944

*[!\ \ ]*)

7945

echo

6792

7946

if test "X$deplibs_check_method" = "Xnone"; then

6793

$ECHO "*** Warning: inter-library dependencies are not supported in this platform."

7947

echo "*** Warning: inter-library dependencies are not supported in this platform."

6794

7948

else

6795

$ECHO "*** Warning: inter-library dependencies are not known to be supported."

7949

echo "*** Warning: inter-library dependencies are not known to be supported."

6796

7950

fi

6797

$ECHO "*** All declared inter-library dependencies are being dropped."

7951

echo "*** All declared inter-library dependencies are being dropped."

6798

7952

droppeddeps=yes

6799

fi

7953

;;

7954

esac

6800

7955

;;

6801

7956

esac

6802

7957

versuffix=$versuffix_save

6808

7963

case $host in

6809

7964

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

6810

7965

# On Rhapsody replace the C library with the System framework

6811

newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

7966

newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

6812

7967

;;

6813

7968

esac

6814

7969

6815

7970

if test "$droppeddeps" = yes; then

6816

7971

if test "$module" = yes; then

6817

$ECHO

6818

$ECHO "*** Warning: libtool could not satisfy all declared inter-library"

7972

echo

7973

echo "*** Warning: libtool could not satisfy all declared inter-library"

6819

7974

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

6820

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

6821

$ECHO "*** application is linked with the -dlopen flag."

7975

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

7976

echo "*** application is linked with the -dlopen flag."

6822

7977

if test -z "$global_symbol_pipe"; then

6823

$ECHO

6824

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

6825

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

6826

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

6827

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

7978

echo

7979

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

7980

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

7981

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

7982

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

6828

7983

fi

6829

7984

if test "$build_old_libs" = no; then

6830

7985

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

6834

7989

build_libtool_libs=no

6835

7990

fi

6836

7991

else

6837

$ECHO "*** The inter-library dependencies that have been dropped here will be"

6838

$ECHO "*** automatically added whenever a program is linked with this library"

6839

$ECHO "*** or is declared to -dlopen it."

7992

echo "*** The inter-library dependencies that have been dropped here will be"

7993

echo "*** automatically added whenever a program is linked with this library"

7994

echo "*** or is declared to -dlopen it."

6840

7995

6841

7996

if test "$allow_undefined" = no; then

6842

$ECHO

6843

$ECHO "*** Since this library must not contain undefined symbols,"

6844

$ECHO "*** because either the platform does not support them or"

6845

$ECHO "*** it was explicitly requested with -no-undefined,"

6846

$ECHO "*** libtool will only create a static version of it."

7997

echo

7998

echo "*** Since this library must not contain undefined symbols,"

7999

echo "*** because either the platform does not support them or"

8000

echo "*** it was explicitly requested with -no-undefined,"

8001

echo "*** libtool will only create a static version of it."

6847

8002

if test "$build_old_libs" = no; then

6848

8003

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

6849

8004

build_libtool_libs=module

6860

8015

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

6861

8016

case $host in

6862

8017

*-*-darwin*)

6863

newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

6864

new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

6865

deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

8018

newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8019

new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8020

deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6866

8021

;;

6867

8022

esac

6868

8023

6875

8030

*)

6876

8031

case " $deplibs " in

6877

8032

*" -L$path/$objdir "*)

6878

new_libs="$new_libs -L$path/$objdir" ;;

8033

func_append new_libs " -L$path/$objdir" ;;

6879

8034

esac

6880

8035

;;

6881

8036

esac

6885

8040

-L*)

6886

8041

case " $new_libs " in

6887

8042

*" $deplib "*) ;;

6888

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

8043

*) func_append new_libs " $deplib" ;;

6889

8044

esac

6890

8045

;;

6891

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

8046

*) func_append new_libs " $deplib" ;;

6892

8047

esac

6893

8048

done

6894

8049

deplibs="$new_libs"

6900

8055

6901

8056

# Test again, we may have decided not to build it any more

6902

8057

if test "$build_libtool_libs" = yes; then

8058

# Remove ${wl} instances when linking with ld.

8059

# FIXME: should test the right _cmds variable.

8060

case $archive_cmds in

8061

*\$LD\ *) wl= ;;

8062

esac

6903

8063

if test "$hardcode_into_libs" = yes; then

6904

8064

# Hardcode the library paths

6905

8065

hardcode_libdirs=

6906

8066

dep_rpath=

6907

8067

rpath="$finalize_rpath"

6908

test "$mode" != relink && rpath="$compile_rpath$rpath"

8068

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

6909

8069

for libdir in $rpath; do

6910

8070

if test -n "$hardcode_libdir_flag_spec"; then

6911

8071

if test -n "$hardcode_libdir_separator"; then

8072

func_replace_sysroot "$libdir"

8073

libdir=$func_replace_sysroot_result

6912

8074

if test -z "$hardcode_libdirs"; then

6913

8075

hardcode_libdirs="$libdir"

6914

8076

else

6917

8079

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

6918

8080

;;

6919

8081

*)

6920

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8082

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

6921

8083

;;

6922

8084

esac

6923

8085

fi

6924

8086

else

6925

8087

eval flag=\"$hardcode_libdir_flag_spec\"

6926

dep_rpath="$dep_rpath $flag"

8088

func_append dep_rpath " $flag"

6927

8089

fi

6928

8090

elif test -n "$runpath_var"; then

6929

8091

case "$perm_rpath " in

6930

8092

*" $libdir "*) ;;

6931

*) perm_rpath="$perm_rpath $libdir" ;;

8093

*) func_append perm_rpath " $libdir" ;;

6932

8094

esac

6933

8095

fi

6934

8096

done

6936

8098

if test -n "$hardcode_libdir_separator" &&

6937

8099

test -n "$hardcode_libdirs"; then

6938

8100

libdir="$hardcode_libdirs"

6939

if test -n "$hardcode_libdir_flag_spec_ld"; then

6940

eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"

6941

else

6942

eval dep_rpath=\"$hardcode_libdir_flag_spec\"

6943

fi

8101

eval "dep_rpath=\"$hardcode_libdir_flag_spec\""

6944

8102

fi

6945

8103

if test -n "$runpath_var" && test -n "$perm_rpath"; then

6946

8104

# We should set the runpath_var.

6947

8105

rpath=

6948

8106

for dir in $perm_rpath; do

6949

rpath="$rpath$dir:"

8107

func_append rpath "$dir:"

6950

8108

done

6951

8109

eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

6952

8110

fi

6954

8112

fi

6955

8113

6956

8114

shlibpath="$finalize_shlibpath"

6957

test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

8115

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

6958

8116

if test -n "$shlibpath"; then

6959

8117

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

6960

8118

fi

6980

8138

linknames=

6981

8139

for link

6982

8140

do

6983

linknames="$linknames $link"

8141

func_append linknames " $link"

6984

8142

done

6985

8143

6986

8144

# Use standard objects if they are pic

6987

test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

8145

test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

6988

8146

test "X$libobjs" = "X " && libobjs=

6989

8147

6990

8148

delfiles=

6991

8149

if test -n "$export_symbols" && test -n "$include_expsyms"; then

6992

8150

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

6993

8151

export_symbols="$output_objdir/$libname.uexp"

6994

delfiles="$delfiles $export_symbols"

8152

func_append delfiles " $export_symbols"

6995

8153

fi

6996

8154

6997

8155

orig_export_symbols=

7022

8180

$opt_dry_run || $RM $export_symbols

7023

8181

cmds=$export_symbols_cmds

7024

8182

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

7025

for cmd in $cmds; do

8183

for cmd1 in $cmds; do

7026

8184

IFS="$save_ifs"

7027

eval cmd=\"$cmd\"

7028

func_len " $cmd"

7029

len=$func_len_result

7030

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

7031

func_show_eval "$cmd" 'exit $?'

8185

# Take the normal branch if the nm_file_list_spec branch

8186

# doesn't work or if tool conversion is not needed.

8187

case $nm_file_list_spec~$to_tool_file_cmd in

8188

*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)

8189

try_normal_branch=yes

8190

eval cmd=\"$cmd1\"

8191

func_len " $cmd"

8192

len=$func_len_result

8193

;;

8194

*)

8195

try_normal_branch=no

8196

;;

8197

esac

8198

if test "$try_normal_branch" = yes \

8199

&& { test "$len" -lt "$max_cmd_len" \

8200

|| test "$max_cmd_len" -le -1; }

8201

then

8202

func_show_eval "$cmd" 'exit $?'

8203

skipped_export=false

8204

elif test -n "$nm_file_list_spec"; then

8205

func_basename "$output"

8206

output_la=$func_basename_result

8207

save_libobjs=$libobjs

8208

save_output=$output

8209

output=${output_objdir}/${output_la}.nm

8210

func_to_tool_file "$output"

8211

libobjs=$nm_file_list_spec$func_to_tool_file_result

8212

func_append delfiles " $output"

8213

func_verbose "creating $NM input file list: $output"

8214

for obj in $save_libobjs; do

8215

func_to_tool_file "$obj"

8216

$ECHO "$func_to_tool_file_result"

8217

done > "$output"

8218

eval cmd=\"$cmd1\"

8219

func_show_eval "$cmd" 'exit $?'

8220

output=$save_output

8221

libobjs=$save_libobjs

7032

8222

skipped_export=false

7033

8223

else

7034

8224

# The command line is too long to execute in one step.

7050

8240

if test -n "$export_symbols" && test -n "$include_expsyms"; then

7051

8241

tmp_export_symbols="$export_symbols"

7052

8242

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

7053

$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

8243

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

7054

8244

fi

7055

8245

7056

8246

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

7062

8252

# global variables. join(1) would be nice here, but unfortunately

7063

8253

# isn't a blessed tool.

7064

8254

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

7065

delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8255

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

7066

8256

export_symbols=$output_objdir/$libname.def

7067

8257

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

7068

8258

fi

7072

8262

case " $convenience " in

7073

8263

*" $test_deplib "*) ;;

7074

8264

*)

7075

tmp_deplibs="$tmp_deplibs $test_deplib"

8265

func_append tmp_deplibs " $test_deplib"

7076

8266

;;

7077

8267

esac

7078

8268

done

7092

8282

test "X$libobjs" = "X " && libobjs=

7093

8283

else

7094

8284

gentop="$output_objdir/${outputname}x"

7095

generated="$generated $gentop"

8285

func_append generated " $gentop"

7096

8286

7097

8287

func_extract_archives $gentop $convenience

7098

libobjs="$libobjs $func_extract_archives_result"

8288

func_append libobjs " $func_extract_archives_result"

7099

8289

test "X$libobjs" = "X " && libobjs=

7100

8290

fi

7101

8291

fi

7102

8292

7103

8293

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

7104

8294

eval flag=\"$thread_safe_flag_spec\"

7105

linker_flags="$linker_flags $flag"

8295

func_append linker_flags " $flag"

7106

8296

fi

7107

8297

7108

8298

# Make a backup of the uninstalled library when relinking

7109

if test "$mode" = relink; then

8299

if test "$opt_mode" = relink; then

7110

8300

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

7111

8301

fi

7112

8302

7151

8341

save_libobjs=$libobjs

7152

8342

fi

7153

8343

save_output=$output

7154

output_la=`$ECHO "X$output" | $Xsed -e "$basename"`

8344

func_basename "$output"

8345

output_la=$func_basename_result

7155

8346

7156

8347

# Clear the reloadable object creation command queue and

7157

8348

# initialize k to one.

7164

8355

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

7165

8356

output=${output_objdir}/${output_la}.lnkscript

7166

8357

func_verbose "creating GNU ld script: $output"

7167

$ECHO 'INPUT (' > $output

8358

echo 'INPUT (' > $output

7168

8359

for obj in $save_libobjs

7169

8360

do

7170

$ECHO "$obj" >> $output

8361

func_to_tool_file "$obj"

8362

$ECHO "$func_to_tool_file_result" >> $output

7171

8363

done

7172

$ECHO ')' >> $output

7173

delfiles="$delfiles $output"

8364

echo ')' >> $output

8365

func_append delfiles " $output"

8366

func_to_tool_file "$output"

8367

output=$func_to_tool_file_result

7174

8368

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

7175

8369

output=${output_objdir}/${output_la}.lnk

7176

8370

func_verbose "creating linker input file list: $output"

7184

8378

fi

7185

8379

for obj

7186

8380

do

7187

$ECHO "$obj" >> $output

8381

func_to_tool_file "$obj"

8382

$ECHO "$func_to_tool_file_result" >> $output

7188

8383

done

7189

delfiles="$delfiles $output"

7190

output=$firstobj\"$file_list_spec$output\"

8384

func_append delfiles " $output"

8385

func_to_tool_file "$output"

8386

output=$firstobj\"$file_list_spec$func_to_tool_file_result\"

7191

8387

else

7192

8388

if test -n "$save_libobjs"; then

7193

8389

func_verbose "creating reloadable object files..."

7211

8407

# command to the queue.

7212

8408

if test "$k" -eq 1 ; then

7213

8409

# The first file doesn't have a previous command to add.

7214

eval concat_cmds=\"$reload_cmds $objlist $last_robj\"

8410

reload_objs=$objlist

8411

eval concat_cmds=\"$reload_cmds\"

7215

8412

else

7216

8413

# All subsequent reloadable object files will link in

7217

8414

# the last one created.

7218

eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"

8415

reload_objs="$objlist $last_robj"

8416

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

7219

8417

fi

7220

8418

last_robj=$output_objdir/$output_la-${k}.$objext

7221

8419

func_arith $k + 1

7222

8420

k=$func_arith_result

7223

8421

output=$output_objdir/$output_la-${k}.$objext

7224

objlist=$obj

8422

objlist=" $obj"

7225

8423

func_len " $last_robj"

7226

8424

func_arith $len0 + $func_len_result

7227

8425

len=$func_arith_result

7231

8429

# reloadable object file. All subsequent reloadable object

7232

8430

# files will link in the last one created.

7233

8431

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

7234

eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"

8432

reload_objs="$objlist $last_robj"

8433

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

7235

8434

if test -n "$last_robj"; then

7236

8435

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

7237

8436

fi

7238

delfiles="$delfiles $output"

8437

func_append delfiles " $output"

7239

8438

7240

8439

else

7241

8440

output=

7269

8468

lt_exit=$?

7270

8469

7271

8470

# Restore the uninstalled library and exit

7272

if test "$mode" = relink; then

8471

if test "$opt_mode" = relink; then

7273

8472

( cd "$output_objdir" && \

7274

8473

$RM "${realname}T" && \

7275

8474

$MV "${realname}U" "$realname" )

7290

8489

if test -n "$export_symbols" && test -n "$include_expsyms"; then

7291

8490

tmp_export_symbols="$export_symbols"

7292

8491

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

7293

$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

8492

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

7294

8493

fi

7295

8494

7296

8495

if test -n "$orig_export_symbols"; then

7302

8501

# global variables. join(1) would be nice here, but unfortunately

7303

8502

# isn't a blessed tool.

7304

8503

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

7305

delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8504

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

7306

8505

export_symbols=$output_objdir/$libname.def

7307

8506

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

7308

8507

fi

7343

8542

# Add any objects from preloaded convenience libraries

7344

8543

if test -n "$dlprefiles"; then

7345

8544

gentop="$output_objdir/${outputname}x"

7346

generated="$generated $gentop"

8545

func_append generated " $gentop"

7347

8546

7348

8547

func_extract_archives $gentop $dlprefiles

7349

libobjs="$libobjs $func_extract_archives_result"

8548

func_append libobjs " $func_extract_archives_result"

7350

8549

test "X$libobjs" = "X " && libobjs=

7351

8550

fi

7352

8551

7362

8561

lt_exit=$?

7363

8562

7364

8563

# Restore the uninstalled library and exit

7365

if test "$mode" = relink; then

8564

if test "$opt_mode" = relink; then

7366

8565

( cd "$output_objdir" && \

7367

8566

$RM "${realname}T" && \

7368

8567

$MV "${realname}U" "$realname" )

7374

8573

IFS="$save_ifs"

7375

8574

7376

8575

# Restore the uninstalled library and exit

7377

if test "$mode" = relink; then

8576

if test "$opt_mode" = relink; then

7378

8577

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

7379

8578

7380

8579

if test -n "$convenience"; then

7455

8654

if test -n "$convenience"; then

7456

8655

if test -n "$whole_archive_flag_spec"; then

7457

8656

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

7458

reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`

8657

reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

7459

8658

else

7460

8659

gentop="$output_objdir/${obj}x"

7461

generated="$generated $gentop"

8660

func_append generated " $gentop"

7462

8661

7463

8662

func_extract_archives $gentop $convenience

7464

8663

reload_conv_objs="$reload_objs $func_extract_archives_result"

7465

8664

fi

7466

8665

fi

7467

8666

8667

# If we're not building shared, we need to use non_pic_objs

8668

test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

8669

7468

8670

# Create the old-style object.

7469

reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

8671

reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

7470

8672

7471

8673

output="$obj"

7472

8674

func_execute_cmds "$reload_cmds" 'exit $?'

7526

8728

case $host in

7527

8729

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

7528

8730

# On Rhapsody replace the C library is the System framework

7529

compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

7530

finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

8731

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

8732

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

7531

8733

;;

7532

8734

esac

7533

8735

7538

8740

if test "$tagname" = CXX ; then

7539

8741

case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

7540

8742

10.[0123])

7541

compile_command="$compile_command ${wl}-bind_at_load"

7542

finalize_command="$finalize_command ${wl}-bind_at_load"

8743

func_append compile_command " ${wl}-bind_at_load"

8744

func_append finalize_command " ${wl}-bind_at_load"

7543

8745

;;

7544

8746

esac

7545

8747

fi

7546

8748

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

7547

compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

7548

finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

8749

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8750

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7549

8751

;;

7550

8752

esac

7551

8753

7559

8761

*)

7560

8762

case " $compile_deplibs " in

7561

8763

*" -L$path/$objdir "*)

7562

new_libs="$new_libs -L$path/$objdir" ;;

8764

func_append new_libs " -L$path/$objdir" ;;

7563

8765

esac

7564

8766

;;

7565

8767

esac

7569

8771

-L*)

7570

8772

case " $new_libs " in

7571

8773

*" $deplib "*) ;;

7572

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

8774

*) func_append new_libs " $deplib" ;;

7573

8775

esac

7574

8776

;;

7575

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

8777

*) func_append new_libs " $deplib" ;;

7576

8778

esac

7577

8779

done

7578

8780

compile_deplibs="$new_libs"

7579

8781

7580

8782

7581

compile_command="$compile_command $compile_deplibs"

7582

finalize_command="$finalize_command $finalize_deplibs"

8783

func_append compile_command " $compile_deplibs"

8784

func_append finalize_command " $finalize_deplibs"

7583

8785

7584

8786

if test -n "$rpath$xrpath"; then

7585

8787

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

7587

8789

# This is the magic to use -rpath.

7588

8790

case "$finalize_rpath " in

7589

8791

*" $libdir "*) ;;

7590

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

8792

*) func_append finalize_rpath " $libdir" ;;

7591

8793

esac

7592

8794

done

7593

8795

fi

7606

8808

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

7607

8809

;;

7608

8810

*)

7609

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8811

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

7610

8812

;;

7611

8813

esac

7612

8814

fi

7613

8815

else

7614

8816

eval flag=\"$hardcode_libdir_flag_spec\"

7615

rpath="$rpath $flag"

8817

func_append rpath " $flag"

7616

8818

fi

7617

8819

elif test -n "$runpath_var"; then

7618

8820

case "$perm_rpath " in

7619

8821

*" $libdir "*) ;;

7620

*) perm_rpath="$perm_rpath $libdir" ;;

8822

*) func_append perm_rpath " $libdir" ;;

7621

8823

esac

7622

8824

fi

7623

8825

case $host in

7626

8828

case :$dllsearchpath: in

7627

8829

*":$libdir:"*) ;;

7628

8830

::) dllsearchpath=$libdir;;

7629

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

8831

*) func_append dllsearchpath ":$libdir";;

7630

8832

esac

7631

8833

case :$dllsearchpath: in

7632

8834

*":$testbindir:"*) ;;

7633

8835

::) dllsearchpath=$testbindir;;

7634

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

8836

*) func_append dllsearchpath ":$testbindir";;

7635

8837

esac

7636

8838

;;

7637

8839

esac

7657

8859

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

7658

8860

;;

7659

8861

*)

7660

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8862

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

7661

8863

;;

7662

8864

esac

7663

8865

fi

7664

8866

else

7665

8867

eval flag=\"$hardcode_libdir_flag_spec\"

7666

rpath="$rpath $flag"

8868

func_append rpath " $flag"

7667

8869

fi

7668

8870

elif test -n "$runpath_var"; then

7669

8871

case "$finalize_perm_rpath " in

7670

8872

*" $libdir "*) ;;

7671

*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

8873

*) func_append finalize_perm_rpath " $libdir" ;;

7672

8874

esac

7673

8875

fi

7674

8876

done

7682

8884

7683

8885

if test -n "$libobjs" && test "$build_old_libs" = yes; then

7684

8886

# Transform all the library objects into standard objects.

7685

compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

7686

finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

8887

compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8888

finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

7687

8889

fi

7688

8890

7689

8891

func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

7695

8897

7696

8898

wrappers_required=yes

7697

8899

case $host in

8900

*cegcc* | *mingw32ce*)

8901

# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

8902

wrappers_required=no

8903

;;

7698

8904

*cygwin* | *mingw* )

7699

8905

if test "$build_libtool_libs" != yes; then

7700

8906

wrappers_required=no

7701

8907

fi

7702

8908

;;

7703

*cegcc)

7704

# Disable wrappers for cegcc, we are cross compiling anyway.

7705

wrappers_required=no

7706

;;

7707

8909

*)

7708

8910

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

7709

8911

wrappers_required=no

7712

8914

esac

7713

8915

if test "$wrappers_required" = no; then

7714

8916

# Replace the output file specification.

7715

compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

8917

compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

7716

8918

link_command="$compile_command$compile_rpath"

7717

8919

7718

8920

# We have no uninstalled library dependencies, so finalize right now.

7719

8921

exit_status=0

7720

8922

func_show_eval "$link_command" 'exit_status=$?'

7721

8923

8924

if test -n "$postlink_cmds"; then

8925

func_to_tool_file "$output"

8926

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8927

func_execute_cmds "$postlink_cmds" 'exit $?'

8928

fi

8929

7722

8930

# Delete the generated files.

7723

8931

if test -f "$output_objdir/${outputname}S.${objext}"; then

7724

8932

func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

7741

8949

# We should set the runpath_var.

7742

8950

rpath=

7743

8951

for dir in $perm_rpath; do

7744

rpath="$rpath$dir:"

8952

func_append rpath "$dir:"

7745

8953

done

7746

8954

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

7747

8955

fi

7749

8957

# We should set the runpath_var.

7750

8958

rpath=

7751

8959

for dir in $finalize_perm_rpath; do

7752

rpath="$rpath$dir:"

8960

func_append rpath "$dir:"

7753

8961

done

7754

8962

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

7755

8963

fi

7759

8967

# We don't need to create a wrapper script.

7760

8968

link_command="$compile_var$compile_command$compile_rpath"

7761

8969

# Replace the output file specification.

7762

link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

8970

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

7763

8971

# Delete the old output file.

7764

8972

$opt_dry_run || $RM $output

7765

8973

# Link the executable and exit

7766

8974

func_show_eval "$link_command" 'exit $?'

8975

8976

if test -n "$postlink_cmds"; then

8977

func_to_tool_file "$output"

8978

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8979

func_execute_cmds "$postlink_cmds" 'exit $?'

8980

fi

8981

7767

8982

exit $EXIT_SUCCESS

7768

8983

fi

7769

8984

7778

8993

if test "$fast_install" != no; then

7779

8994

link_command="$finalize_var$compile_command$finalize_rpath"

7780

8995

if test "$fast_install" = yes; then

7781

relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`

8996

relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

7782

8997

else

7783

8998

# fast_install is set to needless

7784

8999

relink_command=

7790

9005

fi

7791

9006

7792

9007

# Replace the output file specification.

7793

link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

9008

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

7794

9009

7795

9010

# Delete the old output files.

7796

9011

$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

7797

9012

7798

9013

func_show_eval "$link_command" 'exit $?'

7799

9014

9015

if test -n "$postlink_cmds"; then

9016

func_to_tool_file "$output_objdir/$outputname"

9017

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

9018

func_execute_cmds "$postlink_cmds" 'exit $?'

9019

fi

9020

7800

9021

# Now create the wrapper script.

7801

9022

func_verbose "creating $output"

7802

9023

7814

9035

fi

7815

9036

done

7816

9037

relink_command="(cd `pwd`; $relink_command)"

7817

relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

7818

fi

7819

7820

# Quote $ECHO for shipping.

7821

if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then

7822

case $progpath in

7823

[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;

7824

*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;

7825

esac

7826

qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`

7827

else

7828

qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`

9038

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

7829

9039

fi

7830

9040

7831

9041

# Only actually do things if not in dry run mode.

7905

9115

else

7906

9116

oldobjs="$old_deplibs $non_pic_objects"

7907

9117

if test "$preload" = yes && test -f "$symfileobj"; then

7908

oldobjs="$oldobjs $symfileobj"

9118

func_append oldobjs " $symfileobj"

7909

9119

fi

7910

9120

fi

7911

9121

addlibs="$old_convenience"

7913

9123

7914

9124

if test -n "$addlibs"; then

7915

9125

gentop="$output_objdir/${outputname}x"

7916

generated="$generated $gentop"

9126

func_append generated " $gentop"

7917

9127

7918

9128

func_extract_archives $gentop $addlibs

7919

oldobjs="$oldobjs $func_extract_archives_result"

9129

func_append oldobjs " $func_extract_archives_result"

7920

9130

fi

7921

9131

7922

9132

# Do each command in the archive commands.

7927

9137

# Add any objects from preloaded convenience libraries

7928

9138

if test -n "$dlprefiles"; then

7929

9139

gentop="$output_objdir/${outputname}x"

7930

generated="$generated $gentop"

9140

func_append generated " $gentop"

7931

9141

7932

9142

func_extract_archives $gentop $dlprefiles

7933

oldobjs="$oldobjs $func_extract_archives_result"

9143

func_append oldobjs " $func_extract_archives_result"

7934

9144

fi

7935

9145

7936

9146

# POSIX demands no paths to be encoded in archives. We have

7946

9156

done | sort | sort -uc >/dev/null 2>&1); then

7947

9157

:

7948

9158

else

7949

$ECHO "copying selected object files to avoid basename conflicts..."

9159

echo "copying selected object files to avoid basename conflicts..."

7950

9160

gentop="$output_objdir/${outputname}x"

7951

generated="$generated $gentop"

9161

func_append generated " $gentop"

7952

9162

func_mkdir_p "$gentop"

7953

9163

save_oldobjs=$oldobjs

7954

9164

oldobjs=

7972

9182

esac

7973

9183

done

7974

9184

func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

7975

oldobjs="$oldobjs $gentop/$newobj"

9185

func_append oldobjs " $gentop/$newobj"

7976

9186

;;

7977

*) oldobjs="$oldobjs $obj" ;;

9187

*) func_append oldobjs " $obj" ;;

7978

9188

esac

7979

9189

done

7980

9190

fi

9191

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

9192

tool_oldlib=$func_to_tool_file_result

7981

9193

eval cmds=\"$old_archive_cmds\"

7982

9194

7983

9195

func_len " $cmds"

7984

9196

len=$func_len_result

7985

9197

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

7986

9198

cmds=$old_archive_cmds

9199

elif test -n "$archiver_list_spec"; then

9200

func_verbose "using command file archive linking..."

9201

for obj in $oldobjs

9202

do

9203

func_to_tool_file "$obj"

9204

$ECHO "$func_to_tool_file_result"

9205

done > $output_objdir/$libname.libcmd

9206

func_to_tool_file "$output_objdir/$libname.libcmd"

9207

oldobjs=" $archiver_list_spec$func_to_tool_file_result"

9208

cmds=$old_archive_cmds

7987

9209

else

7988

9210

# the command line is too long to link in one step, link in parts

7989

9211

func_verbose "using piecewise archive linking..."

8057

9279

done

8058

9280

# Quote the link command for shipping.

8059

9281

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

8060

relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

9282

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

8061

9283

if test "$hardcode_automatic" = yes ; then

8062

9284

relink_command=

8063

9285

fi

8077

9299

*.la)

8078

9300

func_basename "$deplib"

8079

9301

name="$func_basename_result"

8080

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

9302

func_resolve_sysroot "$deplib"

9303

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

8081

9304

test -z "$libdir" && \

8082

9305

func_fatal_error "\`$deplib' is not a valid libtool archive"

8083

newdependency_libs="$newdependency_libs $libdir/$name"

8084

;;

8085

*) newdependency_libs="$newdependency_libs $deplib" ;;

9306

func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"

9307

;;

9308

-L*)

9309

func_stripname -L '' "$deplib"

9310

func_replace_sysroot "$func_stripname_result"

9311

func_append newdependency_libs " -L$func_replace_sysroot_result"

9312

;;

9313

-R*)

9314

func_stripname -R '' "$deplib"

9315

func_replace_sysroot "$func_stripname_result"

9316

func_append newdependency_libs " -R$func_replace_sysroot_result"

9317

;;

9318

*) func_append newdependency_libs " $deplib" ;;

8086

9319

esac

8087

9320

done

8088

9321

dependency_libs="$newdependency_libs"

8096

9329

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

8097

9330

test -z "$libdir" && \

8098

9331

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

8099

newdlfiles="$newdlfiles $libdir/$name"

9332

func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"

8100

9333

;;

8101

*) newdlfiles="$newdlfiles $lib" ;;

9334

*) func_append newdlfiles " $lib" ;;

8102

9335

esac

8103

9336

done

8104

9337

dlfiles="$newdlfiles"

8115

9348

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

8116

9349

test -z "$libdir" && \

8117

9350

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

8118

newdlprefiles="$newdlprefiles $libdir/$name"

9351

func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"

8119

9352

;;

8120

9353

esac

8121

9354

done

8127

9360

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

8128

9361

*) abs=`pwd`"/$lib" ;;

8129

9362

esac

8130

newdlfiles="$newdlfiles $abs"

9363

func_append newdlfiles " $abs"

8131

9364

done

8132

9365

dlfiles="$newdlfiles"

8133

9366

newdlprefiles=

8136

9369

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

8137

9370

*) abs=`pwd`"/$lib" ;;

8138

9371

esac

8139

newdlprefiles="$newdlprefiles $abs"

9372

func_append newdlprefiles " $abs"

8140

9373

done

8141

9374

dlprefiles="$newdlprefiles"

8142

9375

fi

8143

9376

$RM $output

8144

9377

# place dlname in correct position for cygwin

9378

# In fact, it would be nice if we could use this code for all target

9379

# systems that can't hard-code library paths into their executables

9380

# and that have no shared library path variable independent of PATH,

9381

# but it turns out we can't easily determine that from inspecting

9382

# libtool variables, so we have to hard-code the OSs to which it

9383

# applies here; at the moment, that means platforms that use the PE

9384

# object format with DLL files. See the long comment at the top of

9385

# tests/bindir.at for full details.

8145

9386

tdlname=$dlname

8146

9387

case $host,$output,$installed,$module,$dlname in

8147

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;

9388

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9389

# If a -bindir argument was supplied, place the dll there.

9390

if test "x$bindir" != x ;

9391

then

9392

func_relative_path "$install_libdir" "$bindir"

9393

tdlname=$func_relative_path_result$dlname

9394

else

9395

# Otherwise fall back on heuristic.

9396

tdlname=../bin/$dlname

9397

fi

9398

;;

8148

9399

esac

8149

9400

$ECHO > $output "\

8150

9401

# $outputname - a libtool library file

8203

9454

exit $EXIT_SUCCESS

8204

9455

}

8205

9456

8206

{ test "$mode" = link || test "$mode" = relink; } &&

9457

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&

8207

9458

func_mode_link ${1+"$@"}

8208

9459

8209

9460

8223

9474

for arg

8224

9475

do

8225

9476

case $arg in

8226

-f) RM="$RM $arg"; rmforce=yes ;;

8227

-*) RM="$RM $arg" ;;

8228

*) files="$files $arg" ;;

9477

-f) func_append RM " $arg"; rmforce=yes ;;

9478

-*) func_append RM " $arg" ;;

9479

*) func_append files " $arg" ;;

8229

9480

esac

8230

9481

done

8231

9482

8234

9485

8235

9486

rmdirs=

8236

9487

8237

origobjdir="$objdir"

8238

9488

for file in $files; do

8239

9489

func_dirname "$file" "" "."

8240

9490

dir="$func_dirname_result"

8241

9491

if test "X$dir" = X.; then

8242

objdir="$origobjdir"

9492

odir="$objdir"

8243

9493

else

8244

objdir="$dir/$origobjdir"

9494

odir="$dir/$objdir"

8245

9495

fi

8246

9496

func_basename "$file"

8247

9497

name="$func_basename_result"

8248

test "$mode" = uninstall && objdir="$dir"

9498

test "$opt_mode" = uninstall && odir="$dir"

8249

9499

8250

# Remember objdir for removal later, being careful to avoid duplicates

8251

if test "$mode" = clean; then

9500

# Remember odir for removal later, being careful to avoid duplicates

9501

if test "$opt_mode" = clean; then

8252

9502

case " $rmdirs " in

8253

*" $objdir "*) ;;

8254

*) rmdirs="$rmdirs $objdir" ;;

9503

*" $odir "*) ;;

9504

*) func_append rmdirs " $odir" ;;

8255

9505

esac

8256

9506

fi

8257

9507

8277

9527

8278

9528

# Delete the libtool libraries and symlinks.

8279

9529

for n in $library_names; do

8280

rmfiles="$rmfiles $objdir/$n"

9530

func_append rmfiles " $odir/$n"

8281

9531

done

8282

test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

9532

test -n "$old_library" && func_append rmfiles " $odir/$old_library"

8283

9533

8284

case "$mode" in

9534

case "$opt_mode" in

8285

9535

clean)

8286

case " $library_names " in

8287

# " " in the beginning catches empty $dlname

9536

case " $library_names " in

8288

9537

*" $dlname "*) ;;

8289

*) rmfiles="$rmfiles $objdir/$dlname" ;;

9538

*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;

8290

9539

esac

8291

test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

9540

test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"

8292

9541

;;

8293

9542

uninstall)

8294

9543

if test -n "$library_names"; then

8316

9565

# Add PIC object to the list of files to remove.

8317

9566

if test -n "$pic_object" &&

8318

9567

test "$pic_object" != none; then

8319

rmfiles="$rmfiles $dir/$pic_object"

9568

func_append rmfiles " $dir/$pic_object"

8320

9569

fi

8321

9570

8322

9571

# Add non-PIC object to the list of files to remove.

8323

9572

if test -n "$non_pic_object" &&

8324

9573

test "$non_pic_object" != none; then

8325

rmfiles="$rmfiles $dir/$non_pic_object"

9574

func_append rmfiles " $dir/$non_pic_object"

8326

9575

fi

8327

9576

fi

8328

9577

;;

8329

9578

8330

9579

*)

8331

if test "$mode" = clean ; then

9580

if test "$opt_mode" = clean ; then

8332

9581

noexename=$name

8333

9582

case $file in

8334

9583

*.exe)

8338

9587

noexename=$func_stripname_result

8339

9588

# $file with .exe has already been added to rmfiles,

8340

9589

# add $file without .exe

8341

rmfiles="$rmfiles $file"

9590

func_append rmfiles " $file"

8342

9591

;;

8343

9592

esac

8344

9593

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

8347

9596

func_ltwrapper_scriptname "$file"

8348

9597

relink_command=

8349

9598

func_source $func_ltwrapper_scriptname_result

8350

rmfiles="$rmfiles $func_ltwrapper_scriptname_result"

9599

func_append rmfiles " $func_ltwrapper_scriptname_result"

8351

9600

else

8352

9601

relink_command=

8353

9602

func_source $dir/$noexename

8355

9604

8356

9605

# note $name still contains .exe if it was in $file originally

8357

9606

# as does the version of $file that was added into $rmfiles

8358

rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

9607

func_append rmfiles " $odir/$name $odir/${name}S.${objext}"

8359

9608

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

8360

rmfiles="$rmfiles $objdir/lt-$name"

9609

func_append rmfiles " $odir/lt-$name"

8361

9610

fi

8362

9611

if test "X$noexename" != "X$name" ; then

8363

rmfiles="$rmfiles $objdir/lt-${noexename}.c"

9612

func_append rmfiles " $odir/lt-${noexename}.c"

8364

9613

fi

8365

9614

fi

8366

9615

fi

8368

9617

esac

8369

9618

func_show_eval "$RM $rmfiles" 'exit_status=1'

8370

9619

done

8371

objdir="$origobjdir"

8372

9620

8373

9621

# Try to remove the ${objdir}s in the directories where we deleted files

8374

9622

for dir in $rmdirs; do

8380

9628

exit $exit_status

8381

9629

}

8382

9630

8383

{ test "$mode" = uninstall || test "$mode" = clean; } &&

9631

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&

8384

9632

func_mode_uninstall ${1+"$@"}

8385

9633

8386

test -z "$mode" && {

9634

test -z "$opt_mode" && {

8387

9635

help="$generic_help"

8388

9636

func_fatal_help "you must specify a MODE"

8389

9637

}

8390

9638

8391

9639

test -z "$exec_cmd" && \

8392

func_fatal_help "invalid operation mode \`$mode'"

9640

func_fatal_help "invalid operation mode \`$opt_mode'"

8393

9641

8394

9642

if test -n "$exec_cmd"; then

8395

9643

eval exec "$exec_cmd"