~ubuntu-branches/debian/sid/cryptsetup/sid : revision 22

1

# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-

2

#

3

4

# 2006, 2007, 2008 Free Software Foundation, Inc.

4

# 2006, 2007, 2008, 2009, 2010, 2011 Free Software

5

# Foundation, Inc.

5

6

# Written by Gordon Matzigkeit, 1996

6

7

#

7

8

# This file is free software; the Free Software Foundation gives

10

11

12

m4_define([_LT_COPYING], [dnl

12

13

# 2006, 2007, 2008 Free Software Foundation, Inc.

14

# 2006, 2007, 2008, 2009, 2010, 2011 Free Software

15

# Foundation, Inc.

14

16

# Written by Gordon Matzigkeit, 1996

15

17

#

16

18

# This file is part of GNU Libtool.

37

39

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

38

40

])

39

41

40

# serial 56 LT_INIT

42

# serial 57 LT_INIT

41

43

42

44

43

45

# LT_PREREQ(VERSION)

66

68

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

67

69

AC_DEFUN([LT_INIT],

68

70

[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT

71

AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl

69

72

AC_BEFORE([$0], [LT_LANG])dnl

70

73

AC_BEFORE([$0], [LT_OUTPUT])dnl

71

74

AC_BEFORE([$0], [LTDL_INIT])dnl

82

85

AC_REQUIRE([LTOBSOLETE_VERSION])dnl

83

86

m4_require([_LT_PROG_LTMAIN])dnl

84

87

88

_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])

89

85

90

dnl Parse OPTIONS

86

91

_LT_SET_OPTIONS([$0], [$1])

87

92

118

123

*) break;;

119

124

esac

120

125

done

121

cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

126

cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`

122

127

])

123

128

124

129

138

143

m4_defun([_LT_SETUP],

139

144

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

140

145

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

146

AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl

147

AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl

148

149

_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl

150

dnl

141

151

_LT_DECL([], [host_alias], [0], [The host system])dnl

142

152

_LT_DECL([], [host], [0])dnl

143

153

_LT_DECL([], [host_os], [0])dnl

160

170

dnl

161

171

m4_require([_LT_FILEUTILS_DEFAULTS])dnl

162

172

m4_require([_LT_CHECK_SHELL_FEATURES])dnl

173

m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl

163

174

m4_require([_LT_CMD_RELOAD])dnl

164

175

m4_require([_LT_CHECK_MAGIC_METHOD])dnl

176

m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl

165

177

m4_require([_LT_CMD_OLD_ARCHIVE])dnl

166

178

m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl

179

m4_require([_LT_WITH_SYSROOT])dnl

167

180

168

181

_LT_CONFIG_LIBTOOL_INIT([

169

182

# See if we are running on zsh, and set the options which allow our

179

192

_LT_CHECK_OBJDIR

180

193

181

194

m4_require([_LT_TAG_COMPILER])dnl

182

_LT_PROG_ECHO_BACKSLASH

183

195

184

196

case $host_os in

185

197

aix3*)

193

205

;;

194

206

esac

195

207

196

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

197

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

198

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

199

200

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

201

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

202

203

# Sed substitution to delay expansion of an escaped shell variable in a

204

# double_quote_subst'ed string.

205

delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

206

207

# Sed substitution to delay expansion of an escaped single quote.

208

delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'

209

210

# Sed substitution to avoid accidental globbing in evaled expressions

211

no_glob_subst='s/\*/\\\*/g'

212

213

208

# Global variables:

214

209

ofile=libtool

215

210

can_build_shared=yes

250

245

])# _LT_SETUP

251

246

252

247

248

# _LT_PREPARE_SED_QUOTE_VARS

249

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

250

# Define a few sed substitution that help us do robust quoting.

251

m4_defun([_LT_PREPARE_SED_QUOTE_VARS],

252

[# Backslashify metacharacters that are still active within

253

# double-quoted strings.

254

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

255

256

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

257

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

258

259

# Sed substitution to delay expansion of an escaped shell variable in a

260

# double_quote_subst'ed string.

261

delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

262

263

# Sed substitution to delay expansion of an escaped single quote.

264

delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'

265

266

# Sed substitution to avoid accidental globbing in evaled expressions

267

no_glob_subst='s/\*/\\\*/g'

268

])

269

253

270

# _LT_PROG_LTMAIN

254

271

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

255

272

# Note that this code is called both from `configure', and `config.status'

408

425

# declaration there will have the same value as in `configure'. VARNAME

409

426

# must have a single quote delimited value for this to work.

410

427

m4_define([_LT_CONFIG_STATUS_DECLARE],

411

[$1='`$ECHO "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])

428

[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])

412

429

413

430

414

431

# _LT_CONFIG_STATUS_DECLARATIONS

418

435

# embedded single quotes properly. In configure, this macro expands

419

436

# each variable declared with _LT_DECL (and _LT_TAGDECL) into:

420

437

#

421

# <var>='`$ECHO "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'

438

# <var>='`$ECHO "$<var>" | $SED "$delay_single_quote_subst"`'

422

439

m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],

423

440

[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),

424

441

[m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])

517

534

LTCFLAGS='$LTCFLAGS'

518

535

compiler='$compiler_DEFAULT'

519

536

537

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

538

func_fallback_echo ()

539

{

540

eval 'cat <<_LTECHO_EOF

541

\$[]1

542

_LTECHO_EOF'

543

}

544

520

545

# Quote evaled strings.

521

546

for var in lt_decl_all_varnames([[ \

522

547

]], lt_decl_quote_varnames); do

523

case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in

548

case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in

524

549

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

525

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""

550

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""

526

551

;;

527

552

*)

528

553

eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""

533

558

# Double-quote double-evaled strings.

534

559

for var in lt_decl_all_varnames([[ \

535

560

]], lt_decl_dquote_varnames); do

536

case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in

561

case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in

537

562

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

538

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""

563

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""

539

564

;;

540

565

*)

541

566

eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""

543

568

esac

544

569

done

545

570

546

# Fix-up fallback echo if it was mangled by the above quoting rules.

547

case \$lt_ECHO in

548

*'\\\[$]0 --fallback-echo"')dnl "

549

lt_ECHO=\`\$ECHO "X\$lt_ECHO" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`

550

;;

551

esac

552

553

571

_LT_OUTPUT_LIBTOOL_INIT

554

572

])

555

573

574

# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])

575

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

576

# Generate a child script FILE with all initialization necessary to

577

# reuse the environment learned by the parent script, and make the

578

# file executable. If COMMENT is supplied, it is inserted after the

579

# `#!' sequence but before initialization text begins. After this

580

# macro, additional text can be appended to FILE to form the body of

581

# the child script. The macro ends with non-zero status if the

582

# file could not be fully written (such as if the disk is full).

583

m4_ifdef([AS_INIT_GENERATED],

584

[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],

585

[m4_defun([_LT_GENERATED_FILE_INIT],

586

[m4_require([AS_PREPARE])]dnl

587

[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl

588

[lt_write_fail=0

589

cat >$1 <<_ASEOF || lt_write_fail=1

590

#! $SHELL

591

# Generated by $as_me.

592

$2

593

SHELL=\${CONFIG_SHELL-$SHELL}

594

export SHELL

595

_ASEOF

596

cat >>$1 <<\_ASEOF || lt_write_fail=1

597

AS_SHELL_SANITIZE

598

_AS_PREPARE

599

exec AS_MESSAGE_FD>&1

600

_ASEOF

601

test $lt_write_fail = 0 && chmod +x $1[]dnl

602

m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT

556

603

557

604

# LT_OUTPUT

558

605

# ---------

562

609

AC_DEFUN([LT_OUTPUT],

563

610

[: ${CONFIG_LT=./config.lt}

564

611

AC_MSG_NOTICE([creating $CONFIG_LT])

565

cat >"$CONFIG_LT" <<_LTEOF

566

#! $SHELL

567

# Generated by $as_me.

568

# Run this file to recreate a libtool stub with the current configuration.

612

_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],

613

[# Run this file to recreate a libtool stub with the current configuration.])

569

614

615

cat >>"$CONFIG_LT" <<\_LTEOF

570

616

lt_cl_silent=false

571

SHELL=\${CONFIG_SHELL-$SHELL}

572

_LTEOF

573

574

cat >>"$CONFIG_LT" <<\_LTEOF

575

AS_SHELL_SANITIZE

576

_AS_PREPARE

577

578

exec AS_MESSAGE_FD>&1

579

617

exec AS_MESSAGE_LOG_FD>>config.log

580

618

{

581

619

echo

601

639

m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])

602

640

configured by $[0], generated by m4_PACKAGE_STRING.

603

641

604

642

605

643

This config.lt script is free software; the Free Software Foundation

606

644

gives unlimited permision to copy, distribute and modify it."

607

645

646

684

# appending to config.log, which fails on DOS, as config.log is still kept

647

685

# open by configure. Here we exec the FD to /dev/null, effectively closing

648

686

# config.log, so it can be properly (re)opened and appended to by config.lt.

649

if test "$no_create" != yes; then

650

lt_cl_success=:

651

test "$silent" = yes &&

652

lt_config_lt_args="$lt_config_lt_args --quiet"

653

exec AS_MESSAGE_LOG_FD>/dev/null

654

$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false

655

exec AS_MESSAGE_LOG_FD>>config.log

656

$lt_cl_success || AS_EXIT(1)

657

fi

687

lt_cl_success=:

688

test "$silent" = yes &&

689

lt_config_lt_args="$lt_config_lt_args --quiet"

690

exec AS_MESSAGE_LOG_FD>/dev/null

691

$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false

692

exec AS_MESSAGE_LOG_FD>>config.log

693

$lt_cl_success || AS_EXIT(1)

658

694

])# LT_OUTPUT

659

695

660

696

717

753

# if finds mixed CR/LF and LF-only lines. Since sed operates in

718

754

# text mode, it properly converts lines to CR/LF. This bash problem

719

755

# is reportedly fixed, but why not run on old versions too?

720

sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \

721

|| (rm -f "$cfgfile"; exit 1)

722

723

_LT_PROG_XSI_SHELLFNS

724

725

sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \

726

|| (rm -f "$cfgfile"; exit 1)

727

728

mv -f "$cfgfile" "$ofile" ||

756

sed '$q' "$ltmain" >> "$cfgfile" \

757

|| (rm -f "$cfgfile"; exit 1)

758

759

_LT_PROG_REPLACE_SHELLFNS

760

761

mv -f "$cfgfile" "$ofile" ||

729

762

(rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")

730

763

chmod +x "$ofile"

731

764

],

770

803

m4_case([$1],

771

804

[C], [_LT_LANG(C)],

772

805

[C++], [_LT_LANG(CXX)],

806

[Go], [_LT_LANG(GO)],

773

807

[Java], [_LT_LANG(GCJ)],

774

808

[Fortran 77], [_LT_LANG(F77)],

775

809

[Fortran], [_LT_LANG(FC)],

791

825

])# _LT_LANG

792

826

793

827

828

m4_ifndef([AC_PROG_GO], [

829

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

830

# NOTE: This macro has been submitted for inclusion into #

831

# GNU Autoconf as AC_PROG_GO. When it is available in #

832

# a released version of Autoconf we should remove this #

833

# macro and use it instead. #

834

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

835

m4_defun([AC_PROG_GO],

836

[AC_LANG_PUSH(Go)dnl

837

AC_ARG_VAR([GOC], [Go compiler command])dnl

838

AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl

839

_AC_ARG_VAR_LDFLAGS()dnl

840

AC_CHECK_TOOL(GOC, gccgo)

841

if test -z "$GOC"; then

842

if test -n "$ac_tool_prefix"; then

843

AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])

844

fi

845

fi

846

if test -z "$GOC"; then

847

AC_CHECK_PROG(GOC, gccgo, gccgo, false)

848

fi

849

])#m4_defun

850

])#m4_ifndef

851

852

794

853

# _LT_LANG_DEFAULT_CONFIG

795

854

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

796

855

m4_defun([_LT_LANG_DEFAULT_CONFIG],

821

880

m4_ifdef([LT_PROG_GCJ],

822

881

[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])

823

882

883

AC_PROVIDE_IFELSE([AC_PROG_GO],

884

[LT_LANG(GO)],

885

[m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])

886

824

887

AC_PROVIDE_IFELSE([LT_PROG_RC],

825

888

[LT_LANG(RC)],

826

889

[m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])

831

894

AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])

832

895

AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])

833

896

AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])

897

AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])

834

898

dnl aclocal-1.4 backwards compatibility:

835

899

dnl AC_DEFUN([AC_LIBTOOL_CXX], [])

836

900

dnl AC_DEFUN([AC_LIBTOOL_F77], [])

837

901

dnl AC_DEFUN([AC_LIBTOOL_FC], [])

838

902

dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])

903

dnl AC_DEFUN([AC_LIBTOOL_RC], [])

839

904

840

905

841

906

# _LT_TAG_COMPILER

921

986

$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \

922

987

-dynamiclib -Wl,-single_module conftest.c 2>conftest.err

923

988

_lt_result=$?

924

if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then

989

# If there is a non-empty error log, and "single_module"

990

# appears in it, assume the flag caused a linker warning

991

if test -s conftest.err && $GREP single_module conftest.err; then

992

cat conftest.err >&AS_MESSAGE_LOG_FD

993

# Otherwise, if the output was created with a 0 exit code from

994

# the compiler, it worked.

995

elif test -f libconftest.dylib && test $_lt_result -eq 0; then

925

996

lt_cv_apple_cc_single_mod=yes

926

997

else

927

998

cat conftest.err >&AS_MESSAGE_LOG_FD

929

1000

rm -rf libconftest.dylib*

930

1001

rm -f conftest.*

931

1002

fi])

1003

932

1004

AC_CACHE_CHECK([for -exported_symbols_list linker flag],

933

1005

[lt_cv_ld_exported_symbols_list],

934

1006

[lt_cv_ld_exported_symbols_list=no

940

1012

[lt_cv_ld_exported_symbols_list=no])

941

1013

LDFLAGS="$save_LDFLAGS"

942

1014

])

1015

1016

AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],

1017

[lt_cv_ld_force_load=no

1018

cat > conftest.c << _LT_EOF

1019

int forced_loaded() { return 2;}

1020

_LT_EOF

1021

echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD

1022

$LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD

1023

echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD

1024

$AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD

1025

echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD

1026

$RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD

1027

cat > conftest.c << _LT_EOF

1028

int main() { return 0;}

1029

_LT_EOF

1030

echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD

1031

$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err

1032

_lt_result=$?

1033

if test -s conftest.err && $GREP force_load conftest.err; then

1034

cat conftest.err >&AS_MESSAGE_LOG_FD

1035

elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then

1036

lt_cv_ld_force_load=yes

1037

else

1038

cat conftest.err >&AS_MESSAGE_LOG_FD

1039

fi

1040

rm -f conftest.err libconftest.a conftest conftest.c

1041

rm -rf conftest.dSYM

1042

])

943

1043

case $host_os in

944

1044

rhapsody* | darwin1.[[012]])

945

1045

_lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;

967

1067

else

968

1068

_lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'

969

1069

fi

970

if test "$DSYMUTIL" != ":"; then

1070

if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then

971

1071

_lt_dsymutil='~$DSYMUTIL $lib || :'

972

1072

else

973

1073

_lt_dsymutil=

977

1077

])

978

1078

979

1079

980

# _LT_DARWIN_LINKER_FEATURES

981

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

1080

# _LT_DARWIN_LINKER_FEATURES([TAG])

1081

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

982

1082

# Checks for linker and compiler features on darwin

983

1083

m4_defun([_LT_DARWIN_LINKER_FEATURES],

984

1084

[

987

1087

_LT_TAGVAR(hardcode_direct, $1)=no

988

1088

_LT_TAGVAR(hardcode_automatic, $1)=yes

989

1089

_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

990

_LT_TAGVAR(whole_archive_flag_spec, $1)=''

1090

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

1091

_LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'

1092

m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],

1093

[FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes])

1094

else

1095

_LT_TAGVAR(whole_archive_flag_spec, $1)=''

1096

fi

991

1097

_LT_TAGVAR(link_all_deplibs, $1)=yes

992

1098

_LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"

993

1099

case $cc_basename in

995

1101

*) _lt_dar_can_shared=$GCC ;;

996

1102

esac

997

1103

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

998

output_verbose_link_cmd=echo

1104

output_verbose_link_cmd=func_echo_all

999

1105

_LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"

1000

1106

_LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"

1001

1107

_LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"

1011

1117

fi

1012

1118

])

1013

1119

1014

# _LT_SYS_MODULE_PATH_AIX

1015

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

1120

# _LT_SYS_MODULE_PATH_AIX([TAGNAME])

1121

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

1016

1122

# Links a minimal program and checks the executable

1017

1123

# for the system default hardcoded library path. In most cases,

1018

1124

# this is /usr/lib:/lib, but when the MPI compilers are used

1019

1125

# the location of the communication and MPI libs are included too.

1020

1126

# If we don't find anything, use the default library path according

1021

1127

# to the aix ld manual.

1128

# Store the results from the different compilers for each TAGNAME.

1129

# Allow to override them for all tags through lt_cv_aix_libpath.

1022

1130

m4_defun([_LT_SYS_MODULE_PATH_AIX],

1023

1131

[m4_require([_LT_DECL_SED])dnl

1024

AC_LINK_IFELSE(AC_LANG_PROGRAM,[

1025

lt_aix_libpath_sed='

1026

/Import File Strings/,/^$/ {

1027

/^0/ {

1028

s/^0 *$.*$$/\1/

1029

p

1030

}

1031

}'

1032

aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

1033

# Check for a 64-bit object if we didn't find anything.

1034

if test -z "$aix_libpath"; then

1035

aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

1036

fi],[])

1037

if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

1132

if test "${lt_cv_aix_libpath+set}" = set; then

1133

aix_libpath=$lt_cv_aix_libpath

1134

else

1135

AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],

1136

[AC_LINK_IFELSE([AC_LANG_PROGRAM],[

1137

lt_aix_libpath_sed='[

1138

/Import File Strings/,/^$/ {

1139

/^0/ {

1140

s/^0 *$[^ ]*$ *$/\1/

1141

p

1142

}

1143

}]'

1144

_LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

1145

# Check for a 64-bit object if we didn't find anything.

1146

if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then

1147

_LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

1148

fi],[])

1149

if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then

1150

_LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"

1151

fi

1152

])

1153

aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])

1154

fi

1038

1155

])# _LT_SYS_MODULE_PATH_AIX

1039

1156

1040

1157

1041

1158

# _LT_SHELL_INIT(ARG)

1042

1159

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

1043

1160

m4_define([_LT_SHELL_INIT],

1044

[ifdef([AC_DIVERSION_NOTICE],

1045

[AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

1046

[AC_DIVERT_PUSH(NOTICE)])

1047

$1

1048

AC_DIVERT_POP

1049

])# _LT_SHELL_INIT

1161

[m4_divert_text([M4SH-INIT], [$1

1162

])])# _LT_SHELL_INIT

1163

1050

1164

1051

1165

1052

1166

# _LT_PROG_ECHO_BACKSLASH

1053

1167

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

1054

# Add some code to the start of the generated configure script which

1055

# will find an echo command which doesn't interpret backslashes.

1168

# Find how we can fake an echo command that does not interpret backslash.

1169

# In particular, with Autoconf 2.60 or later we add some code to the start

1170

# of the generated configure script which will find a shell with a builtin

1171

# printf (which we can use as an echo command).

1056

1172

m4_defun([_LT_PROG_ECHO_BACKSLASH],

1057

[_LT_SHELL_INIT([

1058

# Check that we are running under the correct shell.

1059

SHELL=${CONFIG_SHELL-/bin/sh}

1060

1061

case X$lt_ECHO in

1062

X*--fallback-echo)

1063

# Remove one level of quotation (which was required for Make).

1064

ECHO=`echo "$lt_ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`

1065

;;

1173

[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'

1174

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO

1175

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

1176

1177

AC_MSG_CHECKING([how to print strings])

1178

# Test print first, because it will be a builtin if present.

1179

if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \

1180

test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then

1181

ECHO='print -r --'

1182

elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then

1183

ECHO='printf %s\n'

1184

else

1185

# Use this function as a fallback that always works.

1186

func_fallback_echo ()

1187

{

1188

eval 'cat <<_LTECHO_EOF

1189

$[]1

1190

_LTECHO_EOF'

1191

}

1192

ECHO='func_fallback_echo'

1193

fi

1194

1195

# func_echo_all arg...

1196

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

1197

func_echo_all ()

1198

{

1199

$ECHO "$*"

1200

}

1201

1202

case "$ECHO" in

1203

printf*) AC_MSG_RESULT([printf]) ;;

1204

print*) AC_MSG_RESULT([print -r]) ;;

1205

*) AC_MSG_RESULT([cat]) ;;

1066

1206

esac

1067

1207

1068

ECHO=${lt_ECHO-echo}

1069

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

1070

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

1071

shift

1072

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

1073

# Avoid inline document here, it may be left over

1074

:

1075

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

1076

# Yippee, $ECHO works!

1077

:

1078

else

1079

# Restart under the correct shell.

1080

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

1081

fi

1082

1083

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

1084

# used as fallback echo

1085

shift

1086

cat <<_LT_EOF

1087

[$]*

1088

_LT_EOF

1089

exit 0

1090

fi

1091

1092

# The HP-UX ksh and POSIX shell print the target directory to stdout

1093

# if CDPATH is set.

1094

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

1095

1096

if test -z "$lt_ECHO"; then

1097

if test "X${echo_test_string+set}" != Xset; then

1098

# find a string as large as possible, as long as the shell can cope with it

1099

for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do

1100

# expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

1101

if { echo_test_string=`eval $cmd`; } 2>/dev/null &&

1102

{ test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null

1103

then

1104

break

1105

fi

1106

done

1107

fi

1108

1109

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

1110

echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&

1111

test "X$echo_testing_string" = "X$echo_test_string"; then

1112

:

1113

else

1114

# The Solaris, AIX, and Digital Unix default echo programs unquote

1115

# backslashes. This makes it impossible to quote backslashes using

1116

# echo "$something" | sed 's/\\/\\\\/g'

1117

#

1118

# So, first we look for a working echo in the user's PATH.

1119

1120

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

1121

for dir in $PATH /usr/ucb; do

1122

IFS="$lt_save_ifs"

1123

if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&

1124

test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&

1125

echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&

1126

test "X$echo_testing_string" = "X$echo_test_string"; then

1127

ECHO="$dir/echo"

1128

break

1129

fi

1130

done

1131

IFS="$lt_save_ifs"

1132

1133

if test "X$ECHO" = Xecho; then

1134

# We didn't find a better echo, so look for alternatives.

1135

if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&

1136

echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&

1137

test "X$echo_testing_string" = "X$echo_test_string"; then

1138

# This shell has a builtin print -r that does the trick.

1139

ECHO='print -r'

1140

elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&

1141

test "X$CONFIG_SHELL" != X/bin/ksh; then

1142

# If we have ksh, try running configure again with it.

1143

ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

1144

export ORIGINAL_CONFIG_SHELL

1145

CONFIG_SHELL=/bin/ksh

1146

export CONFIG_SHELL

1147

exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}

1148

else

1149

# Try using printf.

1150

ECHO='printf %s\n'

1151

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

1152

echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&

1153

test "X$echo_testing_string" = "X$echo_test_string"; then

1154

# Cool, printf works

1155

:

1156

elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

1157

test "X$echo_testing_string" = 'X\t' &&

1158

echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

1159

test "X$echo_testing_string" = "X$echo_test_string"; then

1160

CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

1161

export CONFIG_SHELL

1162

SHELL="$CONFIG_SHELL"

1163

export SHELL

1164

ECHO="$CONFIG_SHELL [$]0 --fallback-echo"

1165

elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

1166

test "X$echo_testing_string" = 'X\t' &&

1167

echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

1168

test "X$echo_testing_string" = "X$echo_test_string"; then

1169

ECHO="$CONFIG_SHELL [$]0 --fallback-echo"

1170

else

1171

# maybe with a smaller string...

1172

prev=:

1173

1174

for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do

1175

if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null

1176

then

1177

break

1178

fi

1179

prev="$cmd"

1180

done

1181

1182

if test "$prev" != 'sed 50q "[$]0"'; then

1183

echo_test_string=`eval $prev`

1184

export echo_test_string

1185

exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}

1186

else

1187

# Oops. We lost completely, so just stick with echo.

1188

ECHO=echo

1189

fi

1190

fi

1191

fi

1192

fi

1193

fi

1194

fi

1195

1196

# Copy echo and quote the copy suitably for passing to libtool from

1197

# the Makefile, instead of quoting the original, which is used later.

1198

lt_ECHO=$ECHO

1199

if test "X$lt_ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then

1200

lt_ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"

1201

fi

1202

1203

AC_SUBST(lt_ECHO)

1204

])

1208

m4_ifdef([_AS_DETECT_SUGGESTED],

1209

[_AS_DETECT_SUGGESTED([

1210

test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (

1211

ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'

1212

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO

1213

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

1214

PATH=/empty FPATH=/empty; export PATH FPATH

1215

test "X`printf %s $ECHO`" = "X$ECHO" \

1216

|| test "X`print -r -- $ECHO`" = "X$ECHO" )])])

1217

1205

1218

_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])

1206

_LT_DECL([], [ECHO], [1],

1207

[An echo program that does not interpret backslashes])

1219

_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])

1208

1220

])# _LT_PROG_ECHO_BACKSLASH

1209

1221

1210

1222

1223

# _LT_WITH_SYSROOT

1224

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

1225

AC_DEFUN([_LT_WITH_SYSROOT],

1226

[AC_MSG_CHECKING([for sysroot])

1227

AC_ARG_WITH([sysroot],

1228

[ --with-sysroot[=DIR] Search for dependent libraries within DIR

1229

(or the compiler's sysroot if not specified).],

1230

[], [with_sysroot=no])

1231

1232

dnl lt_sysroot will always be passed unquoted. We quote it here

1233

dnl in case the user passed a directory name.

1234

lt_sysroot=

1235

case ${with_sysroot} in #(

1236

yes)

1237

if test "$GCC" = yes; then

1238

lt_sysroot=`$CC --print-sysroot 2>/dev/null`

1239

fi

1240

;; #(

1241

/*)

1242

lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`

1243

;; #(

1244

no|'')

1245

;; #(

1246

*)

1247

AC_MSG_RESULT([${with_sysroot}])

1248

AC_MSG_ERROR([The sysroot must be an absolute path.])

1249

;;

1250

esac

1251

1252

AC_MSG_RESULT([${lt_sysroot:-no}])

1253

_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl

1254

[dependent libraries, and in which our libraries should be installed.])])

1255

1211

1256

# _LT_ENABLE_LOCK

1212

1257

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

1213

1258

m4_defun([_LT_ENABLE_LOCK],

1236

1281

;;

1237

1282

*-*-irix6*)

1238

1283

# Find out which ABI we are using.

1239

echo '[#]line __oline__ "configure"' > conftest.$ac_ext

1284

echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext

1240

1285

if AC_TRY_EVAL(ac_compile); then

1241

1286

if test "$lt_cv_prog_gnu_ld" = yes; then

1242

1287

case `/usr/bin/file conftest.$ac_objext` in

1329

1374

CFLAGS="$SAVE_CFLAGS"

1330

1375

fi

1331

1376

;;

1332

sparc*-*solaris*)

1377

*-*solaris*)

1333

1378

# Find out which ABI we are using.

1334

1379

echo 'int i;' > conftest.$ac_ext

1335

1380

if AC_TRY_EVAL(ac_compile); then

1336

1381

case `/usr/bin/file conftest.o` in

1337

1382

*64-bit*)

1338

1383

case $lt_cv_prog_gnu_ld in

1339

yes*) LD="${LD-ld} -m elf64_sparc" ;;

1384

yes*)

1385

case $host in

1386

i?86-*-solaris*)

1387

LD="${LD-ld} -m elf_x86_64"

1388

;;

1389

sparc*-*-solaris*)

1390

LD="${LD-ld} -m elf64_sparc"

1391

;;

1392

esac

1393

# GNU ld 2.21 introduced _sol2 emulations. Use them if available.

1394

if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then

1395

LD="${LD-ld}_sol2"

1396

fi

1397

;;

1340

1398

*)

1341

1399

if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then

1342

1400

LD="${LD-ld} -64"

1354

1412

])# _LT_ENABLE_LOCK

1355

1413

1356

1414

1415

# _LT_PROG_AR

1416

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

1417

m4_defun([_LT_PROG_AR],

1418

[AC_CHECK_TOOLS(AR, [ar], false)

1419

: ${AR=ar}

1420

: ${AR_FLAGS=cru}

1421

_LT_DECL([], [AR], [1], [The archiver])

1422

_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])

1423

1424

AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],

1425

[lt_cv_ar_at_file=no

1426

AC_COMPILE_IFELSE([AC_LANG_PROGRAM],

1427

[echo conftest.$ac_objext > conftest.lst

1428

lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'

1429

AC_TRY_EVAL([lt_ar_try])

1430

if test "$ac_status" -eq 0; then

1431

# Ensure the archiver fails upon bogus file names.

1432

rm -f conftest.$ac_objext libconftest.a

1433

AC_TRY_EVAL([lt_ar_try])

1434

if test "$ac_status" -ne 0; then

1435

lt_cv_ar_at_file=@

1436

fi

1437

fi

1438

rm -f conftest.* libconftest.a

1439

])

1440

])

1441

1442

if test "x$lt_cv_ar_at_file" = xno; then

1443

archiver_list_spec=

1444

else

1445

archiver_list_spec=$lt_cv_ar_at_file

1446

fi

1447

_LT_DECL([], [archiver_list_spec], [1],

1448

[How to feed a file listing to the archiver])

1449

])# _LT_PROG_AR

1450

1451

1357

1452

# _LT_CMD_OLD_ARCHIVE

1358

1453

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

1359

1454

m4_defun([_LT_CMD_OLD_ARCHIVE],

1360

[AC_CHECK_TOOL(AR, ar, false)

1361

test -z "$AR" && AR=ar

1362

test -z "$AR_FLAGS" && AR_FLAGS=cru

1363

_LT_DECL([], [AR], [1], [The archiver])

1364

_LT_DECL([], [AR_FLAGS], [1])

1455

[_LT_PROG_AR

1365

1456

1366

1457

AC_CHECK_TOOL(STRIP, strip, :)

1367

1458

test -z "$STRIP" && STRIP=:

1380

1471

if test -n "$RANLIB"; then

1381

1472

case $host_os in

1382

1473

openbsd*)

1383

old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"

1474

old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"

1384

1475

;;

1385

1476

*)

1386

old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"

1477

old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"

1387

1478

;;

1388

1479

esac

1389

old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"

1480

old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"

1390

1481

fi

1482

1483

case $host_os in

1484

darwin*)

1485

lock_old_archive_extraction=yes ;;

1486

*)

1487

lock_old_archive_extraction=no ;;

1488

esac

1391

1489

_LT_DECL([], [old_postinstall_cmds], [2])

1392

1490

_LT_DECL([], [old_postuninstall_cmds], [2])

1393

1491

_LT_TAGDECL([], [old_archive_cmds], [2],

1394

1492

[Commands used to build an old-style archive])

1493

_LT_DECL([], [lock_old_archive_extraction], [0],

1494

[Whether to use a lock for old archive extraction])

1395

1495

])# _LT_CMD_OLD_ARCHIVE

1396

1496

1397

1497

1416

1516

-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

1417

1517

-e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

1418

1518

-e 's:$: $lt_compiler_flag:'`

1419

(eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

1519

(eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

1420

1520

(eval "$lt_compile" 2>conftest.err)

1421

1521

ac_status=$?

1422

1522

cat conftest.err >&AS_MESSAGE_LOG_FD

1423

echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

1523

echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

1424

1524

if (exit $ac_status) && test -s "$ac_outfile"; then

1425

1525

# The compiler can only warn and ignore the option if not recognized

1426

1526

# So say no if there are warnings other than the usual output.

1427

$ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

1527

$ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp

1428

1528

$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

1429

1529

if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

1430

1530

$2=yes

1464

1564

if test -s conftest.err; then

1465

1565

# Append any errors to the config.log.

1466

1566

cat conftest.err 1>&AS_MESSAGE_LOG_FD

1467

$ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

1567

$ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp

1468

1568

$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

1469

1569

if diff conftest.exp conftest.er2 >/dev/null; then

1470

1570

$2=yes

1527

1627

lt_cv_sys_max_cmd_len=8192;

1528

1628

;;

1529

1629

1630

mint*)

1631

# On MiNT this can take a long time and run out of memory.

1632

lt_cv_sys_max_cmd_len=8192;

1633

;;

1634

1530

1635

amigaos*)

1531

1636

# On AmigaOS with pdksh, this test takes hours, literally.

1532

1637

# So we just punt and use a minimum line length of 8192.

1552

1657

lt_cv_sys_max_cmd_len=196608

1553

1658

;;

1554

1659

1660

os2*)

1661

# The test takes a long time on OS/2.

1662

lt_cv_sys_max_cmd_len=8192

1663

;;

1664

1555

1665

osf*)

1556

1666

# Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure

1557

1667

# due to this test when exec_disable_arg_limit is 1 on Tru64. It is not

1591

1701

# If test is not a shell built-in, we'll probably end up computing a

1592

1702

# maximum length that is only half of the actual maximum length, but

1593

1703

# we can't tell.

1594

while { test "X"`$SHELL [$]0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \

1595

= "XX$teststring$teststring"; } >/dev/null 2>&1 &&

1704

while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \

1705

= "X$teststring$teststring"; } >/dev/null 2>&1 &&

1596

1706

test $i != 17 # 1/2 MB should be enough

1597

1707

do

1598

1708

i=`expr $i + 1`

1643

1753

lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

1644

1754

lt_status=$lt_dlunknown

1645

1755

cat > conftest.$ac_ext <<_LT_EOF

1646

[#line __oline__ "configure"

1756

[#line $LINENO "configure"

1647

1757

#include "confdefs.h"

1648

1758

1649

1759

#if HAVE_DLFCN_H

1684

1794

# endif

1685

1795

#endif

1686

1796

1687

void fnord() { int i=42;}

1797

/* When -fvisbility=hidden is used, assume the code has been annotated

1798

correspondingly for the symbols needed. */

1799

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

1800

int fnord () __attribute__((visibility("default")));

1801

#endif

1802

1803

int fnord () { return 42; }

1688

1804

int main ()

1689

1805

{

1690

1806

void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

1693

1809

if (self)

1694

1810

{

1695

1811

if (dlsym (self,"fnord")) status = $lt_dlno_uscore;

1696

else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

1812

else

1813

{

1814

if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

1815

else puts (dlerror ());

1816

}

1697

1817

/* dlclose (self); */

1698

1818

}

1699

1819

else

1869

1989

-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

1870

1990

-e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

1871

1991

-e 's:$: $lt_compiler_flag:'`

1872

(eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

1992

(eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

1873

1993

(eval "$lt_compile" 2>out/conftest.err)

1874

1994

ac_status=$?

1875

1995

cat out/conftest.err >&AS_MESSAGE_LOG_FD

1876

echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

1996

echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

1877

1997

if (exit $ac_status) && test -s out/conftest2.$ac_objext

1878

1998

then

1879

1999

# The compiler can only warn and ignore the option if not recognized

1880

2000

# So say no if there are warnings

1881

$ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp

2001

$ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp

1882

2002

$SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2

1883

2003

if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then

1884

2004

_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

2037

2157

m4_require([_LT_FILEUTILS_DEFAULTS])dnl

2038

2158

m4_require([_LT_DECL_OBJDUMP])dnl

2039

2159

m4_require([_LT_DECL_SED])dnl

2160

m4_require([_LT_CHECK_SHELL_FEATURES])dnl

2040

2161

AC_MSG_CHECKING([dynamic linker characteristics])

2041

2162

m4_if([$1],

2042

2163

[], [

2045

2166

darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;

2046

2167

*) lt_awk_arg="/^libraries:/" ;;

2047

2168

esac

2048

lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e "s,=/,/,g"`

2049

if $ECHO "$lt_search_path_spec" | $GREP ';' >/dev/null ; then

2169

case $host_os in

2170

mingw* | cegcc*) lt_sed_strip_eq="s,=$[[A-Za-z]]:$,\1,g" ;;

2171

*) lt_sed_strip_eq="s,=/,/,g" ;;

2172

esac

2173

lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`

2174

case $lt_search_path_spec in

2175

*\;*)

2050

2176

# if the path contains ";" then we assume it to be the separator

2051

2177

# otherwise default to the standard path separator (i.e. ":") - it is

2052

2178

# assumed that no part of a normal pathname contains ";" but that should

2053

2179

# okay in the real world where ";" in dirpaths is itself problematic.

2054

lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED -e 's/;/ /g'`

2055

else

2056

lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

2057

fi

2180

lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`

2181

;;

2182

*)

2183

lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`

2184

;;

2185

esac

2058

2186

# Ok, now we have the path, separated by spaces, we can step through it

2059

2187

# and add multilib dir if necessary.

2060

2188

lt_tmp_lt_search_path_spec=

2067

2195

lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"

2068

2196

fi

2069

2197

done

2070

lt_search_path_spec=`$ECHO $lt_tmp_lt_search_path_spec | awk '

2198

lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '

2071

2199

BEGIN {RS=" "; FS="/|\n";} {

2072

2200

lt_foo="";

2073

2201

lt_count=0;

2087

2215

if (lt_foo != "") { lt_freq[[lt_foo]]++; }

2088

2216

if (lt_freq[[lt_foo]] == 1) { print lt_foo; }

2089

2217

}'`

2090

sys_lib_search_path_spec=`$ECHO $lt_search_path_spec`

2218

# AWK program above erroneously prepends '/' to C:/dos/paths

2219

# for these hosts.

2220

case $host_os in

2221

mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\

2222

$SED 's,/$[[A-Za-z]]:$,\1,g'` ;;

2223

esac

2224

sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`

2091

2225

else

2092

2226

sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

2093

2227

fi])

2113

2247

2114

2248

case $host_os in

2115

2249

aix3*)

2116

version_type=linux

2250

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

2117

2251

library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

2118

2252

shlibpath_var=LIBPATH

2119

2253

2122

2256

;;

2123

2257

2124

2258

aix[[4-9]]*)

2125

version_type=linux

2259

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

2126

2260

need_lib_prefix=no

2127

2261

need_version=no

2128

2262

hardcode_into_libs=yes

2175

2309

m68k)

2176

2310

library_names_spec='$libname.ixlibrary $libname.a'

2177

2311

# Create ${libname}_ixlibrary.a entries in /sys/libs.

2178

finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$ECHO "X$lib" | $Xsed -e '\''s%^.*/$[[^/]]*$\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

2312

finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/$[[^/]]*$\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

2179

2313

;;

2180

2314

esac

2181

2315

;;

2187

2321

;;

2188

2322

2189

2323

bsdi[[45]]*)

2190

version_type=linux

2324

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

2191

2325

need_version=no

2192

2326

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2193

2327

soname_spec='${libname}${release}${shared_ext}$major'

2206

2340

need_version=no

2207

2341

need_lib_prefix=no

2208

2342

2209

case $GCC,$host_os in

2210

yes,cygwin* | yes,mingw* | yes,pw32* | yes,cegcc*)

2343

case $GCC,$cc_basename in

2344

yes,*)

2345

# gcc

2211

2346

library_names_spec='$libname.dll.a'

2212

2347

# DLL is installed to $(libdir)/../bin by postinstall_cmds

2213

2348

postinstall_cmds='base_file=`basename \${file}`~

2228

2363

cygwin*)

2229

2364

# Cygwin DLLs use 'cyg' prefix rather than 'lib'

2230

2365

soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

2231

sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

2366

m4_if([$1], [],[

2367

sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])

2232

2368

;;

2233

2369

mingw* | cegcc*)

2234

2370

# MinGW DLLs use traditional 'lib' prefix

2235

2371

soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

2236

sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

2237

if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then

2238

# It is most probably a Windows format PATH printed by

2239

# mingw gcc, but we are running on Cygwin. Gcc prints its search

2240

# path with ; separators, and with drive letters. We can handle the

2241

# drive letters (cygwin fileutils understands them), so leave them,

2242

# especially as we might pass files found there to a mingw objdump,

2243

# which wouldn't understand a cygwinified path. Ahh.

2244

sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

2245

else

2246

sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

2247

fi

2248

2372

;;

2249

2373

pw32*)

2250

2374

# pw32 DLLs use 'pw' prefix rather than 'lib'

2251

2375

library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

2252

2376

;;

2253

2377

esac

2378

dynamic_linker='Win32 ld.exe'

2379

;;

2380

2381

*,cl*)

2382

# Native MSVC

2383

libname_spec='$name'

2384

soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

2385

library_names_spec='${libname}.dll.lib'

2386

2387

case $build_os in

2388

mingw*)

2389

sys_lib_search_path_spec=

2390

lt_save_ifs=$IFS

2391

IFS=';'

2392

for lt_path in $LIB

2393

do

2394

IFS=$lt_save_ifs

2395

# Let DOS variable expansion print the short 8.3 style file name.

2396

lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`

2397

sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"

2398

done

2399

IFS=$lt_save_ifs

2400

# Convert to MSYS style.

2401

sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \$[[a-zA-Z]]\$:| /\\1|g' -e 's|^ ||'`

2402

;;

2403

cygwin*)

2404

# Convert to unix form, then to dos form, then back to unix form

2405

# but this time dos style (no spaces!) so that the unix form looks

2406

# like /cygdrive/c/PROGRA~1:/cygdr...

2407

sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`

2408

sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`

2409

sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

2410

;;

2411

*)

2412

sys_lib_search_path_spec="$LIB"

2413

if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then

2414

# It is most probably a Windows format PATH.

2415

sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

2416

else

2417

sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

2418

fi

2419

# FIXME: find the short name or the path components, as spaces are

2420

# common. (e.g. "Program Files" -> "PROGRA~1")

2421

;;

2422

esac

2423

2424

# DLL is installed to $(libdir)/../bin by postinstall_cmds

2425

postinstall_cmds='base_file=`basename \${file}`~

2426

dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~

2427

dldir=$destdir/`dirname \$dlpath`~

2428

test -d \$dldir || mkdir -p \$dldir~

2429

$install_prog $dir/$dlname \$dldir/$dlname'

2430

postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

2431

dlpath=$dir/\$dldll~

2432

$RM \$dlpath'

2433

shlibpath_overrides_runpath=yes

2434

dynamic_linker='Win32 link.exe'

2254

2435

;;

2255

2436

2256

2437

*)

2438

# Assume MSVC wrapper

2257

2439

library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'

2440

dynamic_linker='Win32 ld.exe'

2258

2441

;;

2259

2442

esac

2260

dynamic_linker='Win32 ld.exe'

2261

2443

# FIXME: first we should search . and the directory the executable is in

2262

2444

shlibpath_var=PATH

2263

2445

;;

2278

2460

;;

2279

2461

2280

2462

dgux*)

2281

version_type=linux

2463

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

2282

2464

need_lib_prefix=no

2283

2465

need_version=no

2284

2466

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

2286

2468

shlibpath_var=LD_LIBRARY_PATH

2287

2469

;;

2288

2470

2289

freebsd1*)

2290

dynamic_linker=no

2291

;;

2292

2293

2471

freebsd* | dragonfly*)

2294

2472

# DragonFly does not have aout. When/if they implement a new

2295

2473

# versioning mechanism, adjust this.

2297

2475

objformat=`/usr/bin/objformat`

2298

2476

else

2299

2477

case $host_os in

2300

freebsd[[123]]*) objformat=aout ;;

2478

freebsd[[23]].*) objformat=aout ;;

2301

2479

*) objformat=elf ;;

2302

2480

esac

2303

2481

fi

2315

2493

esac

2316

2494

shlibpath_var=LD_LIBRARY_PATH

2317

2495

case $host_os in

2318

freebsd2*)

2496

freebsd2.*)

2319

2497

shlibpath_overrides_runpath=yes

2320

2498

;;

2321

2499

freebsd3.[[01]]* | freebsdelf3.[[01]]*)

2335

2513

;;

2336

2514

2337

2515

gnu*)

2338

version_type=linux

2516

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

2339

2517

need_lib_prefix=no

2340

2518

need_version=no

2341

2519

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

2342

2520

soname_spec='${libname}${release}${shared_ext}$major'

2343

2521

shlibpath_var=LD_LIBRARY_PATH

2522

shlibpath_overrides_runpath=no

2523

hardcode_into_libs=yes

2524

;;

2525

2526

haiku*)

2527

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

2528

need_lib_prefix=no

2529

need_version=no

2530

dynamic_linker="$host_os runtime_loader"

2531

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

2532

soname_spec='${libname}${release}${shared_ext}$major'

2533

shlibpath_var=LIBRARY_PATH

2534

shlibpath_overrides_runpath=yes

2535

sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'

2344

2536

hardcode_into_libs=yes

2345

2537

;;

2346

2538

2386

2578

soname_spec='${libname}${release}${shared_ext}$major'

2387

2579

;;

2388

2580

esac

2389

# HP-UX runs *really* slowly unless shared libraries are mode 555.

2581

# HP-UX runs *really* slowly unless shared libraries are mode 555, ...

2390

2582

postinstall_cmds='chmod 555 $lib'

2583

# or fails outright, so override atomically:

2584

install_override_mode=555

2391

2585

;;

2392

2586

2393

2587

interix[[3-9]]*)

2394

version_type=linux

2588

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

2395

2589

need_lib_prefix=no

2396

2590

need_version=no

2397

2591

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

2407

2601

nonstopux*) version_type=nonstopux ;;

2408

2602

*)

2409

2603

if test "$lt_cv_prog_gnu_ld" = yes; then

2410

version_type=linux

2604

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

2411

2605

else

2412

2606

version_type=irix

2413

2607

fi ;;

2444

2638

dynamic_linker=no

2445

2639

;;

2446

2640

2447

# This must be Linux ELF.

2641

# This must be glibc/ELF.

2448

2642

linux* | k*bsd*-gnu | kopensolaris*-gnu)

2449

version_type=linux

2643

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

2450

2644

need_lib_prefix=no

2451

2645

need_version=no

2452

2646

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2454

2648

finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

2455

2649

shlibpath_var=LD_LIBRARY_PATH

2456

2650

shlibpath_overrides_runpath=no

2651

2457

2652

# Some binutils ld are patched to set DT_RUNPATH

2458

save_LDFLAGS=$LDFLAGS

2459

save_libdir=$libdir

2460

eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \

2461

LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""

2462

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],

2463

[AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],

2464

[shlibpath_overrides_runpath=yes])])

2465

LDFLAGS=$save_LDFLAGS

2466

libdir=$save_libdir

2653

AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath],

2654

[lt_cv_shlibpath_overrides_runpath=no

2655

save_LDFLAGS=$LDFLAGS

2656

save_libdir=$libdir

2657

eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \

2658

LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""

2659

AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],

2660

[AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],

2661

[lt_cv_shlibpath_overrides_runpath=yes])])

2662

LDFLAGS=$save_LDFLAGS

2663

libdir=$save_libdir

2664

])

2665

shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath

2467

2666

2468

2667

# This implies no fast_install, which is unacceptable.

2469

2668

# Some rework will be needed to allow for fast_install

2472

2671

2473

2672

# Append ld.so.conf contents to the search path

2474

2673

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

2475

lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`

2674

lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`

2476

2675

sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"

2477

2676

fi

2478

2677

2516

2715

;;

2517

2716

2518

2717

newsos6)

2519

version_type=linux

2718

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

2520

2719

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2521

2720

shlibpath_var=LD_LIBRARY_PATH

2522

2721

shlibpath_overrides_runpath=yes

2585

2784

;;

2586

2785

2587

2786

solaris*)

2588

version_type=linux

2787

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

2589

2788

need_lib_prefix=no

2590

2789

need_version=no

2591

2790

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2610

2809

;;

2611

2810

2612

2811

sysv4 | sysv4.3*)

2613

version_type=linux

2812

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

2614

2813

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2615

2814

soname_spec='${libname}${release}${shared_ext}$major'

2616

2815

shlibpath_var=LD_LIBRARY_PATH

2634

2833

2635

2834

sysv4*MP*)

2636

2835

if test -d /usr/nec ;then

2637

version_type=linux

2836

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

2638

2837

library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

2639

2838

soname_spec='$libname${shared_ext}.$major'

2640

2839

shlibpath_var=LD_LIBRARY_PATH

2665

2864

2666

2865

tpf*)

2667

2866

# TPF is a cross-target only. Preferred cross-host = GNU/Linux.

2668

version_type=linux

2867

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

2669

2868

need_lib_prefix=no

2670

2869

need_version=no

2671

2870

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2675

2874

;;

2676

2875

2677

2876

uts4*)

2678

version_type=linux

2877

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

2679

2878

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

2680

2879

soname_spec='${libname}${release}${shared_ext}$major'

2681

2880

shlibpath_var=LD_LIBRARY_PATH

2717

2916

The last name is the one that the linker finds with -lNAME]])

2718

2917

_LT_DECL([], [soname_spec], [1],

2719

2918

[[The coded name of the library, if different from the real name]])

2919

_LT_DECL([], [install_override_mode], [1],

2920

[Permission mode override for installation of shared libraries])

2720

2921

_LT_DECL([], [postinstall_cmds], [2],

2721

2922

[Command to use after installation of a shared archive])

2722

2923

_LT_DECL([], [postuninstall_cmds], [2],

2829

3030

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

2830

3031

m4_require([_LT_DECL_SED])dnl

2831

3032

m4_require([_LT_DECL_EGREP])dnl

3033

m4_require([_LT_PROG_ECHO_BACKSLASH])dnl

2832

3034

2833

3035

AC_ARG_WITH([gnu-ld],

2834

3036

[AS_HELP_STRING([--with-gnu-ld],

2950

3152

esac

2951

3153

reload_cmds='$LD$reload_flag -o $output$reload_objs'

2952

3154

case $host_os in

3155

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

3156

if test "$GCC" != yes; then

3157

reload_cmds=false

3158

fi

3159

;;

2953

3160

darwin*)

2954

3161

if test "$GCC" = yes; then

2955

3162

reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'

2958

3165

fi

2959

3166

;;

2960

3167

esac

2961

_LT_DECL([], [reload_flag], [1], [How to create reloadable object files])dnl

2962

_LT_DECL([], [reload_cmds], [2])dnl

3168

_LT_TAGDECL([], [reload_flag], [1], [How to create reloadable object files])dnl

3169

_LT_TAGDECL([], [reload_cmds], [2])dnl

2963

3170

])# _LT_CMD_RELOAD

2964

3171

2965

3172

3011

3218

# Base MSYS/MinGW do not provide the 'file' command needed by

3012

3219

# func_win32_libid shell function, so use a weaker test based on 'objdump',

3013

3220

# unless we find 'file', for example because we are cross-compiling.

3014

if ( file / ) >/dev/null 2>&1; then

3221

# func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.

3222

if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then

3015

3223

lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'

3016

3224

lt_cv_file_magic_cmd='func_win32_libid'

3017

3225

else

3018

lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

3226

# Keep this pattern in sync with the one in func_win32_libid.

3227

lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'

3019

3228

lt_cv_file_magic_cmd='$OBJDUMP -f'

3020

3229

fi

3021

3230

;;

3022

3231

3023

cegcc)

3232

cegcc*)

3024

3233

# use the weaker test based on 'objdump'. See mingw*.

3025

3234

lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'

3026

3235

lt_cv_file_magic_cmd='$OBJDUMP -f'

3050

3259

lt_cv_deplibs_check_method=pass_all

3051

3260

;;

3052

3261

3262

haiku*)

3263

lt_cv_deplibs_check_method=pass_all

3264

;;

3265

3053

3266

hpux10.20* | hpux11*)

3054

3267

lt_cv_file_magic_cmd=/usr/bin/file

3055

3268

case $host_cpu in

3058

3271

lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so

3059

3272

;;

3060

3273

hppa*64*)

3061

[lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']

3274

[lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]']

3062

3275

lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl

3063

3276

;;

3064

3277

*)

3065

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'

3278

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library'

3066

3279

lt_cv_file_magic_test_file=/usr/lib/libc.sl

3067

3280

;;

3068

3281

esac

3083

3296

lt_cv_deplibs_check_method=pass_all

3084

3297

;;

3085

3298

3086

# This must be Linux ELF.

3299

# This must be glibc/ELF.

3087

3300

linux* | k*bsd*-gnu | kopensolaris*-gnu)

3088

3301

lt_cv_deplibs_check_method=pass_all

3089

3302

;;

3162

3375

;;

3163

3376

esac

3164

3377

])

3378

3379

file_magic_glob=

3380

want_nocaseglob=no

3381

if test "$build" = "$host"; then

3382

case $host_os in

3383

mingw* | pw32*)

3384

if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then

3385

want_nocaseglob=yes

3386

else

3387

file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/$..$/s\/[[\1]]\/[[\1]]\/g;/g"`

3388

fi

3389

;;

3390

esac

3391

fi

3392

3165

3393

file_magic_cmd=$lt_cv_file_magic_cmd

3166

3394

deplibs_check_method=$lt_cv_deplibs_check_method

3167

3395

test -z "$deplibs_check_method" && deplibs_check_method=unknown

3169

3397

_LT_DECL([], [deplibs_check_method], [1],

3170

3398

[Method to check whether dependent libraries are shared objects])

3171

3399

_LT_DECL([], [file_magic_cmd], [1],

3172

[Command to use when deplibs_check_method == "file_magic"])

3400

[Command to use when deplibs_check_method = "file_magic"])

3401

_LT_DECL([], [file_magic_glob], [1],

3402

[How to find potential files when deplibs_check_method = "file_magic"])

3403

_LT_DECL([], [want_nocaseglob], [1],

3404

[Find potential files using nocaseglob when deplibs_check_method = "file_magic"])

3173

3405

])# _LT_CHECK_MAGIC_METHOD

3174

3406

3175

3407

3226

3458

NM="$lt_cv_path_NM"

3227

3459

else

3228

3460

# Didn't find any BSD compatible name lister, look for dumpbin.

3229

AC_CHECK_TOOLS(DUMPBIN, ["dumpbin -symbols" "link -dump -symbols"], :)

3461

if test -n "$DUMPBIN"; then :

3462

# Let the user override the test.

3463

else

3464

AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)

3465

case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in

3466

*COFF*)

3467

DUMPBIN="$DUMPBIN -symbols"

3468

;;

3469

*)

3470

DUMPBIN=:

3471

;;

3472

esac

3473

fi

3230

3474

AC_SUBST([DUMPBIN])

3231

3475

if test "$DUMPBIN" != ":"; then

3232

3476

NM="$DUMPBIN"

3239

3483

AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],

3240

3484

[lt_cv_nm_interface="BSD nm"

3241

3485

echo "int some_variable = 0;" > conftest.$ac_ext

3242

(eval echo "\"\$as_me:__oline__: $ac_compile\"" >&AS_MESSAGE_LOG_FD)

3486

(eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD)

3243

3487

(eval "$ac_compile" 2>conftest.err)

3244

3488

cat conftest.err >&AS_MESSAGE_LOG_FD

3245

(eval echo "\"\$as_me:__oline__: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)

3489

(eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)

3246

3490

(eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)

3247

3491

cat conftest.err >&AS_MESSAGE_LOG_FD

3248

(eval echo "\"\$as_me:__oline__: output\"" >&AS_MESSAGE_LOG_FD)

3492

(eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD)

3249

3493

cat conftest.out >&AS_MESSAGE_LOG_FD

3250

3494

if $GREP 'External.*some_variable' conftest.out > /dev/null; then

3251

3495

lt_cv_nm_interface="MS dumpbin"

3260

3504

dnl AC_DEFUN([AM_PROG_NM], [])

3261

3505

dnl AC_DEFUN([AC_PROG_NM], [])

3262

3506

3507

# _LT_CHECK_SHAREDLIB_FROM_LINKLIB

3508

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

3509

# how to determine the name of the shared library

3510

# associated with a specific link library.

3511

# -- PORTME fill in with the dynamic library characteristics

3512

m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB],

3513

[m4_require([_LT_DECL_EGREP])

3514

m4_require([_LT_DECL_OBJDUMP])

3515

m4_require([_LT_DECL_DLLTOOL])

3516

AC_CACHE_CHECK([how to associate runtime and link libraries],

3517

lt_cv_sharedlib_from_linklib_cmd,

3518

[lt_cv_sharedlib_from_linklib_cmd='unknown'

3519

3520

case $host_os in

3521

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

3522

# two different shell functions defined in ltmain.sh

3523

# decide which to use based on capabilities of $DLLTOOL

3524

case `$DLLTOOL --help 2>&1` in

3525

*--identify-strict*)

3526

lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib

3527

;;

3528

*)

3529

lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback

3530

;;

3531

esac

3532

;;

3533

*)

3534

# fallback: assume linklib IS sharedlib

3535

lt_cv_sharedlib_from_linklib_cmd="$ECHO"

3536

;;

3537

esac

3538

])

3539

sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd

3540

test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO

3541

3542

_LT_DECL([], [sharedlib_from_linklib_cmd], [1],

3543

[Command to associate shared and link libraries])

3544

])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB

3545

3546

3547

# _LT_PATH_MANIFEST_TOOL

3548

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

3549

# locate the manifest tool

3550

m4_defun([_LT_PATH_MANIFEST_TOOL],

3551

[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :)

3552

test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt

3553

AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool],

3554

[lt_cv_path_mainfest_tool=no

3555

echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD

3556

$MANIFEST_TOOL '-?' 2>conftest.err > conftest.out

3557

cat conftest.err >&AS_MESSAGE_LOG_FD

3558

if $GREP 'Manifest Tool' conftest.out > /dev/null; then

3559

lt_cv_path_mainfest_tool=yes

3560

fi

3561

rm -f conftest*])

3562

if test "x$lt_cv_path_mainfest_tool" != xyes; then

3563

MANIFEST_TOOL=:

3564

fi

3565

_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl

3566

])# _LT_PATH_MANIFEST_TOOL

3567

3263

3568

3264

3569

# LT_LIB_M

3265

3570

# --------

3268

3573

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

3269

3574

LIBM=

3270

3575

case $host in

3271

*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)

3576

3272

3577

# These system don't have libm, or don't need it

3273

3578

;;

3274

3579

*-ncr-sysv4.3*)

3296

3601

_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

3297

3602

3298

3603

if test "$GCC" = yes; then

3299

_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'

3604

case $cc_basename in

3605

nvcc*)

3606

_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;

3607

*)

3608

_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;;

3609

esac

3300

3610

3301

3611

_LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],

3302

3612

lt_cv_prog_compiler_rtti_exceptions,

3313

3623

m4_defun([_LT_CMD_GLOBAL_SYMBOLS],

3314

3624

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

3315

3625

AC_REQUIRE([AC_PROG_CC])dnl

3626

AC_REQUIRE([AC_PROG_AWK])dnl

3316

3627

AC_REQUIRE([LT_PATH_NM])dnl

3317

3628

AC_REQUIRE([LT_PATH_LD])dnl

3318

3629

m4_require([_LT_DECL_SED])dnl

3380

3691

lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* $.*$$/extern int \1();/p' -e 's/^$symcode* .* $.*$$/extern char \1;/p'"

3381

3692

3382

3693

# Transform an extracted symbol line into symbol name and symbol address

3383

lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: $[[^ ]]*$ $/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* $[[^ ]]*$ $[[^ ]]*$$/ {\"\2\", (void *) \&\2},/p'"

3384

lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: $[[^ ]]*$ $/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* $[[^ ]]*$ $lib[[^ ]]*$$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* $[[^ ]]*$ $[[^ ]]*$$/ {\"lib\2\", (void *) \&\2},/p'"

3694

lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: $[[^ ]]*$[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* $[[^ ]]*$ $[[^ ]]*$$/ {\"\2\", (void *) \&\2},/p'"

3695

lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: $[[^ ]]*$[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* $[[^ ]]*$ $lib[[^ ]]*$$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* $[[^ ]]*$ $[[^ ]]*$$/ {\"lib\2\", (void *) \&\2},/p'"

3385

3696

3386

3697

# Handle CRLF in mingw tool chain

3387

3698

opt_cr=

3405

3716

# which start with @ or ?.

3406

3717

lt_cv_sys_global_symbol_pipe="$AWK ['"\

3407

3718

" {last_section=section; section=\$ 3};"\

3719

" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\

3408

3720

" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\

3409

3721

" \$ 0!~/External *\|/{next};"\

3410

3722

" / 0+ UNDEF /{next}; / UNDEF $[^|]$*()/{next};"\

3417

3729

else

3418

3730

lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]$$symcode$symcode*$[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"

3419

3731

fi

3732

lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"

3420

3733

3421

3734

# Check to see that the pipe works correctly.

3422

3735

pipe_works=no

3438

3751

if AC_TRY_EVAL(ac_compile); then

3439

3752

# Now try to grab the symbols.

3440

3753

nlist=conftest.nm

3441

if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then

3754

if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then

3442

3755

# Try sorting and uniquifying the output.

3443

3756

if sort "$nlist" | uniq > "$nlist"T; then

3444

3757

mv -f "$nlist"T "$nlist"

3450

3763

if $GREP ' nm_test_var$' "$nlist" >/dev/null; then

3451

3764

if $GREP ' nm_test_func$' "$nlist" >/dev/null; then

3452

3765

cat <<_LT_EOF > conftest.$ac_ext

3766

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

3767

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

3768

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

3769

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

3770

# define LT@&t@_DLSYM_CONST

3771

#elif defined(__osf__)

3772

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

3773

# define LT@&t@_DLSYM_CONST

3774

#else

3775

# define LT@&t@_DLSYM_CONST const

3776

#endif

3777

3453

3778

#ifdef __cplusplus

3454

3779

extern "C" {

3455

3780

#endif

3461

3786

cat <<_LT_EOF >> conftest.$ac_ext

3462

3787

3463

3788

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

3464

const struct {

3789

LT@&t@_DLSYM_CONST struct {

3465

3790

const char *name;

3466

3791

void *address;

3467

3792

}

3487

3812

_LT_EOF

3488

3813

# Now try linking the two files.

3489

3814

mv conftest.$ac_objext conftstm.$ac_objext

3490

lt_save_LIBS="$LIBS"

3491

lt_save_CFLAGS="$CFLAGS"

3815

lt_globsym_save_LIBS=$LIBS

3816

lt_globsym_save_CFLAGS=$CFLAGS

3492

3817

LIBS="conftstm.$ac_objext"

3493

3818

CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"

3494

3819

if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then

3495

3820

pipe_works=yes

3496

3821

fi

3497

LIBS="$lt_save_LIBS"

3498

CFLAGS="$lt_save_CFLAGS"

3822

LIBS=$lt_globsym_save_LIBS

3823

CFLAGS=$lt_globsym_save_CFLAGS

3499

3824

else

3500

3825

echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD

3501

3826

fi

3528

3853

AC_MSG_RESULT(ok)

3529

3854

fi

3530

3855

3856

# Response file support.

3857

if test "$lt_cv_nm_interface" = "MS dumpbin"; then

3858

nm_file_list_spec='@'

3859

elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then

3860

nm_file_list_spec='@'

3861

fi

3862

3531

3863

_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],

3532

3864

[Take the output of nm and produce a listing of raw symbols and C names])

3533

3865

_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],

3538

3870

_LT_DECL([global_symbol_to_c_name_address_lib_prefix],

3539

3871

[lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],

3540

3872

[Transform the output of nm in a C name address pair when lib prefix is needed])

3873

_LT_DECL([], [nm_file_list_spec], [1],

3874

[Specify filename containing input files for $NM])

3541

3875

]) # _LT_CMD_GLOBAL_SYMBOLS

3542

3876

3543

3877

3549

3883

_LT_TAGVAR(lt_prog_compiler_pic, $1)=

3550

3884

_LT_TAGVAR(lt_prog_compiler_static, $1)=

3551

3885

3552

AC_MSG_CHECKING([for $compiler option to produce PIC])

3553

3886

m4_if([$1], [CXX], [

3554

3887

# C++ specific cases for pic, static, wl, etc.

3555

3888

if test "$GXX" = yes; then

3600

3933

# DJGPP does not support shared libraries at all

3601

3934

_LT_TAGVAR(lt_prog_compiler_pic, $1)=

3602

3935

;;

3936

haiku*)

3937

# PIC is the default for Haiku.

3938

# The "-static" flag exists, but is broken.

3939

_LT_TAGVAR(lt_prog_compiler_static, $1)=

3940

;;

3603

3941

interix[[3-9]]*)

3604

3942

# Interix 3.x gcc -fpic/-fPIC options generate broken code.

3605

3943

# Instead, we relocate shared libraries at runtime.

3649

3987

;;

3650

3988

esac

3651

3989

;;

3990

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

3991

# This hack is so that the source file can tell whether it is being

3992

# built for inclusion in a dll (and should export symbols for example).

3993

m4_if([$1], [GCJ], [],

3994

[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])

3995

;;

3652

3996

dgux*)

3653

3997

case $cc_basename in

3654

3998

ec++*)

3738

4082

_LT_TAGVAR(lt_prog_compiler_pic, $1)=

3739

4083

_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

3740

4084

;;

3741

xlc* | xlC*)

3742

# IBM XL 8.0 on PPC

4085

xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*)

4086

# IBM XL 8.0, 9.0 on PPC and BlueGene

3743

4087

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

3744

4088

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'

3745

4089

_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'

3801

4145

;;

3802

4146

solaris*)

3803

4147

case $cc_basename in

3804

CC*)

4148

CC* | sunCC*)

3805

4149

# Sun C++ 4.2, 5.x and Centerline C++

3806

4150

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

3807

4151

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

3905

4249

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'

3906

4250

;;

3907

4251

4252

haiku*)

4253

# PIC is the default for Haiku.

4254

# The "-static" flag exists, but is broken.

4255

_LT_TAGVAR(lt_prog_compiler_static, $1)=

4256

;;

4257

3908

4258

hpux*)

3909

4259

# PIC is the default for 64-bit PA HP-UX, but not for 32-bit

3910

4260

# PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag

3947

4297

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

3948

4298

;;

3949

4299

esac

4300

4301

case $cc_basename in

4302

nvcc*) # Cuda Compiler Driver 2.2

4303

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker '

4304

if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then

4305

_LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)"

4306

fi

4307

;;

4308

esac

3950

4309

else

3951

4310

# PORTME Check for flag to pass linker flags through the system compiler.

3952

4311

case $host_os in

4010

4369

_LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'

4011

4370

_LT_TAGVAR(lt_prog_compiler_static, $1)='--static'

4012

4371

;;

4013

pgcc* | pgf77* | pgf90* | pgf95*)

4372

nagfor*)

4373

# NAG Fortran compiler

4374

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'

4375

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'

4376

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4377

;;

4378

pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)

4014

4379

# Portland Group compilers (*not* the Pentium gcc compiler,

4015

4380

# which looks to be a dead project)

4016

4381

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

4022

4387

# All Alpha code is PIC.

4023

4388

_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

4024

4389

;;

4025

xl*)

4026

# IBM XL C 8.0/Fortran 10.1 on PPC

4390

xl* | bgxl* | bgf* | mpixl*)

4391

# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene

4027

4392

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

4028

4393

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'

4029

4394

_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'

4030

4395

;;

4031

4396

*)

4032

4397

case `$CC -V 2>&1 | sed 5q` in

4398

*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)

4399

# Sun Fortran 8.3 passes all unrecognized flags to the linker

4400

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

4401

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4402

_LT_TAGVAR(lt_prog_compiler_wl, $1)=''

4403

;;

4404

*Sun\ F* | *Sun*Fortran*)

4405

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

4406

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4407

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '

4408

;;

4033

4409

*Sun\ C*)

4034

4410

# Sun C 5.9

4035

4411

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

4036

4412

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4037

4413

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

4038

4414

;;

4039

*Sun\ F*)

4040

# Sun Fortran 8.3 passes all unrecognized flags to the linker

4041

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

4415

*Intel*\ [[CF]]*Compiler*)

4416

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

4417

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

4418

_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'

4419

;;

4420

*Portland\ Group*)

4421

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

4422

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'

4042

4423

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4043

_LT_TAGVAR(lt_prog_compiler_wl, $1)=''

4044

4424

;;

4045

4425

esac

4046

4426

;;

4072

4452

_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

4073

4453

_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

4074

4454

case $cc_basename in

4075

f77* | f90* | f95*)

4455

f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)

4076

4456

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;

4077

4457

*)

4078

4458

_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;

4129

4509

_LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"

4130

4510

;;

4131

4511

esac

4132

AC_MSG_RESULT([$_LT_TAGVAR(lt_prog_compiler_pic, $1)])

4133

_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],

4134

[How to pass a linker flag through the compiler])

4512

4513

AC_CACHE_CHECK([for $compiler option to produce PIC],

4514

[_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)],

4515

[_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)])

4516

_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)

4135

4517

4136

4518

#

4137

4519

# Check to make sure the PIC flag actually works.

4150

4532

_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],

4151

4533

[Additional compiler flags for building library objects])

4152

4534

4535

_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],

4536

[How to pass a linker flag through the compiler])

4153

4537

#

4154

4538

# Check to make sure the static flag actually works.

4155

4539

#

4170

4554

m4_defun([_LT_LINKER_SHLIBS],

4171

4555

[AC_REQUIRE([LT_PATH_LD])dnl

4172

4556

AC_REQUIRE([LT_PATH_NM])dnl

4557

m4_require([_LT_PATH_MANIFEST_TOOL])dnl

4173

4558

m4_require([_LT_FILEUTILS_DEFAULTS])dnl

4174

4559

m4_require([_LT_DECL_EGREP])dnl

4175

4560

m4_require([_LT_DECL_SED])dnl

4178

4563

AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])

4179

4564

m4_if([$1], [CXX], [

4180

4565

_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

4566

_LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']

4181

4567

case $host_os in

4182

4568

aix[[4-9]]*)

4183

4569

# If we're using GNU nm, then we don't want the "-C" option.

4184

4570

# -C means demangle to AIX nm, but means don't demangle with GNU nm

4571

# Also, AIX nm treats weak defined symbols like other global defined

4572

# symbols, whereas GNU nm marks them as "W".

4185

4573

if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then

4186

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4574

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4187

4575

else

4188

4576

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4189

4577

fi

4190

4578

;;

4191

4579

pw32*)

4192

4580

_LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"

4193

;;

4581

;;

4194

4582

cygwin* | mingw* | cegcc*)

4195

_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]$[[^ ]]*$/\1 DATA/;/^.*[[ ]]__nm__/s/^.*[[ ]]__nm__$[[^ ]]*$[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'

4196

;;

4197

linux* | k*bsd*-gnu)

4583

case $cc_basename in

4584

cl*)

4585

_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'

4586

;;

4587

*)

4588

_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]$[[^ ]]*$/\1 DATA/;s/^.*[[ ]]__nm__$[[^ ]]*$[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'

4589

_LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']

4590

;;

4591

esac

4592

;;

4593

linux* | k*bsd*-gnu | gnu*)

4198

4594

_LT_TAGVAR(link_all_deplibs, $1)=no

4199

;;

4595

;;

4200

4596

*)

4201

4597

_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

4202

;;

4598

;;

4203

4599

esac

4204

_LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']

4205

4600

], [

4206

4601

runpath_var=

4207

4602

_LT_TAGVAR(allow_undefined_flag, $1)=

4216

4611

_LT_TAGVAR(hardcode_direct, $1)=no

4217

4612

_LT_TAGVAR(hardcode_direct_absolute, $1)=no

4218

4613

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=

4219

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

4220

4614

_LT_TAGVAR(hardcode_libdir_separator, $1)=

4221

4615

_LT_TAGVAR(hardcode_minus_L, $1)=no

4222

4616

_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

4261

4655

openbsd*)

4262

4656

with_gnu_ld=no

4263

4657

;;

4264

linux* | k*bsd*-gnu)

4658

linux* | k*bsd*-gnu | gnu*)

4265

4659

_LT_TAGVAR(link_all_deplibs, $1)=no

4266

4660

;;

4267

4661

esac

4268

4662

4269

4663

_LT_TAGVAR(ld_shlibs, $1)=yes

4664

4665

# On some targets, GNU ld is compatible enough with the native linker

4666

# that we're better off using the native interface for both.

4667

lt_use_gnu_ld_interface=no

4270

4668

if test "$with_gnu_ld" = yes; then

4669

case $host_os in

4670

aix*)

4671

# The AIX port of GNU ld has always aspired to compatibility

4672

# with the native linker. However, as the warning in the GNU ld

4673

# block says, versions before 2.19.5* couldn't really create working

4674

# shared libraries, regardless of the interface used.

4675

case `$LD -v 2>&1` in

4676

*\ $GNU\ Binutils$\ 2.19.5*) ;;

4677

*\ $GNU\ Binutils$\ 2.[[2-9]]*) ;;

4678

*\ $GNU\ Binutils$\ [[3-9]]*) ;;

4679

*)

4680

lt_use_gnu_ld_interface=yes

4681

;;

4682

esac

4683

;;

4684

*)

4685

lt_use_gnu_ld_interface=yes

4686

;;

4687

esac

4688

fi

4689

4690

if test "$lt_use_gnu_ld_interface" = yes; then

4271

4691

# If archive_cmds runs LD, not CC, wlarc should be empty

4272

4692

wlarc='${wl}'

4273

4693

4301

4721

_LT_TAGVAR(ld_shlibs, $1)=no

4302

4722

cat <<_LT_EOF 1>&2

4303

4723

4304

*** Warning: the GNU linker, at least up to release 2.9.1, is reported

4724

*** Warning: the GNU linker, at least up to release 2.19, is reported

4305

4725

*** to be unable to reliably create shared libraries on AIX.

4306

4726

*** Therefore, libtool is disabling shared libraries support. If you

4307

*** really care for shared libraries, you may want to modify your PATH

4308

*** so that a non-GNU linker is found, and then restart.

4727

*** really care for shared libraries, you may want to install binutils

4728

*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.

4729

*** You will then need to restart the configuration process.

4309

4730

4310

4731

_LT_EOF

4311

4732

fi

4341

4762

# _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

4342

4763

# as there is no search path for DLLs.

4343

4764

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

4765

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'

4344

4766

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

4345

4767

_LT_TAGVAR(always_export_symbols, $1)=no

4346

4768

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

4347

4769

_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]$[[^ ]]*$/\1 DATA/;s/^.*[[ ]]__nm__$[[^ ]]*$[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'

4770

_LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']

4348

4771

4349

4772

if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then

4350

4773

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

4362

4785

fi

4363

4786

;;

4364

4787

4788

haiku*)

4789

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4790

_LT_TAGVAR(link_all_deplibs, $1)=yes

4791

;;

4792

4365

4793

interix[[3-9]]*)

4366

4794

_LT_TAGVAR(hardcode_direct, $1)=no

4367

4795

_LT_TAGVAR(hardcode_shlibpath_var, $1)=no

4387

4815

if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \

4388

4816

&& test "$tmp_diet" = no

4389

4817

then

4390

tmp_addflag=

4818

tmp_addflag=' $pic_flag'

4391

4819

tmp_sharedflag='-shared'

4392

4820

case $cc_basename,$host_cpu in

4393

4821

pgcc*) # Portland Group C compiler

4394

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'

4822

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

4395

4823

tmp_addflag=' $pic_flag'

4396

4824

;;

4397

pgf77* | pgf90* | pgf95*) # Portland Group f77 and f90 compilers

4398

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'

4825

pgf77* | pgf90* | pgf95* | pgfortran*)

4826

# Portland Group f77 and f90 compilers

4827

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

4399

4828

tmp_addflag=' $pic_flag -Mnomain' ;;

4400

4829

ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64

4401

4830

tmp_addflag=' -i_dynamic' ;;

4406

4835

lf95*) # Lahey Fortran 8.1

4407

4836

_LT_TAGVAR(whole_archive_flag_spec, $1)=

4408

4837

tmp_sharedflag='--shared' ;;

4409

xl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)

4838

xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)

4410

4839

tmp_sharedflag='-qmkshrobj'

4411

4840

tmp_addflag= ;;

4841

nvcc*) # Cuda Compiler Driver 2.2

4842

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

4843

_LT_TAGVAR(compiler_needs_object, $1)=yes

4844

;;

4412

4845

esac

4413

4846

case `$CC -V 2>&1 | sed 5q` in

4414

4847

*Sun\ C*) # Sun C 5.9

4415

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'

4848

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

4416

4849

_LT_TAGVAR(compiler_needs_object, $1)=yes

4417

4850

tmp_sharedflag='-G' ;;

4418

4851

*Sun\ F*) # Sun Fortran 8.3

4428

4861

fi

4429

4862

4430

4863

case $cc_basename in

4431

xlf*)

4864

xlf* | bgf* | bgxlf* | mpixlf*)

4432

4865

# IBM XL Fortran 10.1 on PPC cannot create shared libs itself

4433

4866

_LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'

4434

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=

4435

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'

4436

_LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -o $lib'

4867

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

4868

_LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'

4437

4869

if test "x$supports_anon_versioning" = xyes; then

4438

4870

_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~

4439

4871

cat $export_symbols | sed -e "s/$.*$/\1;/" >> $output_objdir/$libname.ver~

4440

4872

echo "local: *; };" >> $output_objdir/$libname.ver~

4441

$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'

4873

$LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'

4442

4874

fi

4443

4875

;;

4444

4876

esac

4452

4884

_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

4453

4885

wlarc=

4454

4886

else

4455

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4456

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4887

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4888

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4457

4889

fi

4458

4890

;;

4459

4891

4471

4903

4472

4904

_LT_EOF

4473

4905

elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then

4474

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4475

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4906

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4907

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4476

4908

else

4477

4909

_LT_TAGVAR(ld_shlibs, $1)=no

4478

4910

fi

4518

4950

4519

4951

*)

4520

4952

if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then

4521

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4522

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4953

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

4954

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

4523

4955

else

4524

4956

_LT_TAGVAR(ld_shlibs, $1)=no

4525

4957

fi

4559

4991

else

4560

4992

# If we're using GNU nm, then we don't want the "-C" option.

4561

4993

# -C means demangle to AIX nm, but means don't demangle with GNU nm

4994

# Also, AIX nm treats weak defined symbols like other global

4995

# defined symbols, whereas GNU nm marks them as "W".

4562

4996

if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then

4563

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4997

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4564

4998

else

4565

4999

_LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'

4566

5000

fi

4648

5082

_LT_TAGVAR(allow_undefined_flag, $1)='-berok'

4649

5083

# Determine the default libpath from the value encoded in an

4650

5084

# empty executable.

4651

_LT_SYS_MODULE_PATH_AIX

5085

_LT_SYS_MODULE_PATH_AIX([$1])

4652

5086

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

4653

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

5087

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

4654

5088

else

4655

5089

if test "$host_cpu" = ia64; then

4656

5090

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

4659

5093

else

4660

5094

# Determine the default libpath from the value encoded in an

4661

5095

# empty executable.

4662

_LT_SYS_MODULE_PATH_AIX

5096

_LT_SYS_MODULE_PATH_AIX([$1])

4663

5097

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

4664

5098

# Warning - without using the other run time loading flags,

4665

5099

# -berok will link without error, but may produce a broken library.

4666

5100

_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

4667

5101

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

4668

# Exported symbols can be pulled into shared objects from archives

4669

_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

5102

if test "$with_gnu_ld" = yes; then

5103

# We only use this code for GNU lds that support --whole-archive.

5104

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'

5105

else

5106

# Exported symbols can be pulled into shared objects from archives

5107

_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

5108

fi

4670

5109

_LT_TAGVAR(archive_cmds_need_lc, $1)=yes

4671

5110

# This is similar to how AIX traditionally builds its shared libraries.

4672

5111

_LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

4698

5137

# Microsoft Visual C++.

4699

5138

# hardcode_libdir_flag_spec is actually meaningless, as there is

4700

5139

# no search path for DLLs.

4701

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

4702

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

4703

# Tell ltmain to make .lib files, not .a files.

4704

libext=lib

4705

# Tell ltmain to make .dll files, not .so files.

4706

shrext_cmds=".dll"

4707

# FIXME: Setting linknames here is a bad hack.

4708

_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `$ECHO "X$deplibs" | $Xsed -e '\''s/ -lc$//'\''` -link -dll~linknames='

4709

# The linker will automatically build a .lib file if we build a DLL.

4710

_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'

4711

# FIXME: Should let the user specify the lib program.

4712

_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'

4713

_LT_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'

4714

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

5140

case $cc_basename in

5141

cl*)

5142

# Native MSVC

5143

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

5144

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

5145

_LT_TAGVAR(always_export_symbols, $1)=yes

5146

_LT_TAGVAR(file_list_spec, $1)='@'

5147

# Tell ltmain to make .lib files, not .a files.

5148

libext=lib

5149

# Tell ltmain to make .dll files, not .so files.

5150

shrext_cmds=".dll"

5151

# FIXME: Setting linknames here is a bad hack.

5152

_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='

5153

_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

5154

sed -n -e 's/\\\\\\$.*\\\\\\$/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;

5155

else

5156

sed -e 's/\\\\\\$.*\\\\\\$/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;

5157

fi~

5158

$CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~

5159

linknames='

5160

# The linker will not automatically build a static lib if we build a DLL.

5161

# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'

5162

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

5163

_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'

5164

5165

# Don't use ranlib

5166

_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'

5167

_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~

5168

lt_tool_outputfile="@TOOL_OUTPUT@"~

5169

case $lt_outputfile in

5170

*.exe|*.EXE) ;;

5171

*)

5172

lt_outputfile="$lt_outputfile.exe"

5173

lt_tool_outputfile="$lt_tool_outputfile.exe"

5174

;;

5175

esac~

5176

if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then

5177

$MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;

5178

$RM "$lt_outputfile.manifest";

5179

fi'

5180

;;

5181

*)

5182

# Assume MSVC wrapper

5183

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

5184

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

5185

# Tell ltmain to make .lib files, not .a files.

5186

libext=lib

5187

# Tell ltmain to make .dll files, not .so files.

5188

shrext_cmds=".dll"

5189

# FIXME: Setting linknames here is a bad hack.

5190

_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='

5191

# The linker will automatically build a .lib file if we build a DLL.

5192

_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'

5193

# FIXME: Should let the user specify the lib program.

5194

_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'

5195

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

5196

;;

5197

esac

4715

5198

;;

4716

5199

4717

5200

darwin* | rhapsody*)

4724

5207

_LT_TAGVAR(hardcode_shlibpath_var, $1)=no

4725

5208

;;

4726

5209

4727

freebsd1*)

4728

_LT_TAGVAR(ld_shlibs, $1)=no

4729

;;

4730

4731

5210

# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

4732

5211

# support. Future versions do this automatically, but an explicit c++rt0.o

4733

5212

# does not break anything, and helps significantly (at the cost of a little

4740

5219

;;

4741

5220

4742

5221

# Unfortunately, older versions of FreeBSD 2 do not have this feature.

4743

freebsd2*)

5222

freebsd2.*)

4744

5223

_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

4745

5224

_LT_TAGVAR(hardcode_direct, $1)=yes

4746

5225

_LT_TAGVAR(hardcode_minus_L, $1)=yes

4749

5228

4750

5229

# FreeBSD 3 and greater uses gcc -shared to do shared libraries.

4751

5230

freebsd* | dragonfly*)

4752

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

5231

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

4753

5232

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

4754

5233

_LT_TAGVAR(hardcode_direct, $1)=yes

4755

5234

_LT_TAGVAR(hardcode_shlibpath_var, $1)=no

4757

5236

4758

5237

hpux9*)

4759

5238

if test "$GCC" = yes; then

4760

_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

5239

_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

4761

5240

else

4762

5241

_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

4763

5242

fi

4772

5251

;;

4773

5252

4774

5253

hpux10*)

4775

if test "$GCC" = yes -a "$with_gnu_ld" = no; then

4776

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

5254

if test "$GCC" = yes && test "$with_gnu_ld" = no; then

5255

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

4777

5256

else

4778

5257

_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

4779

5258

fi

4780

5259

if test "$with_gnu_ld" = no; then

4781

5260

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

4782

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'

4783

5261

_LT_TAGVAR(hardcode_libdir_separator, $1)=:

4784

5262

_LT_TAGVAR(hardcode_direct, $1)=yes

4785

5263

_LT_TAGVAR(hardcode_direct_absolute, $1)=yes

4791

5269

;;

4792

5270

4793

5271

hpux11*)

4794

if test "$GCC" = yes -a "$with_gnu_ld" = no; then

5272

if test "$GCC" = yes && test "$with_gnu_ld" = no; then

4795

5273

case $host_cpu in

4796

5274

hppa*64*)

4797

5275

_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

4798

5276

;;

4799

5277

ia64*)

4800

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

5278

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

4801

5279

;;

4802

5280

*)

4803

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

5281

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

4804

5282

;;

4805

5283

esac

4806

5284

else

4812

5290

_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'

4813

5291

;;

4814

5292

*)

4815

_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

5293

m4_if($1, [], [

5294

# Older versions of the 11.00 compiler do not understand -b yet

5295

# (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)

5296

_LT_LINKER_OPTION([if $CC understands -b],

5297

_LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],

5298

[_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],

5299

[_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],

5300

[_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])

4816

5301

;;

4817

5302

esac

4818

5303

fi

4840

5325

4841

5326

irix5* | irix6* | nonstopux*)

4842

5327

if test "$GCC" = yes; then

4843

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

5328

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

4844

5329

# Try to use the -exported_symbol ld option, if it does not

4845

5330

# work, assume that -exports_file does not work either and

4846

5331

# implicitly export all symbols.

4847

save_LDFLAGS="$LDFLAGS"

4848

LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"

4849

AC_LINK_IFELSE(int foo(void) {},

4850

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'

4851

)

4852

LDFLAGS="$save_LDFLAGS"

5332

# This should be the same for all languages, so no per-tag cache variable.

5333

AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],

5334

[lt_cv_irix_exported_symbol],

5335

[save_LDFLAGS="$LDFLAGS"

5336

LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"

5337

AC_LINK_IFELSE(

5338

[AC_LANG_SOURCE(

5339

[AC_LANG_CASE([C], [[int foo (void) { return 0; }]],

5340

[C++], [[int foo (void) { return 0; }]],

5341

[Fortran 77], [[

5342

subroutine foo

5343

end]],

5344

[Fortran], [[

5345

subroutine foo

5346

end]])])],

5347

[lt_cv_irix_exported_symbol=yes],

5348

[lt_cv_irix_exported_symbol=no])

5349

LDFLAGS="$save_LDFLAGS"])

5350

if test "$lt_cv_irix_exported_symbol" = yes; then

5351

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'

5352

fi

4853

5353

else

4854

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

4855

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'

5354

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

5355

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'

4856

5356

fi

4857

5357

_LT_TAGVAR(archive_cmds_need_lc, $1)='no'

4858

5358

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

4914

5414

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

4915

5415

_LT_TAGVAR(hardcode_minus_L, $1)=yes

4916

5416

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

4917

_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$ECHO DATA >> $output_objdir/$libname.def~$ECHO " SINGLE NONSHARED" >> $output_objdir/$libname.def~$ECHO EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

5417

_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

4918

5418

_LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

4919

5419

;;

4920

5420

4921

5421

osf3*)

4922

5422

if test "$GCC" = yes; then

4923

5423

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

4924

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

5424

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

4925

5425

else

4926

5426

_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

4927

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

5427

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

4928

5428

fi

4929

5429

_LT_TAGVAR(archive_cmds_need_lc, $1)='no'

4930

5430

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

4934

5434

osf4* | osf5*) # as osf3* with the addition of -msym flag

4935

5435

if test "$GCC" = yes; then

4936

5436

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

4937

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

5437

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

4938

5438

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

4939

5439

else

4940

5440

_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

4941

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

5441

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

4942

5442

_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~

4943

$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'

5443

$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'

4944

5444

4945

5445

# Both c and cxx compiler support -rpath directly

4946

5446

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

4953

5453

_LT_TAGVAR(no_undefined_flag, $1)=' -z defs'

4954

5454

if test "$GCC" = yes; then

4955

5455

wlarc='${wl}'

4956

_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

5456

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

4957

5457

_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~

4958

$CC -shared ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'

5458

$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'

4959

5459

else

4960

5460

case `$CC -V 2>&1` in

4961

5461

*"Compilers 5.0"*)

5131

5631

# Test whether the compiler implicitly links with -lc since on some

5132

5632

# systems, -lgcc has to come before -lc. If gcc already passes -lc

5133

5633

# to ld, don't add -lc before -lgcc.

5134

AC_MSG_CHECKING([whether -lc should be explicitly linked in])

5135

$RM conftest*

5136

echo "$lt_simple_compile_test_code" > conftest.$ac_ext

5634

AC_CACHE_CHECK([whether -lc should be explicitly linked in],

5635

[lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1),

5636

[$RM conftest*

5637

echo "$lt_simple_compile_test_code" > conftest.$ac_ext

5137

5638

5138

if AC_TRY_EVAL(ac_compile) 2>conftest.err; then

5139

soname=conftest

5140

lib=conftest

5141

libobjs=conftest.$ac_objext

5142

deplibs=

5143

wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)

5144

pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)

5145

compiler_flags=-v

5146

linker_flags=-v

5147

verstring=

5148

output_objdir=.

5149

libname=conftest

5150

lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)

5151

_LT_TAGVAR(allow_undefined_flag, $1)=

5152

if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)

5153

then

5154

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

5155

else

5156

_LT_TAGVAR(archive_cmds_need_lc, $1)=yes

5157

fi

5158

_LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag

5159

else

5160

cat conftest.err 1>&5

5161

fi

5162

$RM conftest*

5163

AC_MSG_RESULT([$_LT_TAGVAR(archive_cmds_need_lc, $1)])

5639

if AC_TRY_EVAL(ac_compile) 2>conftest.err; then

5640

soname=conftest

5641

lib=conftest

5642

libobjs=conftest.$ac_objext

5643

deplibs=

5644

wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)

5645

pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)

5646

compiler_flags=-v

5647

linker_flags=-v

5648

verstring=

5649

output_objdir=.

5650

libname=conftest

5651

lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)

5652

_LT_TAGVAR(allow_undefined_flag, $1)=

5653

if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)

5654

then

5655

lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no

5656

else

5657

lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes

5658

fi

5659

_LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag

5660

else

5661

cat conftest.err 1>&5

5662

fi

5663

$RM conftest*

5664

])

5665

_LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)

5164

5666

;;

5165

5667

esac

5166

5668

fi

5197

5699

_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],

5198

5700

[Flag to hardcode $libdir into a binary during linking.

5199

5701

This must work even if $libdir does not exist])

5200

_LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1],

5201

[[If ld is used when linking, flag to hardcode $libdir into a binary

5202

during linking. This must work even if $libdir does not exist]])

5203

5702

_LT_TAGDECL([], [hardcode_libdir_separator], [1],

5204

5703

[Whether we need a single "-rpath" flag with a separated argument])

5205

5704

_LT_TAGDECL([], [hardcode_direct], [0],

5225

5724

to runtime path list])

5226

5725

_LT_TAGDECL([], [link_all_deplibs], [0],

5227

5726

[Whether libtool must link a program against all its dependency libraries])

5228

_LT_TAGDECL([], [fix_srcfile_path], [1],

5229

[Fix the shell variable $srcfile for the compiler])

5230

5727

_LT_TAGDECL([], [always_export_symbols], [0],

5231

5728

[Set to "yes" if exported symbols are required])

5232

5729

_LT_TAGDECL([], [export_symbols_cmds], [2],

5237

5734

[Symbols that must always be exported])

5238

5735

_LT_TAGDECL([], [prelink_cmds], [2],

5239

5736

[Commands necessary for linking programs (against libraries) with templates])

5737

_LT_TAGDECL([], [postlink_cmds], [2],

5738

[Commands necessary for finishing linking programs])

5240

5739

_LT_TAGDECL([], [file_list_spec], [1],

5241

5740

[Specify filename containing input files])

5242

5741

dnl FIXME: Not yet implemented

5330

5829

])# _LT_LANG_C_CONFIG

5331

5830

5332

5831

5333

# _LT_PROG_CXX

5334

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

5335

# Since AC_PROG_CXX is broken, in that it returns g++ if there is no c++

5336

# compiler, we have our own version here.

5337

m4_defun([_LT_PROG_CXX],

5338

[

5339

pushdef([AC_MSG_ERROR], [_lt_caught_CXX_error=yes])

5340

AC_PROG_CXX

5832

# _LT_LANG_CXX_CONFIG([TAG])

5833

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

5834

# Ensure that the configuration variables for a C++ compiler are suitably

5835

# defined. These variables are subsequently used by _LT_CONFIG to write

5836

# the compiler configuration to `libtool'.

5837

m4_defun([_LT_LANG_CXX_CONFIG],

5838

[m4_require([_LT_FILEUTILS_DEFAULTS])dnl

5839

m4_require([_LT_DECL_EGREP])dnl

5840

m4_require([_LT_PATH_MANIFEST_TOOL])dnl

5341

5841

if test -n "$CXX" && ( test "X$CXX" != "Xno" &&

5342

5842

( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||

5343

5843

(test "X$CXX" != "Xg++"))) ; then

5345

5845

else

5346

5846

_lt_caught_CXX_error=yes

5347

5847

fi

5348

popdef([AC_MSG_ERROR])

5349

])# _LT_PROG_CXX

5350

5351

dnl aclocal-1.4 backwards compatibility:

5352

dnl AC_DEFUN([_LT_PROG_CXX], [])

5353

5354

5355

# _LT_LANG_CXX_CONFIG([TAG])

5356

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

5357

# Ensure that the configuration variables for a C++ compiler are suitably

5358

# defined. These variables are subsequently used by _LT_CONFIG to write

5359

# the compiler configuration to `libtool'.

5360

m4_defun([_LT_LANG_CXX_CONFIG],

5361

[AC_REQUIRE([_LT_PROG_CXX])dnl

5362

m4_require([_LT_FILEUTILS_DEFAULTS])dnl

5363

m4_require([_LT_DECL_EGREP])dnl

5364

5848

5365

5849

AC_LANG_PUSH(C++)

5366

5850

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

5372

5856

_LT_TAGVAR(hardcode_direct, $1)=no

5373

5857

_LT_TAGVAR(hardcode_direct_absolute, $1)=no

5374

5858

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=

5375

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

5376

5859

_LT_TAGVAR(hardcode_libdir_separator, $1)=

5377

5860

_LT_TAGVAR(hardcode_minus_L, $1)=no

5378

5861

_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

5382

5865

_LT_TAGVAR(module_expsym_cmds, $1)=

5383

5866

_LT_TAGVAR(link_all_deplibs, $1)=unknown

5384

5867

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

5868

_LT_TAGVAR(reload_flag, $1)=$reload_flag

5869

_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

5385

5870

_LT_TAGVAR(no_undefined_flag, $1)=

5386

5871

_LT_TAGVAR(whole_archive_flag_spec, $1)=

5387

5872

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

5413

5898

5414

5899

# Allow CC to be a program name with arguments.

5415

5900

lt_save_CC=$CC

5901

lt_save_CFLAGS=$CFLAGS

5416

5902

lt_save_LD=$LD

5417

5903

lt_save_GCC=$GCC

5418

5904

GCC=$GXX

5430

5916

fi

5431

5917

test -z "${LDCXX+set}" || LD=$LDCXX

5432

5918

CC=${CXX-"c++"}

5919

CFLAGS=$CXXFLAGS

5433

5920

compiler=$CC

5434

5921

_LT_TAGVAR(compiler, $1)=$CC

5435

5922

_LT_CC_BASENAME([$compiler])

5451

5938

# Check if GNU C++ uses GNU ld as the underlying linker, since the

5452

5939

# archiving commands below assume that GNU ld is being used.

5453

5940

if test "$with_gnu_ld" = yes; then

5454

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

5455

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

5941

_LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

5942

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

5456

5943

5457

5944

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

5458

5945

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

5484

5971

# Commands to make compiler produce verbose output that lists

5485

5972

# what "hidden" libraries, object files and flags are used when

5486

5973

# linking a shared library.

5487

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'

5974

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

5488

5975

5489

5976

else

5490

5977

GXX=no

5593

6080

_LT_TAGVAR(allow_undefined_flag, $1)='-berok'

5594

6081

# Determine the default libpath from the value encoded in an empty

5595

6082

# executable.

5596

_LT_SYS_MODULE_PATH_AIX

6083

_LT_SYS_MODULE_PATH_AIX([$1])

5597

6084

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

5598

6085

5599

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

6086

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"

5600

6087

else

5601

6088

if test "$host_cpu" = ia64; then

5602

6089

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

5605

6092

else

5606

6093

# Determine the default libpath from the value encoded in an

5607

6094

# empty executable.

5608

_LT_SYS_MODULE_PATH_AIX

6095

_LT_SYS_MODULE_PATH_AIX([$1])

5609

6096

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

5610

6097

# Warning - without using the other run time loading flags,

5611

6098

# -berok will link without error, but may produce a broken library.

5612

6099

_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

5613

6100

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

5614

# Exported symbols can be pulled into shared objects from archives

5615

_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

6101

if test "$with_gnu_ld" = yes; then

6102

# We only use this code for GNU lds that support --whole-archive.

6103

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'

6104

else

6105

# Exported symbols can be pulled into shared objects from archives

6106

_LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'

6107

fi

5616

6108

_LT_TAGVAR(archive_cmds_need_lc, $1)=yes

5617

6109

# This is similar to how AIX traditionally builds its shared

5618

6110

# libraries.

5642

6134

;;

5643

6135

5644

6136

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

5645

# _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

5646

# as there is no search path for DLLs.

5647

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

5648

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

5649

_LT_TAGVAR(always_export_symbols, $1)=no

5650

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

6137

case $GXX,$cc_basename in

6138

,cl* | no,cl*)

6139

# Native MSVC

6140

# hardcode_libdir_flag_spec is actually meaningless, as there is

6141

# no search path for DLLs.

6142

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

6143

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

6144

_LT_TAGVAR(always_export_symbols, $1)=yes

6145

_LT_TAGVAR(file_list_spec, $1)='@'

6146

# Tell ltmain to make .lib files, not .a files.

6147

libext=lib

6148

# Tell ltmain to make .dll files, not .so files.

6149

shrext_cmds=".dll"

6150

# FIXME: Setting linknames here is a bad hack.

6151

_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='

6152

_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

6153

$SED -n -e 's/\\\\\\$.*\\\\\\$/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;

6154

else

6155

$SED -e 's/\\\\\\$.*\\\\\\$/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;

6156

fi~

6157

$CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~

6158

linknames='

6159

# The linker will not automatically build a static lib if we build a DLL.

6160

# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'

6161

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

6162

# Don't use ranlib

6163

_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'

6164

_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~

6165

lt_tool_outputfile="@TOOL_OUTPUT@"~

6166

case $lt_outputfile in

6167

*.exe|*.EXE) ;;

6168

*)

6169

lt_outputfile="$lt_outputfile.exe"

6170

lt_tool_outputfile="$lt_tool_outputfile.exe"

6171

;;

6172

esac~

6173

func_to_tool_file "$lt_outputfile"~

6174

if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then

6175

$MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;

6176

$RM "$lt_outputfile.manifest";

6177

fi'

6178

;;

6179

*)

6180

# g++

6181

# _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

6182

# as there is no search path for DLLs.

6183

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

6184

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'

6185

_LT_TAGVAR(allow_undefined_flag, $1)=unsupported

6186

_LT_TAGVAR(always_export_symbols, $1)=no

6187

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

5651

6188

5652

if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then

5653

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

5654

# If the export-symbols file already is a .def file (1st line

5655

# is EXPORTS), use it as is; otherwise, prepend...

5656

_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

5657

cp $export_symbols $output_objdir/$soname.def;

5658

else

5659

echo EXPORTS > $output_objdir/$soname.def;

5660

cat $export_symbols >> $output_objdir/$soname.def;

5661

fi~

5662

$CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

5663

else

5664

_LT_TAGVAR(ld_shlibs, $1)=no

5665

fi

5666

;;

6189

if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then

6190

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

6191

# If the export-symbols file already is a .def file (1st line

6192

# is EXPORTS), use it as is; otherwise, prepend...

6193

_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

6194

cp $export_symbols $output_objdir/$soname.def;

6195

else

6196

echo EXPORTS > $output_objdir/$soname.def;

6197

cat $export_symbols >> $output_objdir/$soname.def;

6198

fi~

6199

$CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'

6200

else

6201

_LT_TAGVAR(ld_shlibs, $1)=no

6202

fi

6203

;;

6204

esac

6205

;;

5667

6206

darwin* | rhapsody*)

5668

6207

_LT_DARWIN_LINKER_FEATURES($1)

5669

6208

;;

5686

6225

esac

5687

6226

;;

5688

6227

5689

freebsd[[12]]*)

6228

freebsd2.*)

5690

6229

# C++ shared libraries reported to be fairly broken before

5691

6230

# switch to ELF

5692

6231

_LT_TAGVAR(ld_shlibs, $1)=no

5705

6244

gnu*)

5706

6245

;;

5707

6246

6247

haiku*)

6248

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

6249

_LT_TAGVAR(link_all_deplibs, $1)=yes

6250

;;

6251

5708

6252

hpux9*)

5709

6253

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

5710

6254

_LT_TAGVAR(hardcode_libdir_separator, $1)=:

5729

6273

# explicitly linking system object files so we need to strip them

5730

6274

# from the output so that they don't get included in the library

5731

6275

# dependencies.

5732

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'

6276

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

5733

6277

;;

5734

6278

*)

5735

6279

if test "$GXX" = yes; then

5736

_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

6280

_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

5737

6281

else

5738

6282

# FIXME: insert proper C++ library support

5739

6283

_LT_TAGVAR(ld_shlibs, $1)=no

5794

6338

# explicitly linking system object files so we need to strip them

5795

6339

# from the output so that they don't get included in the library

5796

6340

# dependencies.

5797

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'

6341

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

5798

6342

;;

5799

6343

*)

5800

6344

if test "$GXX" = yes; then

5804

6348

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

5805

6349

;;

5806

6350

ia64*)

5807

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

6351

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

5808

6352

;;

5809

6353

*)

5810

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

6354

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

5811

6355

;;

5812

6356

esac

5813

6357

fi

5837

6381

case $cc_basename in

5838

6382

CC*)

5839

6383

# SGI C++

5840

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

6384

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

5841

6385

5842

6386

# Archives containing C++ object files must be created using

5843

6387

# "CC -ar", where "CC" is the IRIX C++ compiler. This is

5848

6392

*)

5849

6393

if test "$GXX" = yes; then

5850

6394

if test "$with_gnu_ld" = no; then

5851

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

6395

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

5852

6396

else

5853

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` -o $lib'

6397

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'

5854

6398

fi

5855

6399

fi

5856

6400

_LT_TAGVAR(link_all_deplibs, $1)=yes

5879

6423

# explicitly linking system object files so we need to strip them

5880

6424

# from the output so that they don't get included in the library

5881

6425

# dependencies.

5882

output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'

6426

output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

5883

6427

5884

6428

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

5885

6429

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

5916

6460

pgCC* | pgcpp*)

5917

6461

# Portland Group C++ compiler

5918

6462

case `$CC -V` in

5919

*pgCC\ [[1-5]]* | *pgcpp\ [[1-5]]*)

6463

*pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)

5920

6464

_LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~

5921

6465

rm -rf $tpldir~

5922

6466

$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~

5923

compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'

6467

compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'

5924

6468

_LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~

5925

6469

rm -rf $tpldir~

5926

6470

$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~

5927

$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~

6471

$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~

5928

6472

$RANLIB $oldlib'

5929

6473

_LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~

5930

6474

rm -rf $tpldir~

5931

6475

$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~

5932

$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'

6476

$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'

5933

6477

_LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~

5934

6478

rm -rf $tpldir~

5935

6479

$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~

5936

$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'

6480

$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'

5937

6481

;;

5938

*) # Version 6 will use weak symbols

6482

*) # Version 6 and above use weak symbols

5939

6483

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'

5940

6484

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'

5941

6485

;;

5943

6487

5944

6488

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

5945

6489

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

5946

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'

6490

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

5947

6491

;;

5948

6492

cxx*)

5949

6493

# Compaq C++

5962

6506

# explicitly linking system object files so we need to strip them

5963

6507

# from the output so that they don't get included in the library

5964

6508

# dependencies.

5965

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`$ECHO "X$templist" | $Xsed -e "s/$^.*ld.*$$ .*ld .*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'

6509

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/$^.*ld.*$$ .*ld .*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'

5966

6510

;;

5967

xl*)

6511

xl* | mpixl* | bgxl*)

5968

6512

# IBM XL 8.0 on PPC, with GNU ld

5969

6513

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

5970

6514

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

5984

6528

_LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

5985

6529

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'

5986

6530

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

5987

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'

6531

_LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'

5988

6532

_LT_TAGVAR(compiler_needs_object, $1)=yes

5989

6533

5990

6534

# Not sure whether something based on

5991

6535

# $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1

5992

6536

# would be better.

5993

output_verbose_link_cmd='echo'

6537

output_verbose_link_cmd='func_echo_all'

5994

6538

5995

6539

# Archives containing C++ object files must be created using

5996

6540

# "CC -xar", where "CC" is the Sun C++ compiler. This is

6059

6603

_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

6060

6604

_LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

6061

6605

fi

6062

output_verbose_link_cmd=echo

6606

output_verbose_link_cmd=func_echo_all

6063

6607

else

6064

6608

_LT_TAGVAR(ld_shlibs, $1)=no

6065

6609

fi

6094

6638

case $host in

6095

6639

osf3*)

6096

6640

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

6097

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && $ECHO "X${wl}-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

6641

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

6098

6642

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

6099

6643

;;

6100

6644

*)

6101

6645

_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

6102

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'

6646

_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

6103

6647

_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~

6104

6648

echo "-hidden">> $lib.exp~

6105

$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~

6649

$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~

6106

6650

$RM $lib.exp'

6107

6651

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

6108

6652

;;

6118

6662

# explicitly linking system object files so we need to strip them

6119

6663

# from the output so that they don't get included in the library

6120

6664

# dependencies.

6121

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`$ECHO "X$templist" | $Xsed -e "s/$^.*ld.*$$ .*ld.*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'

6665

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/$^.*ld.*$$ .*ld.*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

6122

6666

;;

6123

6667

*)

6124

6668

if test "$GXX" = yes && test "$with_gnu_ld" = no; then

6125

6669

_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

6126

6670

case $host in

6127

6671

osf3*)

6128

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

6672

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

6129

6673

;;

6130

6674

*)

6131

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

6675

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

6132

6676

;;

6133

6677

esac

6134

6678

6138

6682

# Commands to make compiler produce verbose output that lists

6139

6683

# what "hidden" libraries, object files and flags are used when

6140

6684

# linking a shared library.

6141

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'

6685

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

6142

6686

6143

6687

else

6144

6688

# FIXME: insert proper C++ library support

6174

6718

6175

6719

solaris*)

6176

6720

case $cc_basename in

6177

CC*)

6721

CC* | sunCC*)

6178

6722

# Sun C++ 4.2, 5.x and Centerline C++

6179

6723

_LT_TAGVAR(archive_cmds_need_lc,$1)=yes

6180

6724

_LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'

6195

6739

esac

6196

6740

_LT_TAGVAR(link_all_deplibs, $1)=yes

6197

6741

6198

output_verbose_link_cmd='echo'

6742

output_verbose_link_cmd='func_echo_all'

6199

6743

6200

6744

# Archives containing C++ object files must be created using

6201

6745

# "CC -xar", where "CC" is the Sun C++ compiler. This is

6215

6759

if test "$GXX" = yes && test "$with_gnu_ld" = no; then

6216

6760

_LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'

6217

6761

if $CC --version | $GREP -v '^2\.7' > /dev/null; then

6218

_LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

6762

_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

6219

6763

_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~

6220

$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

6764

$CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

6221

6765

6222

6766

# Commands to make compiler produce verbose output that lists

6223

6767

# what "hidden" libraries, object files and flags are used when

6224

6768

# linking a shared library.

6225

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'

6769

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

6226

6770

else

6227

6771

# g++ 2.7 appears to require `-G' NOT `-shared' on this

6228

6772

# platform.

6233

6777

# Commands to make compiler produce verbose output that lists

6234

6778

# what "hidden" libraries, object files and flags are used when

6235

6779

# linking a shared library.

6236

output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'

6780

output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

6237

6781

fi

6238

6782

6239

6783

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'

6287

6831

CC*)

6288

6832

_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

6289

6833

_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

6834

_LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~

6835

'"$_LT_TAGVAR(old_archive_cmds, $1)"

6836

_LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~

6837

'"$_LT_TAGVAR(reload_cmds, $1)"

6290

6838

;;

6291

6839

*)

6292

6840

_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'

6342

6890

fi # test -n "$compiler"

6343

6891

6344

6892

CC=$lt_save_CC

6893

CFLAGS=$lt_save_CFLAGS

6345

6894

LDCXX=$LD

6346

6895

LD=$lt_save_LD

6347

6896

GCC=$lt_save_GCC

6356

6905

])# _LT_LANG_CXX_CONFIG

6357

6906

6358

6907

6908

# _LT_FUNC_STRIPNAME_CNF

6909

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

6910

# func_stripname_cnf prefix suffix name

6911

# strip PREFIX and SUFFIX off of NAME.

6912

# PREFIX and SUFFIX must not contain globbing or regex special

6913

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

6914

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

6915

#

6916

# This function is identical to the (non-XSI) version of func_stripname,

6917

# except this one can be used by m4 code that may be executed by configure,

6918

# rather than the libtool script.

6919

m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl

6920

AC_REQUIRE([_LT_DECL_SED])

6921

AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])

6922

func_stripname_cnf ()

6923

{

6924

case ${2} in

6925

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

6926

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

6927

esac

6928

} # func_stripname_cnf

6929

])# _LT_FUNC_STRIPNAME_CNF

6930

6359

6931

# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])

6360

6932

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

6361

6933

# Figure out "hidden" library dependencies from verbose

6364

6936

# objects, libraries and library flags.

6365

6937

m4_defun([_LT_SYS_HIDDEN_LIBDEPS],

6366

6938

[m4_require([_LT_FILEUTILS_DEFAULTS])dnl

6939

AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl

6367

6940

# Dependencies to place before and after the object being linked:

6368

6941

_LT_TAGVAR(predep_objects, $1)=

6369

6942

_LT_TAGVAR(postdep_objects, $1)=

6413

6986

}

6414

6987

};

6415

6988

_LT_EOF

6989

], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF

6990

package foo

6991

func foo() {

6992

}

6993

_LT_EOF

6416

6994

])

6995

6996

_lt_libdeps_save_CFLAGS=$CFLAGS

6997

case "$CC $CFLAGS " in #(

6998

*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;

6999

*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;

7000

*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;

7001

esac

7002

6417

7003

dnl Parse the compiler output and extract the necessary

6418

7004

dnl objects, libraries and library flags.

6419

7005

if AC_TRY_EVAL(ac_compile); then

6425

7011

pre_test_object_deps_done=no

6426

7012

6427

7013

for p in `eval "$output_verbose_link_cmd"`; do

6428

case $p in

7014

case ${prev}${p} in

6429

7015

6430

7016

-L* | -R* | -l*)

6431

7017

# Some compilers place space between "-{L,R}" and the path.

6434

7020

test $p = "-R"; then

6435

7021

prev=$p

6436

7022

continue

6437

else

6438

prev=

6439

7023

fi

6440

7024

7025

# Expand the sysroot to ease extracting the directories later.

7026

if test -z "$prev"; then

7027

case $p in

7028

-L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;

7029

-R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;

7030

-l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;

7031

esac

7032

fi

7033

case $p in

7034

=*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;

7035

esac

6441

7036

if test "$pre_test_object_deps_done" = no; then

6442

case $p in

6443

-L* | -R*)

7037

case ${prev} in

7038

-L | -R)

6444

7039

# Internal compiler library paths should come after those

6445

7040

# provided the user. The postdeps already come after the

6446

7041

# user supplied libs so there is no need to process them.

6460

7055

_LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"

6461

7056

fi

6462

7057

fi

7058

prev=

6463

7059

;;

6464

7060

7061

*.lto.$objext) ;; # Ignore GCC LTO objects

6465

7062

*.$objext)

6466

7063

# This assumes that the test object file only shows up

6467

7064

# once in the compiler output.

6497

7094

fi

6498

7095

6499

7096

$RM -f confest.$objext

7097

CFLAGS=$_lt_libdeps_save_CFLAGS

6500

7098

6501

7099

# PORTME: override above test on systems where it is broken

6502

7100

m4_if([$1], [CXX],

6533

7131

6534

7132

solaris*)

6535

7133

case $cc_basename in

6536

CC*)

7134

CC* | sunCC*)

6537

7135

# The more standards-conforming stlport4 library is

6538

7136

# incompatible with the Cstd library. Avoid specifying

6539

7137

# it if it's in CXXFLAGS. Ignore libCrun as

6577

7175

])# _LT_SYS_HIDDEN_LIBDEPS

6578

7176

6579

7177

6580

# _LT_PROG_F77

6581

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

6582

# Since AC_PROG_F77 is broken, in that it returns the empty string

6583

# if there is no fortran compiler, we have our own version here.

6584

m4_defun([_LT_PROG_F77],

6585

[

6586

pushdef([AC_MSG_ERROR], [_lt_disable_F77=yes])

6587

AC_PROG_F77

6588

if test -z "$F77" || test "X$F77" = "Xno"; then

6589

_lt_disable_F77=yes

6590

fi

6591

popdef([AC_MSG_ERROR])

6592

])# _LT_PROG_F77

6593

6594

dnl aclocal-1.4 backwards compatibility:

6595

dnl AC_DEFUN([_LT_PROG_F77], [])

6596

6597

6598

7178

# _LT_LANG_F77_CONFIG([TAG])

6599

7179

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

6600

7180

# Ensure that the configuration variables for a Fortran 77 compiler are

6601

7181

# suitably defined. These variables are subsequently used by _LT_CONFIG

6602

7182

# to write the compiler configuration to `libtool'.

6603

7183

m4_defun([_LT_LANG_F77_CONFIG],

6604

[AC_REQUIRE([_LT_PROG_F77])dnl

6605

AC_LANG_PUSH(Fortran 77)

7184

[AC_LANG_PUSH(Fortran 77)

7185

if test -z "$F77" || test "X$F77" = "Xno"; then

7186

_lt_disable_F77=yes

7187

fi

6606

7188

6607

7189

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

6608

7190

_LT_TAGVAR(allow_undefined_flag, $1)=

6612

7194

_LT_TAGVAR(hardcode_direct, $1)=no

6613

7195

_LT_TAGVAR(hardcode_direct_absolute, $1)=no

6614

7196

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=

6615

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

6616

7197

_LT_TAGVAR(hardcode_libdir_separator, $1)=

6617

7198

_LT_TAGVAR(hardcode_minus_L, $1)=no

6618

7199

_LT_TAGVAR(hardcode_automatic, $1)=no

6621

7202

_LT_TAGVAR(module_expsym_cmds, $1)=

6622

7203

_LT_TAGVAR(link_all_deplibs, $1)=unknown

6623

7204

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

7205

_LT_TAGVAR(reload_flag, $1)=$reload_flag

7206

_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

6624

7207

_LT_TAGVAR(no_undefined_flag, $1)=

6625

7208

_LT_TAGVAR(whole_archive_flag_spec, $1)=

6626

7209

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

6660

7243

# Allow CC to be a program name with arguments.

6661

7244

lt_save_CC="$CC"

6662

7245

lt_save_GCC=$GCC

7246

lt_save_CFLAGS=$CFLAGS

6663

7247

CC=${F77-"f77"}

7248

CFLAGS=$FFLAGS

6664

7249

compiler=$CC

6665

7250

_LT_TAGVAR(compiler, $1)=$CC

6666

7251

_LT_CC_BASENAME([$compiler])

6714

7299

6715

7300

GCC=$lt_save_GCC

6716

7301

CC="$lt_save_CC"

7302

CFLAGS="$lt_save_CFLAGS"

6717

7303

fi # test "$_lt_disable_F77" != yes

6718

7304

6719

7305

AC_LANG_POP

6720

7306

])# _LT_LANG_F77_CONFIG

6721

7307

6722

7308

6723

# _LT_PROG_FC

6724

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

6725

# Since AC_PROG_FC is broken, in that it returns the empty string

6726

# if there is no fortran compiler, we have our own version here.

6727

m4_defun([_LT_PROG_FC],

6728

[

6729

pushdef([AC_MSG_ERROR], [_lt_disable_FC=yes])

6730

AC_PROG_FC

6731

if test -z "$FC" || test "X$FC" = "Xno"; then

6732

_lt_disable_FC=yes

6733

fi

6734

popdef([AC_MSG_ERROR])

6735

])# _LT_PROG_FC

6736

6737

dnl aclocal-1.4 backwards compatibility:

6738

dnl AC_DEFUN([_LT_PROG_FC], [])

6739

6740

6741

7309

# _LT_LANG_FC_CONFIG([TAG])

6742

7310

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

6743

7311

# Ensure that the configuration variables for a Fortran compiler are

6744

7312

# suitably defined. These variables are subsequently used by _LT_CONFIG

6745

7313

# to write the compiler configuration to `libtool'.

6746

7314

m4_defun([_LT_LANG_FC_CONFIG],

6747

[AC_REQUIRE([_LT_PROG_FC])dnl

6748

AC_LANG_PUSH(Fortran)

7315

[AC_LANG_PUSH(Fortran)

7316

7317

if test -z "$FC" || test "X$FC" = "Xno"; then

7318

_lt_disable_FC=yes

7319

fi

6749

7320

6750

7321

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

6751

7322

_LT_TAGVAR(allow_undefined_flag, $1)=

6755

7326

_LT_TAGVAR(hardcode_direct, $1)=no

6756

7327

_LT_TAGVAR(hardcode_direct_absolute, $1)=no

6757

7328

_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=

6758

_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

6759

7329

_LT_TAGVAR(hardcode_libdir_separator, $1)=

6760

7330

_LT_TAGVAR(hardcode_minus_L, $1)=no

6761

7331

_LT_TAGVAR(hardcode_automatic, $1)=no

6764

7334

_LT_TAGVAR(module_expsym_cmds, $1)=

6765

7335

_LT_TAGVAR(link_all_deplibs, $1)=unknown

6766

7336

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

7337

_LT_TAGVAR(reload_flag, $1)=$reload_flag

7338

_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

6767

7339

_LT_TAGVAR(no_undefined_flag, $1)=

6768

7340

_LT_TAGVAR(whole_archive_flag_spec, $1)=

6769

7341

_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

6803

7375

# Allow CC to be a program name with arguments.

6804

7376

lt_save_CC="$CC"

6805

7377

lt_save_GCC=$GCC

7378

lt_save_CFLAGS=$CFLAGS

6806

7379

CC=${FC-"f95"}

7380

CFLAGS=$FCFLAGS

6807

7381

compiler=$CC

6808

7382

GCC=$ac_cv_fc_compiler_gnu

6809

7383

6859

7433

fi # test -n "$compiler"

6860

7434

6861

7435

GCC=$lt_save_GCC

6862

CC="$lt_save_CC"

7436

CC=$lt_save_CC

7437

CFLAGS=$lt_save_CFLAGS

6863

7438

fi # test "$_lt_disable_FC" != yes

6864

7439

6865

7440

AC_LANG_POP

6896

7471

_LT_LINKER_BOILERPLATE

6897

7472

6898

7473

# Allow CC to be a program name with arguments.

6899

lt_save_CC="$CC"

7474

lt_save_CC=$CC

7475

lt_save_CFLAGS=$CFLAGS

6900

7476

lt_save_GCC=$GCC

6901

7477

GCC=yes

6902

7478

CC=${GCJ-"gcj"}

7479

CFLAGS=$GCJFLAGS

6903

7480

compiler=$CC

6904

7481

_LT_TAGVAR(compiler, $1)=$CC

6905

7482

_LT_TAGVAR(LD, $1)="$LD"

6909

7486

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

6910

7487

6911

7488

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

7489

_LT_TAGVAR(reload_flag, $1)=$reload_flag

7490

_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

6912

7491

6913

7492

## CAVEAT EMPTOR:

6914

7493

## There is no encapsulation within the following macros, do not change

6928

7507

AC_LANG_RESTORE

6929

7508

6930

7509

GCC=$lt_save_GCC

6931

CC="$lt_save_CC"

7510

CC=$lt_save_CC

7511

CFLAGS=$lt_save_CFLAGS

6932

7512

])# _LT_LANG_GCJ_CONFIG

6933

7513

6934

7514

7515

# _LT_LANG_GO_CONFIG([TAG])

7516

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

7517

# Ensure that the configuration variables for the GNU Go compiler

7518

# are suitably defined. These variables are subsequently used by _LT_CONFIG

7519

# to write the compiler configuration to `libtool'.

7520

m4_defun([_LT_LANG_GO_CONFIG],

7521

[AC_REQUIRE([LT_PROG_GO])dnl

7522

AC_LANG_SAVE

7523

7524

# Source file extension for Go test sources.

7525

ac_ext=go

7526

7527

# Object file extension for compiled Go test sources.

7528

objext=o

7529

_LT_TAGVAR(objext, $1)=$objext

7530

7531

# Code to be used in simple compile tests

7532

lt_simple_compile_test_code="package main; func main() { }"

7533

7534

# Code to be used in simple link tests

7535

lt_simple_link_test_code='package main; func main() { }'

7536

7537

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

7538

_LT_TAG_COMPILER

7539

7540

# save warnings/boilerplate of simple test code

7541

_LT_COMPILER_BOILERPLATE

7542

_LT_LINKER_BOILERPLATE

7543

7544

# Allow CC to be a program name with arguments.

7545

lt_save_CC=$CC

7546

lt_save_CFLAGS=$CFLAGS

7547

lt_save_GCC=$GCC

7548

GCC=yes

7549

CC=${GOC-"gccgo"}

7550

CFLAGS=$GOFLAGS

7551

compiler=$CC

7552

_LT_TAGVAR(compiler, $1)=$CC

7553

_LT_TAGVAR(LD, $1)="$LD"

7554

_LT_CC_BASENAME([$compiler])

7555

7556

# Go did not exist at the time GCC didn't implicitly link libc in.

7557

_LT_TAGVAR(archive_cmds_need_lc, $1)=no

7558

7559

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

7560

_LT_TAGVAR(reload_flag, $1)=$reload_flag

7561

_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

7562

7563

## CAVEAT EMPTOR:

7564

## There is no encapsulation within the following macros, do not change

7565

## the running order or otherwise move them around unless you know exactly

7566

## what you are doing...

7567

if test -n "$compiler"; then

7568

_LT_COMPILER_NO_RTTI($1)

7569

_LT_COMPILER_PIC($1)

7570

_LT_COMPILER_C_O($1)

7571

_LT_COMPILER_FILE_LOCKS($1)

7572

_LT_LINKER_SHLIBS($1)

7573

_LT_LINKER_HARDCODE_LIBPATH($1)

7574

7575

_LT_CONFIG($1)

7576

fi

7577

7578

AC_LANG_RESTORE

7579

7580

GCC=$lt_save_GCC

7581

CC=$lt_save_CC

7582

CFLAGS=$lt_save_CFLAGS

7583

])# _LT_LANG_GO_CONFIG

7584

7585

6935

7586

# _LT_LANG_RC_CONFIG([TAG])

6936

7587

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

6937

7588

# Ensure that the configuration variables for the Windows resource compiler

6963

7614

6964

7615

# Allow CC to be a program name with arguments.

6965

7616

lt_save_CC="$CC"

7617

lt_save_CFLAGS=$CFLAGS

6966

7618

lt_save_GCC=$GCC

6967

7619

GCC=

6968

7620

CC=${RC-"windres"}

7621

CFLAGS=

6969

7622

compiler=$CC

6970

7623

_LT_TAGVAR(compiler, $1)=$CC

6971

7624

_LT_CC_BASENAME([$compiler])

6978

7631

6979

7632

GCC=$lt_save_GCC

6980

7633

AC_LANG_RESTORE

6981

CC="$lt_save_CC"

7634

CC=$lt_save_CC

7635

CFLAGS=$lt_save_CFLAGS

6982

7636

])# _LT_LANG_RC_CONFIG

6983

7637

6984

7638

6998

7652

dnl AC_DEFUN([LT_AC_PROG_GCJ], [])

6999

7653

7000

7654

7655

# LT_PROG_GO

7656

# ----------

7657

AC_DEFUN([LT_PROG_GO],

7658

[AC_CHECK_TOOL(GOC, gccgo,)

7659

])

7660

7661

7001

7662

# LT_PROG_RC

7002

7663

# ----------

7003

7664

AC_DEFUN([LT_PROG_RC],

7037

7698

AC_SUBST([OBJDUMP])

7038

7699

])

7039

7700

7701

# _LT_DECL_DLLTOOL

7702

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

7703

# Ensure DLLTOOL variable is set.

7704

m4_defun([_LT_DECL_DLLTOOL],

7705

[AC_CHECK_TOOL(DLLTOOL, dlltool, false)

7706

test -z "$DLLTOOL" && DLLTOOL=dlltool

7707

_LT_DECL([], [DLLTOOL], [1], [DLL creation program])

7708

AC_SUBST([DLLTOOL])

7709

])

7040

7710

7041

7711

# _LT_DECL_SED

7042

7712

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

7130

7800

# Try some XSI features

7131

7801

xsi_shell=no

7132

7802

( _lt_dummy="a/b/c"

7133

test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \

7134

= c,a/b,, \

7803

test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \

7804

= c,a/b,b/c, \

7135

7805

&& eval 'test $(( 1 + 1 )) -eq 2 \

7136

7806

&& test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \

7137

7807

&& xsi_shell=yes

7170

7840

])# _LT_CHECK_SHELL_FEATURES

7171

7841

7172

7842

7173

# _LT_PROG_XSI_SHELLFNS

7174

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

7175

# Bourne and XSI compatible variants of some useful shell functions.

7176

m4_defun([_LT_PROG_XSI_SHELLFNS],

7177

[case $xsi_shell in

7178

yes)

7179

cat << \_LT_EOF >> "$cfgfile"

7180

7181

# func_dirname file append nondir_replacement

7182

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

7183

# otherwise set result to NONDIR_REPLACEMENT.

7184

func_dirname ()

7185

{

7186

case ${1} in

7187

*/*) func_dirname_result="${1%/*}${2}" ;;

7188

* ) func_dirname_result="${3}" ;;

7189

esac

7190

}

7191

7192

# func_basename file

7193

func_basename ()

7194

{

7195

func_basename_result="${1##*/}"

7196

}

7197

7198

# func_dirname_and_basename file append nondir_replacement

7199

# perform func_basename and func_dirname in a single function

7200

# call:

7201

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

7202

# add APPEND to the result, otherwise set result

7203

# to NONDIR_REPLACEMENT.

7204

# value returned in "$func_dirname_result"

7205

# basename: Compute filename of FILE.

7206

# value retuned in "$func_basename_result"

7207

# Implementation must be kept synchronized with func_dirname

7208

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

7209

# those functions but instead duplicate the functionality here.

7210

func_dirname_and_basename ()

7211

{

7212

case ${1} in

7213

*/*) func_dirname_result="${1%/*}${2}" ;;

7214

* ) func_dirname_result="${3}" ;;

7215

esac

7216

func_basename_result="${1##*/}"

7217

}

7218

7219

# func_stripname prefix suffix name

7220

# strip PREFIX and SUFFIX off of NAME.

7221

# PREFIX and SUFFIX must not contain globbing or regex special

7222

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

7223

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

7224

func_stripname ()

7225

{

7226

# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are

7227

# positional parameters, so assign one to ordinary parameter first.

7228

func_stripname_result=${3}

7229

func_stripname_result=${func_stripname_result#"${1}"}

7230

func_stripname_result=${func_stripname_result%"${2}"}

7231

}

7232

7233

# func_opt_split

7234

func_opt_split ()

7235

{

7236

func_opt_split_opt=${1%%=*}

7237

func_opt_split_arg=${1#*=}

7238

}

7239

7240

# func_lo2o object

7241

func_lo2o ()

7242

{

7243

case ${1} in

7244

*.lo) func_lo2o_result=${1%.lo}.${objext} ;;

7245

*) func_lo2o_result=${1} ;;

7246

esac

7247

}

7248

7249

# func_xform libobj-or-source

7250

func_xform ()

7251

{

7252

func_xform_result=${1%.*}.lo

7253

}

7254

7255

# func_arith arithmetic-term...

7256

func_arith ()

7257

{

7258

func_arith_result=$(( $[*] ))

7259

}

7260

7261

# func_len string

7262

# STRING may not start with a hyphen.

7263

func_len ()

7264

{

7265

func_len_result=${#1}

7266

}

7267

7268

_LT_EOF

7269

;;

7270

*) # Bourne compatible functions.

7271

cat << \_LT_EOF >> "$cfgfile"

7272

7273

# func_dirname file append nondir_replacement

7274

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

7275

# otherwise set result to NONDIR_REPLACEMENT.

7276

func_dirname ()

7277

{

7278

# Extract subdirectory from the argument.

7279

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

7280

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

7281

func_dirname_result="${3}"

7282

else

7283

func_dirname_result="$func_dirname_result${2}"

7284

fi

7285

}

7286

7287

# func_basename file

7288

func_basename ()

7289

{

7290

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

7291

}

7292

7293

dnl func_dirname_and_basename

7294

dnl A portable version of this function is already defined in general.m4sh

7295

dnl so there is no need for it here.

7296

7297

# func_stripname prefix suffix name

7298

# strip PREFIX and SUFFIX off of NAME.

7299

# PREFIX and SUFFIX must not contain globbing or regex special

7300

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

7301

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

7302

# func_strip_suffix prefix name

7303

func_stripname ()

7304

{

7305

case ${2} in

7306

.*) func_stripname_result=`$ECHO "X${3}" \

7307

| $Xsed -e "s%^${1}%%" -e "s%\\\\${2}\$%%"`;;

7308

*) func_stripname_result=`$ECHO "X${3}" \

7309

| $Xsed -e "s%^${1}%%" -e "s%${2}\$%%"`;;

7310

esac

7311

}

7312

7313

# sed scripts:

7314

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

7315

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

7316

7317

# func_opt_split

7318

func_opt_split ()

7319

{

7320

func_opt_split_opt=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_opt"`

7321

func_opt_split_arg=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_arg"`

7322

}

7323

7324

# func_lo2o object

7325

func_lo2o ()

7326

{

7327

func_lo2o_result=`$ECHO "X${1}" | $Xsed -e "$lo2o"`

7328

}

7329

7330

# func_xform libobj-or-source

7331

func_xform ()

7332

{

7333

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

7334

}

7335

7336

# func_arith arithmetic-term...

7337

func_arith ()

7338

{

7339

func_arith_result=`expr "$[@]"`

7340

}

7341

7342

# func_len string

7343

# STRING may not start with a hyphen.

7344

func_len ()

7345

{

7346

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

7347

}

7348

7349

_LT_EOF

7350

esac

7351

7352

case $lt_shell_append in

7353

yes)

7354

cat << \_LT_EOF >> "$cfgfile"

7355

7356

# func_append var value

7357

# Append VALUE to the end of shell variable VAR.

7358

func_append ()

7359

{

7360

eval "$[1]+=\$[2]"

7361

}

7362

_LT_EOF

7363

;;

7364

*)

7365

cat << \_LT_EOF >> "$cfgfile"

7366

7367

# func_append var value

7368

# Append VALUE to the end of shell variable VAR.

7369

func_append ()

7370

{

7371

eval "$[1]=\$$[1]\$[2]"

7372

}

7373

7374

_LT_EOF

7375

;;

7376

esac

7377

])

7843

# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY)

7844

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

7845

# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and

7846

# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY.

7847

m4_defun([_LT_PROG_FUNCTION_REPLACE],

7848

[dnl {

7849

sed -e '/^$1 ()$/,/^} # $1 /c\

7850

$1 ()\

7851

{\

7852

m4_bpatsubsts([$2], [$], [\\], [^$[ ]$], [\\\1])

7853

} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \

7854

&& mv -f "$cfgfile.tmp" "$cfgfile" \

7855

|| (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")

7856

test 0 -eq $? || _lt_function_replace_fail=:

7857

])

7858

7859

7860

# _LT_PROG_REPLACE_SHELLFNS

7861

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

7862

# Replace existing portable implementations of several shell functions with

7863

# equivalent extended shell implementations where those features are available..

7864

m4_defun([_LT_PROG_REPLACE_SHELLFNS],

7865

[if test x"$xsi_shell" = xyes; then

7866

_LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl

7867

case ${1} in

7868

*/*) func_dirname_result="${1%/*}${2}" ;;

7869

* ) func_dirname_result="${3}" ;;

7870

esac])

7871

7872

_LT_PROG_FUNCTION_REPLACE([func_basename], [dnl

7873

func_basename_result="${1##*/}"])

7874

7875

_LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl

7876

case ${1} in

7877

*/*) func_dirname_result="${1%/*}${2}" ;;

7878

* ) func_dirname_result="${3}" ;;

7879

esac

7880

func_basename_result="${1##*/}"])

7881

7882

_LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl

7883

# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are

7884

# positional parameters, so assign one to ordinary parameter first.

7885

func_stripname_result=${3}

7886

func_stripname_result=${func_stripname_result#"${1}"}

7887

func_stripname_result=${func_stripname_result%"${2}"}])

7888

7889

_LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl

7890

func_split_long_opt_name=${1%%=*}

7891

func_split_long_opt_arg=${1#*=}])

7892

7893

_LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl

7894

func_split_short_opt_arg=${1#??}

7895

func_split_short_opt_name=${1%"$func_split_short_opt_arg"}])

7896

7897

_LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl

7898

case ${1} in

7899

*.lo) func_lo2o_result=${1%.lo}.${objext} ;;

7900

*) func_lo2o_result=${1} ;;

7901

esac])

7902

7903

_LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo])

7904

7905

_LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))])

7906

7907

_LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}])

7908

fi

7909

7910

if test x"$lt_shell_append" = xyes; then

7911

_LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"])

7912

7913

_LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl

7914

func_quote_for_eval "${2}"

7915

dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \

7916

eval "${1}+=\\\\ \\$func_quote_for_eval_result"])

7917

7918

# Save a `func_append' function call where possible by direct use of '+='

7919

sed -e 's%func_append $[[a-zA-Z_]]\{1,\}$ "%\1+="%g' $cfgfile > $cfgfile.tmp \

7920

&& mv -f "$cfgfile.tmp" "$cfgfile" \

7921

|| (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")

7922

test 0 -eq $? || _lt_function_replace_fail=:

7923

else

7924

# Save a `func_append' function call even when '+=' is not available

7925

sed -e 's%func_append $[[a-zA-Z_]]\{1,\}$ "%\1="$\1%g' $cfgfile > $cfgfile.tmp \

7926

&& mv -f "$cfgfile.tmp" "$cfgfile" \

7927

|| (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")

7928

test 0 -eq $? || _lt_function_replace_fail=:

7929

fi

7930

7931

if test x"$_lt_function_replace_fail" = x":"; then

7932

AC_MSG_WARN([Unable to substitute extended shell functions in $ofile])

7933

fi

7934

])

7935

7936

# _LT_PATH_CONVERSION_FUNCTIONS

7937

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

7938

# Determine which file name conversion functions should be used by

7939

# func_to_host_file (and, implicitly, by func_to_host_path). These are needed

7940

# for certain cross-compile configurations and native mingw.

7941

m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],

7942

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

7943

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

7944

AC_MSG_CHECKING([how to convert $build file names to $host format])

7945

AC_CACHE_VAL(lt_cv_to_host_file_cmd,

7946

[case $host in

7947

*-*-mingw* )

7948

case $build in

7949

*-*-mingw* ) # actually msys

7950

lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32

7951

;;

7952

*-*-cygwin* )

7953

lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32

7954

;;

7955

* ) # otherwise, assume *nix

7956

lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32

7957

;;

7958

esac

7959

;;

7960

*-*-cygwin* )

7961

case $build in

7962

*-*-mingw* ) # actually msys

7963

lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin

7964

;;

7965

*-*-cygwin* )

7966

lt_cv_to_host_file_cmd=func_convert_file_noop

7967

;;

7968

* ) # otherwise, assume *nix

7969

lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin

7970

;;

7971

esac

7972

;;

7973

* ) # unhandled hosts (and "normal" native builds)

7974

lt_cv_to_host_file_cmd=func_convert_file_noop

7975

;;

7976

esac

7977

])

7978

to_host_file_cmd=$lt_cv_to_host_file_cmd

7979

AC_MSG_RESULT([$lt_cv_to_host_file_cmd])

7980

_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd],

7981

[0], [convert $build file names to $host format])dnl

7982

7983

AC_MSG_CHECKING([how to convert $build file names to toolchain format])

7984

AC_CACHE_VAL(lt_cv_to_tool_file_cmd,

7985

[#assume ordinary cross tools, or native build.

7986

lt_cv_to_tool_file_cmd=func_convert_file_noop

7987

case $host in

7988

*-*-mingw* )

7989

case $build in

7990

*-*-mingw* ) # actually msys

7991

lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32

7992

;;

7993

esac

7994

;;

7995

esac

7996

])

7997

to_tool_file_cmd=$lt_cv_to_tool_file_cmd

7998

AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])

7999

_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],

8000

[0], [convert $build files to toolchain format])dnl

8001

])# _LT_PATH_CONVERSION_FUNCTIONS