~ubuntu-branches/ubuntu/oneiric/bluez/oneiric : revision 65

1

# Generated from ltmain.m4sh.

1

2

# libtool (GNU libtool) 2.4

3

# ltmain.sh (GNU libtool) 2.2.6b

3

4

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

4

5

6

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

6

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

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

43

# print informational messages (default)

44

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

45

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

46

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

47

# --version print version information

48

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

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

49

46

#

50

47

# MODE must be one of the following:

51

48

#

52

# clean remove files from the build directory

53

# compile compile a source file into a libtool object

54

# execute automatically set library path, then run a program

55

# finish complete the installation of libtool libraries

56

# install install libraries or executables

57

# link create a library or an executable

58

# uninstall remove libraries from an installed directory

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

59

56

#

60

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

61

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

57

# MODE-ARGS vary depending on the MODE.

62

58

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

63

59

#

64

60

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

65

61

# include the following information:

66

62

#

67

# host-triplet: $host

68

# shell: $SHELL

69

# compiler: $LTCC

70

# compiler flags: $LTCFLAGS

71

# linker: $LD (gnu? $with_gnu_ld)

72

# $progname: (GNU libtool) 2.4 Debian-2.4-2ubuntu1

73

# automake: $automake_version

74

# autoconf: $autoconf_version

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

69

# automake: $automake_version

70

# autoconf: $autoconf_version

75

71

#

76

72

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

77

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

78

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

79

73

80

PROGRAM=libtool

74

PROGRAM=ltmain.sh

81

75

PACKAGE=libtool

82

VERSION="2.4 Debian-2.4-2ubuntu1"

76

VERSION=2.2.6b

83

77

TIMESTAMP=""

84

package_revision=1.3293

78

package_revision=1.3017

85

79

86

80

# Be Bourne compatible

87

81

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

97

91

BIN_SH=xpg4; export BIN_SH # for Tru64

98

92

DUALCASE=1; export DUALCASE # for MKS sh

99

93

100

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

101

func_fallback_echo ()

102

{

103

eval 'cat <<_LTECHO_EOF

104

$1

105

_LTECHO_EOF'

106

}

107

108

94

# 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).

109

98

lt_user_locale=

110

99

lt_safe_locale=

111

100

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

118

107

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

119

108

fi"

120

109

done

121

LC_ALL=C

122

LANGUAGE=C

123

export LANGUAGE LC_ALL

124

110

125

111

$lt_unset CDPATH

126

112

127

113

128

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

129

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

130

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

131

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

132

# function.

133

progpath="$0"

134

114

135

115

136

116

137

117

: ${CP="cp -f"}

138

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

118

: ${ECHO="echo"}

139

119

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

140

120

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

141

121

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

164

144

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

165

145

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

166

146

167

# func_dirname file append nondir_replacement

168

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

169

# otherwise set result to NONDIR_REPLACEMENT.

170

func_dirname ()

171

{

172

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

173

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

174

func_dirname_result="${3}"

175

else

176

func_dirname_result="$func_dirname_result${2}"

177

fi

178

} # func_dirname may be replaced by extended shell implementation

179

180

181

# func_basename file

182

func_basename ()

183

{

184

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

185

} # func_basename may be replaced by extended shell implementation

186

187

188

147

# func_dirname_and_basename file append nondir_replacement

189

148

# perform func_basename and func_dirname in a single function

190

149

# call:

199

158

# those functions but instead duplicate the functionality here.

200

159

func_dirname_and_basename ()

201

160

{

202

# Extract subdirectory from the argument.

203

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

204

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

205

func_dirname_result="${3}"

206

else

207

func_dirname_result="$func_dirname_result${2}"

208

fi

209

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

210

} # func_dirname_and_basename may be replaced by extended shell implementation

211

212

213

# func_stripname prefix suffix name

214

# strip PREFIX and SUFFIX off of NAME.

215

# PREFIX and SUFFIX must not contain globbing or regex special

216

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

217

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

218

# func_strip_suffix prefix name

219

func_stripname ()

220

{

221

case ${2} in

222

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

223

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

224

esac

225

} # func_stripname may be replaced by extended shell implementation

226

227

228

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

229

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

230

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

231

removedotparts=':dotsl

232

s@/\./@/@g

233

t dotsl

234

s,/\.$,/,'

235

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

236

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

237

238

# func_normal_abspath PATH

239

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

240

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

241

# it an absolute path.

242

# value returned in "$func_normal_abspath_result"

243

func_normal_abspath ()

244

{

245

# Start from root dir and reassemble the path.

246

func_normal_abspath_result=

247

func_normal_abspath_tpath=$1

248

func_normal_abspath_altnamespace=

249

case $func_normal_abspath_tpath in

250

"")

251

# Empty path, that just means $cwd.

252

func_stripname '' '/' "`pwd`"

253

func_normal_abspath_result=$func_stripname_result

254

return

255

;;

256

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

257

# two leading slashes without using negated character classes;

258

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

259

///*)

260

# Unusual form of absolute path, do nothing.

261

;;

262

//*)

263

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

264

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

265

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

266

func_normal_abspath_altnamespace=/

267

;;

268

/*)

269

# Absolute path, do nothing.

270

;;

271

*)

272

# Relative path, prepend $cwd.

273

func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

274

;;

275

esac

276

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

277

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

278

# there is one (and only one) here.

279

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

280

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

281

while :; do

282

# Processed it all yet?

283

if test "$func_normal_abspath_tpath" = / ; then

284

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

285

if test -z "$func_normal_abspath_result" ; then

286

func_normal_abspath_result=/

287

fi

288

break

289

fi

290

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

291

-e "$pathcar"`

292

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

293

-e "$pathcdr"`

294

# Figure out what to do with it

295

case $func_normal_abspath_tcomponent in

296

"")

297

# Trailing empty path component, ignore it.

298

;;

299

..)

300

# Parent dir; strip last assembled component from result.

301

func_dirname "$func_normal_abspath_result"

302

func_normal_abspath_result=$func_dirname_result

303

;;

304

*)

305

# Actual path component, append it.

306

func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

307

;;

308

esac

309

done

310

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

311

func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

312

}

313

314

# func_relative_path SRCDIR DSTDIR

315

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

316

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

317

# without needing to append a separator.

318

# value returned in "$func_relative_path_result"

319

func_relative_path ()

320

{

321

func_relative_path_result=

322

func_normal_abspath "$1"

323

func_relative_path_tlibdir=$func_normal_abspath_result

324

func_normal_abspath "$2"

325

func_relative_path_tbindir=$func_normal_abspath_result

326

327

# Ascend the tree starting from libdir

328

while :; do

329

# check if we have found a prefix of bindir

330

case $func_relative_path_tbindir in

331

$func_relative_path_tlibdir)

332

# found an exact match

333

func_relative_path_tcancelled=

334

break

335

;;

336

$func_relative_path_tlibdir*)

337

# found a matching prefix

338

func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

339

func_relative_path_tcancelled=$func_stripname_result

340

if test -z "$func_relative_path_result"; then

341

func_relative_path_result=.

342

fi

343

break

344

;;

345

*)

346

func_dirname $func_relative_path_tlibdir

347

func_relative_path_tlibdir=${func_dirname_result}

348

if test "x$func_relative_path_tlibdir" = x ; then

349

# Have to descend all the way to the root!

350

func_relative_path_result=../$func_relative_path_result

351

func_relative_path_tcancelled=$func_relative_path_tbindir

352

break

353

fi

354

func_relative_path_result=../$func_relative_path_result

355

;;

356

esac

357

done

358

359

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

360

func_stripname '' '/' "$func_relative_path_result"

361

func_relative_path_result=$func_stripname_result

362

func_stripname '/' '/' "$func_relative_path_tcancelled"

363

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

364

func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

365

fi

366

367

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

368

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

369

# file name can be directly appended.

370

if test ! -z "$func_relative_path_result"; then

371

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

372

func_relative_path_result=$func_stripname_result

373

fi

374

}

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"

375

179

376

180

# 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:

377

183

func_dirname_and_basename "$progpath"

378

184

progname=$func_basename_result

185

case $progname in

186

-*) progname=./$progname ;;

187

esac

379

188

380

189

# Make sure we have an absolute path for reexecution:

381

190

case $progpath in

406

215

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

407

216

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

408

217

409

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

410

# string literally.

411

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

412

413

# Sed substitution that converts a w32 file name or path

414

# which contains forward slashes, into one that contains

415

# (escaped) backslashes. A very naive implementation.

416

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

417

418

218

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

419

219

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

420

220

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

443

243

# name if it has been set yet.

444

244

func_echo ()

445

245

{

446

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

246

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

447

247

}

448

248

449

249

# func_verbose arg...

458

258

:

459

259

}

460

260

461

# func_echo_all arg...

462

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

463

func_echo_all ()

464

{

465

$ECHO "$*"

466

}

467

468

261

# func_error arg...

469

262

# Echo program name prefixed message to standard error.

470

263

func_error ()

471

264

{

472

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

265

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

473

266

}

474

267

475

268

# func_warning arg...

476

269

# Echo program name prefixed warning message to standard error.

477

270

func_warning ()

478

271

{

479

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

272

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

480

273

481

274

# bash bug again:

482

275

:

533

326

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

534

327

535

328

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

536

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

329

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

537

330

done

538

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

331

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

539

332

540

333

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

541

334

for my_dir in $my_dir_list; do

585

378

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

586

379

fi

587

380

588

$ECHO "$my_tmpdir"

381

$ECHO "X$my_tmpdir" | $Xsed

589

382

}

590

383

591

384

599

392

{

600

393

case $1 in

601

394

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

602

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

395

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

603

396

*)

604

397

func_quote_for_eval_unquoted_result="$1" ;;

605

398

esac

626

419

{

627

420

case $1 in

628

421

*[\\\`\"]*)

629

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

422

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

630

423

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

631

424

*)

632

425

my_arg="$1" ;;

695

488

fi

696

489

}

697

490

698

# func_tr_sh

699

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

700

# Result is stored in $func_tr_sh_result. All characters

701

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

702

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

703

func_tr_sh ()

704

{

705

case $1 in

706

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

707

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

708

;;

709

* )

710

func_tr_sh_result=$1

711

;;

712

esac

713

}

491

492

714

493

715

494

716

495

# func_version

717

496

# Echo version message to standard output and exit.

718

497

func_version ()

719

498

{

720

$opt_debug

721

722

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

723

:more

724

/\./!{

725

N

726

s/\n# / /

727

b more

728

}

729

:go

730

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

499

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

731

500

s/^# //

732

501

s/^# *$//

733

502

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

740

509

# Echo short help message to standard output and exit.

741

510

func_usage ()

742

511

{

743

$opt_debug

744

745

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

512

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

746

513

s/^# //

747

514

s/^# *$//

748

515

s/\$progname/'$progname'/

749

516

p

750

517

}' < "$progpath"

751

echo

518

$ECHO

752

519

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

753

520

exit $?

754

521

}

755

522

756

# func_help [NOEXIT]

757

# Echo long help message to standard output and exit,

758

# unless 'noexit' is passed as argument.

523

# func_help

524

# Echo long help message to standard output and exit.

759

525

func_help ()

760

526

{

761

$opt_debug

762

763

527

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

764

:print

765

528

s/^# //

766

529

s/^# *$//

767

530

s*\$progname*'$progname'*

774

537

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

775

538

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

776

539

p

777

d

778

}

779

/^# .* home page:/b print

780

/^# General help using/b print

781

' < "$progpath"

782

ret=$?

783

if test -z "$1"; then

784

exit $ret

785

fi

540

}' < "$progpath"

541

exit $?

786

542

}

787

543

788

544

# func_missing_arg argname

790

546

# exit_cmd.

791

547

func_missing_arg ()

792

548

{

793

$opt_debug

794

795

func_error "missing argument for $1."

549

func_error "missing argument for $1"

796

550

exit_cmd=exit

797

551

}

798

552

799

800

# func_split_short_opt shortopt

801

# Set func_split_short_opt_name and func_split_short_opt_arg shell

802

# variables after splitting SHORTOPT after the 2nd character.

803

func_split_short_opt ()

804

{

805

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

806

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

807

808

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

809

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

810

} # func_split_short_opt may be replaced by extended shell implementation

811

812

813

# func_split_long_opt longopt

814

# Set func_split_long_opt_name and func_split_long_opt_arg shell

815

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

816

func_split_long_opt ()

817

{

818

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

819

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

820

821

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

822

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

823

} # func_split_long_opt may be replaced by extended shell implementation

824

825

553

exit_cmd=:

826

554

827

555

828

556

829

557

830

558

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

831

583

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

832

584

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

833

585

834

586

# Global variables.

587

# $mode is unset

835

588

nonopt=

589

execute_dlfiles=

836

590

preserve_args=

837

591

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

838

592

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

839

593

extracted_archives=

840

594

extracted_serial=0

841

595

596

opt_dry_run=false

597

opt_duplicate_deps=false

598

opt_silent=false

599

opt_debug=:

600

842

601

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

843

602

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

844

603

# left over by shells.

845

604

exec_cmd=

846

605

847

# func_append var value

848

# Append VALUE to the end of shell variable VAR.

849

func_append ()

850

{

851

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

852

} # func_append may be replaced by extended shell implementation

853

854

# func_append_quoted var value

855

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

856

# by a space.

857

func_append_quoted ()

858

{

859

func_quote_for_eval "${2}"

860

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

861

} # func_append_quoted may be replaced by extended shell implementation

862

863

864

# func_arith arithmetic-term...

865

func_arith ()

866

{

867

func_arith_result=`expr "${@}"`

868

} # func_arith may be replaced by extended shell implementation

869

870

871

# func_len string

872

# STRING may not start with a hyphen.

873

func_len ()

874

{

875

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

876

} # func_len may be replaced by extended shell implementation

877

878

879

# func_lo2o object

880

func_lo2o ()

881

{

882

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

883

} # func_lo2o may be replaced by extended shell implementation

884

885

886

# func_xform libobj-or-source

887

func_xform ()

888

{

889

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

890

} # func_xform may be replaced by extended shell implementation

891

892

893

606

# func_fatal_configuration arg...

894

607

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

895

608

# a configuration failure hint, and exit.

923

636

# Display the features supported by this script.

924

637

func_features ()

925

638

{

926

echo "host: $host"

639

$ECHO "host: $host"

927

640

if test "$build_libtool_libs" = yes; then

928

echo "enable shared libraries"

641

$ECHO "enable shared libraries"

929

642

else

930

echo "disable shared libraries"

643

$ECHO "disable shared libraries"

931

644

fi

932

645

if test "$build_old_libs" = yes; then

933

echo "enable static libraries"

646

$ECHO "enable static libraries"

934

647

else

935

echo "disable static libraries"

648

$ECHO "disable static libraries"

936

649

fi

937

650

938

651

exit $?

979

692

esac

980

693

}

981

694

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

982

822

# func_check_version_match

983

823

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

984

824

# release of libtool.

1015

855

}

1016

856

1017

857

1018

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

1019

case $1 in

1020

clean|clea|cle|cl)

1021

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

1022

;;

1023

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

1024

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

1025

;;

1026

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

1027

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

1028

;;

1029

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

1030

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

1031

;;

1032

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

1033

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

1034

;;

1035

link|lin|li|l)

1036

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

1037

;;

1038

1039

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

1040

;;

1041

esac

1042

1043

1044

1045

# Option defaults:

1046

opt_debug=:

1047

opt_dry_run=false

1048

opt_config=false

1049

opt_preserve_dup_deps=false

1050

opt_features=false

1051

opt_finish=false

1052

opt_help=false

1053

opt_help_all=false

1054

opt_silent=:

1055

opt_verbose=:

1056

opt_silent=false

1057

opt_verbose=false

1058

1059

1060

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

1061

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

1062

{

1063

# this just eases exit handling

1064

while test $# -gt 0; do

1065

opt="$1"

1066

shift

1067

case $opt in

1068

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

1069

func_echo "enabling shell trace mode"

1070

$opt_debug

1071

;;

1072

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

1073

opt_dry_run=:

1074

;;

1075

--config)

1076

opt_config=:

1077

func_config

1078

;;

1079

--dlopen|-dlopen)

1080

optarg="$1"

1081

opt_dlopen="${opt_dlopen+$opt_dlopen

1082

}$optarg"

1083

shift

1084

;;

1085

--preserve-dup-deps)

1086

opt_preserve_dup_deps=:

1087

;;

1088

--features)

1089

opt_features=:

1090

func_features

1091

;;

1092

--finish)

1093

opt_finish=:

1094

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

1095

;;

1096

--help)

1097

opt_help=:

1098

;;

1099

--help-all)

1100

opt_help_all=:

1101

opt_help=': help-all'

1102

;;

1103

--mode)

1104

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

1105

optarg="$1"

1106

opt_mode="$optarg"

1107

case $optarg in

1108

# Valid mode arguments:

1109

1110

1111

# Catch anything else as an error

1112

*) func_error "invalid argument for $opt"

1113

exit_cmd=exit

1114

break

1115

;;

1116

esac

1117

shift

1118

;;

1119

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

1120

opt_silent=false

1121

func_append preserve_args " $opt"

1122

;;

1123

--no-verbose)

1124

opt_verbose=false

1125

func_append preserve_args " $opt"

1126

;;

1127

--silent|--quiet)

1128

opt_silent=:

1129

func_append preserve_args " $opt"

1130

opt_verbose=false

1131

;;

1132

--verbose|-v)

1133

opt_verbose=:

1134

func_append preserve_args " $opt"

1135

opt_silent=false

1136

;;

1137

--tag)

1138

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

1139

optarg="$1"

1140

opt_tag="$optarg"

1141

func_append preserve_args " $opt $optarg"

1142

func_enable_tag "$optarg"

1143

shift

1144

;;

1145

1146

-\?|-h) func_usage ;;

1147

--help) func_help ;;

1148

--version) func_version ;;

1149

1150

# Separate optargs to long options:

1151

--*=*)

1152

func_split_long_opt "$opt"

1153

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

1154

shift

1155

;;

1156

1157

# Separate non-argument short options:

1158

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

1159

func_split_short_opt "$opt"

1160

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

1161

shift

1162

;;

1163

1164

--) break ;;

1165

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

1166

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

1167

esac

1168

done

1169

1170

# Validate options:

1171

1172

# save first non-option argument

1173

if test "$#" -gt 0; then

1174

nonopt="$opt"

1175

shift

1176

fi

1177

1178

# preserve --debug

1179

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

1180

1181

case $host in

1182

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

1183

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

1184

opt_duplicate_compiler_generated_deps=:

1185

;;

1186

*)

1187

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

1188

;;

1189

esac

1190

1191

$opt_help || {

1192

# Sanity checks first:

1193

func_check_version_match

1194

1195

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

1196

func_fatal_configuration "not configured to build any kind of library"

1197

fi

1198

1199

# Darwin sucks

1200

eval std_shrext=\"$shrext_cmds\"

1201

1202

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

1203

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

1204

func_error "unrecognized option \`-dlopen'"

1205

$ECHO "$help" 1>&2

1206

exit $EXIT_FAILURE

1207

fi

1208

1209

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

1210

generic_help="$help"

1211

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

1212

}

1213

1214

1215

# Bail if the options were screwed

1216

$exit_cmd $EXIT_FAILURE

1217

}

1218

1219

1220

1221

1222

858

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

1223

859

## Main. ##

1224

860

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

1225

861

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

1226

890

# func_lalib_p file

1227

891

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

1228

892

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

1286

950

# temporary ltwrapper_script.

1287

951

func_ltwrapper_scriptname ()

1288

952

{

1289

func_dirname_and_basename "$1" "" "."

1290

func_stripname '' '.exe' "$func_basename_result"

1291

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

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

1292

959

}

1293

960

1294

961

# func_ltwrapper_p file

1334

1001

}

1335

1002

1336

1003

1337

# func_resolve_sysroot PATH

1338

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

1339

# func_resolve_sysroot_result

1340

func_resolve_sysroot ()

1341

{

1342

func_resolve_sysroot_result=$1

1343

case $func_resolve_sysroot_result in

1344

=*)

1345

func_stripname '=' '' "$func_resolve_sysroot_result"

1346

func_resolve_sysroot_result=$lt_sysroot$func_stripname_result

1347

;;

1348

esac

1349

}

1350

1351

# func_replace_sysroot PATH

1352

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

1353

# store the result into func_replace_sysroot_result.

1354

func_replace_sysroot ()

1355

{

1356

case "$lt_sysroot:$1" in

1357

?*:"$lt_sysroot"*)

1358

func_stripname "$lt_sysroot" '' "$1"

1359

func_replace_sysroot_result="=$func_stripname_result"

1360

;;

1361

*)

1362

# Including no sysroot.

1363

func_replace_sysroot_result=$1

1364

;;

1365

esac

1366

}

1367

1368

1004

# func_infer_tag arg

1369

1005

# Infer tagged configuration to use if any are available and

1370

1006

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

1377

1013

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

1378

1014

CC_quoted=

1379

1015

for arg in $CC; do

1380

func_append_quoted CC_quoted "$arg"

1016

func_quote_for_eval "$arg"

1017

CC_quoted="$CC_quoted $func_quote_for_eval_result"

1381

1018

done

1382

CC_expanded=`func_echo_all $CC`

1383

CC_quoted_expanded=`func_echo_all $CC_quoted`

1384

1019

case $@ in

1385

1020

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

1386

1021

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

1387

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

1388

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

1022

1389

1023

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

1390

1024

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

1391

1025

*)

1396

1030

CC_quoted=

1397

1031

for arg in $CC; do

1398

1032

# Double-quote args containing other shell metacharacters.

1399

func_append_quoted CC_quoted "$arg"

1033

func_quote_for_eval "$arg"

1034

CC_quoted="$CC_quoted $func_quote_for_eval_result"

1400

1035

done

1401

CC_expanded=`func_echo_all $CC`

1402

CC_quoted_expanded=`func_echo_all $CC_quoted`

1403

1036

case "$@ " in

1404

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

1405

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

1037

1406

1038

# The compiler in the base compile command matches

1407

1039

# the one in the tagged configuration.

1408

1040

# Assume this is the tagged configuration we want.

1465

1097

}

1466

1098

}

1467

1099

1468

1469

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

1470

# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #

1471

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

1472

1473

# func_convert_core_file_wine_to_w32 ARG

1474

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

1475

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

1476

# correctly configured wine environment available, with the winepath program

1477

# in $build's $PATH.

1478

#

1479

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

1480

# Result is available in $func_convert_core_file_wine_to_w32_result, and will

1481

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

1482

func_convert_core_file_wine_to_w32 ()

1483

{

1484

$opt_debug

1485

func_convert_core_file_wine_to_w32_result="$1"

1486

if test -n "$1"; then

1487

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

1488

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

1489

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

1490

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

1491

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

1492

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

1493

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

1494

func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |

1495

$SED -e "$lt_sed_naive_backslashify"`

1496

else

1497

func_convert_core_file_wine_to_w32_result=

1498

fi

1499

fi

1500

}

1501

# end: func_convert_core_file_wine_to_w32

1502

1503

1504

# func_convert_core_path_wine_to_w32 ARG

1505

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

1506

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

1507

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

1508

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

1509

#

1510

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

1511

# Result is available in $func_convert_core_path_wine_to_w32_result.

1512

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

1513

# are convertible, then the result may be empty.

1514

func_convert_core_path_wine_to_w32 ()

1515

{

1516

$opt_debug

1517

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

1518

func_convert_core_path_wine_to_w32_result=""

1519

if test -n "$1"; then

1520

oldIFS=$IFS

1521

IFS=:

1522

for func_convert_core_path_wine_to_w32_f in $1; do

1523

IFS=$oldIFS

1524

func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"

1525

if test -n "$func_convert_core_file_wine_to_w32_result" ; then

1526

if test -z "$func_convert_core_path_wine_to_w32_result"; then

1527

func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"

1528

else

1529

func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"

1530

fi

1531

fi

1532

done

1533

IFS=$oldIFS

1534

fi

1535

}

1536

# end: func_convert_core_path_wine_to_w32

1537

1538

1539

# func_cygpath ARGS...

1540

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

1541

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

1542

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

1543

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

1544

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

1545

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

1546

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

1547

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

1548

#

1549

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

1550

# be converted.

1551

#

1552

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

1553

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

1554

func_cygpath ()

1555

{

1556

$opt_debug

1557

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

1558

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

1559

if test "$?" -ne 0; then

1560

# on failure, ensure result is empty

1561

func_cygpath_result=

1562

fi

1563

else

1564

func_cygpath_result=

1565

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

1566

fi

1567

}

1568

#end: func_cygpath

1569

1570

1571

# func_convert_core_msys_to_w32 ARG

1572

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

1573

# result in func_convert_core_msys_to_w32_result.

1574

func_convert_core_msys_to_w32 ()

1575

{

1576

$opt_debug

1577

# awkward: cmd appends spaces to result

1578

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

1579

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

1580

}

1581

#end: func_convert_core_msys_to_w32

1582

1583

1584

# func_convert_file_check ARG1 ARG2

1585

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

1586

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

1587

# func_to_host_file_result to ARG1).

1588

func_convert_file_check ()

1589

{

1590

$opt_debug

1591

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

1592

func_error "Could not determine host file name corresponding to"

1593

func_error " \`$1'"

1594

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

1595

# Fallback:

1596

func_to_host_file_result="$1"

1597

fi

1598

}

1599

# end func_convert_file_check

1600

1601

1602

# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH

1603

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

1604

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

1605

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

1606

func_convert_path_check ()

1607

{

1608

$opt_debug

1609

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

1610

func_error "Could not determine the host path corresponding to"

1611

func_error " \`$3'"

1612

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

1613

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

1614

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

1615

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

1616

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

1617

func_to_host_path_result=`echo "$3" |

1618

$SED -e "$lt_replace_pathsep_chars"`

1619

else

1620

func_to_host_path_result="$3"

1621

fi

1622

fi

1623

}

1624

# end func_convert_path_check

1625

1626

1627

# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG

1628

# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT

1629

# and appending REPL if ORIG matches BACKPAT.

1630

func_convert_path_front_back_pathsep ()

1631

{

1632

$opt_debug

1633

case $4 in

1634

$1 ) func_to_host_path_result="$3$func_to_host_path_result"

1635

;;

1636

esac

1637

case $4 in

1638

$2 ) func_append func_to_host_path_result "$3"

1639

;;

1640

esac

1641

}

1642

# end func_convert_path_front_back_pathsep

1643

1644

1645

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

1646

# $build to $host FILE NAME CONVERSION FUNCTIONS #

1647

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

1648

# invoked via `$to_host_file_cmd ARG'

1649

#

1650

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

1651

# Result will be available in $func_to_host_file_result.

1652

1653

1654

# func_to_host_file ARG

1655

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

1656

# in func_to_host_file_result.

1657

func_to_host_file ()

1658

{

1659

$opt_debug

1660

$to_host_file_cmd "$1"

1661

}

1662

# end func_to_host_file

1663

1664

1665

# func_to_tool_file ARG LAZY

1666

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

1667

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

1668

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

1669

func_to_tool_file ()

1670

{

1671

$opt_debug

1672

case ,$2, in

1673

*,"$to_tool_file_cmd",*)

1674

func_to_tool_file_result=$1

1675

;;

1676

*)

1677

$to_tool_file_cmd "$1"

1678

func_to_tool_file_result=$func_to_host_file_result

1679

;;

1680

esac

1681

}

1682

# end func_to_tool_file

1683

1684

1685

# func_convert_file_noop ARG

1686

# Copy ARG to func_to_host_file_result.

1687

func_convert_file_noop ()

1688

{

1689

func_to_host_file_result="$1"

1690

}

1691

# end func_convert_file_noop

1692

1693

1694

# func_convert_file_msys_to_w32 ARG

1695

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

1696

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

1697

# func_to_host_file_result.

1698

func_convert_file_msys_to_w32 ()

1699

{

1700

$opt_debug

1701

func_to_host_file_result="$1"

1702

if test -n "$1"; then

1703

func_convert_core_msys_to_w32 "$1"

1704

func_to_host_file_result="$func_convert_core_msys_to_w32_result"

1705

fi

1706

func_convert_file_check "$1" "$func_to_host_file_result"

1707

}

1708

# end func_convert_file_msys_to_w32

1709

1710

1711

# func_convert_file_cygwin_to_w32 ARG

1712

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

1713

# func_to_host_file_result.

1714

func_convert_file_cygwin_to_w32 ()

1715

{

1716

$opt_debug

1717

func_to_host_file_result="$1"

1718

if test -n "$1"; then

1719

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

1720

# LT_CYGPATH in this case.

1721

func_to_host_file_result=`cygpath -m "$1"`

1722

fi

1723

func_convert_file_check "$1" "$func_to_host_file_result"

1724

}

1725

# end func_convert_file_cygwin_to_w32

1726

1727

1728

# func_convert_file_nix_to_w32 ARG

1729

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

1730

# and a working winepath. Returns result in func_to_host_file_result.

1731

func_convert_file_nix_to_w32 ()

1732

{

1733

$opt_debug

1734

func_to_host_file_result="$1"

1735

if test -n "$1"; then

1736

func_convert_core_file_wine_to_w32 "$1"

1737

func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

1738

fi

1739

func_convert_file_check "$1" "$func_to_host_file_result"

1740

}

1741

# end func_convert_file_nix_to_w32

1742

1743

1744

# func_convert_file_msys_to_cygwin ARG

1745

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

1746

# Returns result in func_to_host_file_result.

1747

func_convert_file_msys_to_cygwin ()

1748

{

1749

$opt_debug

1750

func_to_host_file_result="$1"

1751

if test -n "$1"; then

1752

func_convert_core_msys_to_w32 "$1"

1753

func_cygpath -u "$func_convert_core_msys_to_w32_result"

1754

func_to_host_file_result="$func_cygpath_result"

1755

fi

1756

func_convert_file_check "$1" "$func_to_host_file_result"

1757

}

1758

# end func_convert_file_msys_to_cygwin

1759

1760

1761

# func_convert_file_nix_to_cygwin ARG

1762

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

1763

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

1764

# in func_to_host_file_result.

1765

func_convert_file_nix_to_cygwin ()

1766

{

1767

$opt_debug

1768

func_to_host_file_result="$1"

1769

if test -n "$1"; then

1770

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

1771

func_convert_core_file_wine_to_w32 "$1"

1772

func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

1773

func_to_host_file_result="$func_cygpath_result"

1774

fi

1775

func_convert_file_check "$1" "$func_to_host_file_result"

1776

}

1777

# end func_convert_file_nix_to_cygwin

1778

1779

1780

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

1781

# $build to $host PATH CONVERSION FUNCTIONS #

1782

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

1783

# invoked via `$to_host_path_cmd ARG'

1784

#

1785

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

1786

# The result will be available in $func_to_host_path_result.

1787

#

1788

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

1789

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

1790

# converted to $host format) on output.

1791

#

1792

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

1793

# file name conversion function : func_convert_file_X_to_Y ()

1794

# path conversion function : func_convert_path_X_to_Y ()

1795

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

1796

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

1797

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

1798

# will break.

1799

1800

1801

# func_init_to_host_path_cmd

1802

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

1803

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

1804

to_host_path_cmd=

1805

func_init_to_host_path_cmd ()

1806

{

1807

$opt_debug

1808

if test -z "$to_host_path_cmd"; then

1809

func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

1810

to_host_path_cmd="func_convert_path_${func_stripname_result}"

1811

fi

1812

}

1813

1814

1815

# func_to_host_path ARG

1816

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

1817

# in func_to_host_path_result.

1818

func_to_host_path ()

1819

{

1820

$opt_debug

1821

func_init_to_host_path_cmd

1822

$to_host_path_cmd "$1"

1823

}

1824

# end func_to_host_path

1825

1826

1827

# func_convert_path_noop ARG

1828

# Copy ARG to func_to_host_path_result.

1829

func_convert_path_noop ()

1830

{

1831

func_to_host_path_result="$1"

1832

}

1833

# end func_convert_path_noop

1834

1835

1836

# func_convert_path_msys_to_w32 ARG

1837

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

1838

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

1839

# func_to_host_path_result.

1840

func_convert_path_msys_to_w32 ()

1841

{

1842

$opt_debug

1843

func_to_host_path_result="$1"

1844

if test -n "$1"; then

1845

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

1846

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

1847

# and winepath ignores them completely.

1848

func_stripname : : "$1"

1849

func_to_host_path_tmp1=$func_stripname_result

1850

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1851

func_to_host_path_result="$func_convert_core_msys_to_w32_result"

1852

func_convert_path_check : ";" \

1853

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1854

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

1855

fi

1856

}

1857

# end func_convert_path_msys_to_w32

1858

1859

1860

# func_convert_path_cygwin_to_w32 ARG

1861

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

1862

# func_to_host_file_result.

1863

func_convert_path_cygwin_to_w32 ()

1864

{

1865

$opt_debug

1866

func_to_host_path_result="$1"

1867

if test -n "$1"; then

1868

# See func_convert_path_msys_to_w32:

1869

func_stripname : : "$1"

1870

func_to_host_path_tmp1=$func_stripname_result

1871

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

1872

func_convert_path_check : ";" \

1873

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1874

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

1875

fi

1876

}

1877

# end func_convert_path_cygwin_to_w32

1878

1879

1880

# func_convert_path_nix_to_w32 ARG

1881

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

1882

# a working winepath. Returns result in func_to_host_file_result.

1883

func_convert_path_nix_to_w32 ()

1884

{

1885

$opt_debug

1886

func_to_host_path_result="$1"

1887

if test -n "$1"; then

1888

# See func_convert_path_msys_to_w32:

1889

func_stripname : : "$1"

1890

func_to_host_path_tmp1=$func_stripname_result

1891

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1892

func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

1893

func_convert_path_check : ";" \

1894

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1895

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

1896

fi

1897

}

1898

# end func_convert_path_nix_to_w32

1899

1900

1901

# func_convert_path_msys_to_cygwin ARG

1902

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

1903

# Returns result in func_to_host_file_result.

1904

func_convert_path_msys_to_cygwin ()

1905

{

1906

$opt_debug

1907

func_to_host_path_result="$1"

1908

if test -n "$1"; then

1909

# See func_convert_path_msys_to_w32:

1910

func_stripname : : "$1"

1911

func_to_host_path_tmp1=$func_stripname_result

1912

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

1913

func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

1914

func_to_host_path_result="$func_cygpath_result"

1915

func_convert_path_check : : \

1916

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1917

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

1918

fi

1919

}

1920

# end func_convert_path_msys_to_cygwin

1921

1922

1923

# func_convert_path_nix_to_cygwin ARG

1924

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

1925

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

1926

# func_to_host_file_result.

1927

func_convert_path_nix_to_cygwin ()

1928

{

1929

$opt_debug

1930

func_to_host_path_result="$1"

1931

if test -n "$1"; then

1932

# Remove leading and trailing path separator characters from

1933

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

1934

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

1935

func_stripname : : "$1"

1936

func_to_host_path_tmp1=$func_stripname_result

1937

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

1938

func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

1939

func_to_host_path_result="$func_cygpath_result"

1940

func_convert_path_check : : \

1941

"$func_to_host_path_tmp1" "$func_to_host_path_result"

1942

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

1943

fi

1944

}

1945

# end func_convert_path_nix_to_cygwin

1946

1947

1948

1100

# func_mode_compile arg...

1949

1101

func_mode_compile ()

1950

1102

{

1985

1137

;;

1986

1138

1987

1139

-pie | -fpie | -fPIE)

1988

func_append pie_flag " $arg"

1140

pie_flag="$pie_flag $arg"

1989

1141

continue

1990

1142

;;

1991

1143

1992

1144

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

1993

func_append later " $arg"

1145

later="$later $arg"

1994

1146

continue

1995

1147

;;

1996

1148

2011

1163

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

2012

1164

for arg in $args; do

2013

1165

IFS="$save_ifs"

2014

func_append_quoted lastarg "$arg"

1166

func_quote_for_eval "$arg"

1167

lastarg="$lastarg $func_quote_for_eval_result"

2015

1168

done

2016

1169

IFS="$save_ifs"

2017

1170

func_stripname ' ' '' "$lastarg"

2018

1171

lastarg=$func_stripname_result

2019

1172

2020

1173

# Add the arguments to base_compile.

2021

func_append base_compile " $lastarg"

1174

base_compile="$base_compile $lastarg"

2022

1175

continue

2023

1176

;;

2024

1177

2034

1187

esac # case $arg_mode

2035

1188

2036

1189

# Aesthetically quote the previous argument.

2037

func_append_quoted base_compile "$lastarg"

1190

func_quote_for_eval "$lastarg"

1191

base_compile="$base_compile $func_quote_for_eval_result"

2038

1192

done # for arg

2039

1193

2040

1194

case $arg_mode in

2059

1213

*.[cCFSifmso] | \

2060

1214

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

2061

1215

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

2062

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

1216

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

2063

1217

func_xform "$libobj"

2064

1218

libobj=$func_xform_result

2065

1219

;;

2134

1288

# Calculate the filename of the output object if compiler does

2135

1289

# not support -o with -c

2136

1290

if test "$compiler_c_o" = no; then

2137

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

1291

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

2138

1292

lockfile="$output_obj.lock"

2139

1293

else

2140

1294

output_obj=

2165

1319

$opt_dry_run || $RM $removelist

2166

1320

exit $EXIT_FAILURE

2167

1321

fi

2168

func_append removelist " $output_obj"

1322

removelist="$removelist $output_obj"

2169

1323

$ECHO "$srcfile" > "$lockfile"

2170

1324

fi

2171

1325

2172

1326

$opt_dry_run || $RM $removelist

2173

func_append removelist " $lockfile"

1327

removelist="$removelist $lockfile"

2174

1328

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

2175

1329

2176

func_to_tool_file "$srcfile" func_convert_file_msys_to_w32

2177

srcfile=$func_to_tool_file_result

1330

if test -n "$fix_srcfile_path"; then

1331

eval srcfile=\"$fix_srcfile_path\"

1332

fi

2178

1333

func_quote_for_eval "$srcfile"

2179

1334

qsrcfile=$func_quote_for_eval_result

2180

1335

2194

1349

2195

1350

if test -z "$output_obj"; then

2196

1351

# Place PIC objects in $objdir

2197

func_append command " -o $lobj"

1352

command="$command -o $lobj"

2198

1353

fi

2199

1354

2200

1355

func_show_eval_locale "$command" \

2241

1396

command="$base_compile $qsrcfile $pic_flag"

2242

1397

fi

2243

1398

if test "$compiler_c_o" = yes; then

2244

func_append command " -o $obj"

1399

command="$command -o $obj"

2245

1400

fi

2246

1401

2247

1402

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

2248

func_append command "$suppress_output"

1403

command="$command$suppress_output"

2249

1404

func_show_eval_locale "$command" \

2250

1405

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

2251

1406

2290

1445

}

2291

1446

2292

1447

$opt_help || {

2293

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

1448

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

2294

1449

}

2295

1450

2296

1451

func_mode_help ()

2297

1452

{

2298

1453

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

2299

case $opt_mode in

1454

case $mode in

2300

1455

"")

2301

1456

# Generic help is extracted from the usage comments

2302

1457

# at the start of this file.

2327

1482

2328

1483

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

2329

1484

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

2330

-prefer-pic try to build PIC objects only

2331

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

1485

-prefer-pic try to building PIC objects only

1486

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

2332

1487

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

2333

1488

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

2334

-Wc,FLAG pass FLAG directly to the compiler

2335

1489

2336

1490

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

2337

1491

from the given SOURCEFILE.

2384

1538

2385

1539

The following components of INSTALL-COMMAND are treated specially:

2386

1540

2387

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

1541

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

2388

1542

2389

1543

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

2390

1544

BSD-compatible install options are recognized)."

2404

1558

2405

1559

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

2406

1560

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

2407

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

2408

libraries must be found in the PATH setting at runtime)

2409

1561

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

2410

1562

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

2411

1563

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

2434

1586

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

2435

1587

specify library version info [each variable defaults to 0]

2436

1588

-weak LIBNAME declare that the target provides the LIBNAME interface

2437

-Wc,FLAG

2438

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

2439

-Wl,FLAG

2440

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

2441

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

2442

1589

2443

1590

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

2444

1591

2472

1619

;;

2473

1620

2474

1621

*)

2475

func_fatal_help "invalid operation mode \`$opt_mode'"

1622

func_fatal_help "invalid operation mode \`$mode'"

2476

1623

;;

2477

1624

esac

2478

1625

2479

echo

1626

$ECHO

2480

1627

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

1628

1629

exit $?

2481

1630

}

2482

1631

2483

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

2484

if $opt_help; then

2485

if test "$opt_help" = :; then

2486

func_mode_help

2487

else

2488

{

2489

func_help noexit

2490

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

2491

func_mode_help

2492

done

2493

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

2494

{

2495

func_help noexit

2496

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

2497

echo

2498

func_mode_help

2499

done

2500

} |

2501

sed '1d

2502

/^When reporting/,/^Report/{

2503

H

2504

d

2505

}

2506

$x

2507

/information about other modes/d

2508

/more detailed .*MODE/d

2509

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

2510

fi

2511

exit $?

2512

fi

1632

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

1633

$opt_help && func_mode_help

2513

1634

2514

1635

2515

1636

# func_mode_execute arg...

2522

1643

func_fatal_help "you must specify a COMMAND"

2523

1644

2524

1645

# Handle -dlopen flags immediately.

2525

for file in $opt_dlopen; do

1646

for file in $execute_dlfiles; do

2526

1647

test -f "$file" \

2527

1648

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

2528

1649

2529

1650

dir=

2530

1651

case $file in

2531

1652

*.la)

2532

func_resolve_sysroot "$file"

2533

file=$func_resolve_sysroot_result

2534

2535

1653

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

2536

1654

func_lalib_unsafe_p "$file" \

2537

1655

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

2553

1671

dir="$func_dirname_result"

2554

1672

2555

1673

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

2556

func_append dir "/$objdir"

1674

dir="$dir/$objdir"

2557

1675

else

2558

1676

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

2559

1677

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

2594

1712

for file

2595

1713

do

2596

1714

case $file in

2597

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

1715

-*) ;;

2598

1716

*)

2599

1717

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

2600

1718

if func_ltwrapper_script_p "$file"; then

2610

1728

;;

2611

1729

esac

2612

1730

# Quote arguments (to preserve shell metacharacters).

2613

func_append_quoted args "$file"

1731

func_quote_for_eval "$file"

1732

args="$args $func_quote_for_eval_result"

2614

1733

done

2615

1734

2616

1735

if test "X$opt_dry_run" = Xfalse; then

2635

1754

# Display what would be done.

2636

1755

if test -n "$shlibpath_var"; then

2637

1756

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

2638

echo "export $shlibpath_var"

1757

$ECHO "export $shlibpath_var"

2639

1758

fi

2640

1759

$ECHO "$cmd$args"

2641

1760

exit $EXIT_SUCCESS

2642

1761

fi

2643

1762

}

2644

1763

2645

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

1764

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

2646

1765

2647

1766

2648

1767

# func_mode_finish arg...

2649

1768

func_mode_finish ()

2650

1769

{

2651

1770

$opt_debug

2652

libs=

2653

libdirs=

1771

libdirs="$nonopt"

2654

1772

admincmds=

2655

1773

2656

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

2657

do

2658

if test -d "$opt"; then

2659

func_append libdirs " $opt"

2660

2661

elif test -f "$opt"; then

2662

if func_lalib_unsafe_p "$opt"; then

2663

func_append libs " $opt"

2664

else

2665

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

2666

fi

2667

2668

else

2669

func_fatal_error "invalid argument \`$opt'"

2670

fi

2671

done

2672

2673

if test -n "$libs"; then

2674

if test -n "$lt_sysroot"; then

2675

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

2676

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

2677

else

2678

sysroot_cmd=

2679

fi

2680

2681

# Remove sysroot references

2682

if $opt_dry_run; then

2683

for lib in $libs; do

2684

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

2685

done

2686

else

2687

tmpdir=`func_mktempdir`

2688

for lib in $libs; do

2689

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

2690

> $tmpdir/tmp-la

2691

mv -f $tmpdir/tmp-la $lib

2692

done

2693

${RM}r "$tmpdir"

2694

fi

2695

fi

2696

2697

1774

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

1775

for dir

1776

do

1777

libdirs="$libdirs $dir"

1778

done

1779

2698

1780

for libdir in $libdirs; do

2699

1781

if test -n "$finish_cmds"; then

2700

1782

# Do each command in the finish commands.

2704

1786

if test -n "$finish_eval"; then

2705

1787

# Do the single finish_eval.

2706

1788

eval cmds=\"$finish_eval\"

2707

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

1789

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

2708

1790

$cmds"

2709

1791

fi

2710

1792

done

2713

1795

# Exit here if they wanted silent mode.

2714

1796

$opt_silent && exit $EXIT_SUCCESS

2715

1797

2716

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

2717

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

2718

echo "Libraries have been installed in:"

2719

for libdir in $libdirs; do

2720

$ECHO " $libdir"

2721

done

2722

echo

2723

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

2724

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

2725

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

2726

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

2727

if test -n "$shlibpath_var"; then

2728

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

2729

echo " during execution"

2730

fi

2731

if test -n "$runpath_var"; then

2732

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

2733

echo " during linking"

2734

fi

2735

if test -n "$hardcode_libdir_flag_spec"; then

2736

libdir=LIBDIR

2737

eval flag=\"$hardcode_libdir_flag_spec\"

2738

2739

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

2740

fi

2741

if test -n "$admincmds"; then

2742

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

2743

fi

2744

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

2745

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

2746

fi

2747

echo

2748

2749

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

2750

case $host in

2751

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

2752

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

2753

echo "pages."

2754

;;

2755

*)

2756

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

2757

;;

2758

esac

2759

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

2760

fi

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

2761

1841

exit $EXIT_SUCCESS

2762

1842

}

2763

1843

2764

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

1844

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

2765

1845

2766

1846

2767

1847

# func_mode_install arg...

2772

1852

# install_prog (especially on Windows NT).

2773

1853

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

2774

1854

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

2775

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

1855

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

2776

1856

# Aesthetically quote it.

2777

1857

func_quote_for_eval "$nonopt"

2778

1858

install_prog="$func_quote_for_eval_result "

2786

1866

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

2787

1867

# Aesthetically quote it.

2788

1868

func_quote_for_eval "$arg"

2789

func_append install_prog "$func_quote_for_eval_result"

2790

install_shared_prog=$install_prog

2791

case " $install_prog " in

2792

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

2793

*) install_cp=false ;;

2794

esac

1869

install_prog="$install_prog$func_quote_for_eval_result"

2795

1870

2796

1871

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

2797

1872

dest=

2801

1876

install_type=

2802

1877

isdir=no

2803

1878

stripme=

2804

no_mode=:

2805

1879

for arg

2806

1880

do

2807

arg2=

2808

1881

if test -n "$dest"; then

2809

func_append files " $dest"

1882

files="$files $dest"

2810

1883

dest=$arg

2811

1884

continue

2812

1885

fi

2814

1887

case $arg in

2815

1888

-d) isdir=yes ;;

2816

1889

-f)

2817

if $install_cp; then :; else

2818

prev=$arg

2819

fi

1890

case " $install_prog " in

1891

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

1892

*) prev=$arg ;;

1893

esac

2820

1894

;;

2821

1895

-g | -m | -o)

2822

1896

prev=$arg

2830

1904

*)

2831

1905

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

2832

1906

if test -n "$prev"; then

2833

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

2834

arg2=$install_override_mode

2835

no_mode=false

2836

fi

2837

1907

prev=

2838

1908

else

2839

1909

dest=$arg

2844

1914

2845

1915

# Aesthetically quote the argument.

2846

1916

func_quote_for_eval "$arg"

2847

func_append install_prog " $func_quote_for_eval_result"

2848

if test -n "$arg2"; then

2849

func_quote_for_eval "$arg2"

2850

fi

2851

func_append install_shared_prog " $func_quote_for_eval_result"

1917

install_prog="$install_prog $func_quote_for_eval_result"

2852

1918

done

2853

1919

2854

1920

test -z "$install_prog" && \

2857

1923

test -n "$prev" && \

2858

1924

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

2859

1925

2860

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

2861

if $install_cp; then :; else

2862

func_quote_for_eval "$install_override_mode"

2863

func_append install_shared_prog " -m $func_quote_for_eval_result"

2864

fi

2865

fi

2866

2867

1926

if test -z "$files"; then

2868

1927

if test -z "$dest"; then

2869

1928

func_fatal_help "no file or destination specified"

2918

1977

case $file in

2919

1978

*.$libext)

2920

1979

# Do the static libraries later.

2921

func_append staticlibs " $file"

1980

staticlibs="$staticlibs $file"

2922

1981

;;

2923

1982

2924

1983

*.la)

2925

func_resolve_sysroot "$file"

2926

file=$func_resolve_sysroot_result

2927

2928

1984

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

2929

1985

func_lalib_unsafe_p "$file" \

2930

1986

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

2938

1994

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

2939

1995

case "$current_libdirs " in

2940

1996

*" $libdir "*) ;;

2941

*) func_append current_libdirs " $libdir" ;;

1997

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

2942

1998

esac

2943

1999

else

2944

2000

# Note the libdir as a future libdir.

2945

2001

case "$future_libdirs " in

2946

2002

*" $libdir "*) ;;

2947

*) func_append future_libdirs " $libdir" ;;

2003

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

2948

2004

esac

2949

2005

fi

2950

2006

2951

2007

func_dirname "$file" "/" ""

2952

2008

dir="$func_dirname_result"

2953

func_append dir "$objdir"

2009

dir="$dir$objdir"

2954

2010

2955

2011

if test -n "$relink_command"; then

2956

2012

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

2957

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

2013

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

2958

2014

2959

2015

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

2960

2016

# location b/c this prevents finding dependent libraries that

2967

2023

2968

2024

if test -n "$inst_prefix_dir"; then

2969

2025

# Stick the inst_prefix_dir data into the link command.

2970

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

2026

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

2971

2027

else

2972

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

2028

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

2973

2029

fi

2974

2030

2975

2031

func_warning "relinking \`$file'"

2987

2043

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

2988

2044

2989

2045

# Install the shared library and build the symlinks.

2990

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

2046

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

2991

2047

'exit $?'

2992

2048

tstripme="$stripme"

2993

2049

case $host_os in

3027

2083

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

3028

2084

3029

2085

# Maybe install the static library, too.

3030

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

2086

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

3031

2087

;;

3032

2088

3033

2089

*.lo)

3127

2183

if test -f "$lib"; then

3128

2184

func_source "$lib"

3129

2185

fi

3130

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

2186

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

3131

2187

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

3132

2188

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

3133

2189

finalize=no

3146

2202

file="$func_basename_result"

3147

2203

outputname="$tmpdir/$file"

3148

2204

# Replace the output file specification.

3149

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

2205

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

3150

2206

3151

2207

$opt_silent || {

3152

2208

func_quote_for_expand "$relink_command"

3165

2221

}

3166

2222

else

3167

2223

# Install the binary that we compiled earlier.

3168

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

2224

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

3169

2225

fi

3170

2226

fi

3171

2227

3224

2280

fi

3225

2281

}

3226

2282

3227

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

2283

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

3228

2284

3229

2285

3230

2286

# func_generate_dlsyms outputname originator pic_p

3267

2323

extern \"C\" {

3268

2324

#endif

3269

2325

3270

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

3271

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

3272

#endif

3273

3274

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

3275

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

3276

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

3277

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

3278

# define LT_DLSYM_CONST

3279

#elif defined(__osf__)

3280

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

3281

# define LT_DLSYM_CONST

3282

#else

3283

# define LT_DLSYM_CONST const

3284

#endif

3285

3286

2326

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

3287

2327

"

3288

2328

3292

2332

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

3293

2333

3294

2334

# Add our own program objects to the symbol list.

3295

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

2335

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

3296

2336

for progfile in $progfiles; do

3297

func_to_tool_file "$progfile" func_convert_file_msys_to_w32

3298

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

3299

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

2337

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

2338

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

3300

2339

done

3301

2340

3302

2341

if test -n "$exclude_expsyms"; then

3332

2371

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

3333

2372

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

3334

2373

case $host in

3335

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

2374

*cygwin | *mingw* | *cegcc* )

3336

2375

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

3337

2376

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

3338

2377

;;

3345

2384

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

3346

2385

func_basename "$dlprefile"

3347

2386

name="$func_basename_result"

3348

case $host in

3349

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

3350

# if an import library, we need to obtain dlname

3351

if func_win32_import_lib_p "$dlprefile"; then

3352

func_tr_sh "$dlprefile"

3353

eval "curr_lafile=\$libfile_$func_tr_sh_result"

3354

dlprefile_dlbasename=""

3355

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

3356

# Use subshell, to avoid clobbering current variable values

3357

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

3358

if test -n "$dlprefile_dlname" ; then

3359

func_basename "$dlprefile_dlname"

3360

dlprefile_dlbasename="$func_basename_result"

3361

else

3362

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

3363

$sharedlib_from_linklib_cmd "$dlprefile"

3364

dlprefile_dlbasename=$sharedlib_from_linklib_result

3365

fi

3366

fi

3367

$opt_dry_run || {

3368

if test -n "$dlprefile_dlbasename" ; then

3369

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

3370

else

3371

func_warning "Could not compute DLL name from $name"

3372

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

3373

fi

3374

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3375

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

3376

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

3377

}

3378

else # not an import lib

3379

$opt_dry_run || {

3380

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

3381

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3382

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

3383

}

3384

fi

3385

;;

3386

*)

3387

$opt_dry_run || {

3388

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

3389

func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32

3390

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

3391

}

3392

;;

3393

esac

2387

$opt_dry_run || {

2388

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

2389

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

2390

}

3394

2391

done

3395

2392

3396

2393

$opt_dry_run || {

3418

2415

if test -f "$nlist"S; then

3419

2416

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

3420

2417

else

3421

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

2418

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

3422

2419

fi

3423

2420

3424

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

2421

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

3425

2422

3426

2423

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

3427

2424

typedef struct {

3428

2425

const char *name;

3429

2426

void *address;

3430

2427

} lt_dlsymlist;

3431

extern LT_DLSYM_CONST 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

3432

2446

lt_${my_prefix}_LTX_preloaded_symbols[];

3433

LT_DLSYM_CONST lt_dlsymlist

2447

$lt_dlsym_const lt_dlsymlist

3434

2448

lt_${my_prefix}_LTX_preloaded_symbols[] =

3435

2449

{\

3436

2450

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

3443

2457

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

3444

2458

;;

3445

2459

esac

3446

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

2460

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

3447

2461

{0, (void *) 0}

3448

2462

};

3449

2463

3486

2500

for arg in $LTCFLAGS; do

3487

2501

case $arg in

3488

2502

-pie | -fpie | -fPIE) ;;

3489

*) func_append symtab_cflags " $arg" ;;

2503

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

3490

2504

esac

3491

2505

done

3492

2506

3501

2515

case $host in

3502

2516

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

3503

2517

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

3504

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

3505

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

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

3506

2520

else

3507

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

3508

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

2521

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

2522

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

3509

2523

fi

3510

2524

;;

3511

2525

*)

3512

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

3513

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

2526

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

2527

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

3514

2528

;;

3515

2529

esac

3516

2530

;;

3524

2538

# really was required.

3525

2539

3526

2540

# Nullify the symbol file.

3527

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

3528

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

2541

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

2542

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

3529

2543

fi

3530

2544

}

3531

2545

3535

2549

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

3536

2550

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

3537

2551

# that is supplied when $file_magic_command is called.

3538

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

3539

2552

func_win32_libid ()

3540

2553

{

3541

2554

$opt_debug

3546

2559

win32_libid_type="x86 archive import"

3547

2560

;;

3548

2561

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

3549

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

3550

2562

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

3551

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

3552

func_to_tool_file "$1" func_convert_file_msys_to_w32

3553

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

2563

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

2564

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

3554

2565

$SED -n -e '

3555

2566

1,100{

3556

2567

/ I /{

3579

2590

$ECHO "$win32_libid_type"

3580

2591

}

3581

2592

3582

# func_cygming_dll_for_implib ARG

3583

#

3584

# Platform-specific function to extract the

3585

# name of the DLL associated with the specified

3586

# import library ARG.

3587

# Invoked by eval'ing the libtool variable

3588

# $sharedlib_from_linklib_cmd

3589

# Result is available in the variable

3590

# $sharedlib_from_linklib_result

3591

func_cygming_dll_for_implib ()

3592

{

3593

$opt_debug

3594

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

3595

}

3596

3597

# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs

3598

#

3599

# The is the core of a fallback implementation of a

3600

# platform-specific function to extract the name of the

3601

# DLL associated with the specified import library LIBNAME.

3602

#

3603

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

3604

# on the platform and compiler that created the implib.

3605

#

3606

# Echos the name of the DLL associated with the

3607

# specified import library.

3608

func_cygming_dll_for_implib_fallback_core ()

3609

{

3610

$opt_debug

3611

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

3612

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

3613

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

3614

# Place marker at beginning of archive member dllname section

3615

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

3616

p

3617

d

3618

}

3619

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

3620

# are always uninteresting

3621

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

3622

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

3623

# Ensure marker is printed

3624

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

3625

# Remove all lines with less than 43 characters

3626

/^.\{43\}/!d

3627

# From remaining lines, remove first 43 characters

3628

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

3629

$SED -n '

3630

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

3631

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

3632

H

3633

$ b para

3634

b

3635

:para

3636

x

3637

s/\n//g

3638

# Remove the marker

3639

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

3640

# Remove trailing dots and whitespace

3641

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

3642

# Print

3643

/./p' |

3644

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

3645

# contents of the appropriate section of all members of the

3646

# archive which possess that section. Heuristic: eliminate

3647

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

3648

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

3649

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

3650

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

3651

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

3652

# a '.'.

3653

#

3654

# Of those that remain, print the first one.

3655

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

3656

}

3657

3658

# func_cygming_gnu_implib_p ARG

3659

# This predicate returns with zero status (TRUE) if

3660

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

3661

# with nonzero status (FALSE) otherwise.

3662

func_cygming_gnu_implib_p ()

3663

{

3664

$opt_debug

3665

func_to_tool_file "$1" func_convert_file_msys_to_w32

3666

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

3667

test -n "$func_cygming_gnu_implib_tmp"

3668

}

3669

3670

# func_cygming_ms_implib_p ARG

3671

# This predicate returns with zero status (TRUE) if

3672

# ARG is an MS-style import library. Returns

3673

# with nonzero status (FALSE) otherwise.

3674

func_cygming_ms_implib_p ()

3675

{

3676

$opt_debug

3677

func_to_tool_file "$1" func_convert_file_msys_to_w32

3678

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

3679

test -n "$func_cygming_ms_implib_tmp"

3680

}

3681

3682

# func_cygming_dll_for_implib_fallback ARG

3683

# Platform-specific function to extract the

3684

# name of the DLL associated with the specified

3685

# import library ARG.

3686

#

3687

# This fallback implementation is for use when $DLLTOOL

3688

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

3689

# Invoked by eval'ing the libtool variable

3690

# $sharedlib_from_linklib_cmd

3691

# Result is available in the variable

3692

# $sharedlib_from_linklib_result

3693

func_cygming_dll_for_implib_fallback ()

3694

{

3695

$opt_debug

3696

if func_cygming_gnu_implib_p "$1" ; then

3697

# binutils import library

3698

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

3699

elif func_cygming_ms_implib_p "$1" ; then

3700

# ms-generated import library

3701

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

3702

else

3703

# unknown

3704

sharedlib_from_linklib_result=""

3705

fi

3706

}

3707

2593

3708

2594

3709

2595

# func_extract_an_archive dir oldlib

3712

2598

$opt_debug

3713

2599

f_ex_an_ar_dir="$1"; shift

3714

2600

f_ex_an_ar_oldlib="$1"

3715

if test "$lock_old_archive_extraction" = yes; then

3716

lockfile=$f_ex_an_ar_oldlib.lock

3717

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

3718

func_echo "Waiting for $lockfile to be removed"

3719

sleep 2

3720

done

3721

fi

3722

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

3723

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

3724

if test "$lock_old_archive_extraction" = yes; then

3725

$opt_dry_run || rm -f "$lockfile"

3726

fi

2601

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

3727

2602

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

3728

2603

:

3729

2604

else

3794

2669

darwin_file=

3795

2670

darwin_files=

3796

2671

for darwin_file in $darwin_filelist; do

3797

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

2672

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

3798

2673

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

3799

2674

done # $darwin_filelist

3800

2675

$RM -rf unfat-$$

3809

2684

func_extract_an_archive "$my_xdir" "$my_xabs"

3810

2685

;;

3811

2686

esac

3812

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

2687

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

3813

2688

done

3814

2689

3815

2690

func_extract_archives_result="$my_oldobjs"

3816

2691

}

3817

2692

3818

2693

3819

# func_emit_wrapper [arg=no]

3820

#

3821

# Emit a libtool wrapper script on stdout.

3822

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

3823

# incorporate the script contents within a cygwin/mingw

3824

# wrapper executable. Must ONLY be called from within

3825

# func_mode_link because it depends on a number of variables

3826

# set therein.

3827

#

3828

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

3829

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

3830

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

3831

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

3832

# behavior.

3833

func_emit_wrapper ()

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

3834

2701

{

3835

func_emit_wrapper_arg1=${1-no}

2702

func_emit_wrapper_part1_arg1=no

2703

if test -n "$1" ; then

2704

func_emit_wrapper_part1_arg1=$1

2705

fi

3836

2706

3837

2707

$ECHO "\

3838

2708

#! $SHELL

3848

2718

3849

2719

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

3850

2720

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

2721

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

3851

2722

sed_quote_subst='$sed_quote_subst'

3852

2723

3853

2724

# Be Bourne compatible

3878

2749

else

3879

2750

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

3880

2751

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

3881

file=\"\$0\""

3882

3883

qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`

3884

$ECHO "\

3885

3886

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

3887

func_fallback_echo ()

3888

{

3889

eval 'cat <<_LTECHO_EOF

3890

\$1

3891

_LTECHO_EOF'

3892

}

3893

ECHO=\"$qECHO\"

3894

fi

3895

3896

# Very basic option parsing. These options are (a) specific to

3897

# the libtool wrapper, (b) are identical between the wrapper

3898

# /script/ and the wrapper /executable/ which is used only on

3899

# windows platforms, and (c) all begin with the string "--lt-"

3900

# (application programs are unlikely to have options which match

3901

# this pattern).

3902

#

3903

# There are only two supported options: --lt-debug and

3904

# --lt-dump-script. There is, deliberately, no --lt-help.

3905

#

3906

# The first argument to this parsing function should be the

3907

# script's $0 value, followed by "$@".

3908

lt_option_debug=

3909

func_parse_lt_options ()

3910

{

3911

lt_script_arg0=\$0

3912

shift

3913

for lt_opt

3914

do

3915

case \"\$lt_opt\" in

3916

--lt-debug) lt_option_debug=1 ;;

3917

--lt-dump-script)

3918

lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`

3919

test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.

3920

lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`

3921

cat \"\$lt_dump_D/\$lt_dump_F\"

3922

exit 0

3923

;;

3924

--lt-*)

3925

\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2

3926

exit 1

3927

;;

3928

esac

3929

done

3930

3931

# Print the debug banner immediately:

3932

if test -n \"\$lt_option_debug\"; then

3933

echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2

3934

fi

3935

}

3936

3937

# Used when --lt-debug. Prints its arguments to stdout

3938

# (redirection is the responsibility of the caller)

3939

func_lt_dump_args ()

3940

{

3941

lt_dump_args_N=1;

3942

for lt_arg

3943

do

3944

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"

3945

lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`

3946

done

3947

}

3948

3949

# Core function for launching the target application

3950

func_exec_program_core ()

3951

{

3952

"

3953

case $host in

3954

# Backslashes separate directories on plain windows

3955

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

3956

$ECHO "\

3957

if test -n \"\$lt_option_debug\"; then

3958

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2

3959

func_lt_dump_args \${1+\"\$@\"} 1>&2

3960

fi

3961

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

3962

"

3963

;;

3964

3965

*)

3966

$ECHO "\

3967

if test -n \"\$lt_option_debug\"; then

3968

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2

3969

func_lt_dump_args \${1+\"\$@\"} 1>&2

3970

fi

3971

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

3972

"

3973

;;

3974

esac

3975

$ECHO "\

3976

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

3977

exit 1

3978

}

3979

3980

# A function to encapsulate launching the target application

3981

# Strips options in the --lt-* namespace from \$@ and

3982

# launches target application with the remaining arguments.

3983

func_exec_program ()

3984

{

3985

for lt_wr_arg

3986

do

3987

case \$lt_wr_arg in

3988

--lt-*) ;;

3989

*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;

3990

esac

3991

shift

3992

done

3993

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

3994

}

3995

3996

# Parse options

3997

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

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.

2757

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

3998

2768

3999

2769

# Find the directory that this script lives in.

4000

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

2770

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

4001

2771

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

4002

2772

4003

2773

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

4004

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

2774

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

4005

2775

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

4006

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

2776

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

4007

2777

4008

2778

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

4009

2779

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

4013

2783

esac

4014

2784

fi

4015

2785

4016

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

4017

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

2786

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

2787

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

4018

2788

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

4019

2806

4020

2807

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

4021

2808

# the cwrapper.

4022

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1

2809

WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1

4023

2810

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

4024

2811

# special case for '.'

4025

2812

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

4027

2814

fi

4028

2815

# remove .libs from thisdir

4029

2816

case \"\$thisdir\" in

4030

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

2817

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

4031

2818

$objdir ) thisdir=. ;;

4032

2819

esac

4033

2820

fi

4082

2869

4083

2870

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

4084

2871

4085

# fixup the dll searchpath if we need to.

4086

#

4087

# Fix the DLL searchpath if we need to. Do this before prepending

4088

# to shlibpath, because on Windows, both are PATH and uninstalled

4089

# libraries must come first.

4090

if test -n "$dllsearchpath"; then

4091

$ECHO "\

4092

# Add the dll search path components to the executable PATH

4093

PATH=$dllsearchpath:\$PATH

4094

"

4095

fi

4096

4097

2872

# Export our shlibpath_var if we have one.

4098

2873

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

4099

2874

$ECHO "\

4102

2877

4103

2878

# Some systems cannot cope with colon-terminated $shlibpath_var

4104

2879

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

4105

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

2880

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

4106

2881

4107

2882

export $shlibpath_var

4108

2883

"

4109

2884

fi

4110

2885

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

4111

2894

$ECHO "\

4112

2895

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

4113

2896

# Run the actual program with our arguments.

4114

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

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

4115

2915

fi

4116

2916

else

4117

2917

# The program doesn't exist.

4118

2918

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

4119

2919

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

4120

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

2920

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

4121

2921

exit 1

4122

2922

fi

4123

2923

fi\

4124

2924

"

4125

2925

}

4126

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

4127

3127

4128

3128

# func_emit_cwrapperexe_src

4129

3129

# emit the source code for a wrapper executable on stdout

4141

3141

4142

3142

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

4143

3143

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.

4144

3148

*/

4145

3149

EOF

4146

3150

cat <<"EOF"

4147

#ifdef _MSC_VER

4148

# define _CRT_SECURE_NO_DEPRECATE 1

4149

#endif

4150

3151

#include <stdio.h>

4151

3152

#include <stdlib.h>

4152

3153

#ifdef _MSC_VER

4153

3154

# include <direct.h>

4154

3155

# include <process.h>

4155

3156

# include <io.h>

3157

# define setmode _setmode

4156

3158

#else

4157

3159

# include <unistd.h>

4158

3160

# include <stdint.h>

4159

3161

# ifdef __CYGWIN__

4160

3162

# 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

4161

3169

# endif

4162

3170

#endif

4163

3171

#include <malloc.h>

4169

3177

#include <fcntl.h>

4170

3178

#include <sys/stat.h>

4171

3179

4172

/* declarations of non-ANSI functions */

4173

#if defined(__MINGW32__)

4174

# ifdef __STRICT_ANSI__

4175

int _putenv (const char *);

4176

# endif

4177

#elif defined(__CYGWIN__)

4178

# ifdef __STRICT_ANSI__

4179

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

4180

int putenv (char *);

4181

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

4182

# endif

4183

/* #elif defined (other platforms) ... */

4184

#endif

4185

4186

/* portability defines, excluding path handling macros */

4187

#if defined(_MSC_VER)

4188

# define setmode _setmode

4189

# define stat _stat

4190

# define chmod _chmod

4191

# define getcwd _getcwd

4192

# define putenv _putenv

4193

# define S_IXUSR _S_IEXEC

4194

# ifndef _INTPTR_T_DEFINED

4195

# define _INTPTR_T_DEFINED

4196

# define intptr_t int

4197

# endif

4198

#elif defined(__MINGW32__)

4199

# define setmode _setmode

4200

# define stat _stat

4201

# define chmod _chmod

4202

# define getcwd _getcwd

4203

# define putenv _putenv

4204

#elif defined(__CYGWIN__)

4205

# define HAVE_SETENV

4206

# define FOPEN_WB "wb"

4207

/* #elif defined (other platforms) ... */

4208

#endif

4209

4210

3180

#if defined(PATH_MAX)

4211

3181

# define LT_PATHMAX PATH_MAX

4212

3182

#elif defined(MAXPATHLEN)

4222

3192

# define S_IXGRP 0

4223

3193

#endif

4224

3194

4225

/* path handling portability macros */

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

4226

3203

#ifndef DIR_SEPARATOR

4227

3204

# define DIR_SEPARATOR '/'

4228

3205

# define PATH_SEPARATOR ':'

4253

3230

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

4254

3231

#endif /* PATH_SEPARATOR_2 */

4255

3232

3233

#ifdef __CYGWIN__

3234

# define FOPEN_WB "wb"

3235

#endif

3236

4256

3237

#ifndef FOPEN_WB

4257

3238

# define FOPEN_WB "w"

4258

3239

#endif

4265

3246

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

4266

3247

} while (0)

4267

3248

4268

#if defined(LT_DEBUGWRAPPER)

4269

static int lt_debug = 1;

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

}

4270

3260

#else

4271

static int lt_debug = 0;

3261

# define LTWRAPPER_DEBUGPRINTF(args)

4272

3262

#endif

4273

3263

4274

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

3264

const char *program_name = NULL;

4275

3265

4276

3266

void *xmalloc (size_t num);

4277

3267

char *xstrdup (const char *string);

4281

3271

int make_executable (const char *path);

4282

3272

int check_executable (const char *path);

4283

3273

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

4284

void lt_debugprintf (const char *file, int line, const char *fmt, ...);

4285

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

4286

static const char *nonnull (const char *s);

4287

static const char *nonempty (const char *s);

3274

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

4288

3275

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

4289

3276

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

4290

3281

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

4291

3282

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

4292

char **prepare_spawn (char **argv);

4293

void lt_dump_script (FILE *f);

4294

EOF

4295

4296

cat <<EOF

4297

volatile const char * MAGIC_EXE = "$magic_exe";

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

3302

const char * LIB_PATH_VARNAME = "$shlibpath_var";

4299

3303

EOF

4300

3304

4301

3305

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

4302

func_to_host_path "$temp_rpath"

3306

func_to_host_pathlist "$temp_rpath"

4303

3307

cat <<EOF

4304

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

3308

const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";

4305

3309

EOF

4306

3310

else

4307

3311

cat <<"EOF"

4310

3314

fi

4311

3315

4312

3316

if test -n "$dllsearchpath"; then

4313

func_to_host_path "$dllsearchpath:"

3317

func_to_host_pathlist "$dllsearchpath:"

4314

3318

cat <<EOF

4315

3319

const char * EXE_PATH_VARNAME = "PATH";

4316

const char * EXE_PATH_VALUE = "$func_to_host_path_result";

3320

const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";

4317

3321

EOF

4318

3322

else

4319

3323

cat <<"EOF"

4336

3340

cat <<"EOF"

4337

3341

4338

3342

#define LTWRAPPER_OPTION_PREFIX "--lt-"

3343

#define LTWRAPPER_OPTION_PREFIX_LENGTH 5

4339

3344

3345

static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;

4340

3346

static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;

3347

4341

3348

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

4342

static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";

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

4343

3361

4344

3362

int

4345

3363

main (int argc, char *argv[])

4356

3374

int i;

4357

3375

4358

3376

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

4359

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

3377

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

3378

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

4360

3379

4361

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

4362

* also, copy all non cwrapper options to newargz, except

4363

* argz[0], which is handled differently

4364

*/

4365

newargc=0;

3380

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

4366

3381

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

4367

3382

{

4368

3383

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

4376

3391

esac

4377

3392

4378

3393

cat <<"EOF"

4379

lt_dump_script (stdout);

3394

printf ("%s", script_text_part1);

3395

printf ("%s", script_text_part2);

4380

3396

return 0;

4381

3397

}

4382

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

4383

{

4384

lt_debug = 1;

4385

continue;

4386

}

4387

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

4388

{

4389

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

4390

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

4391

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

4392

report an error. Otherwise, targets might begin to believe

4393

they are allowed to use options in the LTWRAPPER_OPTION_PREFIX

4394

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

4395

need to make LTWRAPPER_OPTION_PREFIX a configure-time option

4396

or a configure.ac-settable value.

4397

*/

4398

lt_fatal (__FILE__, __LINE__,

4399

"unrecognized %s option: '%s'",

4400

ltwrapper_option_prefix, argv[i]);

4401

}

4402

/* otherwise ... */

4403

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

4404

3398

}

4405

newargz[++newargc] = NULL;

4406

4407

EOF

4408

cat <<EOF

4409

/* The GNU banner must be the first non-error debug message */

4410

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");

4411

EOF

4412

cat <<"EOF"

4413

lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);

4414

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

4415

3399

3400

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

4416

3401

tmp_pathspec = find_executable (argv[0]);

4417

3402

if (tmp_pathspec == NULL)

4418

lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);

4419

lt_debugprintf (__FILE__, __LINE__,

4420

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

4421

tmp_pathspec);

3403

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

3404

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

3405

tmp_pathspec));

4422

3406

4423

3407

actual_cwrapper_path = chase_symlinks (tmp_pathspec);

4424

lt_debugprintf (__FILE__, __LINE__,

4425

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

4426

actual_cwrapper_path);

3408

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

3409

actual_cwrapper_path));

4427

3410

XFREE (tmp_pathspec);

4428

3411

4429

actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));

3412

actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));

4430

3413

strendzap (actual_cwrapper_path, actual_cwrapper_name);

4431

3414

4432

3415

/* wrapper name transforms */

4444

3427

target_name = tmp_pathspec;

4445

3428

tmp_pathspec = 0;

4446

3429

4447

lt_debugprintf (__FILE__, __LINE__,

4448

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

4449

target_name);

3430

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

3431

target_name));

4450

3432

EOF

4451

3433

4452

3434

cat <<EOF

4496

3478

4497

3479

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

4498

3480

lt_setenv ("DUALCASE", "1"); /* for MSK sh */

4499

/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must

4500

be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)

4501

because on Windows, both *_VARNAMEs are PATH but uninstalled

4502

libraries must come first. */

3481

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

4503

3482

lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);

4504

lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);

4505

4506

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

4507

nonnull (lt_argv_zero));

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

4508

3552

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

4509

3553

{

4510

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

4511

i, nonnull (newargz[i]));

3554

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

4512

3555

}

4513

3556

4514

3557

EOF

4517

3560

mingw*)

4518

3561

cat <<"EOF"

4519

3562

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

4520

newargz = prepare_spawn (newargz);

4521

3563

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

4522

3564

if (rval == -1)

4523

3565

{

4524

3566

/* failed to start process */

4525

lt_debugprintf (__FILE__, __LINE__,

4526

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

4527

lt_argv_zero, nonnull (strerror (errno)));

3567

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

4528

3568

return 127;

4529

3569

}

4530

3570

return rval;

4546

3586

{

4547

3587

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

4548

3588

if (!p)

4549

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

3589

lt_fatal ("Memory exhausted");

4550

3590

4551

3591

return p;

4552

3592

}

4580

3620

{

4581

3621

struct stat st;

4582

3622

4583

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

4584

nonempty (path));

3623

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

3624

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

4585

3625

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

4586

3626

return 0;

4587

3627

4598

3638

int rval = 0;

4599

3639

struct stat st;

4600

3640

4601

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

4602

nonempty (path));

3641

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

3642

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

4603

3643

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

4604

3644

return 0;

4605

3645

4625

3665

int tmp_len;

4626

3666

char *concat_name;

4627

3667

4628

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

4629

nonempty (wrapper));

3668

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

3669

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

4630

3670

4631

3671

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

4632

3672

return NULL;

4679

3719

{

4680

3720

/* empty path: current directory */

4681

3721

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

4682

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

4683

nonnull (strerror (errno)));

3722

lt_fatal ("getcwd failed");

4684

3723

tmp_len = strlen (tmp);

4685

3724

concat_name =

4686

3725

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

4705

3744

}

4706

3745

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

4707

3746

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

4708

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

4709

nonnull (strerror (errno)));

3747

lt_fatal ("getcwd failed");

4710

3748

tmp_len = strlen (tmp);

4711

3749

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

4712

3750

memcpy (concat_name, tmp, tmp_len);

4732

3770

int has_symlinks = 0;

4733

3771

while (strlen (tmp_pathspec) && !has_symlinks)

4734

3772

{

4735

lt_debugprintf (__FILE__, __LINE__,

4736

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

4737

tmp_pathspec);

3773

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

3774

tmp_pathspec));

4738

3775

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

4739

3776

{

4740

3777

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

4756

3793

}

4757

3794

else

4758

3795

{

4759

lt_fatal (__FILE__, __LINE__,

4760

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

4761

tmp_pathspec, nonnull (strerror (errno)));

3796

char *errstr = strerror (errno);

3797

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

4762

3798

}

4763

3799

}

4764

3800

XFREE (tmp_pathspec);

4771

3807

tmp_pathspec = realpath (pathspec, buf);

4772

3808

if (tmp_pathspec == 0)

4773

3809

{

4774

lt_fatal (__FILE__, __LINE__,

4775

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

3810

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

4776

3811

}

4777

3812

return xstrdup (tmp_pathspec);

4778

3813

#endif

4798

3833

return str;

4799

3834

}

4800

3835

4801

void

4802

lt_debugprintf (const char *file, int line, const char *fmt, ...)

4803

{

4804

va_list args;

4805

if (lt_debug)

4806

{

4807

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

4808

va_start (args, fmt);

4809

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

4810

va_end (args);

4811

}

4812

}

4813

4814

3836

static void

4815

lt_error_core (int exit_status, const char *file,

4816

int line, const char *mode,

3837

lt_error_core (int exit_status, const char *mode,

4817

3838

const char *message, va_list ap)

4818

3839

{

4819

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

3840

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

4820

3841

vfprintf (stderr, message, ap);

4821

3842

fprintf (stderr, ".\n");

4822

3843

4825

3846

}

4826

3847

4827

3848

void

4828

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

3849

lt_fatal (const char *message, ...)

4829

3850

{

4830

3851

va_list ap;

4831

3852

va_start (ap, message);

4832

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

3853

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

4833

3854

va_end (ap);

4834

3855

}

4835

3856

4836

static const char *

4837

nonnull (const char *s)

4838

{

4839

return s ? s : "(null)";

4840

}

4841

4842

static const char *

4843

nonempty (const char *s)

4844

{

4845

return (s && !*s) ? "(empty)" : nonnull (s);

4846

}

4847

4848

3857

void

4849

3858

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

4850

3859

{

4851

lt_debugprintf (__FILE__, __LINE__,

4852

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

4853

nonnull (name), nonnull (value));

3860

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

3861

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

3862

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

4854

3863

{

4855

3864

#ifdef HAVE_SETENV

4856

3865

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

4895

3904

return new_value;

4896

3905

}

4897

3906

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

4898

3990

void

4899

3991

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

4900

3992

{

4901

lt_debugprintf (__FILE__, __LINE__,

4902

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

4903

nonnull (name), nonnull (value));

3993

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

3994

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

3995

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

4904

3996

4905

3997

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

4906

3998

{

4919

4011

void

4920

4012

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

4921

4013

{

4922

lt_debugprintf (__FILE__, __LINE__,

4923

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

4924

nonnull (name), nonnull (value));

4014

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

4015

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

4016

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

4925

4017

4926

4018

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

4927

4019

{

4931

4023

}

4932

4024

}

4933

4025

4934

EOF

4935

case $host_os in

4936

mingw*)

4937

cat <<"EOF"

4938

4939

/* Prepares an argument vector before calling spawn().

4940

Note that spawn() does not by itself call the command interpreter

4941

(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :

4942

({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

4943

GetVersionEx(&v);

4944

v.dwPlatformId == VER_PLATFORM_WIN32_NT;

4945

}) ? "cmd.exe" : "command.com").

4946

Instead it simply concatenates the arguments, separated by ' ', and calls

4947

CreateProcess(). We must quote the arguments since Win32 CreateProcess()

4948

interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a

4949

special way:

4950

- Space and tab are interpreted as delimiters. They are not treated as

4951

delimiters if they are surrounded by double quotes: "...".

4952

- Unescaped double quotes are removed from the input. Their only effect is

4953

that within double quotes, space and tab are treated like normal

4954

characters.

4955

- Backslashes not followed by double quotes are not special.

4956

- But 2*n+1 backslashes followed by a double quote become

4957

n backslashes followed by a double quote (n >= 0):

4958

\" -> "

4959

\\\" -> \"

4960

\\\\\" -> \\"

4961

*/

4962

#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4963

#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"

4964

char **

4965

prepare_spawn (char **argv)

4966

{

4967

size_t argc;

4968

char **new_argv;

4969

size_t i;

4970

4971

/* Count number of arguments. */

4972

for (argc = 0; argv[argc] != NULL; argc++)

4973

;

4974

4975

/* Allocate new argument vector. */

4976

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

4977

4978

/* Put quoted arguments into the new argument vector. */

4979

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

4980

{

4981

const char *string = argv[i];

4982

4983

if (string[0] == '\0')

4984

new_argv[i] = xstrdup ("\"\"");

4985

else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)

4986

{

4987

int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);

4988

size_t length;

4989

unsigned int backslashes;

4990

const char *s;

4991

char *quoted_string;

4992

char *p;

4993

4994

length = 0;

4995

backslashes = 0;

4996

if (quote_around)

4997

length++;

4998

for (s = string; *s != '\0'; s++)

4999

{

5000

char c = *s;

5001

if (c == '"')

5002

length += backslashes + 1;

5003

length++;

5004

if (c == '\\')

5005

backslashes++;

5006

else

5007

backslashes = 0;

5008

}

5009

if (quote_around)

5010

length += backslashes + 1;

5011

5012

quoted_string = XMALLOC (char, length + 1);

5013

5014

p = quoted_string;

5015

backslashes = 0;

5016

if (quote_around)

5017

*p++ = '"';

5018

for (s = string; *s != '\0'; s++)

5019

{

5020

char c = *s;

5021

if (c == '"')

5022

{

5023

unsigned int j;

5024

for (j = backslashes + 1; j > 0; j--)

5025

*p++ = '\\';

5026

}

5027

*p++ = c;

5028

if (c == '\\')

5029

backslashes++;

5030

else

5031

backslashes = 0;

5032

}

5033

if (quote_around)

5034

{

5035

unsigned int j;

5036

for (j = backslashes; j > 0; j--)

5037

*p++ = '\\';

5038

*p++ = '"';

5039

}

5040

*p = '\0';

5041

5042

new_argv[i] = quoted_string;

5043

}

5044

else

5045

new_argv[i] = (char *) string;

5046

}

5047

new_argv[argc] = NULL;

5048

5049

return new_argv;

5050

}

5051

EOF

5052

;;

5053

esac

5054

5055

cat <<"EOF"

5056

void lt_dump_script (FILE* f)

5057

{

5058

EOF

5059

func_emit_wrapper yes |

5060

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

5061

-e 's/^/ fputs ("/' -e 's/$/\\n", f);/'

5062

5063

cat <<"EOF"

5064

}

4026

5065

4027

EOF

5066

4028

}

5067

4029

# end: func_emit_cwrapperexe_src

5068

4030

5069

# func_win32_import_lib_p ARG

5070

# True if ARG is an import lib, as indicated by $file_magic_cmd

5071

func_win32_import_lib_p ()

5072

{

5073

$opt_debug

5074

case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in

5075

*import*) : ;;

5076

*) false ;;

5077

esac

5078

}

5079

5080

4031

# func_mode_link arg...

5081

4032

func_mode_link ()

5082

4033

{

5121

4072

new_inherited_linker_flags=

5122

4073

5123

4074

avoid_version=no

5124

bindir=

5125

4075

dlfiles=

5126

4076

dlprefiles=

5127

4077

dlself=no

5214

4164

esac

5215

4165

5216

4166

case $prev in

5217

bindir)

5218

bindir="$arg"

5219

prev=

5220

continue

5221

;;

5222

4167

dlfiles|dlprefiles)

5223

4168

if test "$preload" = no; then

5224

4169

# Add the symbol object into the linking commands.

5250

4195

;;

5251

4196

*)

5252

4197

if test "$prev" = dlfiles; then

5253

func_append dlfiles " $arg"

4198

dlfiles="$dlfiles $arg"

5254

4199

else

5255

func_append dlprefiles " $arg"

4200

dlprefiles="$dlprefiles $arg"

5256

4201

fi

5257

4202

prev=

5258

4203

continue

5276

4221

*-*-darwin*)

5277

4222

case "$deplibs " in

5278

4223

*" $qarg.ltframework "*) ;;

5279

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

4224

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

5280

4225

;;

5281

4226

esac

5282

4227

;;

5295

4240

moreargs=

5296

4241

for fil in `cat "$save_arg"`

5297

4242

do

5298

# func_append moreargs " $fil"

4243

# moreargs="$moreargs $fil"

5299

4244

arg=$fil

5300

4245

# A libtool-controlled object.

5301

4246

5324

4269

5325

4270

if test "$prev" = dlfiles; then

5326

4271

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

5327

func_append dlfiles " $pic_object"

4272

dlfiles="$dlfiles $pic_object"

5328

4273

prev=

5329

4274

continue

5330

4275

else

5336

4281

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

5337

4282

if test "$prev" = dlprefiles; then

5338

4283

# Preload the old-style object.

5339

func_append dlprefiles " $pic_object"

4284

dlprefiles="$dlprefiles $pic_object"

5340

4285

prev=

5341

4286

fi

5342

4287

5406

4351

if test "$prev" = rpath; then

5407

4352

case "$rpath " in

5408

4353

*" $arg "*) ;;

5409

*) func_append rpath " $arg" ;;

4354

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

5410

4355

esac

5411

4356

else

5412

4357

case "$xrpath " in

5413

4358

*" $arg "*) ;;

5414

*) func_append xrpath " $arg" ;;

4359

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

5415

4360

esac

5416

4361

fi

5417

4362

prev=

5423

4368

continue

5424

4369

;;

5425

4370

weak)

5426

func_append weak_libs " $arg"

4371

weak_libs="$weak_libs $arg"

5427

4372

prev=

5428

4373

continue

5429

4374

;;

5430

4375

xcclinker)

5431

func_append linker_flags " $qarg"

5432

func_append compiler_flags " $qarg"

4376

linker_flags="$linker_flags $qarg"

4377

compiler_flags="$compiler_flags $qarg"

5433

4378

prev=

5434

4379

func_append compile_command " $qarg"

5435

4380

func_append finalize_command " $qarg"

5436

4381

continue

5437

4382

;;

5438

4383

xcompiler)

5439

func_append compiler_flags " $qarg"

4384

compiler_flags="$compiler_flags $qarg"

5440

4385

prev=

5441

4386

func_append compile_command " $qarg"

5442

4387

func_append finalize_command " $qarg"

5443

4388

continue

5444

4389

;;

5445

4390

xlinker)

5446

func_append linker_flags " $qarg"

5447

func_append compiler_flags " $wl$qarg"

4391

linker_flags="$linker_flags $qarg"

4392

compiler_flags="$compiler_flags $wl$qarg"

5448

4393

prev=

5449

4394

func_append compile_command " $wl$qarg"

5450

4395

func_append finalize_command " $wl$qarg"

5480

4425

continue

5481

4426

;;

5482

4427

5483

-bindir)

5484

prev=bindir

5485

continue

5486

;;

5487

5488

4428

-dlopen)

5489

4429

prev=dlfiles

5490

4430

continue

5535

4475

;;

5536

4476

5537

4477

-L*)

5538

func_stripname "-L" '' "$arg"

5539

if test -z "$func_stripname_result"; then

4478

func_stripname '-L' '' "$arg"

4479

dir=$func_stripname_result

4480

if test -z "$dir"; then

5540

4481

if test "$#" -gt 0; then

5541

4482

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

5542

4483

else

5543

4484

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

5544

4485

fi

5545

4486

fi

5546

func_resolve_sysroot "$func_stripname_result"

5547

dir=$func_resolve_sysroot_result

5548

4487

# We need an absolute path.

5549

4488

case $dir in

5550

4489

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

5556

4495

;;

5557

4496

esac

5558

4497

case "$deplibs " in

5559

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

5560

# Will only happen for absolute or sysroot arguments

5561

;;

4498

*" -L$dir "*) ;;

5562

4499

*)

5563

# Preserve sysroot, but never include relative directories

5564

case $dir in

5565

[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;

5566

*) func_append deplibs " -L$dir" ;;

5567

esac

5568

func_append lib_search_path " $dir"

4500

deplibs="$deplibs -L$dir"

4501

lib_search_path="$lib_search_path $dir"

5569

4502

;;

5570

4503

esac

5571

4504

case $host in

5572

4505

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

5573

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

4506

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

5574

4507

case :$dllsearchpath: in

5575

4508

*":$dir:"*) ;;

5576

4509

::) dllsearchpath=$dir;;

5577

*) func_append dllsearchpath ":$dir";;

4510

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

5578

4511

esac

5579

4512

case :$dllsearchpath: in

5580

4513

*":$testbindir:"*) ;;

5581

4514

::) dllsearchpath=$testbindir;;

5582

*) func_append dllsearchpath ":$testbindir";;

4515

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

5583

4516

esac

5584

4517

;;

5585

4518

esac

5589

4522

-l*)

5590

4523

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

5591

4524

case $host in

5592

4525

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

5593

4526

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

5594

4527

continue

5595

4528

;;

5603

4536

;;

5604

4537

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

5605

4538

# Rhapsody C and math libraries are in the System framework

5606

func_append deplibs " System.ltframework"

4539

deplibs="$deplibs System.ltframework"

5607

4540

continue

5608

4541

;;

5609

4542

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

5623

4556

;;

5624

4557

esac

5625

4558

fi

5626

func_append deplibs " $arg"

4559

deplibs="$deplibs $arg"

5627

4560

continue

5628

4561

;;

5629

4562

5635

4568

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

5636

4569

# classes, name mangling, and exception handling.

5637

4570

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

5638

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

5639

func_append compiler_flags " $arg"

4571

-model|-arch|-isysroot)

4572

compiler_flags="$compiler_flags $arg"

5640

4573

func_append compile_command " $arg"

5641

4574

func_append finalize_command " $arg"

5642

4575

prev=xcompiler

5644

4577

;;

5645

4578

5646

4579

5647

func_append compiler_flags " $arg"

4580

compiler_flags="$compiler_flags $arg"

5648

4581

func_append compile_command " $arg"

5649

4582

func_append finalize_command " $arg"

5650

4583

case "$new_inherited_linker_flags " in

5651

4584

*" $arg "*) ;;

5652

* ) func_append new_inherited_linker_flags " $arg" ;;

4585

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

5653

4586

esac

5654

4587

continue

5655

4588

;;

5716

4649

# We need an absolute path.

5717

4650

case $dir in

5718

4651

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

5719

=*)

5720

func_stripname '=' '' "$dir"

5721

dir=$lt_sysroot$func_stripname_result

5722

;;

5723

4652

*)

5724

4653

func_fatal_error "only absolute run-paths are allowed"

5725

4654

;;

5726

4655

esac

5727

4656

case "$xrpath " in

5728

4657

*" $dir "*) ;;

5729

*) func_append xrpath " $dir" ;;

4658

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

5730

4659

esac

5731

4660

continue

5732

4661

;;

5779

4708

for flag in $args; do

5780

4709

IFS="$save_ifs"

5781

4710

func_quote_for_eval "$flag"

5782

func_append arg " $func_quote_for_eval_result"

5783

func_append compiler_flags " $func_quote_for_eval_result"

4711

arg="$arg $wl$func_quote_for_eval_result"

4712

compiler_flags="$compiler_flags $func_quote_for_eval_result"

5784

4713

done

5785

4714

IFS="$save_ifs"

5786

4715

func_stripname ' ' '' "$arg"

5795

4724

for flag in $args; do

5796

4725

IFS="$save_ifs"

5797

4726

func_quote_for_eval "$flag"

5798

func_append arg " $wl$func_quote_for_eval_result"

5799

func_append compiler_flags " $wl$func_quote_for_eval_result"

5800

func_append linker_flags " $func_quote_for_eval_result"

4727

arg="$arg $wl$func_quote_for_eval_result"

4728

compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"

4729

linker_flags="$linker_flags $func_quote_for_eval_result"

5801

4730

done

5802

4731

IFS="$save_ifs"

5803

4732

func_stripname ' ' '' "$arg"

5825

4754

arg="$func_quote_for_eval_result"

5826

4755

;;

5827

4756

5828

# Flags to be passed through unchanged, with rationale:

5829

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

5830

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

5831

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

5832

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

5833

# -q* compiler args for the IBM compiler

5834

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

5835

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

5836

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

5837

# @file GCC response files

5838

# -tp=* Portland pgcc target processor selection

5839

# --sysroot=* for sysroot support

5840

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

4757

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

4758

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

4759

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

4760

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

4761

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

4762

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

4763

# compiler args for GCC

4764

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

4765

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

4766

# @file GCC response files

5841

4767

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

5842

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

5843

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

4768

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

5844

4769

func_quote_for_eval "$arg"

5845

4770

arg="$func_quote_for_eval_result"

5846

4771

func_append compile_command " $arg"

5847

4772

func_append finalize_command " $arg"

5848

func_append compiler_flags " $arg"

4773

compiler_flags="$compiler_flags $arg"

5849

4774

continue

5850

4775

;;

5851

4776

5857

4782

5858

4783

*.$objext)

5859

4784

# A standard object.

5860

func_append objs " $arg"

4785

objs="$objs $arg"

5861

4786

;;

5862

4787

5863

4788

*.lo)

5888

4813

5889

4814

if test "$prev" = dlfiles; then

5890

4815

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

5891

func_append dlfiles " $pic_object"

4816

dlfiles="$dlfiles $pic_object"

5892

4817

prev=

5893

4818

continue

5894

4819

else

5900

4825

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

5901

4826

if test "$prev" = dlprefiles; then

5902

4827

# Preload the old-style object.

5903

func_append dlprefiles " $pic_object"

4828

dlprefiles="$dlprefiles $pic_object"

5904

4829

prev=

5905

4830

fi

5906

4831

5945

4870

5946

4871

*.$libext)

5947

4872

# An archive.

5948

func_append deplibs " $arg"

5949

func_append old_deplibs " $arg"

4873

deplibs="$deplibs $arg"

4874

old_deplibs="$old_deplibs $arg"

5950

4875

continue

5951

4876

;;

5952

4877

5953

4878

*.la)

5954

4879

# A libtool-controlled library.

5955

4880

5956

func_resolve_sysroot "$arg"

5957

4881

if test "$prev" = dlfiles; then

5958

4882

# This library was specified with -dlopen.

5959

func_append dlfiles " $func_resolve_sysroot_result"

4883

dlfiles="$dlfiles $arg"

5960

4884

prev=

5961

4885

elif test "$prev" = dlprefiles; then

5962

4886

# The library was specified with -dlpreopen.

5963

func_append dlprefiles " $func_resolve_sysroot_result"

4887

dlprefiles="$dlprefiles $arg"

5964

4888

prev=

5965

4889

else

5966

func_append deplibs " $func_resolve_sysroot_result"

4890

deplibs="$deplibs $arg"

5967

4891

fi

5968

4892

continue

5969

4893

;;

6001

4925

6002

4926

if test -n "$shlibpath_var"; then

6003

4927

# get the directories listed in $shlibpath_var

6004

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

4928

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

6005

4929

else

6006

4930

shlib_search_path=

6007

4931

fi

6010

4934

6011

4935

func_dirname "$output" "/" ""

6012

4936

output_objdir="$func_dirname_result$objdir"

6013

func_to_tool_file "$output_objdir/"

6014

tool_output_objdir=$func_to_tool_file_result

6015

4937

# Create the object directory.

6016

4938

func_mkdir_p "$output_objdir"

6017

4939

6032

4954

# Find all interdependent deplibs by searching for libraries

6033

4955

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

6034

4956

for deplib in $deplibs; do

6035

if $opt_preserve_dup_deps ; then

4957

if $opt_duplicate_deps ; then

6036

4958

case "$libs " in

6037

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

4959

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

6038

4960

esac

6039

4961

fi

6040

func_append libs " $deplib"

4962

libs="$libs $deplib"

6041

4963

done

6042

4964

6043

4965

if test "$linkmode" = lib; then

6050

4972

if $opt_duplicate_compiler_generated_deps; then

6051

4973

for pre_post_dep in $predeps $postdeps; do

6052

4974

case "$pre_post_deps " in

6053

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

4975

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

6054

4976

esac

6055

func_append pre_post_deps " $pre_post_dep"

4977

pre_post_deps="$pre_post_deps $pre_post_dep"

6056

4978

done

6057

4979

fi

6058

4980

pre_post_deps=

6111

5033

case $pass in

6112

5034

dlopen) libs="$dlfiles" ;;

6113

5035

dlpreopen) libs="$dlprefiles" ;;

6114

link)

6115

libs="$deplibs %DEPLIBS%"

6116

test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"

6117

;;

5036

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

6118

5037

esac

6119

5038

fi

6120

5039

if test "$linkmode,$pass" = "lib,dlpreopen"; then

6122

5041

for lib in $dlprefiles; do

6123

5042

# Ignore non-libtool-libs

6124

5043

dependency_libs=

6125

func_resolve_sysroot "$lib"

6126

5044

case $lib in

6127

*.la) func_source "$func_resolve_sysroot_result" ;;

5045

*.la) func_source "$lib" ;;

6128

5046

esac

6129

5047

6130

5048

# Collect preopened libtool deplibs, except any this library

6131

5049

# has declared as weak libs

6132

5050

for deplib in $dependency_libs; do

6133

func_basename "$deplib"

6134

deplib_base=$func_basename_result

5051

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

6135

5052

case " $weak_libs " in

6136

5053

*" $deplib_base "*) ;;

6137

*) func_append deplibs " $deplib" ;;

5054

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

6138

5055

esac

6139

5056

done

6140

5057

done

6155

5072

compile_deplibs="$deplib $compile_deplibs"

6156

5073

finalize_deplibs="$deplib $finalize_deplibs"

6157

5074

else

6158

func_append compiler_flags " $deplib"

5075

compiler_flags="$compiler_flags $deplib"

6159

5076

if test "$linkmode" = lib ; then

6160

5077

case "$new_inherited_linker_flags " in

6161

5078

*" $deplib "*) ;;

6162

* ) func_append new_inherited_linker_flags " $deplib" ;;

5079

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

6163

5080

esac

6164

5081

fi

6165

5082

fi

6244

5161

if test "$linkmode" = lib ; then

6245

5162

case "$new_inherited_linker_flags " in

6246

5163

*" $deplib "*) ;;

6247

* ) func_append new_inherited_linker_flags " $deplib" ;;

5164

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

6248

5165

esac

6249

5166

fi

6250

5167

fi

6257

5174

test "$pass" = conv && continue

6258

5175

newdependency_libs="$deplib $newdependency_libs"

6259

5176

func_stripname '-L' '' "$deplib"

6260

func_resolve_sysroot "$func_stripname_result"

6261

func_append newlib_search_path " $func_resolve_sysroot_result"

5177

newlib_search_path="$newlib_search_path $func_stripname_result"

6262

5178

;;

6263

5179

prog)

6264

5180

if test "$pass" = conv; then

6272

5188

finalize_deplibs="$deplib $finalize_deplibs"

6273

5189

fi

6274

5190

func_stripname '-L' '' "$deplib"

6275

func_resolve_sysroot "$func_stripname_result"

6276

func_append newlib_search_path " $func_resolve_sysroot_result"

5191

newlib_search_path="$newlib_search_path $func_stripname_result"

6277

5192

;;

6278

5193

*)

6279

5194

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

6284

5199

-R*)

6285

5200

if test "$pass" = link; then

6286

5201

func_stripname '-R' '' "$deplib"

6287

func_resolve_sysroot "$func_stripname_result"

6288

dir=$func_resolve_sysroot_result

5202

dir=$func_stripname_result

6289

5203

# Make sure the xrpath contains only unique directories.

6290

5204

case "$xrpath " in

6291

5205

*" $dir "*) ;;

6292

*) func_append xrpath " $dir" ;;

5206

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

6293

5207

esac

6294

5208

fi

6295

5209

deplibs="$deplib $deplibs"

6296

5210

continue

6297

5211

;;

6298

*.la)

6299

func_resolve_sysroot "$deplib"

6300

lib=$func_resolve_sysroot_result

6301

;;

5212

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

6302

5213

*.$libext)

6303

5214

if test "$pass" = conv; then

6304

5215

deplibs="$deplib $deplibs"

6316

5227

match_pattern*)

6317

5228

set dummy $deplibs_check_method; shift

6318

5229

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

6319

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

5230

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

6320

5231

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

6321

5232

valid_a_lib=yes

6322

5233

fi

6326

5237

;;

6327

5238

esac

6328

5239

if test "$valid_a_lib" != yes; then

6329

echo

5240

$ECHO

6330

5241

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

6331

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

6332

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

6333

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

6334

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

6335

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

5242

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

5243

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

5244

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

5245

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

5246

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

6336

5247

else

6337

echo

5248

$ECHO

6338

5249

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

6339

5250

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

6340

5251

deplibs="$deplib $deplibs"

6361

5272

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

6362

5273

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

6363

5274

# we need to preload.

6364

func_append newdlprefiles " $deplib"

5275

newdlprefiles="$newdlprefiles $deplib"

6365

5276

compile_deplibs="$deplib $compile_deplibs"

6366

5277

finalize_deplibs="$deplib $finalize_deplibs"

6367

5278

else

6368

func_append newdlfiles " $deplib"

5279

newdlfiles="$newdlfiles $deplib"

6369

5280

fi

6370

5281

fi

6371

5282

continue

6407

5318

6408

5319

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

6409

5320

if test -n "$inherited_linker_flags"; then

6410

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

5321

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

6411

5322

for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do

6412

5323

case " $new_inherited_linker_flags " in

6413

5324

*" $tmp_inherited_linker_flag "*) ;;

6414

*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;

5325

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

6415

5326

esac

6416

5327

done

6417

5328

fi

6418

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

5329

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

6419

5330

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

6420

5331

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

6421

5332

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

6422

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

6423

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

5333

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

5334

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

6424

5335

fi

6425

5336

6426

5337

if test "$pass" = conv; then

6431

5342

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

6432

5343

fi

6433

5344

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

6434

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

6435

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

6436

tmp_libs=

6437

for deplib in $dependency_libs; do

6438

deplibs="$deplib $deplibs"

6439

if $opt_preserve_dup_deps ; then

6440

case "$tmp_libs " in

6441

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

6442

esac

6443

fi

6444

func_append tmp_libs " $deplib"

6445

done

5345

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

5346

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

6446

5347

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

6447

5348

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

6448

5349

fi

5350

tmp_libs=

5351

for deplib in $dependency_libs; do

5352

deplibs="$deplib $deplibs"

5353

if $opt_duplicate_deps ; then

5354

case "$tmp_libs " in

5355

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

5356

esac

5357

fi

5358

tmp_libs="$tmp_libs $deplib"

5359

done

6449

5360

continue

6450

5361

fi # $pass = conv

6451

5362

6452

5363

6453

5364

# Get the name of the library we link against.

6454

5365

linklib=

6455

if test -n "$old_library" &&

6456

{ test "$prefer_static_libs" = yes ||

6457

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

6458

linklib=$old_library

6459

else

6460

for l in $old_library $library_names; do

6461

linklib="$l"

6462

done

6463

fi

5366

for l in $old_library $library_names; do

5367

linklib="$l"

5368

done

6464

5369

if test -z "$linklib"; then

6465

5370

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

6466

5371

fi

6477

5382

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

6478

5383

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

6479

5384

# bomb out in the load deplibs phase.

6480

func_append dlprefiles " $lib $dependency_libs"

5385

dlprefiles="$dlprefiles $lib $dependency_libs"

6481

5386

else

6482

func_append newdlfiles " $lib"

5387

newdlfiles="$newdlfiles $lib"

6483

5388

fi

6484

5389

continue

6485

5390

fi # $pass = dlopen

6501

5406

6502

5407

# Find the relevant object directory and library name.

6503

5408

if test "X$installed" = Xyes; then

6504

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

5409

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

6505

5410

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

6506

5411

dir="$ladir"

6507

5412

absdir="$abs_ladir"

6508

5413

libdir="$abs_ladir"

6509

5414

else

6510

dir="$lt_sysroot$libdir"

6511

absdir="$lt_sysroot$libdir"

5415

dir="$libdir"

5416

absdir="$libdir"

6512

5417

fi

6513

5418

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

6514

5419

else

6516

5421

dir="$ladir"

6517

5422

absdir="$abs_ladir"

6518

5423

# Remove this search path later

6519

func_append notinst_path " $abs_ladir"

5424

notinst_path="$notinst_path $abs_ladir"

6520

5425

else

6521

5426

dir="$ladir/$objdir"

6522

5427

absdir="$abs_ladir/$objdir"

6523

5428

# Remove this search path later

6524

func_append notinst_path " $abs_ladir"

5429

notinst_path="$notinst_path $abs_ladir"

6525

5430

fi

6526

5431

fi # $installed = yes

6527

5432

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

6532

5437

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

6533

5438

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

6534

5439

fi

6535

case "$host" in

6536

# special handling for platforms with PE-DLLs.

6537

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

6538

# Linker will automatically link against shared library if both

6539

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

6540

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

6541

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

6542

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

6543

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

6544

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

6545

# dlname from the la file.

6546

if test -n "$dlname"; then

6547

func_tr_sh "$dir/$linklib"

6548

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

6549

func_append newdlprefiles " $dir/$linklib"

6550

else

6551

func_append newdlprefiles " $dir/$old_library"

6552

# Keep a list of preopened convenience libraries to check

6553

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

6554

test -z "$libdir" && \

6555

func_append dlpreconveniencelibs " $dir/$old_library"

6556

fi

6557

;;

6558

* )

6559

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

6560

# are required to link).

6561

if test -n "$old_library"; then

6562

func_append newdlprefiles " $dir/$old_library"

6563

# Keep a list of preopened convenience libraries to check

6564

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

6565

test -z "$libdir" && \

6566

func_append dlpreconveniencelibs " $dir/$old_library"

6567

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

6568

elif test -n "$dlname"; then

6569

func_append newdlprefiles " $dir/$dlname"

6570

else

6571

func_append newdlprefiles " $dir/$linklib"

6572

fi

6573

;;

6574

esac

5440

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

5441

# are required to link).

5442

if test -n "$old_library"; then

5443

newdlprefiles="$newdlprefiles $dir/$old_library"

5444

# Keep a list of preopened convenience libraries to check

5445

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

5446

test -z "$libdir" && \

5447

dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"

5448

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

5449

elif test -n "$dlname"; then

5450

newdlprefiles="$newdlprefiles $dir/$dlname"

5451

else

5452

newdlprefiles="$newdlprefiles $dir/$linklib"

5453

fi

6575

5454

fi # $pass = dlpreopen

6576

5455

6577

5456

if test -z "$libdir"; then

6589

5468

6590

5469

6591

5470

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

6592

func_append newlib_search_path " $ladir"

5471

newlib_search_path="$newlib_search_path $ladir"

6593

5472

deplibs="$lib $deplibs"

6594

5473

6595

5474

linkalldeplibs=no

6602

5481

for deplib in $dependency_libs; do

6603

5482

case $deplib in

6604

5483

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

6605

func_resolve_sysroot "$func_stripname_result"

6606

func_append newlib_search_path " $func_resolve_sysroot_result"

5484

newlib_search_path="$newlib_search_path $func_stripname_result"

6607

5485

;;

6608

5486

esac

6609

5487

# Need to link against all dependency_libs?

6614

5492

# or/and link against static libraries

6615

5493

newdependency_libs="$deplib $newdependency_libs"

6616

5494

fi

6617

if $opt_preserve_dup_deps ; then

5495

if $opt_duplicate_deps ; then

6618

5496

case "$tmp_libs " in

6619

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

5497

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

6620

5498

esac

6621

5499

fi

6622

func_append tmp_libs " $deplib"

5500

tmp_libs="$tmp_libs $deplib"

6623

5501

done # for deplib

6624

5502

continue

6625

5503

fi # $linkmode = prog...

6634

5512

# Make sure the rpath contains only unique directories.

6635

5513

case "$temp_rpath:" in

6636

5514

*"$absdir:"*) ;;

6637

*) func_append temp_rpath "$absdir:" ;;

5515

*) temp_rpath="$temp_rpath$absdir:" ;;

6638

5516

esac

6639

5517

fi

6640

5518

6646

5524

*)

6647

5525

case "$compile_rpath " in

6648

5526

*" $absdir "*) ;;

6649

*) func_append compile_rpath " $absdir" ;;

5527

*) compile_rpath="$compile_rpath $absdir"

6650

5528

esac

6651

5529

;;

6652

5530

esac

6655

5533

*)

6656

5534

case "$finalize_rpath " in

6657

5535

*" $libdir "*) ;;

6658

*) func_append finalize_rpath " $libdir" ;;

5536

*) finalize_rpath="$finalize_rpath $libdir"

6659

5537

esac

6660

5538

;;

6661

5539

esac

6680

5558

case $host in

6681

5559

*cygwin* | *mingw* | *cegcc*)

6682

5560

# No point in relinking DLLs because paths are not encoded

6683

func_append notinst_deplibs " $lib"

5561

notinst_deplibs="$notinst_deplibs $lib"

6684

5562

need_relink=no

6685

5563

;;

6686

5564

*)

6687

5565

if test "$installed" = no; then

6688

func_append notinst_deplibs " $lib"

5566

notinst_deplibs="$notinst_deplibs $lib"

6689

5567

need_relink=yes

6690

5568

fi

6691

5569

;;

6702

5580

fi

6703

5581

done

6704

5582

if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

6705

echo

5583

$ECHO

6706

5584

if test "$linkmode" = prog; then

6707

5585

$ECHO "*** Warning: Linking the executable $output against the loadable module"

6708

5586

else

6720

5598

*)

6721

5599

case "$compile_rpath " in

6722

5600

*" $absdir "*) ;;

6723

*) func_append compile_rpath " $absdir" ;;

5601

*) compile_rpath="$compile_rpath $absdir"

6724

5602

esac

6725

5603

;;

6726

5604

esac

6729

5607

*)

6730

5608

case "$finalize_rpath " in

6731

5609

*" $libdir "*) ;;

6732

*) func_append finalize_rpath " $libdir" ;;

5610

*) finalize_rpath="$finalize_rpath $libdir"

6733

5611

esac

6734

5612

;;

6735

5613

esac

6783

5661

linklib=$newlib

6784

5662

fi # test -n "$old_archive_from_expsyms_cmds"

6785

5663

6786

if test "$linkmode" = prog || test "$opt_mode" != relink; then

5664

if test "$linkmode" = prog || test "$mode" != relink; then

6787

5665

add_shlibpath=

6788

5666

add_dir=

6789

5667

add=

6805

5683

if test "X$dlopenmodule" != "X$lib"; then

6806

5684

$ECHO "*** Warning: lib $linklib is a module, not a shared library"

6807

5685

if test -z "$old_library" ; then

6808

echo

6809

echo "*** And there doesn't seem to be a static archive available"

6810

echo "*** The link will probably fail, sorry"

5686

$ECHO

5687

$ECHO "*** And there doesn't seem to be a static archive available"

5688

$ECHO "*** The link will probably fail, sorry"

6811

5689

else

6812

5690

add="$dir/$old_library"

6813

5691

fi

6839

5717

if test -n "$inst_prefix_dir"; then

6840

5718

case $libdir in

6841

5719

[\\/]*)

6842

func_append add_dir " -L$inst_prefix_dir$libdir"

5720

add_dir="$add_dir -L$inst_prefix_dir$libdir"

6843

5721

;;

6844

5722

esac

6845

5723

fi

6861

5739

if test -n "$add_shlibpath"; then

6862

5740

case :$compile_shlibpath: in

6863

5741

*":$add_shlibpath:"*) ;;

6864

*) func_append compile_shlibpath "$add_shlibpath:" ;;

5742

*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;

6865

5743

esac

6866

5744

fi

6867

5745

if test "$linkmode" = prog; then

6875

5753

test "$hardcode_shlibpath_var" = yes; then

6876

5754

case :$finalize_shlibpath: in

6877

5755

*":$libdir:"*) ;;

6878

*) func_append finalize_shlibpath "$libdir:" ;;

5756

*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

6879

5757

esac

6880

5758

fi

6881

5759

fi

6882

5760

fi

6883

5761

6884

if test "$linkmode" = prog || test "$opt_mode" = relink; then

5762

if test "$linkmode" = prog || test "$mode" = relink; then

6885

5763

add_shlibpath=

6886

5764

add_dir=

6887

5765

add=

6895

5773

elif test "$hardcode_shlibpath_var" = yes; then

6896

5774

case :$finalize_shlibpath: in

6897

5775

*":$libdir:"*) ;;

6898

*) func_append finalize_shlibpath "$libdir:" ;;

5776

*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;

6899

5777

esac

6900

5778

add="-l$name"

6901

5779

elif test "$hardcode_automatic" = yes; then

6912

5790

if test -n "$inst_prefix_dir"; then

6913

5791

case $libdir in

6914

5792

[\\/]*)

6915

func_append add_dir " -L$inst_prefix_dir$libdir"

5793

add_dir="$add_dir -L$inst_prefix_dir$libdir"

6916

5794

;;

6917

5795

esac

6918

5796

fi

6947

5825

6948

5826

# Just print a warning and add the library to dependency_libs so

6949

5827

# that the program can be linked against the static library.

6950

echo

5828

$ECHO

6951

5829

$ECHO "*** Warning: This system can not link to static lib archive $lib."

6952

echo "*** I have the capability to make that library automatically link in when"

6953

echo "*** you link to this library. But I can only do this if you have a"

6954

echo "*** shared version of the library, which you do not appear to have."

5830

$ECHO "*** I have the capability to make that library automatically link in when"

5831

$ECHO "*** you link to this library. But I can only do this if you have a"

5832

$ECHO "*** shared version of the library, which you do not appear to have."

6955

5833

if test "$module" = yes; then

6956

echo "*** But as you try to build a module library, libtool will still create "

6957

echo "*** a static module, that should work as long as the dlopening application"

6958

echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

5834

$ECHO "*** But as you try to build a module library, libtool will still create "

5835

$ECHO "*** a static module, that should work as long as the dlopening application"

5836

$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."

6959

5837

if test -z "$global_symbol_pipe"; then

6960

echo

6961

echo "*** However, this would only work if libtool was able to extract symbol"

6962

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

6963

echo "*** not find such a program. So, this module is probably useless."

6964

echo "*** \`nm' from GNU binutils and a full rebuild may help."

5838

$ECHO

5839

$ECHO "*** However, this would only work if libtool was able to extract symbol"

5840

$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"

5841

$ECHO "*** not find such a program. So, this module is probably useless."

5842

$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."

6965

5843

fi

6966

5844

if test "$build_old_libs" = no; then

6967

5845

build_libtool_libs=module

6989

5867

temp_xrpath=$func_stripname_result

6990

5868

case " $xrpath " in

6991

5869

*" $temp_xrpath "*) ;;

6992

*) func_append xrpath " $temp_xrpath";;

5870

*) xrpath="$xrpath $temp_xrpath";;

6993

5871

esac;;

6994

*) func_append temp_deplibs " $libdir";;

5872

*) temp_deplibs="$temp_deplibs $libdir";;

6995

5873

esac

6996

5874

done

6997

5875

dependency_libs="$temp_deplibs"

6998

5876

fi

6999

5877

7000

func_append newlib_search_path " $absdir"

5878

newlib_search_path="$newlib_search_path $absdir"

7001

5879

# Link against this library

7002

5880

test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

7003

5881

# ... and its dependency_libs

7004

5882

tmp_libs=

7005

5883

for deplib in $dependency_libs; do

7006

5884

newdependency_libs="$deplib $newdependency_libs"

7007

case $deplib in

7008

-L*) func_stripname '-L' '' "$deplib"

7009

func_resolve_sysroot "$func_stripname_result";;

7010

*) func_resolve_sysroot "$deplib" ;;

7011

esac

7012

if $opt_preserve_dup_deps ; then

5885

if $opt_duplicate_deps ; then

7013

5886

case "$tmp_libs " in

7014

*" $func_resolve_sysroot_result "*)

7015

func_append specialdeplibs " $func_resolve_sysroot_result" ;;

5887

*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;

7016

5888

esac

7017

5889

fi

7018

func_append tmp_libs " $func_resolve_sysroot_result"

5890

tmp_libs="$tmp_libs $deplib"

7019

5891

done

7020

5892

7021

5893

if test "$link_all_deplibs" != no; then

7022

5894

# Add the search paths of all dependency libraries

7023

5895

for deplib in $dependency_libs; do

7024

path=

7025

5896

case $deplib in

7026

5897

-L*) path="$deplib" ;;

7027

5898

*.la)

7028

func_resolve_sysroot "$deplib"

7029

deplib=$func_resolve_sysroot_result

7030

5899

func_dirname "$deplib" "" "."

7031

dir=$func_dirname_result

5900

dir="$func_dirname_result"

7032

5901

# We need an absolute path.

7033

5902

case $dir in

7034

5903

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

7055

5924

if test -z "$darwin_install_name"; then

7056

5925

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

7057

5926

fi

7058

func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

7059

func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"

5927

compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

5928

linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"

7060

5929

path=

7061

5930

fi

7062

5931

fi

7089

5958

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

7090

5959

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

7091

5960

else

7092

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

5961

compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

7093

5962

fi

7094

5963

fi

7095

5964

dependency_libs="$newdependency_libs"

7106

5975

for dir in $newlib_search_path; do

7107

5976

case "$lib_search_path " in

7108

5977

*" $dir "*) ;;

7109

*) func_append lib_search_path " $dir" ;;

5978

*) lib_search_path="$lib_search_path $dir" ;;

7110

5979

esac

7111

5980

done

7112

5981

newlib_search_path=

7164

6033

-L*)

7165

6034

case " $tmp_libs " in

7166

6035

*" $deplib "*) ;;

7167

*) func_append tmp_libs " $deplib" ;;

6036

*) tmp_libs="$tmp_libs $deplib" ;;

7168

6037

esac

7169

6038

;;

7170

*) func_append tmp_libs " $deplib" ;;

6039

*) tmp_libs="$tmp_libs $deplib" ;;

7171

6040

esac

7172

6041

done

7173

6042

eval $var=\"$tmp_libs\"

7183

6052

;;

7184

6053

esac

7185

6054

if test -n "$i" ; then

7186

func_append tmp_libs " $i"

6055

tmp_libs="$tmp_libs $i"

7187

6056

fi

7188

6057

done

7189

6058

dependency_libs=$tmp_libs

7224

6093

# Now set the variables for building old libraries.

7225

6094

build_libtool_libs=no

7226

6095

oldlibs="$output"

7227

func_append objs "$old_deplibs"

6096

objs="$objs$old_deplibs"

7228

6097

;;

7229

6098

7230

6099

lib)

7257

6126

if test "$deplibs_check_method" != pass_all; then

7258

6127

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

7259

6128

else

7260

echo

6129

$ECHO

7261

6130

$ECHO "*** Warning: Linking the shared library $output against the non-libtool"

7262

6131

$ECHO "*** objects $objs is not portable!"

7263

func_append libobjs " $objs"

6132

libobjs="$libobjs $objs"

7264

6133

fi

7265

6134

fi

7266

6135

7325

6194

age="$number_minor"

7326

6195

revision="$number_revision"

7327

6196

;;

7328

freebsd-aout|freebsd-elf|qnx|sunos)

6197

freebsd-aout|freebsd-elf|sunos)

7329

6198

current="$number_major"

7330

6199

revision="$number_minor"

7331

6200

age="0"

7337

6206

revision="$number_minor"

7338

6207

lt_irix_increment=no

7339

6208

;;

7340

*)

7341

func_fatal_configuration "$modename: unknown library version type \`$version_type'"

7342

;;

7343

6209

esac

7344

6210

;;

7345

6211

no)

7461

6327

done

7462

6328

7463

6329

# Make executables depend on our current version.

7464

func_append verstring ":${current}.0"

6330

verstring="$verstring:${current}.0"

7465

6331

;;

7466

6332

7467

6333

qnx)

7529

6395

fi

7530

6396

7531

6397

func_generate_dlsyms "$libname" "$libname" "yes"

7532

func_append libobjs " $symfileobj"

6398

libobjs="$libobjs $symfileobj"

7533

6399

test "X$libobjs" = "X " && libobjs=

7534

6400

7535

if test "$opt_mode" != relink; then

6401

if test "$mode" != relink; then

7536

6402

# Remove our outputs, but don't remove object files since they

7537

6403

# may have been created when compiling PIC objects.

7538

6404

removelist=

7548

6414

continue

7549

6415

fi

7550

6416

fi

7551

func_append removelist " $p"

6417

removelist="$removelist $p"

7552

6418

;;

7553

6419

*) ;;

7554

6420

esac

7559

6425

7560

6426

# Now set the variables for building old libraries.

7561

6427

if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

7562

func_append oldlibs " $output_objdir/$libname.$libext"

6428

oldlibs="$oldlibs $output_objdir/$libname.$libext"

7563

6429

7564

6430

# Transform .lo files to .o files.

7565

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

6431

oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`

7566

6432

fi

7567

6433

7568

6434

# Eliminate all temporary directories.

7569

6435

#for path in $notinst_path; do

7570

# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`

7571

# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`

7572

# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`

6436

# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`

6437

# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`

6438

# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`

7573

6439

#done

7574

6440

7575

6441

if test -n "$xrpath"; then

7576

6442

# If the user specified any rpath flags, then add them.

7577

6443

temp_xrpath=

7578

6444

for libdir in $xrpath; do

7579

func_replace_sysroot "$libdir"

7580

func_append temp_xrpath " -R$func_replace_sysroot_result"

6445

temp_xrpath="$temp_xrpath -R$libdir"

7581

6446

case "$finalize_rpath " in

7582

6447

*" $libdir "*) ;;

7583

*) func_append finalize_rpath " $libdir" ;;

6448

*) finalize_rpath="$finalize_rpath $libdir" ;;

7584

6449

esac

7585

6450

done

7586

6451

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

7594

6459

for lib in $old_dlfiles; do

7595

6460

case " $dlprefiles $dlfiles " in

7596

6461

*" $lib "*) ;;

7597

*) func_append dlfiles " $lib" ;;

6462

*) dlfiles="$dlfiles $lib" ;;

7598

6463

esac

7599

6464

done

7600

6465

7604

6469

for lib in $old_dlprefiles; do

7605

6470

case "$dlprefiles " in

7606

6471

*" $lib "*) ;;

7607

*) func_append dlprefiles " $lib" ;;

6472

*) dlprefiles="$dlprefiles $lib" ;;

7608

6473

esac

7609

6474

done

7610

6475

7611

6476

if test "$build_libtool_libs" = yes; then

7612

6477

if test -n "$rpath"; then

7613

6478

case $host in

7614

6479

7615

6480

# these systems don't actually have a c library (as such)!

7616

6481

;;

7617

6482

*-*-rhapsody* | *-*-darwin1.[012])

7618

6483

# Rhapsody C library is in the System framework

7619

func_append deplibs " System.ltframework"

6484

deplibs="$deplibs System.ltframework"

7620

6485

;;

7621

6486

*-*-netbsd*)

7622

6487

# Don't link with libc until the a.out ld.so is fixed.

7633

6498

*)

7634

6499

# Add libc to deplibs on all other systems if necessary.

7635

6500

if test "$build_libtool_need_lc" = "yes"; then

7636

func_append deplibs " -lc"

6501

deplibs="$deplibs -lc"

7637

6502

fi

7638

6503

;;

7639

6504

esac

7682

6547

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7683

6548

case " $predeps $postdeps " in

7684

6549

*" $i "*)

7685

func_append newdeplibs " $i"

6550

newdeplibs="$newdeplibs $i"

7686

6551

i=""

7687

6552

;;

7688

6553

esac

7693

6558

set dummy $deplib_matches; shift

7694

6559

deplib_match=$1

7695

6560

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7696

func_append newdeplibs " $i"

6561

newdeplibs="$newdeplibs $i"

7697

6562

else

7698

6563

droppeddeps=yes

7699

echo

6564

$ECHO

7700

6565

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7701

echo "*** I have the capability to make that library automatically link in when"

7702

echo "*** you link to this library. But I can only do this if you have a"

7703

echo "*** shared version of the library, which I believe you do not have"

7704

echo "*** because a test_compile did reveal that the linker did not use it for"

7705

echo "*** its dynamic dependency list that programs get resolved with at runtime."

6566

$ECHO "*** I have the capability to make that library automatically link in when"

6567

$ECHO "*** you link to this library. But I can only do this if you have a"

6568

$ECHO "*** shared version of the library, which I believe you do not have"

6569

$ECHO "*** because a test_compile did reveal that the linker did not use it for"

6570

$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."

7706

6571

fi

7707

6572

fi

7708

6573

;;

7709

6574

*)

7710

func_append newdeplibs " $i"

6575

newdeplibs="$newdeplibs $i"

7711

6576

;;

7712

6577

esac

7713

6578

done

7725

6590

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7726

6591

case " $predeps $postdeps " in

7727

6592

*" $i "*)

7728

func_append newdeplibs " $i"

6593

newdeplibs="$newdeplibs $i"

7729

6594

i=""

7730

6595

;;

7731

6596

esac

7736

6601

set dummy $deplib_matches; shift

7737

6602

deplib_match=$1

7738

6603

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

7739

func_append newdeplibs " $i"

6604

newdeplibs="$newdeplibs $i"

7740

6605

else

7741

6606

droppeddeps=yes

7742

echo

6607

$ECHO

7743

6608

$ECHO "*** Warning: dynamic linker does not accept needed library $i."

7744

echo "*** I have the capability to make that library automatically link in when"

7745

echo "*** you link to this library. But I can only do this if you have a"

7746

echo "*** shared version of the library, which you do not appear to have"

7747

echo "*** because a test_compile did reveal that the linker did not use this one"

7748

echo "*** as a dynamic dependency that programs can get resolved with at runtime."

6609

$ECHO "*** I have the capability to make that library automatically link in when"

6610

$ECHO "*** you link to this library. But I can only do this if you have a"

6611

$ECHO "*** shared version of the library, which you do not appear to have"

6612

$ECHO "*** because a test_compile did reveal that the linker did not use this one"

6613

$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."

7749

6614

fi

7750

6615

fi

7751

6616

else

7752

6617

droppeddeps=yes

7753

echo

6618

$ECHO

7754

6619

$ECHO "*** Warning! Library $i is needed by this library but I was not able to"

7755

echo "*** make it link in! You will probably need to install it or some"

7756

echo "*** library that it depends on before this library will be fully"

7757

echo "*** functional. Installing it before continuing would be even better."

6620

$ECHO "*** make it link in! You will probably need to install it or some"

6621

$ECHO "*** library that it depends on before this library will be fully"

6622

$ECHO "*** functional. Installing it before continuing would be even better."

7758

6623

fi

7759

6624

;;

7760

6625

*)

7761

func_append newdeplibs " $i"

6626

newdeplibs="$newdeplibs $i"

7762

6627

;;

7763

6628

esac

7764

6629

done

7775

6640

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7776

6641

case " $predeps $postdeps " in

7777

6642

*" $a_deplib "*)

7778

func_append newdeplibs " $a_deplib"

6643

newdeplibs="$newdeplibs $a_deplib"

7779

6644

a_deplib=""

7780

6645

;;

7781

6646

esac

7782

6647

fi

7783

6648

if test -n "$a_deplib" ; then

7784

6649

libname=`eval "\\$ECHO \"$libname_spec\""`

7785

if test -n "$file_magic_glob"; then

7786

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

7787

else

7788

libnameglob=$libname

7789

fi

7790

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

7791

6650

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

7792

if test "$want_nocaseglob" = yes; then

7793

shopt -s nocaseglob

7794

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7795

$nocaseglob

7796

else

7797

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

7798

fi

6651

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7799

6652

for potent_lib in $potential_libs; do

7800

6653

# Follow soft links.

7801

6654

if ls -lLd "$potent_lib" 2>/dev/null |

7812

6665

potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

7813

6666

case $potliblink in

7814

6667

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

7815

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

6668

*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;

7816

6669

esac

7817

6670

done

7818

6671

if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

7819

6672

$SED -e 10q |

7820

6673

$EGREP "$file_magic_regex" > /dev/null; then

7821

func_append newdeplibs " $a_deplib"

6674

newdeplibs="$newdeplibs $a_deplib"

7822

6675

a_deplib=""

7823

6676

break 2

7824

6677

fi

7827

6680

fi

7828

6681

if test -n "$a_deplib" ; then

7829

6682

droppeddeps=yes

7830

echo

6683

$ECHO

7831

6684

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7832

echo "*** I have the capability to make that library automatically link in when"

7833

echo "*** you link to this library. But I can only do this if you have a"

7834

echo "*** shared version of the library, which you do not appear to have"

7835

echo "*** because I did check the linker path looking for a file starting"

6685

$ECHO "*** I have the capability to make that library automatically link in when"

6686

$ECHO "*** you link to this library. But I can only do this if you have a"

6687

$ECHO "*** shared version of the library, which you do not appear to have"

6688

$ECHO "*** because I did check the linker path looking for a file starting"

7836

6689

if test -z "$potlib" ; then

7837

6690

$ECHO "*** with $libname but no candidates were found. (...for file magic test)"

7838

6691

else

7843

6696

;;

7844

6697

*)

7845

6698

# Add a -L argument.

7846

func_append newdeplibs " $a_deplib"

6699

newdeplibs="$newdeplibs $a_deplib"

7847

6700

;;

7848

6701

esac

7849

6702

done # Gone through all deplibs.

7859

6712

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7860

6713

case " $predeps $postdeps " in

7861

6714

*" $a_deplib "*)

7862

func_append newdeplibs " $a_deplib"

6715

newdeplibs="$newdeplibs $a_deplib"

7863

6716

a_deplib=""

7864

6717

;;

7865

6718

esac

7870

6723

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

7871

6724

for potent_lib in $potential_libs; do

7872

6725

potlib="$potent_lib" # see symlink-check above in file_magic test

7873

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

6726

if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \

7874

6727

$EGREP "$match_pattern_regex" > /dev/null; then

7875

func_append newdeplibs " $a_deplib"

6728

newdeplibs="$newdeplibs $a_deplib"

7876

6729

a_deplib=""

7877

6730

break 2

7878

6731

fi

7881

6734

fi

7882

6735

if test -n "$a_deplib" ; then

7883

6736

droppeddeps=yes

7884

echo

6737

$ECHO

7885

6738

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

7886

echo "*** I have the capability to make that library automatically link in when"

7887

echo "*** you link to this library. But I can only do this if you have a"

7888

echo "*** shared version of the library, which you do not appear to have"

7889

echo "*** because I did check the linker path looking for a file starting"

6739

$ECHO "*** I have the capability to make that library automatically link in when"

6740

$ECHO "*** you link to this library. But I can only do this if you have a"

6741

$ECHO "*** shared version of the library, which you do not appear to have"

6742

$ECHO "*** because I did check the linker path looking for a file starting"

7890

6743

if test -z "$potlib" ; then

7891

6744

$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

7892

6745

else

7897

6750

;;

7898

6751

*)

7899

6752

# Add a -L argument.

7900

func_append newdeplibs " $a_deplib"

6753

newdeplibs="$newdeplibs $a_deplib"

7901

6754

;;

7902

6755

esac

7903

6756

done # Gone through all deplibs.

7904

6757

;;

7905

6758

none | unknown | *)

7906

6759

newdeplibs=""

7907

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

6760

tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \

6761

-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`

7908

6762

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

7909

6763

for i in $predeps $postdeps ; do

7910

6764

# can't use Xsed below, because $i might contain '/'

7911

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

6765

tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`

7912

6766

done

7913

6767

fi

7914

case $tmp_deplibs in

7915

*[!\ \ ]*)

7916

echo

6768

if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |

6769

$GREP . >/dev/null; then

6770

$ECHO

7917

6771

if test "X$deplibs_check_method" = "Xnone"; then

7918

echo "*** Warning: inter-library dependencies are not supported in this platform."

6772

$ECHO "*** Warning: inter-library dependencies are not supported in this platform."

7919

6773

else

7920

echo "*** Warning: inter-library dependencies are not known to be supported."

6774

$ECHO "*** Warning: inter-library dependencies are not known to be supported."

7921

6775

fi

7922

echo "*** All declared inter-library dependencies are being dropped."

6776

$ECHO "*** All declared inter-library dependencies are being dropped."

7923

6777

droppeddeps=yes

7924

;;

7925

esac

6778

fi

7926

6779

;;

7927

6780

esac

7928

6781

versuffix=$versuffix_save

7934

6787

case $host in

7935

6788

*-*-rhapsody* | *-*-darwin1.[012])

7936

6789

# On Rhapsody replace the C library with the System framework

7937

newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`

6790

newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

7938

6791

;;

7939

6792

esac

7940

6793

7941

6794

if test "$droppeddeps" = yes; then

7942

6795

if test "$module" = yes; then

7943

echo

7944

echo "*** Warning: libtool could not satisfy all declared inter-library"

6796

$ECHO

6797

$ECHO "*** Warning: libtool could not satisfy all declared inter-library"

7945

6798

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

7946

echo "*** a static module, that should work as long as the dlopening"

7947

echo "*** application is linked with the -dlopen flag."

6799

$ECHO "*** a static module, that should work as long as the dlopening"

6800

$ECHO "*** application is linked with the -dlopen flag."

7948

6801

if test -z "$global_symbol_pipe"; then

7949

echo

7950

echo "*** However, this would only work if libtool was able to extract symbol"

7951

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

7952

echo "*** not find such a program. So, this module is probably useless."

7953

echo "*** \`nm' from GNU binutils and a full rebuild may help."

6802

$ECHO

6803

$ECHO "*** However, this would only work if libtool was able to extract symbol"

6804

$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"

6805

$ECHO "*** not find such a program. So, this module is probably useless."

6806

$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."

7954

6807

fi

7955

6808

if test "$build_old_libs" = no; then

7956

6809

oldlibs="$output_objdir/$libname.$libext"

7960

6813

build_libtool_libs=no

7961

6814

fi

7962

6815

else

7963

echo "*** The inter-library dependencies that have been dropped here will be"

7964

echo "*** automatically added whenever a program is linked with this library"

7965

echo "*** or is declared to -dlopen it."

6816

$ECHO "*** The inter-library dependencies that have been dropped here will be"

6817

$ECHO "*** automatically added whenever a program is linked with this library"

6818

$ECHO "*** or is declared to -dlopen it."

7966

6819

7967

6820

if test "$allow_undefined" = no; then

7968

echo

7969

echo "*** Since this library must not contain undefined symbols,"

7970

echo "*** because either the platform does not support them or"

7971

echo "*** it was explicitly requested with -no-undefined,"

7972

echo "*** libtool will only create a static version of it."

6821

$ECHO

6822

$ECHO "*** Since this library must not contain undefined symbols,"

6823

$ECHO "*** because either the platform does not support them or"

6824

$ECHO "*** it was explicitly requested with -no-undefined,"

6825

$ECHO "*** libtool will only create a static version of it."

7973

6826

if test "$build_old_libs" = no; then

7974

6827

oldlibs="$output_objdir/$libname.$libext"

7975

6828

build_libtool_libs=module

7986

6839

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

7987

6840

case $host in

7988

6841

*-*-darwin*)

7989

newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7990

new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7991

deplibs=`$ECHO " $deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

6842

newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

6843

new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

6844

deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

7992

6845

;;

7993

6846

esac

7994

6847

8001

6854

*)

8002

6855

case " $deplibs " in

8003

6856

*" -L$path/$objdir "*)

8004

func_append new_libs " -L$path/$objdir" ;;

6857

new_libs="$new_libs -L$path/$objdir" ;;

8005

6858

esac

8006

6859

;;

8007

6860

esac

8011

6864

-L*)

8012

6865

case " $new_libs " in

8013

6866

*" $deplib "*) ;;

8014

*) func_append new_libs " $deplib" ;;

6867

*) new_libs="$new_libs $deplib" ;;

8015

6868

esac

8016

6869

;;

8017

*) func_append new_libs " $deplib" ;;

6870

*) new_libs="$new_libs $deplib" ;;

8018

6871

esac

8019

6872

done

8020

6873

deplibs="$new_libs"

8031

6884

hardcode_libdirs=

8032

6885

dep_rpath=

8033

6886

rpath="$finalize_rpath"

8034

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

6887

test "$mode" != relink && rpath="$compile_rpath$rpath"

8035

6888

for libdir in $rpath; do

8036

6889

if test -n "$hardcode_libdir_flag_spec"; then

8037

6890

if test -n "$hardcode_libdir_separator"; then

8038

func_replace_sysroot "$libdir"

8039

libdir=$func_replace_sysroot_result

8040

6891

if test -z "$hardcode_libdirs"; then

8041

6892

hardcode_libdirs="$libdir"

8042

6893

else

8045

6896

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8046

6897

;;

8047

6898

*)

8048

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

6899

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8049

6900

;;

8050

6901

esac

8051

6902

fi

8052

6903

else

8053

6904

eval flag=\"$hardcode_libdir_flag_spec\"

8054

func_append dep_rpath " $flag"

6905

dep_rpath="$dep_rpath $flag"

8055

6906

fi

8056

6907

elif test -n "$runpath_var"; then

8057

6908

case "$perm_rpath " in

8058

6909

*" $libdir "*) ;;

8059

*) func_apped perm_rpath " $libdir" ;;

6910

*) perm_rpath="$perm_rpath $libdir" ;;

8060

6911

esac

8061

6912

fi

8062

6913

done

8074

6925

# We should set the runpath_var.

8075

6926

rpath=

8076

6927

for dir in $perm_rpath; do

8077

func_append rpath "$dir:"

6928

rpath="$rpath$dir:"

8078

6929

done

8079

6930

eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"

8080

6931

fi

8082

6933

fi

8083

6934

8084

6935

shlibpath="$finalize_shlibpath"

8085

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

6936

test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

8086

6937

if test -n "$shlibpath"; then

8087

6938

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

8088

6939

fi

8108

6959

linknames=

8109

6960

for link

8110

6961

do

8111

func_append linknames " $link"

6962

linknames="$linknames $link"

8112

6963

done

8113

6964

8114

6965

# Use standard objects if they are pic

8115

test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`

6966

test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

8116

6967

test "X$libobjs" = "X " && libobjs=

8117

6968

8118

6969

delfiles=

8119

6970

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8120

6971

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

8121

6972

export_symbols="$output_objdir/$libname.uexp"

8122

func_append delfiles " $export_symbols"

6973

delfiles="$delfiles $export_symbols"

8123

6974

fi

8124

6975

8125

6976

orig_export_symbols=

8150

7001

$opt_dry_run || $RM $export_symbols

8151

7002

cmds=$export_symbols_cmds

8152

7003

save_ifs="$IFS"; IFS='~'

8153

for cmd1 in $cmds; do

7004

for cmd in $cmds; do

8154

7005

IFS="$save_ifs"

8155

# Take the normal branch if the nm_file_list_spec branch

8156

# doesn't work or if tool conversion is not needed.

8157

case $nm_file_list_spec~$to_tool_file_cmd in

8158

*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)

8159

try_normal_branch=yes

8160

eval cmd=\"$cmd1\"

8161

func_len " $cmd"

8162

len=$func_len_result

8163

;;

8164

*)

8165

try_normal_branch=no

8166

;;

8167

esac

8168

if test "$try_normal_branch" = yes \

8169

&& { test "$len" -lt "$max_cmd_len" \

8170

|| test "$max_cmd_len" -le -1; }

8171

then

8172

func_show_eval "$cmd" 'exit $?'

8173

skipped_export=false

8174

elif test -n "$nm_file_list_spec"; then

8175

func_basename "$output"

8176

output_la=$func_basename_result

8177

save_libobjs=$libobjs

8178

save_output=$output

8179

output=${output_objdir}/${output_la}.nm

8180

func_to_tool_file "$output"

8181

libobjs=$nm_file_list_spec$func_to_tool_file_result

8182

func_append delfiles " $output"

8183

func_verbose "creating $NM input file list: $output"

8184

for obj in $save_libobjs; do

8185

func_to_tool_file "$obj"

8186

$ECHO "$func_to_tool_file_result"

8187

done > "$output"

8188

eval cmd=\"$cmd1\"

8189

func_show_eval "$cmd" 'exit $?'

8190

output=$save_output

8191

libobjs=$save_libobjs

7006

eval cmd=\"$cmd\"

7007

func_len " $cmd"

7008

len=$func_len_result

7009

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

7010

func_show_eval "$cmd" 'exit $?'

8192

7011

skipped_export=false

8193

7012

else

8194

7013

# The command line is too long to execute in one step.

8210

7029

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8211

7030

tmp_export_symbols="$export_symbols"

8212

7031

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8213

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

7032

$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

8214

7033

fi

8215

7034

8216

7035

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

8222

7041

# global variables. join(1) would be nice here, but unfortunately

8223

7042

# isn't a blessed tool.

8224

7043

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8225

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

7044

delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8226

7045

export_symbols=$output_objdir/$libname.def

8227

7046

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8228

7047

fi

8232

7051

case " $convenience " in

8233

7052

*" $test_deplib "*) ;;

8234

7053

*)

8235

func_append tmp_deplibs " $test_deplib"

7054

tmp_deplibs="$tmp_deplibs $test_deplib"

8236

7055

;;

8237

7056

esac

8238

7057

done

8252

7071

test "X$libobjs" = "X " && libobjs=

8253

7072

else

8254

7073

gentop="$output_objdir/${outputname}x"

8255

func_append generated " $gentop"

7074

generated="$generated $gentop"

8256

7075

8257

7076

func_extract_archives $gentop $convenience

8258

func_append libobjs " $func_extract_archives_result"

7077

libobjs="$libobjs $func_extract_archives_result"

8259

7078

test "X$libobjs" = "X " && libobjs=

8260

7079

fi

8261

7080

fi

8262

7081

8263

7082

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

8264

7083

eval flag=\"$thread_safe_flag_spec\"

8265

func_append linker_flags " $flag"

7084

linker_flags="$linker_flags $flag"

8266

7085

fi

8267

7086

8268

7087

# Make a backup of the uninstalled library when relinking

8269

if test "$opt_mode" = relink; then

7088

if test "$mode" = relink; then

8270

7089

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

8271

7090

fi

8272

7091

8311

7130

save_libobjs=$libobjs

8312

7131

fi

8313

7132

save_output=$output

8314

func_basename "$output"

8315

output_la=$func_basename_result

7133

output_la=`$ECHO "X$output" | $Xsed -e "$basename"`

8316

7134

8317

7135

# Clear the reloadable object creation command queue and

8318

7136

# initialize k to one.

8325

7143

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

8326

7144

output=${output_objdir}/${output_la}.lnkscript

8327

7145

func_verbose "creating GNU ld script: $output"

8328

echo 'INPUT (' > $output

7146

$ECHO 'INPUT (' > $output

8329

7147

for obj in $save_libobjs

8330

7148

do

8331

func_to_tool_file "$obj"

8332

$ECHO "$func_to_tool_file_result" >> $output

7149

$ECHO "$obj" >> $output

8333

7150

done

8334

echo ')' >> $output

8335

func_append delfiles " $output"

8336

func_to_tool_file "$output"

8337

output=$func_to_tool_file_result

7151

$ECHO ')' >> $output

7152

delfiles="$delfiles $output"

8338

7153

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

8339

7154

output=${output_objdir}/${output_la}.lnk

8340

7155

func_verbose "creating linker input file list: $output"

8348

7163

fi

8349

7164

for obj

8350

7165

do

8351

func_to_tool_file "$obj"

8352

$ECHO "$func_to_tool_file_result" >> $output

7166

$ECHO "$obj" >> $output

8353

7167

done

8354

func_append delfiles " $output"

8355

func_to_tool_file "$output"

8356

output=$firstobj\"$file_list_spec$func_to_tool_file_result\"

7168

delfiles="$delfiles $output"

7169

output=$firstobj\"$file_list_spec$output\"

8357

7170

else

8358

7171

if test -n "$save_libobjs"; then

8359

7172

func_verbose "creating reloadable object files..."

8377

7190

# command to the queue.

8378

7191

if test "$k" -eq 1 ; then

8379

7192

# The first file doesn't have a previous command to add.

8380

reload_objs=$objlist

8381

eval concat_cmds=\"$reload_cmds\"

7193

eval concat_cmds=\"$reload_cmds $objlist $last_robj\"

8382

7194

else

8383

7195

# All subsequent reloadable object files will link in

8384

7196

# the last one created.

8385

reload_objs="$objlist $last_robj"

8386

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

7197

eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"

8387

7198

fi

8388

7199

last_robj=$output_objdir/$output_la-${k}.$objext

8389

7200

func_arith $k + 1

8390

7201

k=$func_arith_result

8391

7202

output=$output_objdir/$output_la-${k}.$objext

8392

objlist=" $obj"

7203

objlist=$obj

8393

7204

func_len " $last_robj"

8394

7205

func_arith $len0 + $func_len_result

8395

7206

len=$func_arith_result

8399

7210

# reloadable object file. All subsequent reloadable object

8400

7211

# files will link in the last one created.

8401

7212

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

8402

reload_objs="$objlist $last_robj"

8403

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

7213

eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"

8404

7214

if test -n "$last_robj"; then

8405

7215

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

8406

7216

fi

8407

func_append delfiles " $output"

7217

delfiles="$delfiles $output"

8408

7218

8409

7219

else

8410

7220

output=

8438

7248

lt_exit=$?

8439

7249

8440

7250

# Restore the uninstalled library and exit

8441

if test "$opt_mode" = relink; then

7251

if test "$mode" = relink; then

8442

7252

( cd "$output_objdir" && \

8443

7253

$RM "${realname}T" && \

8444

7254

$MV "${realname}U" "$realname" )

8459

7269

if test -n "$export_symbols" && test -n "$include_expsyms"; then

8460

7270

tmp_export_symbols="$export_symbols"

8461

7271

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

8462

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

7272

$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'

8463

7273

fi

8464

7274

8465

7275

if test -n "$orig_export_symbols"; then

8471

7281

# global variables. join(1) would be nice here, but unfortunately

8472

7282

# isn't a blessed tool.

8473

7283

$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,$.*$$[ \,].*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter

8474

func_append delfiles " $export_symbols $output_objdir/$libname.filter"

7284

delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"

8475

7285

export_symbols=$output_objdir/$libname.def

8476

7286

$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols

8477

7287

fi

8512

7322

# Add any objects from preloaded convenience libraries

8513

7323

if test -n "$dlprefiles"; then

8514

7324

gentop="$output_objdir/${outputname}x"

8515

func_append generated " $gentop"

7325

generated="$generated $gentop"

8516

7326

8517

7327

func_extract_archives $gentop $dlprefiles

8518

func_append libobjs " $func_extract_archives_result"

7328

libobjs="$libobjs $func_extract_archives_result"

8519

7329

test "X$libobjs" = "X " && libobjs=

8520

7330

fi

8521

7331

8531

7341

lt_exit=$?

8532

7342

8533

7343

# Restore the uninstalled library and exit

8534

if test "$opt_mode" = relink; then

7344

if test "$mode" = relink; then

8535

7345

( cd "$output_objdir" && \

8536

7346

$RM "${realname}T" && \

8537

7347

$MV "${realname}U" "$realname" )

8543

7353

IFS="$save_ifs"

8544

7354

8545

7355

# Restore the uninstalled library and exit

8546

if test "$opt_mode" = relink; then

7356

if test "$mode" = relink; then

8547

7357

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

8548

7358

8549

7359

if test -n "$convenience"; then

8624

7434

if test -n "$convenience"; then

8625

7435

if test -n "$whole_archive_flag_spec"; then

8626

7436

eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"

8627

reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`

7437

reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`

8628

7438

else

8629

7439

gentop="$output_objdir/${obj}x"

8630

func_append generated " $gentop"

7440

generated="$generated $gentop"

8631

7441

8632

7442

func_extract_archives $gentop $convenience

8633

7443

reload_conv_objs="$reload_objs $func_extract_archives_result"

8634

7444

fi

8635

7445

fi

8636

7446

8637

# If we're not building shared, we need to use non_pic_objs

8638

test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

8639

8640

7447

# Create the old-style object.

8641

reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

7448

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

8642

7449

8643

7450

output="$obj"

8644

7451

func_execute_cmds "$reload_cmds" 'exit $?'

8698

7505

case $host in

8699

7506

*-*-rhapsody* | *-*-darwin1.[012])

8700

7507

# On Rhapsody replace the C library is the System framework

8701

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`

8702

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`

7508

compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

7509

finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`

8703

7510

;;

8704

7511

esac

8705

7512

8710

7517

if test "$tagname" = CXX ; then

8711

7518

case ${MACOSX_DEPLOYMENT_TARGET-10.0} in

8712

7519

10.[0123])

8713

func_append compile_command " ${wl}-bind_at_load"

8714

func_append finalize_command " ${wl}-bind_at_load"

7520

compile_command="$compile_command ${wl}-bind_at_load"

7521

finalize_command="$finalize_command ${wl}-bind_at_load"

8715

7522

;;

8716

7523

esac

8717

7524

fi

8718

7525

# Time to change all our "foo.ltframework" stuff back to "-framework foo"

8719

compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

8720

finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

7526

compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

7527

finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% $[^ $]*$.ltframework% -framework \1%g'`

8721

7528

;;

8722

7529

esac

8723

7530

8731

7538

*)

8732

7539

case " $compile_deplibs " in

8733

7540

*" -L$path/$objdir "*)

8734

func_append new_libs " -L$path/$objdir" ;;

7541

new_libs="$new_libs -L$path/$objdir" ;;

8735

7542

esac

8736

7543

;;

8737

7544

esac

8741

7548

-L*)

8742

7549

case " $new_libs " in

8743

7550

*" $deplib "*) ;;

8744

*) func_append new_libs " $deplib" ;;

7551

*) new_libs="$new_libs $deplib" ;;

8745

7552

esac

8746

7553

;;

8747

*) func_append new_libs " $deplib" ;;

7554

*) new_libs="$new_libs $deplib" ;;

8748

7555

esac

8749

7556

done

8750

7557

compile_deplibs="$new_libs"

8751

7558

8752

7559

8753

func_append compile_command " $compile_deplibs"

8754

func_append finalize_command " $finalize_deplibs"

7560

compile_command="$compile_command $compile_deplibs"

7561

finalize_command="$finalize_command $finalize_deplibs"

8755

7562

8756

7563

if test -n "$rpath$xrpath"; then

8757

7564

# If the user specified any rpath flags, then add them.

8759

7566

# This is the magic to use -rpath.

8760

7567

case "$finalize_rpath " in

8761

7568

*" $libdir "*) ;;

8762

*) func_append finalize_rpath " $libdir" ;;

7569

*) finalize_rpath="$finalize_rpath $libdir" ;;

8763

7570

esac

8764

7571

done

8765

7572

fi

8778

7585

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8779

7586

;;

8780

7587

*)

8781

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

7588

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8782

7589

;;

8783

7590

esac

8784

7591

fi

8785

7592

else

8786

7593

eval flag=\"$hardcode_libdir_flag_spec\"

8787

func_append rpath " $flag"

7594

rpath="$rpath $flag"

8788

7595

fi

8789

7596

elif test -n "$runpath_var"; then

8790

7597

case "$perm_rpath " in

8791

7598

*" $libdir "*) ;;

8792

*) func_append perm_rpath " $libdir" ;;

7599

*) perm_rpath="$perm_rpath $libdir" ;;

8793

7600

esac

8794

7601

fi

8795

7602

case $host in

8798

7605

case :$dllsearchpath: in

8799

7606

*":$libdir:"*) ;;

8800

7607

::) dllsearchpath=$libdir;;

8801

*) func_append dllsearchpath ":$libdir";;

7608

*) dllsearchpath="$dllsearchpath:$libdir";;

8802

7609

esac

8803

7610

case :$dllsearchpath: in

8804

7611

*":$testbindir:"*) ;;

8805

7612

::) dllsearchpath=$testbindir;;

8806

*) func_append dllsearchpath ":$testbindir";;

7613

*) dllsearchpath="$dllsearchpath:$testbindir";;

8807

7614

esac

8808

7615

;;

8809

7616

esac

8829

7636

*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

8830

7637

;;

8831

7638

*)

8832

func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"

7639

hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

8833

7640

;;

8834

7641

esac

8835

7642

fi

8836

7643

else

8837

7644

eval flag=\"$hardcode_libdir_flag_spec\"

8838

func_append rpath " $flag"

7645

rpath="$rpath $flag"

8839

7646

fi

8840

7647

elif test -n "$runpath_var"; then

8841

7648

case "$finalize_perm_rpath " in

8842

7649

*" $libdir "*) ;;

8843

*) func_append finalize_perm_rpath " $libdir" ;;

7650

*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;

8844

7651

esac

8845

7652

fi

8846

7653

done

8854

7661

8855

7662

if test -n "$libobjs" && test "$build_old_libs" = yes; then

8856

7663

# Transform all the library objects into standard objects.

8857

compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

8858

finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`

7664

compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

7665

finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`

8859

7666

fi

8860

7667

8861

7668

func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

8867

7674

8868

7675

wrappers_required=yes

8869

7676

case $host in

8870

*cegcc* | *mingw32ce*)

8871

# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.

8872

wrappers_required=no

8873

;;

8874

7677

*cygwin* | *mingw* )

8875

7678

if test "$build_libtool_libs" != yes; then

8876

7679

wrappers_required=no

8877

7680

fi

8878

7681

;;

7682

*cegcc)

7683

# Disable wrappers for cegcc, we are cross compiling anyway.

7684

wrappers_required=no

7685

;;

8879

7686

*)

8880

7687

if test "$need_relink" = no || test "$build_libtool_libs" != yes; then

8881

7688

wrappers_required=no

8884

7691

esac

8885

7692

if test "$wrappers_required" = no; then

8886

7693

# Replace the output file specification.

8887

compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

7694

compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

8888

7695

link_command="$compile_command$compile_rpath"

8889

7696

8890

7697

# We have no uninstalled library dependencies, so finalize right now.

8891

7698

exit_status=0

8892

7699

func_show_eval "$link_command" 'exit_status=$?'

8893

7700

8894

if test -n "$postlink_cmds"; then

8895

func_to_tool_file "$output"

8896

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8897

func_execute_cmds "$postlink_cmds" 'exit $?'

8898

fi

8899

8900

7701

# Delete the generated files.

8901

7702

if test -f "$output_objdir/${outputname}S.${objext}"; then

8902

7703

func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'

8919

7720

# We should set the runpath_var.

8920

7721

rpath=

8921

7722

for dir in $perm_rpath; do

8922

func_append rpath "$dir:"

7723

rpath="$rpath$dir:"

8923

7724

done

8924

7725

compile_var="$runpath_var=\"$rpath\$$runpath_var\" "

8925

7726

fi

8927

7728

# We should set the runpath_var.

8928

7729

rpath=

8929

7730

for dir in $finalize_perm_rpath; do

8930

func_append rpath "$dir:"

7731

rpath="$rpath$dir:"

8931

7732

done

8932

7733

finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "

8933

7734

fi

8937

7738

# We don't need to create a wrapper script.

8938

7739

link_command="$compile_var$compile_command$compile_rpath"

8939

7740

# Replace the output file specification.

8940

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`

7741

link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`

8941

7742

# Delete the old output file.

8942

7743

$opt_dry_run || $RM $output

8943

7744

# Link the executable and exit

8944

7745

func_show_eval "$link_command" 'exit $?'

8945

8946

if test -n "$postlink_cmds"; then

8947

func_to_tool_file "$output"

8948

postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`

8949

func_execute_cmds "$postlink_cmds" 'exit $?'

8950

fi

8951

8952

7746

exit $EXIT_SUCCESS

8953

7747

fi

8954

7748

8963

7757

if test "$fast_install" != no; then

8964

7758

link_command="$finalize_var$compile_command$finalize_rpath"

8965

7759

if test "$fast_install" = yes; then

8966

relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`

7760

relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`

8967

7761

else

8968

7762

# fast_install is set to needless

8969

7763

relink_command=

8975

7769

fi

8976

7770

8977

7771

# Replace the output file specification.

8978

link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

7772

link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

8979

7773

8980

7774

# Delete the old output files.

8981

7775

$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

8982

7776

8983

7777

func_show_eval "$link_command" 'exit $?'

8984

7778

8985

if test -n "$postlink_cmds"; then

8986

func_to_tool_file "$output_objdir/$outputname"

8987

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'`

8988

func_execute_cmds "$postlink_cmds" 'exit $?'

8989

fi

8990

8991

7779

# Now create the wrapper script.

8992

7780

func_verbose "creating $output"

8993

7781

9005

7793

fi

9006

7794

done

9007

7795

relink_command="(cd `pwd`; $relink_command)"

9008

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

7796

relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

7797

fi

7798

7799

# Quote $ECHO for shipping.

7800

if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then

7801

case $progpath in

7802

[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;

7803

*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;

7804

esac

7805

qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`

7806

else

7807

qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`

9009

7808

fi

9010

7809

9011

7810

# Only actually do things if not in dry run mode.

9085

7884

else

9086

7885

oldobjs="$old_deplibs $non_pic_objects"

9087

7886

if test "$preload" = yes && test -f "$symfileobj"; then

9088

func_append oldobjs " $symfileobj"

7887

oldobjs="$oldobjs $symfileobj"

9089

7888

fi

9090

7889

fi

9091

7890

addlibs="$old_convenience"

9093

7892

9094

7893

if test -n "$addlibs"; then

9095

7894

gentop="$output_objdir/${outputname}x"

9096

func_append generated " $gentop"

7895

generated="$generated $gentop"

9097

7896

9098

7897

func_extract_archives $gentop $addlibs

9099

func_append oldobjs " $func_extract_archives_result"

7898

oldobjs="$oldobjs $func_extract_archives_result"

9100

7899

fi

9101

7900

9102

7901

# Do each command in the archive commands.

9107

7906

# Add any objects from preloaded convenience libraries

9108

7907

if test -n "$dlprefiles"; then

9109

7908

gentop="$output_objdir/${outputname}x"

9110

func_append generated " $gentop"

7909

generated="$generated $gentop"

9111

7910

9112

7911

func_extract_archives $gentop $dlprefiles

9113

func_append oldobjs " $func_extract_archives_result"

7912

oldobjs="$oldobjs $func_extract_archives_result"

9114

7913

fi

9115

7914

9116

7915

# POSIX demands no paths to be encoded in archives. We have

9126

7925

done | sort | sort -uc >/dev/null 2>&1); then

9127

7926

:

9128

7927

else

9129

echo "copying selected object files to avoid basename conflicts..."

7928

$ECHO "copying selected object files to avoid basename conflicts..."

9130

7929

gentop="$output_objdir/${outputname}x"

9131

func_append generated " $gentop"

7930

generated="$generated $gentop"

9132

7931

func_mkdir_p "$gentop"

9133

7932

save_oldobjs=$oldobjs

9134

7933

oldobjs=

9152

7951

esac

9153

7952

done

9154

7953

func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"

9155

func_append oldobjs " $gentop/$newobj"

7954

oldobjs="$oldobjs $gentop/$newobj"

9156

7955

;;

9157

*) func_append oldobjs " $obj" ;;

7956

*) oldobjs="$oldobjs $obj" ;;

9158

7957

esac

9159

7958

done

9160

7959

fi

9164

7963

len=$func_len_result

9165

7964

if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

9166

7965

cmds=$old_archive_cmds

9167

elif test -n "$archiver_list_spec"; then

9168

func_verbose "using command file archive linking..."

9169

for obj in $oldobjs

9170

do

9171

func_to_tool_file "$obj"

9172

$ECHO "$func_to_tool_file_result"

9173

done > $output_objdir/$libname.libcmd

9174

func_to_tool_file "$output_objdir/$libname.libcmd"

9175

oldobjs=" $archiver_list_spec$func_to_tool_file_result"

9176

cmds=$old_archive_cmds

9177

7966

else

9178

7967

# the command line is too long to link in one step, link in parts

9179

7968

func_verbose "using piecewise archive linking..."

9247

8036

done

9248

8037

# Quote the link command for shipping.

9249

8038

relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"

9250

relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`

8039

relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`

9251

8040

if test "$hardcode_automatic" = yes ; then

9252

8041

relink_command=

9253

8042

fi

9270

8059

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

9271

8060

test -z "$libdir" && \

9272

8061

func_fatal_error "\`$deplib' is not a valid libtool archive"

9273

func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"

9274

;;

9275

-L*)

9276

func_stripname -L '' "$deplib"

9277

func_replace_sysroot "$func_stripname_result"

9278

func_append newdependency_libs " -L$func_replace_sysroot_result"

9279

;;

9280

-R*)

9281

func_stripname -R '' "$deplib"

9282

func_replace_sysroot "$func_stripname_result"

9283

func_append newdependency_libs " -R$func_replace_sysroot_result"

9284

;;

9285

*) func_append newdependency_libs " $deplib" ;;

8062

newdependency_libs="$newdependency_libs $libdir/$name"

8063

;;

8064

*) newdependency_libs="$newdependency_libs $deplib" ;;

9286

8065

esac

9287

8066

done

9288

8067

dependency_libs="$newdependency_libs"

9296

8075

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9297

8076

test -z "$libdir" && \

9298

8077

func_fatal_error "\`$lib' is not a valid libtool archive"

9299

func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"

8078

newdlfiles="$newdlfiles $libdir/$name"

9300

8079

;;

9301

*) func_append newdlfiles " $lib" ;;

8080

*) newdlfiles="$newdlfiles $lib" ;;

9302

8081

esac

9303

8082

done

9304

8083

dlfiles="$newdlfiles"

9315

8094

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`

9316

8095

test -z "$libdir" && \

9317

8096

func_fatal_error "\`$lib' is not a valid libtool archive"

9318

func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"

8097

newdlprefiles="$newdlprefiles $libdir/$name"

9319

8098

;;

9320

8099

esac

9321

8100

done

9327

8106

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9328

8107

*) abs=`pwd`"/$lib" ;;

9329

8108

esac

9330

func_append newdlfiles " $abs"

8109

newdlfiles="$newdlfiles $abs"

9331

8110

done

9332

8111

dlfiles="$newdlfiles"

9333

8112

newdlprefiles=

9336

8115

[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;

9337

8116

*) abs=`pwd`"/$lib" ;;

9338

8117

esac

9339

func_append newdlprefiles " $abs"

8118

newdlprefiles="$newdlprefiles $abs"

9340

8119

done

9341

8120

dlprefiles="$newdlprefiles"

9342

8121

fi

9343

8122

$RM $output

9344

8123

# place dlname in correct position for cygwin

9345

# In fact, it would be nice if we could use this code for all target

9346

# systems that can't hard-code library paths into their executables

9347

# and that have no shared library path variable independent of PATH,

9348

# but it turns out we can't easily determine that from inspecting

9349

# libtool variables, so we have to hard-code the OSs to which it

9350

# applies here; at the moment, that means platforms that use the PE

9351

# object format with DLL files. See the long comment at the top of

9352

# tests/bindir.at for full details.

9353

8124

tdlname=$dlname

9354

8125

case $host,$output,$installed,$module,$dlname in

9355

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)

9356

# If a -bindir argument was supplied, place the dll there.

9357

if test "x$bindir" != x ;

9358

then

9359

func_relative_path "$install_libdir" "$bindir"

9360

tdlname=$func_relative_path_result$dlname

9361

else

9362

# Otherwise fall back on heuristic.

9363

tdlname=../bin/$dlname

9364

fi

9365

;;

8126

*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;

9366

8127

esac

9367

8128

$ECHO > $output "\

9368

8129

# $outputname - a libtool library file

9421

8182

exit $EXIT_SUCCESS

9422

8183

}

9423

8184

9424

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&

8185

{ test "$mode" = link || test "$mode" = relink; } &&

9425

8186

func_mode_link ${1+"$@"}

9426

8187

9427

8188

9441

8202

for arg

9442

8203

do

9443

8204

case $arg in

9444

-f) func_append RM " $arg"; rmforce=yes ;;

9445

-*) func_append RM " $arg" ;;

9446

*) func_append files " $arg" ;;

8205

-f) RM="$RM $arg"; rmforce=yes ;;

8206

-*) RM="$RM $arg" ;;

8207

*) files="$files $arg" ;;

9447

8208

esac

9448

8209

done

9449

8210

9452

8213

9453

8214

rmdirs=

9454

8215

8216

origobjdir="$objdir"

9455

8217

for file in $files; do

9456

8218

func_dirname "$file" "" "."

9457

8219

dir="$func_dirname_result"

9458

8220

if test "X$dir" = X.; then

9459

odir="$objdir"

8221

objdir="$origobjdir"

9460

8222

else

9461

odir="$dir/$objdir"

8223

objdir="$dir/$origobjdir"

9462

8224

fi

9463

8225

func_basename "$file"

9464

8226

name="$func_basename_result"

9465

test "$opt_mode" = uninstall && odir="$dir"

8227

test "$mode" = uninstall && objdir="$dir"

9466

8228

9467

# Remember odir for removal later, being careful to avoid duplicates

9468

if test "$opt_mode" = clean; then

8229

# Remember objdir for removal later, being careful to avoid duplicates

8230

if test "$mode" = clean; then

9469

8231

case " $rmdirs " in

9470

*" $odir "*) ;;

9471

*) func_append rmdirs " $odir" ;;

8232

*" $objdir "*) ;;

8233

*) rmdirs="$rmdirs $objdir" ;;

9472

8234

esac

9473

8235

fi

9474

8236

9494

8256

9495

8257

# Delete the libtool libraries and symlinks.

9496

8258

for n in $library_names; do

9497

func_append rmfiles " $odir/$n"

8259

rmfiles="$rmfiles $objdir/$n"

9498

8260

done

9499

test -n "$old_library" && func_append rmfiles " $odir/$old_library"

8261

test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"

9500

8262

9501

case "$opt_mode" in

8263

case "$mode" in

9502

8264

clean)

9503

case " $library_names " in

8265

case " $library_names " in

8266

# " " in the beginning catches empty $dlname

9504

8267

*" $dlname "*) ;;

9505

*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;

8268

*) rmfiles="$rmfiles $objdir/$dlname" ;;

9506

8269

esac

9507

test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"

8270

test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"

9508

8271

;;

9509

8272

uninstall)

9510

8273

if test -n "$library_names"; then

9532

8295

# Add PIC object to the list of files to remove.

9533

8296

if test -n "$pic_object" &&

9534

8297

test "$pic_object" != none; then

9535

func_append rmfiles " $dir/$pic_object"

8298

rmfiles="$rmfiles $dir/$pic_object"

9536

8299

fi

9537

8300

9538

8301

# Add non-PIC object to the list of files to remove.

9539

8302

if test -n "$non_pic_object" &&

9540

8303

test "$non_pic_object" != none; then

9541

func_append rmfiles " $dir/$non_pic_object"

8304

rmfiles="$rmfiles $dir/$non_pic_object"

9542

8305

fi

9543

8306

fi

9544

8307

;;

9545

8308

9546

8309

*)

9547

if test "$opt_mode" = clean ; then

8310

if test "$mode" = clean ; then

9548

8311

noexename=$name

9549

8312

case $file in

9550

8313

*.exe)

9554

8317

noexename=$func_stripname_result

9555

8318

# $file with .exe has already been added to rmfiles,

9556

8319

# add $file without .exe

9557

func_append rmfiles " $file"

8320

rmfiles="$rmfiles $file"

9558

8321

;;

9559

8322

esac

9560

8323

# Do a test to see if this is a libtool program.

9563

8326

func_ltwrapper_scriptname "$file"

9564

8327

relink_command=

9565

8328

func_source $func_ltwrapper_scriptname_result

9566

func_append rmfiles " $func_ltwrapper_scriptname_result"

8329

rmfiles="$rmfiles $func_ltwrapper_scriptname_result"

9567

8330

else

9568

8331

relink_command=

9569

8332

func_source $dir/$noexename

9571

8334

9572

8335

# note $name still contains .exe if it was in $file originally

9573

8336

# as does the version of $file that was added into $rmfiles

9574

func_append rmfiles " $odir/$name $odir/${name}S.${objext}"

8337

rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"

9575

8338

if test "$fast_install" = yes && test -n "$relink_command"; then

9576

func_append rmfiles " $odir/lt-$name"

8339

rmfiles="$rmfiles $objdir/lt-$name"

9577

8340

fi

9578

8341

if test "X$noexename" != "X$name" ; then

9579

func_append rmfiles " $odir/lt-${noexename}.c"

8342

rmfiles="$rmfiles $objdir/lt-${noexename}.c"

9580

8343

fi

9581

8344

fi

9582

8345

fi

9584

8347

esac

9585

8348

func_show_eval "$RM $rmfiles" 'exit_status=1'

9586

8349

done

8350

objdir="$origobjdir"

9587

8351

9588

8352

# Try to remove the ${objdir}s in the directories where we deleted files

9589

8353

for dir in $rmdirs; do

9595

8359

exit $exit_status

9596

8360

}

9597

8361

9598

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&

8362

{ test "$mode" = uninstall || test "$mode" = clean; } &&

9599

8363

func_mode_uninstall ${1+"$@"}

9600

8364

9601

test -z "$opt_mode" && {

8365

test -z "$mode" && {

9602

8366

help="$generic_help"

9603

8367

func_fatal_help "you must specify a MODE"

9604

8368

}

9605

8369

9606

8370

test -z "$exec_cmd" && \

9607

func_fatal_help "invalid operation mode \`$opt_mode'"

8371

func_fatal_help "invalid operation mode \`$mode'"

9608

8372

9609

8373

if test -n "$exec_cmd"; then

9610

8374

eval exec "$exec_cmd"