Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/tcl8.5.2/unix/tcl.m4 @ 25

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: