config/tcl.m4

   1 #------------------------------------------------------------------------
   2 # SC_PATH_TCLCONFIG --
   3 #
   4 #       Locate the tclConfig.sh file and perform a sanity check on
   5 #       the Tcl compile flags
   6 #
   7 # Arguments:
   8 #       none
   9 #
  10 # Results:
  11 #
  12 #       Adds the following arguments to configure:
  13 #               --with-tcl=...
  14 #
  15 #       Defines the following vars:
  16 #               TCL_BIN_DIR     Full path to the directory containing
  17 #                               the tclConfig.sh file
  18 #------------------------------------------------------------------------
  19
  20 AC_DEFUN([SC_PATH_TCLCONFIG], [
  21     #
  22     # Ok, lets find the tcl configuration
  23     # First, look for one uninstalled.
  24     # the alternative search directory is invoked by --with-tcl
  25     #
  26
  27     if test x"${no_tcl}" = x ; then
  28         # we reset no_tcl in case something fails here
  29         no_tcl=true
  30         AC_ARG_WITH(tcl, [  --with-tcl              directory containing tcl configuration (tclConfig.sh)], with_tclconfig=${withval})
  31         AC_MSG_CHECKING([for Tcl configuration])
  32         AC_CACHE_VAL(ac_cv_c_tclconfig,[
  33
  34             # First check to see if --with-tcl was specified.
  35             case "${host}" in
  36                 *-*-cygwin*) platDir="win" ;;
  37                 *) platDir="unix" ;;
  38             esac
  39             if test x"${with_tclconfig}" != x ; then
  40                 if test -f "${with_tclconfig}/tclConfig.sh" ; then
  41                     ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
  42                 else
  43                     AC_MSG_ERROR([${with_tclconfig} directory doesn't contain tclConfig.sh])
  44                 fi
  45             fi
  46
  47             # then check for a private Tcl installation
  48             if test x"${ac_cv_c_tclconfig}" = x ; then
  49                 for i in \
  50                         ../tcl \
  51                         `ls -dr ../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
  52                         `ls -dr ../tcl[[8-9]].[[0-9]] 2>/dev/null` \
  53                         `ls -dr ../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
  54                         ../../tcl \
  55                         `ls -dr ../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
  56                         `ls -dr ../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
  57                         `ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
  58                         ../../../tcl \
  59                         `ls -dr ../../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
  60                         `ls -dr ../../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
  61                         `ls -dr ../../../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
  62                     if test -f "$i/$platDir/tclConfig.sh" ; then
  63                         ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
  64                         break
  65                     fi
  66                 done
  67             fi
  68
  69             # on Darwin, check in Framework installation locations
  70             if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tclconfig}" = x ; then
  71                 for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
  72                         `ls -d /Library/Frameworks 2>/dev/null` \
  73                         `ls -d /Network/Library/Frameworks 2>/dev/null` \
  74                         `ls -d /System/Library/Frameworks 2>/dev/null` \
  75                         ; do
  76                     if test -f "$i/Tcl.framework/tclConfig.sh" ; then
  77                         ac_cv_c_tclconfig=`(cd $i/Tcl.framework; pwd)`
  78                         break
  79                     fi
  80                 done
  81             fi
  82
  83             # check in a few common install locations
  84             if test x"${ac_cv_c_tclconfig}" = x ; then
  85                 for i in `ls -d ${libdir} 2>/dev/null` \
  86                         `ls -d ${exec_prefix}/lib 2>/dev/null` \
  87                         `ls -d ${prefix}/lib 2>/dev/null` \
  88                         `ls -d /usr/local/lib 2>/dev/null` \
  89                         `ls -d /usr/contrib/lib 2>/dev/null` \
  90                         `ls -d /usr/lib 2>/dev/null` \
  91                         ; do
  92                     if test -f "$i/tclConfig.sh" ; then
  93                         ac_cv_c_tclconfig=`(cd $i; pwd)`
  94                         break
  95                     fi
  96                 done
  97             fi
  98
  99             # check in a few other private locations
 100             if test x"${ac_cv_c_tclconfig}" = x ; then
 101                 for i in \
 102                         ${srcdir}/../tcl \
 103                         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
 104                         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]] 2>/dev/null` \
 105                         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
 106                     if test -f "$i/$platDir/tclConfig.sh" ; then
 107                     ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
 108                     break
 109                 fi
 110                 done
 111             fi
 112         ])
 113
 114         if test x"${ac_cv_c_tclconfig}" = x ; then
 115             TCL_BIN_DIR="# no Tcl configs found"
 116             AC_MSG_WARN([Can't find Tcl configuration definitions])
 117             exit 0
 118         else
 119             no_tcl=
 120             TCL_BIN_DIR=${ac_cv_c_tclconfig}
 121             AC_MSG_RESULT([found ${TCL_BIN_DIR}/tclConfig.sh])
 122         fi
 123     fi
 124 ])
 125
 126 #------------------------------------------------------------------------
 127 # SC_PATH_TKCONFIG --
 128 #
 129 #       Locate the tkConfig.sh file
 130 #
 131 # Arguments:
 132 #       none
 133 #
 134 # Results:
 135 #
 136 #       Adds the following arguments to configure:
 137 #               --with-tk=...
 138 #
 139 #       Defines the following vars:
 140 #               TK_BIN_DIR      Full path to the directory containing
 141 #                               the tkConfig.sh file
 142 #------------------------------------------------------------------------
 143
 144 AC_DEFUN([SC_PATH_TKCONFIG], [
 145     #
 146     # Ok, lets find the tk configuration
 147     # First, look for one uninstalled.
 148     # the alternative search directory is invoked by --with-tk
 149     #
 150
 151     if test x"${no_tk}" = x ; then
 152         # we reset no_tk in case something fails here
 153         no_tk=true
 154         AC_ARG_WITH(tk, [  --with-tk               directory containing tk configuration (tkConfig.sh)], with_tkconfig=${withval})
 155         AC_MSG_CHECKING([for Tk configuration])
 156         AC_CACHE_VAL(ac_cv_c_tkconfig,[
 157
 158             # First check to see if --with-tkconfig was specified.
 159             if test x"${with_tkconfig}" != x ; then
 160                 if test -f "${with_tkconfig}/tkConfig.sh" ; then
 161                     ac_cv_c_tkconfig=`(cd ${with_tkconfig}; pwd)`
 162                 else
 163                     AC_MSG_ERROR([${with_tkconfig} directory doesn't contain tkConfig.sh])
 164                 fi
 165             fi
 166
 167             # then check for a private Tk library
 168             case "${host}" in
 169                 *-*-cygwin*) platDir="win" ;;
 170                 *) platDir="unix" ;;
 171             esac
 172             if test x"${ac_cv_c_tkconfig}" = x ; then
 173                 for i in \
 174                         ../tk \
 175                         `ls -dr ../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
 176                         `ls -dr ../tk[[8-9]].[[0-9]] 2>/dev/null` \
 177                         `ls -dr ../tk[[8-9]].[[0-9]]* 2>/dev/null` \
 178                         ../../tk \
 179                         `ls -dr ../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
 180                         `ls -dr ../../tk[[8-9]].[[0-9]] 2>/dev/null` \
 181                         `ls -dr ../../tk[[8-9]].[[0-9]]* 2>/dev/null` \
 182                         ../../../tk \
 183                         `ls -dr ../../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
 184                         `ls -dr ../../../tk[[8-9]].[[0-9]] 2>/dev/null` \
 185                         `ls -dr ../../../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
 186                     if test -f "$i/$platDir/tkConfig.sh" ; then
 187                         ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
 188                         break
 189                     fi
 190                 done
 191             fi
 192
 193             # on Darwin, check in Framework installation locations
 194             if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tkconfig}" = x ; then
 195                 for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
 196                         `ls -d /Library/Frameworks 2>/dev/null` \
 197                         `ls -d /Network/Library/Frameworks 2>/dev/null` \
 198                         `ls -d /System/Library/Frameworks 2>/dev/null` \
 199                         ; do
 200                     if test -f "$i/Tk.framework/tkConfig.sh" ; then
 201                         ac_cv_c_tkconfig=`(cd $i/Tk.framework; pwd)`
 202                         break
 203                     fi
 204                 done
 205             fi
 206
 207             # check in a few common install locations
 208             if test x"${ac_cv_c_tkconfig}" = x ; then
 209                 for i in `ls -d ${libdir} 2>/dev/null` \
 210                         `ls -d ${exec_prefix}/lib 2>/dev/null` \
 211                         `ls -d ${prefix}/lib 2>/dev/null` \
 212                         `ls -d /usr/local/lib 2>/dev/null` \
 213                         `ls -d /usr/contrib/lib 2>/dev/null` \
 214                         `ls -d /usr/lib 2>/dev/null` \
 215                         ; do
 216                     if test -f "$i/tkConfig.sh" ; then
 217                         ac_cv_c_tkconfig=`(cd $i; pwd)`
 218                         break
 219                     fi
 220                 done
 221             fi
 222             # check in a few other private locations
 223             if test x"${ac_cv_c_tkconfig}" = x ; then
 224                 for i in \
 225                         ${srcdir}/../tk \
 226                         `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
 227                         `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]] 2>/dev/null` \
 228                         `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
 229                     if test -f "$i/$platDir/tkConfig.sh" ; then
 230                         ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
 231                         break
 232                     fi
 233                 done
 234             fi
 235         ])
 236
 237         if test x"${ac_cv_c_tkconfig}" = x ; then
 238             TK_BIN_DIR="# no Tk configs found"
 239             AC_MSG_WARN([Can't find Tk configuration definitions])
 240             exit 0
 241         else
 242             no_tk=
 243             TK_BIN_DIR=${ac_cv_c_tkconfig}
 244             AC_MSG_RESULT([found ${TK_BIN_DIR}/tkConfig.sh])
 245         fi
 246     fi
 247 ])
 248
 249 #------------------------------------------------------------------------
 250 # SC_LOAD_TCLCONFIG --
 251 #
 252 #       Load the tclConfig.sh file
 253 #
 254 # Arguments:
 255 #
 256 #       Requires the following vars to be set:
 257 #               TCL_BIN_DIR
 258 #
 259 # Results:
 260 #
 261 #       Subst the following vars:
 262 #               TCL_BIN_DIR
 263 #               TCL_SRC_DIR
 264 #               TCL_LIB_FILE
 265 #
 266 #------------------------------------------------------------------------
 267
 268 AC_DEFUN([SC_LOAD_TCLCONFIG], [
 269     AC_MSG_CHECKING([for existence of ${TCL_BIN_DIR}/tclConfig.sh])
 270
 271     if test -f "${TCL_BIN_DIR}/tclConfig.sh" ; then
 272         AC_MSG_RESULT([loading])
 273         . ${TCL_BIN_DIR}/tclConfig.sh
 274     else
 275         AC_MSG_RESULT([could not find ${TCL_BIN_DIR}/tclConfig.sh])
 276     fi
 277
 278     # eval is required to do the TCL_DBGX substitution
 279     eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\""
 280     eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\""
 281
 282     # If the TCL_BIN_DIR is the build directory (not the install directory),
 283     # then set the common variable name to the value of the build variables.
 284     # For example, the variable TCL_LIB_SPEC will be set to the value
 285     # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
 286     # instead of TCL_BUILD_LIB_SPEC since it will work with both an
 287     # installed and uninstalled version of Tcl.
 288     if test -f ${TCL_BIN_DIR}/Makefile ; then
 289         TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC}
 290         TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC}
 291         TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH}
 292     elif test "`uname -s`" = "Darwin"; then
 293         # If Tcl was built as a framework, attempt to use the libraries
 294         # from the framework at the given location so that linking works
 295         # against Tcl.framework installed in an arbitary location.
 296         case ${TCL_DEFS} in
 297             *TCL_FRAMEWORK*)
 298                 if test -f ${TCL_BIN_DIR}/${TCL_LIB_FILE}; then
 299                     for i in "`cd ${TCL_BIN_DIR}; pwd`" \
 300                              "`cd ${TCL_BIN_DIR}/../..; pwd`"; do
 301                         if test "`basename "$i"`" = "${TCL_LIB_FILE}.framework"; then
 302                             TCL_LIB_SPEC="-F`dirname "$i"` -framework ${TCL_LIB_FILE}"
 303                             break
 304                         fi
 305                     done
 306                 fi
 307                 if test -f ${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}; then
 308                     TCL_STUB_LIB_SPEC="-L${TCL_BIN_DIR} ${TCL_STUB_LIB_FLAG}"
 309                     TCL_STUB_LIB_PATH="${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"
 310                 fi
 311                 ;;
 312         esac
 313     fi
 314
 315     # eval is required to do the TCL_DBGX substitution
 316     eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
 317     eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
 318     eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
 319     eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""
 320
 321     AC_SUBST(TCL_VERSION)
 322     AC_SUBST(TCL_PATCH_LEVEL)
 323     AC_SUBST(TCL_BIN_DIR)
 324     AC_SUBST(TCL_SRC_DIR)
 325
 326     AC_SUBST(TCL_LIB_FILE)
 327     AC_SUBST(TCL_LIB_FLAG)
 328     AC_SUBST(TCL_LIB_SPEC)
 329
 330     AC_SUBST(TCL_STUB_LIB_FILE)
 331     AC_SUBST(TCL_STUB_LIB_FLAG)
 332     AC_SUBST(TCL_STUB_LIB_SPEC)
 333 ])
 334
 335 #------------------------------------------------------------------------
 336 # SC_LOAD_TKCONFIG --
 337 #
 338 #       Load the tkConfig.sh file
 339 #
 340 # Arguments:
 341 #
 342 #       Requires the following vars to be set:
 343 #               TK_BIN_DIR
 344 #
 345 # Results:
 346 #
 347 #       Sets the following vars that should be in tkConfig.sh:
 348 #               TK_BIN_DIR
 349 #------------------------------------------------------------------------
 350
 351 AC_DEFUN([SC_LOAD_TKCONFIG], [
 352     AC_MSG_CHECKING([for existence of ${TK_BIN_DIR}/tkConfig.sh])
 353
 354     if test -f "${TK_BIN_DIR}/tkConfig.sh" ; then
 355         AC_MSG_RESULT([loading])
 356         . ${TK_BIN_DIR}/tkConfig.sh
 357     else
 358         AC_MSG_RESULT([could not find ${TK_BIN_DIR}/tkConfig.sh])
 359     fi
 360
 361     # eval is required to do the TK_DBGX substitution
 362     eval "TK_LIB_FILE=\"${TK_LIB_FILE}\""
 363     eval "TK_STUB_LIB_FILE=\"${TK_STUB_LIB_FILE}\""
 364
 365     # If the TK_BIN_DIR is the build directory (not the install directory),
 366     # then set the common variable name to the value of the build variables.
 367     # For example, the variable TK_LIB_SPEC will be set to the value
 368     # of TK_BUILD_LIB_SPEC. An extension should make use of TK_LIB_SPEC
 369     # instead of TK_BUILD_LIB_SPEC since it will work with both an
 370     # installed and uninstalled version of Tcl.
 371     if test -f ${TK_BIN_DIR}/Makefile ; then
 372         TK_LIB_SPEC=${TK_BUILD_LIB_SPEC}
 373         TK_STUB_LIB_SPEC=${TK_BUILD_STUB_LIB_SPEC}
 374         TK_STUB_LIB_PATH=${TK_BUILD_STUB_LIB_PATH}
 375     elif test "`uname -s`" = "Darwin"; then
 376         # If Tk was built as a framework, attempt to use the libraries
 377         # from the framework at the given location so that linking works
 378         # against Tk.framework installed in an arbitary location.
 379         case ${TK_DEFS} in
 380             *TK_FRAMEWORK*)
 381                 if test -f ${TK_BIN_DIR}/${TK_LIB_FILE}; then
 382                     for i in "`cd ${TK_BIN_DIR}; pwd`" \
 383                              "`cd ${TK_BIN_DIR}/../..; pwd`"; do
 384                         if test "`basename "$i"`" = "${TK_LIB_FILE}.framework"; then
 385                             TK_LIB_SPEC="-F`dirname "$i"` -framework ${TK_LIB_FILE}"
 386                             break
 387                         fi
 388                     done
 389                 fi
 390                 if test -f ${TK_BIN_DIR}/${TK_STUB_LIB_FILE}; then
 391                     TK_STUB_LIB_SPEC="-L${TK_BIN_DIR} ${TK_STUB_LIB_FLAG}"
 392                     TK_STUB_LIB_PATH="${TK_BIN_DIR}/${TK_STUB_LIB_FILE}"
 393                 fi
 394                 ;;
 395         esac
 396     fi
 397
 398     # eval is required to do the TK_DBGX substitution
 399     eval "TK_LIB_FLAG=\"${TK_LIB_FLAG}\""
 400     eval "TK_LIB_SPEC=\"${TK_LIB_SPEC}\""
 401     eval "TK_STUB_LIB_FLAG=\"${TK_STUB_LIB_FLAG}\""
 402     eval "TK_STUB_LIB_SPEC=\"${TK_STUB_LIB_SPEC}\""
 403
 404     AC_SUBST(TK_VERSION)
 405     AC_SUBST(TK_BIN_DIR)
 406     AC_SUBST(TK_SRC_DIR)
 407
 408     AC_SUBST(TK_LIB_FILE)
 409     AC_SUBST(TK_LIB_FLAG)
 410     AC_SUBST(TK_LIB_SPEC)
 411
 412     AC_SUBST(TK_STUB_LIB_FILE)
 413     AC_SUBST(TK_STUB_LIB_FLAG)
 414     AC_SUBST(TK_STUB_LIB_SPEC)
 415 ])
 416
 417 #------------------------------------------------------------------------
 418 # SC_PROG_TCLSH
 419 #       Locate a tclsh shell installed on the system path. This macro
 420 #       will only find a Tcl shell that already exists on the system.
 421 #       It will not find a Tcl shell in the Tcl build directory or
 422 #       a Tcl shell that has been installed from the Tcl build directory.
 423 #       If a Tcl shell can't be located on the PATH, then TCLSH_PROG will
 424 #       be set to "". Extensions should take care not to create Makefile
 425 #       rules that are run by default and depend on TCLSH_PROG. An
 426 #       extension can't assume that an executable Tcl shell exists at
 427 #       build time.
 428 #
 429 # Arguments
 430 #       none
 431 #
 432 # Results
 433 #       Subst's the following values:
 434 #               TCLSH_PROG
 435 #------------------------------------------------------------------------
 436
 437 AC_DEFUN([SC_PROG_TCLSH], [
 438     AC_MSG_CHECKING([for tclsh])
 439     AC_CACHE_VAL(ac_cv_path_tclsh, [
 440         search_path=`echo ${PATH} | sed -e 's/:/ /g'`
 441         for dir in $search_path ; do
 442             for j in `ls -r $dir/tclsh[[8-9]]* 2> /dev/null` \
 443                     `ls -r $dir/tclsh* 2> /dev/null` ; do
 444                 if test x"$ac_cv_path_tclsh" = x ; then
 445                     if test -f "$j" ; then
 446                         ac_cv_path_tclsh=$j
 447                         break
 448                     fi
 449                 fi
 450             done
 451         done
 452     ])
 453
 454     if test -f "$ac_cv_path_tclsh" ; then
 455         TCLSH_PROG="$ac_cv_path_tclsh"
 456         AC_MSG_RESULT([$TCLSH_PROG])
 457     else
 458         # It is not an error if an installed version of Tcl can't be located.
 459         TCLSH_PROG=""
 460         AC_MSG_RESULT([No tclsh found on PATH])
 461     fi
 462     AC_SUBST(TCLSH_PROG)
 463 ])
 464
 465 #------------------------------------------------------------------------
 466 # SC_BUILD_TCLSH
 467 #       Determine the fully qualified path name of the tclsh executable
 468 #       in the Tcl build directory. This macro will correctly determine
 469 #       the name of the tclsh executable even if tclsh has not yet
 470 #       been built in the build directory. The build tclsh must be used
 471 #       when running tests from an extension build directory. It is not
 472 #       correct to use the TCLSH_PROG in cases like this.
 473 #
 474 # Arguments
 475 #       none
 476 #
 477 # Results
 478 #       Subst's the following values:
 479 #               BUILD_TCLSH
 480 #------------------------------------------------------------------------
 481
 482 AC_DEFUN([SC_BUILD_TCLSH], [
 483     AC_MSG_CHECKING([for tclsh in Tcl build directory])
 484     BUILD_TCLSH=${TCL_BIN_DIR}/tclsh
 485     AC_MSG_RESULT([$BUILD_TCLSH])
 486     AC_SUBST(BUILD_TCLSH)
 487 ])
 488
 489 #------------------------------------------------------------------------
 490 # SC_ENABLE_SHARED --
 491 #
 492 #       Allows the building of shared libraries
 493 #
 494 # Arguments:
 495 #       none
 496 #
 497 # Results:
 498 #
 499 #       Adds the following arguments to configure:
 500 #               --enable-shared=yes|no
 501 #
 502 #       Defines the following vars:
 503 #               STATIC_BUILD    Used for building import/export libraries
 504 #                               on Windows.
 505 #
 506 #       Sets the following vars:
 507 #               SHARED_BUILD    Value of 1 or 0
 508 #------------------------------------------------------------------------
 509
 510 AC_DEFUN([SC_ENABLE_SHARED], [
 511     AC_MSG_CHECKING([how to build libraries])
 512     AC_ARG_ENABLE(shared,
 513         [  --enable-shared         build and link with shared libraries [--enable-shared]],
 514         [tcl_ok=$enableval], [tcl_ok=yes])
 515
 516     if test "${enable_shared+set}" = set; then
 517         enableval="$enable_shared"
 518         tcl_ok=$enableval
 519     else
 520         tcl_ok=yes
 521     fi
 522
 523     if test "$tcl_ok" = "yes" ; then
 524         AC_MSG_RESULT([shared])
 525         SHARED_BUILD=1
 526     else
 527         AC_MSG_RESULT([static])
 528         SHARED_BUILD=0
 529         AC_DEFINE(STATIC_BUILD)
 530     fi
 531 ])
 532
 533 #------------------------------------------------------------------------
 534 # SC_ENABLE_FRAMEWORK --
 535 #
 536 #       Allows the building of shared libraries into frameworks
 537 #
 538 # Arguments:
 539 #       none
 540 #
 541 # Results:
 542 #
 543 #       Adds the following arguments to configure:
 544 #               --enable-framework=yes|no
 545 #
 546 #       Sets the following vars:
 547 #               FRAMEWORK_BUILD Value of 1 or 0
 548 #------------------------------------------------------------------------
 549
 550 AC_DEFUN([SC_ENABLE_FRAMEWORK], [
 551     if test "`uname -s`" = "Darwin" ; then
 552         AC_MSG_CHECKING([how to package libraries])
 553         AC_ARG_ENABLE(framework,
 554             [  --enable-framework      package shared libraries in MacOSX frameworks [--disable-framework]],
 555             [enable_framework=$enableval], [enable_framework=no])
 556         if test $enable_framework = yes; then
 557             if test $SHARED_BUILD = 0; then
 558                 AC_MSG_WARN([Frameworks can only be built if --enable-shared is yes])
 559                 enable_framework=no
 560             fi
 561             if test $tcl_corefoundation = no; then
 562                 AC_MSG_WARN([Frameworks can only be used when CoreFoundation is available])
 563                 enable_framework=no
 564             fi
 565         fi
 566         if test $enable_framework = yes; then
 567             AC_MSG_RESULT([framework])
 568             FRAMEWORK_BUILD=1
 569         else
 570             if test $SHARED_BUILD = 1; then
 571                 AC_MSG_RESULT([shared library])
 572             else
 573                 AC_MSG_RESULT([static library])
 574             fi
 575             FRAMEWORK_BUILD=0
 576         fi
 577     fi
 578 ])
 579
 580 #------------------------------------------------------------------------
 581 # SC_ENABLE_THREADS --
 582 #
 583 #       Specify if thread support should be enabled.  TCL_THREADS is
 584 #       checked so that if you are compiling an extension against a
 585 #       threaded core, your extension must be compiled threaded as well.
 586 #
 587 # Arguments:
 588 #       none
 589 #
 590 # Results:
 591 #
 592 #       Adds the following arguments to configure:
 593 #               --enable-threads
 594 #
 595 #       Sets the following vars:
 596 #               THREADS_LIBS    Thread library(s)
 597 #
 598 #       Defines the following vars:
 599 #               TCL_THREADS
 600 #               _REENTRANT
 601 #               _THREAD_SAFE
 602 #
 603 #------------------------------------------------------------------------
 604
 605 AC_DEFUN([SC_ENABLE_THREADS], [
 606     AC_ARG_ENABLE(threads, [  --enable-threads        build with threads],
 607         [tcl_ok=$enableval], [tcl_ok=no])
 608
 609     if test "${TCL_THREADS}" = 1; then
 610         tcl_threaded_core=1;
 611     fi
 612
 613     if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
 614         TCL_THREADS=1
 615         # USE_THREAD_ALLOC tells us to try the special thread-based
 616         # allocator that significantly reduces lock contention
 617         AC_DEFINE(USE_THREAD_ALLOC)
 618         AC_DEFINE(_REENTRANT)
 619         if test "`uname -s`" = "SunOS" ; then
 620             AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 621         fi
 622         AC_DEFINE(_THREAD_SAFE)
 623         AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no)
 624         if test "$tcl_ok" = "no"; then
 625             # Check a little harder for __pthread_mutex_init in the same
 626             # library, as some systems hide it there until pthread.h is
 627             # defined.  We could alternatively do an AC_TRY_COMPILE with
 628             # pthread.h, but that will work with libpthread really doesn't
 629             # exist, like AIX 4.2.  [Bug: 4359]
 630             AC_CHECK_LIB(pthread, __pthread_mutex_init,
 631                 tcl_ok=yes, tcl_ok=no)
 632         fi
 633
 634         if test "$tcl_ok" = "yes"; then
 635             # The space is needed
 636             THREADS_LIBS=" -lpthread"
 637         else
 638             AC_CHECK_LIB(pthreads, pthread_mutex_init,
 639                 tcl_ok=yes, tcl_ok=no)
 640             if test "$tcl_ok" = "yes"; then
 641                 # The space is needed
 642                 THREADS_LIBS=" -lpthreads"
 643             else
 644                 AC_CHECK_LIB(c, pthread_mutex_init,
 645                     tcl_ok=yes, tcl_ok=no)
 646                 if test "$tcl_ok" = "no"; then
 647                     AC_CHECK_LIB(c_r, pthread_mutex_init,
 648                         tcl_ok=yes, tcl_ok=no)
 649                     if test "$tcl_ok" = "yes"; then
 650                         # The space is needed
 651                         THREADS_LIBS=" -pthread"
 652                     else
 653                         TCL_THREADS=0
 654                         AC_MSG_WARN([Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile...])
 655                     fi
 656                 fi
 657             fi
 658         fi
 659
 660         # Does the pthread-implementation provide
 661         # 'pthread_attr_setstacksize' ?
 662
 663         ac_saved_libs=$LIBS
 664         LIBS="$LIBS $THREADS_LIBS"
 665         AC_CHECK_FUNCS(pthread_attr_setstacksize)
 666         AC_CHECK_FUNCS(pthread_atfork)
 667         LIBS=$ac_saved_libs
 668     else
 669         TCL_THREADS=0
 670     fi
 671     # Do checking message here to not mess up interleaved configure output
 672     AC_MSG_CHECKING([for building with threads])
 673     if test "${TCL_THREADS}" = 1; then
 674         AC_DEFINE(TCL_THREADS, 1, [Are we building with threads enabled?])
 675         if test "${tcl_threaded_core}" = 1; then
 676             AC_MSG_RESULT([yes (threaded core)])
 677         else
 678             AC_MSG_RESULT([yes])
 679         fi
 680     else
 681         AC_MSG_RESULT([no (default)])
 682     fi
 683
 684     AC_SUBST(TCL_THREADS)
 685 ])
 686
 687 #------------------------------------------------------------------------
 688 # SC_ENABLE_SYMBOLS --
 689 #
 690 #       Specify if debugging symbols should be used.
 691 #       Memory (TCL_MEM_DEBUG) and compile (TCL_COMPILE_DEBUG) debugging
 692 #       can also be enabled.
 693 #
 694 # Arguments:
 695 #       none
 696 #
 697 #       Requires the following vars to be set in the Makefile:
 698 #               CFLAGS_DEBUG
 699 #               CFLAGS_OPTIMIZE
 700 #               LDFLAGS_DEBUG
 701 #               LDFLAGS_OPTIMIZE
 702 #
 703 # Results:
 704 #
 705 #       Adds the following arguments to configure:
 706 #               --enable-symbols
 707 #
 708 #       Defines the following vars:
 709 #               CFLAGS_DEFAULT  Sets to $(CFLAGS_DEBUG) if true
 710 #                               Sets to $(CFLAGS_OPTIMIZE) if false
 711 #               LDFLAGS_DEFAULT Sets to $(LDFLAGS_DEBUG) if true
 712 #                               Sets to $(LDFLAGS_OPTIMIZE) if false
 713 #               DBGX            Debug library extension
 714 #
 715 #------------------------------------------------------------------------
 716
 717 AC_DEFUN([SC_ENABLE_SYMBOLS], [
 718     AC_MSG_CHECKING([for build with symbols])
 719     AC_ARG_ENABLE(symbols, [  --enable-symbols        build with debugging symbols [--disable-symbols]],    [tcl_ok=$enableval], [tcl_ok=no])
 720 # FIXME: Currently, LDFLAGS_DEFAULT is not used, it should work like CFLAGS_DEFAULT.
 721     if test "$tcl_ok" = "no"; then
 722         CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)'
 723         LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)'
 724         DBGX=""
 725         AC_MSG_RESULT([no])
 726     else
 727         CFLAGS_DEFAULT='$(CFLAGS_DEBUG)'
 728         LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)'
 729         DBGX=g
 730         if test "$tcl_ok" = "yes"; then
 731             AC_MSG_RESULT([yes (standard debugging)])
 732         fi
 733     fi
 734     AC_SUBST(CFLAGS_DEFAULT)
 735     AC_SUBST(LDFLAGS_DEFAULT)
 736
 737     if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then
 738         AC_DEFINE(TCL_MEM_DEBUG)
 739     fi
 740
 741     if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then
 742         AC_DEFINE(TCL_COMPILE_DEBUG)
 743         AC_DEFINE(TCL_COMPILE_STATS)
 744     fi
 745
 746     if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then
 747         if test "$tcl_ok" = "all"; then
 748             AC_MSG_RESULT([enabled symbols mem compile debugging])
 749         else
 750             AC_MSG_RESULT([enabled $tcl_ok debugging])
 751         fi
 752     fi
 753 ])
 754
 755 #------------------------------------------------------------------------
 756 # SC_ENABLE_LANGINFO --
 757 #
 758 #       Allows use of modern nl_langinfo check for better l10n.
 759 #       This is only relevant for Unix.
 760 #
 761 # Arguments:
 762 #       none
 763 #
 764 # Results:
 765 #
 766 #       Adds the following arguments to configure:
 767 #               --enable-langinfo=yes|no (default is yes)
 768 #
 769 #       Defines the following vars:
 770 #               HAVE_LANGINFO   Triggers use of nl_langinfo if defined.
 771 #
 772 #------------------------------------------------------------------------
 773
 774 AC_DEFUN([SC_ENABLE_LANGINFO], [
 775     AC_ARG_ENABLE(langinfo,
 776         [  --enable-langinfo      use nl_langinfo if possible to determine
 777                           encoding at startup, otherwise use old heuristic],
 778         [langinfo_ok=$enableval], [langinfo_ok=yes])
 779
 780     HAVE_LANGINFO=0
 781     if test "$langinfo_ok" = "yes"; then
 782         AC_CHECK_HEADER(langinfo.h,[langinfo_ok=yes],[langinfo_ok=no])
 783     fi
 784     AC_MSG_CHECKING([whether to use nl_langinfo])
 785     if test "$langinfo_ok" = "yes"; then
 786         AC_CACHE_VAL(tcl_cv_langinfo_h, [
 787             AC_TRY_COMPILE([#include <langinfo.h>], [nl_langinfo(CODESET);],
 788                     [tcl_cv_langinfo_h=yes],[tcl_cv_langinfo_h=no])])
 789         AC_MSG_RESULT([$tcl_cv_langinfo_h])
 790         if test $tcl_cv_langinfo_h = yes; then
 791             AC_DEFINE(HAVE_LANGINFO)
 792         fi
 793     else
 794         AC_MSG_RESULT([$langinfo_ok])
 795     fi
 796 ])
 797
 798 #--------------------------------------------------------------------
 799 # SC_CONFIG_MANPAGES
 800 #
 801 #       Decide whether to use symlinks for linking the manpages,
 802 #       whether to compress the manpages after installation, and
 803 #       whether to add a package name suffix to the installed
 804 #       manpages to avoidfile name clashes.
 805 #       If compression is enabled also find out what file name suffix
 806 #       the given compression program is using.
 807 #
 808 # Arguments:
 809 #       none
 810 #
 811 # Results:
 812 #
 813 #       Adds the following arguments to configure:
 814 #               --enable-man-symlinks
 815 #               --enable-man-compression=PROG
 816 #               --enable-man-suffix[=STRING]
 817 #
 818 #       Defines the following variable:
 819 #
 820 #       MAN_FLAGS -     The apropriate flags for installManPage
 821 #                       according to the user's selection.
 822 #
 823 #--------------------------------------------------------------------
 824
 825 AC_DEFUN([SC_CONFIG_MANPAGES], [
 826     AC_MSG_CHECKING([whether to use symlinks for manpages])
 827     AC_ARG_ENABLE(man-symlinks,
 828             [  --enable-man-symlinks   use symlinks for the manpages],
 829         test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks",
 830         enableval="no")
 831     AC_MSG_RESULT([$enableval])
 832
 833     AC_MSG_CHECKING([whether to compress the manpages])
 834     AC_ARG_ENABLE(man-compression,
 835             [  --enable-man-compression=PROG
 836                       compress the manpages with PROG],
 837         [case $enableval in
 838             yes) AC_MSG_ERROR([missing argument to --enable-man-compression]);;
 839             no)  ;;
 840             *)   MAN_FLAGS="$MAN_FLAGS --compress $enableval";;
 841         esac],
 842         enableval="no")
 843     AC_MSG_RESULT([$enableval])
 844     if test "$enableval" != "no"; then
 845         AC_MSG_CHECKING([for compressed file suffix])
 846         touch TeST
 847         $enableval TeST
 848         Z=`ls TeST* | sed 's/^....//'`
 849         rm -f TeST*
 850         MAN_FLAGS="$MAN_FLAGS --extension $Z"
 851         AC_MSG_RESULT([$Z])
 852     fi
 853
 854     AC_MSG_CHECKING([whether to add a package name suffix for the manpages])
 855     AC_ARG_ENABLE(man-suffix,
 856             [  --enable-man-suffix=STRING
 857                       use STRING as a suffix to manpage file names
 858                       (default: $1)],
 859         [case $enableval in
 860             yes) enableval="$1" MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
 861             no)  ;;
 862             *)   MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
 863         esac],
 864         enableval="no")
 865     AC_MSG_RESULT([$enableval])
 866
 867     AC_SUBST(MAN_FLAGS)
 868 ])
 869
 870 #--------------------------------------------------------------------
 871 # SC_CONFIG_SYSTEM
 872 #
 873 #       Determine what the system is (some things cannot be easily checked
 874 #       on a feature-driven basis, alas). This can usually be done via the
 875 #       "uname" command, but there are a few systems, like Next, where
 876 #       this doesn't work.
 877 #
 878 # Arguments:
 879 #       none
 880 #
 881 # Results:
 882 #       Defines the following var:
 883 #
 884 #       system -        System/platform/version identification code.
 885 #
 886 #--------------------------------------------------------------------
 887
 888 AC_DEFUN([SC_CONFIG_SYSTEM], [
 889     AC_CACHE_CHECK([system version], tcl_cv_sys_version, [
 890         if test -f /usr/lib/NextStep/software_version; then
 891             tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
 892         else
 893             tcl_cv_sys_version=`uname -s`-`uname -r`
 894             if test "$?" -ne 0 ; then
 895                 AC_MSG_WARN([can't find uname command])
 896                 tcl_cv_sys_version=unknown
 897             else
 898                 # Special check for weird MP-RAS system (uname returns weird
 899                 # results, and the version is kept in special file).
 900
 901                 if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
 902                     tcl_cv_sys_version=MP-RAS-`awk '{print $[3]}' /etc/.relid`
 903                 fi
 904                 if test "`uname -s`" = "AIX" ; then
 905                     tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
 906                 fi
 907             fi
 908         fi
 909     ])
 910     system=$tcl_cv_sys_version
 911 ])
 912
 913 #--------------------------------------------------------------------
 914 # SC_CONFIG_CFLAGS
 915 #
 916 #       Try to determine the proper flags to pass to the compiler
 917 #       for building shared libraries and other such nonsense.
 918 #
 919 # Arguments:
 920 #       none
 921 #
 922 # Results:
 923 #
 924 #       Defines and substitutes the following vars:
 925 #
 926 #       DL_OBJS -       Name of the object file that implements dynamic
 927 #                       loading for Tcl on this system.
 928 #       DL_LIBS -       Library file(s) to include in tclsh and other base
 929 #                       applications in order for the "load" command to work.
 930 #       LDFLAGS -      Flags to pass to the compiler when linking object
 931 #                       files into an executable application binary such
 932 #                       as tclsh.
 933 #       LD_SEARCH_FLAGS-Flags to pass to ld, such as "-R /usr/local/tcl/lib",
 934 #                       that tell the run-time dynamic linker where to look
 935 #                       for shared libraries such as libtcl.so.  Depends on
 936 #                       the variable LIB_RUNTIME_DIR in the Makefile. Could
 937 #                       be the same as CC_SEARCH_FLAGS if ${CC} is used to link.
 938 #       CC_SEARCH_FLAGS-Flags to pass to ${CC}, such as "-Wl,-rpath,/usr/local/tcl/lib",
 939 #                       that tell the run-time dynamic linker where to look
 940 #                       for shared libraries such as libtcl.so.  Depends on
 941 #                       the variable LIB_RUNTIME_DIR in the Makefile.
 942 #       MAKE_LIB -      Command to execute to build the a library;
 943 #                       differs when building shared or static.
 944 #       MAKE_STUB_LIB -
 945 #                       Command to execute to build a stub library.
 946 #       INSTALL_LIB -   Command to execute to install a library;
 947 #                       differs when building shared or static.
 948 #       INSTALL_STUB_LIB -
 949 #                       Command to execute to install a stub library.
 950 #       STLIB_LD -      Base command to use for combining object files
 951 #                       into a static library.
 952 #       SHLIB_CFLAGS -  Flags to pass to cc when compiling the components
 953 #                       of a shared library (may request position-independent
 954 #                       code, among other things).
 955 #       SHLIB_LD -      Base command to use for combining object files
 956 #                       into a shared library.
 957 #       SHLIB_LD_LIBS - Dependent libraries for the linker to scan when
 958 #                       creating shared libraries.  This symbol typically
 959 #                       goes at the end of the "ld" commands that build
 960 #                       shared libraries. The value of the symbol is
 961 #                       "${LIBS}" if all of the dependent libraries should
 962 #                       be specified when creating a shared library.  If
 963 #                       dependent libraries should not be specified (as on
 964 #                       SunOS 4.x, where they cause the link to fail, or in
 965 #                       general if Tcl and Tk aren't themselves shared
 966 #                       libraries), then this symbol has an empty string
 967 #                       as its value.
 968 #       SHLIB_SUFFIX -  Suffix to use for the names of dynamically loadable
 969 #                       extensions.  An empty string means we don't know how
 970 #                       to use shared libraries on this platform.
 971 # TCL_SHLIB_LD_EXTRAS - Additional element which are added to SHLIB_LD_LIBS
 972 #  TK_SHLIB_LD_EXTRAS   for the build of Tcl and Tk, but not recorded in the
 973 #                       tclConfig.sh, since they are only used for the build
 974 #                       of Tcl and Tk.
 975 #                       Examples: MacOS X records the library version and
 976 #                       compatibility version in the shared library.  But
 977 #                       of course the Tcl version of this is only used for Tcl.
 978 #       LIB_SUFFIX -    Specifies everything that comes after the "libfoo"
 979 #                       in a static or shared library name, using the $VERSION variable
 980 #                       to put the version in the right place.  This is used
 981 #                       by platforms that need non-standard library names.
 982 #                       Examples:  ${VERSION}.so.1.1 on NetBSD, since it needs
 983 #                       to have a version after the .so, and ${VERSION}.a
 984 #                       on AIX, since a shared library needs to have
 985 #                       a .a extension whereas shared objects for loadable
 986 #                       extensions have a .so extension.  Defaults to
 987 #                       ${VERSION}${SHLIB_SUFFIX}.
 988 #       TCL_NEEDS_EXP_FILE -
 989 #                       1 means that an export file is needed to link to a
 990 #                       shared library.
 991 #       TCL_EXP_FILE -  The name of the installed export / import file which
 992 #                       should be used to link to the Tcl shared library.
 993 #                       Empty if Tcl is unshared.
 994 #       TCL_BUILD_EXP_FILE -
 995 #                       The name of the built export / import file which
 996 #                       should be used to link to the Tcl shared library.
 997 #                       Empty if Tcl is unshared.
 998 #       CFLAGS_DEBUG -
 999 #                       Flags used when running the compiler in debug mode
1000 #       CFLAGS_OPTIMIZE -
1001 #                       Flags used when running the compiler in optimize mode
1002 #       CFLAGS -        Additional CFLAGS added as necessary (usually 64-bit)
1003 #
1004 #--------------------------------------------------------------------
1005
1006 AC_DEFUN([SC_CONFIG_CFLAGS], [
1007
1008     # Step 0.a: Enable 64 bit support?
1009
1010     AC_MSG_CHECKING([if 64bit support is requested])
1011     AC_ARG_ENABLE(64bit,[  --enable-64bit          enable 64bit support (where applicable)],
1012         [do64bit=$enableval], [do64bit=no])
1013     AC_MSG_RESULT([$do64bit])
1014
1015     # Step 0.b: Enable Solaris 64 bit VIS support?
1016
1017     AC_MSG_CHECKING([if 64bit Sparc VIS support is requested])
1018     AC_ARG_ENABLE(64bit-vis,[  --enable-64bit-vis      enable 64bit Sparc VIS support],
1019         [do64bitVIS=$enableval], [do64bitVIS=no])
1020     AC_MSG_RESULT([$do64bitVIS])
1021
1022     if test "$do64bitVIS" = "yes"; then
1023         # Force 64bit on with VIS
1024         do64bit=yes
1025     fi
1026
1027     # Step 1: set the variable "system" to hold the name and version number
1028     # for the system.
1029
1030     SC_CONFIG_SYSTEM
1031
1032     # Step 2: check for existence of -ldl library.  This is needed because
1033     # Linux can use either -ldl or -ldld for dynamic loading.
1034
1035     AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
1036
1037     # Require ranlib early so we can override it in special cases below.
1038
1039     AC_REQUIRE([AC_PROG_RANLIB])
1040
1041     # Step 3: set configuration options based on system name and version.
1042
1043     do64bit_ok=no
1044     LDFLAGS_ORIG="$LDFLAGS"
1045     TCL_EXPORT_FILE_SUFFIX=""
1046     UNSHARED_LIB_SUFFIX=""
1047     TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
1048     ECHO_VERSION='`echo ${VERSION}`'
1049     TCL_LIB_VERSIONS_OK=ok
1050     CFLAGS_DEBUG=-g
1051     CFLAGS_OPTIMIZE=-O
1052     if test "$GCC" = "yes" ; then
1053         CFLAGS_WARNING="-Wall -Wno-implicit-int -fno-strict-aliasing"
1054     else
1055         CFLAGS_WARNING=""
1056     fi
1057     TCL_NEEDS_EXP_FILE=0
1058     TCL_BUILD_EXP_FILE=""
1059     TCL_EXP_FILE=""
1060 dnl FIXME: Replace AC_CHECK_PROG with AC_CHECK_TOOL once cross compiling is fixed.
1061 dnl AC_CHECK_TOOL(AR, ar)
1062     AC_CHECK_PROG(AR, ar, ar)
1063     if test "${AR}" = "" ; then
1064         AC_MSG_ERROR([Required archive tool 'ar' not found on PATH.])
1065     fi
1066     STLIB_LD='${AR} cr'
1067     LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
1068     PLAT_OBJS=""
1069     PLAT_SRCS=""
1070     case $system in
1071         AIX-*)
1072             if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then
1073                 # AIX requires the _r compiler when gcc isn't being used
1074                 case "${CC}" in
1075                     *_r)
1076                         # ok ...
1077                         ;;
1078                     *)
1079                         CC=${CC}_r
1080                         ;;
1081                 esac
1082                 AC_MSG_RESULT([Using $CC for compiling with threads])
1083             fi
1084             LIBS="$LIBS -lc"
1085             SHLIB_CFLAGS=""
1086             # Note: need the LIBS below, otherwise Tk won't find Tcl's
1087             # symbols when dynamically loaded into tclsh.
1088             SHLIB_LD_LIBS='${LIBS}'
1089             SHLIB_SUFFIX=".so"
1090
1091             DL_OBJS="tclLoadDl.o"
1092             LD_LIBRARY_PATH_VAR="LIBPATH"
1093
1094             # Check to enable 64-bit flags for compiler/linker on AIX 4+
1095             if test "$do64bit" = "yes" -a "`uname -v`" -gt "3" ; then
1096                 if test "$GCC" = "yes" ; then
1097                     AC_MSG_WARN([64bit mode not supported with GCC on $system])
1098                 else
1099                     do64bit_ok=yes
1100                     CFLAGS="$CFLAGS -q64"
1101                     LDFLAGS="$LDFLAGS -q64"
1102                     RANLIB="${RANLIB} -X64"
1103                     AR="${AR} -X64"
1104                     SHLIB_LD_FLAGS="-b64"
1105                 fi
1106             fi
1107
1108             if test "`uname -m`" = "ia64" ; then
1109                 # AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC
1110                 SHLIB_LD="/usr/ccs/bin/ld -G -z text"
1111                 # AIX-5 has dl* in libc.so
1112                 DL_LIBS=""
1113                 if test "$GCC" = "yes" ; then
1114                     CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
1115                 else
1116                     CC_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}'
1117                 fi
1118                 LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
1119             else
1120                 if test "$GCC" = "yes" ; then
1121                     SHLIB_LD="gcc -shared"
1122                 else
1123                     SHLIB_LD="/bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry"
1124                 fi
1125                 SHLIB_LD="${TCL_SRC_DIR}/unix/ldAix ${SHLIB_LD} ${SHLIB_LD_FLAGS}"
1126                 DL_LIBS="-ldl"
1127                 CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1128                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1129                 TCL_NEEDS_EXP_FILE=1
1130                 TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp'
1131             fi
1132
1133             # AIX v<=4.1 has some different flags than 4.2+
1134             if test "$system" = "AIX-4.1" -o "`uname -v`" -lt "4" ; then
1135                 LIBOBJS="$LIBOBJS tclLoadAix.o"
1136                 DL_LIBS="-lld"
1137             fi
1138
1139             # On AIX <=v4 systems, libbsd.a has to be linked in to support
1140             # non-blocking file IO.  This library has to be linked in after
1141             # the MATH_LIBS or it breaks the pow() function.  The way to
1142             # insure proper sequencing, is to add it to the tail of MATH_LIBS.
1143             # This library also supplies gettimeofday.
1144             #
1145             # AIX does not have a timezone field in struct tm. When the AIX
1146             # bsd library is used, the timezone global and the gettimeofday
1147             # methods are to be avoided for timezone deduction instead, we
1148             # deduce the timezone by comparing the localtime result on a
1149             # known GMT value.
1150
1151             AC_CHECK_LIB(bsd, gettimeofday, libbsd=yes, libbsd=no)
1152             if test $libbsd = yes; then
1153                 MATH_LIBS="$MATH_LIBS -lbsd"
1154                 AC_DEFINE(USE_DELTA_FOR_TZ)
1155             fi
1156             ;;
1157         BeOS*)
1158             SHLIB_CFLAGS="-fPIC"
1159             SHLIB_LD="${CC} -nostart"
1160             SHLIB_LD_LIBS='${LIBS}'
1161             SHLIB_SUFFIX=".so"
1162             DL_OBJS="tclLoadDl.o"
1163             DL_LIBS="-ldl"
1164
1165             #-----------------------------------------------------------
1166             # Check for inet_ntoa in -lbind, for BeOS (which also needs
1167             # -lsocket, even if the network functions are in -lnet which
1168             # is always linked to, for compatibility.
1169             #-----------------------------------------------------------
1170             AC_CHECK_LIB(bind, inet_ntoa, [LIBS="$LIBS -lbind -lsocket"])
1171             ;;
1172         BSD/OS-2.1*|BSD/OS-3*)
1173             SHLIB_CFLAGS=""
1174             SHLIB_LD="shlicc -r"
1175             SHLIB_LD_LIBS='${LIBS}'
1176             SHLIB_SUFFIX=".so"
1177             DL_OBJS="tclLoadDl.o"
1178             DL_LIBS="-ldl"
1179             CC_SEARCH_FLAGS=""
1180             LD_SEARCH_FLAGS=""
1181             ;;
1182         BSD/OS-4.*)
1183             SHLIB_CFLAGS="-export-dynamic -fPIC"
1184             SHLIB_LD="cc -shared"
1185             SHLIB_LD_LIBS='${LIBS}'
1186             SHLIB_SUFFIX=".so"
1187             DL_OBJS="tclLoadDl.o"
1188             DL_LIBS="-ldl"
1189             LDFLAGS="$LDFLAGS -export-dynamic"
1190             CC_SEARCH_FLAGS=""
1191             LD_SEARCH_FLAGS=""
1192             ;;
1193         dgux*)
1194             SHLIB_CFLAGS="-K PIC"
1195             SHLIB_LD="cc -G"
1196             SHLIB_LD_LIBS=""
1197             SHLIB_SUFFIX=".so"
1198             DL_OBJS="tclLoadDl.o"
1199             DL_LIBS="-ldl"
1200             CC_SEARCH_FLAGS=""
1201             LD_SEARCH_FLAGS=""
1202             ;;
1203         HP-UX-*.11.*)
1204             # Use updated header definitions where possible
1205             AC_DEFINE(_XOPEN_SOURCE)          # Use the XOPEN network library
1206             AC_DEFINE(_XOPEN_SOURCE_EXTENDED) # Use the XOPEN network library
1207             LIBS="$LIBS -lxnet"               # Use the XOPEN network library
1208
1209             if test "`uname -m`" = "ia64" ; then
1210                 SHLIB_SUFFIX=".so"
1211             else
1212                 SHLIB_SUFFIX=".sl"
1213             fi
1214             AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
1215             if test "$tcl_ok" = yes; then
1216                 SHLIB_CFLAGS="+z"
1217                 SHLIB_LD="ld -b"
1218                 SHLIB_LD_LIBS='${LIBS}'
1219                 DL_OBJS="tclLoadShl.o"
1220                 DL_LIBS="-ldld"
1221                 LDFLAGS="$LDFLAGS -Wl,-E"
1222                 CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
1223                 LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
1224                 LD_LIBRARY_PATH_VAR="SHLIB_PATH"
1225             fi
1226             if test "$GCC" = "yes" ; then
1227                 SHLIB_LD="gcc -shared"
1228                 SHLIB_LD_LIBS='${LIBS}'
1229                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1230             fi
1231
1232             # Users may want PA-RISC 1.1/2.0 portable code - needs HP cc
1233             #CFLAGS="$CFLAGS +DAportable"
1234
1235             # Check to enable 64-bit flags for compiler/linker
1236             if test "$do64bit" = "yes" ; then
1237                 if test "$GCC" = "yes" ; then
1238                     hpux_arch=`${CC} -dumpmachine`
1239                     case $hpux_arch in
1240                         hppa64*)
1241                             # 64-bit gcc in use.  Fix flags for GNU ld.
1242                             do64bit_ok=yes
1243                             SHLIB_LD="${CC} -shared"
1244                             SHLIB_LD_LIBS='${LIBS}'
1245                             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1246                             LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1247                             ;;
1248                         *)
1249                             AC_MSG_WARN([64bit mode not supported with GCC on $system])
1250                             ;;
1251                     esac
1252                 else
1253                     do64bit_ok=yes
1254                     CFLAGS="$CFLAGS +DD64"
1255                     LDFLAGS="$LDFLAGS +DD64"
1256                 fi
1257             fi
1258             ;;
1259         HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*)
1260             SHLIB_SUFFIX=".sl"
1261             AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
1262             if test "$tcl_ok" = yes; then
1263                 SHLIB_CFLAGS="+z"
1264                 SHLIB_LD="ld -b"
1265                 SHLIB_LD_LIBS=""
1266                 DL_OBJS="tclLoadShl.o"
1267                 DL_LIBS="-ldld"
1268                 LDFLAGS="$LDFLAGS -Wl,-E"
1269                 CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
1270                 LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
1271                 LD_LIBRARY_PATH_VAR="SHLIB_PATH"
1272             fi
1273             ;;
1274         IRIX-4.*)
1275             SHLIB_CFLAGS="-G 0"
1276             SHLIB_SUFFIX=".a"
1277             SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
1278             SHLIB_LD_LIBS='${LIBS}'
1279             DL_OBJS="tclLoadAout.o"
1280             DL_LIBS=""
1281             LDFLAGS="$LDFLAGS -Wl,-D,08000000"
1282             CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1283             LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1284             SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
1285             ;;
1286         IRIX-5.*)
1287             SHLIB_CFLAGS=""
1288             SHLIB_LD="ld -shared -rdata_shared"
1289             SHLIB_LD_LIBS='${LIBS}'
1290             SHLIB_SUFFIX=".so"
1291             DL_OBJS="tclLoadDl.o"
1292             DL_LIBS=""
1293             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1294             LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1295             ;;
1296         IRIX-6.*)
1297             SHLIB_CFLAGS=""
1298             SHLIB_LD="ld -n32 -shared -rdata_shared"
1299             SHLIB_LD_LIBS='${LIBS}'
1300             SHLIB_SUFFIX=".so"
1301             DL_OBJS="tclLoadDl.o"
1302             DL_LIBS=""
1303             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1304             LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1305             if test "$GCC" = "yes" ; then
1306                 CFLAGS="$CFLAGS -mabi=n32"
1307                 LDFLAGS="$LDFLAGS -mabi=n32"
1308             else
1309                 case $system in
1310                     IRIX-6.3)
1311                         # Use to build 6.2 compatible binaries on 6.3.
1312                         CFLAGS="$CFLAGS -n32 -D_OLD_TERMIOS"
1313                         ;;
1314                     *)
1315                         CFLAGS="$CFLAGS -n32"
1316                         ;;
1317                 esac
1318                 LDFLAGS="$LDFLAGS -n32"
1319             fi
1320             ;;
1321         IRIX64-6.*)
1322             SHLIB_CFLAGS=""
1323             SHLIB_LD="ld -n32 -shared -rdata_shared"
1324             SHLIB_LD_LIBS='${LIBS}'
1325             SHLIB_SUFFIX=".so"
1326             DL_OBJS="tclLoadDl.o"
1327             DL_LIBS=""
1328             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1329             LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1330
1331             # Check to enable 64-bit flags for compiler/linker
1332
1333             if test "$do64bit" = "yes" ; then
1334                 if test "$GCC" = "yes" ; then
1335                     AC_MSG_WARN([64bit mode not supported by gcc])
1336                 else
1337                     do64bit_ok=yes
1338                     SHLIB_LD="ld -64 -shared -rdata_shared"
1339                     CFLAGS="$CFLAGS -64"
1340                     LDFLAGS="$LDFLAGS -64"
1341                 fi
1342             fi
1343             ;;
1344         Linux*)
1345             SHLIB_CFLAGS="-fPIC"
1346             SHLIB_LD_LIBS='${LIBS}'
1347             SHLIB_SUFFIX=".so"
1348
1349             CFLAGS_OPTIMIZE=-O2
1350             # egcs-2.91.66 on Redhat Linux 6.0 generates lots of warnings
1351             # when you inline the string and math operations.  Turn this off to
1352             # get rid of the warnings.
1353             #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES"
1354
1355             if test "$have_dl" = yes; then
1356                 SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}'
1357                 DL_OBJS="tclLoadDl.o"
1358                 DL_LIBS="-ldl"
1359                 LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
1360                 CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1361                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1362             else
1363                 AC_CHECK_HEADER(dld.h, [
1364                     SHLIB_LD="ld -shared"
1365                     DL_OBJS="tclLoadDld.o"
1366                     DL_LIBS="-ldld"
1367                     CC_SEARCH_FLAGS=""
1368                     LD_SEARCH_FLAGS=""])
1369             fi
1370             if test "`uname -m`" = "alpha" ; then
1371                 CFLAGS="$CFLAGS -mieee"
1372             fi
1373             if test $do64bit = yes; then
1374                 AC_CACHE_CHECK([if compiler accepts -m64 flag], tcl_cv_cc_m64, [
1375                     hold_cflags=$CFLAGS
1376                     CFLAGS="$CFLAGS -m64"
1377                     AC_TRY_LINK(,, tcl_cv_cc_m64=yes, tcl_cv_cc_m64=no)
1378                     CFLAGS=$hold_cflags])
1379                 if test $tcl_cv_cc_m64 = yes; then
1380                     CFLAGS="$CFLAGS -m64"
1381                     do64bit_ok=yes
1382                 fi
1383             fi
1384
1385             # The combo of gcc + glibc has a bug related
1386             # to inlining of functions like strtod(). The
1387             # -fno-builtin flag should address this problem
1388             # but it does not work. The -fno-inline flag
1389             # is kind of overkill but it works.
1390             # Disable inlining only when one of the
1391             # files in compat/*.c is being linked in.
1392             if test x"${LIBOBJS}" != x ; then
1393                 CFLAGS="$CFLAGS -fno-inline"
1394             fi
1395
1396             # XIM peeking works under XFree86.
1397             AC_DEFINE(PEEK_XCLOSEIM)
1398
1399             ;;
1400         GNU*)
1401             SHLIB_CFLAGS="-fPIC"
1402             SHLIB_LD_LIBS='${LIBS}'
1403             SHLIB_SUFFIX=".so"
1404
1405             if test "$have_dl" = yes; then
1406                 SHLIB_LD="${CC} -shared"
1407                 DL_OBJS=""
1408                 DL_LIBS="-ldl"
1409                 LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
1410                 CC_SEARCH_FLAGS=""
1411                 LD_SEARCH_FLAGS=""
1412             else
1413                 AC_CHECK_HEADER(dld.h, [
1414                     SHLIB_LD="ld -shared"
1415                     DL_OBJS=""
1416                     DL_LIBS="-ldld"
1417                     CC_SEARCH_FLAGS=""
1418                     LD_SEARCH_FLAGS=""])
1419             fi
1420             if test "`uname -m`" = "alpha" ; then
1421                 CFLAGS="$CFLAGS -mieee"
1422             fi
1423             ;;
1424         Lynx*)
1425             SHLIB_CFLAGS="-fPIC"
1426             SHLIB_LD_LIBS='${LIBS}'
1427             SHLIB_SUFFIX=".so"
1428             CFLAGS_OPTIMIZE=-02
1429             SHLIB_LD="${CC} -shared "
1430             DL_OBJS="tclLoadDl.o"
1431             DL_LIBS="-mshared -ldl"
1432             LD_FLAGS="-Wl,--export-dynamic"
1433             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1434             LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1435             ;;
1436         MP-RAS-02*)
1437             SHLIB_CFLAGS="-K PIC"
1438             SHLIB_LD="cc -G"
1439             SHLIB_LD_LIBS=""
1440             SHLIB_SUFFIX=".so"
1441             DL_OBJS="tclLoadDl.o"
1442             DL_LIBS="-ldl"
1443             CC_SEARCH_FLAGS=""
1444             LD_SEARCH_FLAGS=""
1445             ;;
1446         MP-RAS-*)
1447             SHLIB_CFLAGS="-K PIC"
1448             SHLIB_LD="cc -G"
1449             SHLIB_LD_LIBS=""
1450             SHLIB_SUFFIX=".so"
1451             DL_OBJS="tclLoadDl.o"
1452             DL_LIBS="-ldl"
1453             LDFLAGS="$LDFLAGS -Wl,-Bexport"
1454             CC_SEARCH_FLAGS=""
1455             LD_SEARCH_FLAGS=""
1456             ;;
1457         NetBSD-*|FreeBSD-[[1-2]].*)
1458             # Not available on all versions:  check for include file.
1459             AC_CHECK_HEADER(dlfcn.h, [
1460                 # NetBSD/SPARC needs -fPIC, -fpic will not do.
1461                 SHLIB_CFLAGS="-fPIC"
1462                 SHLIB_LD="ld -Bshareable -x"
1463                 SHLIB_LD_LIBS='${LIBS}'
1464                 SHLIB_SUFFIX=".so"
1465                 DL_OBJS="tclLoadDl.o"
1466                 DL_LIBS=""
1467                 CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1468                 LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1469                 AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
1470                     AC_EGREP_CPP(yes, [
1471 #ifdef __ELF__
1472         yes
1473 #endif
1474                     ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
1475                 if test $tcl_cv_ld_elf = yes; then
1476                     SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
1477                 else
1478                     SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
1479                 fi
1480             ], [
1481                 SHLIB_CFLAGS=""
1482                 SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
1483                 SHLIB_LD_LIBS='${LIBS}'
1484                 SHLIB_SUFFIX=".a"
1485                 DL_OBJS="tclLoadAout.o"
1486                 DL_LIBS=""
1487                 CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1488                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1489                 SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1490             ])
1491
1492             # FreeBSD doesn't handle version numbers with dots.
1493
1494             UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1495             TCL_LIB_VERSIONS_OK=nodots
1496             ;;
1497         OpenBSD-*)
1498             case `arch -s` in
1499             m88k|vax)
1500                 SHLIB_CFLAGS=""
1501                 SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
1502                 SHLIB_LD_LIBS='${LIBS}'
1503                 SHLIB_SUFFIX=".a"
1504                 DL_OBJS="tclLoadAout.o"
1505                 DL_LIBS=""
1506                 LDFLAGS=""
1507                 CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1508                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1509                 SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1510                 ;;
1511             *)
1512                 # OpenBSD/SPARC[64] needs -fPIC, -fpic will not do.
1513                 case `machine` in
1514                 sparc|sparc64)
1515                     SHLIB_CFLAGS="-fPIC";;
1516                 *)
1517                     SHLIB_CFLAGS="-fpic";;
1518                 esac
1519                 SHLIB_LD="${CC} -shared ${SHLIB_CFLAGS}"
1520                 SHLIB_LD_LIBS='${LIBS}'
1521                 SHLIB_SUFFIX=".so"
1522                 DL_OBJS="tclLoadDl.o"
1523                 DL_LIBS=""
1524                 CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1525                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1526                 SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
1527                 AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
1528                     AC_EGREP_CPP(yes, [
1529 #ifdef __ELF__
1530         yes
1531 #endif
1532                     ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
1533                 if test $tcl_cv_ld_elf = yes; then
1534                     LDFLAGS=-Wl,-export-dynamic
1535                 else
1536                     LDFLAGS=""
1537                 fi
1538                 ;;
1539             esac
1540
1541             # OpenBSD doesn't do version numbers with dots.
1542             UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1543             TCL_LIB_VERSIONS_OK=nodots
1544             ;;
1545         FreeBSD-*)
1546             # FreeBSD 3.* and greater have ELF.
1547             SHLIB_CFLAGS="-fPIC"
1548             SHLIB_LD="ld -Bshareable -x"
1549             SHLIB_LD_LIBS='${LIBS}'
1550             SHLIB_SUFFIX=".so"
1551             DL_OBJS="tclLoadDl.o"
1552             DL_LIBS=""
1553             LDFLAGS="$LDFLAGS -export-dynamic"
1554             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1555             LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1556             if test "${TCL_THREADS}" = "1" ; then
1557                 # The -pthread needs to go in the CFLAGS, not LIBS
1558                 LIBS=`echo $LIBS | sed s/-pthread//`
1559                 CFLAGS="$CFLAGS -pthread"
1560                 LDFLAGS="$LDFLAGS -pthread"
1561             fi
1562             case $system in
1563             FreeBSD-3.*)
1564                 # FreeBSD-3 doesn't handle version numbers with dots.
1565                 UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1566                 SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
1567                 TCL_LIB_VERSIONS_OK=nodots
1568                 ;;
1569             esac
1570             ;;
1571         Darwin-*)
1572             CFLAGS_OPTIMIZE="-Os"
1573             SHLIB_CFLAGS="-fno-common"
1574             # To avoid discrepancies between what headers configure sees during
1575             # preprocessing tests and compiling tests, move any -isysroot and
1576             # -mmacosx-version-min flags from CFLAGS to CPPFLAGS:
1577             CPPFLAGS="${CPPFLAGS} `echo " ${CFLAGS}" | \
1578                 awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
1579                 if ([$]i~/^(isysroot|mmacosx-version-min)/) print "-"[$]i}'`"
1580             CFLAGS="`echo " ${CFLAGS}" | \
1581                 awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
1582                 if (!([$]i~/^(isysroot|mmacosx-version-min)/)) print "-"[$]i}'`"
1583             if test $do64bit = yes; then
1584                 case `arch` in
1585                     ppc)
1586                         AC_CACHE_CHECK([if compiler accepts -arch ppc64 flag],
1587                                 tcl_cv_cc_arch_ppc64, [
1588                             hold_cflags=$CFLAGS
1589                             CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
1590                             AC_TRY_LINK(,, tcl_cv_cc_arch_ppc64=yes,
1591                                     tcl_cv_cc_arch_ppc64=no)
1592                             CFLAGS=$hold_cflags])
1593                         if test $tcl_cv_cc_arch_ppc64 = yes; then
1594                             CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
1595                             do64bit_ok=yes
1596                         fi;;
1597                     i386)
1598                         AC_CACHE_CHECK([if compiler accepts -arch x86_64 flag],
1599                                 tcl_cv_cc_arch_x86_64, [
1600                             hold_cflags=$CFLAGS
1601                             CFLAGS="$CFLAGS -arch x86_64"
1602                             AC_TRY_LINK(,, tcl_cv_cc_arch_x86_64=yes,
1603                                     tcl_cv_cc_arch_x86_64=no)
1604                             CFLAGS=$hold_cflags])
1605                         if test $tcl_cv_cc_arch_x86_64 = yes; then
1606                             CFLAGS="$CFLAGS -arch x86_64"
1607                             do64bit_ok=yes
1608                         fi;;
1609                     *)
1610                         AC_MSG_WARN([Don't know how enable 64-bit on architecture `arch`]);;
1611                 esac
1612             else
1613                 # Check for combined 32-bit and 64-bit fat build
1614                 echo "$CFLAGS " | grep -E -q -- '-arch (ppc64|x86_64) ' && \
1615                     echo "$CFLAGS " | grep -E -q -- '-arch (ppc|i386) ' && \
1616                     fat_32_64=yes
1617             fi
1618             SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS}'
1619             AC_CACHE_CHECK([if ld accepts -single_module flag], tcl_cv_ld_single_module, [
1620                 hold_ldflags=$LDFLAGS
1621                 LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
1622                 AC_TRY_LINK(, [int i;], tcl_cv_ld_single_module=yes, tcl_cv_ld_single_module=no)
1623                 LDFLAGS=$hold_ldflags])
1624             if test $tcl_cv_ld_single_module = yes; then
1625                 SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
1626             fi
1627             SHLIB_LD_LIBS='${LIBS}'
1628             SHLIB_SUFFIX=".dylib"
1629             DL_OBJS="tclLoadDyld.o"
1630             DL_LIBS=""
1631             # Don't use -prebind when building for Mac OS X 10.4 or later only:
1632             test "`echo "${MACOSX_DEPLOYMENT_TARGET}" | awk -F '10\\.' '{print int([$]2)}'`" -lt 4 -a \
1633                 "`echo "${CPPFLAGS}" | awk -F '-mmacosx-version-min=10\\.' '{print int([$]2)}'`" -lt 4 && \
1634                 LDFLAGS="$LDFLAGS -prebind"
1635             LDFLAGS="$LDFLAGS -headerpad_max_install_names"
1636             AC_CACHE_CHECK([if ld accepts -search_paths_first flag], tcl_cv_ld_search_paths_first, [
1637                 hold_ldflags=$LDFLAGS
1638                 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
1639                 AC_TRY_LINK(, [int i;], tcl_cv_ld_search_paths_first=yes, tcl_cv_ld_search_paths_first=no)
1640                 LDFLAGS=$hold_ldflags])
1641             if test $tcl_cv_ld_search_paths_first = yes; then
1642                 LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
1643             fi
1644             CC_SEARCH_FLAGS=""
1645             LD_SEARCH_FLAGS=""
1646             LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH"
1647             PLAT_OBJS=\$\(MAC\_OSX_OBJS\)
1648             PLAT_SRCS=\$\(MAC\_OSX_SRCS\)
1649             AC_MSG_CHECKING([whether to use CoreFoundation])
1650             AC_ARG_ENABLE(corefoundation, [  --enable-corefoundation use CoreFoundation API [--enable-corefoundation]],
1651                 [tcl_corefoundation=$enableval], [tcl_corefoundation=yes])
1652             AC_MSG_RESULT([$tcl_corefoundation])
1653             if test $tcl_corefoundation = yes; then
1654                 AC_CACHE_CHECK([for CoreFoundation.framework], tcl_cv_lib_corefoundation, [
1655                     hold_libs=$LIBS
1656                     if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
1657                         # On Tiger there is no 64-bit CF, so remove 64-bit archs
1658                         # from CFLAGS et al. while testing for presence of CF.
1659                         # 64-bit CF is disabled in tclUnixPort.h if necessary.
1660                         eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc64 / /g" -e "s/-arch x86_64 / /g"`"'
1661                     done; fi
1662                     LIBS="$LIBS -framework CoreFoundation"
1663                     AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
1664                         [CFBundleRef b = CFBundleGetMainBundle();],
1665                         tcl_cv_lib_corefoundation=yes, tcl_cv_lib_corefoundation=no)
1666                     if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
1667                         eval $v'="$hold_'$v'"'
1668                     done; fi; LIBS=$hold_libs])
1669                 if test $tcl_cv_lib_corefoundation = yes; then
1670                     LIBS="$LIBS -framework CoreFoundation"
1671                     AC_DEFINE(HAVE_COREFOUNDATION)
1672                 else
1673                     tcl_corefoundation=no
1674                 fi
1675                 if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then
1676                     AC_CACHE_CHECK([for 64-bit CoreFoundation], tcl_cv_lib_corefoundation_64, [
1677                         for v in CFLAGS CPPFLAGS LDFLAGS; do
1678                             eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc / /g" -e "s/-arch i386 / /g"`"'
1679                         done
1680                         AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
1681                             [CFBundleRef b = CFBundleGetMainBundle();],
1682                             tcl_cv_lib_corefoundation_64=yes, tcl_cv_lib_corefoundation_64=no)
1683                         for v in CFLAGS CPPFLAGS LDFLAGS; do
1684                             eval $v'="$hold_'$v'"'
1685                         done])
1686                     if test $tcl_cv_lib_corefoundation_64 = no; then
1687                         AC_DEFINE(NO_COREFOUNDATION_64)
1688                     fi
1689                 fi
1690             fi
1691             AC_DEFINE(MAC_OSX_TCL)
1692             ;;
1693         NEXTSTEP-*)
1694             SHLIB_CFLAGS=""
1695             SHLIB_LD="cc -nostdlib -r"
1696             SHLIB_LD_LIBS=""
1697             SHLIB_SUFFIX=".so"
1698             DL_OBJS="tclLoadNext.o"
1699             DL_LIBS=""
1700             CC_SEARCH_FLAGS=""
1701             LD_SEARCH_FLAGS=""
1702             ;;
1703         OS/390-*)
1704             CFLAGS_OPTIMIZE=""          # Optimizer is buggy
1705             AC_DEFINE(_OE_SOCKETS)      # needed in sys/socket.h
1706             ;;
1707         OSF1-1.0|OSF1-1.1|OSF1-1.2)
1708             # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1
1709             SHLIB_CFLAGS=""
1710             # Hack: make package name same as library name
1711             SHLIB_LD='ld -R -export $@:'
1712             SHLIB_LD_LIBS=""
1713             SHLIB_SUFFIX=".so"
1714             DL_OBJS="tclLoadOSF.o"
1715             DL_LIBS=""
1716             CC_SEARCH_FLAGS=""
1717             LD_SEARCH_FLAGS=""
1718             ;;
1719         OSF1-1.*)
1720             # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
1721             SHLIB_CFLAGS="-fPIC"
1722             if test "$SHARED_BUILD" = "1" ; then
1723                 SHLIB_LD="ld -shared"
1724             else
1725                 SHLIB_LD="ld -non_shared"
1726             fi
1727             SHLIB_LD_LIBS=""
1728             SHLIB_SUFFIX=".so"
1729             DL_OBJS="tclLoadDl.o"
1730             DL_LIBS=""
1731             CC_SEARCH_FLAGS=""
1732             LD_SEARCH_FLAGS=""
1733             ;;
1734         OSF1-V*)
1735             # Digital OSF/1
1736             SHLIB_CFLAGS=""
1737             if test "$SHARED_BUILD" = "1" ; then
1738                 SHLIB_LD='ld -shared -expect_unresolved "*"'
1739             else
1740                 SHLIB_LD='ld -non_shared -expect_unresolved "*"'
1741             fi
1742             SHLIB_LD_LIBS=""
1743             SHLIB_SUFFIX=".so"
1744             DL_OBJS="tclLoadDl.o"
1745             DL_LIBS=""
1746             CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
1747             LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
1748             if test "$GCC" = "yes" ; then
1749                 CFLAGS="$CFLAGS -mieee"
1750             else
1751                 CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee"
1752             fi
1753             # see pthread_intro(3) for pthread support on osf1, k.furukawa
1754             if test "${TCL_THREADS}" = "1" ; then
1755                 CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE"
1756                 CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
1757                 LIBS=`echo $LIBS | sed s/-lpthreads//`
1758                 if test "$GCC" = "yes" ; then
1759                     LIBS="$LIBS -lpthread -lmach -lexc"
1760                 else
1761                     CFLAGS="$CFLAGS -pthread"
1762                     LDFLAGS="$LDFLAGS -pthread"
1763                 fi
1764             fi
1765
1766             ;;
1767         QNX-6*)
1768             # QNX RTP
1769             # This may work for all QNX, but it was only reported for v6.
1770             SHLIB_CFLAGS="-fPIC"
1771             SHLIB_LD="ld -Bshareable -x"
1772             SHLIB_LD_LIBS=""
1773             SHLIB_SUFFIX=".so"
1774             DL_OBJS="tclLoadDl.o"
1775             # dlopen is in -lc on QNX
1776             DL_LIBS=""
1777             CC_SEARCH_FLAGS=""
1778             LD_SEARCH_FLAGS=""
1779             ;;
1780         RISCos-*)
1781             SHLIB_CFLAGS="-G 0"
1782             SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
1783             SHLIB_LD_LIBS='${LIBS}'
1784             SHLIB_SUFFIX=".a"
1785             DL_OBJS="tclLoadAout.o"
1786             DL_LIBS=""
1787             LDFLAGS="$LDFLAGS -Wl,-D,08000000"
1788             CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1789             LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1790             ;;
1791         SCO_SV-3.2*)
1792             # Note, dlopen is available only on SCO 3.2.5 and greater. However,
1793             # this test works, since "uname -s" was non-standard in 3.2.4 and
1794             # below.
1795             if test "$GCC" = "yes" ; then
1796                 SHLIB_CFLAGS="-fPIC -melf"
1797                 LDFLAGS="$LDFLAGS -melf -Wl,-Bexport"
1798             else
1799                 SHLIB_CFLAGS="-Kpic -belf"
1800                 LDFLAGS="$LDFLAGS -belf -Wl,-Bexport"
1801             fi
1802             SHLIB_LD="ld -G"
1803             SHLIB_LD_LIBS=""
1804             SHLIB_SUFFIX=".so"
1805             DL_OBJS="tclLoadDl.o"
1806             DL_LIBS=""
1807             CC_SEARCH_FLAGS=""
1808             LD_SEARCH_FLAGS=""
1809             ;;
1810         SINIX*5.4*)
1811             SHLIB_CFLAGS="-K PIC"
1812             SHLIB_LD="cc -G"
1813             SHLIB_LD_LIBS=""
1814             SHLIB_SUFFIX=".so"
1815             DL_OBJS="tclLoadDl.o"
1816             DL_LIBS="-ldl"
1817             CC_SEARCH_FLAGS=""
1818             LD_SEARCH_FLAGS=""
1819             ;;
1820         SunOS-4*)
1821             SHLIB_CFLAGS="-PIC"
1822             SHLIB_LD="ld"
1823             SHLIB_LD_LIBS=""
1824             SHLIB_SUFFIX=".so"
1825             DL_OBJS="tclLoadDl.o"
1826             DL_LIBS="-ldl"
1827             CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1828             LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1829
1830             # SunOS can't handle version numbers with dots in them in library
1831             # specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
1832             # requires an extra version number at the end of .so file names.
1833             # So, the library has to have a name like libtcl75.so.1.0
1834
1835             SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
1836             UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
1837             TCL_LIB_VERSIONS_OK=nodots
1838             ;;
1839         SunOS-5.[[0-6]])
1840             # Careful to not let 5.10+ fall into this case
1841
1842             # Note: If _REENTRANT isn't defined, then Solaris
1843             # won't define thread-safe library routines.
1844
1845             AC_DEFINE(_REENTRANT)
1846             AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1847
1848             SHLIB_CFLAGS="-KPIC"
1849
1850             # Note: need the LIBS below, otherwise Tk won't find Tcl's
1851             # symbols when dynamically loaded into tclsh.
1852
1853             SHLIB_LD_LIBS='${LIBS}'
1854             SHLIB_SUFFIX=".so"
1855             DL_OBJS="tclLoadDl.o"
1856             DL_LIBS="-ldl"
1857             if test "$GCC" = "yes" ; then
1858                 SHLIB_LD="$CC -shared"
1859                 CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
1860                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1861             else
1862                 SHLIB_LD="/usr/ccs/bin/ld -G -z text"
1863                 CC_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
1864                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1865             fi
1866             ;;
1867         SunOS-5*)
1868             # Note: If _REENTRANT isn't defined, then Solaris
1869             # won't define thread-safe library routines.
1870
1871             AC_DEFINE(_REENTRANT)
1872             AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1873
1874             SHLIB_CFLAGS="-KPIC"
1875
1876             # Check to enable 64-bit flags for compiler/linker
1877             if test "$do64bit" = "yes" ; then
1878                 arch=`isainfo`
1879                 if test "$arch" = "sparcv9 sparc" ; then
1880                         if test "$GCC" = "yes" ; then
1881                             if test "`gcc -dumpversion | awk -F. '{print [$]1}'`" -lt "3" ; then
1882                                 AC_MSG_WARN([64bit mode not supported with GCC < 3.2 on $system])
1883                             else
1884                                 do64bit_ok=yes
1885                                 CFLAGS="$CFLAGS -m64 -mcpu=v9"
1886                                 LDFLAGS="$LDFLAGS -m64 -mcpu=v9"
1887                                 SHLIB_CFLAGS="-fPIC"
1888                             fi
1889                         else
1890                             do64bit_ok=yes
1891                             if test "$do64bitVIS" = "yes" ; then
1892                                 CFLAGS="$CFLAGS -xarch=v9a"
1893                                 LDFLAGS="$LDFLAGS -xarch=v9a"
1894                             else
1895                                 CFLAGS="$CFLAGS -xarch=v9"
1896                                 LDFLAGS="$LDFLAGS -xarch=v9"
1897                             fi
1898                             # Solaris 64 uses this as well
1899                             #LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH_64"
1900                         fi
1901                 elif test "$arch" = "amd64 i386" ; then
1902                     if test "$GCC" = "yes" ; then
1903                         AC_MSG_WARN([64bit mode not supported with GCC on $system])
1904                     else
1905                         do64bit_ok=yes
1906                         CFLAGS="$CFLAGS -xarch=amd64"
1907                         LDFLAGS="$LDFLAGS -xarch=amd64"
1908                     fi
1909                 else
1910                     AC_MSG_WARN([64bit mode not supported for $arch])
1911                 fi
1912             fi
1913
1914             # Note: need the LIBS below, otherwise Tk won't find Tcl's
1915             # symbols when dynamically loaded into tclsh.
1916
1917             SHLIB_LD_LIBS='${LIBS}'
1918             SHLIB_SUFFIX=".so"
1919             DL_OBJS="tclLoadDl.o"
1920             DL_LIBS="-ldl"
1921             if test "$GCC" = "yes" ; then
1922                 SHLIB_LD="$CC -shared"
1923                 CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
1924                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1925                 if test "$do64bit_ok" = "yes" ; then
1926                     # We need to specify -static-libgcc or we need to
1927                     # add the path to the sparv9 libgcc.
1928                     SHLIB_LD="$SHLIB_LD -m64 -mcpu=v9 -static-libgcc"
1929                     # for finding sparcv9 libgcc, get the regular libgcc
1930                     # path, remove so name and append 'sparcv9'
1931                     #v9gcclibdir="`gcc -print-file-name=libgcc_s.so` | ..."
1932                     #CC_SEARCH_FLAGS="${CC_SEARCH_FLAGS},-R,$v9gcclibdir"
1933                 fi
1934             else
1935                 case $system in
1936                     SunOS-5.[[1-9]][[0-9]]*)
1937                         SHLIB_LD='${CC} -G -z text';;
1938                     *)
1939                         SHLIB_LD="/usr/ccs/bin/ld -G -z text";;
1940                 esac
1941                 CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
1942                 LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
1943             fi
1944             ;;
1945         ULTRIX-4.*)
1946             SHLIB_CFLAGS="-G 0"
1947             SHLIB_SUFFIX=".a"
1948             SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
1949             SHLIB_LD_LIBS='${LIBS}'
1950             DL_OBJS="tclLoadAout.o"
1951             DL_LIBS=""
1952             LDFLAGS="$LDFLAGS -Wl,-D,08000000"
1953             CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
1954             LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
1955             if test "$GCC" != "yes" ; then
1956                 CFLAGS="$CFLAGS -DHAVE_TZSET -std1"
1957             fi
1958             ;;
1959         UNIX_SV* | UnixWare-5*)
1960             SHLIB_CFLAGS="-KPIC"
1961             SHLIB_LD="cc -G"
1962             SHLIB_LD_LIBS=""
1963             SHLIB_SUFFIX=".so"
1964             DL_OBJS="tclLoadDl.o"
1965             DL_LIBS="-ldl"
1966             # Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers
1967             # that don't grok the -Bexport option.  Test that it does.
1968             AC_CACHE_CHECK([for ld accepts -Bexport flag], tcl_cv_ld_Bexport, [
1969                 hold_ldflags=$LDFLAGS
1970                 LDFLAGS="$LDFLAGS -Wl,-Bexport"
1971                 AC_TRY_LINK(, [int i;], tcl_cv_ld_Bexport=yes, tcl_cv_ld_Bexport=no)
1972                 LDFLAGS=$hold_ldflags])
1973             if test $tcl_cv_ld_Bexport = yes; then
1974                 LDFLAGS="$LDFLAGS -Wl,-Bexport"
1975             fi
1976             CC_SEARCH_FLAGS=""
1977             LD_SEARCH_FLAGS=""
1978             ;;
1979     esac
1980
1981     if test "$do64bit" = "yes" -a "$do64bit_ok" = "no" ; then
1982         AC_MSG_WARN([64bit support being disabled -- don't know magic for this platform])
1983     fi
1984
1985 dnl # Add any CPPFLAGS set in the environment to our CFLAGS, but delay doing so
1986 dnl # until the end of configure, as configure's compile and link tests use
1987 dnl # both CPPFLAGS and CFLAGS (unlike our compile and link) but configure's
1988 dnl # preprocessing tests use only CPPFLAGS.
1989     SC_CONFIG_COMMANDS_PRE([CFLAGS="${CFLAGS} ${CPPFLAGS}"; CPPFLAGS=""])
1990
1991     # Step 4: If pseudo-static linking is in use (see K. B. Kenny, "Dynamic
1992     # Loading for Tcl -- What Became of It?".  Proc. 2nd Tcl/Tk Workshop,
1993     # New Orleans, LA, Computerized Processes Unlimited, 1994), then we need
1994     # to determine which of several header files defines the a.out file
1995     # format (a.out.h, sys/exec.h, or sys/exec_aout.h).  At present, we
1996     # support only a file format that is more or less version-7-compatible.
1997     # In particular,
1998     #   - a.out files must begin with `struct exec'.
1999     #   - the N_TXTOFF on the `struct exec' must compute the seek address
2000     #     of the text segment
2001     #   - The `struct exec' must contain a_magic, a_text, a_data, a_bss
2002     #     and a_entry fields.
2003     # The following compilation should succeed if and only if either sys/exec.h
2004     # or a.out.h is usable for the purpose.
2005     #
2006     # Note that the modified COFF format used on MIPS Ultrix 4.x is usable; the
2007     # `struct exec' includes a second header that contains information that
2008     # duplicates the v7 fields that are needed.
2009
2010     if test "x$DL_OBJS" = "xtclLoadAout.o" ; then
2011         AC_CACHE_CHECK([sys/exec.h], tcl_cv_sysexec_h, [
2012         AC_TRY_COMPILE([#include <sys/exec.h>],[
2013             struct exec foo;
2014             unsigned long seek;
2015             int flag;
2016 #if defined(__mips) || defined(mips)
2017             seek = N_TXTOFF (foo.ex_f, foo.ex_o);
2018 #else
2019             seek = N_TXTOFF (foo);
2020 #endif
2021             flag = (foo.a_magic == OMAGIC);
2022             return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
2023     ], tcl_cv_sysexec_h=usable, tcl_cv_sysexec_h=unusable)])
2024         if test $tcl_cv_sysexec_h = usable; then
2025             AC_DEFINE(USE_SYS_EXEC_H)
2026         else
2027             AC_CACHE_CHECK([a.out.h], tcl_cv_aout_h, [
2028             AC_TRY_COMPILE([#include <a.out.h>],[
2029                 struct exec foo;
2030                 unsigned long seek;
2031                 int flag;
2032 #if defined(__mips) || defined(mips)
2033                 seek = N_TXTOFF (foo.ex_f, foo.ex_o);
2034 #else
2035                 seek = N_TXTOFF (foo);
2036 #endif
2037                 flag = (foo.a_magic == OMAGIC);
2038                 return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
2039             ], tcl_cv_aout_h=usable, tcl_cv_aout_h=unusable)])
2040             if test $tcl_cv_aout_h = usable; then
2041                 AC_DEFINE(USE_A_OUT_H)
2042             else
2043                 AC_CACHE_CHECK([sys/exec_aout.h], tcl_cv_sysexecaout_h, [
2044                 AC_TRY_COMPILE([#include <sys/exec_aout.h>],[
2045                     struct exec foo;
2046                     unsigned long seek;
2047                     int flag;
2048 #if defined(__mips) || defined(mips)
2049                     seek = N_TXTOFF (foo.ex_f, foo.ex_o);
2050 #else
2051                     seek = N_TXTOFF (foo);
2052 #endif
2053                     flag = (foo.a_midmag == OMAGIC);
2054                     return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
2055                 ], tcl_cv_sysexecaout_h=usable, tcl_cv_sysexecaout_h=unusable)])
2056                 if test $tcl_cv_sysexecaout_h = usable; then
2057                     AC_DEFINE(USE_SYS_EXEC_AOUT_H)
2058                 else
2059                     DL_OBJS=""
2060                 fi
2061             fi
2062         fi
2063     fi
2064
2065     # Step 5: disable dynamic loading if requested via a command-line switch.
2066
2067     AC_ARG_ENABLE(load, [  --disable-load          disallow dynamic loading and "load" command],
2068         [tcl_ok=$enableval], [tcl_ok=yes])
2069     if test "$tcl_ok" = "no"; then
2070         DL_OBJS=""
2071     fi
2072
2073     if test "x$DL_OBJS" != "x" ; then
2074         BUILD_DLTEST="\$(DLTEST_TARGETS)"
2075     else
2076         echo "Can't figure out how to do dynamic loading or shared libraries"
2077         echo "on this system."
2078         SHLIB_CFLAGS=""
2079         SHLIB_LD=""
2080         SHLIB_SUFFIX=""
2081         DL_OBJS="tclLoadNone.o"
2082         DL_LIBS=""
2083         LDFLAGS="$LDFLAGS_ORIG"
2084         CC_SEARCH_FLAGS=""
2085         LD_SEARCH_FLAGS=""
2086         BUILD_DLTEST=""
2087     fi
2088
2089     # If we're running gcc, then change the C flags for compiling shared
2090     # libraries to the right flags for gcc, instead of those for the
2091     # standard manufacturer compiler.
2092
2093     if test "$DL_OBJS" != "tclLoadNone.o" ; then
2094         if test "$GCC" = "yes" ; then
2095             case $system in
2096                 AIX-*)
2097                     ;;
2098                 BSD/OS*)
2099                     ;;
2100                 IRIX*)
2101                     ;;
2102                 NetBSD-*|FreeBSD-*|OpenBSD-*)
2103                     ;;
2104                 Darwin-*)
2105                     ;;
2106                 RISCos-*)
2107                     ;;
2108                 SCO_SV-3.2*)
2109                     ;;
2110                 ULTRIX-4.*)
2111                     ;;
2112                 *)
2113                     SHLIB_CFLAGS="-fPIC"
2114                     ;;
2115             esac
2116         fi
2117     fi
2118
2119     if test "$SHARED_LIB_SUFFIX" = "" ; then
2120         SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}${SHLIB_SUFFIX}'
2121     fi
2122     if test "$UNSHARED_LIB_SUFFIX" = "" ; then
2123         UNSHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
2124     fi
2125
2126     if test "${SHARED_BUILD}" = "1" && test "${SHLIB_SUFFIX}" != "" ; then
2127         LIB_SUFFIX=${SHARED_LIB_SUFFIX}
2128         MAKE_LIB='${SHLIB_LD} -o [$]@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
2129         INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
2130     else
2131         LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}
2132
2133         if test "$RANLIB" = "" ; then
2134             MAKE_LIB='$(STLIB_LD) [$]@ ${OBJS}'
2135             INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
2136         else
2137             MAKE_LIB='${STLIB_LD} [$]@ ${OBJS} ; ${RANLIB} [$]@'
2138             INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(LIB_FILE))'
2139         fi
2140
2141 dnl        Not at all clear what this was doing in Tcl's configure.in
2142 dnl        or why it was needed was needed. In any event, this sort of
2143 dnl        things needs to be done in the big loop above.
2144 dnl        REMOVE THIS BLOCK LATER! (mdejong)
2145 dnl        case $system in
2146 dnl            BSD/OS*)
2147 dnl                ;;
2148 dnl            AIX-[[1-4]].*)
2149 dnl                ;;
2150 dnl            *)
2151 dnl                SHLIB_LD_LIBS=""
2152 dnl                ;;
2153 dnl        esac
2154     fi
2155
2156
2157     # Stub lib does not depend on shared/static configuration
2158     if test "$RANLIB" = "" ; then
2159         MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS}'
2160         INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)'
2161     else
2162         MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS} ; ${RANLIB} [$]@'
2163         INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(STUB_LIB_FILE))'
2164     fi
2165
2166
2167     AC_SUBST(DL_LIBS)
2168
2169     AC_SUBST(DL_OBJS)
2170     AC_SUBST(PLAT_OBJS)
2171     AC_SUBST(PLAT_SRCS)
2172     AC_SUBST(CFLAGS)
2173     AC_SUBST(CFLAGS_DEBUG)
2174     AC_SUBST(CFLAGS_OPTIMIZE)
2175     AC_SUBST(CFLAGS_WARNING)
2176
2177     AC_SUBST(LDFLAGS)
2178     AC_SUBST(LDFLAGS_DEBUG)
2179     AC_SUBST(LDFLAGS_OPTIMIZE)
2180     AC_SUBST(CC_SEARCH_FLAGS)
2181     AC_SUBST(LD_SEARCH_FLAGS)
2182
2183     AC_SUBST(STLIB_LD)
2184     AC_SUBST(SHLIB_LD)
2185     AC_SUBST(TCL_SHLIB_LD_EXTRAS)
2186     AC_SUBST(TK_SHLIB_LD_EXTRAS)
2187     AC_SUBST(SHLIB_LD_LIBS)
2188     AC_SUBST(SHLIB_CFLAGS)
2189     AC_SUBST(SHLIB_SUFFIX)
2190
2191     AC_SUBST(MAKE_LIB)
2192     AC_SUBST(MAKE_STUB_LIB)
2193     AC_SUBST(INSTALL_LIB)
2194     AC_SUBST(INSTALL_STUB_LIB)
2195     AC_SUBST(RANLIB)
2196 ])
2197
2198 #--------------------------------------------------------------------
2199 # SC_SERIAL_PORT
2200 #
2201 #       Determine which interface to use to talk to the serial port.
2202 #       Note that #include lines must begin in leftmost column for
2203 #       some compilers to recognize them as preprocessor directives,
2204 #       and some build environments have stdin not pointing at a
2205 #       pseudo-terminal (usually /dev/null instead.)
2206 #
2207 # Arguments:
2208 #       none
2209 #
2210 # Results:
2211 #
2212 #       Defines only one of the following vars:
2213 #               HAVE_SYS_MODEM_H
2214 #               USE_TERMIOS
2215 #               USE_TERMIO
2216 #               USE_SGTTY
2217 #
2218 #--------------------------------------------------------------------
2219
2220 AC_DEFUN([SC_SERIAL_PORT], [
2221     AC_CHECK_HEADERS(sys/modem.h)
2222     AC_CACHE_CHECK([termios vs. termio vs. sgtty], tcl_cv_api_serial, [
2223     AC_TRY_RUN([
2224 #include <termios.h>
2225
2226 int main() {
2227     struct termios t;
2228     if (tcgetattr(0, &t) == 0) {
2229         cfsetospeed(&t, 0);
2230         t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
2231         return 0;
2232     }
2233     return 1;
2234 }], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
2235     if test $tcl_cv_api_serial = no ; then
2236         AC_TRY_RUN([
2237 #include <termio.h>
2238
2239 int main() {
2240     struct termio t;
2241     if (ioctl(0, TCGETA, &t) == 0) {
2242         t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
2243         return 0;
2244     }
2245     return 1;
2246 }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
2247     fi
2248     if test $tcl_cv_api_serial = no ; then
2249         AC_TRY_RUN([
2250 #include <sgtty.h>
2251
2252 int main() {
2253     struct sgttyb t;
2254     if (ioctl(0, TIOCGETP, &t) == 0) {
2255         t.sg_ospeed = 0;
2256         t.sg_flags |= ODDP | EVENP | RAW;
2257         return 0;
2258     }
2259     return 1;
2260 }], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
2261     fi
2262     if test $tcl_cv_api_serial = no ; then
2263         AC_TRY_RUN([
2264 #include <termios.h>
2265 #include <errno.h>
2266
2267 int main() {
2268     struct termios t;
2269     if (tcgetattr(0, &t) == 0
2270         || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
2271         cfsetospeed(&t, 0);
2272         t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
2273         return 0;
2274     }
2275     return 1;
2276 }], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
2277     fi
2278     if test $tcl_cv_api_serial = no; then
2279         AC_TRY_RUN([
2280 #include <termio.h>
2281 #include <errno.h>
2282
2283 int main() {
2284     struct termio t;
2285     if (ioctl(0, TCGETA, &t) == 0
2286         || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
2287         t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
2288         return 0;
2289     }
2290     return 1;
2291     }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
2292     fi
2293     if test $tcl_cv_api_serial = no; then
2294         AC_TRY_RUN([
2295 #include <sgtty.h>
2296 #include <errno.h>
2297
2298 int main() {
2299     struct sgttyb t;
2300     if (ioctl(0, TIOCGETP, &t) == 0
2301         || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
2302         t.sg_ospeed = 0;
2303         t.sg_flags |= ODDP | EVENP | RAW;
2304         return 0;
2305     }
2306     return 1;
2307 }], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=none, tcl_cv_api_serial=none)
2308     fi])
2309     case $tcl_cv_api_serial in
2310         termios) AC_DEFINE(USE_TERMIOS);;
2311         termio)  AC_DEFINE(USE_TERMIO);;
2312         sgtty)   AC_DEFINE(USE_SGTTY);;
2313     esac
2314 ])
2315
2316 #--------------------------------------------------------------------
2317 # SC_MISSING_POSIX_HEADERS
2318 #
2319 #       Supply substitutes for missing POSIX header files.  Special
2320 #       notes:
2321 #           - stdlib.h doesn't define strtol, strtoul, or
2322 #             strtod insome versions of SunOS
2323 #           - some versions of string.h don't declare procedures such
2324 #             as strstr
2325 #
2326 # Arguments:
2327 #       none
2328 #
2329 # Results:
2330 #
2331 #       Defines some of the following vars:
2332 #               NO_DIRENT_H
2333 #               NO_ERRNO_H
2334 #               NO_VALUES_H
2335 #               HAVE_LIMITS_H or NO_LIMITS_H
2336 #               NO_STDLIB_H
2337 #               NO_STRING_H
2338 #               NO_SYS_WAIT_H
2339 #               NO_DLFCN_H
2340 #               HAVE_UNISTD_H
2341 #               HAVE_SYS_PARAM_H
2342 #
2343 #               HAVE_STRING_H ?
2344 #
2345 #--------------------------------------------------------------------
2346
2347 AC_DEFUN([SC_MISSING_POSIX_HEADERS], [
2348     AC_CACHE_CHECK([dirent.h], tcl_cv_dirent_h, [
2349     AC_TRY_LINK([#include <sys/types.h>
2350 #include <dirent.h>], [
2351 #ifndef _POSIX_SOURCE
2352 #   ifdef __Lynx__
2353         /*
2354          * Generate compilation error to make the test fail:  Lynx headers
2355          * are only valid if really in the POSIX environment.
2356          */
2357
2358         missing_procedure();
2359 #   endif
2360 #endif
2361 DIR *d;
2362 struct dirent *entryPtr;
2363 char *p;
2364 d = opendir("foobar");
2365 entryPtr = readdir(d);
2366 p = entryPtr->d_name;
2367 closedir(d);
2368 ], tcl_cv_dirent_h=yes, tcl_cv_dirent_h=no)])
2369
2370     if test $tcl_cv_dirent_h = no; then
2371         AC_DEFINE(NO_DIRENT_H)
2372     fi
2373
2374     AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H)])
2375     AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H)])
2376     AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H)])
2377     AC_CHECK_HEADER(limits.h,
2378         [AC_DEFINE(HAVE_LIMITS_H)], [AC_DEFINE(NO_LIMITS_H)])
2379     AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0)
2380     AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0)
2381     AC_EGREP_HEADER(strtoul, stdlib.h, , tcl_ok=0)
2382     AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0)
2383     if test $tcl_ok = 0; then
2384         AC_DEFINE(NO_STDLIB_H)
2385     fi
2386     AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0)
2387     AC_EGREP_HEADER(strstr, string.h, , tcl_ok=0)
2388     AC_EGREP_HEADER(strerror, string.h, , tcl_ok=0)
2389
2390     # See also memmove check below for a place where NO_STRING_H can be
2391     # set and why.
2392
2393     if test $tcl_ok = 0; then
2394         AC_DEFINE(NO_STRING_H)
2395     fi
2396
2397     AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H)])
2398     AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H)])
2399
2400     # OS/390 lacks sys/param.h (and doesn't need it, by chance).
2401     AC_HAVE_HEADERS(unistd.h sys/param.h)
2402 ])
2403
2404 #--------------------------------------------------------------------
2405 # SC_PATH_X
2406 #
2407 #       Locate the X11 header files and the X11 library archive.  Try
2408 #       the ac_path_x macro first, but if it doesn't find the X stuff
2409 #       (e.g. because there's no xmkmf program) then check through
2410 #       a list of possible directories.  Under some conditions the
2411 #       autoconf macro will return an include directory that contains
2412 #       no include files, so double-check its result just to be safe.
2413 #
2414 # Arguments:
2415 #       none
2416 #
2417 # Results:
2418 #
2419 #       Sets the the following vars:
2420 #               XINCLUDES
2421 #               XLIBSW
2422 #
2423 #--------------------------------------------------------------------
2424
2425 AC_DEFUN([SC_PATH_X], [
2426     AC_PATH_X
2427     not_really_there=""
2428     if test "$no_x" = ""; then
2429         if test "$x_includes" = ""; then
2430             AC_TRY_CPP([#include <X11/XIntrinsic.h>], , not_really_there="yes")
2431         else
2432             if test ! -r $x_includes/X11/Intrinsic.h; then
2433                 not_really_there="yes"
2434             fi
2435         fi
2436     fi
2437     if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
2438         AC_MSG_CHECKING([for X11 header files])
2439         found_xincludes="no"
2440         AC_TRY_CPP([#include <X11/Intrinsic.h>], found_xincludes="yes", found_xincludes="no")
2441         if test "$found_xincludes" = "no"; then
2442             dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/X11R6/include /usr/X11R5/include /usr/include/X11R5 /usr/include/X11R4 /usr/openwin/include /usr/X11/include /usr/sww/include"
2443             for i in $dirs ; do
2444                 if test -r $i/X11/Intrinsic.h; then
2445                     AC_MSG_RESULT([$i])
2446                     XINCLUDES=" -I$i"
2447                     found_xincludes="yes"
2448                     break
2449                 fi
2450             done
2451         fi
2452     else
2453         if test "$x_includes" != ""; then
2454             XINCLUDES="-I$x_includes"
2455             found_xincludes="yes"
2456         fi
2457     fi
2458     if test found_xincludes = "no"; then
2459         AC_MSG_RESULT([couldn't find any!])
2460     fi
2461
2462     if test "$no_x" = yes; then
2463         AC_MSG_CHECKING([for X11 libraries])
2464         XLIBSW=nope
2465         dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/X11R6/lib /usr/X11R5/lib /usr/lib/X11R5 /usr/lib/X11R4 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
2466         for i in $dirs ; do
2467             if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
2468                 AC_MSG_RESULT([$i])
2469                 XLIBSW="-L$i -lX11"
2470                 x_libraries="$i"
2471                 break
2472             fi
2473         done
2474     else
2475         if test "$x_libraries" = ""; then
2476             XLIBSW=-lX11
2477         else
2478             XLIBSW="-L$x_libraries -lX11"
2479         fi
2480     fi
2481     if test "$XLIBSW" = nope ; then
2482         AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow)
2483     fi
2484     if test "$XLIBSW" = nope ; then
2485         AC_MSG_RESULT([could not find any!  Using -lX11.])
2486         XLIBSW=-lX11
2487     fi
2488 ])
2489
2490 #--------------------------------------------------------------------
2491 # SC_BLOCKING_STYLE
2492 #
2493 #       The statements below check for systems where POSIX-style
2494 #       non-blocking I/O (O_NONBLOCK) doesn't work or is unimplemented.
2495 #       On these systems (mostly older ones), use the old BSD-style
2496 #       FIONBIO approach instead.
2497 #
2498 # Arguments:
2499 #       none
2500 #
2501 # Results:
2502 #
2503 #       Defines some of the following vars:
2504 #               HAVE_SYS_IOCTL_H
2505 #               HAVE_SYS_FILIO_H
2506 #               USE_FIONBIO
2507 #               O_NONBLOCK
2508 #
2509 #--------------------------------------------------------------------
2510
2511 AC_DEFUN([SC_BLOCKING_STYLE], [
2512     AC_CHECK_HEADERS(sys/ioctl.h)
2513     AC_CHECK_HEADERS(sys/filio.h)
2514     SC_CONFIG_SYSTEM
2515     AC_MSG_CHECKING([FIONBIO vs. O_NONBLOCK for nonblocking I/O])
2516     case $system in
2517         # There used to be code here to use FIONBIO under AIX.  However, it
2518         # was reported that FIONBIO doesn't work under AIX 3.2.5.  Since
2519         # using O_NONBLOCK seems fine under AIX 4.*, I removed the FIONBIO
2520         # code (JO, 5/31/97).
2521
2522         OSF*)
2523             AC_DEFINE(USE_FIONBIO)
2524             AC_MSG_RESULT([FIONBIO])
2525             ;;
2526         SunOS-4*)
2527             AC_DEFINE(USE_FIONBIO)
2528             AC_MSG_RESULT([FIONBIO])
2529             ;;
2530         ULTRIX-4.*)
2531             AC_DEFINE(USE_FIONBIO)
2532             AC_MSG_RESULT([FIONBIO])
2533             ;;
2534         *)
2535             AC_MSG_RESULT([O_NONBLOCK])
2536             ;;
2537     esac
2538 ])
2539
2540 #--------------------------------------------------------------------
2541 # SC_TIME_HANLDER
2542 #
2543 #       Checks how the system deals with time.h, what time structures
2544 #       are used on the system, and what fields the structures have.
2545 #
2546 # Arguments:
2547 #       none
2548 #
2549 # Results:
2550 #
2551 #       Defines some of the following vars:
2552 #               USE_DELTA_FOR_TZ
2553 #               HAVE_TM_GMTOFF
2554 #               HAVE_TM_TZADJ
2555 #               HAVE_TIMEZONE_VAR
2556 #
2557 #--------------------------------------------------------------------
2558
2559 AC_DEFUN([SC_TIME_HANDLER], [
2560     AC_CHECK_HEADERS(sys/time.h)
2561     AC_HEADER_TIME
2562     AC_STRUCT_TIMEZONE
2563
2564     AC_CHECK_FUNCS(gmtime_r localtime_r)
2565
2566     AC_CACHE_CHECK([tm_tzadj in struct tm], tcl_cv_member_tm_tzadj, [
2567         AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_tzadj;],
2568             tcl_cv_member_tm_tzadj=yes, tcl_cv_member_tm_tzadj=no)])
2569     if test $tcl_cv_member_tm_tzadj = yes ; then
2570         AC_DEFINE(HAVE_TM_TZADJ)
2571     fi
2572
2573     AC_CACHE_CHECK([tm_gmtoff in struct tm], tcl_cv_member_tm_gmtoff, [
2574         AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_gmtoff;],
2575             tcl_cv_member_tm_gmtoff=yes, tcl_cv_member_tm_gmtoff=no)])
2576     if test $tcl_cv_member_tm_gmtoff = yes ; then
2577         AC_DEFINE(HAVE_TM_GMTOFF)
2578     fi
2579
2580     #
2581     # Its important to include time.h in this check, as some systems
2582     # (like convex) have timezone functions, etc.
2583     #
2584     AC_CACHE_CHECK([long timezone variable], tcl_cv_timezone_long, [
2585         AC_TRY_COMPILE([#include <time.h>],
2586             [extern long timezone;
2587             timezone += 1;
2588             exit (0);],
2589             tcl_cv_timezone_long=yes, tcl_cv_timezone_long=no)])
2590     if test $tcl_cv_timezone_long = yes ; then
2591         AC_DEFINE(HAVE_TIMEZONE_VAR)
2592     else
2593         #
2594         # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
2595         #
2596         AC_CACHE_CHECK([time_t timezone variable], tcl_cv_timezone_time, [
2597             AC_TRY_COMPILE([#include <time.h>],
2598                 [extern time_t timezone;
2599                 timezone += 1;
2600                 exit (0);],
2601                 tcl_cv_timezone_time=yes, tcl_cv_timezone_time=no)])
2602         if test $tcl_cv_timezone_time = yes ; then
2603             AC_DEFINE(HAVE_TIMEZONE_VAR)
2604         fi
2605     fi
2606 ])
2607
2608 #--------------------------------------------------------------------
2609 # SC_BUGGY_STRTOD
2610 #
2611 #       Under Solaris 2.4, strtod returns the wrong value for the
2612 #       terminating character under some conditions.  Check for this
2613 #       and if the problem exists use a substitute procedure
2614 #       "fixstrtod" (provided by Tcl) that corrects the error.
2615 #       Also, on Compaq's Tru64 Unix 5.0,
2616 #       strtod(" ") returns 0.0 instead of a failure to convert.
2617 #
2618 # Arguments:
2619 #       none
2620 #
2621 # Results:
2622 #
2623 #       Might defines some of the following vars:
2624 #               strtod (=fixstrtod)
2625 #
2626 #--------------------------------------------------------------------
2627
2628 AC_DEFUN([SC_BUGGY_STRTOD], [
2629     AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0)
2630     if test "$tcl_strtod" = 1; then
2631         AC_CACHE_CHECK([for Solaris2.4/Tru64 strtod bugs], tcl_cv_strtod_buggy,[
2632             AC_TRY_RUN([
2633                 extern double strtod();
2634                 int main() {
2635                     char *infString="Inf", *nanString="NaN", *spaceString=" ";
2636                     char *term;
2637                     double value;
2638                     value = strtod(infString, &term);
2639                     if ((term != infString) && (term[-1] == 0)) {
2640                         exit(1);
2641                     }
2642                     value = strtod(nanString, &term);
2643                     if ((term != nanString) && (term[-1] == 0)) {
2644                         exit(1);
2645                     }
2646                     value = strtod(spaceString, &term);
2647                     if (term == (spaceString+1)) {
2648                         exit(1);
2649                     }
2650                     exit(0);
2651                 }], tcl_cv_strtod_buggy=ok, tcl_cv_strtod_buggy=buggy,
2652                     tcl_cv_strtod_buggy=buggy)])
2653         if test "$tcl_cv_strtod_buggy" = buggy; then
2654             LIBOBJS="$LIBOBJS fixstrtod.o"
2655             AC_DEFINE(strtod, fixstrtod)
2656         fi
2657     fi
2658 ])
2659
2660 #--------------------------------------------------------------------
2661 # SC_TCL_LINK_LIBS
2662 #
2663 #       Search for the libraries needed to link the Tcl shell.
2664 #       Things like the math library (-lm) and socket stuff (-lsocket vs.
2665 #       -lnsl) are dealt with here.
2666 #
2667 # Arguments:
2668 #       Requires the following vars to be set in the Makefile:
2669 #               DL_LIBS
2670 #               LIBS
2671 #               MATH_LIBS
2672 #
2673 # Results:
2674 #
2675 #       Subst's the following var:
2676 #               TCL_LIBS
2677 #               MATH_LIBS
2678 #
2679 #       Might append to the following vars:
2680 #               LIBS
2681 #
2682 #       Might define the following vars:
2683 #               HAVE_NET_ERRNO_H
2684 #
2685 #--------------------------------------------------------------------
2686
2687 AC_DEFUN([SC_TCL_LINK_LIBS], [
2688     #--------------------------------------------------------------------
2689     # On a few very rare systems, all of the libm.a stuff is
2690     # already in libc.a.  Set compiler flags accordingly.
2691     # Also, Linux requires the "ieee" library for math to work
2692     # right (and it must appear before "-lm").
2693     #--------------------------------------------------------------------
2694
2695     AC_CHECK_FUNC(sin, MATH_LIBS="", MATH_LIBS="-lm")
2696     AC_CHECK_LIB(ieee, main, [MATH_LIBS="-lieee $MATH_LIBS"])
2697
2698     #--------------------------------------------------------------------
2699     # Interactive UNIX requires -linet instead of -lsocket, plus it
2700     # needs net/errno.h to define the socket-related error codes.
2701     #--------------------------------------------------------------------
2702
2703     AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"])
2704     AC_CHECK_HEADER(net/errno.h, [AC_DEFINE(HAVE_NET_ERRNO_H)])
2705
2706     #--------------------------------------------------------------------
2707     #   Check for the existence of the -lsocket and -lnsl libraries.
2708     #   The order here is important, so that they end up in the right
2709     #   order in the command line generated by make.  Here are some
2710     #   special considerations:
2711     #   1. Use "connect" and "accept" to check for -lsocket, and
2712     #      "gethostbyname" to check for -lnsl.
2713     #   2. Use each function name only once:  can't redo a check because
2714     #      autoconf caches the results of the last check and won't redo it.
2715     #   3. Use -lnsl and -lsocket only if they supply procedures that
2716     #      aren't already present in the normal libraries.  This is because
2717     #      IRIX 5.2 has libraries, but they aren't needed and they're
2718     #      bogus:  they goof up name resolution if used.
2719     #   4. On some SVR4 systems, can't use -lsocket without -lnsl too.
2720     #      To get around this problem, check for both libraries together
2721     #      if -lsocket doesn't work by itself.
2722     #--------------------------------------------------------------------
2723
2724     tcl_checkBoth=0
2725     AC_CHECK_FUNC(connect, tcl_checkSocket=0, tcl_checkSocket=1)
2726     if test "$tcl_checkSocket" = 1; then
2727         AC_CHECK_FUNC(setsockopt, , [AC_CHECK_LIB(socket, setsockopt,
2728             LIBS="$LIBS -lsocket", tcl_checkBoth=1)])
2729     fi
2730     if test "$tcl_checkBoth" = 1; then
2731         tk_oldLibs=$LIBS
2732         LIBS="$LIBS -lsocket -lnsl"
2733         AC_CHECK_FUNC(accept, tcl_checkNsl=0, [LIBS=$tk_oldLibs])
2734     fi
2735     AC_CHECK_FUNC(gethostbyname, , [AC_CHECK_LIB(nsl, gethostbyname,
2736             [LIBS="$LIBS -lnsl"])])
2737
2738     # Don't perform the eval of the libraries here because DL_LIBS
2739     # won't be set until we call SC_CONFIG_CFLAGS
2740
2741     TCL_LIBS='${DL_LIBS} ${LIBS} ${MATH_LIBS}'
2742     AC_SUBST(TCL_LIBS)
2743     AC_SUBST(MATH_LIBS)
2744 ])
2745
2746 #--------------------------------------------------------------------
2747 # SC_TCL_EARLY_FLAGS
2748 #
2749 #       Check for what flags are needed to be passed so the correct OS
2750 #       features are available.
2751 #
2752 # Arguments:
2753 #       None
2754 #
2755 # Results:
2756 #
2757 #       Might define the following vars:
2758 #               _ISOC99_SOURCE
2759 #               _LARGEFILE64_SOURCE
2760 #               _LARGEFILE_SOURCE64
2761 #
2762 #--------------------------------------------------------------------
2763
2764 AC_DEFUN([SC_TCL_EARLY_FLAG],[
2765     AC_CACHE_VAL([tcl_cv_flag_]translit($1,[A-Z],[a-z]),
2766         AC_TRY_COMPILE([$2], $3, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no,
2767             AC_TRY_COMPILE([[#define ]$1[ 1
2768 ]$2], $3,
2769                 [tcl_cv_flag_]translit($1,[A-Z],[a-z])=yes,
2770                 [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no)))
2771     if test ["x${tcl_cv_flag_]translit($1,[A-Z],[a-z])[}" = "xyes"] ; then
2772         AC_DEFINE($1)
2773         tcl_flags="$tcl_flags $1"
2774     fi
2775 ])
2776
2777 AC_DEFUN([SC_TCL_EARLY_FLAGS],[
2778     AC_MSG_CHECKING([for required early compiler flags])
2779     tcl_flags=""
2780     SC_TCL_EARLY_FLAG(_ISOC99_SOURCE,[#include <stdlib.h>],
2781         [char *p = (char *)strtoll; char *q = (char *)strtoull;])
2782     SC_TCL_EARLY_FLAG(_LARGEFILE64_SOURCE,[#include <sys/stat.h>],
2783         [struct stat64 buf; int i = stat64("/", &buf);])
2784     SC_TCL_EARLY_FLAG(_LARGEFILE_SOURCE64,[#include <sys/stat.h>],
2785         [char *p = (char *)open64;])
2786     if test "x${tcl_flags}" = "x" ; then
2787         AC_MSG_RESULT([none])
2788     else
2789         AC_MSG_RESULT([${tcl_flags}])
2790     fi
2791 ])
2792
2793 #--------------------------------------------------------------------
2794 # SC_TCL_64BIT_FLAGS
2795 #
2796 #       Check for what is defined in the way of 64-bit features.
2797 #
2798 # Arguments:
2799 #       None
2800 #
2801 # Results:
2802 #
2803 #       Might define the following vars:
2804 #               TCL_WIDE_INT_IS_LONG
2805 #               TCL_WIDE_INT_TYPE
2806 #               HAVE_STRUCT_DIRENT64
2807 #               HAVE_STRUCT_STAT64
2808 #               HAVE_TYPE_OFF64_T
2809 #
2810 #--------------------------------------------------------------------
2811
2812 AC_DEFUN([SC_TCL_64BIT_FLAGS], [
2813     AC_MSG_CHECKING([for 64-bit integer type])
2814     AC_CACHE_VAL(tcl_cv_type_64bit,[
2815         tcl_cv_type_64bit=none
2816         # See if the compiler knows natively about __int64
2817         AC_TRY_COMPILE(,[__int64 value = (__int64) 0;],
2818             tcl_type_64bit=__int64, tcl_type_64bit="long long")
2819         # See if we should use long anyway  Note that we substitute in the
2820         # type that is our current guess for a 64-bit type inside this check
2821         # program, so it should be modified only carefully...
2822         AC_TRY_COMPILE(,[switch (0) {
2823             case 1: case (sizeof(]${tcl_type_64bit}[)==sizeof(long)): ;
2824         }],tcl_cv_type_64bit=${tcl_type_64bit})])
2825     if test "${tcl_cv_type_64bit}" = none ; then
2826         AC_DEFINE(TCL_WIDE_INT_IS_LONG)
2827         AC_MSG_RESULT([using long])
2828     else
2829         AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit})
2830         AC_MSG_RESULT([${tcl_cv_type_64bit}])
2831
2832         # Now check for auxiliary declarations
2833         AC_CACHE_CHECK([for struct dirent64], tcl_cv_struct_dirent64,[
2834             AC_TRY_COMPILE([#include <sys/types.h>
2835 #include <sys/dirent.h>],[struct dirent64 p;],
2836                 tcl_cv_struct_dirent64=yes,tcl_cv_struct_dirent64=no)])
2837         if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then
2838             AC_DEFINE(HAVE_STRUCT_DIRENT64)
2839         fi
2840
2841         AC_CACHE_CHECK([for struct stat64], tcl_cv_struct_stat64,[
2842             AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 p;
2843 ],
2844                 tcl_cv_struct_stat64=yes,tcl_cv_struct_stat64=no)])
2845         if test "x${tcl_cv_struct_stat64}" = "xyes" ; then
2846             AC_DEFINE(HAVE_STRUCT_STAT64)
2847         fi
2848
2849         AC_CHECK_FUNCS(open64 lseek64)
2850         AC_MSG_CHECKING([for off64_t])
2851         AC_CACHE_VAL(tcl_cv_type_off64_t,[
2852             AC_TRY_COMPILE([#include <sys/types.h>],[off64_t offset;
2853 ],
2854                 tcl_cv_type_off64_t=yes,tcl_cv_type_off64_t=no)])
2855         dnl Define HAVE_TYPE_OFF64_T only when the off64_t type and the
2856         dnl functions lseek64 and open64 are defined.
2857         if test "x${tcl_cv_type_off64_t}" = "xyes" && \
2858                 test "x${ac_cv_func_lseek64}" = "xyes" && \
2859                 test "x${ac_cv_func_open64}" = "xyes" ; then
2860             AC_DEFINE(HAVE_TYPE_OFF64_T)
2861             AC_MSG_RESULT([yes])
2862         else
2863             AC_MSG_RESULT([no])
2864         fi
2865     fi
2866 ])
2867
2868 #--------------------------------------------------------------------
2869 # SC_TCL_GETHOSTBYADDR_R
2870 #
2871 #       Check if we have MT-safe variant of gethostbyaddr().
2872 #
2873 # Arguments:
2874 #       None
2875 #
2876 # Results:
2877 #
2878 #       Might define the following vars:
2879 #               HAVE_GETHOSTBYADDR_R
2880 #               HAVE_GETHOSTBYADDR_R_7
2881 #               HAVE_GETHOSTBYADDR_R_8
2882 #
2883 #--------------------------------------------------------------------
2884
2885 AC_DEFUN([SC_TCL_GETHOSTBYADDR_R], [AC_CHECK_FUNC(gethostbyaddr_r, [
2886     AC_CACHE_CHECK([for gethostbyaddr_r with 7 args], tcl_cv_api_gethostbyaddr_r_7, [
2887     AC_TRY_COMPILE([
2888         #include <netdb.h>
2889     ], [
2890         char *addr;
2891         int length;
2892         int type;
2893         struct hostent *result;
2894         char buffer[2048];
2895         int buflen = 2048;
2896         int h_errnop;
2897
2898         (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
2899                                &h_errnop);
2900     ], tcl_cv_api_gethostbyaddr_r_7=yes, tcl_cv_api_gethostbyaddr_r_7=no)])
2901     tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
2902     if test "$tcl_ok" = yes; then
2903         AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
2904     else
2905         AC_CACHE_CHECK([for gethostbyaddr_r with 8 args], tcl_cv_api_gethostbyaddr_r_8, [
2906         AC_TRY_COMPILE([
2907             #include <netdb.h>
2908         ], [
2909             char *addr;
2910             int length;
2911             int type;
2912             struct hostent *result, *resultp;
2913             char buffer[2048];
2914             int buflen = 2048;
2915             int h_errnop;
2916
2917             (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
2918                                    &resultp, &h_errnop);
2919         ], tcl_cv_api_gethostbyaddr_r_8=yes, tcl_cv_api_gethostbyaddr_r_8=no)])
2920         tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
2921         if test "$tcl_ok" = yes; then
2922             AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
2923         fi
2924     fi
2925     if test "$tcl_ok" = yes; then
2926         AC_DEFINE(HAVE_GETHOSTBYADDR_R)
2927     fi
2928 ])])
2929
2930 #--------------------------------------------------------------------
2931 # SC_TCL_GETHOSTBYNAME_R
2932 #
2933 #       Check to see what variant of gethostbyname_r() we have.
2934 #       Based on David Arnold's example from the comp.programming.threads
2935 #       FAQ Q213
2936 #
2937 # Arguments:
2938 #       None
2939 #
2940 # Results:
2941 #
2942 #       Might define the following vars:
2943 #               HAVE_GETHOSTBYADDR_R
2944 #               HAVE_GETHOSTBYADDR_R_3
2945 #               HAVE_GETHOSTBYADDR_R_5
2946 #               HAVE_GETHOSTBYADDR_R_6
2947 #
2948 #--------------------------------------------------------------------
2949
2950 AC_DEFUN([SC_TCL_GETHOSTBYNAME_R], [AC_CHECK_FUNC(gethostbyname_r, [
2951     AC_CACHE_CHECK([for gethostbyname_r with 6 args], tcl_cv_api_gethostbyname_r_6, [
2952     AC_TRY_COMPILE([
2953         #include <netdb.h>
2954     ], [
2955         char *name;
2956         struct hostent *he, *res;
2957         char buffer[2048];
2958         int buflen = 2048;
2959         int h_errnop;
2960
2961         (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop);
2962     ], tcl_cv_api_gethostbyname_r_6=yes, tcl_cv_api_gethostbyname_r_6=no)])
2963     tcl_ok=$tcl_cv_api_gethostbyname_r_6
2964     if test "$tcl_ok" = yes; then
2965         AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
2966     else
2967         AC_CACHE_CHECK([for gethostbyname_r with 5 args], tcl_cv_api_gethostbyname_r_5, [
2968         AC_TRY_COMPILE([
2969             #include <netdb.h>
2970         ], [
2971             char *name;
2972             struct hostent *he;
2973             char buffer[2048];
2974             int buflen = 2048;
2975             int h_errnop;
2976
2977             (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop);
2978         ], tcl_cv_api_gethostbyname_r_5=yes, tcl_cv_api_gethostbyname_r_5=no)])
2979         tcl_ok=$tcl_cv_api_gethostbyname_r_5
2980         if test "$tcl_ok" = yes; then
2981             AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
2982         else
2983             AC_CACHE_CHECK([for gethostbyname_r with 3 args], tcl_cv_api_gethostbyname_r_3, [
2984             AC_TRY_COMPILE([
2985                 #include <netdb.h>
2986             ], [
2987                 char *name;
2988                 struct hostent *he;
2989                 struct hostent_data data;
2990
2991                 (void) gethostbyname_r(name, he, &data);
2992             ], tcl_cv_api_gethostbyname_r_3=yes, tcl_cv_api_gethostbyname_r_3=no)])
2993             tcl_ok=$tcl_cv_api_gethostbyname_r_3
2994             if test "$tcl_ok" = yes; then
2995                 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
2996             fi
2997         fi
2998     fi
2999     if test "$tcl_ok" = yes; then
3000         AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3001     fi
3002 ])])
3003
3004 #--------------------------------------------------------------------
3005 # SC_TCL_GETPWUID_R
3006 #
3007 #       Check if we have MT-safe variant of getpwuid() and if yes,
3008 #       which one exactly.
3009 #
3010 # Arguments:
3011 #       None
3012 #
3013 # Results:
3014 #
3015 #       Might define the following vars:
3016 #               HAVE_GETPWUID_R
3017 #               HAVE_GETPWUID_R_4
3018 #               HAVE_GETPWUID_R_5
3019 #
3020 #--------------------------------------------------------------------
3021
3022 AC_DEFUN([SC_TCL_GETPWUID_R], [AC_CHECK_FUNC(getpwuid_r, [
3023     AC_CACHE_CHECK([for getpwuid_r with 5 args], tcl_cv_api_getpwuid_r_5, [
3024     AC_TRY_COMPILE([
3025         #include <sys/types.h>
3026         #include <pwd.h>
3027     ], [
3028         uid_t uid;
3029         struct passwd pw, *pwp;
3030         char buf[512];
3031         int buflen = 512;
3032
3033         (void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
3034     ], tcl_cv_api_getpwuid_r_5=yes, tcl_cv_api_getpwuid_r_5=no)])
3035     tcl_ok=$tcl_cv_api_getpwuid_r_5
3036     if test "$tcl_ok" = yes; then
3037         AC_DEFINE(HAVE_GETPWUID_R_5)
3038     else
3039         AC_CACHE_CHECK([for getpwuid_r with 4 args], tcl_cv_api_getpwuid_r_4, [
3040         AC_TRY_COMPILE([
3041             #include <sys/types.h>
3042             #include <pwd.h>
3043         ], [
3044             uid_t uid;
3045             struct passwd pw;
3046             char buf[512];
3047             int buflen = 512;
3048
3049             (void)getpwnam_r(uid, &pw, buf, buflen);
3050         ], tcl_cv_api_getpwuid_r_4=yes, tcl_cv_api_getpwuid_r_4=no)])
3051         tcl_ok=$tcl_cv_api_getpwuid_r_4
3052         if test "$tcl_ok" = yes; then
3053             AC_DEFINE(HAVE_GETPWUID_R_4)
3054         fi
3055     fi
3056     if test "$tcl_ok" = yes; then
3057         AC_DEFINE(HAVE_GETPWUID_R)
3058     fi
3059 ])])
3060
3061 #--------------------------------------------------------------------
3062 # SC_TCL_GETPWNAM_R
3063 #
3064 #       Check if we have MT-safe variant of getpwnam() and if yes,
3065 #       which one exactly.
3066 #
3067 # Arguments:
3068 #       None
3069 #
3070 # Results:
3071 #
3072 #       Might define the following vars:
3073 #               HAVE_GETPWNAM_R
3074 #               HAVE_GETPWNAM_R_4
3075 #               HAVE_GETPWNAM_R_5
3076 #
3077 #--------------------------------------------------------------------
3078
3079 AC_DEFUN([SC_TCL_GETPWNAM_R], [AC_CHECK_FUNC(getpwnam_r, [
3080     AC_CACHE_CHECK([for getpwnam_r with 5 args], tcl_cv_api_getpwnam_r_5, [
3081     AC_TRY_COMPILE([
3082         #include <sys/types.h>
3083         #include <pwd.h>
3084     ], [
3085         char *name;
3086         struct passwd pw, *pwp;
3087         char buf[512];
3088         int buflen = 512;
3089
3090         (void) getpwnam_r(name, &pw, buf, buflen, &pwp);
3091     ], tcl_cv_api_getpwnam_r_5=yes, tcl_cv_api_getpwnam_r_5=no)])
3092     tcl_ok=$tcl_cv_api_getpwnam_r_5
3093     if test "$tcl_ok" = yes; then
3094         AC_DEFINE(HAVE_GETPWNAM_R_5)
3095     else
3096         AC_CACHE_CHECK([for getpwnam_r with 4 args], tcl_cv_api_getpwnam_r_4, [
3097         AC_TRY_COMPILE([
3098             #include <sys/types.h>
3099             #include <pwd.h>
3100         ], [
3101             char *name;
3102             struct passwd pw;
3103             char buf[512];
3104             int buflen = 512;
3105
3106             (void)getpwnam_r(name, &pw, buf, buflen);
3107         ], tcl_cv_api_getpwnam_r_4=yes, tcl_cv_api_getpwnam_r_4=no)])
3108         tcl_ok=$tcl_cv_api_getpwnam_r_4
3109         if test "$tcl_ok" = yes; then
3110             AC_DEFINE(HAVE_GETPWNAM_R_4)
3111         fi
3112     fi
3113     if test "$tcl_ok" = yes; then
3114         AC_DEFINE(HAVE_GETPWNAM_R)
3115     fi
3116 ])])
3117
3118 #--------------------------------------------------------------------
3119 # SC_TCL_GETGRGID_R
3120 #
3121 #       Check if we have MT-safe variant of getgrgid() and if yes,
3122 #       which one exactly.
3123 #
3124 # Arguments:
3125 #       None
3126 #
3127 # Results:
3128 #
3129 #       Might define the following vars:
3130 #               HAVE_GETGRGID_R
3131 #               HAVE_GETGRGID_R_4
3132 #               HAVE_GETGRGID_R_5
3133 #
3134 #--------------------------------------------------------------------
3135
3136 AC_DEFUN([SC_TCL_GETGRGID_R], [AC_CHECK_FUNC(getgrgid_r, [
3137     AC_CACHE_CHECK([for getgrgid_r with 5 args], tcl_cv_api_getgrgid_r_5, [
3138     AC_TRY_COMPILE([
3139         #include <sys/types.h>
3140         #include <grp.h>
3141     ], [
3142         gid_t gid;
3143         struct group gr, *grp;
3144         char buf[512];
3145         int buflen = 512;
3146
3147         (void) getgrgid_r(gid, &gr, buf, buflen, &grp);
3148     ], tcl_cv_api_getgrgid_r_5=yes, tcl_cv_api_getgrgid_r_5=no)])
3149     tcl_ok=$tcl_cv_api_getgrgid_r_5
3150     if test "$tcl_ok" = yes; then
3151         AC_DEFINE(HAVE_GETGRGID_R_5)
3152     else
3153         AC_CACHE_CHECK([for getgrgid_r with 4 args], tcl_cv_api_getgrgid_r_4, [
3154         AC_TRY_COMPILE([
3155             #include <sys/types.h>
3156             #include <grp.h>
3157         ], [
3158             gid_t gid;
3159             struct group gr;
3160             char buf[512];
3161             int buflen = 512;
3162
3163             (void)getgrgid_r(gid, &gr, buf, buflen);
3164         ], tcl_cv_api_getgrgid_r_4=yes, tcl_cv_api_getgrgid_r_4=no)])
3165         tcl_ok=$tcl_cv_api_getgrgid_r_4
3166         if test "$tcl_ok" = yes; then
3167             AC_DEFINE(HAVE_GETGRGID_R_4)
3168         fi
3169     fi
3170     if test "$tcl_ok" = yes; then
3171         AC_DEFINE(HAVE_GETGRGID_R)
3172     fi
3173 ])])
3174
3175 #--------------------------------------------------------------------
3176 # SC_TCL_GETGRNAM_R
3177 #
3178 #       Check if we have MT-safe variant of getgrnam() and if yes,
3179 #       which one exactly.
3180 #
3181 # Arguments:
3182 #       None
3183 #
3184 # Results:
3185 #
3186 #       Might define the following vars:
3187 #               HAVE_GETGRNAM_R
3188 #               HAVE_GETGRNAM_R_4
3189 #               HAVE_GETGRNAM_R_5
3190 #
3191 #--------------------------------------------------------------------
3192
3193 AC_DEFUN([SC_TCL_GETGRNAM_R], [AC_CHECK_FUNC(getgrnam_r, [
3194     AC_CACHE_CHECK([for getgrnam_r with 5 args], tcl_cv_api_getgrnam_r_5, [
3195     AC_TRY_COMPILE([
3196         #include <sys/types.h>
3197         #include <grp.h>
3198     ], [
3199         char *name;
3200         struct group gr, *grp;
3201         char buf[512];
3202         int buflen = 512;
3203
3204         (void) getgrnam_r(name, &gr, buf, buflen, &grp);
3205     ], tcl_cv_api_getgrnam_r_5=yes, tcl_cv_api_getgrnam_r_5=no)])
3206     tcl_ok=$tcl_cv_api_getgrnam_r_5
3207     if test "$tcl_ok" = yes; then
3208         AC_DEFINE(HAVE_GETGRNAM_R_5)
3209     else
3210         AC_CACHE_CHECK([for getgrnam_r with 4 args], tcl_cv_api_getgrnam_r_4, [
3211         AC_TRY_COMPILE([
3212             #include <sys/types.h>
3213             #include <grp.h>
3214         ], [
3215             char *name;
3216             struct group gr;
3217             char buf[512];
3218             int buflen = 512;
3219
3220             (void)getgrnam_r(name, &gr, buf, buflen);
3221         ], tcl_cv_api_getgrnam_r_4=yes, tcl_cv_api_getgrnam_r_4=no)])
3222         tcl_ok=$tcl_cv_api_getgrnam_r_4
3223         if test "$tcl_ok" = yes; then
3224             AC_DEFINE(HAVE_GETGRNAM_R_4)
3225         fi
3226     fi
3227     if test "$tcl_ok" = yes; then
3228         AC_DEFINE(HAVE_GETGRNAM_R)
3229     fi
3230 ])])
3231
3232 #--------------------------------------------------------------------
3233 # SC_CONFIG_COMMANDS_PRE(CMDS)
3234 #
3235 #       Replacement for autoconf 2.5x AC_COMMANDS_PRE:
3236 #               Commands to run right before config.status is
3237 #               created. Accumulates.
3238 #
3239 #       Requires presence of SC_OUTPUT_COMMANDS_PRE at the end
3240 #       of configure.in (right before AC_OUTPUT).
3241 #
3242 #--------------------------------------------------------------------
3243
3244 AC_DEFUN([SC_CONFIG_COMMANDS_PRE], [
3245     define([SC_OUTPUT_COMMANDS_PRE], defn([SC_OUTPUT_COMMANDS_PRE])[$1
3246 ])])
3247 AC_DEFUN([SC_OUTPUT_COMMANDS_PRE])
3248