Contents of /trunk/configure

#! /bin/sh

# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 2.13 
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.

# Defaults:
ac_help=
ac_default_prefix=/usr/local
# Any additions from configure.in:
ac_help="$ac_help

ASCEND specific options

Compiler options:
  --enable-gcc            allow use of gcc if avaiable"
ac_help="$ac_help
  --enable-optimization   optimize the C code while building ascend"
ac_help="$ac_help
  --with-x                use the X Window System"
ac_help="$ac_help
Location of Tcl, Tk, and tkTable:
  --with-tcl=LIBRARY,HEADER
                          The location of the Tcl8.0 library and/or header
                          For a static Tcl8.0 library, give the full path:
                              --with-tcl='/usr/local/lib/libtcl8.0.a'
                          For a dynamic library, give any -L options required:
                              --with-tcl='-L/usr/local/lib -ltcl8.0'
                          To specify only the header, leave off the library:
                              --with-tcl=',/usr/local/include/tcl.h' "
ac_help="$ac_help
  --with-tk=LIBRARY,HEADER
                          The location of the Tk8.0 library and/or header
                          For a static Tk8.0 library, give the full path:
                              --with-tk='/usr/local/lib/libtk8.0.a'
                          For a dynamic library, give any -L options required:
                              --with-tk='-L/usr/local/lib -ltk8.0'
                          To specify only the header, leave off the library:
                              --with-tk=',/usr/local/include/tk.h' "
ac_help="$ac_help
  --with-tktable=TKTABLE  full path to a TkTable1.3 static library"
ac_help="$ac_help
  --with-wish=/path/to/bin/wish
                          The location of the wish shell executable matching 
                          the tcl/tk given by --with-tk and --with-tcl.
                          X11 must be running during configure.   "
ac_help="$ac_help
Fortran compiler and libraries:
  --with-fortran=F77,F77LIBS
                          The location of your Fortran compiler and its
                          library files.  For example, under SunOS:
                             --with-fortran='f77,-L/usr/lang/lib -lF77 -lM77'
                          To specify only the compiler or libraries, leave off
                          whatever is not needed:
                              --with-fortran=',-L/usr/lang/lib -lF77 -lM77'
                          Use '--without-fortran' to not link against
                          any Fortran libraries"
ac_help="$ac_help
  --with-blas=BLASLIB     The full path to the blas library.
                          Use '--with-blas=build' to build the blas library
                          from the sources that come with the distribution."
ac_help="$ac_help
  --with-linpack=LPAKLIB  The full path to the linpack library.
                          Use '--with-linpack=build' to build the library
                          from the sources that come with the distribution."
ac_help="$ac_help
  --with-lsod=LSODLIB     The full path to the lsod library.
                          Use '--with-lsod=build' to build the lsod library
                          from the sources that come with the distribution."
ac_help="$ac_help
  --with-conopt=CONOPTLIB The full path to the conopt library."
ac_help="$ac_help
Generation of Makefiles:
  --without-tkdir         do not generate Makefiles in the TK subdir"
ac_help="$ac_help
  --without-models        do not generate Makefiles in the models subdir"

# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
cache_file=./config.cache
exec_prefix=NONE
host=NONE
no_create=
nonopt=NONE
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
target=NONE
verbose=
x_includes=NONE
x_libraries=NONE
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datadir='${prefix}/share'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
libdir='${exec_prefix}/lib'
includedir='${prefix}/include'
oldincludedir='/usr/include'
infodir='${prefix}/info'
mandir='${prefix}/man'

# Initialize some other variables.
subdirs=
MFLAGS= MAKEFLAGS=
SHELL=${CONFIG_SHELL-/bin/sh}
# Maximum number of lines to put in a shell here document.
ac_max_here_lines=12

ac_prev=
for ac_option
do

  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval "$ac_prev=\$ac_option"
    ac_prev=
    continue
  fi

  case "$ac_option" in
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  *) ac_optarg= ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case "$ac_option" in

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir="$ac_optarg" ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build="$ac_optarg" ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file="$ac_optarg" ;;

  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
  | --da=*)
    datadir="$ac_optarg" ;;

  -disable-* | --disable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    eval "enable_${ac_feature}=no" ;;

  -enable-* | --enable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "enable_${ac_feature}='$ac_optarg'" ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix="$ac_optarg" ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he)
    # Omit some internal or obsolete options to make the list less imposing.
    # This message is too long to be a string in the A/UX 3.1 sh.
    cat << EOF
Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
Configuration:
  --cache-file=FILE       cache test results in FILE
  --help                  print this message
  --no-create             do not create output files
  --quiet, --silent       do not print \`checking...' messages
  --version               print the version of autoconf that created configure
Directory and file names:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [same as prefix]
  --bindir=DIR            user executables in DIR [EPREFIX/bin]
  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
  --datadir=DIR           read-only architecture-independent data in DIR
                          [PREFIX/share]
  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
                          [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
  --includedir=DIR        C header files in DIR [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
  --infodir=DIR           info documentation in DIR [PREFIX/info]
  --mandir=DIR            man documentation in DIR [PREFIX/man]
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
  --program-prefix=PREFIX prepend PREFIX to installed program names
  --program-suffix=SUFFIX append SUFFIX to installed program names
  --program-transform-name=PROGRAM
                          run sed PROGRAM on installed program names
EOF
    cat << EOF
Host type:
  --build=BUILD           configure for building on BUILD [BUILD=HOST]
  --host=HOST             configure for HOST [guessed]
  --target=TARGET         configure for TARGET [TARGET=HOST]
Features and packages:
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --x-includes=DIR        X include files are in DIR
  --x-libraries=DIR       X library files are in DIR
EOF
    if test -n "$ac_help"; then
      echo "--enable and --with options recognized:$ac_help"
    fi
    exit 0 ;;

  -host | --host | --hos | --ho)
    ac_prev=host ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host="$ac_optarg" ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir="$ac_optarg" ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir="$ac_optarg" ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir="$ac_optarg" ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir="$ac_optarg" ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst \
  | --locals | --local | --loca | --loc | --lo)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
    localstatedir="$ac_optarg" ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir="$ac_optarg" ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir="$ac_optarg" ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix="$ac_optarg" ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix="$ac_optarg" ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix="$ac_optarg" ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name="$ac_optarg" ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir="$ac_optarg" ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir="$ac_optarg" ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site="$ac_optarg" ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir="$ac_optarg" ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir="$ac_optarg" ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target="$ac_optarg" ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers)
    echo "configure generated by autoconf version 2.13"
    exit 0 ;;

  -with-* | --with-*)
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "with_${ac_package}='$ac_optarg'" ;;

  -without-* | --without-*)
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    eval "with_${ac_package}=no" ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes="$ac_optarg" ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries="$ac_optarg" ;;

  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
    ;;

  *)
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
      echo "configure: warning: $ac_option: invalid host type" 1>&2
    fi
    if test "x$nonopt" != xNONE; then
      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
    fi
    nonopt="$ac_option"
    ;;

  esac
done

if test -n "$ac_prev"; then
  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
fi

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

# File descriptor usage:
# 0 standard input
# 1 file creation
# 2 errors and warnings
# 3 some systems may open it to /dev/tty
# 4 used on the Kubota Titan
# 6 checking for... messages and results
# 5 compiler messages saved in config.log
if test "$silent" = yes; then
  exec 6>/dev/null
else
  exec 6>&1
fi
exec 5>./config.log

echo "\
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
" 1>&5

# Strip out --no-create and --no-recursion so they do not pile up.
# Also quote any args containing shell metacharacters.
ac_configure_args=
for ac_arg
do
  case "$ac_arg" in
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c) ;;
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
  esac
done

# NLS nuisances.
# Only set these to C if already set.  These must not be set unconditionally
# because not all systems understand e.g. LANG=C (notably SCO).
# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
# Non-C LC_CTYPE values break the ctype check.
if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
ac_unique_file=ascend4/compiler/ascParse.y

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then its parent.
  ac_prog=$0
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
  srcdir=$ac_confdir
  if test ! -r $srcdir/$ac_unique_file; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r $srcdir/$ac_unique_file; then
  if test "$ac_srcdir_defaulted" = yes; then
    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
  else
    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
  fi
fi
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`

# Prefer explicitly selected file to automatically selected ones.
if test -z "$CONFIG_SITE"; then
  if test "x$prefix" != xNONE; then
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
  else
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
  fi
fi
for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    echo "loading site script $ac_site_file"
    . "$ac_site_file"
  fi
done


ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

ac_exeext=
ac_objext=o
if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='	'
  else
    ac_n=-n ac_c= ac_t=
  fi
else
  ac_n= ac_c='\c' ac_t=
fi


#--------------------------------------------------------------------
#  CVS Most Recent Revision Data
#	Put this data after AC_INIT since we want this information
#	to also appear in configure and autoconf, when creating
#	configure, strips all comments that appear in configure.in
#	before AC_INIT
#    $Revision: 1.37 $
#    $Date: 2003/11/23 19:36:39 $
#    $Author: ballan $
#    $Source: /afs/cs.cmu.edu/project/ascend/Repository/configure,v $
#--------------------------------------------------------------------


#--------------------------------------------------------------------
#	Where configure should look for files it needs.
#--------------------------------------------------------------------
ac_aux_dir=
for ac_dir in config $srcdir/config; do
  if test -f $ac_dir/install-sh; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install-sh -c"
    break
  elif test -f $ac_dir/install.sh; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install.sh -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  { echo "configure: error: can not find install-sh or install.sh in config $srcdir/config" 1>&2; exit 1; }
fi
ac_config_guess=$ac_aux_dir/config.guess
ac_config_sub=$ac_aux_dir/config.sub
ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.


#--------------------------------------------------------------------
#	Set the output variables prefix and exec_prefix that
#	determine where things will be installed.
#--------------------------------------------------------------------
if test "${prefix}" = "NONE"; then
    prefix=/usr/local
fi
if test "${exec_prefix}" = "NONE"; then
    exec_prefix=$prefix
fi


#--------------------------------------------------------------------
#	For the Fortran support libraries and the TCL/TK libraries
#	and header files, we unfortunately need the full path to
#	these files.  The problem with having the full path is that
#	if the user moves the source tree, things will break unless
#	the user re-runs configure.
#--------------------------------------------------------------------
ascpwd=`pwd`
fullpathsrcdir=`cd $srcdir ; pwd`


#--------------------------------------------------------------------
#	The asc_include variable is (directory) path to the ascend4
#	SOURCE directory relative to the immediate subdirectories of
#	the ascend4 OBJECT directory.
#	-- If we are building in the source directory ($srcdir is "."
#	   asc_include is simply "../."
#	-- If the user gives us a full path to the configure script,
#	   we just append "/ascend4" to that full path:
#	   "$scrdir/ascend4"
#	-- For any other value of $srcdir (like ../src/), we go up
#	   two directories (to get to the top of the OBJECT tree,
#	   insert the source directory, and then go back down one
#	   level to the ascend4 directory: "../../$srcdir/ascend4"
#--------------------------------------------------------------------
case "$srcdir" in
    .)
        asc_include="../$srcdir"
        ;;
    /*)
        asc_include="$srcdir/ascend4"
        ;;
    *)
        asc_include="../../$srcdir/ascend4"
        ;;
esac


#--------------------------------------------------------------------
#	Do basic checks to determine
#	* if we have `ranlib'
#	* if we can create symbolic links
#	* if `make' sets the MAKE macro
#	* a bsd-compatible `install' program
#	  If we use the install-sh script that comes with configure,
#	  prefix it with the current directory so it'll work in
#	  subdirectories.  Unfortunately, it won't work if the user
#	  moves the source tree.
#--------------------------------------------------------------------
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:686: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_RANLIB="ranlib"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
fi
fi
RANLIB="$ac_cv_prog_RANLIB"
if test -n "$RANLIB"; then
  echo "$ac_t""$RANLIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
echo "configure:714: checking whether ln -s works" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  rm -f conftestdata
if ln -s X conftestdata 2>/dev/null
then
  rm -f conftestdata
  ac_cv_prog_LN_S="ln -s"
else
  ac_cv_prog_LN_S=ln
fi
fi
LN_S="$ac_cv_prog_LN_S"
if test "$ac_cv_prog_LN_S" = "ln -s"; then
  echo "$ac_t""yes" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
echo "configure:735: checking whether ${MAKE-make} sets \${MAKE}" >&5
set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftestmake <<\EOF
all:
	@echo 'ac_maketemp="${MAKE}"'
EOF
# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
if test -n "$ac_maketemp"; then
  eval ac_cv_prog_make_${ac_make}_set=yes
else
  eval ac_cv_prog_make_${ac_make}_set=no
fi
rm -f conftestmake
fi
if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  SET_MAKE=
else
  echo "$ac_t""no" 1>&6
  SET_MAKE="MAKE=${MAKE-make}"
fi

# Find a good install program.  We prefer a C program (faster),
# so one script is as good as another.  But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# ./install, which can be erroneously created by make from ./install.sh.
echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
echo "configure:773: checking for a BSD compatible install" >&5
if test -z "$INSTALL"; then
if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
    IFS="${IFS= 	}"; ac_save_IFS="$IFS"; IFS=":"
  for ac_dir in $PATH; do
    # Account for people who put trailing slashes in PATH elements.
    case "$ac_dir/" in
    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
    *)
      # OSF1 and SCO ODT 3.0 have their own names for install.
      # Don't use installbsd from OSF since it installs stuff as root
      # by default.
      for ac_prog in ginstall scoinst install; do
        if test -f $ac_dir/$ac_prog; then
	  if test $ac_prog = install &&
            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
	    # AIX install.  It has an incompatible calling convention.
	    :
	  else
	    ac_cv_path_install="$ac_dir/$ac_prog -c"
	    break 2
	  fi
	fi
      done
      ;;
    esac
  done
  IFS="$ac_save_IFS"

fi
  if test "${ac_cv_path_install+set}" = set; then
    INSTALL="$ac_cv_path_install"
  else
    # As a last resort, use the slow shell script.  We don't cache a
    # path for INSTALL within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the path is relative.
    INSTALL="$ac_install_sh"
  fi
fi
echo "$ac_t""$INSTALL" 1>&6

# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

case "X$INSTALL" in
    X/*)
        ;;
    *)
        INSTALL="$ascpwd/$INSTALL"
        ;;
esac


#--------------------------------------------------------------------
#	Get the host type for various checks along the way
#--------------------------------------------------------------------

# Make sure we can run config.sub.
if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
fi

echo $ac_n "checking host system type""... $ac_c" 1>&6
echo "configure:844: checking host system type" >&5

host_alias=$host
case "$host_alias" in
NONE)
  case $nonopt in
  NONE)
    if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
    else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
    fi ;;
  *) host_alias=$nonopt ;;
  esac ;;
esac

host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
echo "$ac_t""$host" 1>&6


#--------------------------------------------------------------------
#	Check for the C compiler: set CC and CFLAGS.
#	If the user does NOT specify `--enable-gcc' on the configure
#	command command line, set CC to either the envar CC or `cc'.
#	Call AC_PROG_CC which will use the value of CC (perhaps set
#	immediately above) or will check for `gcc' and then for `cc'
#	if `gcc' is not found.
#
#	If we are using GCC, then assume it groks ANSI.  Otherwise,
#	try to compile a small program using ANSI constructs with
#	CC.  If this fails, try to locate each of the following:
#		c89 xlc acc
#	and if successful, see if it compiles an ANSI C program.
#	(Doing this in a loop would be ideal, but configure caches
#	the result of AC_CHECK_PROG and uses the cached value for
#	all but the first pass through the loop.  This is also the
#	reason we have to use a different variable asc_cc1, asc_cc2
#	for each call to AC_CHECK_PROG.
#
#	If we do not find an ANSI C compiler, print a warning and
#	use the first value of CC we tried.
#--------------------------------------------------------------------

# Check whether --enable-gcc or --disable-gcc was given.
if test "${enable_gcc+set}" = set; then
  enableval="$enable_gcc"
  asc_gcc_ok=$enableval
else
  asc_gcc_ok=no
fi

if test ! "$asc_gcc_ok" = "yes"; then
    CC=${CC-cc}
fi
asc_orig_cc=$CC

if test "X$asc_gcc_ok" = "Xyes" ; then
    asc_ansi_ok=yes
else
    echo $ac_n "checking whether $CC understands const, void*, and function prototypes""... $ac_c" 1>&6
echo "configure:906: checking whether $CC understands const, void*, and function prototypes" >&5
    cat > conftest.$ac_ext <<EOF
#line 908 "configure"
#include "confdefs.h"

int main() {

          int tstproto(int arg1, char * arg2);
          int tstconst(const int arg1, const char *arg2);
          int tstvoidp(const int arg1, const void *arg2); 
; return 0; }
EOF
if { (eval echo configure:918: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
   asc_ansi_ok=yes 
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
   asc_ansi_ok=no 
fi
rm -f conftest*
    echo "$ac_t""$asc_ansi_ok" 1>&6
fi

if test "$asc_ansi_ok" = no ; then
    # Extract the first word of "c89", so it can be a program name with args.
set dummy c89; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:935: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_asc_cc1'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$asc_cc1"; then
  ac_cv_prog_asc_cc1="$asc_cc1" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_asc_cc1="c89"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_asc_cc1" && ac_cv_prog_asc_cc1="NONE"
fi
fi
asc_cc1="$ac_cv_prog_asc_cc1"
if test -n "$asc_cc1"; then
  echo "$ac_t""$asc_cc1" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

    if test ! "$asc_cc1" = NONE ; then
        CC=$asc_cc1
        echo $ac_n "checking whether $CC understands const, void*, and function prototypes""... $ac_c" 1>&6
echo "configure:965: checking whether $CC understands const, void*, and function prototypes" >&5
        cat > conftest.$ac_ext <<EOF
#line 967 "configure"
#include "confdefs.h"

int main() {

              int tstproto(int arg1, char * arg2);
              int tstconst(const int arg1, const char *arg2);
              int tstvoidp(const int arg1, const void *arg2); 
; return 0; }
EOF
if { (eval echo configure:977: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
   asc_ansi_ok=yes 
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
   asc_ansi_ok=no 
fi
rm -f conftest*
        echo "$ac_t""$asc_ansi_ok" 1>&6
    fi
fi

if test "$asc_ansi_ok" = no ; then
    # Extract the first word of "xlc", so it can be a program name with args.
set dummy xlc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:995: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_asc_cc2'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$asc_cc2"; then
  ac_cv_prog_asc_cc2="$asc_cc2" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_asc_cc2="xlc"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_asc_cc2" && ac_cv_prog_asc_cc2="NONE"
fi
fi
asc_cc2="$ac_cv_prog_asc_cc2"
if test -n "$asc_cc2"; then
  echo "$ac_t""$asc_cc2" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

    if test ! "$asc_cc2" = NONE ; then
        CC=$asc_cc2
        echo $ac_n "checking whether $CC understands const, void*, and function prototypes""... $ac_c" 1>&6
echo "configure:1025: checking whether $CC understands const, void*, and function prototypes" >&5
        cat > conftest.$ac_ext <<EOF
#line 1027 "configure"
#include "confdefs.h"

int main() {

              int tstproto(int arg1, char * arg2);
              int tstconst(const int arg1, const char *arg2);
              int tstvoidp(const int arg1, const void *arg2); 
; return 0; }
EOF
if { (eval echo configure:1037: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
   asc_ansi_ok=yes 
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
   asc_ansi_ok=no 
fi
rm -f conftest*
        echo "$ac_t""$asc_ansi_ok" 1>&6
    fi
fi

if test "$asc_ansi_ok" = no ; then
    # Extract the first word of "acc", so it can be a program name with args.
set dummy acc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1055: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_asc_cc3'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$asc_cc3"; then
  ac_cv_prog_asc_cc3="$asc_cc3" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_asc_cc3="acc"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_asc_cc3" && ac_cv_prog_asc_cc3="NONE"
fi
fi
asc_cc3="$ac_cv_prog_asc_cc3"
if test -n "$asc_cc3"; then
  echo "$ac_t""$asc_cc3" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

    if test ! "$asc_cc3" = NONE ; then
        CC=$asc_cc3
        echo $ac_n "checking whether $CC understands const, void*, and function prototypes""... $ac_c" 1>&6
echo "configure:1085: checking whether $CC understands const, void*, and function prototypes" >&5
        cat > conftest.$ac_ext <<EOF
#line 1087 "configure"
#include "confdefs.h"

int main() {

              int tstproto(int arg1, char * arg2);
              int tstconst(const int arg1, const char *arg2);
              int tstvoidp(const int arg1, const void *arg2); 
; return 0; }
EOF
if { (eval echo configure:1097: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
   asc_ansi_ok=yes 
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
   asc_ansi_ok=no 
fi
rm -f conftest*
        echo "$ac_t""$asc_ansi_ok" 1>&6
    fi
fi

# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1114: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CC="gcc"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1144: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_prog_rejected=no
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
        ac_prog_rejected=yes
	continue
      fi
      ac_cv_prog_CC="cc"
      break
    fi
  done
  IFS="$ac_save_ifs"
if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# -gt 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    set dummy "$ac_dir/$ac_word" "$@"
    shift
    ac_cv_prog_CC="$@"
  fi
fi
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

  if test -z "$CC"; then
    case "`uname -s`" in
    *win32* | *WIN32*)
      # Extract the first word of "cl", so it can be a program name with args.
set dummy cl; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1195: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CC="cl"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi
 ;;
    esac
  fi
  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
fi

echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
echo "configure:1227: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5

ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

cat > conftest.$ac_ext << EOF

#line 1238 "configure"
#include "confdefs.h"

main(){return(0);}
EOF
if { (eval echo configure:1243: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  ac_cv_prog_cc_works=yes
  # If we can't run a trivial program, we are probably using a cross compiler.
  if (./conftest; exit) 2>/dev/null; then
    ac_cv_prog_cc_cross=no
  else
    ac_cv_prog_cc_cross=yes
  fi
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_cv_prog_cc_works=no
fi
rm -fr conftest*
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
if test $ac_cv_prog_cc_works = no; then
  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
echo "configure:1269: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
cross_compiling=$ac_cv_prog_cc_cross

echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
echo "configure:1274: checking whether we are using GNU C" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.c <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1283: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gcc=yes
else
  ac_cv_prog_gcc=no
fi
fi

echo "$ac_t""$ac_cv_prog_gcc" 1>&6

if test $ac_cv_prog_gcc = yes; then
  GCC=yes
else
  GCC=
fi

ac_test_CFLAGS="${CFLAGS+set}"
ac_save_CFLAGS="$CFLAGS"
CFLAGS=
echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
echo "configure:1302: checking whether ${CC-cc} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  echo 'void f(){}' > conftest.c
if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
  ac_cv_prog_cc_g=yes
else
  ac_cv_prog_cc_g=no
fi
rm -f conftest*

fi

echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
if test "$ac_test_CFLAGS" = set; then
  CFLAGS="$ac_save_CFLAGS"
elif test $ac_cv_prog_cc_g = yes; then
  if test "$GCC" = yes; then
    CFLAGS="-g -O2"
  else
    CFLAGS="-g"
  fi
else
  if test "$GCC" = yes; then
    CFLAGS="-O2"
  else
    CFLAGS=
  fi
fi


if test "$asc_ansi_ok" = no ; then
    CC=$asc_orig_cc
    { echo "configure: error: Cannot find an ANSI C compiler.  ASCEND will not build
	without an ANSI compiler.  If you have an ANSI compiler which
	configure is not finding, set the CC environment variable to
	the full path fo the compiler and rerun configure." 1>&2; exit 1; }
fi


#--------------------------------------------------------------------
#	Do other misc checks with CC and CFLAGS.
#
#	Determine how to run the C preprocessor.
#
#	If the user specifies --enable-optimization, remove `-g'
#	from CFLAGS, add `-O' to CFLAGS, and define `NDEBUG'.  If
#	we are not building optimized, check for special libraries
#	needed for building a debugging binary (currenly only
#	/usr/lib/end.o under HPUX).
#
#	Check if we're running on AIX; if so, add `-D_ALL_SOURCE'
#	to CFLAGS.
#
#	Check if we're running on HPUX; if so, add -D_HPUX_SOURCE'
#	to CFLAGS unless the C preprocessor goes it for us.
#--------------------------------------------------------------------

echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
echo "configure:1362: checking how to run the C preprocessor" >&5
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
    # This must be in double quotes, not single quotes, because CPP may get
  # substituted into the Makefile and "${CC-cc}" will confuse make.
  CPP="${CC-cc} -E"
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp.
  cat > conftest.$ac_ext <<EOF
#line 1377 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1383: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  :
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  CPP="${CC-cc} -E -traditional-cpp"
  cat > conftest.$ac_ext <<EOF
#line 1394 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1400: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  :
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  CPP="${CC-cc} -nologo -E"
  cat > conftest.$ac_ext <<EOF
#line 1411 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1417: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  :
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  CPP=/lib/cpp
fi
rm -f conftest*
fi
rm -f conftest*
fi
rm -f conftest*
  ac_cv_prog_CPP="$CPP"
fi
  CPP="$ac_cv_prog_CPP"
else
  ac_cv_prog_CPP="$CPP"
fi
echo "$ac_t""$CPP" 1>&6


# Check whether --enable-optimization or --disable-optimization was given.
if test "${enable_optimization+set}" = set; then
  enableval="$enable_optimization"
  asc_do_opt="$enableval"
else
  asc_do_opt=no
fi

if test "$asc_do_opt" = yes; then
    CFLAGS=`echo "-O $CFLAGS " | sed 's/ -g / /g'`
    cat >> confdefs.h <<\EOF
#define NDEBUG 1
EOF

else
    # Extract the first word of "end.o", so it can be a program name with args.
set dummy end.o; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1460: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_DEBUG_LIBS'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$DEBUG_LIBS" in
  /*)
  ac_cv_path_DEBUG_LIBS="$DEBUG_LIBS" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_DEBUG_LIBS="$DEBUG_LIBS" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="/usr/lib"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_DEBUG_LIBS="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
DEBUG_LIBS="$ac_cv_path_DEBUG_LIBS"
if test -n "$DEBUG_LIBS"; then
  echo "$ac_t""$DEBUG_LIBS" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

fi

echo $ac_n "checking for AIX""... $ac_c" 1>&6
echo "configure:1495: checking for AIX" >&5
cat > conftest.$ac_ext <<EOF
#line 1497 "configure"
#include "confdefs.h"

#ifdef _AIX
    yes
#endif

EOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "yes" >/dev/null 2>&1; then
  rm -rf conftest*
   asc_aix=yes ; cat >> confdefs.h <<\EOF
#define _ALL_SOURCE 1
EOF
 
else
  rm -rf conftest*
  asc_aix=no
fi
rm -f conftest*

echo "$ac_t""$asc_aix" 1>&6

echo $ac_n "checking whether -D_HPUX_SOURCE is needed""... $ac_c" 1>&6
echo "configure:1521: checking whether -D_HPUX_SOURCE is needed" >&5
cat > conftest.$ac_ext <<EOF
#line 1523 "configure"
#include "confdefs.h"

#ifdef __hpux
#ifndef _HPUX_SOURCE
    yes
#endif
#endif

EOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "yes" >/dev/null 2>&1; then
  rm -rf conftest*
   asc_hpux=yes ; cat >> confdefs.h <<\EOF
#define _HPUX_SOURCE 1
EOF
 
else
  rm -rf conftest*
  asc_hpux=no
fi
rm -f conftest*

echo "$ac_t""$asc_hpux" 1>&6

# Check the size of pointers; if cross compiling, assume 32 bit pointers
echo $ac_n "checking size of void *""... $ac_c" 1>&6
echo "configure:1550: checking size of void *" >&5
if eval "test \"`echo '$''{'ac_cv_sizeof_void_p'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  ac_cv_sizeof_void_p=4
else
  cat > conftest.$ac_ext <<EOF
#line 1558 "configure"
#include "confdefs.h"
#include <stdio.h>
int main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) return(1);
  fprintf(f, "%d\n", sizeof(void *));
  return(0);
}
EOF
if { (eval echo configure:1569: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
  ac_cv_sizeof_void_p=`cat conftestval`
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -fr conftest*
  ac_cv_sizeof_void_p=0
fi
rm -fr conftest*
fi

fi
echo "$ac_t""$ac_cv_sizeof_void_p" 1>&6
cat >> confdefs.h <<EOF
#define SIZEOF_VOID_P $ac_cv_sizeof_void_p
EOF


#--------------------------------------------------------------------
#	Set YACC.
#	See if we can find `yacc' ourselves; if not, call the
#	autoconf macro which looks for `bison' and then for `yacc'
#--------------------------------------------------------------------
asc_found_yacc=0
# Extract the first word of "yacc", so it can be a program name with args.
set dummy yacc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1599: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$YACC"; then
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_YACC="yacc"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_YACC" && ac_cv_prog_YACC="asc_found_yacc=no"
fi
fi
YACC="$ac_cv_prog_YACC"
if test -n "$YACC"; then
  echo "$ac_t""$YACC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test "$asc_found_yacc" = no ; then
    for ac_prog in 'bison -y' byacc
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1632: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$YACC"; then
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_YACC="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
YACC="$ac_cv_prog_YACC"
if test -n "$YACC"; then
  echo "$ac_t""$YACC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$YACC" && break
done
test -n "$YACC" || YACC="yacc"

fi


#--------------------------------------------------------------------
#	Set LEX.
#	ASCEND requires a `flex' which understands -P (allows you to
#	specify a prefix other than `yy').  The -P flag was added at
#	the same time a -V (version) flag was added (version 2.4.1),
#	so if `flex' understands -V, it'll understand -P (checking
#	for -P directly requires a flex input file).
#
#	1. If `LEX' is not set, look for `flex' and set `LEX' to
#	   `flex' if found.
#	2. If `flex' was found, see if it understands -V.  If so,
#	   set `scanner_src' and `typer_src' to have `flex' generate
#	   the C files from the flex input files
#	   ascend4/compiler/scanner.l & ascend4/interface/typelex.l
#	   We don't need to look for libfl.a since we define
#	   yywrap() ourselves.
#	3. If `flex' wasn't found or was found but isn't new enough:
#	   a. Print a warning message
#	   b. Set `scanner_src' and `typer_src' to use pre-generated
#	      C files for the flex files mentioned in (2).
#	   c. Set `LEX' to `lex'
#	   d. Search for the lex library `libl.a' and set LEXLIB to
#	      its location.
#--------------------------------------------------------------------
# Extract the first word of "flex", so it can be a program name with args.
set dummy flex; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1692: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$LEX"; then
  ac_cv_prog_LEX="$LEX" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_LEX="flex"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
LEX="$ac_cv_prog_LEX"
if test -n "$LEX"; then
  echo "$ac_t""$LEX" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


if test -n "$LEX" ; then
    echo $ac_n "checking whether $LEX is at least version 2.4.1""... $ac_c" 1>&6
echo "configure:1721: checking whether $LEX is at least version 2.4.1" >&5
    echo "$LEX -V" 1>&5
    if $LEX -V 1>&5 2>&5 ; then
        echo "$ac_t""yes" 1>&6
        scanner_src="scanner.c.from.flex"
        typer_src="typelex.c.from.flex"
    else
        echo "$ac_t""no" 1>&6
        LEX=''
    fi
fi

if test -z "$LEX" ; then
    echo "configure: warning: Cannot find a flex lexer version 2.4.1 or greater.
	Using pregenerated C files for ascend4/compiler/scanner.l
	and ascend4/interface/typelex.l.  If you have flex 2.4.1
	or newer, set the LEX environment variable to its location
	and run configure again." 1>&2
    scanner_src="scanner.c.from.c"
    typer_src="typelex.c.from.c"

    # let configure set LEX and LEXLIB even though we won't be using them
    # Extract the first word of "flex", so it can be a program name with args.
set dummy flex; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1746: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$LEX"; then
  ac_cv_prog_LEX="$LEX" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_LEX="flex"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_LEX" && ac_cv_prog_LEX="lex"
fi
fi
LEX="$ac_cv_prog_LEX"
if test -n "$LEX"; then
  echo "$ac_t""$LEX" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test -z "$LEXLIB"
then
  case "$LEX" in
  flex*) ac_lib=fl ;;
  *) ac_lib=l ;;
  esac
  echo $ac_n "checking for yywrap in -l$ac_lib""... $ac_c" 1>&6
echo "configure:1780: checking for yywrap in -l$ac_lib" >&5
ac_lib_var=`echo $ac_lib'_'yywrap | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-l$ac_lib  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 1788 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char yywrap();

int main() {
yywrap()
; return 0; }
EOF
if { (eval echo configure:1799: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  LEXLIB="-l$ac_lib"
else
  echo "$ac_t""no" 1>&6
fi

fi

fi


#--------------------------------------------------------------------
#	Math libraries.
#	On a few very rare systems, all of the libm.a stuff is
#	already in libc.a.  Set compiler flags accordingly.
#	Also, Linux requires the "ieee" library for math to work
#	right (and it must appear before "-lm").
#
#	When building on HPUX with GCC, GCC cannot find `copysign'
#	because it lives in an odd place; see if we need to add
#	this odd place to MATH_LIBS.
#
#	See if erf(), the error function, exists; if so, define
#	HAVE_ERF.
#--------------------------------------------------------------------
echo $ac_n "checking for sin""... $ac_c" 1>&6
echo "configure:1839: checking for sin" >&5
if eval "test \"`echo '$''{'ac_cv_func_sin'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1844 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char sin(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char sin();

int main() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_sin) || defined (__stub___sin)
choke me
#else
sin();
#endif

; return 0; }
EOF
if { (eval echo configure:1867: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_func_sin=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_func_sin=no"
fi
rm -f conftest*
fi

if eval "test \"`echo '$ac_cv_func_'sin`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  MATH_LIBS=""
else
  echo "$ac_t""no" 1>&6
MATH_LIBS="-lm"
fi


echo $ac_n "checking for printf in -lieee""... $ac_c" 1>&6
echo "configure:1889: checking for printf in -lieee" >&5
ac_lib_var=`echo ieee'_'printf | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lieee  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 1897 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char printf();

int main() {
printf()
; return 0; }
EOF
if { (eval echo configure:1908: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  MATH_LIBS="-lieee $MATH_LIBS"
else
  echo "$ac_t""no" 1>&6
fi


if test -n "$MATH_LIBS" ; then
    echo $ac_n "checking for copysign in -lm""... $ac_c" 1>&6
echo "configure:1931: checking for copysign in -lm" >&5
ac_lib_var=`echo m'_'copysign | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lm $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 1939 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char copysign();

int main() {
copysign()
; return 0; }
EOF
if { (eval echo configure:1950: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
  cat >> confdefs.h <<EOF
#define $ac_tr_lib 1
EOF

  LIBS="-lm $LIBS"

else
  echo "$ac_t""no" 1>&6
echo $ac_n "checking for drem in -lm""... $ac_c" 1>&6
echo "configure:1976: checking for drem in -lm" >&5
ac_lib_var=`echo m'_'drem | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lm /lib/pa1.1/libM.a
         $LIBS"
cat > conftest.$ac_ext <<EOF
#line 1985 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char drem();

int main() {
drem()
; return 0; }
EOF
if { (eval echo configure:1996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  MATH_LIBS="$MATH_LIBS /lib/pa1.1/libM.a"
                     
else
  echo "$ac_t""no" 1>&6
fi

fi

fi

# store the current list of libraries, add the math libraries to LIBS,
# check for erf(), then reset the value of LIBS.
asc_keep_LIBS="$LIBS"
LIBS="$LIBS $MATH_LIBS"
for ac_func in erf
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:2028: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2033 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $ac_func(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char $ac_func();

int main() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
$ac_func();
#endif

; return 0; }
EOF
if { (eval echo configure:2056: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=no"
fi
rm -f conftest*
fi

if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
  cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
 
else
  echo "$ac_t""no" 1>&6
fi
done

LIBS="$asc_keep_LIBS"


#--------------------------------------------------------------------
#	Check for X11.
#	We'll use the simple autoconf builtin macro for finding
#	X11 until we find a reason not to.
#
#	On Solaris and IRIX, add the path to the X library to the
#	run-time shared-library-search-path so the ASCEND binary
#	can find the X library without the user having to set
#	LD_LIBRARY_PATH
#--------------------------------------------------------------------
# If we find X, set shell vars x_includes and x_libraries to the
# paths, otherwise set no_x=yes.
# Uses ac_ vars as temps to allow command line to override cache and checks.
# --without-x overrides everything else, but does not touch the cache.
echo $ac_n "checking for X""... $ac_c" 1>&6
echo "configure:2098: checking for X" >&5

# Check whether --with-x or --without-x was given.
if test "${with_x+set}" = set; then
  withval="$with_x"
  :
fi

# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
if test "x$with_x" = xno; then
  # The user explicitly disabled X.
  have_x=disabled
else
  if test "x$x_includes" != xNONE && test "x$x_libraries" != xNONE; then
    # Both variables are already set.
    have_x=yes
  else
if eval "test \"`echo '$''{'ac_cv_have_x'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  # One or both of the vars are not set, and there is no cached value.
ac_x_includes=NO ac_x_libraries=NO
rm -fr conftestdir
if mkdir conftestdir; then
  cd conftestdir
  # Make sure to not put "make" in the Imakefile rules, since we grep it out.
  cat > Imakefile <<'EOF'
acfindx:
	@echo 'ac_im_incroot="${INCROOT}"; ac_im_usrlibdir="${USRLIBDIR}"; ac_im_libdir="${LIBDIR}"'
EOF
  if (xmkmf) >/dev/null 2>/dev/null && test -f Makefile; then
    # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
    eval `${MAKE-make} acfindx 2>/dev/null | grep -v make`
    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
    for ac_extension in a so sl; do
      if test ! -f $ac_im_usrlibdir/libX11.$ac_extension &&
        test -f $ac_im_libdir/libX11.$ac_extension; then
        ac_im_usrlibdir=$ac_im_libdir; break
      fi
    done
    # Screen out bogus values from the imake configuration.  They are
    # bogus both because they are the default anyway, and because
    # using them would break gcc on systems where it needs fixed includes.
    case "$ac_im_incroot" in
	/usr/include) ;;
	*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes="$ac_im_incroot" ;;
    esac
    case "$ac_im_usrlibdir" in
	/usr/lib | /lib) ;;
	*) test -d "$ac_im_usrlibdir" && ac_x_libraries="$ac_im_usrlibdir" ;;
    esac
  fi
  cd ..
  rm -fr conftestdir
fi

if test "$ac_x_includes" = NO; then
  # Guess where to find include files, by looking for this one X11 .h file.
  test -z "$x_direct_test_include" && x_direct_test_include=X11/Intrinsic.h

  # First, try using that file with no special directory specified.
cat > conftest.$ac_ext <<EOF
#line 2160 "configure"
#include "confdefs.h"
#include <$x_direct_test_include>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2165: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  rm -rf conftest*
  # We can compile using X headers with no special include directory.
ac_x_includes=
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  # Look for the header file in a standard set of common directories.
# Check X11 before X11Rn because it is often a symlink to the current release.
  for ac_dir in               \
    /usr/X11/include          \
    /usr/X11R6/include        \
    /usr/X11R5/include        \
    /usr/X11R4/include        \
                              \
    /usr/include/X11          \
    /usr/include/X11R6        \
    /usr/include/X11R5        \
    /usr/include/X11R4        \
                              \
    /usr/local/X11/include    \
    /usr/local/X11R6/include  \
    /usr/local/X11R5/include  \
    /usr/local/X11R4/include  \
                              \
    /usr/local/include/X11    \
    /usr/local/include/X11R6  \
    /usr/local/include/X11R5  \
    /usr/local/include/X11R4  \
                              \
    /usr/X386/include         \
    /usr/x386/include         \
    /usr/XFree86/include/X11  \
                              \
    /usr/include              \
    /usr/local/include        \
    /usr/unsupported/include  \
    /usr/athena/include       \
    /usr/local/x11r5/include  \
    /usr/lpp/Xamples/include  \
                              \
    /usr/openwin/include      \
    /usr/openwin/share/include \
    ; \
  do
    if test -r "$ac_dir/$x_direct_test_include"; then
      ac_x_includes=$ac_dir
      break
    fi
  done
fi
rm -f conftest*
fi # $ac_x_includes = NO

if test "$ac_x_libraries" = NO; then
  # Check for the libraries.

  test -z "$x_direct_test_library" && x_direct_test_library=Xt
  test -z "$x_direct_test_function" && x_direct_test_function=XtMalloc

  # See if we find them without any special options.
  # Don't add to $LIBS permanently.
  ac_save_LIBS="$LIBS"
  LIBS="-l$x_direct_test_library $LIBS"
cat > conftest.$ac_ext <<EOF
#line 2234 "configure"
#include "confdefs.h"

int main() {
${x_direct_test_function}()
; return 0; }
EOF
if { (eval echo configure:2241: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  LIBS="$ac_save_LIBS"
# We can link X programs with no special library path.
ac_x_libraries=
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  LIBS="$ac_save_LIBS"
# First see if replacing the include by lib works.
# Check X11 before X11Rn because it is often a symlink to the current release.
for ac_dir in `echo "$ac_x_includes" | sed s/include/lib/` \
    /usr/X11/lib          \
    /usr/X11R6/lib        \
    /usr/X11R5/lib        \
    /usr/X11R4/lib        \
                          \
    /usr/lib/X11          \
    /usr/lib/X11R6        \
    /usr/lib/X11R5        \
    /usr/lib/X11R4        \
                          \
    /usr/local/X11/lib    \
    /usr/local/X11R6/lib  \
    /usr/local/X11R5/lib  \
    /usr/local/X11R4/lib  \
                          \
    /usr/local/lib/X11    \
    /usr/local/lib/X11R6  \
    /usr/local/lib/X11R5  \
    /usr/local/lib/X11R4  \
                          \
    /usr/X386/lib         \
    /usr/x386/lib         \
    /usr/XFree86/lib/X11  \
                          \
    /usr/lib              \
    /usr/local/lib        \
    /usr/unsupported/lib  \
    /usr/athena/lib       \
    /usr/local/x11r5/lib  \
    /usr/lpp/Xamples/lib  \
    /lib/usr/lib/X11	  \
                          \
    /usr/openwin/lib      \
    /usr/openwin/share/lib \
    ; \
do
  for ac_extension in a so sl; do
    if test -r $ac_dir/lib${x_direct_test_library}.$ac_extension; then
      ac_x_libraries=$ac_dir
      break 2
    fi
  done
done
fi
rm -f conftest*
fi # $ac_x_libraries = NO

if test "$ac_x_includes" = NO || test "$ac_x_libraries" = NO; then
  # Didn't find X anywhere.  Cache the known absence of X.
  ac_cv_have_x="have_x=no"
else
  # Record where we found X for the cache.
  ac_cv_have_x="have_x=yes \
	        ac_x_includes=$ac_x_includes ac_x_libraries=$ac_x_libraries"
fi
fi
  fi
  eval "$ac_cv_have_x"
fi # $with_x != no

if test "$have_x" != yes; then
  echo "$ac_t""$have_x" 1>&6
  no_x=yes
else
  # If each of the values was on the command line, it overrides each guess.
  test "x$x_includes" = xNONE && x_includes=$ac_x_includes
  test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
  # Update the cache value to reflect the command line values.
  ac_cv_have_x="have_x=yes \
		ac_x_includes=$x_includes ac_x_libraries=$x_libraries"
  echo "$ac_t""libraries $x_libraries, headers $x_includes" 1>&6
fi

if test -n "$x_includes"; then
    X11_INCLUDES="-I$x_includes"
fi
if test -n "$x_libraries"; then
    X11_LIBRARIES="-L$x_libraries"
    case "$host" in
        sparc-sun-solaris*)
            X11_RUN_PATH="-R$x_libraries" 
            ;;
        mips-sgi-irix*)
            X11_RUN_PATH="-rpath $x_libraries"
            ;;
        *)
            X11_RUN_PATH=""
            ;;
    esac
fi


#--------------------------------------------------------------------
#	Check for the existence of various libraries.  The order here
#	is important, so that then end up in the right order in the
#	command line generated by make.  The -lsocket and -lnsl
#	libraries require a couple of special tricks:
#	1. Use "connect" and "accept" to check for -lsocket, and
#	   "gethostbyname" to check for -lnsl.
#	2. Use each function name only once:  can't redo a check
#	   because autoconf caches the results of the last check
#	   and won't redo it.
#	3. Use -lnsl and -lsocket only if they supply procedures that
#	   aren't already present in the normal libraries.  This is
#	   because IRIX 5.2 has libraries, but they aren't needed and
#	   they're bogus:  they goof up name resolution if used.
#	4. On some SVR4 systems, can't use -lsocket without -lnsl
#	   too. To get around this problem, check for both libraries
#	   together if -lsocket doesn't work by itself.
#--------------------------------------------------------------------

asc_checkBoth=0
echo $ac_n "checking for connect""... $ac_c" 1>&6
echo "configure:2367: checking for connect" >&5
if eval "test \"`echo '$''{'ac_cv_func_connect'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2372 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char connect(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char connect();

int main() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_connect) || defined (__stub___connect)
choke me
#else
connect();
#endif

; return 0; }
EOF
if { (eval echo configure:2395: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_func_connect=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_func_connect=no"
fi
rm -f conftest*
fi

if eval "test \"`echo '$ac_cv_func_'connect`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  asc_checkSocket=0
else
  echo "$ac_t""no" 1>&6
asc_checkSocket=1
fi

if test "$asc_checkSocket" = 1; then
    echo $ac_n "checking for printf in -lsocket""... $ac_c" 1>&6
echo "configure:2417: checking for printf in -lsocket" >&5
ac_lib_var=`echo socket'_'printf | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lsocket  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 2425 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char printf();

int main() {
printf()
; return 0; }
EOF
if { (eval echo configure:2436: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  X11_EXTRA_LIBS="-lsocket"
else
  echo "$ac_t""no" 1>&6
asc_checkBoth=1
fi

fi
if test "$asc_checkBoth" = 1; then
    asc_oldLibs=$LIBS
    X11_EXTRA_LIBS="-lsocket -lnsl"
    LIBS="$LIBS $X11_EXTRA_LIBS"
    echo $ac_n "checking for accept""... $ac_c" 1>&6
echo "configure:2463: checking for accept" >&5
if eval "test \"`echo '$''{'ac_cv_func_accept'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2468 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char accept(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char accept();

int main() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_accept) || defined (__stub___accept)
choke me
#else
accept();
#endif

; return 0; }
EOF
if { (eval echo configure:2491: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_func_accept=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_func_accept=no"
fi
rm -f conftest*
fi

if eval "test \"`echo '$ac_cv_func_'accept`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  asc_checkNsl=0
else
  echo "$ac_t""no" 1>&6
X11_EXTRA_LIBS=""
fi

    LIBS=$asc_oldLibs
fi
asc_oldLibs=$LIBS
LIBS="$LIBS $X11_EXTRA_LIBS"
echo $ac_n "checking for gethostbyname""... $ac_c" 1>&6
echo "configure:2516: checking for gethostbyname" >&5
if eval "test \"`echo '$''{'ac_cv_func_gethostbyname'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2521 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char gethostbyname(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char gethostbyname();

int main() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_gethostbyname) || defined (__stub___gethostbyname)
choke me
#else
gethostbyname();
#endif

; return 0; }
EOF
if { (eval echo configure:2544: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_func_gethostbyname=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_func_gethostbyname=no"
fi
rm -f conftest*
fi

if eval "test \"`echo '$ac_cv_func_'gethostbyname`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  :
else
  echo "$ac_t""no" 1>&6
echo $ac_n "checking for printf in -lnsl""... $ac_c" 1>&6
echo "configure:2562: checking for printf in -lnsl" >&5
ac_lib_var=`echo nsl'_'printf | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lnsl  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 2570 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char printf();

int main() {
printf()
; return 0; }
EOF
if { (eval echo configure:2581: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  X11_EXTRA_LIBS="$X11_EXTRA_LIBS -lnsl"
else
  echo "$ac_t""no" 1>&6
fi

fi

LIBS=$asc_oldLibs


#--------------------------------------------------------------------
#	The following comes directly from the configure.in file for
#	Tcl8.0.
#
#	The statements below define a collection of symbols related to
#	dynamic loading and shared libraries:
#
#	DL_OBJS -	Name of the object file that implements dynamic
#			loading for ASCEND on this system.
#	DL_LIBS -	Library file(s) to include in tclsh and other base
#			applications in order for the "load" command to work.
#	LD_FLAGS -	Flags to pass to the compiler when linking object
#			files into an executable application binary such
#			as tclsh.
#	LD_SEARCH_FLAGS-Flags to pass to ld, such as "-R /usr/local/tcl/lib",
#			that tell the run-time dynamic linker where to look
#			for shared libraries such as libtcl.so.  Depends on
#			the variable LIB_RUNTIME_DIR in the Makefile.
#	MAKE_LIB -	Command to execute to build the ASCEND library;
#			differs depending on whether or not ASCEND is being
#			compiled as a shared library.
#	SHLIB_CFLAGS -	Flags to pass to cc when compiling the components
#			of a shared library (may request position-independent
#			code, among other things).
#	SHLIB_LD -	Base command to use for combining object files
#			into a shared library.
#	SHLIB_LD_LIBS -	Dependent libraries for the linker to scan when
#			creating shared libraries.  This symbol typically
#			goes at the end of the "ld" commands that build
#			shared libraries. The value of the symbol is
#			"${LIBS}" if all of the dependent libraries should
#			be specified when creating a shared library.  If
#			dependent libraries should not be specified (as on
#			SunOS 4.x, where they cause the link to fail, or in
#			general if ASCEND and Tk aren't themselves shared
#			libraries), then this symbol has an empty string
#			as its value.
#	SHLIB_SUFFIX -	Suffix to use for the names of dynamically loadable
#			extensions.  An empty string means we don't know how
#			to use shared libraries on this platform.
#	ASC_LIB_FILE -	Name of the file that contains the ASCEND library, such
#			as libtcl7.8.so or libtcl7.8.a.
#	ASC_LIB_SUFFIX -Specifies everything that comes after the "libtcl"
#			in the shared library name, using the $VERSION variable
#			to put the version in the right place.  This is used
#			by platforms that need non-standard library names.
#			Examples:  ${VERSION}.so.1.1 on NetBSD, since it needs
#			to have a version after the .so, and ${VERSION}.a
#			on AIX, since the ASCEND shared library needs to have
#			a .a extension whereas shared objects for loadable
#			extensions have a .so extension.  Defaults to
#			${VERSION}${SHLIB_SUFFIX}.
#--------------------------------------------------------------------

# Step 1: set the variable "system" to hold the name and version number
# for the system.  This can usually be done via the "uname" command, but
# there are a few systems, like Next, where this doesn't work.

# Changed this to use the "$host" variable from AC_CANONICAL_HOST

# Step 2: check for existence of -ldl library.  This is needed because
# Linux can use either -ldl or -ldld for dynamic loading.

echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
echo "configure:2670: checking for dlopen in -ldl" >&5
ac_lib_var=`echo dl'_'dlopen | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ldl  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 2678 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char dlopen();

int main() {
dlopen()
; return 0; }
EOF
if { (eval echo configure:2689: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  have_dl=yes
else
  echo "$ac_t""no" 1>&6
have_dl=no
fi


# Step 3: set configuration options based on system name and version.

ASC_SHARED_LIB_SUFFIX=""
ASC_UNSHARED_LIB_SUFFIX=""
ASC_LIB_VERSIONS_OK=ok
case $host in
    *-aix*)
	SHLIB_CFLAGS=""
	SHLIB_LD="$fullpathsrcdir/ldAix /bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512"
	SHLIB_LD_LIBS='${LIBS}'
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-lld"
	LD_FLAGS=""
	LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	ASC_SHARED_LIB_SUFFIX='${VERSION}.a'
	;;
    *-bsdi*)
	SHLIB_CFLAGS=""
	SHLIB_LD="shlicc -r"
	SHLIB_LD_LIBS='${LIBS}'
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS=""
	;;
    *-dgux*)
	SHLIB_CFLAGS="-K PIC"
	SHLIB_LD="cc -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS=""
	;;
    *-hpux8*|*-hpux9*|*-hpux10*)
	echo $ac_n "checking for shl_load in -ldld""... $ac_c" 1>&6
echo "configure:2750: checking for shl_load in -ldld" >&5
ac_lib_var=`echo dld'_'shl_load | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ldld  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 2758 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char shl_load();

int main() {
shl_load()
; return 0; }
EOF
if { (eval echo configure:2769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  tcl_ok=yes
else
  echo "$ac_t""no" 1>&6
tcl_ok=no
fi

	if test "$tcl_ok" = yes; then
	    SHLIB_CFLAGS="+z"
	    SHLIB_LD="ld -b"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".sl"
	    DL_OBJS=""
	    DL_LIBS="-ldld"
	    LD_FLAGS="-Wl,-E"
	    LD_SEARCH_FLAGS='-Wl,+b,${LIB_RUNTIME_DIR}:.'
	fi
	;;
    *-irix4*)
	SHLIB_CFLAGS="-G 0"
	SHLIB_SUFFIX=".a"
	SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
	SHLIB_LD_LIBS='${LIBS}'
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS="-Wl,-D,08000000"
	LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	ASC_SHARED_LIB_SUFFIX='${VERSION}.a'
	;;
    *-irix5*|*-irix6.*)
	SHLIB_CFLAGS=""
	SHLIB_LD="ld -shared -rdata_shared"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS=""
	LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	;;
    *-linux*)
	SHLIB_CFLAGS="-fPIC"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	if test "$have_dl" = yes; then
	    SHLIB_LD="${CC} -shared"
	    DL_OBJS=""
	    DL_LIBS="-ldl"
	    LD_FLAGS="-rdynamic"
	    LD_SEARCH_FLAGS=""
	else
	    ac_safe=`echo "dld.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for dld.h""... $ac_c" 1>&6
echo "configure:2835: checking for dld.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2840 "configure"
#include "confdefs.h"
#include <dld.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2845: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  
		SHLIB_LD="ld -shared"
		DL_OBJS=""
		DL_LIBS="-ldld"
		LD_FLAGS=""
		LD_SEARCH_FLAGS=""
else
  echo "$ac_t""no" 1>&6
fi

	fi
	;;
    MP-RAS-02*)
	SHLIB_CFLAGS="-K PIC"
	SHLIB_LD="cc -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS=""
	;;
    MP-RAS-*)
	SHLIB_CFLAGS="-K PIC"
	SHLIB_LD="cc -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS="-Wl,-Bexport"
	LD_SEARCH_FLAGS=""
	;;
    *-netbsd*|*-freebsd*|*-openbsd*)
	# Not available on all versions:  check for include file.
	ac_safe=`echo "dlfcn.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for dlfcn.h""... $ac_c" 1>&6
echo "configure:2897: checking for dlfcn.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2902 "configure"
#include "confdefs.h"
#include <dlfcn.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2907: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  
	    SHLIB_CFLAGS="-fpic"
	    SHLIB_LD="ld -Bshareable -x"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS=""
	    DL_LIBS=""
	    LD_FLAGS=""
	    LD_SEARCH_FLAGS=""
	    ASC_SHARED_LIB_SUFFIX='`echo ${VERSION} | tr -d .`.so.1.0'
	
else
  echo "$ac_t""no" 1>&6

	    SHLIB_CFLAGS=""
	    SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".a"
	    DL_OBJS=""
	    DL_LIBS=""
	    LD_FLAGS=""
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	    ASC_SHARED_LIB_SUFFIX='`echo ${VERSION} | tr -d .`.a'
	
fi


	# FreeBSD doesn't handle version numbers with dots.

	ASC_UNSHARED_LIB_SUFFIX='`echo ${VERSION} | tr -d .`.a'
	ASC_LIB_VERSIONS_OK=nodots
	;;
    *-nextstep*)
	SHLIB_CFLAGS=""
	SHLIB_LD="cc -nostdlib -r"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS=""
	LD_SEARCH_FLAGS=""
	;;
    alpha-dec-osf*)
        # Digital OSF/1
	SHLIB_CFLAGS=""
	SHLIB_LD='ld -shared -expect_unresolved "*"'
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS=""
	LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	;;
    *-riscos*)
	SHLIB_CFLAGS="-G 0"
	SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
	SHLIB_LD_LIBS='${LIBS}'
	SHLIB_SUFFIX=".a"
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS="-Wl,-D,08000000"
	LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	;;
    SCO_SV-3.2*)
        # Note, dlopen is available only on SCO 3.2.5 and greater.  However,
        # this test works, since "uname -s" was non-standard in 3.2.4 and
        # below.
	SHLIB_CFLAGS="-Kpic -belf"
	SHLIB_LD="ld -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS="-belf -Wl,-Bexport"
	LD_SEARCH_FLAGS=""
	;;
    *-sni-sysv*)
	SHLIB_CFLAGS="-K PIC"
	SHLIB_LD="cc -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS=""
	;;
    *-sunos4*)
	SHLIB_CFLAGS="-PIC"
	SHLIB_LD="ld"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'

	# SunOS can't handle version numbers with dots in them in library
	# specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
	# requires an extra version number at the end of .so file names.
	# So, the library has to have a name like libtcl75.so.1.0

	ASC_SHARED_LIB_SUFFIX='`echo ${VERSION} | tr -d .`.so.1.0'
	ASC_UNSHARED_LIB_SUFFIX='`echo ${VERSION} | tr -d .`.a'
	ASC_LIB_VERSIONS_OK=nodots
	;;
    *-solaris*)
	SHLIB_CFLAGS="-KPIC"
	SHLIB_LD="/usr/ccs/bin/ld -G -z text"

	# Note: need the LIBS below, otherwise Tk won't find ASCEND's
	# symbols when dynamically loaded into tclsh.

	SHLIB_LD_LIBS='${LIBS}'
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	LD_FLAGS=""
	LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
	;;
    *-ultrix4*)
	SHLIB_CFLAGS="-G 0"
	SHLIB_SUFFIX=".a"
	SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
	SHLIB_LD_LIBS='${LIBS}'
	DL_OBJS=""
	DL_LIBS=""
	LD_FLAGS="-Wl,-D,08000000"
	LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	;;
    mips-dde-sysv*)
	SHLIB_CFLAGS="-KPIC"
	SHLIB_LD="cc -G"
	SHLIB_LD_LIBS=""
	SHLIB_SUFFIX=".so"
	DL_OBJS=""
	DL_LIBS="-ldl"
	# Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers
	# that don't grok the -Bexport option.  Test that it does.
	hold_ldflags=$LDFLAGS
	echo $ac_n "checking for ld accepts -Bexport flag""... $ac_c" 1>&6
echo "configure:3063: checking for ld accepts -Bexport flag" >&5
	LDFLAGS="${LDFLAGS} -Wl,-Bexport"
	cat > conftest.$ac_ext <<EOF
#line 3066 "configure"
#include "confdefs.h"

int main() {
int i;
; return 0; }
EOF
if { (eval echo configure:3073: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  found=yes
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  found=no
fi
rm -f conftest*
	LDFLAGS=$hold_ldflags
	echo "$ac_t""$found" 1>&6
	if test "$found" = yes; then
	  LD_FLAGS="-Wl,-Bexport"
	else
	  LD_FLAGS=""
	fi
	LD_SEARCH_FLAGS=""
	;;
esac

# Step 4: If pseudo-static linking is in use (see K. B. Kenny, "Dynamic
# Loading for Tcl -- What Became of It?".  Proc. 2nd Tcl/Tk Workshop,
# New Orleans, LA, Computerized Processes Unlimited, 1994), then we need
# to determine which of several header files defines the a.out file
# format (a.out.h, sys/exec.h, or sys/exec_aout.h).  At present, we
# support only a file format that is more or less version-7-compatible. 
# In particular,
#	- a.out files must begin with `struct exec'.
#	- the N_TXTOFF on the `struct exec' must compute the seek address
#	  of the text segment
#	- The `struct exec' must contain a_magic, a_text, a_data, a_bss
#	  and a_entry fields.
# The following compilation should succeed if and only if either sys/exec.h
# or a.out.h is usable for the purpose.
#
# Note that the modified COFF format used on MIPS Ultrix 4.x is usable; the
# `struct exec' includes a second header that contains information that
# duplicates the v7 fields that are needed.
# Step 5: disable dynamic loading if requested via a command-line switch.

#--------------------------------------------------------------------
#	TCL / TK / TK-TABLE
#
#	The user can specify the location of the Tcl and/or Tk
#	libraries using the --with-tcl and --with-tk configure
#	options. Print a warning if the user tries to say
#	--without-tcl since ASCEND requires Tcl/Tk.
#
#	If the user does not specify the location, we need to search
#	for either shared or static versions of the Tcl and Tk
#	libraries, and they must be for version 8.x of Tcl/Tk.
#
#	Check for the static Tcl library in a list of reasonable
#	locations.  If we find it, verify that it is from Tcl 8.0 by
#	looking for the symbol `TclCompileCatchCmd'.  Remember, we
#	need the math library and the dynamic loader library (-ldl or
#	-ldld) to avoid undefined symbols when we test the version of
#	the Tcl library.
#
#	If we can't find a static Tcl8.0 library, try to find a
#	dynamic one by calling AC_CHECK_LIB and looking for the
#	function `TclCompileCatchCmd'.  If we fail, print an error
#	message and exit configure.
#
#	Search for a version of tcl.h that contains `8.' in the
#	TCL_MAJOR_VERSION macro; we look in a list of reasonable
#	locations, then call AC_EGREP_HEADER to look for us.
#
#	Repeat the process for the Tk library; the symbol we want is
#	`Tk_NameOfFont'; remember we need the X library---and all the
#	libraries it needs---as well as the Tcl library to avoid
#	undefined symbols when we test the version of the Tk library.
#
#	The user can use --with-tktable to specify a location for a
#	static version of the Tk-Table library.  If a value is
#	specified, assume it is good and define the cpp macro
#	STATIC_TABLE.
#
#	If a value is not specified, look for libTktable.a; if we
#	find it, assume it works and define the cpp macro
#	STATIC_TABLE.  If we don't find it, assume ASCEND will be
#	able to dynamically load it at run time and tell the user
#	about our assumption.
#--------------------------------------------------------------------
#
#  a list of directories to search for the Tcl/Tk libraries
asc_tcl_library_dirs="
    /usr/local/lib/ascend/lib
    $prefix/lib:$exec_prefix/lib
    $ascpwd/tcl8.0
    $ascpwd/tcl8.0/unix
    $ascpwd/tk8.0
    $ascpwd/tk8.0/unix
    $ascpwd/ascend4/lib
    /lib
    /usr/lib
    /usr/local/lib
    /usr/contributed/lib
    /afs/cs/project/ascend/depot/@sys/lib
"
#  a list of directories to search for the Tcl/Tk include files
asc_tcl_include_dirs="
    /usr/local/lib/ascend/include
    $prefix/include
    $fullpathsrcdir/tcl8.0
    $fullpathsrcdir/tcl8.0/generic
    $fullpathsrcdir/tk8.0
    $fullpathsrcdir/tk8.0/generic
    $fullpathsrcdir/ascend4/include
    $ascpwd/ascend4/include
    /usr/include
    /usr/local/include
    /usr/contributed/include
    /afs/cs/project/ascend/depot/common/include
"
#  a list of directories to search for the TkTable library
asc_tk_table_dirs="
    /usr/local/lib/ascend/lib/Tktable
    $prefix/lib/Tktable
    $exec_prefix/lib/Tktable
    $ascpwd/tkTable1.80
    $ascpwd/ascend4/lib
    $ascpwd/ascend4/lib/Tktable
    /afs/cs/project/ascend/depot/@sys/lib/Tktable
"
#  see if the user gave us the location of the Tcl8.0
#  library and/or header file
#
# Check whether --with-tcl or --without-tcl was given.
if test "${with_tcl+set}" = set; then
  withval="$with_tcl"
  :
else
  with_tcl=yes
fi


case "$with_tcl" in
    no)
	#  User specified --without-tcl; this makes no sense,
	#  print a warning and search for it ourselves
        echo "configure: warning: Bad option '--without-tcl'
	ASCEND must be compiled with Tcl8.0." 1>&2
	with_tcllib=_searching
	with_tclhdr=_searching
        ;;
    yes|,|"")
	#  User didn't give the option or didn't give useful
	#  information, search for it ourselves
	with_tcllib=_searching
	with_tclhdr=_searching
	;;
    ,*)
	#  Only the header was specified.
	with_tcllib=_searching
	TCL_HDR=`echo $with_tcl | sed 's/^,//'`
        ;;
    *,?*)
	#  Both the library and the header were specified
        TCL_LIB=`echo $with_tcl | sed 's/,.*$//'`
	TCL_HDR=`echo $with_tcl | sed 's/^.*,//'`
        ;;
    *)
	#  Only the library was specified
        TCL_LIB=`echo $with_tcl | sed 's/,$//'`
	with_tclhdr=_searching
        ;;
esac

#  try to find a static version of the Tcl8.0 library
#
if test "X$with_tcllib" = X_searching ; then
    for ac_prog in libtcl8.0.a libtcl80.a
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:3251: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_TCL_LIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TCL_LIB" in
  /*)
  ac_cv_path_TCL_LIB="$TCL_LIB" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_TCL_LIB="$TCL_LIB" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_tcl_library_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_TCL_LIB="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TCL_LIB="$ac_cv_path_TCL_LIB"
if test -n "$TCL_LIB"; then
  echo "$ac_t""$TCL_LIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$TCL_LIB" && break
done

    if test -z "$TCL_LIB" ; then
        TCL_LIB=_searching
    fi
else
    echo "$ac_t""checking for tcl library... $TCL_LIB" 1>&6
fi

#  verify the TCL_LIB
if test ! "X$TCL_LIB" = X_searching ; then
    echo $ac_n "checking whether $TCL_LIB is for Tcl8.0""... $ac_c" 1>&6
echo "configure:3296: checking whether $TCL_LIB is for Tcl8.0" >&5
    asc_libs_orig=$LIBS
    LIBS="$TCL_LIB $X11_LIBRARIES $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
    cat > conftest.$ac_ext <<EOF
#line 3300 "configure"
#include "confdefs.h"

int main() {
TclCompileCatchCmd()
; return 0; }
EOF
if { (eval echo configure:3307: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  :
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  TCL_LIB=_searching
fi
rm -f conftest*;
    if test "X$TCL_LIB" = X_searching ; then
        echo "$ac_t""no" 1>&6
    else
        echo "$ac_t""yes" 1>&6
    fi
    LIBS=$asc_libs_orig
fi

#  see if the default LPATH can find the Tcl8.0 library
#
if test "X$TCL_LIB" = X_searching ; then
    echo $ac_n "checking for TclCompileCatchCmd in -ltcl8.0""... $ac_c" 1>&6
echo "configure:3328: checking for TclCompileCatchCmd in -ltcl8.0" >&5
ac_lib_var=`echo tcl8.0'_'TclCompileCatchCmd | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltcl8.0 $X11_LIBRARIES $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3336 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char TclCompileCatchCmd();

int main() {
TclCompileCatchCmd()
; return 0; }
EOF
if { (eval echo configure:3347: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TCL_LIB="-ltcl8.0" 
else
  echo "$ac_t""no" 1>&6
fi

fi
if test "X$TCL_LIB" = X_searching ; then
    echo $ac_n "checking for TclCompileCatchCmd in -ltcl80""... $ac_c" 1>&6
echo "configure:3370: checking for TclCompileCatchCmd in -ltcl80" >&5
ac_lib_var=`echo tcl80'_'TclCompileCatchCmd | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltcl80 $X11_LIBRARIES $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3378 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char TclCompileCatchCmd();

int main() {
TclCompileCatchCmd()
; return 0; }
EOF
if { (eval echo configure:3389: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TCL_LIB="-ltcl80" 
else
  echo "$ac_t""no" 1>&6
fi

fi
if test "X$TCL_LIB" = X_searching ; then
    echo $ac_n "checking for TclCompileCatchCmd in -ltcl""... $ac_c" 1>&6
echo "configure:3412: checking for TclCompileCatchCmd in -ltcl" >&5
ac_lib_var=`echo tcl'_'TclCompileCatchCmd | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltcl $X11_LIBRARIES $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3420 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char TclCompileCatchCmd();

int main() {
TclCompileCatchCmd()
; return 0; }
EOF
if { (eval echo configure:3431: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TCL_LIB="-ltcl" 
else
  echo "$ac_t""no" 1>&6
fi

fi

#  give up searching for the Tcl8.0 library
#
if test "X$TCL_LIB" = X_searching ; then
    { echo "configure: error: Cannot find a compatiable Tcl library.
	You must build and install Tcl version 8.0 or newer before you
	can build ASCEND.  If you have installed the correct version
	of Tcl, run configure again with the argument:
		--with-tcl=LIBRARY,HEADER
	where LIBRARY and HEADER are the full paths to the Tcl8.0
	library file and header file, respectively." 1>&2; exit 1; }
fi

#  see if the user gave us the location of the Tcl8.0 header file
#
if test ! "X$with_tclhdr" = X_searching ; then
    if test ! -f "$TCL_HDR" ; then
	echo "configure: warning: user specified Tcl header file, $TCL_HDR, does not exist" 1>&2
        with_tclhdr=_searching
        TCL_HDR=''
    fi
fi
if test "X$with_tclhdr" = X_searching ; then
    # Extract the first word of "tcl.h", so it can be a program name with args.
set dummy tcl.h; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:3478: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_TCL_HDR'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TCL_HDR" in
  /*)
  ac_cv_path_TCL_HDR="$TCL_HDR" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_TCL_HDR="$TCL_HDR" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_tcl_include_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_TCL_HDR="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TCL_HDR="$ac_cv_path_TCL_HDR"
if test -n "$TCL_HDR"; then
  echo "$ac_t""$TCL_HDR" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

    if test -z "$TCL_HDR" ; then
        cat > conftest.$ac_ext <<EOF
#line 3512 "configure"
#include "confdefs.h"
#include <tcl.h>
EOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "TCL_MAJOR_VERSION.*8" >/dev/null 2>&1; then
  rm -rf conftest*
  TCL_HDR='tcl.h'
fi
rm -f conftest*

    fi
else
    echo "$ac_t""checking for tcl header... $TCL_HDR" 1>&6
fi
if test -f "$TCL_HDR" ; then
    echo $ac_n "checking whether $TCL_HDR is for version 8""... $ac_c" 1>&6
echo "configure:3529: checking whether $TCL_HDR is for version 8" >&5
    echo 'grep TCL_MAJOR_VERSION "$TCL_HDR" 2>&5' 1>&5
    grep_tcl_h=`grep TCL_MAJOR_VERSION "$TCL_HDR" 2>&5`
    echo $grep_tcl_h 1>&5
    case "$grep_tcl_h" in
        *8)
	    echo "$ac_t""yes" 1>&6
            ;;
        *)
	    echo "$ac_t""no" 1>&6
	    TCL_HDR=
            ;;
    esac
fi
if test -z "$TCL_HDR" ; then
    { echo "configure: error: Cannot find a compatiable Tcl header file.
	You must build and install Tcl version 8.0 or newer before you
	can build ASCEND.  If you have installed the correct version
	of Tcl, run configure again with the argument:
		--with-tcl=LIBRARY,HEADER
	where LIBRARY and HEADER are the full paths to the Tcl8.0
	library file and header file, respectively." 1>&2; exit 1; }
fi
TCL_HDR=`echo $TCL_HDR | sed 's,tcl\.h$,,'`
if test -n "$TCL_HDR" ; then
    TCL_HDR="-I$TCL_HDR"
fi


######  REPEAT FOR TK
#
#  see if the user gave us the location of the Tk8.0
#  library and/or header file
#
# Check whether --with-tk or --without-tk was given.
if test "${with_tk+set}" = set; then
  withval="$with_tk"
  :
else
  with_tk=yes
fi


case "$with_tk" in
    no)
	#  User specified --without-tk; this makes no sense,
	#  print a warning and search for it ourselves
        echo "configure: warning: Bad option '--without-tk'
	ASCEND must be compiled with Tk8.0." 1>&2
	with_tklib=_searching
	with_tkhdr=_searching
        ;;
    yes|,|"")
	#  User didn't give the option or didn't give useful
	#  information, search for it ourselves
	with_tklib=_searching
	with_tkhdr=_searching
	;;
    ,*)
	#  Only the header was specified.
	with_tklib=_searching
	TK_HDR=`echo $with_tk | sed 's/^,//'`
        ;;
    *,?*)
	#  Both the library and the header were specified
        TK_LIB=`echo $with_tk | sed 's/,.*$//'`
	TK_HDR=`echo $with_tk | sed 's/^.*,//'`
        ;;
    *)
	#  Only the library was specified
        TK_LIB=`echo $with_tk | sed 's/,$//'`
	with_tkhdr=_searching
        ;;
esac

#  try to find a static version of the Tk8.0 library
#
if test "X$with_tklib" = X_searching ; then
    for ac_prog in libtk8.0.a libtk80.a libtk.a
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:3612: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_TK_LIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TK_LIB" in
  /*)
  ac_cv_path_TK_LIB="$TK_LIB" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_TK_LIB="$TK_LIB" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_tcl_library_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_TK_LIB="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TK_LIB="$ac_cv_path_TK_LIB"
if test -n "$TK_LIB"; then
  echo "$ac_t""$TK_LIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$TK_LIB" && break
done

    if test -z "TK_LIB" ; then
        TK_LIB=_searching
    fi
else
    echo "$ac_t""checking for tk library... $TK_LIB" 1>&6
fi

#  verify the TK_LIB
#
if test ! "X$TK_LIB" = X_searching ; then
    echo $ac_n "checking whether $TK_LIB is for Tk8.0""... $ac_c" 1>&6
echo "configure:3658: checking whether $TK_LIB is for Tk8.0" >&5
    asc_libs_orig=$LIBS
    LIBS="$TK_LIB $TCL_LIB $X11_LIBRARIES -lX11 $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
    cat > conftest.$ac_ext <<EOF
#line 3662 "configure"
#include "confdefs.h"

int main() {
Tk_NameOfFont()
; return 0; }
EOF
if { (eval echo configure:3669: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  :
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  TK_LIB=_searching
fi
rm -f conftest*;
    if test "X$TK_LIB" = X_searching ; then
        echo "$ac_t""no" 1>&6
    else
        echo "$ac_t""yes" 1>&6
    fi
    LIBS=$asc_libs_orig
fi

#  see if the default LPATH can find the Tk8.0 library
#
if test "X$TK_LIB" = X_searching ; then
    echo "$ac_t""checking for a dynamically loaded Tk8.0 library" 1>&6
    echo $ac_n "checking for Tk_NameOfFont in -ltk8.0""... $ac_c" 1>&6
echo "configure:3691: checking for Tk_NameOfFont in -ltk8.0" >&5
ac_lib_var=`echo tk8.0'_'Tk_NameOfFont | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltk8.0 $TCL_LIB $X11_LIBRARIES -lX11 $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3699 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char Tk_NameOfFont();

int main() {
Tk_NameOfFont()
; return 0; }
EOF
if { (eval echo configure:3710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TK_LIB="-ltk8.0" 
else
  echo "$ac_t""no" 1>&6
fi

fi
if test "X$TK_LIB" = X_searching ; then
    echo $ac_n "checking for Tk_NameOfFont in -ltk80""... $ac_c" 1>&6
echo "configure:3733: checking for Tk_NameOfFont in -ltk80" >&5
ac_lib_var=`echo tk80'_'Tk_NameOfFont | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltk80 $TCL_LIB $X11_LIBRARIES -lX11 $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3741 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char Tk_NameOfFont();

int main() {
Tk_NameOfFont()
; return 0; }
EOF
if { (eval echo configure:3752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TK_LIB="-ltk80" 
else
  echo "$ac_t""no" 1>&6
fi

fi
if test "X$TK_LIB" = X_searching ; then
    echo $ac_n "checking for Tk_NameOfFont in -ltk""... $ac_c" 1>&6
echo "configure:3775: checking for Tk_NameOfFont in -ltk" >&5
ac_lib_var=`echo tk'_'Tk_NameOfFont | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltk $TCL_LIB $X11_LIBRARIES -lX11 $X11_EXTRA_LIBS $DL_LIBS $MATH_LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 3783 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char Tk_NameOfFont();

int main() {
Tk_NameOfFont()
; return 0; }
EOF
if { (eval echo configure:3794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  TK_LIB="-ltk" 
else
  echo "$ac_t""no" 1>&6
fi

fi

#  give up searching for the Tk8.0 library
#
if test "X$TK_LIB" = X_searching ; then
    { echo "configure: error: Cannot find a compatiable Tk library.
	You must build and install Tk version 8.0 or newer before you
	can build ASCEND.  If you have installed the correct version
	of Tk, run configure again with the argument:
		--with-tk=LIBRARY,HEADER
	where LIBRARY and HEADER are the full paths to the Tk8.0
	library file and header file, respectively." 1>&2; exit 1; }
fi

#  see if the user gave us the location of the Tk8.0 header file
#
if test ! "X$with_tkhdr" = X_searching ; then
    if test ! -f "$TK_HDR" ; then
	echo "configure: warning: user specified Tk header file, $TK_HDR, does not exist" 1>&2
        with_tkhdr=_searching
        TK_HDR=''
    fi
fi
if test "X$with_tkhdr" = X_searching ; then
    # Extract the first word of "tk.h", so it can be a program name with args.
set dummy tk.h; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:3841: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_TK_HDR'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TK_HDR" in
  /*)
  ac_cv_path_TK_HDR="$TK_HDR" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_TK_HDR="$TK_HDR" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_tcl_include_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_TK_HDR="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TK_HDR="$ac_cv_path_TK_HDR"
if test -n "$TK_HDR"; then
  echo "$ac_t""$TK_HDR" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

    if test -z "$TK_HDR" ; then
        cat > conftest.$ac_ext <<EOF
#line 3875 "configure"
#include "confdefs.h"
#include <tk.h>
EOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "TK_MAJOR_VERSION.*8" >/dev/null 2>&1; then
  rm -rf conftest*
  TK_HDR='tk.h'
fi
rm -f conftest*

    fi
else
    echo "$ac_t""checking for tk header... $TK_HDR" 1>&6
fi
if test -f "$TK_HDR" ; then
    echo $ac_n "checking whether $TK_HDR is for version 8""... $ac_c" 1>&6
echo "configure:3892: checking whether $TK_HDR is for version 8" >&5
    echo 'grep TK_MAJOR_VERSION "$TK_HDR" 2>&5' 1>&5
    grep_tk_h=`grep TK_MAJOR_VERSION "$TK_HDR" 2>&5`
    echo $grep_tk_h 1>&5
    case "$grep_tk_h" in
        *8)
	    echo "$ac_t""yes" 1>&6
            ;;
        *)
	    echo "$ac_t""no" 1>&6
            TK_HDR=
            ;;
    esac
fi
if test -z "$TK_HDR" ; then
    { echo "configure: error: Cannot find a compatiable Tk header file.
	You must build and install Tk version 8.0 or newer before you
	can build ASCEND.  If you have installed the correct version
	of Tk, run configure again with the argument:
		--with-tk=LIBRARY,HEADER
	where LIBRARY and HEADER are the full paths to the Tk8.0
	library file and header file, respectively." 1>&2; exit 1; }
fi
TK_HDR=`echo $TK_HDR | sed 's,tk\.h$,,'`
if test -n "$TK_HDR" ; then
    TK_HDR="-I$TK_HDR"
    if test "X$TCL_HDR" = "X$TK_HDR" ; then
        TK_HDR=
    fi
fi


# Check whether --with-tktable or --without-tktable was given.
if test "${with_tktable+set}" = set; then
  withval="$with_tktable"
  :
fi

case "$with_tktable" in
    yes|no|"")
        # search for the table
        # Extract the first word of "libTktable.a", so it can be a program name with args.
set dummy libTktable.a; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:3936: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_TKTABLE_LIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TKTABLE_LIB" in
  /*)
  ac_cv_path_TKTABLE_LIB="$TKTABLE_LIB" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_TKTABLE_LIB="$TKTABLE_LIB" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_tk_table_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_TKTABLE_LIB="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TKTABLE_LIB="$ac_cv_path_TKTABLE_LIB"
if test -n "$TKTABLE_LIB"; then
  echo "$ac_t""$TKTABLE_LIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

        ;;
    *)
        # use the user's value
        TKTABLE_LIB="$with_tktable"
        ;;
esac
if test -n "$TKTABLE_LIB" ; then
    HAVE_TKTABLE='-DSTATIC_TKTABLE'
else
    echo "$ac_t""Assuming Tktable will be dynamically linked into ASCEND" 1>&6
fi

# Check whether --with-wish or --without-wish was given.
if test "${with_wish+set}" = set; then
  withval="$with_wish"
  :
else
  with_wish=no
fi

case "$with_wish" in
    yes|no|"")
        echo "$ac_t""--with-wish not specified.
        Setting env vars TCL_LIBRARY, TK_LIBRARY may be needed to run." 1>&6
        ;;
    *)
        echo $ac_n "checking wish for tcl_library,tklibrary""... $ac_c" 1>&6
echo "configure:3995: checking wish for tcl_library,tklibrary" >&5
        ASC_TK_LIBRARY=`config/wishvar tk_library $with_wish`
        ASC_TCL_LIBRARY=`config/wishvar tcl_library $with_wish`
	echo "$ac_t"" $ASC_TCL_LIBRARY , $ASC_TK_LIBRARY" 1>&6
        ;;
esac


#--------------------------------------------------------------------
#	FORTRAN
#
#	ASCEND uses the LSOD integrator and is capable of working
#	with CONOPT and with MINOS.  These libraries are written in
#	Fortran; to use them, configure needs to find a Fortran
#	compiler and the necessary Fortran libraries (e.g.,
#	libF77.a).  LSOD, CONOPT, and MINOS also require the BLAS and
#	LINPACK libraries to avoid undefined symbols at link time.
#
#	The builder can specify the location of
#	* the Fortran compiler and libraries using
#	  --with-fortran=<compiler>,<libraries>
#	* the BLAS library using
#	  --with-blas=<blas-library>
#	* the LINPACK library using
#	  --with-linpack=<linpack-library>
#	* the LSOD library using
#	  --with-blas=<lsod-library>
#	* the CONOPT library using
#	  --with-conopt=<conopt-library>
#	* the MINOS library using
#	  --with-minos=<minos-library>   <===currently disabled
#	The builder can disable some parts of the fortran build using
#	the --without-<package> configure option.
#
#	If the user does not specify the locations of the compiler
#	and the libraries and does not disable them, configure
#	attempts to find them.
#
#	Building with LSOD, CONOPT, and/or MINOS is further
#	complicated by the dependencies between these libraries and
#	the BLAS and LINPACK libraries.
#
#	If we cannot find a Fortran compiler, we disable all Fortran
#	code (LSOD, CONOPT, and MINOS).  Otherwise, look for the
#	Fortran libraries (e.g., libF77.a) based on the type of
#	machine we are compiling on.
#
#	If Fortran is enabled, we need to find a compiled BLAS
#	library or source code.  Check for the machine's libblas.a
#	and ASCEND's libascblas.a; if those fail, check for the
#	libascblas.a source code; if that fails, we disable all
#	Fortran (LSOD, CONOPT, MINOS).
#
#	If Fortran is enabled, we need to find a compiled LINPACK
#	library or source code.  Check for the machine's liblpak.a
#	and ASCEND's libasclpak.a; if those fail, check for the
#	libasclpak.a source code; if that fails, we disable all
#	Fortran (LSOD, CONOPT, MINOS).
#
#	If Fortran is enabled, we try to find a compiled LSOD library
#	or source code.  Check for a libinteg.a; if that fails, check
#	for the libinteg.a source code; if that fails, we disable
#	LSOD.  If we find LSOD, define STATIC_LSOD.
#
#	If Fortran is enabled, we try to find a compiled OPTSQP
#	library or source code.  Check for a librsqp.a; if that fails,
#	check for the librsqp.a source code; if that fails, we disable
#	OPTSQP.  If we find RSQP, define STATIC_OPTSQP.
#
#	If Fortran is enabled, we try to find a compiled CONOPT
#	library.  Check for a libconsub.a; if that fails, we disable
#	CONOPT.  If we find CONOPT, define STATIC_CONOPT; if not,
#	tell the user where to find CONOPT using the contact
#	information from the nonlinear programming FAQ:
#    http://www.mcs.anl.gov/home/otc/Guide/faq/nonlinear-programming-faq.html
#
#	If Fortran is enabled, we try to find a compiled MINOS
#	library or source code.  Check for a libminos54.a; if that
#	fails, check for the libminos54.a source code; if that fails,
#	we disable MINOS.  If we find MINOS, define STATIC_MINOS; if
#	not, tell the user where to find MINOS using the contact
#	information from the nonlinear programming FAQ:
#    http://www.mcs.anl.gov/home/otc/Guide/faq/nonlinear-programming-faq.html
#--------------------------------------------------------------------
#
#  the list of directories to search for the fortran compiler
asc_f77_prog_dirs="$PATH:/usr/lang:/opt/SUNWspro/bin"
#
#  the list of directories to search for the required fortran libraries
asc_f77_support_dirs="
    /lib
    /usr/lib
    /usr/local/lib
    /usr/contributed/lib
    /usr/local/lib/ascend/lib
    $ascpwd/blas
    $ascpwd/linpack
    $ascpwd/lsod
    $ascpwd/conopt
    $ascpwd/rsqp
    $ascpwd/minos
    $ascpwd/ascend4/archive
    /afs/cs/project/ascend/depot/@sys/lib
    /afs/cs/project/ascend/depot/build/obj/conopt
"
#
# Check whether --with-fortran or --without-fortran was given.
if test "${with_fortran+set}" = set; then
  withval="$with_fortran"
  :
else
  with_fortran=yes
fi

case "$with_fortran" in
    no)
	#  The user disabled all fortran using
	#  the --without-fortran option.
        F77=
        F77LIBS=
        with_f77=no
	with_f77libs=no
        ;;
    yes|,|"")
	#  The user didn't pass in the --with-fortran option
	#  or didn't give us any useful information.  We do
	#  the search ourselves.
        with_f77=_searching
	with_f77libs=_searching
        ;;
    ,*)
	#  The user passed in the libraries, search for the
	#  compiler ourselves.
	with_f77=_searching
	F77LIBS=`echo $with_fortran | sed 's/^,//'`
        echo "user gave F77LIBS=$F77LIBS"
        ;;
    *,?*)
	#  The user passed in both the compiler and the
	#  libraries.
	F77=`echo $with_fortran | sed s'/,.*$//'`
	F77LIBS=`echo $with_fortran | sed 's/^.*,//'`
        echo "user gave F77=$F77"
        echo "user gave F77LIBS=$F77LIBS"
	;;
    *)
	#  The user passed in the compiler; search for the
	#  libraries ourselves.
	F77=`echo $with_fortran | sed s'/,$//'`
	with_f77libs=_searching
        echo "user gave F77=$F77"
	;;
esac

if test "X$with_f77" = X_searching ; then
    #  Search for the fortran compiler; print a warning if we can't
    #  find it and disable all fortran.
    for ac_prog in f77 xlf g77
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:4157: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_F77'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$F77" in
  /*)
  ac_cv_path_F77="$F77" # Let the user override the test with a path.
  ;;
  ?:/*)			 
  ac_cv_path_F77="$F77" # Let the user override the test with a dos path.
  ;;
  *)
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$asc_f77_prog_dirs"
  for ac_dir in $ac_dummy; do 
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_path_F77="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
F77="$ac_cv_path_F77"
if test -n "$F77"; then
  echo "$ac_t""$F77" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$F77" && break
done

    if test -z "$F77" ; then
        with_fortran=no
        with_f77libs=no
        echo "configure: warning: Cannot find your Fortran compiler.  Building ASCEND
	without integration, MINOS, and CONOPT support.  To bulid ASCEND with
	Fortran support, run configure with the option
		--with-fortran=F77,F77LIBS
	where F77 is the full path to your Fortran compiler and F77LIBS are
	its related libraries" 1>&2
    fi
fi

if test "X$with_f77libs" = X_searching ; then
    #  We found a compiler, now search for the fortran libraries
    #  based on the system type.
    echo "$ac_t""checking for fortran libraries based on system type" 1>&6
    case "$host" in
        alpha-dec-osf*)
            echo $ac_n "checking for for_lle in -lfor""... $ac_c" 1>&6
echo "configure:4211: checking for for_lle in -lfor" >&5
ac_lib_var=`echo for'_'for_lle | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lfor $F77LIBS $LIBS"
cat > conftest.$ac_ext <<EOF
#line 4219 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
/* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
char for_lle();

int main() {
for_lle()
; return 0; }
EOF
if { (eval echo configure:4230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6