source: trunk/libs/newlib/src/config/tcl.m4 @ 478

Last change on this file since 478 was 444, checked in by satin@…, 6 years ago

add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc

File size: 96.9 KB
Line 
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
20AC_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
143AC_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
266AC_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 arbitrary 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
349AC_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 arbitrary 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
435AC_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
480AC_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
508AC_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
548AC_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
603AC_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
715AC_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
772AC_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 appropriate flags for installManPage
819#                       according to the user's selection.
820#
821#--------------------------------------------------------------------
822
823AC_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
886AC_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
1004AC_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=""
1058dnl FIXME: Replace AC_CHECK_PROG with AC_CHECK_TOOL once cross compiling is fixed.
1059dnl 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
1983dnl # Add any CPPFLAGS set in the environment to our CFLAGS, but delay doing so
1984dnl # until the end of configure, as configure's compile and link tests use
1985dnl # both CPPFLAGS and CFLAGS (unlike our compile and link) but configure's
1986dnl # 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
2139dnl        Not at all clear what this was doing in Tcl's configure.ac
2140dnl        or why it was needed was needed. In any event, this sort of
2141dnl        things needs to be done in the big loop above.
2142dnl        REMOVE THIS BLOCK LATER! (mdejong)
2143dnl        case $system in
2144dnl            BSD/OS*)
2145dnl                ;;
2146dnl            AIX-[[1-4]].*)
2147dnl                ;;
2148dnl            *)
2149dnl                SHLIB_LD_LIBS=""
2150dnl                ;;
2151dnl        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
2218AC_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
2224int 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
2237int 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
2250int 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
2265int 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
2281int 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
2296int 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
2345AC_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
2359DIR *d;
2360struct dirent *entryPtr;
2361char *p;
2362d = opendir("foobar");
2363entryPtr = readdir(d);
2364p = entryPtr->d_name;
2365closedir(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
2423AC_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
2509AC_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
2557AC_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
2626AC_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
2685AC_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
2762AC_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
2775AC_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
2810AC_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
2883AC_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
2948AC_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
3020AC_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
3077AC_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
3134AC_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
3191AC_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.ac (right before AC_OUTPUT).
3239#
3240#--------------------------------------------------------------------
3241
3242AC_DEFUN([SC_CONFIG_COMMANDS_PRE], [
3243    define([SC_OUTPUT_COMMANDS_PRE], defn([SC_OUTPUT_COMMANDS_PRE])[$1
3244])])
3245AC_DEFUN([SC_OUTPUT_COMMANDS_PRE])
3246
Note: See TracBrowser for help on using the repository browser.