Subversion Repositories Vertical

#

# 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)