# # 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 , , and # 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 >>)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 . # 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)