Blame | Last modification | View Log | Download | RSS feed
#
# This file describes a "configure" script that is used to build
# makefiles for a particular platform. Process this file using
# Autoconf version 1.13 in order to generate that script. All
# lines of this file up to the AC_INIT macro are ignored.
#
# The build process allows for using a cross-compiler. But the default
# action is to target the same platform that we are running on. The
# configure script needs to discover the following properties of the
# build and target systems:
#
# srcdir
#
# The is the name of the directory that contains the
# "configure" shell script. All source files are
# located relative to this directory.
#
# BUILD_CC
#
# The name of a command that is used to convert C
# source files into executables that run on the build
# platform.
#
# BUILD_CFLAGS
#
# Switches that the build compiler needs in order to construct
# command-line programs.
#
# BUILD_LIBS
#
# Libraries that the build compiler needs in order to construct
# command-line programs.
#
# BUILD_EXEEXT
#
# The filename extension for executables on the build
# platform. "" for Unix and ".exe" for Windows.
#
# BUILD_TCLSH
#
# The name of a tclsh executable on the build platform.
#
# TARGET_CC
#
# The name of a command that runs on the build platform
# and converts C source files into *.o files for the
# target platform. In other words, the cross-compiler.
#
# TARGET_CFLAGS
#
# Switches that the target compiler needs to turn C source files
# into *.o files. Do not include TARGET_TCL_INC, TARGET_X_INC
# or TARGET_TK_INC in this list. Makefiles might add
# additional switches such as "-I.".
#
# TARGET_TCL_INC
# TARGET_X_INC
# TARGET_TK_INC
# TARGET_BLT_INC
#
# These variables define the directories that contain header
# files for Tcl, X11, Tk, and BLT respectively. If the compiler
# is able to find <tcl.h>, <X11/Xlib.h>, <tk.h> and <blt.h>
# on its own, then these can be blank.
#
# TARGET_LINK
#
# The name of the linker that combines *.o files generated
# by TARGET_CC into executables for the target platform.
#
# TARGET_TCL_LIBS
# TARGET_X_LIBS
# TARGET_TK_LIBS
# TARGET_BLT_LIBS
#
# These are the library directives passed to the target linker
# that cause the executable to link against Tcl, X11, Tk, and
# BLT respectively. They might be switches like "-ltcl8.0" or
# pathnames of library files like "../../src/libtcl8.0.a".
#
# TARGET_LIBS
#
# Additional libraries or other switch that the target linker needs
# to build an executable on the target. Do not include
# on this list any libraries in TARGET_TCL_LIBS, TARGET_X_LIBS,
# TARGET_TK_LIBS, or TARGET_BLT_LIBS.
#
# TARGET_EXEEXT
#
# The filename extension for executables on the
# target platform. "" for Unix and ".exe" for windows.
#
# TARGET_TCL_SCRIPT_DIR
#
# A directory on the build platform that contains the
# Tcl script libraries that are compatible with the
# Tcl C libraries of the target platform.
#
# TARGET_TK_SCRIPT_DIR
#
# A directory on the build platform that contains the
# Tk script libraries that are compatible with the
# Tk C libraries of the target platform.
#
# The generated configure script will make an attempt to guess
# at all of the above parameters. You can override any of
# the guesses by setting the environment variable named
# "config_AAAA" where "AAAA" is the name of the parameter
# described above. (Exception: srcdir cannot be set this way.)
# If you have a file that sets one or more of these environment
# variables, you can invoke configure as follows:
#
# configure --with-hints=FILE
#
# where FILE is the name of the file that sets the environment
# variables. FILE should be an absolute pathname.
#
# If you have a Tcl/Tk/BLT source distribution available, then the
# files in that distribution will be used instead of any other
# Tcl/Tk/BLT files the script might discover if you tell the configure
# script about the source tree. Use commandline options:
#
# --with-tcl=PATH --with-tk=PATH --with-blt=PATH
#
# Or set environment variables config_WITH_TCL, config_WITH_TK, or
# config_WITH_BLT.
#
# This configure.in file is easy to reuse on other projects. Just
# change the argument to AC_INIT(). And disable any features that
# you don't need (for example BLT) by erasing or commenting out
# the corresponding code.
#
AC_INIT(src/psdgui.c)
#########
# Check to see if the --with-hints=FILE option is used.
#
AC_ARG_WITH(hints,
[ --with-hints=FILE Read configuration options from FILE],
. $withval)
#########
# Locate a compiler for the build machine. This compiler should
# generate command-line programs that run on the build machine.
#
default_build_cflags="-g"
if test "$config_BUILD_CC" = ""; then
AC_PROG_CC
if test "$cross_compiling" = "yes"; then
AC_MSG_ERROR([unable to find a compiler for building build tools])
fi
BUILD_CC=$CC
default_build_cflags=$CFLAGS
else
BUILD_CC=$config_BUILD_CC
AC_MSG_CHECKING([host compiler])
CC=$BUILD_CC
AC_MSG_RESULT($BUILD_CC)
fi
AC_MSG_CHECKING([switches for the host compiler])
if test "$config_BUILD_CFLAGS" != ""; then
CFLAGS=$config_BUILD_CFLAGS
BUILD_CFLAGS=$config_BUILD_CFLAGS
else
BUILD_CFLAGS=$default_build_cflags
fi
AC_MSG_RESULT($BUILD_CFLAGS)
if test "$config_BUILD_LIBS" != ""; then
BUILD_LIBS=$config_BUILD_LIBS
fi
AC_SUBST(BUILD_CC)
AC_SUBST(BUILD_CFLAGS)
AC_SUBST(BUILD_LIBS)
##########
# Locate a compiler that converts C code into *.o files that run on
# the target machine.
#
AC_MSG_CHECKING([target compiler])
if test "$config_TARGET_CC" != ""; then
TARGET_CC=$config_TARGET_CC
else
TARGET_CC=$BUILD_CC
fi
AC_MSG_RESULT($TARGET_CC)
AC_MSG_CHECKING([switches on the target compiler])
if test "$config_TARGET_CFLAGS" != ""; then
TARGET_CFLAGS=$config_TARGET_CFLAGS
else
TARGET_CFLAGS=$BUILD_CFLAGS
fi
AC_MSG_RESULT($TARGET_CFLAGS)
AC_MSG_CHECKING([target linker])
if test "$config_TARGET_LINK" = ""; then
TARGET_LINK=$TARGET_CC
else
TARGET_LINK=$config_TARGET_LINK
fi
AC_MSG_RESULT($TARGET_LINK)
AC_MSG_CHECKING([switches on the target compiler])
if test "$config_TARGET_TFLAGS" != ""; then
TARGET_TFLAGS=$config_TARGET_TFLAGS
else
TARGET_TFLAGS=$BUILD_CFLAGS
fi
AC_MSG_RESULT($TARGET_TFLAGS)
AC_SUBST(TARGET_CC)
AC_SUBST(TARGET_CFLAGS)
AC_SUBST(TARGET_LINK)
AC_SUBST(TARGET_LFLAGS)
# Set the $cross variable if we are cross-compiling. Make
# it 0 if we are not.
#
AC_MSG_CHECKING([if host and target compilers are the same])
if test "$BUILD_CC" = "$TARGET_CC"; then
cross=0
AC_MSG_RESULT(yes)
else
cross=1
AC_MSG_RESULT(no)
fi
###########
# Lots of things are different if we are compiling for Windows using
# the CYGWIN environment. So check for that special case and handle
# things accordingly.
#
AC_MSG_CHECKING([if executables have the .exe suffix])
if test "$config_BUILD_EXEEXT" = ".exe"; then
CYGWIN=yes
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(unknown)
fi
if test "$CYGWIN" != "yes"; then
AC_CYGWIN
fi
if test "$CYGWIN" = "yes"; then
BUILD_EXEEXT=.exe
else
BUILD_EXEEXT=""
fi
if test "$cross" = "0"; then
TARGET_EXEEXT=$BUILD_EXEEXT
else
TARGET_EXEEXT=$config_TARGET_EXEEXT
fi
if test "$TARGET_EXEEXT" = ".exe"; then
ACD_UNIX=0
ACD_WIN=1
tclsubdir=win
else
ACD_UNIX=1
ACD_WIN=0
tclsubdir=unix
fi
TARGET_CFLAGS="$TARGET_CFLAGS -DACD_UNIX=$ACD_UNIX -DACD_WIN=$ACD_WIN"
AC_SUBST(BUILD_EXEEXT)
AC_SUBST(ACD_UNIX)
AC_SUBST(ACD_WIN)
AC_SUBST(TARGET_EXEEXT)
#########
# Locate a working copy of tclsh. We have to have this program
# running on the build platform since the makefiles use it.
#
AC_ARG_WITH(tcl,
[ --with-tcl=DIR Directory holding Tcl source tree for target])
if test "$config_WITH_TCL" != ""; then
with_tcl=$config_WITH_TCL
fi
if test "$config_BUILD_TCLSH" != ""; then
AC_MSG_CHECKING([for a working "tclsh"])
BUILD_TCLSH=$config_BUILD_TCLSH
AC_MSG_RESULT($BUILD_TCLSH)
else
if test "$with_tcl" != ""; then
if test -x "$with_tcl/$tclsubdir/tclsh"; then
BUILD_TCLSH=$with_tcl/$tclsubdir/tclsh
else
if test -x "$with_tcl/$tclsubdir/tclsh8.0"; then
BUILD_TCLSH=$with_tcl/$tclsubdir/tclsh8.0
fi
fi
fi
if test "$BUILD_TCLSH" = ""; then
AC_CHECK_PROGS(BUILD_TCLSH, tclsh8.0 tclsh80 cygtclsh80 tclsh, "")
fi
if test "$BUILD_TCLSH" = ""; then
AC_MSG_ERROR([no working "tclsh" could be found])
fi
fi
AC_SUBST(BUILD_TCLSH)
#########
# Locate the directory that contains all of the Tcl initialization
# scripts for the target machine.
#
AC_MSG_CHECKING([Tcl script library])
if test "$config_TARGET_TCL_SCRIPT_DIR" != ""; then
TARGET_TCL_SCRIPT_DIR=$config_TARGET_TCL_SCRIPT_DIR
else
changequote(<<<,>>>)dnl
cat > conftest.tcl <<\EOF
regsub {^([A-Za-z]):/} [info library] {//\1/} out
puts -nonewline $out
exit
EOF
changequote([,])dnl
tcllibdir=`$BUILD_TCLSH <conftest.tcl`
rm -f conftest.tcl
if test ! -r $tcllibdir/init.tcl; then
AC_MSG_ERROR(not found)
fi
TARGET_TCL_SCRIPT_DIR=$tcllibdir
fi
AC_MSG_RESULT($TARGET_TCL_SCRIPT_DIR)
AC_SUBST(TARGET_TCL_SCRIPT_DIR)
#########
# Locate the directory that contains all of the Tk initialization
# scripts for the target machine.
#
AC_ARG_WITH(tk,
[ --with-tk=DIR Directory holding Tk source tree for target])
if test "$config_WITH_TK" != ""; then
with_tk=$config_WITH_TK
fi
AC_MSG_CHECKING([Tk script library])
if test "$config_TARGET_TK_SCRIPT_DIR" != ""; then
TARGET_TK_SCRIPT_DIR=$config_TARGET_TK_SCRIPT_DIR
else
if test "$with_tk" != ""; then
tklibdir=$with_tk/library
else
changequote(<<<,>>>)dnl
cat > conftest.tcl <<\EOF
regsub {^([A-Za-z]):/} [info library] {//\1/} out
regsub {/tcl7.6} $out {tk4.2} out
regsub {/tcl([^/]*)} $out {/tk\1} out
puts -nonewline $out
exit
EOF
changequote([,])dnl
tklibdir=`$BUILD_TCLSH <conftest.tcl`
rm -f conftest.tcl
fi
if test ! -r $tklibdir/tk.tcl; then
AC_MSG_ERROR(not found)
fi
TARGET_TK_SCRIPT_DIR=$tklibdir
fi
AC_MSG_RESULT($TARGET_TK_SCRIPT_DIR)
AC_SUBST(TARGET_TK_SCRIPT_DIR)
##########
# Extract generic linker options from the environment.
#
if test "$config_TARGET_LIBS" != ""; then
TARGET_LIBS=$config_TARGET_LIBS
else
TARGET_LIBS=""
fi
AC_SUBST(TARGET_LIBS)
##########
# Figure out what C libraries are required to compile Tcl programs.
#
if test "$config_TARGET_TCL_LIBS" != ""; then
TARGET_TCL_LIBS="$config_TARGET_TCL_LIBS"
else
if test "$with_tcl" != ""; then
extra=`echo $with_tcl/$tclsubdir/libtcl*.a`
fi
CC=$TARGET_CC
AC_CHECK_FUNC(sin, LIBS="", LIBS="-lm")
AC_CHECK_LIB(dl, dlopen)
otherlibs=$LIBS
if test "$extra" != ""; then
LIBS=$extra
else
LIBS=""
AC_SEARCH_LIBS(Tcl_Init, tcl8.0 tcl80 tcl,,,$otherlibs)
fi
TARGET_TCL_LIBS="$LIBS $otherlibs"
fi
AC_SUBST(TARGET_TCL_LIBS)
##########
# Figure out where to get the TCL header files.
#
AC_MSG_CHECKING([TCL header files])
if test "$config_TARGET_TCL_INC" != ""; then
TARGET_TCL_INC=$config_TARGET_TCL_INC
else
if test "$with_tcl" != ""; then
TARGET_TCL_INC="-I$with_tcl/generic -I$with_tcl/$tclsubdir"
else
TARGET_TCL_INC=""
fi
fi
AC_MSG_RESULT($TARGET_TCLINC)
AC_SUBST(TARGET_TCL_INC)
###########
# Figure out what C libraries are required to compile X11 programs.
# If the target is windows, we assume the compiler is Cygwin20 and
# insert arguments that generate a windows GUI application.
#
if test "$config_TARGET_X_LIBS" != ""; then
TARGET_X_LIBS=$config_TARGET_X_LIBS
TARGET_X_INC=$config_TARGET_X_INC
else
if test $ACD_UNIX = 1; then
AC_PATH_XTRA
if test "$X_CFLAGS" = "-DX_DISPLAY_MISSING"; then
TARGET_X_LIBS=""
TARGET_X_INC=""
else
xlibs="$X_LIBS $X_PRE_LIB -lX11 $X_EXTRA_LIBS"
TARGET_X_LIBS=`echo $xlibs | sed -e 's/^ *//' -e 's/ //'g -e 's/ *$//'`
if test "$x_includes" != ""; then
TARGET_X_INC=`echo $x_includes | sed -e 's/^/-I/' -e 's/ */ -I/'`
fi
fi
else
TARGET_X_LIBS="-mwindows -e _mainCRTStartup"
TARGET_X_INC=""
fi
fi
AC_SUBST(TARGET_X_LIBS)
AC_SUBST(TARGET_X_INC)
##########
# Figure out what libraries are required to compile Tk programs.
#
if test "$config_TARGET_TK_LIBS" != ""; then
TARGET_TK_LIBS="$config_TARGET_TK_LIBS"
else
if test "$with_tk" != ""; then
extra=`echo $with_tk/$tclsubdir/libtk*.a`
else
CC=$TARGET_CC
otherlibs="$TARGET_X_LIBS $TARGET_TCL_LIBS"
LIBS=""
AC_SEARCH_LIBS(Tk_Init, tk8.0 tk80 tk,,,$otherlibs)
TARGET_TK_LIBS=$LIBS
fi
fi
AC_SUBST(TARGET_TK_LIBS)
###########
# Figure out where to get the TK header files.
#
AC_MSG_CHECKING([TK header files])
if test "$config_TARGET_TK_INC" != ""; then
TARGET_TK_INC=$config_TARGET_TK_INC
else
if test "$with_tk" != ""; then
TARGET_TK_INC="-I$with_tk/generic -I$with_tk/$tclsubdir"
if test "$tclsubdir" = "win"; then
TARGET_TK_INC="$TARGET_TK_INC -I$with_tk/xlib"
fi
else
TARGET_TK_INC=""
fi
fi
AC_MSG_RESULT($TARGET_TK_INC)
AC_SUBST(TARGET_TK_INC)
############
# Figure out where to look for BLT header files <blt.h>.
#
AC_ARG_WITH(blt,
[ --with-blt=DIR Directory holding BLT source tree for target])
if test "$config_WITH_BLT" != ""; then
with_tk=$config_WITH_BLT
fi
AC_MSG_CHECKING([BLT header files])
if test "$config_TARGET_BLT_INC" != ""; then
TARGET_BLT_INC=$config_TARGET_BLT_INC
else
if test "$with_BLT" != ""; then
TARGET_BLT_INC="-I$with_blt/src"
else
TARGET_BLT_INC=""
fi
fi
AC_MSG_RESULT($TARGET_BLT_INC)
AC_SUBST(TARGET_BLT_INC)
##########
# Figure out what libraries are required to compile BLT programs.
#
if test "$config_TARGET_BLT_LIBS" != ""; then
TARGET_BLT_LIBS="$config_TARGET_BLT_LIBS"
else
if test "$with_blt" != ""; then
TARGET_BLT_LIBS=`echo $with_blt/src/libBLT*.a`
else
CC=$TARGET_CC
otherlibs="$TARGET_TK_LIBS $TARGET_X_LIBS $TARGET_TCL_LIBS"
LIBS=""
AC_SEARCH_LIBS(Blt_Init, BLT BLT2.4 BLT24,,,$otherlibs)
TARGET_BLT_LIBS=$LIBS
fi
fi
AC_SUBST(TARGET_BLT_LIBS)
###########
# Generate the Makefile.
#
exec 7>./Makefile
echo "\
# Top-level makefile. This generates a second-tier makefile
# and invokes it. See comments in the \"makemake.tcl.in\" or
# \"makemake.tcl\" files for additional information.
#
TCLSH = $BUILD_TCLSH
" 1>&7
cat 1>&7 <<\EOF
all: all.mk
$(MAKE) -f all.mk all
all.mk: makemake.tcl
$(TCLSH) makemake.tcl >all.mk
debug: all.mk
$(MAKE) -f all.mk debug
doc: all.mk
$(MAKE) -f all.mk doc
install: all.mk
$(MAKE) -f all.mk install
clean: all.mk
$(MAKE) -f all.mk clean
distclean: all.mk
$(MAKE) -f all.mk distclean
rm -f all.mk Makefile makemake.tcl config.*
EOF
#########
# Generate the output files.
#
AC_OUTPUT(makemake.tcl)