#!/bin/sh 
#****************************************************************************
#*			TAU Portable Profiling Package			   **
#*			http://www.cs.uoregon.edu/research/tau	           **
#****************************************************************************
#*    Copyright 1997-2003						   **
#*    Department of Computer and Information Science, University of Oregon **
#*    Advanced Computing Laboratory, Los Alamos National Laboratory        **
#*    Research Center Juelich, ZAM Germany                                 **
#****************************************************************************
#*	
#*  Permission to use, copy, modify, and distribute this software and its
#*  documentation for any purpose and without fee is hereby granted,
#*  provided that the above copyright notice appear in all copies and that
#*  both that copyright notice and this permission notice appear in
#*  supporting documentation, and that the name of University of Oregon (UO)
#*  and Los Alamos National Laboratory (LANL) not be
#*  used in advertising or publicity pertaining to distribution of
#*  the software without specific, written prior permission.  The
#*  University of Oregon and LANL makes no representations about the
#*  suitability of this software for any purpose.  It is provided "as is"
#*  without express or implied warranty.
#*
#*  THE UNIVERSITY OF OREGON AND LANL DISCLAIMS ALL WARRANTIES WITH REGARD TO
#*  THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
#*  FITNESS, IN NO EVENT SHALL THE UNIVERSITY OF OREGON OR LANL BE LIABLE FOR
#*  ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
#*  RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
#*  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
#*  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#****************************************************************************
#****************************************************************************
#*  Authors :    Sameer Shende (sameer@cs.uoregon.edu) (UO, LANL)
#*		 Peter Beckman, Steve Karmesin (ACL, LANL)
#*		 Kathleen Lindlan, Ariya Lohavanichbutr (UO)		
#*  Principal Investigators : 
#*		 Janice Cuny, Allen Malony (UO)
#*  TAU project was developed by Bernd Mohr, Lars Hansen, Kurt Windisch, 
#*  Darryl Brown, et. al. and directed by Allen Malony at University of Oregon.
#*  The TAU Portable Profiling Package uses part of TAU.
#****************************************************************************

# Configure script for TAU
#   Sameer Shende 11/12/97 for TAU Portable Profiling Package
#   Kurt Windisch 12/9/96
# Based on the configure script for Sage/pC++ by:
#   Pete Beckman 9/6/93
#   Lars Thomas Hansen 2/27/95 (Solaris fix)
#
# New options for TAU/HPC++:
#   -pcxx <sageroot directory>
#   -sage2 <edg-sage2 directory>
#   -pstl <pstl directory>
#   -hpnx <hpc++lib/nexus directory>
#
# Options for Configure :
#   ./configure -cc=<C Compiler> -c++=<C++ Compiler> -useropt=<User options>
#   -gnu  -PROFILE -TRACE  
# 
# Recommended configuration for testing on SGI:
#   ./configure -useropt=-64 -PROFILE
# For testing with KAI's KCC compiler 
#   ./configure -cc=cc -c++=KCC -PROFILE 
# If your C++ compiler does not support STL, you could use something like:
#   ./configure -useropt='-I/usr/local/packages/SGI-STL/' 
# after downloading the Standard Templates Library.
# This configure script has been tested on SGI, LINUX, SOLARIS2 and HP
#

# Currently this configure file modifies Makefiles within Sage to the
# following architecture names (see ./utils/archfind) :
#   ptx             a Sequent Symmetry running DYNIX/ptx (386/486 based)
#   symmetry        a Sequent Symmetry running DYNIX 3 (386/486 based)
#   hp9000s700      an HP 9000, series 700, running hpux
#   hp9000s800      an HP 9000, series 800, running hpux
#   decstation      a DecStation XXXX
#   rs6000	    an IBM RS6000 running AIX
#   sun4            a Sun Microsystems series 4 workstation (SPARC based)
#   solaris2	    a Sun Workstation running SVR4 Solaris 
#   next            a NeXT computer
#   sgi4k           an SGI R4K-based machine
#   sgi8k           an SGI R8K-based (Power) machine
#   cm5             a Thinking Machines Corporation CM-5
#   paragon         an Intel paragon
#   tc2000          a BBN Butterfly tc2000
#   ksr1            a Kendall Square KSR1
#   unknown         default setup, no machine selected (original)
#   alpha           an HP/Compaq Alpha running OSF/1 Tru64
#   c90             a Cray C90 running Unicos
#   t3d             a Cray T3D (Alpha-based) computer array
#   i386_linux 	    an Intel ix86 PC running LINUX
#   default         Returns all files to "distribution" snapshot. 
#                      This MUST be done before any CVS commands are called
#
# The tkfile may contain definitions of environment variables in the
# style of /bin/sh, e.g. (these are the defaults)
#
#   tcltkheader="-I/usr/local/include"
#   tcltklib="-L/usr/local/lib -ltk4.0 -ltcl7.4"
#   x11header="-I/usr/include"
#   x11lib="-L/usr/lib -lX11"
#
# If a file name is given, it must contain all these definitions.
# No checking is done to ensure that it does so.

default=false

for arg in "$@"; do
  case $arg in
  default)
    default=true
    ;;	
  -help)
    echo "TAU Configuration Utility "
    echo "***********************************************************************"
    echo "Usage: configure [OPTIONS]"
    echo "  where [OPTIONS] are:"
    echo ""
    echo "Compiler Options:"
    echo "-c++=<compiler>  ............................ specify the C++ compiler."
    echo "          options [CC|KCC|g++|*xlC*|cxx|pgCC|FCC|guidec++|aCC|c++|ecpc|"
    echo "                                      icpc|scgcc|scpathCC|pathCC|orCC]."
    echo "-cc=<compiler> ................................ specify the C compiler."
    echo "          options [cc|gcc|scgcc|KCC|pgcc|guidec|*xlc*|ecc|pathcc|orcc]."
    echo "-fortran=<compiler> ..................... specify the Fortran compiler."
    echo "   options    [gnu|sgi|ibm|ibm64|hp|cray|pgi|absoft|fujitsu|sun|compaq|"
    echo "       g95|open64|kai|nec|hitachi|intel|absoft|lahey|nagware|pathscale]"
    echo "-pdt=<dir> ........ Specify location of PDT (Program Database Toolkit)."
    echo "-pdt_c++=<compiler>  ............ specify a different PDT C++ compiler."
    echo "          options [CC|KCC|g++|*xlC*|cxx|pgCC|FCC|guidec++|aCC|c++|ecpc|"
    echo "                                               icpc|scgcc|pathCC|orCC]."
    echo "-useropt='<parameters>' ... optional arguments to compilers (e.g. -O3)."
    echo ""
    echo "Installation Options:"
    echo "-prefix=<dir> ................ Specify a target installation directory."
    echo "-exec-prefix=<arch> .......... Specify a target architecture directory."
    echo "-arch=<architecture> ................... Specify a target architecture."
    echo "       options          [xt3|craycnl|bgp|bgl|ibm64|ibm64linux|sunx86_64"
    echo "                               |solaris2-64|mips32|sgin32|sgi64|sgio32]"
    echo ""
    echo "MPI Options:"
    echo "-mpi .......................... Specify use of TAU MPI wrapper library."
    echo "-mpiinc=<dir> ............. Specify location of MPI include dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-mpilib=<dir> ............. Specify location of MPI library dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-mpilibrary=<library> ................ Specify a different MPI library."
    echo "            e.g., -mpilibrary=-lmpi_r                                  "
    echo ""
    echo "OpenMP Options:"
    echo "-openmp ........................................... Use OpenMP threads."
    echo "-opari ..................................................... Use Opari."
    echo "-opari_region ......... Report performance data for all OpenMP regions."
    echo "-opari_construct ... Report performance data for all OpenMP constructs."
    echo ""
    echo "SHMEM Options:"
    echo "-shmem ...................... Specify use of TAU SHMEM wrapper library."
    echo "-shmeminc=<dir> ......... Specify location of SHMEM include dir and use"
    echo "                         the TAU SHMEM Profiling and Tracing Interface."
    echo "-shmemlib=<dir> ......... Specify location of SHMEM library dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-shmemlibrary=<library> ............ Specify a different SHMEM library."
    echo "            e.g., -shmemlibrary=-lsmac                                 "
    echo ""
    echo "Other Options:"
    echo "-iowrapper .................................... Build POSIX IO Wrapper."
    echo "-pthread .................................. Use pthread thread package."
    echo "-papithread .................................. Use PAPI thread package."
    echo "-papi=<dir> ............... Specify location of PAPI (Performance API)."
    echo "-jdk=<dir>  Build a library for profiling Java code with specified jdk."
    echo "-vtf=<dir> ......... Specify location of VTF3 Trace Generation Package."
    echo "-otf=<dir> ....... Specify location of Open Trace Format (OTF) Package."
    echo "-slog2 ........ Specify use of TAU internal SLOG2 SDK/Jumpshot Package."
    echo "-nocomm  ........ Disable tracking communication events in MPI library."
    echo "-epilog=<dir>  ............ Specify location of EPILOG Tracing package."
    echo "-epiloglib=<dir> ........... Specify full path to EPILOG lib directory."
    echo "-epilogbin=<dir> ........... Specify full path to EPILOG bin directory."
    echo "-epiloginc=<dir> ....... Specify full path to EPILOG include directory."
    echo "-vampirtrace=<dir>  .. Specify location of VampirTrace Tracing package."
    echo "-pythoninc=<dir> ........ Specify location of Python include directory."
    echo "-pythonlib=<dir> ............ Specify location of Python lib directory."
    echo "-tag=<unique name> ........ Specify a tag to identify the installation."
    echo "-TRACE ..................................... Generate TAU event traces."
    echo "-MPITRACE ... Generate event traces for MPI events and their ancestors."
    echo "-PROFILE ............ Generate profiles (summary statistics) (default)."
    echo "-PROFILECALLPATH ......................... Generate call path profiles."
    echo "-PROFILEPARAM .... Generate profiles with parameter mapped event data ."
    echo "-PROFILEPHASE .......................... Generate phase based profiles."
    echo "-PROFILESTATS .................. Enable standard deviation calculation."
    echo "-DEPTHLIMIT ........... Disable instrumentation beyond a certain depth."
    echo "-PROFILEMEMORY .. Track heap memory utilization at each function entry."
    echo "-PROFILEHEADROOM .. Track memory free (or headroom) at each func entry."
    echo "-MULTIPLECOUNTERS ............ Use multiple hardware counters and time."
    echo "-COMPENSATE ........ Compensate for profiling measurement perturbation."
    echo "-BGLTIMERS .... Use fast low-overhead timers on IBM BlueGene/L systems."
    echo "-BGPTIMERS .... Use fast low-overhead timers on IBM BlueGene/P systems."
    echo "-SGITIMERS .......... Use fast nanosecond timers on SGI R10000 systems."
    echo "-CRAYTIMERS ............ Use fast nanosecond timers on Cray X1 systems."
    echo "-LINUXTIMERS ......... Use low overhead TSC Counter for wallclock time."
    echo "-CPUTIME .......... Use usertime+system time instead of wallclock time."
    echo "-PAPIWALLCLOCK ........ Use PAPI to access wallclock time. Needs -papi."
    echo "-PAPIVIRTUAL   .......... Use PAPI for virtual (user) time calculation."
    echo "-INTELCXXLIBICC   ......... Use Intel -cxxlib-icc option for compiling."
    echo "-noex .................. Use no exceptions while compiling the library."
    echo "-DISABLESHARED .................. Do not build libTAU.so shared object."
    echo "-help ...................................... display this help message."
    echo "-fullhelp .............................. display the full help message."
    echo ""
    echo "More advanced options are available, use -fullhelp to see them."
    exit
    ;;

  -fullhelp)
    echo "TAU Configuration Utility "
    echo "***********************************************************************"
    echo "Usage: configure [OPTIONS]"
    echo "  where [OPTIONS] are:"
    echo "-c++=<compiler>  ............................ specify the C++ compiler."
    echo "          options [CC|KCC|g++|*xlC*|cxx|pgCC|FCC|guidec++|aCC|c++|ecpc|"
    echo "                                      icpc|scgcc|scpathCC|pathCC|orCC]."
    echo "-cc=<compiler> ................................ specify the C compiler."
    echo "          options [cc|gcc|scgcc|KCC|pgcc|guidec|*xlc*|ecc|pathcc|orcc]."
    echo "-pdt_c++=<compiler>  ............ specify a different PDT C++ compiler."
    echo "         options [CC|KCC|g++|*xlC*|cxx|pgCC|FCC|guidec++|aCC|c++|ecpc|"
    echo "                                               icpc|scgcc|pathCC|orCC]."
    echo "-pdtcompdir=<compilerdir> . specify a different PDT compiler directory."
    echo "-pdtarchdir=<archdir> . specify a different PDT architecture directory."
    echo "-fortran=<compiler> ..................... specify the Fortran compiler."
    echo "   options    [gnu|sgi|ibm|ibm64|hp|cray|pgi|absoft|fujitsu|sun|compaq|"
    echo "       g95|open64|kai|nec|hitachi|intel|absoft|lahey|nagware|pathscale]"
    echo "-useropt='<parameters>' ............... list of commandline parameters."
    echo "-extrashlibopts='<parameters>' ...... arguments for building libTAU.so." 
    echo "-prefix=<dir> ................ Specify a target installation directory."
    echo "-exec-prefix=<arch> .......... Specify a target architecture directory."
    echo "-arch=<architecture> ................... Specify a target architecture."
    echo "       options          [xt3|craycnl|bgp|bgl|ibm64|ibm64linux|sunx86_64"
    echo "                               |solaris2-64|mips32|sgin32|sgi64|sgio32]"
    echo "-iowrapper .................................... Build POSIX IO Wrapper."
    echo "-pthread .................................. Use pthread thread package."
    echo "-papithread .................................. Use PAPI thread package."
    echo "-charm=<dir> .............................. Use charm++ thread package."
    echo "-sproc .................................. Use SGI sproc thread package."
    echo "-tulipthread=<dir> .......... Specify location of Tulip/Smarts package."
    echo "-smarts .................. Use SMARTS API for threads (use with above)."
    echo "-openmp ........................................... Use OpenMP threads."
    echo "-opari ..................................................... Use Opari."
    echo "-opari_region ......... Report performance data for all OpenMP regions."
    echo "-opari_construct ... Report performance data for all OpenMP constructs."
    echo "-pcl=<dir> ..... Specify location of PCL (Performance Counter Library)."
    echo "-papi=<dir> ............... Specify location of PAPI (Performance API)."
    echo "-pdt=<dir> ........ Specify location of PDT (Program Database Toolkit)."
    echo "-jdk=<dir>  Build a library for profiling Java code with specified jdk."
    echo "-dyninst=<dir> ................... Specify location of DynInst Package."
    echo "-vtf=<dir> ......... Specify location of VTF3 Trace Generation Package."
    echo "-otf=<dir> ....... Specify location of Open Trace Format (OTF) Package."
    echo "-slog2=<dir> .......... Specify location of SLOG2 SDK/Jumpshot Package."
    echo "-slog2 ........ Specify use of TAU internal SLOG2 SDK/Jumpshot Package."
    echo "-mpi .......................... Specify use of TAU MPI wrapper library."
    echo "-mpiinc=<dir> ............. Specify location of MPI include dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-mpilib=<dir> ............. Specify location of MPI library dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-mpilibrary=<library> ................ Specify a different MPI library."
    echo "            e.g., -mpilibrary=-lmpi_r                                  "
    echo "-shmem ...................... Specify use of TAU SHMEM wrapper library."
    echo "-shmeminc=<dir> ......... Specify location of SHMEM include dir and use"
    echo "                         the TAU SHMEM Profiling and Tracing Interface."
    echo "-shmemlib=<dir> ......... Specify location of SHMEM library dir and use"
    echo "                           the TAU MPI Profiling and Tracing Interface."
    echo "-shmemlibrary=<library> ............ Specify a different SHMEM library."
    echo "            e.g., -shmemlibrary=-lsmac                                 "
    echo "-nocomm  ........ Disable tracking communication events in MPI library."
    echo "-epilog=<dir>  ............ Specify location of EPILOG Tracing package."
    echo "-epiloglib=<dir> ........... Specify full path to EPILOG lib directory."
    echo "-epilogbin=<dir> ........... Specify full path to EPILOG bin directory."
    echo "-epiloginc=<dir> ....... Specify full path to EPILOG include directory."
    echo "-vampirtrace=<dir>  .. Specify location of VampirTrace Tracing package."
    echo "-pythoninc=<dir> ........ Specify location of Python include directory."
    echo "-pythonlib=<dir> ............ Specify location of Python lib directory."
    echo "-tag=<unique name> ........ Specify a tag to identify the installation."
    echo "-perfinc=<dir> ............. Specify a Perflib[LANL] include directory."
    echo "-perflib=<dir> ................. Specify a Perflib[LANL] lib directory."
    echo "-perflibrary=<library> ... Specify a different perflib runtime library."
    echo "-ktau ........................................... Kernel TAU Profiling."
    echo "-ktau_shctr ........................ Kernel TAU Profiling with shared- "
    echo "                                                   OS counters support."
    echo "-ktauinc=<dir> ............... Specify location of Linux Kernel source."
    echo "-ktauincuser=<dir> ............... Specify location of KTAU user incls."
    echo "-ktaulib=<dir> ............ Specify location of KTAU library libktau.a."
    echo "-ktausym=<path to System.map>  ...... Specify location of Linux Kernel."
    echo "                                                          Symbol Table."
    echo "-muse ................................. Specify the use of MAGNET/MUSE." 
    echo "-muse_event ............................Specify the use of MAGNET/MUSE."
    echo "                                w/ non-monotonically increasing values." 
    echo "-muse_multiple ........................ Specify the use of MAGNET/MUSE." 
    echo "                                    w/ monotonically increasing values." 
    echo "-stff=<dir> .... Location of RENCI Scalable Time-series filter library."
    echo "-sddf=<dir> ...... SDDF library location; Only required for RENCI STFF."
    echo "-TRACE ..................................... Generate TAU event traces."
    echo "-MPITRACE ... Generate event traces for MPI events and their ancestors."
    echo "-PROFILE ............ Generate profiles (summary statistics) (default)."
    echo "-PROFILECALLPATH ......................... Generate call path profiles."
    echo "-PROFILEPARAM .... Generate profiles with parameter mapped event data ."
    echo "-PROFILEPHASE .......................... Generate phase based profiles."
    echo "-PROFILESTATS .................. Enable standard deviation calculation."
    echo "-DEPTHLIMIT ........... Disable instrumentation beyond a certain depth."
    echo "-PROFILEMEMORY .. Track heap memory utilization at each function entry."
    echo "-PROFILEHEADROOM .. Track memory free (or headroom) at each func entry."
    echo "-MULTIPLECOUNTERS ............ Use multiple hardware counters and time."
    echo "-COMPENSATE ........ Compensate for profiling measurement perturbation."
    echo "-BGLTIMERS .... Use fast low-overhead timers on IBM BlueGene/L systems."
    echo "-BGPTIMERS .... Use fast low-overhead timers on IBM BlueGene/P systems."
    echo "-SGITIMERS .......... Use fast nanosecond timers on SGI R10000 systems."
    echo "-CRAYTIMERS ............ Use fast nanosecond timers on Cray X1 systems."
    echo "-LINUXTIMERS ......... Use low overhead TSC Counter for wallclock time."
    echo "-CPUTIME .......... Use usertime+system time instead of wallclock time."
    echo "-JAVACPUTIME ...................... Use JVMPI thread specific cpu time."
    echo "-PAPIWALLCLOCK ........ Use PAPI to access wallclock time. Needs -papi."
    echo "-PAPIVIRTUAL   .......... Use PAPI for virtual (user) time calculation."
    echo "-INTELCXXLIBICC   ......... Use Intel -cxxlib-icc option for compiling."
    echo "-noex .................. Use no exceptions while compiling the library."
    echo "-DISABLESHARED .................. Do not build libTAU.so shared object."
    echo "-help ...................................... display this help message."
    echo "-fullhelp .............................. display the full help message."
    exit
    ;;
  esac
done

rm -f .clean

if [ $default = false ] ; then
    rm -f .last_config
fi

# This method will escape spaces so that you can use ./configure `cat .last_config` when you've used them
for arg in "$@"; do
    # Thanks to Bernd Mohr for the following that handles quotes and spaces
    # -e 's/^x//'          removes the x at the start
    # -e 's/"/\\\"/g'      replaces " with \"
    # -e s,\',%@%\',g      replaces ' with %@%'
    # -e 's/%@%/\\\/g'     replaces %@% \
    # -e 's/ /\\\ /g'      replaces space with \space
    modarg=`echo "x$arg" | sed -e 's/^x//' -e 's/"/\\\"/g' -e s,\',%@%\',g -e 's/%@%/\\\/g' -e 's/ /\\\ /g'`
    modargs="$modargs $modarg"
done

if [ $default = false ] ; then
#    echo "configured with:"
#    echo ""
#    echo "$modargs"
#    echo ""
    echo "$modargs" >> .all_configs
    echo "$modargs" > .last_config
fi

# test if we're using the bash shell
usingbash=no
readlink=`which readlink`
if [ "x$readlink" != "x" ] ; then
    if [ -x "$readlink" ] ; then
	symlink=`readlink /bin/sh`
	if [ "x$symlink" = "xbash" ] ; then
	    usingbash=yes
	fi
    fi
fi

# write tau_config.h that's used as meta-data containing the TAU configuration
if [ "$usingbash" = "yes" ] ; then 
    modmodargs=`echo "x$modargs" | sed -e 's/^x//' -e 's#\\\#\\\\\\\\#g'`
else 
    modmodargs=`echo "x$modargs" | sed -e 's/^x//' -e 's#\\\#\\\\\\\\\\\#g'`
fi
echo "#define TAU_CONFIG \"$modmodargs\"" > include/tau_config.h

START_DIR=`pwd`

# Record all the arguments
arguments=$*

# Default compilers and options
c_compiler=default
cxx_compiler=default
pdt_cxx_compiler=default
fixmakeargs=""
pcxxopt=-g
useropt=
tag=no
tautag=
orig_useropt=
mpi=no
mpi2=no
mpiio=no
mpiinc=
mpilib=
mpilibrary=no
ibmmpi=no
shmem=no
shmeminc=
shmemlib=
shmemlibrary=no
threadsafe=no
additional_mpiincs=
additional_mpilibs=
pythoninc=
pythonlib=
python=no
sicortex=no
extradir=
extrashlibopts=
awe=no
pthread=no
papithread=no
papipfm=no
papisubdir=
charm=no
muse=no
muse_event=no
muse_multiple=no
comm=yes
sproc=no
noex=no
disableshared=no
setnode0=no
tulipthread=no
compensate=no
smarts=no
pcl=no
papi=no
perf=no
perfincdir=
perflibdir=
perflibrary=
task=no
lwp=no
tcltk=yes
tcltkfile="/"
kai=no
pgi=no
fujitsu=no
guidef90=no
stdcxxlib=no
inteltflop=no
intelcxxlibicc=no
intelifort=no
intel=no
gnu=no
profile=no
monitor=no
profilecounters=no
multiplecounters=no
profilestats=no
profilememory=no
profileheadroom=no
callpath=no
profileparam=no
depthlimit=no
phase=no
profilecalls=no
profilecallstack=no
trace=no
mpitrace=no
debugprof=no
bgltimers=no
bgptimers=no
sgitimers=no
craytimers=no
linuxtimers=no
alphatimers=no
cputime=no
javacputime=no
papiwallclock=no
papivirtual=no
use_pcxx=no
use_hpcxx=no
use_ansic=no
use_sage2=no
use_pstl=no
use_hpnx=no
tauarch=unknown
pdtcompdir=unknown
pdtarchdir=unknown
tauprefix=unknown
execprefix=unknown
taugcclibdir=unknown
tautoplevel=
tauoptions=
pdt_root_dir="."
pdt=no
vtf=no
otf=no
slog2=no
internalslog2=no
opari=no
epilog=no
scalasca=no
epilogextralinkcmd=
epiloglib=no
epilogbin=no
epiloginc=no
epilogdir=no
epiloglibdir=no
epilogbindir=bin
epilogincdir=
vampirtrace=no
opari_region=no
opari_construct=no
dyninst=no
java=no
openmp=no
ibmxlc=no
ibmxlc_r=no 
fortran_compiler=no
ktau=no
ktau_merge=no
ktau_shctr=no
ktauinc=
ktauincuser=
ktaulib=
ktausym=
catamount=no
gpshmem=no
stff=no
stffdir=
sddf=no
sddfdir=
iowrapper=no
home=$HOME

# debug:
# echo $arguments

# Reset include/Makefile before starting anything else
for i in include/Makefile
do
    sed -f utils/FixMakefile.sed.default < ${i} > ${i}~~0
    mv ${i}~~0 ${i}
done

# PARSE COMMAND LINE SWITCHES
###############################################################
for arg in "$@";
do
  case $arg in

  -cc=*)
    myarg=`echo $arg | sed 's/-cc=//'`
    if [ $myarg = cc -o $myarg = gcc -o $myarg = KCC -o $myarg = pgcc -o $myarg = guidec -o $myarg = xlc -o $myarg = ecc -o $myarg = icc -o $myarg = powerpc64-linux-gcc -o $myarg = pathcc -o $myarg = fcc -o $myarg = orcc -o $myarg = qk-pgcc -o $myarg = scgcc -o $myarg = scpathcc -o $myarg = mips64el-gentoo-linux-gnu-gcc -o $myarg = powerpc-bgp-linux-gcc ]
      then
        c_compiler=$myarg
      else
        testxlc=`echo $myarg | sed -e 's/xlc//'`
        testmp=`echo $myarg | sed -e 's/^mp//'`
        if [ "y$testxlc" = "y$myarg"  -a "y$testmp" = "y$myarg" ]
        then
          echo "WARNING: valid options for cc are 'cc', 'gcc', 'KCC', 'guidec', '*xlc*', 'ecc', 'icc', 'pathcc', 'fcc', 'orcc', 'qk-pgcc', 'powerpc-bgp-linux-gcc', and 'pgcc' "
#       exit 1
        else
	  if [ "y$testxlc" != "y$myarg" ]
          then 
            c_compiler=$myarg
          else
            c_compiler=`$myarg -show | awk '{ print $1; }'`
          fi
        fi
    fi
    shift
    ;;

  -c++=*)
    myarg=`echo $arg | sed 's/-c++=//'`
    if [ $myarg = CC -o $myarg = KCC -o $myarg = g++ -o $myarg = cxx  -o $myarg = NCC -o $myarg = pgCC  -o $myarg = egcs -o $myarg = FCC -o $myarg = guidec++ -o $myarg = aCC -o $myarg = c++ -o $myarg = ecpc -o $myarg = icpc -o $myarg = powerpc64-linux-g++ -o $myarg = pathCC -o $myarg = orCC -o $myarg = qk-pgCC -o $myarg = scg++ -o $myarg = scpathCC -o $myarg = mips64el-gentoo-linux-gnu-g++ -o $myarg = powerpc-bgp-linux-g++ -o $myarg = mpicxx ] 
      then
        cxx_compiler=$myarg
      else
        testxlc=`echo $myarg | sed -e 's/xl//'`
        testmp=`echo $myarg | sed -e 's/^mp//'`
	if [ "y$testxlc" = "y$myarg" -a "y$testmp" = "y$myarg" ]
        then
          echo "WARNING: valid options for c++ are 'CC', 'KCC', 'g++', '*xlC*', 'cxx' , 'NCC', 'egcs', 'pgCC', 'FCC', 'guidec++', 'aCC', 'ecpc', 'icpc', 'pathCC', 'c++', 'qk-pgCC', and 'orCC'"
#       exit 1
        else
	  if [ "y$testxlc" != "y$myarg" ]
          then 
            cxx_compiler=$myarg
          else
            cxx_compiler=`$myarg -show | awk '{ print $1; }'`
          fi
        fi
    fi
    shift
    ;;

  -pdt_c++=*)
    pdt_cxx_full_path=`echo $arg | sed 's@-pdt_c++=@@g'`
    myarg=`echo $arg |  echo $arg | sed 's@-pdt_c++=@@g' | sed 's@.*/@@g'`
    if [  $myarg = CC -o $myarg = KCC -o $myarg = g++ -o $myarg = cxx  -o $myarg = NCC -o $myarg = pgCC  -o $myarg = egcs -o $myarg = FCC -o $myarg = guidec++ -o $myarg = aCC -o $myarg = c++ -o $myarg = ecpc -o $myarg = icpc -o $myarg = powerpc64-linux-g++ -o $myarg = pathCC -o $myarg = orCC -o $myarg = qk-pgCC -o $myarg = scg++ -o $myarg = scpathCC -o $myarg = mips64el-gentoo-linux-gnu-g++ -o $myarg = powerpc-bgp-linux-g++ ]
      then
        pdt_cxx_compiler=$myarg
      else
        testxlc=`echo $myarg | sed -e 's/xl//'`
        if [ "y$testxlc" = "y$myarg" ]
        then
          echo "WARNING: valid options for pdt_c++ are 'CC', 'KCC', 'g++', '*xlC*', 'cxx' , 'egcs', 'pgCC', 'FCC', 'guidec++', 'aCC', 'c++', and 'orCC'"
#       exit 1
        else
          pdt_cxx_compiler=$myarg
        fi
    fi
    shift
    ;;

  -fortran=*)
    myarg=`echo $arg | sed 's/-fortran=//'`
    if [ $myarg = gnu -o $myarg = sgi -o $myarg = ibm -o $myarg = ibm64 -o $myarg = hp -o $myarg = cray -o $myarg = pgi -o $myarg = absoft -o $myarg = fujitsu -o $myarg = sun -o $myarg = compaq -o $myarg = kai -o $myarg = hitachi -o $myarg = intel -o $myarg = nec -o $myarg = absoft -o $myarg = lahey -o $myarg = nagware -o $myarg = pathscale -o $myarg = gfortran -o $myarg = g95 -o $myarg = open64 ] 
    then
      fortran_compiler=$myarg
    else
      echo "WARNING: valid options for fortran are 'gnu', 'sgi', 'ibm', 'ibm64', 'hp', 'cray', 'pgi', 'absoft', 'fujitsu', 'sun', 'compaq', 'kai', 'hitachi', 'intel', 'nec' , 'absoft', 'lahey', 'nagware', 'pathscale', 'gfortran', 'g95', and 'open64'"
      exit 1
    fi
    shift
    ;;

  -gnu)
      c_compiler=gcc
      cxx_compiler=g++
    shift
    ;;

  -dec)
      c_compiler=cc
      cxx_compiler=g++
    shift
    ;;

  -ibm)
      c_compiler=xlc_r
      cxx_compiler=xlC_r
    shift
    ;;

  -cfront)
      c_compiler=cc
      cxx_compiler=CC
    shift
    ;;

  -sgi)
      c_compiler=cc
      cxx_compiler=CC
    shift
    ;;

  -task)
      task=yes
    shift
    ;;

  -awe=*)
      awe=yes
      awedir=`echo $arg | sed -e 's/-awe=//'`
    shift
    ;;

  -tag=*)
      tag=yes
      tautag=`echo $arg | sed -e 's/-tag=//'`
    shift
    ;;

  -lwp)
      lwp=yes
    shift
    ;;

  -pthread=*)
      pthread=yes
      ptdir=`echo $arg | sed -e 's/-pthread=//'`
    shift
    ;;
 
  -pthread)
      pthread=yes
    shift
    ;;

  -papithread)
      papithread=yes
    shift
    ;;

  -iowrapper)
      iowrapper=yes
      shift
      ;;

  -charm=*)
      pthread=yes
      charm=yes
      charmdir=`echo $arg | sed -e 's/-charm=//'`
    shift
    ;;

  -COMPENSATE)
     compensate=yes
    shift
    ;;


  -forceshared)
     fixmakeargs="$fixmakeargs FORCESHARED"
    shift
    ;;


  -ktau)
      ktau=yes
    shift
    ;;

  -ktau_merge)
      ktau_merge=no
    shift
    ;;

  -ktau_shctr)
      ktau_shctr=yes
    shift
    ;;

  -ktauinc=*)
    ktauinc=`echo $arg | sed -e 's/-ktauinc=//' -e 's/ /#/g'`
    if [ ! -d $ktauinc ]
    then
      echo "Error: Cannot access KTAU include directory $ktauinc"
      exit 1
    fi
    shift
    ;;

  -ktauincuser=*)
    ktauincuser=`echo $arg | sed -e 's/-ktauincuser=//' -e 's/ /#/g'`
    if [ ! -d $ktauincuser ]
    then
      echo "Error: Cannot access KTAU user include directory $ktauincuser"
      exit 1
    fi
    shift
    ;;

  -ktaulib=*)
    ktaulib=`echo $arg | sed -e 's/-ktaulib=//' -e 's/ /#/g'`
    if [ ! -d $ktaulib ]
    then
      echo "Error: Cannot access KTAU user lib $ktaulib"
      exit 1
    fi
    shift
    ;;

  -ktausym=*)
    ktausym=`echo $arg | sed -e 's/-ktausym=//' -e 's/ /#/g'`
    if [ ! -e $ktausym ]
    then
      echo "Warning: Cannot access KTAU Linux Kernel Symbol Table $ktausym locally (Does it exist on the compute nodes?). Continuing."
    fi
    shift
    ;;
 
  -muse)
      muse=yes
    shift
    ;;

  -muse_event)
      muse_event=yes
    shift
    ;;

  -muse_multiple)
      muse_multiple=yes
    shift
    ;;

  -nocomm)
      comm=no
    shift
    ;;

  -sproc)
      sproc=yes
    shift
    ;;

  -smarts)
      smarts=yes
    shift
    ;;

  -tulipthread=*)
      tulipthread=yes
      tulipdir=`echo $arg | sed -e 's/-tulipthread=//'`
      if [ ! -d $tulipdir ]
      then
        echo "Error: Cannot access TULIP directory $tulipdir"
        exit 1
      fi
    shift
    ;;

  -pcl=*)
      pcl=yes
      pcldir=`echo $arg | sed -e 's/-pcl=//'`
      if [ ! -d $pcldir ]
      then
        echo "Error: Cannot access PCL directory $pcldir"
        exit 1
      fi
    shift
    ;;

  -papi=*)
      papi=yes
      papidir=`echo $arg | sed -e 's/-papi=//'`
      if [ ! -d $papidir ]
      then
        echo "Error: Cannot access PAPI directory $papidir"
        exit 1
      fi
    shift
    ;;

  -perfinc=*)
      perf=yes
      perfincdir=`echo $arg | sed -e 's/-perfinc=//'`
      if [ ! -d $perfincdir ]
      then
        echo "Error: Cannot access PERF include directory $perfincdir"
        exit 1
      fi
    shift
    ;;

  -perflib=*)
      perf=yes
      perflibdir=`echo $arg | sed -e 's/-perflib=//'`
      if [ ! -d $perflibdir ]
      then
        echo "Error: Cannot access PERF lib directory $perflibdir"
        exit 1
      fi
    shift
    ;;

  -perflibrary=*)
      perf=yes
      perflibrary=`echo $arg | sed -e 's/-perflibrary=//' -e 's/ /#/g'`
    shift
    ;;

  -opari)
      opari=yes
      openmp=yes
    shift
    ;;

  -opari=*)
      opari=yes
      openmp=yes
    shift
    ;;

  -opari_region)
      opari_region=yes
    shift
    ;;

  -opari_construct)
      opari_construct=yes
    shift
    ;;

  -vampirtrace=*)
      vampirtrace=yes
      trace=yes
      vampirtracedir=`echo $arg | sed -e 's/-vampirtrace=//'`
      if [ ! -d $vampirtracedir ]
      then
        echo "Error: Cannot access VAMPIRTRACE directory $vampirtracedir"
        exit 1
      fi
    shift
    ;;

  -epilog=*)
      epilog=yes
      trace=yes
      epilogdir=`echo $arg | sed -e 's/-epilog=//'`
      if [ ! -d $epilogdir ]
      then
        echo "Error: Cannot access EPILOG directory $epilogdir"
        exit 1
      fi
    shift
    ;;

  -epiloglib=*)
      epilog=yes
      epiloglib=yes
      trace=yes
      epiloglibdir=`echo $arg | sed -e 's/-epiloglib=//'`
    shift
    ;;

  -epilogbin=*)
      epilog=yes
      epilogbin=yes
      trace=yes
      epilogbindir=`echo $arg | sed -e 's/-epilogbin=//'`
    shift
    ;;

  -epiloginc=*)
      epilog=yes
      epiloginc=yes
      trace=yes
      epilogincdir=`echo $arg | sed -e 's/-epiloginc=//'`
    shift
    ;;

  -pdt=*)
      pdt=yes
      pdtdir=`echo $arg | sed -e 's/-pdt=//'`
      if [ ! -d $pdtdir ]
      then
        echo "Error: Cannot access PDT directory $pdtdir"
        exit 1
      fi
    shift
    ;;

  -vtf=*)
      vtf=yes
      trace=yes
      vtfdir=`echo $arg | sed -e 's/-vtf=//'`
      if [ ! -d $vtfdir ]
      then
        echo "Error: Cannot access VTF3 directory $vtfdir"
        exit 1
      fi
    shift
    ;;

  -otf=*)
      otf=yes
      trace=yes
      otfdir=`echo $arg | sed -e 's/-otf=//'`
      if [ ! -d $otfdir ]
      then
        echo "Error: Cannot access OTF directory $otfdir"
        exit 1
      fi
    shift
    ;;

  -dyninst=*)
      dyninst=yes
      dyninstdir=`echo $arg | sed -e 's/-dyninst=//'`
      if [ ! -d $dyninstdir ]
      then
        echo "Error: Cannot access DyninstAPI directory $dyninstdir"
        exit 1
      fi
    shift
    ;;

  -openmp)
      openmp=yes
    shift
    ;;

  -jdk=*)
      java=yes
      jdkdir=`echo $arg | sed -e 's/-jdk=//'`
      if [ ! -d $jdkdir ]
      then
        echo "Error: Cannot access JDK directory $jdkdir"
        exit 1
      fi 
      jv=`$jdkdir/bin/java -version 2>&1 | grep version | awk '{ print $3; }'| sed -e s/\"//g`
    if [ `echo $jv | sed -e s/1.6\.*// | wc -c` -eq 1 ] || [ `echo $jv | sed -e s/1.7\.*// | wc -c` -eq 1 ]
    then
        echo "Error: Specify a JDK of version 1.5 or earlier"
        exit 1
    fi
    shift
    ;;

  -slog2=*)
      slog2=yes
      trace=yes
      slog2dir=`echo $arg | sed -e 's/-slog2=//'`
      if [ ! -d $slog2dir ]
      then
        echo "Error: Cannot access SLOG2 directory $slog2dir"
        exit 1
      fi
    shift
    ;;


  -slog2)
      slog2=yes
      trace=yes
      internalslog2=yes
    shift
    ;;
    
    -pcxxopt=*)
    pcxxopt=`echo $arg | sed -e 's/-pcxxopt=//' -e 's/ /_/g'`
    shift
    ;;

  -useropt=*)
# Note you might be passed -g#-O3 which becomes -g -O3
    orig_useropt=`echo $arg | sed -e 's/-useropt=//' -e 's/#/ /g'`
# Note you might be passed -g -O3 which becomes -g#-O3 here
    useropt=`echo $arg | sed -e 's/-useropt=//' -e 's/ /#/g'`
    shift
    ;;

  -extrashlibopts=*)
# Note you might be passed -g#-O3 which becomes -g -O3
    extrashlibopts=`echo $arg | sed -e 's/-extrashlibopts=//' -e 's/ /#/g'`
# Note you might be passed -g -O3 which becomes -g#-O3 here
    shift
    ;;

  -mpi)
    mpi=yes
    shift
    ;;

  -mpiinc=*)
    mpi=yes
    mpiinc=`echo $arg | sed -e 's/-mpiinc=//' -e 's/ /#/g'`
    if [ ! -d $mpiinc ]
    then
      echo "Error: Cannot access MPI include directory $mpiinc"
      exit 1
    fi
    shift
    ;;

  -mpilib=*)
    mpi=yes
    mpilib=`echo $arg | sed -e 's/-mpilib=//' -e 's/ /#/g'`
    if [ ! -d $mpilib ]
    then
      echo "Error: Cannot access MPI lib directory $mpilib"
      exit 1
    fi
    shift
    ;;

  -mpilibrary=*)
# you may be passed -lmpich#-L/usr/opt/gm#-lgm#-lpthread#-ldl by installtau
    mpilibrary=`echo $arg | sed -e 's/-mpilibrary=//' -e 's/#/ /g'`
    shift
    ;;

  -shmem)
    shmem=yes
    shift
    ;;

  -shmeminc=*)
    shmeminc=`echo $arg | sed -e 's/-shmeminc=//' -e 's/ /#/g'`
    if [ ! -d $shmeminc ]
    then
      echo "Error: Cannot access SHMEM include directory $shmeminc"
      exit 1
    fi
    shmem=yes
    shift
    ;;

  -shmemlib=*)
    shmemlib=`echo $arg | sed -e 's/-shmemlib=//' -e 's/ /#/g'`
    if [ ! -d $shmemlib ]
    then
      echo "Error: Cannot access SHMEM lib directory $shmemlib"
      exit 1
    fi
    shmem=yes
    shift
    ;;

  -shmemlibrary=*)
    shmemlibrary=`echo $arg | sed -e 's/-shmemlibrary=//' -e 's/ /#/g'`
    shmem=yes
    shift
    ;;

  -stff=*)
    stffdir=`echo $arg | sed -e 's/-stff=//' -e 's/ /#/g'`
    if [ ! -d $stffdir ] ; then
        echo "Error: couldn't find RENCI STFF library in $stffdir"
        exit 1
    fi
    stff=yes
    shift
    ;;

  -sddf=*)
    sddfdir=`echo $arg | sed -e 's/-sddf=//' -e 's/ /#/g'`
    if [ ! -d $sddfdir ] ; then
        echo "Error: couldn't find sddf library in $sddfdir"
        exit 1
    fi
    sddf=yes
    shift
    ;;

  -pythoninc=*)
    pythoninc=`echo $arg | sed -e 's/-pythoninc=//' -e 's/ /#/g'`
    if [ ! -d $pythoninc ]
    then
      echo "Error: Cannot access Python include directory $pythoninc"
      exit 1
    fi
    python=yes
    shift
    ;;

  -pythonlib=*)
    pythonlib=`echo $arg | sed -e 's/-pythonlib=//' -e 's/ /#/g'`
    if [ ! -d $pythonlib ]
    then
      echo "Error: Cannot access Python lib directory $pythonlib"
      exit 1
    fi
    python=yes
    shift
    ;;

  -opt=*)
    pcxxopt=`echo $arg | sed -e 's/-opt=//' -e 's/ /_/g'`
    useropt="$pcxxopt"
    shift
    ;;

  -pcxx=*)
    use_pcxx=yes
    sage1dir=`echo $arg | sed -e 's/-pcxx=//' -e 's/ /_/g'`
    shift
    ;;

  -sage2=*)
    use_sage2=yes
    sage2dir=`echo $arg | sed -e 's/-sage2=//' -e 's/ /_/g'`
    shift
    ;;

  -hpcxx)
    use_hpcxx=yes
    shift
    ;;

  -hpcxx=*)
    use_hpcxx=yes
    sage2dir=`echo $arg | sed -e 's/-hpcxx=//' -e 's/ /_/g'`
    shift
    ;;

  -pstl=*)
    use_pstl=yes
    pstldir=`echo $arg | sed -e 's/-pstl=//' -e 's/ /_/g'`
    shift
    ;;

  -hpnx=*)
    use_hpnx=yes
    hpnxdir=`echo $arg | sed -e 's/-hpnx=//' -e 's/ /_/g'`
    shift
    ;;

  -tkfile=*)
    tcltkfile=`echo $arg | sed -e 's/-tkfile=//' -e 's/ /_/g'`
    shift
    ;;

  -ansic)
    use_ansic=yes
    shift
    ;;

  -PROFILE)
    profile=yes
    shift
    ;;

  -PROFILECOUNTERS)
    profile=yes
    profilecounters=yes
    shift
    ;;

  -MULTIPLECOUNTERS)
    multiplecounters=yes
    shift
    ;;

  -PROFILECALLS)
    profile=yes
    profilecalls=yes
    shift
    ;;

  -PROFILEPHASE)
    phase=yes
    shift
    ;;

  -PROFILECALLPATH)
    profile=yes
    callpath=yes
    shift
    ;;
  -PROFILEPARAM)
    profile=yes
    profileparam=yes
    shift
    ;;

  -DEPTHLIMIT)
    depthlimit=yes
    shift
    ;;

  -PROFILESTATS)
    profile=yes
    profilestats=yes
    shift
    ;;

  -PROFILEMEMORY)
    profile=yes
    profilememory=yes
    shift
    ;;

  -PROFILEHEADROOM)
    profile=yes
    profileheadroom=yes
    shift
    ;;

  -PROFILECALLSTACK)
    profile=yes
    profilecallstack=yes
    shift
    ;;

  -TRACE)
    trace=yes
    shift
    ;;

  -MPITRACE)
    mpitrace=yes
    shift
    ;;

  -MONITOR)
    monitor=yes
    shift
    ;;

  -DEBUGPROF)
    debugprof=yes
    shift
    ;;

  -BGLTIMERS)
    bgltimers=yes
    shift
    ;;

  -BGPTIMERS)
    bgptimers=yes
    shift
    ;;

  -SGITIMERS)
    sgitimers=yes
    shift
    ;;

  -CRAYTIMERS)
    craytimers=yes
    shift
    ;;

  -LINUXTIMERS)
    linuxtimers=yes
    shift
    ;;

  -ALPHATIMERS)
    alphatimers=yes
    shift
    ;;

  -CPUTIME)
    cputime=yes
    shift
    ;;

  -JAVACPUTIME)
    javacputime=yes
    shift
    ;;

  -PAPIWALLCLOCK)
    papiwallclock=yes
    shift
    ;;

  -PAPIVIRTUAL)
    papivirtual=yes
    shift
    ;;

  -INTELCXXLIBICC)
    intelcxxlibicc=yes
    shift
    ;; 

  -INTELTFLOP)
    inteltflop=yes
    shift
    ;; 

  -noex)
    # NO exceptions to be used while building the lib.
    noex=yes
    shift
    ;;

  -DISABLESHARED)
    # NO exceptions to be used while building the lib.
    disableshared=yes
    shift
    ;;

  -setnode0)
    # When this option is invoked, TAU sets the default node no to 0 instead 
    # of using -1. So, profile.0.0.0 is created even if TAU_PROFILE_SET_NODE(0)
    # is not called in the application. Do not use with tracing
    setnode0=yes
    shift
    ;;

  -arch=*)
    tauarch=`echo $arg | sed -e 's/-arch=//' -e 's/ /_/g'`
    shift
    ;;

  -pdtcompdir=*)
    pdtcompdir=`echo $arg | sed -e 's/-pdtcompdir=//' -e 's/ /_/g'`
    shift
    ;;

  -pdtarchdir=*)
    pdtarchdir=`echo $arg | sed -e 's/-pdtarchdir=//' -e 's/ /_/g'`
    shift
    ;;

  -prefix=*)
    tauprefix=`echo $arg | sed -e 's/-prefix=//' -e 's/ /_/g'`
    echo "tauprefix =  $tauprefix "
    fixmakeargs="$fixmakeargs tauprefix=$tauprefix"
    shift
    ;;

  -exec-prefix=*)
    execprefix=`echo $arg | sed -e 's/-exec-prefix=//' -e 's/ /_/g'`
    fixmakeargs="$fixmakeargs execprefix=$execprefix"
    shift
    ;;

  default)
    echo "Fixing Makefiles"
    ;;	
  '')
    #echo "NULL switch!"
    # Required for HP/Compaq Tru64 machines.
    ;;
  *)
    echo "ERROR: Command line switch \`$arg' not recognized" 1>&2
    echo "Run configure with -help to see a list of options" 1>&2
    exit 1
    ;;
  esac
done

# -- some functions

configure_java () {

  echo "TAU: installing TAU's ParaProf profile browser" 
  taushell=sh
  if [ $machine = solaris2* -o $machine = alpha ]
  then
    taushell=ksh
  fi

  x=`java -version 2>&1 | grep version | awk '{ print $3; }'| sed -e s/\"//g`

  oldjdk=no

  if [ `echo $x | sed -e s/1.1\.*// | wc -c` -eq 1 ]
  then
    oldjdk=no
  else
    if [ `echo $x | sed -e s/1.2\.*// | wc -c` -eq 1 ]
    then
      echo "jdk version 1.2 found"
      oldjdk=yes
    else
      if [ `echo $x | sed -e s/1.3\.*// | wc -c` -eq 1 ]
      then
        echo "jdk version 1.3 found"
        oldjdk=yes
      else
        echo "jdk version 1.4 or better found"
        oldjdk=no;
      fi
    fi
  fi

  if [ $oldjdk = yes ]
  then
    paraprofjar=paraprof-1.3.jar
  else
    paraprofjar=paraprof.jar
  fi
}

configure_perfexplorer () {


echo "TAU: installed TAU's PerfDMF database utilities in ${targetdir}/${architecture}/bin" 

cat ${tauroot}/tools/src/perfdmf/bin/configure.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/perfdmf_configure
chmod a+rx ${targetdir}/${architecture}/bin/perfdmf_configure

cat ${tauroot}/tools/src/perfdmf/bin/createapp.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/perfdmf_createapp
chmod a+rx ${targetdir}/${architecture}/bin/perfdmf_createapp

cat ${tauroot}/tools/src/perfdmf/bin/createexp.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/perfdmf_createexp
chmod a+rx ${targetdir}/${architecture}/bin/perfdmf_createexp

cat ${tauroot}/tools/src/perfdmf/bin/loadtrial.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/perfdmf_loadtrial
chmod a+rx ${targetdir}/${architecture}/bin/perfdmf_loadtrial

cat ${tauroot}/tools/src/perfdmf/bin/phaseconvert.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/phaseconvert
chmod a+rx ${targetdir}/${architecture}/bin/phaseconvert

if [ ! -d ${home}/.ParaProf ] 
  then
    mkdir -p ${home}/.ParaProf
fi
cat ${tauroot}/tools/src/perfdmf/bin/derby.properties.skel | 
sed -e 's,@HOME@,'${home}',' > ${home}/.ParaProf/derby.properties

cat ${tauroot}/tools/src/perfexplorer/bin/configure.skel | 
sed -e 's,@TAUROOTDIR@,'$tauroot',' \
-e 's,@SHELL@,'$taushell',' \
-e 's,@ARCH@,'$architecture',' \
-e 's,@TARGETDIR@,'$targetdir',' \
 > ${tauroot}/tools/src/perfexplorer/configure
chmod a+rx ${tauroot}/tools/src/perfexplorer/configure

cat ${tauroot}/tools/src/perfexplorer/bin/perfexplorer_configure.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir',' \
-e 's,@SHELL@,'$taushell',' \
-e 's,@ARCH@,'$architecture',' \
-e 's,@TARGETDIR@,'$targetdir',' \
 > ${targetdir}/${architecture}/bin/perfexplorer_configure
chmod a+rx ${targetdir}/${architecture}/bin/perfexplorer_configure

if [ ! -d ${targetdir}/etc ] 
  then
    mkdir -p ${targetdir}/etc
fi
cp ${tauroot}/tools/src/perfexplorer/bin/perfexplorer.skel ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/dbschema.derby ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/dbschema.mysql ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/dbschema.oracle ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/dbschema.postgresql ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/dbschema.db2 ${targetdir}/etc/.
cp ${tauroot}/tools/src/perfexplorer/etc/java.policy ${targetdir}/etc/.
  
BINTARGET=${targetdir}/${architecture}/bin
JARTARGET=${targetdir}/${architecture}/lib

  # install paraprof
cat ${tauroot}/tools/src/paraprof/bin/paraprof.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
    -e 's,@OLDJDK@,'$oldjdk',' > $BINTARGET/paraprof
chmod a+rx $BINTARGET/paraprof

  # install ppscript
cat ${tauroot}/tools/src/ppscript.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
    -e 's,@OLDJDK@,'$oldjdk',' > $BINTARGET/ppscript
chmod a+rx $BINTARGET/ppscript

  # install portal utils
cat ${tauroot}/tools/src/tau_portal/bin/perfdmfdb.py.skel | sed -e 's,@BINDIR@,'$BINTARGET',' > $BINTARGET/perfdmfdb.py
cat ${tauroot}/tools/src/tau_portal/bin/portal.py.skel | sed -e 's,@BINDIR@,'$BINTARGET',' > $BINTARGET/portal.py
cp ${tauroot}/tools/src/tau_portal/bin/tau_portal.py $BINTARGET
chmod a+rx $BINTARGET/tau_portal.py $BINTARGET/portal.py $BINTARGET/perfdmfdb.py

cat ${tauroot}/tools/src/perfexplorer/bin/perfexplorer.skel |
sed -e 's,@TAUROOT@,'$targetdir',' \
    -e 's,@TAUSHELL@,'$taushell',' \
    -e 's,@TAUARCH@,'$architecture',' \
    -e 's,@RROOT@,'$rroot',' \
    -e 's,@ANALYSIS_ENGINE@,'weka',' \
    -e 's,@SERVER_HOSTNAME@,'$serverhostname',' \
    -e 's,@SERVER_OBJECT_PORT@,'$objectport',' \
    -e 's,@SERVER_RMIREGISTRY_PORT@,'$registryport',' \
    -e 's,@CONFIGFILE@,'$configfile',' \
    > $BINTARGET/perfexplorer
chmod a+rx $BINTARGET/perfexplorer


if [ ! -f $BINTARGET/jracy ] ; then 
    cd $BINTARGET/; ln -s paraprof jracy; cd ${tauroot}; 
fi


cp ${tauroot}/tools/src/paraprof/bin/$paraprofjar $JARTARGET
cp ${tauroot}/tools/src/perfdmf/bin/perfdmf.jar $JARTARGET
cp ${tauroot}/tools/src/perfexplorer/perfexplorer.jar $JARTARGET
cp ${tauroot}/src/Profile/TAU.jar $JARTARGET
cp ${tauroot}/tools/src/perfexplorer/perfexplorer-1.4.jar $JARTARGET
cp ${tauroot}/tools/src/vis/bin/vis.jar $JARTARGET
cp ${tauroot}/tools/src/common/bin/tau-common.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jargs.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/batik-combined.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jfreechart-0.9.21.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jcommon-0.9.6.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jgraph.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jgraph-1.3.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jython.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/jogl/jogl.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/derby.jar $JARTARGET
cp ${tauroot}/tools/src/contrib/xerces.jar $JARTARGET
cp ${tauroot}/tools/src/common/resources/tau16x16.gif $JARTARGET

echo "TAU: installed ParaProf, PerfDMF, PerfExplorer and supporting jars in:"
echo "$JARTARGET"

case $machine in
    
    apple)
	gunzip -c tools/src/contrib/jogl/apple/libjogl.jnilib.gz > $JARTARGET/libjogl.jnilib
	gunzip -c tools/src/contrib/jogl/apple/libjogl_awt.jnilib.gz > $JARTARGET/libjogl_awt.jnilib
	gunzip -c tools/src/contrib/jogl/apple/libjogl_cg.jnilib.gz > $JARTARGET/libjogl_cg.jnilib
	;;
    
    i386_linux)
	gunzip -c tools/src/contrib/jogl/i386_linux/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/i386_linux/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/i386_linux/libjogl_cg.so.gz > $JARTARGET/libjogl_cg.so
	gunzip -c tools/src/contrib/jogl/i386_linux/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;
    
    x86_64)
	gunzip -c tools/src/contrib/jogl/x86_64/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/x86_64/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/x86_64/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	gunzip -c tools/src/contrib/jogl/x86_64/libjogl_cg.so.gz > $JARTARGET/libjogl_cg.so
	;;

    ia64)
	gunzip -c tools/src/contrib/jogl/ia64/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/ia64/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/ia64/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;

    solaris2)
	gunzip -c tools/src/contrib/jogl/solaris2/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/solaris2/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/solaris2/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;

    solaris2-64)
	gunzip -c tools/src/contrib/jogl/solaris2-64/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/solaris2-64/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/solaris2-64/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;

    sun386i)
	gunzip -c tools/src/contrib/jogl/sun386i/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/sun386i/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/sun386i/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;

    sunx86_64)
	gunzip -c tools/src/contrib/jogl/sunx86_64/libjogl.so.gz > $JARTARGET/libjogl.so
	gunzip -c tools/src/contrib/jogl/sunx86_64/libjogl_awt.so.gz > $JARTARGET/libjogl_awt.so
	gunzip -c tools/src/contrib/jogl/sunx86_64/libjogl_drihack.so.gz > $JARTARGET/libjogl_drihack.so
	;;
    
    *)
	echo "Platform does not support JOGL, no 3d displays will be available in ParaProf"
	
	;;
esac


}

make_directories () {

if [ $tauprefix = unknown ] 
then 
  fixmakeargs="$fixmakeargs tauprefix=$tauroot"
  # make bin dir if it does not exist
  if [ ! -d ./$architecture ] 
    then
      mkdir -p ./$architecture
  fi
  if [ ! -d ./$architecture/bin ] 
    then
      mkdir ./$architecture/bin
  fi

  # make lib dir if it does not exist
  if [ ! -d ./$architecture/lib ] 
    then
      mkdir ./$architecture/lib
  fi
fi

# make XtraP directories
if [ -d XtraP ]
then
  if [ ! -d XtraP/lib/$architecture ] 
    then
      mkdir XtraP/lib/$architecture
  fi
fi

}


# -- set up portable echo command
case "`echo 'x\c'`" in
'x\c')  echo="echo -n"  nnl= ;;     #BSD
x)      echo="echo"     nnl="\c";;  #SysV
*)      echo 'Cannot setup echo. What weird machine do you have?' 1>2&
        exit 1;;
esac

# lth@cs.uoregon.edu: don't mess with the compiler if it is 'default'.
# The user may define TAU_CCOM as an environment variable or let it be blank;
# if blank, it is defaulted in archfind.

if [ "$c_compiler" != "" -a "$c_compiler" != "default" ]; then
  TAU_CCOM="$c_compiler"          # for 'archfind'
  export TAU_CCOM
fi


echo "-------------------- TAU configure script ---------------"


tauroot=`pwd | sed -e 's,^/tmp_mnt/nfs,,' -e 's,^/tmp_mnt,,'`
echo \#define TAUROOT \"$tauroot\" > include/tauroot.h
if [ $tauprefix != unknown ]
then
  echo \#define TAUROOT \"$tauprefix\" > include/tauroot.h
fi

echo "  The TAU source code has just been configured to use the"
echo "  tau root directory $tauroot."
echo "  If you move the Tau distribution, you must either"
echo "    * set an environment variable TAUROOT containing the new"
echo "      location before running any TAU tools"
echo "  or"
echo "    * run configure again and recompile"
echo "-----------------------------------------------------------------"

fixmakeargs="$fixmakeargs tauroot=$tauroot"
# Try and figure out architecture
detectarch=unknown
cd utils
detectarch=`./archfind` 
detectxdev=`./archfind -x` 
detectspec=`./archfind -s` 
cd ..
if [ "x$detectarch" = "x" ] 
  then
    detectarch=unknown
fi


###############################################################
# if there are no arguments, GUESS at system configuration
if [ $tauarch = unknown -o $tauarch = none ]
  then 
    if [ $# = 1 ]
      then
	if [ $1 = default ]
	then 
	  machine=$1
	fi
      else
        echo Attempting to auto-configure system, determining architecture...
        machine=$detectarch
        if [ $machine = unknown ]
          then
            echo I could not determine the architecture of this host
            echo You must give me a hint.
	    echo Perhaps, the C compiler is not working.
            echo Please check the licenses. 
            exit 0
        fi
        echo I think this is a $machine...
      fi
  else
    machine=$tauarch
    if [ $detectarch != unknown -a $machine != unknown ]
      then
        detectxdev=$machine
        if [ $detectarch != $machine ]
           then
	     echo WARNING\!\! Auto-detect:$detectarch overridden with $machine
        fi
    fi
fi


if [ ${tauprefix} = unknown ]
then
  targetdir=${tauroot}
else
  targetdir=${tauprefix}
fi


# use -m32 when specifying 32 bit on an Opteron/EM64T
if [ "x$detectarch" = "xx86_64" -a "x$machine" = "xi386_linux" ] ; then
    fixmakeargs="$fixmakeargs FORCEIA32"
fi
    

if [ $machine = mips ] ; then
    sicortex=yes
fi
if [ $machine = mips32 ] ; then
    sicortex=yes
fi

if [ $sicortex = yes ] ; then
    sicortexlink=""
    sicortexmpi=""
    if [ $epilog = yes ] ; then
	elglibrary="-lelg"
	if [ $mpi = yes -a $openmp = yes ] ; then
	    # hybrid
	    sicortexlink="-L$epiloglibdir#-Wl,-whole-archive#-lfmpi#-lelg.ompi#-Wl,-no-whole-archive#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-lscmpi"
	elif [ $mpi = yes ] ; then
	    # mpi
	    sicortexlink="-L$epiloglibdir#-lfmpi#-lelg.mpi#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-lscmpi"
	elif [ $openmp = yes ] ; then
	    # openmp
	    sicortexlink="-L$epiloglibdir#-Wl,-whole-archive#-lelg.omp#-Wl,-no-whole-archive#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic"
	else
	    # serial
	    sicortexlink="-L$epiloglibdir#-lelg#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic"
	fi

    fi
    if [ $vampirtrace = yes ] ; then
	if [ $mpi = yes -a $openmp = yes ] ; then
	    # hybrid
	    sicortexlink="-L$vampirtracedir/$vampirtracelibdir#-Wl,-whole-archive#-lvt.fmpi#-lvt.ompi#-lotf#-Wl,-no-whole-archive#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-lscmpi"
	elif [ $mpi = yes ] ; then
	    # mpi
	    sicortexlink="-L$vampirtracedir/$vampirtracelibdir#-lvt.fmpi#-lvt.mpi#-lotf#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-lscmpi"
	elif [ $openmp = yes ] ; then
	    # openmp
	    sicortexlink="-L$vampirtracedir/$vampirtracelibdir#-Wl,-whole-archive#-lvt.omp#-lotf#-Wl,-no-whole-archive#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic"
	else
	    # serial
	    sicortexlink="-L$vampirtracedir/$vampirtracelibdir#-lvt#-lotf#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic"
	fi

    fi

    fixmakeargs="$fixmakeargs SICORTEX sicortexlink=${sicortexlink}"
fi


######################################################################
# If the default gcc/g++ is not used, Modify the Makefiles...
# Choose the c++ and cc compiler

case $machine in
   tc2000 | ksr1 | c90 | cray | t3e | crayx1 | craysv1)
     if [ $cxx_compiler = default ]
       then
         cxx_compiler=CC
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=cc             
     fi
     ;;
   
   nec) 
     if [ $cxx_compiler = default ]
       then
         cxx_compiler=c++
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=cc             
     fi
     ;;

   apple) 
     if [ $cxx_compiler = default ]
       then
         cxx_compiler=g++
     fi

     # To fix the  make install  clash with INSTALL file in file systems 
     # that are case insensitive. Move INSTALL file to INSTALL.txt 
     if [ -f INSTALL ]
       then
	mv INSTALL INSTALL.txt
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=gcc             
     fi
     ;;


   cygwin) 
     if [ $cxx_compiler = default ]
       then
         cxx_compiler=g++
     fi

     # To fix the  make install  clash with INSTALL file in file systems 
     # that are case insensitive. Move INSTALL file to INSTALL.txt 
     if [ -f INSTALL ]
       then
	mv INSTALL INSTALL.txt
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=gcc             
     fi
     ;;

   alpha)
     if [ $cxx_compiler = default ]
       then
      # If it has the HP/Compaq cxx compiler, use it
	 if [ -d /lib/cmplrs/cxx ]
           then
             cxx_compiler=cxx
           else
             cxx_compiler=g++
         fi
	 c_compiler=cc
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=gcc
     fi
     ;;
  
   rs6000 | ibm64)
     if [ $cxx_compiler = default ]
       then
         # If it has the IBM xlC compiler, use it
	 if [ -f /usr/bin/xlC -o -f /usr/vacpp/bin/xlC ]
           then
             cxx_compiler=xlC_r
             c_compiler=xlc_r
           else
             cxx_compiler=g++
         fi
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=gcc
     fi
     ;;
  
   bgl)
    if [ $cxx_compiler = default ]
    then
      cxx_compiler=blrts_xlC
      c_compiler=blrts_xlc
    fi
    ;;

   bgp)
    if [ $cxx_compiler = default ] ; then
      cxx_compiler=mpixlcxx_r
      c_compiler=mpixlc_r
    elif [ $cxx_compiler = mpicxx ] ; then
      cxx_compiler=mpicxx
      c_compiler=mpicc
      gnu=yes
      fixmakeargs="$fixmakeargs GNU BGP_GFORTRAN"
    fi
    ;;

    xt3)
    catamount=yes
    if [ $cxx_compiler = default ] ; then
	cxx_compiler=CC
	c_compiler=cc
	default_fortran=pgi
	if [ "x$PE_ENV" = xPGI ] ; then
	    #tauoptions="${tauoptions}-pgi"
	    pgi=yes
	    default_fortran=pgi
	elif [ "x$PE_ENV" = xGNU ] ; then
	    gnu=yes
	    tauoptions="${tauoptions}-gnu"
	    default_fortran=gnu
	elif [ "x$PE_ENV" = xPATHSCALE ] ; then
	    tauoptions="${tauoptions}-pathscale"
	    default_fortran=pathscale
	fi
	if [ $fortran_compiler = no ] ; then
	    fortran_compiler=$default_fortran
	fi
    fi
    ;;

    craycnl)
    if [ $cxx_compiler = default ] ; then
	cxx_compiler=CC
	c_compiler=cc
	default_fortran=pgi
	if [ "x$PE_ENV" = xPGI ] ; then
	    #tauoptions="${tauoptions}-pgi"
	    pgi=yes
	    default_fortran=pgi
	elif [ "x$PE_ENV" = xGNU ] ; then
	    gnu=yes
	    tauoptions="${tauoptions}-gnu"
	    default_fortran=gfortran
	elif [ "x$PE_ENV" = xPATHSCALE ] ; then
	    tauoptions="${tauoptions}-pathscale"
	    default_fortran=pathscale
	fi
	if [ $fortran_compiler = no ] ; then
	    fortran_compiler=$default_fortran
	fi
    fi
    ;;
   hitachi)
     if [ $cxx_compiler = default ]
       then
	 cxx_compiler=KCC
	 c_compiler=cc
       fi

    if [ $fortran_compiler = no ] 
      then 
        fixmakeargs="$fixmakeargs HITACHI_FORTRAN"
        fortran_compiler=yes
      fi
    ;;

   sgi4k | sgi8k | sgin32 | sgi64)
     if [ $cxx_compiler = default ]
       then
	# SGI has no 64 bit C++ compiler except "CC", so if we are an
	# R8K, we have to use "CC"
	if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ]
	  then 
	    cxx_compiler=CC
            c_compiler=cc
	  else
            # We are an SGI R4K-based machine, use NCC if available
	    if [ -f /bin/NCC ]
              then
                cxx_compiler=NCC
                c_compiler=cc
              else
                cxx_compiler=g++
            fi
          fi
        fi
     if [ $c_compiler = default ]
       then
         c_compiler=gcc
     fi
     ;;
  
   *)
     if [ $cxx_compiler = default ]
       then
         cxx_compiler=g++
         if [ $fortran_compiler = no ] ; then
             fortran_compiler=gfortran
         fi
     fi

     if [ $c_compiler = default ]
       then
         c_compiler=gcc             
     fi
     ;;

esac

if [ "$machine" = "apple" ] ; then
  compiler_name=`which $cxx_compiler | awk '{print $1;}'`
  if [ "$compiler_name" = "no" -o "$compiler_name" = "" ]; then
    echo "NOTE: No compilers found, please use option '-c++=<compilername>' if you have a C++ compiler" 
    architecture=$machine
    make_directories
    configure_java
    configure_perfexplorer
		cp tools/src/common/resources/tau-medium.png apple/lib/
    exit 0
  fi
fi


######################################################################
# For template instantiations in the library -ptused for CC compilers
if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ] 
  then
  if [ $cxx_compiler = CC ]
    then
      fixmakeargs="$fixmakeargs SGICC"
      if [ $pdt = yes -a $pdt_cxx_compiler = default ]
        then
 	  fixmakeargs="$fixmakeargs PDTSGICC"
      fi
  fi
fi

if [ $machine = hitachi ]
  then
    fixmakeargs="$fixmakeargs HITACHI"
fi
   
if [ $machine = t3e -a $cxx_compiler = CC ] 
  then
    fixmakeargs="$fixmakeargs CRAYCC"
fi

if [ $machine = crayx1 -o $machine = craysv1 -a $cxx_compiler = CC ]
  then
    fixmakeargs="$fixmakeargs CRAYX1CC"
fi

######################################################################
# Set default Profiling Options in Makefiles
if [ $profile = no -a $trace = no -a $mpitrace = no  -a $machine != default ]
  then
    echo "-PROFILE and/or -TRACE should be specified. Choosing -PROFILE as the default"
    profile=yes 
fi
 
if [ $profile = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILE"
fi

if [ $java = yes ]
  then
    tauoptions="${tauoptions}-jdk"
fi

if [ $profilecalls = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILECALLS"
fi

if [ $profilestats = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILESTATS"
fi

if [ $profilememory = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILEMEMORY"
    tauoptions="${tauoptions}-memory"
fi

if [ $profileheadroom = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILEHEADROOM"
    tauoptions="${tauoptions}-headroom"
fi

if [ $tag = yes ]
then
  tauoptions="${tauoptions}-${tautag}"
fi
  
if [ $callpath = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILECALLPATH"
    tauoptions="${tauoptions}-callpath"
fi

if [ $profileparam = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILEPARAM"
    tauoptions="${tauoptions}-param"
fi

if [ $depthlimit = yes ]
  then
    fixmakeargs="$fixmakeargs DEPTHLIMIT"
    tauoptions="${tauoptions}-depthlimit"
fi

if [ $phase = yes ]
  then
    fixmakeargs="$fixmakeargs PROFILECALLPATH PROFILEPHASE"
    tauoptions="${tauoptions}-phase"
   if [ $callpath = yes ]
   then
     echo "ERROR: Incompatible options specified."
     echo "You must choose between -PROFILECALLPATH and -PROFILEPHASE. You cannot choose both!!"
     exit 1
   fi
fi

if [ $setnode0 = yes -a $trace = no ]
  then
    fixmakeargs="$fixmakeargs SETNODE0"
    tauoptions="${tauoptions}-setnode"
fi

if [ $comm = no ]
  then
    fixmakeargs="$fixmakeargs NOCOMM"
    tauoptions="${tauoptions}-nocomm"
fi

if [ $iowrapper = yes ] ; then
    fixmakeargs="$fixmakeargs IOWRAPPER"
fi    

if [ $profilecallstack = yes ]
  then
      fixmakeargs="$fixmakeargs CALLSTACK"
fi

if [ $stff = yes ]
  then
      fixmakeargs="$fixmakeargs RENCI_STFF stffdir=${stffdir} sddfdir=${sddfdir}"
      tauoptions="${tauoptions}-stff"
      if [ $sddf = no -o "x$sddfdir" = "x" ]; then
          echo "Error: Must specify -sddf=/path/to/sddflib along with -stff=/path/to/stfflib!"
      fi
fi

if [ $trace = yes ]
  then
    cat <<EOF > tau_type_test.c
  #include <include/Profile/tau_types.h>

  int main(int argc, char **argv) {
    if (sizeof(x_int8) != 1 ||
        sizeof(x_int16) != 2 ||
        sizeof(x_int32) != 4 ||
        sizeof(x_int64) != 8) {
        return -1;
    }
    return 0;
  }
EOF
    
    if [ $catamount = no -a ! $machine = bgl -a ! $machine = bgp -a ! $machine = mips -a ! $machine = mips32 ] ; then
	$echo "Checking type sizes... ${nnl}"
	if $c_compiler -I. $orig_useropt tau_type_test.c -o tau_type_test 1> /dev/null 2>&1 ; then
	    if ./tau_type_test 1> /dev/null 2>&1 ; then
		echo "ok"
	    else
		echo ""
		echo ""
		echo "Warning: couldn't find correct type sizes!"
		echo "Please contact tau-bugs@cs.uoregon.edu with your system details"
		echo ""
	    fi
	else
	    echo ""
	    echo ""
	    echo "Warning: couldn't find correct type sizes!"
	    echo "Please contact tau-bugs@cs.uoregon.edu with your system details"
	    echo ""
	fi
	rm -f tau_type_test.c tau_type_test
    fi
    
    fixmakeargs="$fixmakeargs TRACE"
fi

if [ $mpitrace = yes ]
  then
    fixmakeargs="$fixmakeargs MPITRACE"
fi

if [ $monitor = yes ]
  then
    fixmakeargs="$fixmakeargs MONITOR"
fi

if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ] 
  then
  if [ $profilecounters = yes ]
    then
      fixmakeargs="$fixmakeargs SGICOUNTERS"
      tauoptions="${tauoptions}-counters"
  fi
fi

if [ $linuxtimers = yes ]
then
  fixmakeargs="$fixmakeargs LINUXTIMERS"
  tauoptions="${tauoptions}-linuxtimers"
fi

if [ $alphatimers = yes ]
then
  fixmakeargs="$fixmakeargs ALPHATIMERS"
  tauoptions="${tauoptions}-alphatimers"
fi

if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ] 
  then
  if [ $profilecounters = no -a $sgitimers = yes ]
    then
      fixmakeargs="$fixmakeargs SGITIMERS"
      tauoptions="${tauoptions}-sgitimers"
  fi
fi

if [ $bgltimers = yes -a $machine = bgp ]
then
  echo "WARNING: You configured -BGLTIMERS on BGP. Changing it to -BGPTIMERS."
  bgptimers=yes
  bgltimers=no
fi

if [ $bgptimers = yes -a $machine = bgl ]
then
  echo "WARNING: You configured -BGPTIMERS on BGL. Changing it to -BGLTIMERS."
  bgptimers=no
  bgltimers=yes
fi

if [ $bgltimers = yes ]
then
  fixmakeargs="$fixmakeargs BGLTIMERS"
  tauoptions="${tauoptions}-bgltimers"
fi

if [ $bgptimers = yes ]
then
  fixmakeargs="$fixmakeargs BGPTIMERS"
  tauoptions="${tauoptions}-bgptimers"
fi

if [ $craytimers = yes ]
then
  fixmakeargs="$fixmakeargs CRAYTIMERS"
  tauoptions="${tauoptions}-craytimers"
fi

if [ $cputime = yes ]
  then
    fixmakeargs="$fixmakeargs CPUTIME"
fi

if [ $javacputime = yes ]
  then
    fixmakeargs="$fixmakeargs JAVACPUTIME"
fi

if [ $papiwallclock = yes ]
  then
    fixmakeargs="$fixmakeargs PAPIWALLCLOCK"
    tauoptions="${tauoptions}-papiwallclock"
fi

if [ $multiplecounters = yes ]
  then
    fixmakeargs="$fixmakeargs MULTIPLECOUNTERS"
    tauoptions="${tauoptions}-multiplecounters"
    if [ $profilecalls = yes -o $profilestats = yes -o $profilecounters = yes ]
    then
      echo "******** ERROR : -MULTIPLECOUNTERS option is incompatible with "
      echo "**************** -PROFILECOUNTERS, -PROFILECALLS, or -PROFILESTATS"
      echo "**************** Please reconfigure TAU without these."
      echo "******** EXITING .... "
      exit 1
    fi
fi

if [ $papivirtual = yes ]
  then
    fixmakeargs="$fixmakeargs PAPIVIRTUAL"
    tauoptions="${tauoptions}-papivirtual"
fi

if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ] 
  then
  if [ $cxx_compiler = g++ ]
    then
      fixmakeargs="$fixmakeargs SGIGNU"
  fi
fi

if [ $machine = freebsd ]
then
    fixmakeargs="$fixmakeargs FREEBSD"
fi
    
if [ $machine = apple ]
  then
  if [ $cxx_compiler = g++ -o $cxx_compiler = c++  -o $cxx_compiler = icpc ]
    then
      fixmakeargs="$fixmakeargs APPLECXX"
  fi
  if [ $fortran_compiler = ibm -o $fortran_compiler = ibm64 ]
    then
      fixmakeargs="$fixmakeargs IBMXLFAPPLE"
      extradir=`which xlf90 | sed s/xlf90/../`
      fortran_compiler=yes
  fi
  # xlc++ doesn't like include/Memory. Move this directory
  if [ -d include/Memory -a ! -d include/MemoryWrapper ] 
  then
    mv include/Memory include/MemoryWrapper	
  else
    if [ -d include/Memory -a -d include/MemoryWrapper ]
    then 
      /bin/rm -rf include/Memory
    fi 
  fi
fi

if [ $machine = ppc64 -o $machine = bgl -o $machine = bgp ]
then
  if [ $cxx_compiler = g++ ]
  then
    if [ $fortran_compiler = no ] 
    then
      extradir=`which xlf90 | sed s/xlf90/../`
      fixmakeargs="$fixmakeargs IBM_FORTRAN"
    fi
  fi
fi

if [ $machine = ibm64 -o $machine = ibm64linux ]
then
  if [ $cxx_compiler = g++ -o $cxx_compiler = powerpc64-linux-g++ ]
  then
    if [ $fortran_compiler = no ] 
    then
      extradir=`which xlf90 | sed s/xlf90/../`
      fixmakeargs="$fixmakeargs IBM64_FORTRAN"
    fi
  fi
fi

if [ $machine = t3e -a $cxx_compiler = KCC ]
  then
    fixmakeargs="$fixmakeargs CRAYKAI"
    if [ $fortran_compiler = no ] 
    then 
      fixmakeargs="$fixmakeargs CRAY_FORTRAN"
      fortran_compiler=yes
    fi
fi

if [ $machine = crayx1 -o $machine = craysv1 ]
  then 
    if [ $fortran_compiler = no ]
    then
      fixmakeargs="$fixmakeargs CRAY_X1_FORTRAN"
      fortran_compiler=yes
    fi
fi


if [ $debugprof = yes ]
  then
    fixmakeargs="$fixmakeargs DEBUGPROF"
fi

if [ $inteltflop = yes ]
  then
      fixmakeargs="$fixmakeargs INTELTFLOP"
fi 
    


######################################################################
# Set default C++ compiler in all Makefiles
case $cxx_compiler in
   CC)
      echo "Default C++ compiler will be CC"
      fixmakeargs="$fixmakeargs USE_CFRONT"
      ;;

   *g++)
      echo "Default C++ compiler will be " \
         `gcc -v 2>&1 | tail -1 | sed 's/gcc/g++/g'`
      gnu=yes
      # No fixmakeargs needed because it is the default
      ;;

   egcs)
      echo "Default C++ compiler will be " \
         `egcs -v 2>&1 | tail -1 | sed 's/gcc/egcs/g'`
      # No fixmakeargs needed because it is the default
      ;;

   cxx)
      echo "Default C++ compiler will be the HP Tru64 cxx C++ compiler"
      fixmakeargs="$fixmakeargs USE_DECCXX"
      if [ $fortran_compiler = no ]
      then 
        f90loaded=`which f90 | sed -e 's/f90/../g' | grep "^no"`
        if [ "x$f90loaded" = "x" ]
        then
    	  # f90 module has been loaded and which f90 returns a path	
          extradir="`which f90 | sed s/f90/../`"
	  echo "Found f90 in `which f90`"
        fi
        fixmakeargs="$fixmakeargs COMPAQ_FORTRAN"
        fortran_compiler=yes
      fi
      ;;

   *xl*)
      echo "Default C++ compiler will be IBMs xlC C++ compiler"
      fixmakeargs="$fixmakeargs USE_IBMXLC COMPINST_XL"
      if [ "$machine" = "apple" ] 
      then
        fixmakeargs="$fixmakeargs IBMXLCAPPLE"
	if [ $fortran_compiler = no ] 
        then
          fixmakeargs="$fixmakeargs IBMXLFAPPLE"
        fi
      fi
      ibmxlc=yes

      if [ "$machine" = "bgp" ] ; then
	  ibm_compiler=bgxlC_r
      else 
	  ibm_compiler=$cxx_compiler
      fi
      compilerLocation=`which $ibm_compiler`

      if [ "x$compilerLocation" = "x/usr/bin/$ibm_compiler" ] ; then
	  # if xlc or blrts_xlc is found in /usr/bin, it is likely a
	  # symlink.  Since we use ../lib to locate the libraries
	  # we will dereference the symlink once.  Don't do it more 
          # than once, or you'll end up with the wrong thing

	  # check for readlink first
	  readlink=`which readlink`
	  if [ "x$readlink" != "x" ] ; then
	      if [ -x "$readlink" ] ; then
		  if [ -h $compilerLocation ] ; then
		      compilerLocation=`readlink $compilerLocation`
		  fi
	      fi
	  fi
      fi

      extradircxx=`echo $compilerLocation | sed s/$ibm_compiler/../`

      extradir=`which xlf90 | sed s/xlf90/../`
      if [ $fortran_compiler = no ] 
      then
	if [ "$machine" = "ibm64" -o "$machine" = "ibm64linux" ]
        then
          fixmakeargs="$fixmakeargs IBM64_FORTRAN"
	else
          fixmakeargs="$fixmakeargs IBM_FORTRAN"
	fi
        fortran_compiler=yes
      fi
      threadtest=`echo $ibm_compiler | sed -e 's/_r//'`
      if [ "y$threadtest" = "y$ibm_compiler" ]
      then
	echo "Not using the thread-safe version of the IBM compiler"
      else
	ibmxlc_r=yes
        fixmakeargs="$fixmakeargs THREADSAFE_COMPILERS"
	echo "Using thread-safe version of the IBM compiler"
        threadsafe=yes
      fi
      ;;

   NCC)
      echo "Default C++ compiler will be SGI's Delta C++ compiler"
      fixmakeargs="$fixmakeargs USE_SGINCC"
      ;;
   
   KCC)
      echo "Default C++ compiler will be KAI KCC C++ Compiler"
      kai=yes
      fixmakeargs="$fixmakeargs KAI"
      ;;

   pgCC)
      echo "Default C++ compiler will be PGI pgCC C++ Compiler"
      pgi=yes
      pgiflag=`pgCC -help | head -1 | grep 1.7 | wc -l` 
	
      fixmakeargs="$fixmakeargs COMPINST_PGI"

      if [ $pgiflag = 1 ] 
      then
	echo  "Using PGI ver 1.7 Compiler"
        fixmakeargs="$fixmakeargs PGI PGI1.7"
      else
        fixmakeargs="$fixmakeargs PGI PGICC"
      fi

      if [ $fortran_compiler = no ]
      then 
        extradir=`which pgCC | sed s/pgCC/../`
        fixmakeargs="$fixmakeargs PGI_FORTRAN"
        fortran_compiler=yes
      fi
      ;;

   FCC)
      echo "Default C++ compiler will be Fujitsu C++ Compiler"	 
      fujitsu=yes
      fixmakeargs="$fixmakeargs FUJITSU"
      if [ $fortran_compiler = no ]
      then 
        extradir=`which FCC | sed s/FCC/../`
        fixmakeargs="$fixmakeargs FUJITSU_FORTRAN"
        fortran_compiler=yes
      fi
      if [ $machine = solaris2 -o $machine = solaris2-64 ] 
      then
        extradir=`which FCC | sed s/FCC/../`
        fixmakeargs="$fixmakeargs FUJITSU_SOLARIS"
        fortran_compiler=yes
      fi
      ;;

   guidec++)
      echo "Default C++ compiler will be KAI KAP/Pro OpenMP guidec++ Compiler"
      kai=yes
      fixmakeargs="$fixmakeargs KAI GUIDE OPENMP"
      openmp=yes
      tauoptions="${tauoptions}-guide"
      if [ $fortran_compiler = no ]
      then
        fixmakeargs="$fixmakeargs KAI_FORTRAN"
        guidef90=yes
        fortran_compiler=yes
      fi
        
      ;;

   aCC)
      echo "Default C++ compiler will be HP aCC Compiler"
      fixmakeargs="$fixmakeargs ACC"
      tauoptions="${tauoptions}-acc"
      if [ $fortran_compiler = no ]
      then
        fixmakeargs="$fixmakeargs HP_FORTRAN"
        fortran_compiler=yes
      fi
        
      ;;
   orCC)
      echo "Default C++ compiler will ORC Open64 orCC compiler"
      fixmakeargs="$fixmakeargs OPEN64ORC"
      tauoptions="${tauoptions}-orcc"
      if [ $c_compiler = default ] 
      then
        c_compiler=orcc
      fi

      if [ $fortran_compiler = no ] 
      then
        fixmakeargs="$fixmakeargs OPEN64ORC_FORTRAN"
        fortran_compiler=yes
      fi
     
      if [ $openmp = yes ]
      then
	fixmakeargs="$fixmakeargs OPEN64_OPENMP"
      fi

      ;;

   c++)
        if [ $machine = nec ]
	then
          echo "Default C++ compiler will be NEC c++ compiler"
          fixmakeargs="$fixmakeargs USE_NECCXX"
          tauoptions="${tauoptions}-cxx"
          if [ $fortran_compiler = no ]
          then 
            extradir=`which f90 | sed s/f90/../`
            fixmakeargs="$fixmakeargs NEC_FORTRAN"
            fortran_compiler=yes
          fi
        else
          echo "Default C++ compiler will be Apple c++ compiler"
          fixmakeargs="$fixmakeargs APPLECXX"
          tauoptions="${tauoptions}-cxx"
        fi 

      ;;

   ecpc)
      echo "Default C++ compiler will be Intel ecpc C++ compiler"
      fixmakeargs="$fixmakeargs USE_INTELCXX"
      tauoptions="${tauoptions}-ecpc"
      intel=yes
      if [ $fortran_compiler = no ]
      then
        fixmakeargs="$fixmakeargs INTEL_FORTRAN"
        fortran_compiler=intel
        extradir=`which efc | sed s/efc/../`
      fi

      if [ $intelcxxlibicc = yes ]
      then
        fixmakeargs="$fixmakeargs INTELCXXLIBICC"
      fi

      ;;
	
   icpc)
      echo "Default C++ compiler will be Intel icpc C++ compiler"
      fixmakeargs="$fixmakeargs USE_INTELCXX COMPINST_INTEL9"
      tauoptions="${tauoptions}-icpc"
      intel=yes
      if [ $fortran_compiler = no ]
      then
        fixmakeargs="$fixmakeargs INTEL32_FORTRAN"
        fortran_compiler=intel
        intelifort=`which ifort 2>/dev/null`
        if [ "y$intelifort" != "y"  -a -x "$intelifort" ]
        then 
          extradir=`which ifort | sed -e 's/\/bin\/ifort$//'`
        fi
      fi
      if [ $intelcxxlibicc = yes ]
      then
        fixmakeargs="$fixmakeargs INTELCXXLIBICC"
      fi

      ;;
   pathCC|scpathCC)
      echo "Default C++ compiler will be PathScale pathCC C++ compiler"
      fixmakeargs="$fixmakeargs USE_PATHCC COMPINST_GNU"
      tauoptions="${tauoptions}-pathcc"
      pathscale=yes
      if [ $fortran_compiler = no ]
      then
        fixmakeargs="$fixmakeargs PATHSCALE_FORTRAN"
        fortran_compiler=pathscale
      fi

      ;;

    qk-pgCC)
      echo "Default C++ compiler will be PGI pgCC C++ Compiler"
      pgi=yes
      fixmakeargs="$fixmakeargs PGI PGICC COMPINST_PGI"
      fixmakeargs="$fixmakeargs PGINOPRELINK"

      if [ $fortran_compiler = no ]
      then 
        extradir=`which pgCC | sed s/pgCC/../`
        fixmakeargs="$fixmakeargs PGI_FORTRAN PGI_CATAMOUNT"
        fortran_compiler=yes
      fi
      ;;

    mpicxx)
	if [ $machine = bgp ] ; then
	    echo "Using GNU Compilers for BGP"
	    tauoptions="${tauoptions}-gnu"
	else
	    echo "ERROR Unknown C++ compiler: $cxx_compiler"
	    exit 1
	fi
	;;
   *)
      echo "ERROR Unknown C++ compiler: $cxx_compiler"
      exit 1
      ;;

esac

######################################################################
# Set default F90 compiler in all Makefiles
case $fortran_compiler in
   gnu)
      echo "Default Fortran compiler will be GNU g77"
      fixmakeargs="$fixmakeargs GNU_FORTRAN"
      ;;

   gfortran)
      echo "Default Fortran compiler will be GNU gfortran"
      if [ $cxx_compiler = scg++ ] 
      then
        fixmakeargs="$fixmakeargs SC_GFORTRAN"
      else
	taugfortranlibdir=`gfortran -print-libgcc-file-name | sed s/libgcc.a//`
	fixmakeargs="$fixmakeargs taugfortranlibdir=$taugfortranlibdir" 
        fixmakeargs="$fixmakeargs GNU_GFORTRAN"
      fi
      ;;

   g95)
      echo "Default Fortran compiler will be G95"
      fixmakeargs="$fixmakeargs G95_FORTRAN"
      extradir=`g95 -print-libgcc-file-name | sed s/libgcc.a//`
      echo extra=$extradir
      ;;

   sgi)
      echo "Default Fortran compiler will be SGI f90"
      fixmakeargs="$fixmakeargs SGI_FORTRAN"
      ;;

   ibm)
      echo "Default Fortran compiler will be IBM xlf90"
      extradir=`which xlf90 | sed s/xlf90/../`
      fixmakeargs="$fixmakeargs IBM_FORTRAN"
      ;;

   ibm64)
      echo "Default Fortran compiler will be IBM xlf90 (64 bits)"
      extradir=`which xlf90 | sed s/xlf90/../`
      fixmakeargs="$fixmakeargs IBM64_FORTRAN"
      ;;

   hp)
      echo "Default Fortran compiler will be HP f90"
      extradir=`which f90 | sed s/f90/../`
      fixmakeargs="$fixmakeargs HP_FORTRAN"
      ;;

   cray)
      echo "Default Fortran compiler will be Cray f90"
      if [ $machine = crayx1 -o $machine = craysv1 ] 
      then 
        fixmakeargs="$fixmakeargs CRAY_X1_FORTRAN"
      else
        fixmakeargs="$fixmakeargs CRAY_FORTRAN"
      fi
      ;;

   pgi)
      echo "Default Fortran compiler will be PGI"
      extradir=`which pgCC | sed s/pgCC/../`
      fixmakeargs="$fixmakeargs PGI_FORTRAN"
      ;;

   absoft)
      echo "Default Fortran compiler will be Absoft f90"
      extradir="`which f90 | sed s/f90/../`"
      fixmakeargs="$fixmakeargs ABSOFT_FORTRAN"
      ;;

   fujitsu)
      echo "Default Fortran compiler will be Fujitsu F90"
      extradir=`which FCC | sed s/FCC/../`
      fixmakeargs="$fixmakeargs FUJITSU_FORTRAN"
      ;;

   nec)
      echo "Default Fortran compiler will be NEC f90"
      extradir=`which f90 | sed s/f90/../`
      fixmakeargs="$fixmakeargs NEC_FORTRAN"
      ;;

   lahey)
      echo "Default Fortran compiler will be Lahey lf95"
      extradir=`which lf95 | sed s/lf95/../`
      if [ -d $extradir/lib64 ]
      then
        fixmakeargs="$fixmakeargs LAHEY64_FORTRAN"
      else
        fixmakeargs="$fixmakeargs LAHEY_FORTRAN"
      fi
      ;;

   nagware)
      echo "Default Fortran compiler will be Nagware f95"
      extradir=`which f95 | sed s@\/f95@\/..@`
      fixmakeargs="$fixmakeargs NAGWARE_FORTRAN"
      ;;

   pathscale)
      echo "Default Fortran compiler will be Pathscale pathf95"
      if [ $cxx_compiler = scpathCC -o $cxx_compiler = scg++ ] 
      then
        extradir=`which scpathf95 | sed s@\/scpathf95@\/..@`
        fixmakeargs="$fixmakeargs SC_PATHSCALE"
      else
        extradir=`which pathf95 | sed s@\/pathf95@\/..@`
        fixmakeargs="$fixmakeargs PATHSCALE_FORTRAN"
      fi
      ;;

   sun)
      echo "Default Fortran compiler will be SUN f90" 
      fixmakeargs="$fixmakeargs SUN_FORTRAN"
      ;;

   compaq)
      echo "Default Fortran compiler will be HP Tru64 f90"
      f90loaded=`which f90 | sed -e 's/f90/../g' | grep "^no"`
      if [ "x$f90loaded" = "x" ]
      then
        # f90 module has been loaded and which f90 returns a path
        extradir="`which f90 | sed s/f90/../`"
        echo "Found f90 in `which f90`"
      fi
      fixmakeargs="$fixmakeargs COMPAQ_FORTRAN"
      ;;

   kai)
      echo "Default Fortran compiler will be KAI guidef90"
      fixmakeargs="$fixmakeargs KAI_FORTRAN"
      guidef90=yes
      ;;

   open64)
      echo "Default Fortran compiler will be ORC Open64 orf90"
      fixmakeargs="$fixmakeargs OPEN64ORC_FORTRAN"
      ;;  

   intel)
      if [ $cxx_compiler = ecpc ]
      then
        echo "Default Fortran compiler will be Intel efc"
        fixmakeargs="$fixmakeargs INTEL_FORTRAN"
      else
        echo "Default Fortran compiler will be Intel ifort"
        fixmakeargs="$fixmakeargs INTEL32_FORTRAN"
        intelifort=`which ifort 2>/dev/null`
        if [ "y$intelifort" != "y" -a -x "$intelifort" ]
        then 
          extradir=`which ifort | sed -e 's/\/bin\/ifort$//'`
        fi
      fi
      ;;
   no)
      ;;

   *)
      ;;

esac

# Encode the full path of the C++/C compiler in the stub Makefile
full_cxx_compiler=`which $cxx_compiler`
full_cc_compiler=`which $c_compiler`
fixmakeargs="$fixmakeargs fullcxx=$full_cxx_compiler fullcc=$full_cc_compiler"





######################################################################
# Set MPI options. First set the include dir if it is not specified
if [ $mpi = yes -a $machine = ibm64 ]
then
  ibmxlc_r=yes
  echo "Enabling threaded MPI libraries for IBM64"
  if [ $threadsafe = no ]
  then
    fixmakeargs="$fixmakeargs THREADSAFE_COMPILERS"
    threadsafe=yes
  fi
fi

if [ $mpi = yes -a "x$mpiinc" = "x" ] 
then
  case $machine in 
  rs6000|ibm64)
	mpiinc=/usr/lpp/ppe.poe/include
	mpiincf90dir='-I/usr/lpp/ppe.poe/include/thread'
	if [ $machine = ibm64 ]
	then
	  mpiincf90dir='-I/usr/lpp/ppe.poe/include/thread64'
	fi 

        if [ $ibmxlc_r = yes ] 
        then
          additional_mpiincs='-I/usr/lpp/ssp/css/include'
        fi
	additional_mpiincs="$additional_mpiincs $mpiincf90dir"
        ;;
  bgl)
	mpiinc=/bgl/BlueLight/ppcfloor/bglsys/include
        ;;
  bgp)
	mpiinc=/bgsys/drivers/ppcfloor/comm/include
        ;;
  t3e|crayx1|craysv1)
	mpiinc=/opt/ctl/mpt/mpt/include
	;;
  xt3)
	mpiinc=/opt/xt-mpt/default/mpich2-64/P2/include
	;;
  craycnl)
	mpiinc=/opt/xt-mpt/default/mpich2-64/P/include
	;;
  solaris2*)
	mpiinc=/opt/SUNWhpc/include
	;;
  *)
        mpiinc=`which mpirun | sed -e 's/\/bin\/mpirun$//'`/include
        if [ -d $mpiinc ]
        then
          echo "Using MPI include directory $mpiinc"
        fi
	;;
  esac
fi

# Add threaded include dir to the MPI include dir for IBM 
if [ "x$mpiinc" != "x" ] 
then
  case $machine in 
    rs6000)
      if [ -d /usr/lpp/ppe.poe/include/thread ] 
      then 
        mpiincf90dir='-I/usr/lpp/ppe.poe/include/thread'
      fi
      if [ $ibmxlc_r = yes ] 
      then
        additional_mpiincs='-I/usr/lpp/ssp/css/include'
      fi
      additional_mpiincs="$additional_mpiincs $mpiincf90dir"
      ;;
    ibm64)
      if [ -d /usr/lpp/ppe.poe/include/thread64 ] 
      then 
        mpiincf90dir='-I/usr/lpp/ppe.poe/include/thread64'
      fi
      if [ $ibmxlc_r = yes ] 
      then
        additional_mpiincs='-I/usr/lpp/ssp/css/include'
      fi
      additional_mpiincs="$additional_mpiincs $mpiincf90dir"
      ;;
    *)
      ;;
  esac
fi


if [ $mpi = yes -a "x$mpilib" = "x" ]
then
  case $machine in 
  rs6000|ibm64) 
	mpilib=/usr/lpp/ppe.poe/lib
        if [ $ibmxlc_r = yes ] 
        then
          additional_mpilibs='-L/usr/lpp/ppe.poe/lib/threads -L/usr/lpp/ssp/css/lib -llapi_r'
        fi
	;;
  bgl)
        mpilib=/bgl/BlueLight/ppcfloor/bglsys/lib
	additional_mpilibs='-lmsglayer.rts -ldevices.rts -lrts.rts -ldevices.rts'
        ;;
  bgp)
        mpilib=/bgsys/drivers/ppcfloor/comm/lib
	additional_mpilibs='-ldcmfcoll.cnk -ldcmf.cnk -lpthread -L/bgsys/drivers/ppcfloor/runtime/SPI -lSPI.cna' 
	;;
  t3e|crayx1|craysv1)  
	mpilib=/opt/ctl/mpt/mpt/lib/
	;;
  xt3)
	mpilib=/opt/xt-mpt/default/mpich2-64/P2/lib
	;;
  craycnl)
	mpilib=/opt/xt-mpt/default/mpich2-64/P/lib
	;;
  solaris2*)
	mpilib=/opt/SUNWhpc/lib
	;;
  *)    
        mpilib=`which mpirun | sed -e 's/\/bin\/mpirun$//'`/lib
        if [ -d $mpilib ]
        then
          echo "Using MPI lib directory $mpilib"
        fi
	;;
  esac
fi


# Next, check the properties of the MPI implementation.
if [ "x$mpiinc" != "x" -o "x$mpilib" != "x" -o $mpi = yes ]
then
  #echo "MPI is specified"
  mpi=yes
  fixmakeargs="$fixmakeargs MPI"
  tauoptions="${tauoptions}-mpi"

  mpicompiler=$cxx_compiler
  msuf=C

  if [ $machine = t3e ]
  then
    mpicompiler=$c_compiler
    msuf=c
  fi
  cat <<EOF > mpi_thread_test.$msuf
  #include <mpi.h>

  int main(int argc, char **argv)
  {
    int ret, req, provided;
    ret = PMPI_Init_thread(&argc, &argv, req, &provided);
    return ret;
  }
EOF
  if [ "x$mpiinc" != "x" ]
  then
    # echo "mpiinc is specified"
    mpi_include=-I$mpiinc
  fi
     
  cat <<EOF > mpi2.$msuf
  #include <mpi.h>

  int foo(MPI_Win win)
  {
    int ret;
    ret = MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
    return ret;
  }
EOF

  cat <<EOF > mpi2iorequest.$msuf
  #include <mpi.h>

  int foo (MPI_File fh, void *buf, int count,
                          MPI_Datatype datatype, MPIO_Request *request)
  {
    return MPI_File_iread_shared (fh, buf, count, datatype, request);

  }
EOF

cat <<EOF > mpi2attr.$msuf
  #include <mpi.h>

  int foo(MPI_Win_copy_attr_function *f1, MPI_Type_copy_attr_function *f2, 
        MPI_Comm_copy_attr_function *f3)
  {
    return 0;
  }

  int MPI_Type_get_attr(MPI_Datatype type, int type_keyval, void *attribute, int *flag)
  {
    return PMPI_Type_get_attr(type, type_keyval, attribute, flag);
  }
EOF

  cat <<EOF > mpi2typeex.$msuf
  #include <mpi.h>

  int f1( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype
  , MPI_Op op, MPI_Comm comm)
  {
    return MPI_Exscan( sendbuf, recvbuf, count, datatype, op, comm) ;
  }

  int f2( MPI_Datatype type, MPI_Datatype * newtype)
  {
    return MPI_Type_dup( type, newtype) ;
  }

  int f3( int p, int r, MPI_Datatype * newtype)
  {
    return MPI_Type_create_f90_real( p, r, newtype) ;
  }

  int f4( int p, int r, MPI_Datatype * newtype)
  {
    return MPI_Type_create_f90_complex( p, r, newtype) ;
  }


EOF

  cat <<EOF > mpi2add.$msuf
  #include <mpi.h>

  int f1( int * errorclass)
  {
    return MPI_Add_error_class( errorclass) ;
  }

  int f2( char * datarep, int incount, MPI_Datatype datatype, MPI_Aint * size)
  {
    return MPI_Pack_external_size( datarep, incount, datatype, size) ;
  }

EOF

  cat <<EOF > mpi2grequest.$msuf
  #include <mpi.h>

  int foo(MPI_Grequest_query_function *grequest_query_fn,
              MPI_Grequest_free_function *grequest_free_fn,
              MPI_Grequest_cancel_function *grequest_cancel_fn,
              void *extra_state, MPI_Request *request) 
  {
    return MPI_Grequest_start(grequest_query_fn,
              grequest_free_fn,
              grequest_cancel_fn,
              extra_state, request);

  }

  int bar(MPI_Request request)
  {
    return MPI_Grequest_complete(request);
  }

EOF
  cat <<EOF > mpi2datarep.$msuf
  #include <mpi.h>

  int foo( char * datarep, MPI_Datarep_conversion_function * read_conversion_fn, MPI_Datarep_conversion_function * write_conversion_fn, MPI_Datarep_extent_function * dtype_file_extent_fn, void * extra_state)
  {
    return MPI_Register_datarep( datarep, read_conversion_fn, write_conversion_fn, dtype_file_extent_fn, extra_state);

  }

EOF

  cat <<EOF > mpi2errhandler.$msuf
  #include <mpi.h>

  int foo (MPI_Comm_errhandler_fn *a, MPI_Errhandler *b)
  {
    return MPI_Comm_create_errhandler(a,b);
 
  }
  int bar (MPI_File_errhandler_fn * function, MPI_Errhandler * errhandler)
  {
    return MPI_File_create_errhandler(function, errhandler);
  }
EOF

  cat <<EOF > mpi2hpconst.$msuf
  #include <mpi.h>
  /* HP MPI uses const char * instead of char * in the 
     prototypes of the following routines */
  int foo(MPI_Info Info, const char *key, const char *value)
  { 
    return PMPI_Info_set(Info, key, value);
  }
  int f1(MPI_Info a, const char * b, int c, char * d, int *e) 
  {
    return PMPI_Info_get(a,b,c,d,e);
  }
  int f2(MPI_Info a, const char *b)
  {
    return PMPI_Info_delete(a,b);
  }
  int MPI_Info_get_valuelen(MPI_Info a, const char * b, int * c, int * d)
  { /* above decl triggers an error on T3E */
    return PMPI_Info_get_valuelen(a,b,c,d);
  }

EOF

cat << EOF > mpistatus.$msuf

  #include <mpi.h>
  #include <memory.h>
  int foo(MPI_Fint *status)
  {
    MPI_Status s;
    return MPI_Status_f2c(status, &s);
  }
EOF
  

  if [ $machine = sgi64 -a $cxx_compiler = CC ]
  then
    orig_useropt="$orig_useropt -64"
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi_thread_test.$msuf  1> /dev/null 2>&1
  then
    echo "Thread-safe MPI interface is defined... "
    fixmakeargs="$fixmakeargs MPI_THREADED"
  fi

  if [ -d "$mpiinc/ulm" ] ; then
      echo "LA-MPI detected, working around broken MPI_Request_c2f()"
      fixmakeargs="$fixmakeargs LAMPI"
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2.$msuf  1> /dev/null 2>&1
  then
    echo "MPI-2 Interface is defined..."
    # Wait don't enable this for SGI Altix. Their MPI2 is not complete
    if [ -r $mpilib/libmpi.so -a -r $mpilib/libmpi++.so -a -r $mpilib/libsma.so -a -r $mpilib/libxmpi.so ] 
    then
      echo "SGI MPI detected. Disabling MPI2 wrappers for SGI MPI"
    elif [ -r $mpilib/libfmpi.so -a -r $mpilib/libmpio.so  -a -r $mpilib/libtvscampi.so ] 
    then 
      # Wait. Scali does not use MPI2 PMPI interface properly. 
      echo "Scali MPI detected. Disabling MPI2 wrappers for Scali MPI"
    elif [ -r $mpilib/liblam.a -o -r $mpilib/liblam.la ] 
    then 
      # Wait. LAM MPI's MPI2 PMPI interface is broken. 
      echo "LAM MPI detected. Disabling MPI2 wrappers for LAM MPI"
    elif [ "$mpilibrary" = "-lscmpi" ] 
    then 
      # Wait. SiCortex's MPI2 interface is broken. 
      echo "SiCortex detected. Disabling MPI2 wrappers"
      fixmakeargs="$fixmakeargs MPICH_IGNORE_CXX_SEEK"
    elif [ "$tauarch" = "bgp" ] ; then
      echo "BGP MPI detected. Disabling MPI2 wrappers"
      fixmakeargs="$fixmakeargs MPICH_IGNORE_CXX_SEEK"
    else 
      fixmakeargs="$fixmakeargs MPI2"
      mpi2=yes
    fi

  fi
  if $mpicompiler $orig_useropt $mpi_include -c mpi2grequest.$msuf  1> /dev/null 2>&1
  then
    if [ $mpi2 = yes ]  
    then 
      echo "MPI-2 Grequest Interface is defined..."
      fixmakeargs="$fixmakeargs MPIGREQUEST"
    fi
  fi


  if [ -f $mpilib/liblam.a -o -f $mpilib/liblammpi++.a ] ; then
    if $mpicompiler $orig_useropt $mpi_include -c mpi2iorequest.$msuf  1> /dev/null 2>&1
    then
     if [ $mpi2 = yes ]  
     then 
       echo "MPI-2 MPIO_Request Interface is defined..."
       fixmakeargs="$fixmakeargs MPIOREQUEST"
       mpiio=yes
     fi
    fi
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2datarep.$msuf  1> /dev/null 2>&1
  then
    if [ $mpi2 = yes ]  
    then 
      echo "MPI-2 MPI_Datarep_conversion_function Interface is defined..."
      fixmakeargs="$fixmakeargs MPIDATAREP"
    fi
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2errhandler.$msuf  1> /dev/null 2>&1
  then
    if [ $mpi2 = yes ]  
    then 
      echo "MPI-2 Comm_create_errhandler Interface is defined..."
      fixmakeargs="$fixmakeargs MPIERRHANDLER"
    fi
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2hpconst.$msuf  1> /dev/null 2>&1
  then
    if [ $mpi2 = yes ]  
    then 
      echo "MPI-2 MPI_Info_set takes const char * instead of char * args"
      fixmakeargs="$fixmakeargs MPICONSTCHAR"
    fi
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2attr.$msuf  1> /dev/null 2>&1
  then
    echo "MPI-2 MPI*attr_functions are defined..."
    fixmakeargs="$fixmakeargs MPIATTR"
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2typeex.$msuf  1> /dev/null 2>&1
  then
    echo "MPI-2 MPI_Type_dup and MPI_Exscan are defined..."
    fixmakeargs="$fixmakeargs MPITYPEEX"
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpi2add.$msuf  1> /dev/null 2>&1
  then
    echo "MPI-2 MPI_Add_error* functions are defined..."
    fixmakeargs="$fixmakeargs MPIADDERROR"
  fi

  if $mpicompiler $orig_useropt $mpi_include -c mpistatus.$msuf  1> /dev/null 2>&1
  then
    echo "MPI_Status f2c/c2f found..."
  else
    echo "MPI_Status c2f/f2c functions are needed"
    fixmakeargs="$fixmakeargs MPINEEDSTATUSCONV"
  fi

  /bin/rm -rf mpi_thread_test.$msuf mpi_thread_test.o mpi2.$msuf mpi2.o mpi2iorequest.o mpi2iorequest.$msuf mpi2grequest.o mpi2grequest.$msuf mpi2datarep.$msuf mpi2datarep.o mpi2errhandler.o mpi2errhandler.$msuf mpi2hpconst.o mpi2hpconst.$msuf mpi2attr.o mpi2attr.$msuf mpi2typeex.o mpi2typeex.$msuf mpi2add.o mpi2add.$msuf mpistatus.o mpistatus.$msuf
else
  fixmakeargs="$fixmakeargs mpiincargs=$mpiincargs mpilibargs=$mpilibargs mpiflibargs=$mpiflibargs mpilib=$mpilib"
fi



  

if [ "x$mpiinc" != "x" ]
then 

    # Check for OpenMPI and add additional include directory
    if [ -d $mpiinc/openmpi ]
	then
	echo "NOTE: Using OpenMPI"
	additional_mpiincs="-I$mpiinc/openmpi/ompi -I$mpiinc/openmpi"
    fi

  if [ -d $mpiinc ]
  then
    #echo "Include dir found. adding -I$mpiinc to INC"
    mpiincargs="$mpiincargs -I$mpiinc $additional_mpiincs"
    mpiincargs=`echo $mpiincargs | sed  -e 's/ /#/g'`
    fixmakeargs="$fixmakeargs mpiincargs=$mpiincargs"
  fi
fi
  
  

if [ $tauprefix != unknown ]
  then
    tautoplevel=$tauprefix
  else
    tautoplevel=$tauroot
fi

if [ $perf = yes ] 
then
  fixmakeargs="$fixmakeargs PERFLIB"
  tauoptions="${tauoptions}-perf"
  if [ "x$perfincdir" != "x" ] 
  then
    fixmakeargs="$fixmakeargs perfincdir=$perfincdir"
  fi
  if [ "x$perflibdir" != "x" ] 
  then
    fixmakeargs="$fixmakeargs perflibdir=$perflibdir"
  fi
  if [ "x$perflibrary" != "x" ] 
  then
    fixmakeargs="$fixmakeargs perflibrary=$perflibrary"
  else
    if [ -f $perflibdir/libpapi.a ]
    then 
      perflibrary="-lperfrt#-lpapi"  
    else
      perflibrary="-lperfrt"
    fi 
    fixmakeargs="$fixmakeargs perflibrary=$perflibrary"
  fi
fi

if [ $epilog = yes -a $epiloginc = no -a $epilogdir != no ]
then
  if [ -f $epilogdir/include/elg_rw.h ]
  then
    epilogincdir=$epilogdir/include
  else
    epilogincdir=$epilogdir/src
  fi
fi

if [ $epilog = yes -a $epilogbin = no -a $epilogdir != no ]
then
  if [ -f $epilogdir/bin/opari ]
  then
    epilogbindir=$epilogdir/bin
  else
    epilogbindir=$epilogdir/src
  fi
fi

if [ $epilog = yes -a -f $epilogbindir/skin ]
then
  fixmakeargs="$fixmakeargs SCALASCA"
  scalasca=yes
fi

if [ $epilog = yes -a $epiloglib = no -a $epilogdir != no ]
then
  if [ -f $epilogdir/lib/libelg.base.a ] 
  then
    epiloglibdir=$epilogdir/lib
  elif [ -f $epilogdir/src/libelg.base.a ]
  then 
    epiloglibdir=$epilogdir/src
  elif [ -f $epilogdir/lib/be/libelg.base.a ]
  then 
    epiloglibdir=$epilogdir/lib/be
  elif [ -f $epilogdir/lib/fe/libelg.base.a ]
  then 
    epiloglibdir=$epilogdir/lib/fe
  elif [ -f $epilogdir/lib64/libelg.base.a ]
  then 
    epiloglibdir=$epilogdir/lib64
  elif [ -f $epilogdir/lib32/libelg.base.a ]
  then 
    epiloglibdir=$epilogdir/lib32
  else 
    echo "ERROR: PLEASE SPECIFY A VALID -epiloglib=<dir> option."
  fi
fi

if [ $vampirtrace = yes ]
then
    if [ -f $vampirtracedir/lib/libvt.a ] 
    then
      vampirtracelibdir=lib
    else
      vampirtracelibdir=vtlib
    fi
fi



if [ $papi = yes ] ; then
    fixmakeargs="$fixmakeargs PAPI papidir=$papidir"
    tauoptions="${tauoptions}-papi"
    p=$papidir/lib
    papisubdir=lib
    if [ $machine = "mips32" ] ; then
	papisubdir=lib32
	fixmakeargs="$fixmakeargs papisubdir=lib32"
    else
	if [ -f $p/libpapi.so -o -f $p/libpapi.a -o -f $p/libpapi64.so -o -f $p/libpapi64.a -o -f $p/libpapi.rts.a ] ; then
	    papisubdir=lib
	    fixmakeargs="$fixmakeargs papisubdir=lib"
	else
	    if [ -f $p/cnos64/libpapi.so ] ; then
		papisubdir=lib/cnos64
		fixmakeargs="$fixmakeargs papisubdir=lib/cnos64"
	    else
		if [ -f $p/xt-cnl/lib/libpapi.so ] ; then 
		    papisubdir=xt-cnl/lib
		    fixmakeargs="$fixmakeargs papisubdir=xt-cnl/lib"
                else 
		    if [ -f $papidir/lib64/libpapi.so ] ; then 
			papisubdir=lib64
			fixmakeargs="$fixmakeargs papisubdir=lib64"
		    else
			papisubdir=src
			fixmakeargs="$fixmakeargs papisubdir=src"
		    fi
		fi
	    fi
	fi
    fi
    

      if [ -f $papidir/lib/libpfm.a ] ; then 

	      cat <<EOF > tau_papi_test.c
#include <papi.h>
int main (int argc, char **argv) {
  int papi_ver;
  papi_ver = PAPI_library_init(PAPI_VER_CURRENT);
}
EOF
	      if $c_compiler $orig_useropt tau_papi_test.c -I$papidir/include -L$papidir/$papisubdir -lpfm -lpapi -lpfm -o tau_papi_test 1> /dev/null 2>&1 ; then
		  fixmakeargs="$fixmakeargs PAPIPFM"
		  papipfm=yes
	      fi
	      /bin/rm -f tau_papi_test.c tau_papi_test
      fi		



fi

    
if [ $mpi = yes ]
then
  wrapperlib="-L$tautoplevel/$machine/lib -lTauMpi\$(TAU_CONFIG)"
  if [ $epilog = yes -a $mpi = yes ]
  then


      if [ $sicortex = yes ] ; then
	  wrapperlib="-L$epiloglibdir -Wl,-whole-archive -lelg.mpi -Wl,-no-whole-archive"
      else
	  wrapperlib="-L$epiloglibdir -lelg.mpi"
      fi


# kconfig puts -Wl,-rpath <papidir>/lib and this messes up ifort
#    if [ $scalasca = yes ]
#    then
#      if [ -f $epilogbindir/kconfig ]
#      then
#        echo "NOTE: Using kconfig to determine libs used in Scalasca/Epilog"
#        wrapperlib=`$epilogbindir/kconfig --for --mpi --libs`
#      fi
#    fi

    if [ $openmp = yes ] ; then
	if [ $sicortex = yes ] ; then
	    wrapperlib="-L$epiloglibdir -Wl,-whole-archive -lelg.ompi -Wl,-no-whole-archive -Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic"
	else
	    wrapperlib="-L$epiloglibdir -lelg.ompi"
	fi
    fi
  fi 

  if [ $vampirtrace = yes -a $mpi = yes ] ; then
    if [ $vampirtrace = yes -a -f $vampirtracedir/$vampirtracelibdir/libvt.fmpi.a -o -f $vampirtracedir/$vampirtracelibdir/libvt.fmpi.a ] ; then
      vtfortranwrapper="-lvt.fmpi"
    else 
      vtfortranwrapper=""
    fi

    wrapperlib="-L$tautoplevel/$machine/lib -ltau\$(TAU_CONFIG) -L$vampirtracedir/$vampirtracelibdir $vtfortranwrapper -lvt.mpi -lotf -lz"
    if [ $openmp = yes ] ; then
# should we have a -lvt.fmpi here? 
	fixmakeargs="pcxxopt=$pcxxopt useropt=$useropt extrashlibopts=$extrashlibopts $fixmakeargs"
	if [ $sicortex = yes ] ; then
	    wrapperlib="$sicortexlink"
#-L$tautoplevel/$machine/lib -ltau\$(TAU_CONFIG) -L$vampirtracedir/$vampirtracelibdir -Wl,-whole-archive $vtfortranwrapper -lvt.ompi -lotf -lbfd -Wl,-no-whole-archive -lz"
	else
	    wrapperlib="-L$tautoplevel/$machine/lib -ltau\$(TAU_CONFIG) -L$vampirtracedir/$vampirtracelibdir -Wl,-whole-archive $vtfortranwrapper -lvt.ompi -lotf -Wl,-no-whole-archive -lz"
	fi
    fi
  fi 
  
  if [ $perf = yes ] 
  then
    wrapperlib="-L$\(PERFLIBDIR) \$(PERFLIBRARY)"
  fi
     
  mpilibargs=$wrapperlib
  wrapperC=$wrapperlib

  if [ -d $mpilib ] ; then
    #echo "Lib dir found. adding -L$mpilib to LIB"
    mpilibargs="$mpilibargs -L$mpilib"
    if [ -r $mpilib/libmpi_r.a -a -r $mpilib/libmpi.a ] ; then
      fixmakeargs="$fixmakeargs IBMMPI"
      ibmmpi=yes
    fi

    if [ -f $mpilib/libfmpi.a -o -f $mpilib/libfmpi.so ] ; then
      #echo "Fortran fmpi.* found"
      mpiflibargs="-L$mpilib -lfmpi $wrapperlib"
    else
      if [ $epilog = yes -a -f $epiloglibdir/libfmpi.a ] ; then
        mpiflibargs="-lfmpi"
        wrapperlib="$wrapperlib -lfmpi"
      fi 
      if [ $epilog = yes -a -f $epiloglibdir/libelgfmpi.a ] ; then
        mpiflibargs="-lelgfmpi"
        wrapperlib="$wrapperlib -lelgfmpi"
      fi 
      if [ $epilog = yes -a -f $epiloglibdir/libepk.ad.fmpi.a ] ; then
        mpiflibargs="-lepk.ad.fmpi"
        wrapperlib="$wrapperlib -lepk.ad.fmpi"
      fi

      if [ -f $mpilib/libfmpich.cnk.a -o -f $mpilib/libfmpich.cnk.so ] ; then
	mpiflibargs="-lfmpich.cnk"
      #  wrapperlib="$wrapperlib -lfmpich.cnk"
      fi

      if [ -f $mpilib/libfmpich.a -o -f $mpilib/libfmpich.so ] ; then
          #echo "Fortran fmpich.* found"
          if [ $mpi2 = "yes" ] ; then
              #mpich2, must not use -lfmpich
	      if [ -f /usr/lib/librt.a -a $catamount = no ] ; then
                 # mpich2 uses librt for aio_* routines
		  mpiflibargs="-L$mpilib $wrapperlib -lpthread -lrt"
		  mpilibargs="$mpilibargs -lpthread -lrt"
	      else
		  mpiflibargs="-L$mpilib $wrapperlib"
	      fi
	  else 
	      #mpich1, must use -lfmpich
	      mpiflibargs="-L$mpilib -lfmpich $wrapperlib"
	  fi
	  # Does MPI_Init have weak bindings for Fortran (Infiniband MPI)
	  weakmpi=T 
	  # by default it has a T for defined symbol in nm output */
          weakmpi=`nm $mpilib/libfmpich.a | grep mpi_init | awk '{ print $2 ; }' | head -n 1 `
	  if [ "x$weakmpi" = "xW" ]
	  then
	   echo "MPI has weak bindings for mpi_init Fortran bindings..."
             fixmakeargs="$fixmakeargs WEAKMPIINIT"
          fi
      else 
	  if [ -f $mpilib/liblamf77mpi.a -o -f $mpilib/liblamf77mpi.so ] ; then
              #echo "Fortran liblamf77mpi.* found"
	      mpiflibargs="-L$mpilib -llamf77mpi $wrapperlib"
	  else
	    if [ -f $mpilib/libmpi_f77.so ] ; then
              #echo "Fortran libmpi_f77.* found"
	      mpiflibargs="-L$mpilib -lmpi_f77 $wrapperlib"
	    else
              #echo "No Fortran interface found"
	      mpiflibargs="$mpiflibargs $wrapperlib -L$mpilib"
            fi
	  fi
      fi
    fi
  
    # Cases
    if [ -r $mpilib/libmpi.a -o -r $mpilib/libmpi.so ] ; then
      #echo "libmpi.* found!!"
	if [ "x$mpilibrary" = "xno" ] ; then 
	    mpilibrary=-lmpi
	    if [ -r $mpilib/libmpi++.so ] ; then
		mpilibrary='-lmpi -lmpi++'
	        # SGI MPT
	    fi

	# OpenMPI
	if [ -r $mpilib/libmpi_cxx.so ] ; then 
	    mpilibrary='-lmpi -lmpi_cxx'
	fi

        if [ -r $mpilib/libopen-pal.a -a ! -r $mpilib/libmpi_cxx.so ]; then
	   echo "NOTE: OpenMPI configured with --disable_shared"
	   mpilibrary='-lmpi_cxx -lmpi -lopen-rte -lopen-pal -lrt -lnuma -ldl -lpthread -lutil'
	   # check for -libverbs, sometimes necessary with OpenMPI
	   if [ -r /usr/lib64/libibverbs.a -o -r /usr/lib64/libibverbs.so ] ; then 
	       mpilibrary="$mpilibrary -libverbs"
	   fi
        fi
	
        # See if threaded MPI should be used on AIX
        if [ $ibmxlc_r = yes -a -r $mpilib/libmpi_r.a ] ; then
	    mpilibrary="-lmpi_r $additional_mpilibs"
        fi
      fi
      if [ -r $mpilib/libpmpi.a -o -r $mpilib/libpmpi.so ] ; then
          #echo "libpmpi.* found "
	  mpilibargs="$mpilibargs -lpmpi $mpilibrary"
	  mpiflibargs="$mpiflibargs -lpmpi $mpilibrary"
      else
          #echo "libpmpi.* not found -lmpi probably contains PMPI routines"
	  mpilibargs="$mpilibargs $mpilibrary" 
	  mpiflibargs="$mpiflibargs $mpilibrary" 
      fi
    else
      #echo "libmpi.* not found!! Checking for mpich.*..."
      if [ -r $mpilib/libmpich.a -o -r $mpilib/libpmpich.so -o -r $mpilib/libmpich.rts.a -o -r $mpilib/libmpich.cnk.a ] ; then 
	  fixmakeargs="$fixmakeargs MPICH_IGNORE_CXX_SEEK"
          if [ $mpi2 = yes ] ; then
	    fixmakeargs="$fixmakeargs MPICH2_MPI_INPLACE"
          fi
          #echo "MPICH found "
	  if [ "x$mpilibrary" = "xno" ] ; then 
	      if [ -r $mpilib/libmpich.rts.a ] ; then
         	  # For BG/L 
		  mpilibrary="-lmpich.rts $additional_mpilibs"
              else 
                if [ -r $mpilib/libmpich.cnk.a ]; then
		  # For BG/P
		  mpilibrary="-lmpich.cnk $additional_mpilibs"
	        else
		  mpilibrary=-lmpich
	        fi
              fi
	  fi

	  if [ -r $mpilib/libpmpich++.a -o -r $mpilib/libpmpich++.so ] ; then 
              #echo "pmpich++ found"
	      mpilibrary="-lpmpich++ $mpilibrary"
	  fi
	  
	  if [ -r $mpilib/libmpichcxx.a -o -r $mpilib/libmpichcxx.so ] ; then 
              #echo "mpichcxx found"
	      mpilibrary="-lmpichcxx $mpilibrary"
	  fi
	  
	  if [ -r $mpilib/libpmpich.a -o -r $mpilib/libpmpich.so ] ; then 
              #echo "pmpich found"
	      mpilibargs="$mpilibargs -lpmpich $mpilibrary"
	      mpiflibargs="$mpiflibargs -lpmpich $mpilibrary"
	  else
              #echo "pmpich not found"
	      mpilibargs="$mpilibargs $mpilibrary"
	      mpiflibargs="$mpiflibargs $mpilibrary"
	  fi
	  
	  if [ -r /usr/lib/librt.a -o -r /usr/lib/librt.so ] ; then 
              #echo "librt found"
	      mpilibargs="$mpilibargs -lrt"
	      mpiflibargs="$mpiflibargs -lrt"
	  fi
	  
	  if [ -r /usr/lib64/libibverbs.a -o -r /usr/lib64/libibverbs.so ] ; then 
              #echo "libibverbs found"
	      mpilibargs="$mpilibargs -libverbs"
	      mpiflibargs="$mpiflibargs -libverbs"
	  fi

	  if [ -r $mpilib/libscdma.a -a -r $mpilib/libpmi.a ] ; then
	      # echo "add -lscdma -lpmi to the SiCortex link line"
	      mpilibargs="$mpilibargs -lscdma -lpmi"
	      mpiflibargs="$mpiflibargs -lscdma -lpmi"
	  fi
      else
	  if [ "x$mpilibrary" != "xno" ] ; then 
	      mpilibargs="$mpilibargs $mpilibrary"
	      mpiflibargs="$mpiflibargs $mpilibrary"
	  fi
      fi
    fi

    # libmpi.* found. But libpmpi* not found. 
    # both found.
    # libmpi.* not found - look for libmpich.*
    # For fortran libfmpich.* look for libpmpi

    # Check for libmpio.a
    if [ -r $mpilib/libmpio.a ]
    then
      mpilibargs="$mpilibargs -lmpio"
      mpiflibargs="$mpiflibargs -lmpio"
    fi

    # Special check for LAM MPI
    if [ -r $mpilib/liblam.a ]
    then
      echo "This looks like a LAM MPI installation. Adding -llam to link command line"

      if [ -r $mpilib/liblammpi++.a ] ; then
	  mpilibargs="$mpilibargs -llammpi++ -lmpi"
	  mpiflibargs="$mpiflibargs -llammpi++ -lmpi"
      fi
      mpilibargs="$mpilibargs -llam"
      mpiflibargs="$mpiflibargs -llam"
      if [ -f /usr/lib/libutil.a ] 
      then
# This is a Linux box, add -lutil to the mpi libraries
        echo "Adding -lutil to link command line for LAM MPI"
        mpilibargs="$mpilibargs -lutil -ldl -lpthread"
        mpiflibargs="$mpiflibargs -lutil -ldl -lpthread"
      fi
    fi 
    # Special check for Intel MPI
    if [ -r $mpilib/libmpiif.a ]
    then
      echo "This looks like an Intel MPI installation."
      mpilibargs="$mpilibargs -lmpiif -ldl -lrt"
      mpiflibargs="$mpiflibargs -lmpiif -ldl -lrt"
    fi
    # Special check for HPMPI
    if [ -r $mpilib/libmpi_hmp.a ]
    then
      echo "This looks like an HP/MPI installation."
      mpilibargs="$mpilibargs -ldl"
      mpiflibargs="$mpiflibargs -ldl"
    fi
    # Special check for ChaMPIon/Pro 
    if [ -r $mpilib/libcmpi.a ]
    then
      echo "This looks like a ChaMPIon/Pro installation."
      mpiextraargs=`cmpicc -v -echo | cut -c8- `
      mpilibargs="$mpilibargs $mpiextraargs"
      mpiflibargs="$mpiflibargs $mpiextraargs -lcmpi_fort"
    fi
    # Special check for VMI [NCSA] MPICH
    if [ -r $mpilib/libvmi.a ]
    then
      echo "This looks like a VMI MPICH installation. Adding -lvmi -lpthread -ldl to link command line"
      mpilibargs="$mpilibargs -lvmi -lpthread -ldl"
      mpiflibargs="$mpiflibargs -lvmi -lpthread -ldl"
    fi
      
    mpilibargs=`echo $mpilibargs | sed  -e 's/ /#/g'`
    mpiflibargs=`echo $mpiflibargs | sed  -e 's/ /#/g'`
    if [ $papipfm = yes -a "x$mpilib" = "x/usr/lib" ]
    then
      echo "NOTE: Adding -L<papidir> before -L<mpidir> to use PAPI's libpfm"
      mpilibargs="-L$papidir/$\(PAPISUBDIR\)#$mpilibargs"
      mpiflibargs="-L$papidir/$\(PAPISUBDIR\)#$mpiflibargs"
    fi
    fixmakeargs="$fixmakeargs mpilibargs=$mpilibargs mpiflibargs=$mpiflibargs mpilib=$mpilib"

    # now throw in non-wrapped MPI library lines
    wrapperF=$wrapperlib
    nowrapC=`echo $wrapperC | sed  -e 's/ /#/g'`
    nowrapF=`echo $wrapperF | sed  -e 's/ /#/g'`
    notaumpilibargs=`echo $mpilibargs | sed -e "s@$nowrapC@@"`
    notaumpiflibargs=`echo $mpiflibargs | sed -e "s@$nowrapF@@"`
    fixmakeargs="$fixmakeargs mpinowraplibargs=$notaumpilibargs mpinowrapflibargs=$notaumpiflibargs mpilib=$mpilib"

    # Check to see if the MPI library contains a _r 
    mpithreadtest=`echo $mpilibrary | sed -e 's/_r//'`
    if [ "y$mpithreadtest" = "y$mpilibrary" ] 
    then
      echo "NOTE: MPI library does not have a threaded _r suffix "
    else
      echo "NOTE: MPI library has a threaded _r suffix "
      fixmakeargs="$fixmakeargs MPI_R_SUFFIX"
    fi # mpi _r check

  fi # If -d mpilib
else # if mpilib is specified
    if [ $openmp = yes ] 
    then
	if [ $epilog = yes ] ; then
	    if [ $sicortex = yes ] ; then
		wrapperlib="-L$epiloglibdir#-Wl,-whole-archive#-lelg.omp#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-Wl,-no-whole-archive#-ldl"
	    else
		wrapperlib="-L$epiloglibdir#-lelg.omp#-ldl"
	    fi
	    fixmakeargs="extrashlibopts=$wrapperlib $fixmakeargs"
	elif [ $vampirtrace = yes ] ; then
	    if [ $sicortex = yes ] ; then
		wrapperlib="-L$vampirtracedir/$vampirtracelibdir#-Wl,-whole-archive#-lvt.omp#-lotf#-Wl,-no-whole-archive#-lz#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-ldl"
	    else
		wrapperlib="-L$vampirtracedir/$vampirtracelibdir#-Wl,-whole-archive#-lvt.omp#-lotf#-Wl,-no-whole-archive#-lz#-ldl"
	    fi
	    fixmakeargs="extrashlibopts=$wrapperlib $fixmakeargs"
	fi
    else
	if [ $epilog = yes ]
	then
	    wrapperlib="-L$epiloglibdir#-lelg#-ldl"
	    fixmakeargs="extrashlibopts=$wrapperlib $fixmakeargs"
	elif [ $vampirtrace = yes ]
	then
	    wrapperlib="-L$vampirtracedir/$vampirtracelibdir#-lvt#-lotf#-lz#-Wl,-Bstatic#-lbfd#-liberty#-Wl,-Bdynamic#-ldl"
	    fixmakeargs="extrashlibopts=$wrapperlib $fixmakeargs"
	fi
    fi
fi
######################################################################
# Set default CC compiler in all Makefiles

if [ "$mpi" = "yes" -a "$ibmxlc_r" = "no" -a "$ibmxlc" = "yes" -a "$machine" = "ibm64" ]
then
  echo "WARNING: PLEASE use xlC_r instead of xlC with MPI in 64 bit mode!! Reconfigure."
  echo "----------------------------------------------------------------"
fi

# Now check for SHMEM options
if [ $shmem = yes ] 
then
  if [ "x$shmeminc" != "x" ]
  then 
    if [ -d $shmeminc ]
    then
    #echo "Include dir found. adding -I$mpiinc to INC"
      shmemincargs="-I$shmeminc"
      gpshmem=no
      if [ -r $shmeminc/gpshmem.h ] 
      then
        fixmakeargs="$fixmakeargs GPSHMEM"
        gpshmem=yes
      fi
    fi
  else
    if [ $catamount = yes ] 
    then
      shmemincargs="-I/opt/xt-mpt/default/include/mpp"
    fi
  fi
  
  if [ $shmemlibrary = no ]
  then 
    shmemlibrary=-lsma
    if [ $gpshmem = yes ] 
    then
      shmemlibrary=-lgpshmem
    fi
  fi
  if [ "x$shmemlib" != "x" ]
  then 
    if [ -d $shmemlib ]
    then
    #echo "Lib dir found. adding -L$shmemlib to LIB"
      shmemlibargs="$shmemlibargs -L$shmemlib"
    fi
  else
    if [ $catamount = yes ] 
    then
      shmemlibargs="$shmemlibargs -L/opt/xt-mpt/default/lib/cnos64"
    fi
  fi

  shmemlibargs="$shmemlibargs $shmemlibrary"
  shmemlibargs=`echo $shmemlibargs | sed  -e 's/ /#/g'`
  fixmakeargs="$fixmakeargs SHMEM"
  tauoptions="${tauoptions}-shmem"
  fixmakeargs="$fixmakeargs shmemlibargs=$shmemlibargs shmemincargs=$shmemincargs"
fi

gcclibdir=unknown
if [ $c_compiler != gcc ]
  then
    echo Default C compiler will be $c_compiler
    fixmakeargs="$fixmakeargs USE_CC"
  else
    echo "Default C compiler will be " `gcc -v 2>&1 | tail -1`

# I must set the gcclibdir in the Makefiles if we combine gcc, cc, and CC 
    gcclibdir=`gcc -v 2>&1 | awk '{print $4;}' | \
       awk -F/ '{for (i=2; i<NF; i++) printf("/%s",$i); printf("\n"); }'`
#    echo $gcclibdir
fi

######################################################################
# Set default compiler options

if [ $use_pcxx = yes ]
then
  opt=`echo $pcxxopt | sed -e 's/_/ /g' -e 's/^$/(none)/'`
  echo "Default compiler options for pC++ programs are $opt"
  opt=`echo $useropt | sed -e 's/_/ /g' -e 's/^$/(none)/'`
  echo "Default compiler options for pC++ user programs are $opt"

  fixmakeargs="pcxxopt=$pcxxopt useropt=$useropt extrashlibopts=$extrashlibopts $fixmakeargs"
fi

fixmakeargs="c_compiler=$c_compiler cxx_compiler=$cxx_compiler useropt=$useropt extradir=$extradir extradircxx=$extradircxx extrashlibopts=$extrashlibopts $fixmakeargs"

######################################################################
# discover the paths for standard system include directories

cat << EOF > get_stdinc.C
#include <stddef.h>
#include <iostream>
EOF

cat << EOF > find_stdinc.awk
BEGIN {cinc=""; cppinc="";}
/^#[0123456789]+ ".+\/stddef.h"/ {cinc = substr(\$2, 2, length(\$2)-11);}
/^#line [0123456789]+ ".+\/stddef.h"/ {cinc = substr(\$3, 2, length(\$3)-11);}
/^# [0123456789]+ ".+\/stddef.h"/ {cinc = substr(\$3, 2, length(\$3)-11);}
/^#[0123456789]+ ".+\/iostream.h"/ {cppinc = substr(\$2, 2, length(\$2)-13);}
/^#line [0123456789]+ ".+\/iostream.h"/ {cppinc = substr(\$3, 2, length(\$3)-13);}
/^# [0123456789]+ ".+\/iostream.h"/ {cppinc = substr(\$3, 2, length(\$3)-13);}
END {printf("-I%s -I%s\n", cinc, cppinc);}
EOF

if [ $machine = hitachi ]
then
  stdinc="-I/usr/include"
else
  stdinc=`$cxx_compiler  -E get_stdinc.C | awk -f find_stdinc.awk`
fi  

rm -f get_stdinc.C find_stdinc.awk

#####################################################################
cat << EOF > f1.c
      #define  _LARGEFILE64_SOURCE    1 
      #include <sys/types.h>
      #include <sys/stat.h>
      #include <fcntl.h>

      int main(int argc, char** argv) {
         int file = open ("asdf", O_LARGEFILE, 0600);
      }
EOF


$echo "Checking if open takes O_LARGEFILE... ${nnl}"
if $c_compiler $orig_useropt -c f1.c 1> /dev/null 2>&1 ; then
    fixmakeargs="$fixmakeargs TAU_LARGEFILE"
    echo "yes"
else
    echo "no"
fi
/bin/rm -f f1.o f1.c


######################################################################
# Check for BFD
######################################################################
  cat <<EOF > conftest_bfd.c
  #include <bfd.h>
EOF
$echo "Checking for bfd.h... ${nnl}"
if $c_compiler $orig_useropt -c conftest_bfd.c 1> /dev/null 2>&1 ; then
    fixmakeargs="$fixmakeargs TAU_BFD"
    echo "yes"
else
    echo "no"
fi
/bin/rm -f conftest_bfd.o conftest_bfd.c
######################################################################

######################################################################
cat <<EOF > get_typeinfo1.C
#include <typeinfo> 
using std::type_info;
#ifdef __GNUC__
#include <cxxabi.h>
using namespace std;
#endif /* GNUC */

EOF

if $cxx_compiler $orig_useropt -c get_typeinfo1.C 1> /dev/null 2>&1 
then 
  echo "C++ compiler supports Std Runtime Type Information (default)"
  if [ $cxx_compiler = g++ -o $cxx_compiler = c++ -o $cxx_compiler = powerpc64-linux-g++ ] 
  then 
    echo "Supporting GNU RTTI options"
  fi
else
cat <<EOF > get_typeinfo2.C
#include <typeinfo.h>
EOF
  if $cxx_compiler $orig_useropt -c get_typeinfo2.C 1> /dev/null 2>&1 
  then
    echo "C++ compiler supports RTTI"
    fixmakeargs="$fixmakeargs RTTI"
  else
    echo "C++ compiler doesn't support Runtime Type Information"
    fixmakeargs="$fixmakeargs NORTTI"
  fi 
fi
rm -f get_typeinfo1.C get_typeinfo2.C get_typeinfo*.o *.ti *.ii

######################################################################
if [ $cxx_compiler = pgCC ] 
then
  cat <<EOF > pgitest.C
int foo(int x)
{
  return x;
}
EOF
  if $cxx_compiler $orig_useropt -c pgitest.C 1> /dev/null 2>&1 
  then 
    if $cxx_compiler $orig_useropt --prelink_objects pgitest.o 1> /dev/null 2>&1 
    then
      echo "PGI compiler supports the --prelink_objects option"
    else
      echo "PGI compiler should not use --prelink_objects option for making libs"
      fixmakeargs="$fixmakeargs PGINOPRELINK"
    fi
  else
    echo "ERROR: Your PGI compiler is not working! Please check the license file"
  fi 
  rm -f pgitest.o pgitest.C libpgitest.a
fi
######################################################################
# If epilog is used, check and see if it supports v2.1s write interface
if [ $epilog =  yes ]
then
  echo "Checking epilog write interface:"
cat << EOF > elgtest.C
#include <elg_rw.h>
int foo(ElgOut *out, elg_ui4 eventc)
{
  return ElgOut_write_NUM_EVENTS(out, eventc);
}
EOF
 if $cxx_compiler $orig_useropt -I$epilogincdir -c elgtest.C 1> /dev/null 2>&1
  then
    fixmakeargs="$fixmakeargs TAU2EPILOG"
  fi
  rm -f elgtest.C elgtest.o 
fi

######################################################################
# Save C++ compiler, C compiler, and USEROPT for build

echo "$machine: cxx         = $cxx_compiler" >> ./build/Config.info
echo "$machine: cc          = $c_compiler" >> ./build/Config.info
opt=`echo $useropt | sed -e 's/_/ /g'`
echo "$machine: useropt     = $opt" >> ./build/Config.info
echo "$machine: stdincludes = $stdinc" >> ./build/Config.info 
echo "" >> ./build/Config.info

######################################################################
## STATIC ANALYSIS: Ductape/Program Database Toolkit/IL Analyser
    
# NOW PDT configuration handled in PDT
######################################################################


######################################################################
# test whether C++ compiler supports AT&T task library

echo "#include <task.h>" > /tmp/tau$$.C
echo "class IamReallyATTtask : public object {};" >> /tmp/tau$$.C

if $cxx_compiler -c /tmp/tau$$.C 1> /dev/null 2>&1
then
#  echo "AT&T task library found; using it"
  task=yes
fi
rm -f /tmp/tau$$.C tau$$.o


######################################################################
# test whether C++ compiler supports Std C++ Library (KAI KCC compiler) 
echo "Testing for Standard C++ Library support for string class"
cat <<EOF > /tmp/tau$$.C
#include <string>
#include <vector>
#include <list>
#include <map>
using std::string;
using std::vector;
using std::pair;
using std::list;
using std::map;
void foo(void) { string s1; return; }
EOF

if $cxx_compiler -c /tmp/tau$$.C 1> /dev/null 2>&1
then 
  echo "Found support for Standard C++ Library string"
  echo "NOTE: Compiling Profiling Library and Applications with -DTAU_STDCXXLIB"
  echo "***********************************************************************"
  stdcxxlib=yes
else
  echo "Did not find <string> Standard C++ Library header file. Using <bstring.h> "
fi 
rm -f /tmp/tau$$.C tau$$.o


######################################################################
# test whether C++ compiler supports SUN LWP thread library

if [ -f /usr/include/lwp/lwp.h ]
then
  echo "SUN LWP thread library found; using it"
  lwp=yes
fi


######################################################################
# Set some more Profiling options

if [ $stdcxxlib = yes ]
  then
    fixmakeargs="$fixmakeargs STDCXXLIB"
fi    


######################################################################
if [ $machine = craycnl ] 
then
  #echo "This looks like a Cray Compute Node Linux (CNL) system..."
  fixmakeargs="$fixmakeargs CRAYCNL"
fi

######################################################################
if [ $catamount = yes ] 
then
  #echo "This looks like a CATAMOUNT Cray RS system..."
  fixmakeargs="$fixmakeargs CATAMOUNT"

  if [ $fortran_compiler = pgi ] 
  then
      fixmakeargs="$fixmakeargs PGI_CATAMOUNT"
  fi
fi

######################################################################
if [ $cxx_compiler = g++ -o $cxx_compiler = egcs -o $cxx_compiler = powerpc64-linux-g++ -o $cxx_compiler = c++ -o $cxx_compiler = scg++ -o $cxx_compiler = mips64el-gentoo-linux-gnu-g++  -o $cxx_compiler = powerpc-bgp-linux-g++ ]
  then
    fixmakeargs="$fixmakeargs GNU COMPINST_GNU"
    if [ $machine = ibm64 -o $machine = rs6000 -o $machine = ppc64 -o $machine = bgl -o $machine = bgp -o $machine = ibm64linux ]
    then
      tauoptions="${tauoptions}-gnu"
    fi
    taugcclibdir=`$c_compiler -print-libgcc-file-name | sed -e 's,[^/]*$,,'`
    echo "Using GNU lib dir as $taugcclibdir"
    fixmakeargs="$fixmakeargs taugcclibdir=$taugcclibdir" 
fi
######################################################################
# TEST FOR ALL MACHINE TYPES
case $machine in
     hp9000s700 | hp9000s800)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine NO_RANLIB HP $fixmakeargs"
# HP-ALLOCA HP_CFLAGS

	if [ `/bin/uname -r | cut -d. -f2` = 10 ]
	then
          echo This machine uses HPUX Version 10
          fixmakeargs="HPUX10 $fixmakeargs"
        fi

	if [ $c_compiler = cc ]
  	then
		fixmakeargs="HP_CFLAGS HP-ALLOCA $fixmakeargs"
	fi

	if [ $cxx_compiler = g++ ]
  	then
		fixmakeargs="HPGNU $fixmakeargs"
	fi

	if [ $pdt_cxx_compiler = aCC ]
  	then
		fixmakeargs="PDTHPACC $fixmakeargs"
	fi

# Check for Convex SPP enviroment
	if [ $detectxdev = cnxspp ]
	  then
	    fixmakeargs="$fixmakeargs CNXSPP"
	fi

	;;

     decstation)
	echo Found a \"$machine\" configuration definition
#	fixmakeargs="arch=$machine MIPS_CC $fixmakeargs"
# with gcc, there are no changes needed...
	fixmakeargs="arch=$machine $fixmakeargs"
	;;

     ppc64)
	echo "Found an IBM PPC-64 Linux configuration definition"
	fixmakeargs="arch=$machine PPC64 $fixmakeargs"
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs PPC64PAPI"
	fi
        ;; 

     bgp)
	echo "Found an IBM PPC-64 BG/P Linux configuration definition"
	fixmakeargs="arch=$machine BGP $fixmakeargs"
	if [ $papi = yes ] ; then
	    p=$papidir/lib
	    if [ -f $p/libpapi.a ] ; then
		fixmakeargs="$fixmakeargs BGPPAPI"
	    fi
	fi
        ;; 
     bgl)
	echo "Found an IBM PPC-64 BGL Linux configuration definition"
	fixmakeargs="arch=$machine BGL $fixmakeargs"
	if [ $papi = yes ] ; then
	    p=$papidir/lib
	    if [ -f $p/libpapi.a ] ; then
		fixmakeargs="$fixmakeargs BGLPAPI"
	    else 
		fixmakeargs="$fixmakeargs BGLPAPI_RTS"
	    fi
	fi
        ;; 

     ia64)
	echo "Found an IA-64 configuration definition"
	fixmakeargs="arch=$machine $fixmakeargs"
	
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs IA64PAPI"
	fi
	;;
     x86_64|xt3|craycnl)
	echo "Found an x86_64 configuration definition"
	fixmakeargs="arch=$machine $fixmakeargs"
	
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs X86_64PAPI"
	fi
	;;
     ibm64)
	echo Found a \"$machine\" configuration definition
        if [ `uname -s` = AIX ]
        then
	  fixmakeargs="arch=$machine $fixmakeargs SP1 IBM64"
        else 
          if [ `uname -s ` = Linux ] 
          then
	    fixmakeargs="arch=$machine $fixmakeargs PPC64 IBM64"
          else
	    fixmakeargs="arch=$machine $fixmakeargs IBM64"
          fi
        fi

	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs IBM64PAPI"
	fi
	;;
     ibm64linux)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs PPC64 IBM64LINUX"
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs IBM64PAPILINUX"
	fi
	;;

     mips32)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs MIPS32 MIPS32LINUX"
	sicortex=yes
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs MIPS32PAPI"
	fi
	;;

     mips)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs MIPS64 MIPS64LINUX"
	sicortex=yes
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs MIPS64PAPI"
	fi
	;;

     rs6000)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs SP1"

	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs IBMPAPI"
	fi
# Check for SP1 xdev enviroment
#        if [ $detectxdev = sp1 ]
#          then
#            fixmakeargs="$fixmakeargs SP1"
#        fi
	;;

     alpha)
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs ALPHAPAPI"
	fi
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs"
	fixmakeargs="COMPAQ_ALPHA $fixmakeargs"
        if [ $pdt_cxx_compiler = cxx ]
        then
          fixmakeargs="$fixmakeargs PDTALPHACXX"
        fi
        if [ $guidef90 = yes ]
        then
          f90loaded=`which f90 | sed -e 's/f90/../g' | grep "^no"`
          if [ "x$f90loaded" = "x" ]
          then
    	    # f90 module has been loaded and which f90 returns a path	
            extradir="`which f90 | sed s/f90/../`"
	    echo "Found f90 in `which f90`"
          fi
          fixmakeargs="$fixmakeargs extradir=$extradir COMPAQ_GUIDEF90"
        fi
	;;

     sgi4k | sgi8k | sgi32 | sgin32 | sgi64)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs"
	if [ $c_compiler = cc ]
          then
# Check CPU type for compiler optimization flags... (-mips2) (-mips4)
            if [ $machine = sgi4k ]
              then
	        fixmakeargs="$fixmakeargs MIPS_CC"
                fixmakeargs="$fixmakeargs MIPSR4K"
                echo "NOTE: *** This is an SGI Challenge (R4K) ***"
              else
                fixmakeargs="$fixmakeargs MIPSR8K"
              echo "NOTE: *** This is an SGI POWER Challenge/Origin (R8K, R10K) ***"
            fi
        fi
        if [ $machine = sgin32 ] 
	  then
	    fixmakeargs="$fixmakeargs ENABLEN32BIT"
	fi

        if [ $machine = sgi64 ] 
	  then
	    fixmakeargs="$fixmakeargs ENABLE64BIT"
	    if [ $papi = yes ]
	    then
		if [ -f $papidir/lib/libpapi64.so -o -f $papidir/src/libpapi64.so ]
		then 
	    	  fixmakeargs="$fixmakeargs SGI64PAPI"
		fi
	    fi		
	fi

        if [ $machine = sgi32 ] 
	  then
	    fixmakeargs="$fixmakeargs ENABLE32BIT"
	fi

# Check for sgimp xdev enviroment
        if [ $detectxdev = sgimp -o $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ]
          then
            fixmakeargs="$fixmakeargs SGIMP"
            if [ $fortran_compiler = no ] 
	    then
              fixmakeargs="$fixmakeargs SGI_FORTRAN"
              fortran_compiler=yes
	    fi
	      
        fi
	;;

     next)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine NEXT_CLIB $fixmakeargs"
	;;

# Currently cm5 cross-development environments are NOT supported
# for solaris2 machines....
     solaris2*)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine SOL2 $fixmakeargs"
        if [ "$tauarch" = "solaris2-64" ] 
        then
	    fixmakeargs="$fixmakeargs SOLARIS64"
        fi
     
	if [ $papi = yes ]
 	  then
	    fixmakeargs="$fixmakeargs SOL2PAPI"
	fi
	if [ $cxx_compiler = CC ]  
	  then
	    fixmakeargs="$fixmakeargs SOL2CC"
	    if [ $openmp = yes ]
	    then
	      fixmakeargs="$fixmakeargs SOL2CC_OPENMP"
	    fi
	    if [ $fortran_compiler = no ]  
	    then
	      fixmakeargs="$fixmakeargs SUN_FORTRAN"
              fortran_compiler=yes
            fi
        fi
	 
		

# Check for Meiko CS2 xdev enviroment
        if [ $detectxdev = cs2 ]
          then
            fixmakeargs="$fixmakeargs CS2"
        fi
	;;

     sun386i)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine SUN386I $fixmakeargs"
	if [ $cxx_compiler = CC ]  
	  then
	    fixmakeargs="$fixmakeargs SOL2CC"
	    if [ $openmp = yes ]
	    then
	      fixmakeargs="$fixmakeargs SOL2CC_OPENMP"
	    fi
	    if [ $fortran_compiler = no ]  
	    then
	      fixmakeargs="$fixmakeargs SUN_FORTRAN"
              fortran_compiler=yes
            fi
        fi
	;;

     sunx86_64)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine $fixmakeargs SUNX86_64"
	if [ $cxx_compiler = CC ]  
	  then
	    fixmakeargs="$fixmakeargs SOL2CC"
	    if [ $openmp = yes ]
	    then
	      fixmakeargs="$fixmakeargs SOL2CC_OPENMP"
	    fi
	    if [ $fortran_compiler = no ]  
	    then
	      fixmakeargs="$fixmakeargs SUN_FORTRAN"
              fortran_compiler=yes
            fi
        fi
	;;


     sun4 | cm5)
	echo Found a \"$machine\" configuration definition
        fixmakeargs="arch=$machine $fixmakeargs"

# Check for cm5 xdev enviroment
        if [ $machine = cm5 -o $detectxdev = cm5 ]
          then
            fixmakeargs="$fixmakeargs CM5"
        fi
	;;

     ptx)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine PTX HP-ALLOCA $fixmakeargs"
        ;;

     tc2000)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine TC2000 $fixmakeargs"
        ;;

     c90)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine C90 CRAY-ALLOCA $fixmakeargs"
# Check for T3D xdev enviroment
        if [ $detectxdev = t3d ]
          then
            fixmakeargs="$fixmakeargs T3D"
        fi
	;;

     t3e)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine T3E CRAY-ALLOCA $fixmakeargs"
	if [ $fortran_compiler = no ]  
	then
	  fixmakeargs="$fixmakeargs CRAY_FORTRAN"
          fortran_compiler=yes
        fi
        ;;

     ksr1)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine KSR NO_RANLIB $fixmakeargs"
        ;;

     paragon)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine PARAGON $fixmakeargs"
        ;;

     symmetry)
	echo Found a \"$machine\" configuration definition
	fixmakeargs="arch=$machine SYMMETRY $fixmakeargs"
	;;

     unknown)
        echo unknown architecture.
	fixmakeargs="arch=$machine $fixmakeargs"
	;;

     default)
	fixmakeargs="arch=$machine $fixmakeargs"
	;;

     -*)
	echo "Invalid option \`$1'" 1>&2
	exit 1
	;;

     *)
	echo No special modifications found for architecture \"$machine\"
	fixmakeargs="arch=$machine  $fixmakeargs"
	;;
    esac

if [ $machine = x86_64 -o $machine = i386_linux -o $machine = ia64 ]
then
        if [ $cxx_compiler = CC ]
          then
            fixmakeargs="$fixmakeargs SUNCC"
            if [ $openmp = yes ]
            then
              fixmakeargs="$fixmakeargs SUNCC_OPENMP"
            fi
            if [ $fortran_compiler = no ]
            then
              fixmakeargs="$fixmakeargs SUN_FORTRAN"
              fortran_compiler=yes
            fi
        fi
fi


if [ $tauarch = none ]
then
  architecture=
  fixmakeargs="$fixmakeargs arch= "
else
  if [ $execprefix = unknown ]
  then
    architecture=$machine
  else
    architecture=$execprefix
  fi
fi

# write out .h file to define this architecture __easily__
echo \#define TAU_$machine > ./include/tauarch.h
echo \#define TAU_ARCH \"$machine\" >> ./include/tauarch.h

make_directories

if [ $awe = yes ]
  then
    fixmakeargs="$fixmakeargs AWE_AVAILABLE awedir=$awedir"
    echo "$machine: AWEDIR = $awedir" >> ./build/Config.info
fi

if [ $pthread = yes ]
  then
    fixmakeargs="$fixmakeargs PTHREAD_AVAILABLE ptdir=$ptdir"
    echo "$machine: PTDIR = $ptdir" >> ./build/Config.info
    tauoptions="${tauoptions}-pthread"
fi

if [ $papithread = yes ] ; then
    if [ $papi = no ] ; then
	echo ""
	echo "Error: To use the PAPI thread layer, you must specify -papi=<dir>"
	echo ""
	exit
    fi

    if [ ! `uname -s ` = Linux ] ; then
	echo ""
	echo "Error: The PAPI thread layer only works on Linux"
	echo ""
	exit
    fi

    fixmakeargs="$fixmakeargs TAU_PAPI_THREADS"
    tauoptions="${tauoptions}-papithread"
fi

if [ $charm = yes ]
    then
    fixmakeargs="$fixmakeargs TAU_CHARM charmdir=$charmdir"
    echo "$machine: CHARMDIR = $charmdir" >> ./build/Config.info
    tauoptions="${tauoptions}-charm"
fi

if [ $compensate = yes ]
  then 
    fixmakeargs="$fixmakeargs COMPENSATE"
    tauoptions="${tauoptions}-compensate"
fi
   
if [ $muse = yes ]
  then
    fixmakeargs="$fixmakeargs MUSE"
    tauoptions="${tauoptions}-muse"
fi

if [ $muse_event = yes ]
  then
    fixmakeargs="$fixmakeargs MUSE_EVENT"
    tauoptions="${tauoptions}-muse_event"
fi

if [ $muse_multiple = yes ]
  then
    fixmakeargs="$fixmakeargs MUSE_MULTIPLE"
    tauoptions="${tauoptions}-muse_multiple"
fi

if [ $sproc = yes ]
  then
    fixmakeargs="$fixmakeargs TAU_SPROC"
    tauoptions="${tauoptions}-sproc"
fi

if [ $pcl = yes ]
  then
    fixmakeargs="$fixmakeargs PCL pcldir=$pcldir"
    tauoptions="${tauoptions}-pcl"
fi


if [ $python = yes ]
  then
    fixmakeargs="$fixmakeargs PYTHON pythoninc=$pythoninc pythonlib=$pythonlib"
    tauoptions="${tauoptions}-python"
    if [ $machine = rs6000 -a "x$pythonlib" = "x" ] 
    then
      echo "ERROR: For IBM systems, please specify the -pythonlib=<dir> flag where *.py files and the config directory are located!"
      exit 1
    fi
fi

if [ $ktau = yes ]
  then
    fixmakeargs="$fixmakeargs KTAU ktauinc=$ktauinc ktauincuser=$ktauincuser ktaulib=$ktaulib ktausym=$ktausym"
    tauoptions="${tauoptions}-ktau"
fi

if [ $ktau_merge = yes ]
  then
    fixmakeargs="$fixmakeargs KTAU_MERGE ktauinc=$ktauinc ktauincuser=$ktauincuser ktaulib=$ktaulib ktausym=$ktausym"
    tauoptions="${tauoptions}-ktau_merge"
fi

if [ $ktau_shctr = yes ]
  then
    fixmakeargs="$fixmakeargs KTAU_SHCTR ktauinc=$ktauinc ktauincuser=$ktauincuser ktaulib=$ktaulib ktausym=$ktausym"
    tauoptions="${tauoptions}-ktau_shctr"
fi

if [ $vtf = yes ]
then
  fixmakeargs="$fixmakeargs VTF vtfdir=$vtfdir"
fi

if [ $otf = yes ]
then
  fixmakeargs="$fixmakeargs OTF otfdir=$otfdir"
  if [ ! -d $otfdir/${architecture} ] 
  then
    fixmakeargs="$fixmakeargs OTFSRC"
  fi  
fi

if [ $slog2 = yes ]
then
  if [ $internalslog2 = yes ]
  then
     slog2dir=$tauroot/tools/src/contrib/slog2sdk/
      if [ ! -d $slog2dir ]
      then
        echo "Error: Cannot access SLOG2 directory $slog2dir"
        exit 1
      fi
  fi
  fixmakeargs="$fixmakeargs SLOG2 slog2dir=$slog2dir"
  if [ "x$jdkdir" = "x" ]
  then
    jdkdir=$JAVA_HOME 
    #`which javac | sed s/javac/../`
    if [ "x$jdkdir" = "x" ]
    then
      echo "You must set the JAVA_HOME environment variable to compile the jni version of tau2slog2. Please re-configure TAU."
    fi
    fixmakeargs="$fixmakeargs jdkdir=$jdkdir"
  fi
fi

if [ $pdt = yes ]
then
  fixmakeargs="$fixmakeargs PDT pdtdir=$pdtdir"
  tauoptions="${tauoptions}-pdt"
  if [ $pdtcompdir != unknown ]
  then
    fixmakeargs="$fixmakeargs PDTARCH pdtcompdir=$pdtcompdir"
  fi

  if [ $pdtarchdir != unknown ]
  then
    fixmakeargs="$fixmakeargs PDTARCHITECTURE pdtarchdir=$pdtarchdir"
  fi

  if [ $pdt_cxx_compiler != default ]
  then
# Check if they specified -pdt_c++=/usr/bin/g++ instead of just g++ 
    if [ "x$pdt_cxx_full_path" != "x$pdt_cxx_compiler" ]
    then
      pdt_cxx_used=$pdt_cxx_full_path
    else
      pdt_cxx_used=$pdt_cxx_compiler
    fi

    fixmakeargs="$fixmakeargs PDTCXX pdtcxx=$pdt_cxx_used"
    if [ $machine = sgi8k -o $machine = sgin32 -o $machine = sgi64 ]
    then
      if [ $pdt_cxx_compiler = CC ]
      then
        fixmakeargs="$fixmakeargs PDTSGICC"
      fi
    fi
  fi

# Check if PDT has Fortran statement level information
  cat <<EOF > checkpdt.cpp
  #include <pdbAll.h>

  int IsFortranDoStatement(pdbStmt::stmt_t k)
  {
	if (k == pdbStmt::ST_FDO) return 1;
	else return 0;
  }
EOF
  if [ $machine = alpha -a $cxx_compiler = cxx ]; then
    orig_useropt="$orig_useropt -x c++ -D__USE_STD_IOSTREAM"
  fi
  if $cxx_compiler $orig_useropt -I$pdtdir/include -c checkpdt.cpp 1> /dev/null 2>&1
  then
    echo "PDT supports Fortran Loop Level information"
  else
    echo "IMPORTANT NOTE: Your PDT does not support Fortran Loop Level information."
    echo "***************You may want to upgrade to a newer release."
    echo "See http://www.cs.uoregon.edu/research/pdt"
    fixmakeargs="$fixmakeargs PDTNOFSTMTS"
  fi
  /bin/rm -f checkpdt.o checkpdt.cpp
fi


if [ $vampirtrace = yes ]; then
cat <<EOF>vttest.cpp
#include "Profile/Profiler.h"
#include "Profile/TauVampirTrace.h"
int foo(void)
{
  uint64_t x;
  return 0;
}
EOF
  if $cxx_compiler $orig_useropt -Iinclude -I$vampirtracedir/include -c vttest.cpp -DTRACING_ON -DTAU_DOT_H_LESS_HEADERS 1> /dev/null 2>&1
  then
    echo "VampirTrace check successful"
  else
    echo "Using VampirTrace options for compiling"
    fixmakeargs="$fixmakeargs VAMPIRTRACEINTS"
  fi
  /bin/rm -f vttest.cpp
fi
    
 


if [ $java = yes ]
  then
    fixmakeargs="$fixmakeargs JAVA jdkdir=$jdkdir"
fi

if [ $openmp = yes ]
  then
    fixmakeargs="$fixmakeargs OPENMP"
    tauoptions="${tauoptions}-openmp"
fi

if [ $opari = yes ] ; then
    fixmakeargs="$fixmakeargs KOJAKOPARI"
    fixmakeargs="$fixmakeargs OPARI oparidir=$oparidir"
    tauoptions="${tauoptions}-opari"
fi


if [ $vampirtrace = yes ]
  then
    fixmakeargs="$fixmakeargs VAMPIRTRACE vampirtracedir=$vampirtracedir"
    tauoptions="${tauoptions}-vampirtrace"
    if [ $mpi = yes ] 
    then 
      if [ $openmp = yes ] 
      then
        fixmakeargs="$fixmakeargs VAMPIRTRACEOMPI" 
      else
        fixmakeargs="$fixmakeargs VAMPIRTRACEMPI" 
      fi 
    else
      if [ $openmp = yes ]
      then
        fixmakeargs="$fixmakeargs VAMPIRTRACEOMP" 
      fi
    fi
fi

if [ $epilog = yes ]
  then

    if [ -f $epiloglibdir/libsz.a ]
    then
      epilogextralinkcmd="-lsz"
    fi

    if [ -f $epiloglibdir/libcubew3.a ]
    then
      epilogextralinkcmd="$epilogextralinkcmd#-lcubew3"
    fi

    if [ -f $epiloglibdir/libepk.util.a ]
    then
      epilogextralinkcmd="$epilogextralinkcmd#-lepk.util"
    fi
    if [ $scalasca = yes -a -f /usr/lib/libswclock.a ]
    then
      epilogextralinkcmd="$epilogextralinkcmd#-lswclock"
    fi

    fixmakeargs="$fixmakeargs EPILOG epilogdir=$epilogdir epiloglibdir=$epiloglibdir epilogbindir=$epilogbindir epilogextralinkcmd=$epilogextralinkcmd epilogincdir=$epilogincdir"
    tauoptions="${tauoptions}-epilog"
    if [ $scalasca = yes ]
    then
      tauoptions="${tauoptions}-scalasca"
    fi
    if [ $mpi = yes ] 
    then 
      if [ $openmp = yes ] 
      then
        fixmakeargs="$fixmakeargs EPILOGOMPI" 
      else
        fixmakeargs="$fixmakeargs EPILOGMPI" 
      fi 
    else
      if [ $openmp = yes ]
      then
        fixmakeargs="$fixmakeargs EPILOGOMP" 
      fi
    fi
fi

if [ $dyninst = yes ]
  then
    fixmakeargs="$fixmakeargs DYNINST dyninstdir=$dyninstdir"
    if [ ! -d $dyninstdir/lib ]
	then
	fixmakeargs="$fixmakeargs DYNINST41"
    fi
    if [ ! -d $dyninstdir/$PLATFORM/lib/libcommon.so ] ; then
	fixmakeargs="$fixmakeargs DYNINST6"
    fi
    if [ ! -d $dyninstdir/src/include -o ! -d $dyninstdir/include ] ; then
	fixmakeargs="$fixmakeargs DYNINST5.2"
    fi
fi

if [ $pcl = yes ]
  then
    if [ $pthread = yes  -o $openmp = yes ]
    then 
      fixmakeargs="$fixmakeargs PCLPTHREAD"
    fi
fi

if [ $papi = yes ]
  then
    if [ $pthread = yes -o $openmp = yes ]
    then
      fixmakeargs="$fixmakeargs PAPIPTHREAD"
    fi
fi

if [ $opari = yes ]
  then
    if [ $pthread = yes -o $tulipthread = yes -o $smarts = yes -o $java = yes ]
    then
      echo "ERROR: -opari option requires OpenMP threads package."
      echo "*****************************************************"
      exit 1
    fi
    if [ $opari_construct = yes -a $opari_region = no ]
    then
      fixmakeargs="$fixmakeargs OPARI_CONSTRUCT"
    fi
    if [ $opari_construct = no -a $opari_region = yes ]
    then
      fixmakeargs="$fixmakeargs OPARI_REGION"
    fi
fi

if [ $tulipthread = yes ]
  then
    fixmakeargs="$fixmakeargs TULIPTHREADS tulipdir=$tulipdir"
    echo "$machine: TULIPDIR = $tulipdir" >> ./build/Config.info
    if [ $smarts = yes ]
    then
      fixmakeargs="$fixmakeargs SMARTS"
      tauoptions="${tauoptions}-smarts"
    else
      tauoptions="${tauoptions}-tulip"
    fi
fi

if [ $trace = yes ]
  then
    if [ $profile = yes ] 
      then
        tauoptions="${tauoptions}-profile"
    fi
    if [ $profilestats = yes ] 
      then
        tauoptions="${tauoptions}-profilestats"
    fi
    tauoptions="${tauoptions}-trace"
fi

if [ $mpitrace = yes ]
  then
    tauoptions="${tauoptions}-mpitrace"
fi

if [ $kai = yes ]
  then
    tauoptions="${tauoptions}-kcc"
fi 

if [ $pgi = yes ]
  then
    tauoptions="${tauoptions}-pgi"
    if [ $openmp = yes ]
    then
      fixmakeargs="$fixmakeargs PGIOPENMP"
    fi
fi 

if [ $intel = yes ]
  then
    if [ $openmp = yes ]
    then
      fixmakeargs="$fixmakeargs INTELOPENMP"
    fi
fi 


if [ $gnu = yes ]
  then
    if [ $openmp = yes ]
    then
      fixmakeargs="$fixmakeargs GNUOPENMP"
    fi
fi 



if [ $fortran_compiler = intel ] ; then
    intelifort=`which ifort 2>/dev/null`
    if [ "y$intelifort" != "y" ] ; then 
	if [ -x $intelifort ]
	then
	    echo "Using Intel ifort as the Fortran Compiler"
	    fixmakeargs="$fixmakeargs INTELIFORT"
	fi
    fi
fi


# CHECK if Intel 8.0 compilers are available. 
if [ $cxx_compiler = icpc ] ; then
    echo "Checking version (8.0/8.1+) of Intel compilers"
      # Intel compilers changed from -cxxlib-icc to -cxxlib-gcc (default) in 8.1
    cat << EOF > f1.cpp
#include <iostream>
using namespace std;

extern "C" {
  void foo(int *x) {
    cout << "x = "<<*x<<endl;
  }
}
EOF

cat << EOF > f2.c
int foo();
int main(int argc, char **argv) {
  return foo();
}
EOF
      
      $cxx_compiler -c f1.cpp
      icc -c f2.c
      if icc f1.o f2.o -o foo -lcprts 1>/dev/null 2>&1 ; then
          echo "Intel v8.0 compilers used"
      else
          $cxx_compiler -c -cxxlib-icc f1.cpp 1>/dev/null 2>&1
          $cxx_compiler -c f1.cpp
          tau_opt_bits=
          if [ `uname -m` = x86_64 -a $machine = i386_linux ]; then
          # if someone is using the 32-bit intel compilers on an x86_64
          # then we need to use -m32 with g++ to get the 32-bit libstdc++
              tau_opt_bits=-m32
              fixmakeargs="$fixmakeargs INTEL32_ON_64" 
          fi
          taugcclibdir=`g++ $tau_opt_bits -print-libgcc-file-name | sed -e 's,[^/]*$,,'`
          taugcclib=`g++ $tau_opt_bits -print-libgcc-file-name `
          taugcclib2dir=`which g++ | sed s/g++/../`         
          if icc f1.o f2.o -o foo -L$taugcclib2dir/lib -L$taugcclibdir -lstdc++ $taugcclib 1>/dev/null 2>&1 ; then
#          echo "Confirmed  - links with gcc libs"
              echo "Intel v8.1+ compilers used"
              if [ "x$taugcclib2dir" != "x/usr/bin/../lib" ] ; then
		  if [ "x$machine" = "xx86_64" ] ; then
		      tauextralibopts="taugcclibopts=-L$taugcclib2dir/lib64"
		  else 
		      tauextralibopts="taugcclibopts=-L$taugcclib2dir/lib"
		  fi
# Here a different version of gcc is used (other than the one installed in /usr/bin)
              fi
              fixmakeargs="$fixmakeargs $tauextralibopts taugcclibdir=$taugcclibdir INTEL81FIX" 
          fi
      fi
      /bin/rm -f f1.o f2.o f1.cpp f2.c foo
      # Check over!
fi


if [ $fortran_compiler = intel ] ; then
  intelifort=`which ifort 2>/dev/null`
  if [ "y$intelifort" != "y" ] ;  then 
    if [ -x $intelifort ] ; then
      echo "Checking version (10.0+) of Intel compilers"
      ifort -v 2>&1 | grep "Version 10" > /dev/null
      if [ $? = 0 ] ; then
          echo "Intel v10.0+ compilers used"
          fixmakeargs="$fixmakeargs INTEL10FIX COMPINST_GNU" 
      fi
    fi
  fi
fi

if [ $ibmxlc = yes ]
then
  if [ $openmp = yes ]
  then
    fixmakeargs="$fixmakeargs IBMXLC_OPENMP"
  fi
fi
	
if [ $machine = hitachi ]
then
  if [ $openmp = yes ]
  then
    fixmakeargs="$fixmakeargs HITACHI_OPENMP"
  fi
fi

if [ $cxx_compiler = cxx ]
then
  if [ $openmp = yes ]
  then
    fixmakeargs="$fixmakeargs COMPAQCXX_OPENMP"
  fi
  if [ $pthread = yes ]
  then
    fixmakeargs="$fixmakeargs COMPAQCXX_PTHREAD"
  fi
fi
   

if [ $fujitsu = yes ]
  then
    tauoptions="${tauoptions}-fujitsu"
fi 

if [ $disableshared = yes ]
then
    fixmakeargs="$fixmakeargs NOSHARED"
fi

if [ $noex = yes ]
  then
    tauoptions="${tauoptions}-noex"
    if [ $kai = yes ]
      then
        fixmakeargs="$fixmakeargs KAINOEX"
    else
    # OTHER COMPILERS NO EXCEPTIONS... SGICC needs this 
        fixmakeargs="$fixmakeargs SGICCNOEX"
    fi
fi
    
#### END OF TAU OPTIONS. Make changes above this line 
fixmakeargs="$fixmakeargs tauoptions=$tauoptions"


if [ $lwp = yes ]
  then
    fixmakeargs="$fixmakeargs LWP_AVAILABLE"
fi

if [ $task = yes ]
  then
    if [ -d XtraP ] 
    then
      XtraPRoot=${tauroot}/XtraP
      if [ $machine != default ]
        then
          echo \#define XTRAPROOT \"$XtraPRoot\"> ${XtraPRoot}/include/XtraPRoot.h
          fixmakeargs="$fixmakeargs TASK_AVAILABLE"
        else
          echo \#define XTRAPROOT \"\" > ${XtraPRoot}/include/XtraPRoot.h
      fi
    fi
fi

if [ $use_pcxx = yes ] 
then	
  fixmakeargs="$fixmakeargs PCXX sage1dir=$sage1dir"
fi

if [ $use_hpcxx = yes ] 
then	
  fixmakeargs="$fixmakeargs HPCXX"
fi

if [ $use_ansic = yes ] 
then	
  fixmakeargs="$fixmakeargs ANSIC"
fi

if [ $use_sage2 = yes ]
then
  fixmakeargs="sage2dir=$sage2dir $fixmakeargs"
fi

if [ $tcltk = yes ]
then
  fixmakeargs="$fixmakeargs TCLTK"
fi



if [ $sicortex = yes ] ; then
    fixmakeargs="$fixmakeargs SICORTEX extrashlibopts=${sicortexlink}"
fi



configure_java

if [ ${tauprefix} = unknown ] ; then
    targetdir=${tauroot}
else
    targetdir=${tauprefix}
    if [ ! -d ${tauprefix} ] ; then
	echo "making directory $tauprefix "
	mkdir -p ${tauprefix}
      # Copy INSTALL README LICENSE files over there 
	cp README LICENSE CREDITS ${tauprefix}
    fi
    if [ ! -d ${tauprefix}/${architecture} ] ; then
	echo "making directory $tauprefix/$architecture lib bin"
	mkdir ${tauprefix}/${architecture}
	mkdir ${tauprefix}/${architecture}/lib
	mkdir ${tauprefix}/${architecture}/bin
    else
	if [ "x$architecture" = "x" ] ; then
	    echo "making directory $tauprefix lib bin"
	    if [ ! -d ${tauprefix}/bin ] ; then
		mkdir ${tauprefix}/bin
	    fi
	    if [ ! -d ${tauprefix}/lib ] ; then
		mkdir ${tauprefix}/lib
	    fi
	fi
    fi
fi


BINTARGET=${targetdir}/${architecture}/bin
JARTARGET=${targetdir}/${architecture}/lib

# Install tau_compiler.sh 
if [ ! -f /bin/bash ] ; then
    bashpath=`which bash`
    if [ ! -f $bashpath ] ; then
	echo "ERROR: You need a working bash shell in your path to use tau_compiler.sh"
	echo "Please add bash to your path and re-run configure."
	echo "**************************************************"
    else
	cat ${tauroot}/tools/src/tau_compiler.sh | sed -e 's#/bin/bash#'$bashpath'#'  > $BINTARGET/tau_compiler.sh
    fi
else
    cp ${tauroot}/tools/src/tau_compiler.sh $BINTARGET
fi
echo "TAU: installed tau_compiler.sh in $BINTARGET"

cp ${tauroot}/tools/src/tau_treemerge.pl $BINTARGET
cp ${tauroot}/tools/src/tauex $BINTARGET
cp ${tauroot}/tools/src/taucc $BINTARGET
cp ${tauroot}/tools/src/taucxx $BINTARGET
cp ${tauroot}/tools/src/tauf90 $BINTARGET
cp ${tauroot}/tools/src/tauex.multiple $BINTARGET
cp ${tauroot}/tools/src/tau_cxx.sh $BINTARGET
cp ${tauroot}/tools/src/tau_cc.sh $BINTARGET
cp ${tauroot}/tools/src/tau_f90.sh $BINTARGET
cp ${tauroot}/tools/src/contrib/tcollect10.ini $BINTARGET




# Copy over tau_load.sh
if [ $mpi = yes ]
then
  cat ${tauroot}/tools/src/tau_load.sh | sed -e 's,@TAUROOTDIR@,'$targetdir',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/tau_load.sh
  chmod a+rx ${targetdir}/${architecture}/bin/tau_load.sh
  echo "TAU: installed tau_load.sh in ${targetdir}/${architecture}/bin"
fi

if [ $ibmmpi = yes ]
then
  cat ${tauroot}/tools/src/tau_poe | sed -e 's,@TAUROOTDIR@,'$targetdir',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/tau_poe
  chmod a+rx ${targetdir}/${architecture}/bin/tau_poe
  echo "TAU: installed tau_poe in ${targetdir}/${architecture}/bin"
fi

cp ${tauroot}/tools/src/jtau_tf/bin/TAU_tf.jar ${targetdir}/${architecture}/lib
echo "TAU: installed Java trace reader/writer api in ${targetdir}/${architecture}/lib"


#if [ $trace = yes ]
#then
cat ${tauroot}/tools/src/contrib/slog2sdk/bin/jumpshot.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/jumpshot
chmod a+rx ${targetdir}/${architecture}/bin/jumpshot

cat ${tauroot}/tools/src/contrib/slog2sdk/bin/slog2print.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/slog2print
chmod a+rx ${targetdir}/${architecture}/bin/slog2print

cat ${tauroot}/tools/src/tau2slog2/bin/tau2slog2.skel | 
sed -e 's,@OLDJDK@,'$oldjdk',' -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/tau2slog2
chmod a+rx ${targetdir}/${architecture}/bin/tau2slog2

echo "TAU: installed tau2slog2, slog2print and jumpshot in ${targetdir}/${architecture}/bin"

cp ${tauroot}/tools/src/contrib/slog2sdk/lib/jumpshot.jar ${targetdir}/${architecture}/lib
cp ${tauroot}/tools/src/contrib/slog2sdk/lib/traceTOslog2.jar ${targetdir}/${architecture}/lib
cp ${tauroot}/tools/src/contrib/slog2sdk/lib/slog2printserial.jar ${targetdir}/${architecture}/lib
cp ${tauroot}/tools/src/tau2slog2/bin/tau2slog2.jar ${targetdir}/${architecture}/lib
echo "TAU: installed required slog2sdk jars in ${targetdir}/${architecture}/lib"
#fi


if [ $slog2 = yes ]
then
  if [ $internalslog2 = yes ]
  then
    cat ${tauroot}/tools/src/contrib/slog2sdk/bin/jumpshot.skel | 
    sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/jumpshot
    chmod a+rx ${targetdir}/${architecture}/bin/jumpshot
    
    cat ${tauroot}/tools/src/contrib/slog2sdk/bin/slog2print.skel | 
    sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' > ${targetdir}/${architecture}/bin/slog2print
    chmod a+rx ${targetdir}/${architecture}/bin/slog2print
    echo "TAU: installed slog2print and jumpshot in ${targetdir}/${architecture}/bin"
    cp ${tauroot}/tools/src/contrib/slog2sdk/lib/jumpshot.jar ${targetdir}/${architecture}/lib
    cp ${tauroot}/tools/src/contrib/slog2sdk/lib/traceTOslog2.jar ${targetdir}/${architecture}/lib
    cp ${tauroot}/tools/src/contrib/slog2sdk/lib/slog2printserial.jar ${targetdir}/${architecture}/lib
    echo "TAU: installed required slog2sdk jars in ${targetdir}/${architecture}/lib"
    
    slog2dir=$targetdir/$architecture
  fi
  utils/slogconverter/tau2slog2.skel $jdkdir $targetdir $slog2dir $architecture > $targetdir/$architecture/bin/tau2slog2JNI
  chmod a+rx ${targetdir}/${architecture}/bin/tau2slog2JNI
  echo "TAU: installed tau2slog2JNI in ${targetdir}/${architecture}/bin"
fi



cat ${tauroot}/tools/src/tau-config.in | 
sed -e 's,@TAUROOTDIR@,'$targetdir',' -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/tau-config
chmod a+rx ${targetdir}/${architecture}/bin/tau-config

echo "TAU: installed tauinc.pl in ${targetdir}/${architecture}/bin"
cp ${tauroot}/tools/src/tauinc.pl ${targetdir}/${architecture}/bin
chmod a+rx  ${targetdir}/${architecture}/bin/tauinc.pl

configure_perfexplorer

cat ${tauroot}/tools/src/TauIL/bin/tau_analyze.skel | 
sed -e 's,@TAUROOTDIR@,'$targetdir','  -e 's,@SHELL@,'$taushell',' -e 's,@ARCH@,'$architecture',' \
 > ${targetdir}/${architecture}/bin/tau_analyze
chmod a+rx ${targetdir}/${architecture}/bin/tau_analyze
echo "TAU: installed tau_analyze in ${targetdir}/${architecture}/bin"

cat ${tauroot}/tools/src/TauIL/Makefile.inc.skel |
sed -e 's,@TAUROOTDIR@,'$tauroot',' \
> ${tauroot}/tools/src/TauIL/Makefile.inc
echo "TAU: installed Makefile.inc in ${tauroot}/tools/src/TauIL"

cp ${tauroot}/tools/src/TauIL/bin/*.jar ${targetdir}/${architecture}/lib
echo "TAU: installed TauIL and supporting jars in ${targetdir}/${architecture}/lib"

cp ${tauroot}/tools/src/tau_throttle.sh ${targetdir}/${architecture}/bin
echo "TAU: installed tau_throttle script"


wishname=wish

tk_path="/usr/local/bin/tkman"

# -- set name of remote shell command
if [ $machine = "hp9000s700" -o $machine = "hp9000s800" ]
then
  remotesh=remsh
else
  remotesh=rsh
fi

# -- now install the TAU tools
#TAUTOOLS="tau taud fancy classy cagey racy dandy cosy dumpy speedy handy spiffy"
# TAU Portable profiling package just needs racy
TAUTOOLS="taud racy"

echo " "
echo "TAU: installing tools in ${tauroot}/${architecture}/bin"
for tool in $TAUTOOLS ;  do
    rm -f ${tauroot}/${architecture}/bin/$tool
    cat ${tauroot}/tools/tool.skel |
    sed -e 's,@TAUROOT@,'$targetdir',' -e 's,@ARCH@,'$architecture',' -e 's,@TOOL@,'$tool',' \
	-e 's,@REMSH@,'$remotesh',' -e 's,@TKMANPATH@,'$tk_path',' \
	-e 's,@WISHNAME@,'$wishname',' \
	> ${targetdir}/${architecture}/bin/${tool}
    chmod a+rx ${targetdir}/${architecture}/bin/${tool}
done


if [ $use_pcxx = yes ]
then

$echo "TAU: installing breezy... ${nnl}"
rm -f ${tauroot}/bin/${architecture}/breezy
cat lang_support/pc++/breezy/userAgent/tool.skel |
sed -e 's,@TAUROOT@,'${tauroot}',' -e 's,@ARCH@,'${architecture}',' -e 's,@TOOL@,'breezy',' \
> ${tauroot}/bin/${architecture}/breezy
chmod a+rx ${tauroot}/bin/${architecture}/breezy
echo "done"

if [ $tcltkfile  = "/" ]
then
  echo ""
  echo "For compiling the breezy user interface, we need the very"
  echo "site-specific locations for header files and libraries for"
  echo "X11 and Tcl/Tk. Typing <return> after the questions will use"
  echo "the specified default locations in brackets."
  echo ""

  echo "Options for including Tcl/Tk headers [-I/usr/local/include]"
  $echo "? ${nnl}"
  read tcltkheader
  if [ "x$tcltkheader" = "x" ]; then tcltkheader="-I/usr/local/include"; fi

  foo="`echo $tcltkheader | sed -e 's/-I/-L/' -e 's/include/lib/'` -ltk4.0 -ltcl7.4"
  echo "Options for linking Tcl/Tk [$foo]"
  $echo "? ${nnl}"
  read tcltklib
  if [ "x$tcltklib" = "x" ]; then tcltklib="$foo"; fi

  echo "Options for including X11 headers [-I/usr/include]"
  $echo "? ${nnl}"
  read x11header
  if [ "x$x11header" = "x" ]; then x11header="-I/usr/include"; fi

  foo="`echo $x11header | sed -e 's/-I/-L/' -e 's/include/lib/'` -lX11"
  echo "Options for linking X11 [$foo]"
  $echo "? ${nnl}"
  read x11lib
  if [ "x$x11lib" = "x" ]; then x11lib="$foo"; fi

  echo ""
else
  echo "TAU: using make info from file $tcltkfile"
  . $tcltkfile
fi

sed -e 's,^TCLTKHEADER =.*$,TCLTKHEADER = '"$tcltkheader"',' \
    -e 's,^X11HEADER   =.*$,X11HEADER   = '"$x11header"','   \
    -e 's,^X11LIB      =.*$,X11LIB      = '"$x11lib"','      \
    -e 's,^TCLTKLIB    =.*$,TCLTKLIB    = '"$tcltklib"','    \
    lang_support/pc++/breezy/userAgent/Makefile > tmpmake
mv tmpmake lang_support/pc++/breezy/userAgent/Makefile

fi  # if breezy

if [ $use_hpcxx = yes ]
then
# Fix the file info for preprocessor in lang_support/hpc++/include-clean
sed -e 's,^#1 ".*/lang_support/hpc++/include/hpc++.h",'#1\ \"$tauroot/lang_support/hpc++/include/hpc++.h\"',' lang_support/hpc++/include-clean/hpc++.h > tmplib
mv tmplib lang_support/hpc++/include-clean/hpc++.h
fi

# Save the FixMakefile args
# Clear any old data
grep "^#" ./utils/FixMakefile.info > ./utils/FixMakefile.info~~0
/bin/mv ./utils/FixMakefile.info~~0 ./utils/FixMakefile.info
echo $fixmakeargs >> ./utils/FixMakefile.info

# Now FINALLY FixMakefile with the string I have built
utils/FixMakefile $fixmakeargs

# Use default setups, forget everything else (PHB)
if [ $machine = default ]
  then
    /bin/cp ./utils/FixMakefile.sed.default  ./utils/FixMakefile.sed
    /bin/cp ./utils/FixMakefile.info.default ./utils/FixMakefile.info
    /bin/cp ./build/Config.info.default      ./build/Config.info
fi

    sedout="./utils/FixMakefile.sed"
echo "Applying script to all Makefiles, please wait, this may take a while..."

# Change back to $START_DIR (defined at the top) to ensure we're in the tau2 directory
# before we execute this fairly dangerous 'find' command
cd $START_DIR
for i in `find . -name Makefile -print `
#for i in $tauroot/include/Makefile $tauroot/src/Profile/Makefile $tauroot/utils/Makefile $tauroot/Makefile
  do 
    $echo ".${nnl}"
    sed -f $sedout < ${i} > ${i}~~0
    mv ${i}~~0 ${i}
done
echo .

if [ $tauprefix != unknown ]
  then 
    echo "TAU: Copying include directory to ${tauprefix}"
    cp -r include ${tauprefix}
    echo "TAU: Copying man directory to ${tauprefix}"
    cp -r man ${tauprefix}
fi

# Attempt to install metatext (jev)
if [ -f ./metatext/configure ]
  then
    cd ./metatext
    ./configure  1> /dev/null 2>&1
    cd ..
fi



#############################################################################
# Set up TAU-specific build system

echo " "
echo "Configuring TAU Build scripts..."

# -- Save C++ compiler, C compiler, and USEROPT for pC++
if [ $use_pcxx = yes ]
then
echo "$machine: pcxx_root    = $sage1dir" >> \
        ./build/pc++/Config.info
echo "$machine: pcxx_cxx     = $cxx_compiler" >> \
        ./build/pc++/Config.info
echo "$machine: pcxx_cc      = $c_compiler" >> \
        ./build/pc++/Config.info
opt=`echo $useropt | sed -e 's/_/ /g'`
echo "$machine: pcxx_useropt = $opt" >> \
        ./build/pc++/Config.info
echo "" >> ./build/pc++/Config.info
fi

# -- Save C++ compiler, C compiler, and USEROPT for HPC++
if [ $use_hpcxx = yes ]
then
opt=`echo $useropt | sed -e 's/_/ /g'`
echo "$machine: hpcxx_useropt = $opt" >> \
        ./build/hpc++/Config.info
echo "$machine: hpcxx_sage1 = $sage1dir" >> \
        ./build/hpc++/Config.info
echo "$machine: hpcxx_sage2 = $sage2dir" >> \
        ./build/hpc++/Config.info
echo "$machine: hpcxx_pstl = $pstldir" >> \
        ./build/hpc++/Config.info
echo "$machine: hpcxx_hpnx = $hpnxdir" >> \
        ./build/hpc++/Config.info
echo "" >> ./build/hpc++/Config.info
fi

# Modify the Makefiles so include/Makefile is replaced by the TAU options 
# for specific examples
echo "s@include \(.*\)TAUROOTDIR\(.*\)@include $\(TAUROOTDIR\)/$architecture/lib/Makefile.tau$tauoptions@g" > utils/sedexamples.out
#echo "s@include/Makefile@$machine/lib/Makefile.tau$tauoptions@g" >utils/sedexamples.out
sedex="./utils/sedexamples.out"

echo "Modifying Makefiles in the examples subdirectory..."

# Prefix start from examples directory
pr=examples
exampleslist="instrument/Makefile mapping/embedded/Makefile \
  mapping/external/Makefile fork/Makefile selectiveAccess/Makefile"

if [ $fortran_compiler != no ] 
then
  exampleslist="$exampleslist fortran/Makefile f90/Makefile"
fi

# Rules for adding examples follow...
# If PDT is specified, then modify the following makefiles
if [ $pdt = yes ]
then
  exampleslist="$exampleslist autoinstrument/Makefile reduce/Makefile cinstrument/Makefile"
  if [ $fortran_compiler != no ]
  then
    exampleslist="$exampleslist selective/Makefile"
  fi
fi

# If PDT is specified WITH MPI
if [ $pdt = yes -a $mpi = yes ]
then
  exampleslist="$exampleslist pdt_mpi/c++/Makefile pdt_mpi/c/Makefile" 
  if [ $pthread = yes ]
  then
    exampleslist="$exampleslist mixedmode/Makefile"
  fi

  if [ $fortran_compiler != no ]
  then
    exampleslist="$exampleslist pdt_mpi/f90/Makefile"
  fi 
fi

if [ $mpi = yes ]
then
  exampleslist="$exampleslist pi/Makefile mpishlib/Makefile"
  if [ $fortran_compiler != no ]
  then
    exampleslist="$exampleslist NPB2.3/config/make.def"
  fi
  if [ $openmp = yes ]
  then 
    exampleslist="$exampleslist openmpi/Makefile"
  fi
fi

if [ $opari = yes ] 
then
  exampleslist="$exampleslist opari/c++/Makefile"
  if [ $pdt = yes -a $fortran_compiler != no ]
  then 
    exampleslist="$exampleslist opari/pdt_f90/Makefile"
  fi

  if [ $mpi = yes ]
  then
    exampleslist="$exampleslist opari/openmpi/Makefile"
  fi
fi

if [ $trace = yes ]
then
  exampleslist="$exampleslist traceinput/c++/Makefile traceinput/c/Makefile"
fi

if [ $callpath = yes ]
then
  exampleslist="$exampleslist callpath/Makefile"
fi

if [ $python = yes -o $java = yes -o $dyninst = yes ]
then
# RESET the exampleslist, the C, C++, F90 examples don't matter!
  exampleslist=""
fi

if [ $pthread = yes ]
then
  exampleslist="$exampleslist threads/Makefile cthreads/Makefile"
fi

if [ $sproc = yes ]
then
  exampleslist="$exampleslist sproc/Makefile"
fi

if [ $papi = yes -o $pcl = yes ]
then
  exampleslist="$exampleslist papi/Makefile multicounter/Makefile"
  if [ $pthread = yes ]
  then
    exampleslist="$exampleslist papithreads/Makefile" 
  fi 
fi






######################################################################
# If the default gcc/g++ is not used, Modify the Makefiles...
# Choose the c++ and cc compiler





# Modify the Makefiles only if prefix is not specified. 
if [ $tauprefix = unknown ]
then 
  for i in $exampleslist
  do 
    $echo ".${nnl}"
    sed -f $sedex < $pr/${i} > $pr/${i}~~0
    mv $pr/${i}~~0 $pr/${i}
  done
# Copy over the Makefile so make clean works
  cp include/Makefile $machine/lib/Makefile.tau$tauoptions
fi
echo .

# If it is default, restore to original state
if [ "y$1"  = "ydefault" ]
then
  echo "Fixing examples Makefiles..."
  echo "s@include \(.*\)TAUROOTDIR\(.*\)@include $\(TAUROOTDIR\)/include/Makefile@g" >utils/sedexamples.out
  sedex="./utils/sedexamples.out"
  for i in `find examples -name Makefile -print` examples/NPB2.3/config/make.def
  do 
    $echo ".${nnl}"
    sed -f $sedex < ${i} > ${i}~~0
    mv ${i}~~0 ${i}
  done
fi
    
if [ $perf = yes ]
then
    cp include/Makefile $tautoplevel/$architecture/lib/Makefile.tau$tauoptions
fi
  

if [ $slog2 = yes ]
then
  /bin/rm -f utils/slogconverter/trace_impl.h
  utils/slogconverter/slogtest $jdkdir > utils/slogconverter/trace_impl.h
fi

if [ $tauprefix != unknown ]
then
  cp -r examples ${tauprefix}
  cp .all_configs .last_config ${tauprefix}
fi


# bye bye
echo 
echo "Configuration complete!"
if [ $tauprefix != unknown ]
  then 
    echo "   Please add " $tauprefix/$architecture/bin " to your path"
  else
    echo "   Please add " $tauroot/$architecture/bin " to your path"
fi
echo '   Type "make install" to begin compilation'

exit 0









