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