#!/bin/sh

# $Id: makeMakefile,v 1.191 2014/02/22 17:23:51 svein Exp $

# IMPORTANT: Make is picky about tab stops. Every continuation line in a
#            rule must start with a tab stop.

#############################################################################
#
# Preprocessing
#
#############################################################################

if_test () {
# $1: First operand
# $2: Operator
# $3: Second operand
# $4: Then-clause

	op1=$1; operator=$2; op2=$3;
	if test $# -gt 3; then
	    then_clause="$4"
	else
	    then_clause=""
	fi

	if test "$XITE_HOSTTYPE" != "Win32"; then
		echo "	     -@if test $op1 $operator $op2; then \\"
		if test -n "$then_clause"; then
		    echo "$then_clause; \\"
		    echo "      fi"
		fi
	else
	        if test "$op1" = "!"; then
		    op1="NOT"
		fi
		if test "$operator" = "=" -o "$operator" = "=="; then
			operator="EQU"
		elif test "$operator" = "!="; then
			operator="NEQ"
		elif test "$operator" = "-d"; then
		        operator="EXIST"
		fi
		echo "	     -@IF $op1 $operator $op2 \\"
		if test -n "$then_clause"; then
		    echo "($then_clause)"
		fi

	fi
}

end_if () {
	if test "$XITE_HOSTTYPE" != "Win32"; then
		echo "	     fi"
	fi
}

unix_only () {
	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
		echo "	     $*"
	fi
}

ar_cmd () {
# $1: Library file
# $2: Object files (in the form of a "make" macro)

	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
		echo "	       echo \"\$(AR) \$(AR_A_OPT) $1 $2\"${CMD_SEP} \\"
		echo "	       \$(AR) \$(AR_A_OPT) $1 $2${CMD_SEP} \\"
	else
		echo "	     @IF EXIST $1 \\"
		echo "	       echo \"\$(AR) \$(AR_A_OPT) $1 $2\"${CMD_SEP} \\"
		echo "	       \$(AR) \$(AR_A_OPT) $1 $2"
		echo "	     @IF NOT EXIST $1 \\"
		echo "	       echo \"\$(AR) \$(AR_A_OPT) /OUT:$1 $2\"${CMD_SEP} \\"
		echo "	       \$(AR) \$(AR_A_OPT) /OUT:$1 $2"
	fi
}

cd_lib_and_clean () {
	echo "	       -cd \$(XITE_LIB_DEST)${CMD_SEP} \\"
	echo "	       \$(RM_F) *.${OBJ_EXT} obj-files${CMD_SEP} \\"
}

lib_list () {
	echo "	       \$(AR) \$(AR_T_OPT) \$(?) | \\"
	echo "	       \$(GREP_V) \"SYMDEF\" > obj-files${CMD_SEP} \\"
}

lib_extract_f () {
# $1: Library file
	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
		echo "	       \$(AR) \$(AR_X_OPT) $1${CMD_SEP} \\"
	else
		echo "	       ${lib_extract} $1${CMD_SEP} \\"
	fi
}

install_dso () {
# $1: Complete dso name, including version spec
# $2: Short dso name
	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	        echo "	       -cd \$(XITE_LIB_DEST)${CMD_SEP} \\"
		echo "	       \$(LINK_F) $1 \\"
		echo "	         $2 ${TO_DEV_NULL}"
	else
	        echo "	       -cd \$(XITE_LIB_DEST)${CMD_SEP} \\"
		echo "	       \$(LINK_F) $1 \\"
		echo "	         $2 ${TO_DEV_NULL}"
	fi
}

cmd_and_echo () {
# $1: cmd
	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
		echo "	       echo \"$1\"${CMD_SEP} \\"
		echo "	       $1${CMD_SEP} \\"
	else
		echo "	       $1"
	fi
}

ld_basic_cmd () {
# $1: Library file
# $2: Object files

	if [ "$XITE_HOSTTYPE" = "Win32" ]; then
		echo "	       \$(LD) \$(DSO_NAME_FLAGS)$1 $2 \\"
	elif [ "$XITE_HOSTTYPE" != "SunOS" -a "$XITE_HOSTTYPE" != "AIX" ]; then
		echo "	       \$(LD) \$(DSO_NAME_FLAGS) $1 $2 \\"
		echo "	         -o $1 \\"
	else
		echo "	       \$(LD) -o $1 $2 \\"
	fi
}

dso_target () {
# $1: Label for dso target (not a real target)
# $2: Name of dso file (dependency of dso label) and final installed dso target
# $3: Directory for installation of $2
# $4: Name of dso file prior to final installation (output of linker)
# $5: Static library dependency file of dso target
# $6: Directory for $5
# $7: Extra arguments to the linker

  echo "$1: $3${DIR_SEP}$2"

  if [ "$XITE_HOSTTYPE" != "Win32" ]; then
    echo "$3${DIR_SEP}$2: $3${DIR_SEP}$4"
    install_dso "$4" "$2"
    echo ""
    echo "$3${DIR_SEP}$4: $6${DIR_SEP}$5"
    cd_lib_and_clean
    lib_list
    lib_extract_f "\$(?)"
    ld_basic_cmd "$4" "*.${OBJ_EXT}"
    echo "	             $7${CMD_SEP} \\"
    unix_only "	       \$(CHMOD) a+rx $3${DIR_SEP}$4 ${TO_DEV_NULL}"
  else
    echo "$3${DIR_SEP}$4: $6${DIR_SEP}$5"
    cd_lib_and_clean
    lib_list
    lib_extract_f "\$(?)"
    ld_basic_cmd "$4" "*.${OBJ_EXT}"
    echo "	             $7"
    install_dso "$4" "$2"
  fi
}

prog=`basename $0`

tmpHosttype=""; help=0
while test "$#" -gt 0
do
	case $1 in
	-p)
		if test $# -le 1; then
		  echo "Argument missing for option $1." 1>&2; help=1; break
		fi
		shift
		tmpHosttype="$1"
		;;
	-h|-help)
		help=1; break
		;;
	-x)
		if test $# -le 1; then
		  echo "Argument missing for option $1." 1>&2; help=1; break
		fi
		shift
		XITE_HOME=$1
		;;
	*)
		echo "Unknown argument $1." 1>&2;
		help=1; break
		;;
	esac
	shift
done

if test -z "$XITE_HOME"
then
  echo "$prog: XITE home directory is not known." 1>&2
  echo "Aborting $prog." 1>&2
  help=1
fi

if test "$help" -eq 1
then
	echo "usage: $prog [-x <XITE home-directory>] [-p <platform>] [-h(elp)]" 1>&2
	echo "       where default <platform> is the one you're using now" 1>&2
	echo "       and default XITE home-directory is given by the" 1>&2
	echo "       environment variable XITE_HOME." 1>&2
	exit 1
fi

utildir=$XITE_HOME/etc/.install
getPlatform=$utildir/getPlatform

if test -z "$tmpHosttype" -a -n "$XITE_HOSTTYPE"
then
	tmpHosttype=$XITE_HOSTTYPE
fi

XITE_HOSTTYPE=`$getPlatform "$tmpHosttype" "$utildir" stderr`

utildir_XP=%XITE_HOME%\\etc\\.install
lib_extract=$utildir_XP\\lib_extract.cmd


#############################################################################
#
# Start to generate Makefile.
#
#############################################################################

echo "# Makefile for XITE software, $XITE_HOSTTYPE"

cat <<\EOF_START
#
######################################################################
# Customization:
#
# You may want to change the definitions of
#     1) CC
#     2) X_INC_DIR (Not for Windows)
#     3) X_LIB_DIR (Not for Windows)
#     4) XITE_BIN_DEST
#     5) XITE_LIB_DEST
#     6) XITE_INC_DEST
#     7) XITE_MAN_DEST
#     8) XITE_DOC_DEST
#     9) CFLAGS
#    10) LFLAGS
#    11) XLIB
#    12) MATLAB_INC
#    13) MATLAB_LIB
#    14) MATLAB_MEX_DEST
#    15) TIFF_INC_DIR
#    16) TIFF_LIB_DIR
#    17) PNG_INC_DIR
#    18) PNG_LIB_DIR
#    19) PNM_INC_DIR
#    20) PNM_LIB_DIR
#    21) FWF_INC_DIR (Not for Windows)
#    22) FWF_LIB_DIR (Not for Windows)
#    23) XPM_INC_DIR (Not for Windows)
#    24) XPM_LIB_DIR (Not for Windows)
# to reflect your particular needs.
######################################################################

.SUFFIXES:
.SUFFIXES: .dummy

EOF_START

if    [ "$XITE_HOSTTYPE" = "IRIX"   -o \
	"$XITE_HOSTTYPE" = "IRIX64" -o \
	"$XITE_HOSTTYPE" = "OSF1" ]
then
	echo "RPATH_OPT       = -rpath"
	RPATH_OPT="yes"
elif [ "$XITE_HOSTTYPE" = "SunOS5" ]; then
	echo "RPATH_OPT       = -R"
	RPATH_OPT="yes"
elif [ "$XITE_HOSTTYPE" = "Linux" -o "$XITE_HOSTTYPE" = "Linux_x86_64" ]; then
	echo "RPATH_OPT       = -Xlinker -rpath -Xlinker"
	RPATH_OPT="yes"
else
	echo "RPATH_OPT       ="
	RPATH_OPT=""
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "SHELL           = /bin/sh"
	DIR_SEP="/"
	CMD_SEP="; "
	LIB_EXT=".a"
	DSO_EXT=".so"
	OBJ_EXT="o"
	OBJ_LIB_EXT=""
	EXE_EXT=""
	OUT_OPT="-o "
	echo "LIB_TIFF        = -ltiff"

        if [ "$XITE_HOSTTYPE" = "SunOS5" ]; then
		echo "LIB_Z           = -lz"
	 	echo "LIB_JPEG        = -ljpeg"
	else
		echo "LIB_Z           = -lz"
	 	echo "LIB_JPEG        = -ljpeg"
	fi
	echo "LIB_MATH        = -lm"
	echo "LIB_PNG         = -lpng"
	echo "# Single-library netpbm requires version 10 or later"
	echo "LIB_PNM         = -lnetpbm"
	echo "# LIB_PNM       = -lpnm -lppm -lpgm -lpbm"

        if [ "$XITE_HOSTTYPE" = "Linux" -o "$XITE_HOSTTYPE" = "Linux_x86_64" ];
	then
		echo "LIB_PTY         = -lutil"
	else
		echo "LIB_PTY         = "
	fi

	echo "COPY            = cp"
	echo "LINK            = ln -s"
	echo "LINK_F          = ln -f -s"
	echo "CHMOD           = chmod"
	echo "RM              = rm"
	echo "RM_F            = \$(RM) -f"
	echo "GREP            = grep"
	echo "GREP_V          = \$(GREP) -v"

	EQU_STRING="="
	NEQ_STRING="!="
	TO_DEV_NULL="> /dev/null 2>&1"
else
	DIR_SEP="\\"
	CMD_SEP=" & "
	LIB_EXT=".lib"
	DSO_EXT=".dll"
	OBJ_EXT="obj"
	OBJ_LIB_EXT=":.o=.${OBJ_EXT}"
	EXE_EXT=".exe"
	OUT_OPT="-OUT:"
	echo "LIB_TIFF        = libtiff.lib"
#	echo "LIB_Z           = "
#	echo "LIB_JPEG        = "
#	echo "LIB_MATH        = "
	echo "LIB_PNG         = libpng.lib"
	echo "# Single-library netpbm requires version 10 or later"
	echo "LIB_PNM         = libnetpbm.lib"
	echo "#LIB_PNM         = libpnm.lib libppm.lib libpgm.lib libpbm.lib"
	echo "COPY            = copy"
	echo "LINK            = \$(COPY)"
	echo "LINK_F          = \$(LINK)"
	echo "CHMOD           = "
	echo "RM              = del"
	echo "RM_F            = \$(RM) /F"
	echo "GREP            = find"
	echo "GREP_V          = \$(GREP) /V"
	EQU_STRING="EQU"
	NEQ_STRING="NEQ"
	TO_DEV_NULL=""
fi # Win32

echo "XITE_HOSTTYPE   = $XITE_HOSTTYPE"

#############################################################################
#
# CC, X_INC_DIR, X_LIB_DIR, XITE_BIN_DEST, XITE_LIB_DEST, XITE_MAN_DEST,
# XITE_DOC_DEST, DEBUG
#
#############################################################################

cat <<\EOF_CC

# 1) Set CC to the C compiler you want to use, typcially cc, gcc or cl (XP)
#
EOF_CC

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "CC              = gcc"
else
	echo "CC              = cl"
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then

	cat <<\EOF_X

# 2) Set X_INC_DIR equal to the directory path for X11 include files.
#
X_INC_DIR       = /usr/include/X11


# 3) Set X_LIB_DIR equal to the directory to search for X11 library files.
#
X_LIB_DIR       = /usr/lib64
X_LIB_RPATH     = $(RPATH_OPT) $(X_LIB_DIR)

# 4) Set XITE_XAPPLRESDIR equal to the X11 application default reqource dir.
#
XITE_XAPPLRESDIR = $XITE_HOME/etc/app-defaults
EOF_X

	if [ -n "$RPATH_OPT" ]; then
		echo "LFLAGS_X        = -L\$(X_LIB_DIR) \$(X_LIB_RPATH)"
	else
		echo "LFLAGS_X        = -L\$(X_LIB_DIR)"
	fi
fi # !Win32

echo "
# 4) Set XITE_BIN_DEST to determine where the XITE executables will
#    be placed
#
"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "#TOP            = ${DIR_SEP}local"
	echo "TOP             = \$\$XITE_HOME"
else
	echo "#TOP            = C:"
	echo "TOP             = \$(XITE_HOME)"
fi # !Win32

echo "XITE_BIN_DEST   = \$(TOP)${DIR_SEP}bin
#XITE_BIN_DEST   = \$(TOP)${DIR_SEP}bin${DIR_SEP}\$(XITE_HOSTTYPE)


# 5) Set XITE_LIB_DEST to determine where the XITE object library will be
#    placed
#
#XITE_LIB_DEST   = .
XITE_LIB_DEST   = \$(TOP)${DIR_SEP}lib
#XITE_LIB_DEST   = \$(TOP)${DIR_SEP}lib${DIR_SEP}\$(XITE_HOSTTYPE)
XITE            = xite"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_LIB        = lib\$(XITE)${LIB_EXT}
XITE_MAJ        = .3
XITE_MIN        = .4"
else
echo "XITE_LIB        = lib\$(XITE)_static${LIB_EXT}
XITE_MAJ        =
XITE_MIN        = "
fi
echo "XITE_DSO        = lib\$(XITE)${DSO_EXT}
XITE_DSO_V      = \$(XITE_DSO)\$(XITE_MAJ)\$(XITE_MIN)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_LIB_X      = lib\$(XITE)X${LIB_EXT}"
echo "XITE_X_MAJ      = .3
XITE_X_MIN      = .4"
echo "XITE_X_DSO      = lib\$(XITE)X${DSO_EXT}
XITE_X_DSO_V    = \$(XITE_X_DSO)\$(XITE_X_MAJ)\$(XITE_X_MIN)"
fi

if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "LIB_XITE         = \$(XITE_LIB)"
	echo "LIB_XITE_IMP     = lib\$(XITE)${LIB_EXT}"
	echo "LIB_XITE_IMP_MEX = -l\$(XITE)"
else
	echo "LIB_XITE         = -l\$(XITE)"
	echo "LIB_XITE_IMP     = \$(LIB_XITE)"
	echo "LIB_XITE_IMP_MEX = \$(LIB_XITE_IMP)"
	echo "LIB_XITE_X       = -l\$(XITE)X"
	echo "LIB_XITE_X_IMP   = \$(LIB_XITE_X)"
fi

echo "
# 6) Set XITE_INC_DEST to determine where the XITE header files will be put
#
#XITE_INC_DEST   = .
XITE_INC_DEST   = \$(TOP)${DIR_SEP}include


# 7) Set XITE_MAN_DEST to determine where the XITE manual files will be put
#
#XITE_MAN_DEST   = .
XITE_MAN_DEST   = \$(TOP)${DIR_SEP}man


# 8) Set XITE_DOC_DEST to determine where the XITE html files will be put
#
#XITE_DOC_DEST   = .
XITE_DOC_DEST   = \$(TOP)${DIR_SEP}doc


# 9) Set CFLAGS
#
#DEBUG          = -DDEBUG
DEBUG           = 
"

#############################################################################
#
# OPTIM, OPTIM_GNU, CFLAGS_ALWAYS, CFLAGS_PROD_CC, CFLAGS_DEV_CC, CFLAGS_MEX
#
#############################################################################

if test "$XITE_HOSTTYPE" = "AIX"
then

	cat <<\EOF_AIX

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV -Dvfork=fork \
                  $(DEBUG) -DDEF_STRCASECMP $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    =
CARCH_OPT       = 

EOF_AIX

elif test "$XITE_HOSTTYPE" = "HP-UX"
then

	cat <<\EOF_HP-UX

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -DHPUX -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV $(DEBUG) \
                  $(REGEX) $(DIRENT) $(PTY) $(XITE_WM_COLORMAP)

OPTIM           = +O2
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    =
CARCH_OPT       = 

EOF_HP-UX

elif test "$XITE_HOSTTYPE" = "IRIX"
then

	cat <<\EOF_IRIX

REGEX           = -DREGEX
DIRENT          = 
PTY             = -DGETPTY
XITE_WM_COLORMAP = 

# The option -mips2 requires an R4000 family processor, or higher

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV -D_BSD_SIGNALS \
                  -Dvfork=fork $(DEBUG) $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O2
OPTIM_GNU       = -O
CDEBUG          = -g -fullwarn
CC_DSO_FLAGS    =
CARCH_OPT       = -signed -mips2

EOF_IRIX

elif test "$XITE_HOSTTYPE" = "IRIX64"
then

	cat <<\EOF_IRIX64

REGEX           = -DREGEX
DIRENT          = 
PTY             = -DGETPTY 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV -D_BSD_SIGNALS \
                  -Dvfork=fork $(DEBUG) $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O2
OPTIM_GNU       = -O
CDEBUG          = -g -fullwarn
CC_DSO_FLAGS    =
CARCH_OPT       = -signed

EOF_IRIX64

elif test "$XITE_HOSTTYPE" = "Linux" -o "$XITE_HOSTTYPE" = "Linux_x86_64"
then

	cat <<\EOF_Linux

REGEX           = -DREGEX
DIRENT          = 
PTY             = -DOPENPTY
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) $(DEBUG) -Dinstring=__instring \
                  $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O3
CDEBUG          = -g
CC_DSO_FLAGS    = -fPIC
CARCH_OPT       = 

EOF_Linux

elif test "$XITE_HOSTTYPE" = "OSF1"
then

	cat <<\EOF_OSF1

REGEX           = -DREGEX
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV -Dvfork=fork $(DEBUG) \
                  $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g -verbose
CC_DSO_FLAGS    =
CARCH_OPT       = -std1

EOF_OSF1

elif test "$XITE_HOSTTYPE" = "SunOS"
then

	cat <<\EOF_SunOS

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) $(DEBUG) -DDEF_STRCASECMP \
                  $(REGEX) $(DIRENT) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    = -PIC
CARCH_OPT       = 

EOF_SunOS

elif test "$XITE_HOSTTYPE" = "SunOS5"
then

	cat <<\EOF_SunOS5

REGEX           = -DREGEX
DIRENT          = -DNO_DIRENT
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV $(DEBUG) \
                  $(DIRENT) $(REGEX) $(PTY) -I/usr/ucbinclude \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g -v
CC_DSO_FLAGS    = -KPIC
CARCH_OPT       = 

EOF_SunOS5

elif test "$XITE_HOSTTYPE" = "ULTRIX"
then

	cat <<\EOF_ULTRIX

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) $(DEBUG) $(DIRENT) $(REGEX) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    =
CARCH_OPT       = 

EOF_ULTRIX

elif test "$XITE_HOSTTYPE" = "CYGWIN32"
then

	cat <<\EOF_CYGWIN32

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -D$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV $(DEBUG) \
                  $(DIRENT) $(REGEX) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    =
CARCH_OPT       = 

EOF_CYGWIN32

elif test "$XITE_HOSTTYPE" = "Other"
then

	cat <<\EOF_Other

REGEX           = 
DIRENT          = 
PTY             = 
XITE_WM_COLORMAP = 

CFLAGS_ALWAYS   = -Dunknown $(DEBUG) $(DIRENT) $(REGEX) $(PTY) \
                  $(XITE_WM_COLORMAP)

OPTIM           = -O
OPTIM_GNU       = -O
CDEBUG          = -g
CC_DSO_FLAGS    =
CARCH_OPT       = 

EOF_Other

elif test "$XITE_HOSTTYPE" = "Win32"
then

	cat <<\EOF_Win32

REGEX           = 
DIRENT          = -DNO_DIRENT

CFLAGS_ALWAYS   = -D_WIN32 -DO_NDELAY=FNDELAY -D$(XITE_HOSTTYPE) -DSYSTEM_V \
                  -DSYSV $(DEBUG) /nologo -DDEF_STRCASECMP -Dsleep=_sleep \
                  $(DIRENT) $(REGEX)

OPTIM           = /O2
OPTIM_GNU       = /O
CDEBUG          = /Z7 /W4
CC_DSO_FLAGS    = /MD
CARCH_OPT       = 

EOF_Win32

fi

echo "GCC_DSO_FLAGS   = -fPIC
"

cat <<\EOF_CFLAGS_PROD
# The following is recommended for final production version with cc
#
CFLAGS_PROD_CC  = $(CFLAGS_ALWAYS) $(OPTIM) $(CARCH_OPT) -I$(XITE_INC_DEST)

# The following is recommended during software development with cc
#
CFLAGS_DEV_CC   = $(CFLAGS_ALWAYS) $(CDEBUG) $(CARCH_OPT) -I$(XITE_INC_DEST)
EOF_CFLAGS_PROD

if test "$XITE_HOSTTYPE" != "Win32"
then
echo "CFLAGS_MEX     = \$(CFLAGS_ALWAYS) -O -I\$(XITE_INC_DEST)"
else
echo "
CFLAGS_MEX     = -D_WIN32 -D\$(XITE_HOSTTYPE) -DSYSTEM_V -DSYSV \\
                  \$(DEBUG) -DDEF_STRCASECMP \$(DIRENT) \$(REGEX) \\
                  -O -I\$(XITE_INC_DEST)"
fi


#############################################################################
#
# GNU_WARN, CFLAGS_PROD_GCC, CFLAGS_DEV_GCC
#
#############################################################################

cat <<\EOF_GNU_WARN

GNU_WARN        = -Wall -Wmissing-prototypes -Wstrict-prototypes \
                  -Wnested-externs -Wpointer-arith
EOF_GNU_WARN

if test "$XITE_HOSTTYPE" = "AIX" -o "$XITE_HOSTTYPE" = "IRIX" -o \
  "$XITE_HOSTTYPE" = "IRIX64"
then

	echo "GCC_ARCH_OPT    = -fsigned-char"

else

	echo "GCC_ARCH_OPT    ="

fi

cat <<\EOF_GNU

# The following is recommended for the final production version with gcc
#
CFLAGS_PROD_GCC = $(CFLAGS_ALWAYS) $(GCC_ARCH_OPT) $(OPTIM_GNU) \
                  -I$(XITE_INC_DEST)

# The following is recommended during software development with gcc
#
CFLAGS_DEV_GCC  = $(CFLAGS_ALWAYS) $(GCC_ARCH_OPT) -g $(GNU_WARN) \
                  -I$(XITE_INC_DEST)

EOF_GNU


#############################################################################
#
# CFLAGS
#
#############################################################################

cat <<\EOF_CFLAGS

CFLAGS          = $(CFLAGS_PROD_CC)
DSO_FLAGS       = $(CC_DSO_FLAGS)

EOF_CFLAGS

#############################################################################
#
# LFLAGS, XLIB
#
#############################################################################

echo "# 10) Set LFLAGS
#"

if [ -n "$RPATH_OPT" ]; then
	echo "XITE_LIB_RPATH  = \$(RPATH_OPT) \$(XITE_LIB_DEST)"
else
	echo "XITE_LIB_RPATH  = "
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "LFLAGS_XITE     = -L\$(XITE_LIB_DEST) \$(XITE_LIB_RPATH)"
else
	echo "LFLAGS_XITE     = /LIBPATH:\$(XITE_LIB_DEST)"
fi

if test "$XITE_HOSTTYPE" = "OSF1"
then

	cat <<\EOF_LFLAGS

LFLAGS          = $(LFLAGS_XITE)
XITE_LIB_RPATH  = $(RPATH_OPT) $(XITE_LIB_DEST)
LFLAGS_MEX      = -L$(XITE_LIB_DEST) LDFLAGS='$$LDFLAGS $(XITE_LIB_RPATH)'

CC_LD           = $(CC) -shared
# If archive libraries: -all
CC_DSO_NAME_FLAGS = -soname
CC_LD_FLAGS     = $(LIB_MATH)

# 11) Set extra libraries
#
XLIB            = -ldnet_stub -lots
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "SunOS5"
then

	cat <<\EOF_LFLAGS
ucblib_RPATH = $(RPATH_OPT) /usr/ucblib
LFLAGS          = -L/usr/ucblib $(ucblib_RPATH) $(LFLAGS_XITE)
LFLAGS_MEX      = -L/usr/ucblib -L$(XITE_LIB_DEST) LDFLAGS='$$LDFLAGS $(ucblib_RPATH) \
                  $(XITE_LIB_RPATH)'

CC_LD           = $(CC) -G -i -z defs
# "-z text" to give fatal error if parts of code is not shareable
#   (causing patching at runtime)
CC_DSO_NAME_FLAGS = -h
CC_LD_FLAGS     = -lc $(LIB_MATH)

# 11) Set extra libraries
#
XLIB            = -lucb
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "SunOS"
then

	cat <<\EOF_LFLAGS
LFLAGS          = $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST)

CC_LD           = ld
# "-z text" to give fatal error if parts of code is not shareable
#   (causing patching at runtime)
CC_DSO_NAME_FLAGS =
CC_LD_FLAGS     = 

# 11) Set extra libraries
#
XLIB            =
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "IRIX" -o "$XITE_HOSTTYPE" = "IRIX64"
then

	cat <<\EOF_LFLAGS
LFLAGS          = $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST) \
                  LDFLAGS='$$LDFLAGS $(XITE_LIB_RPATH)'

CC_LD           = $(CC) -shared
# If archive libraries: -all
CC_DSO_NAME_FLAGS = -soname
CC_LD_FLAGS     =

# 11) Set extra libraries
#
XLIB            = 
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "AIX"
then

	cat <<\EOF_LFLAGS
LFLAGS          = $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST)

CC_LD           = ld -G
# If archive libraries: -bexpall
CC_DSO_NAME_FLAGS = 
CC_LD_FLAGS     =

# 11) Set extra libraries
#
XLIB            = 
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "Linux" -o "$XITE_HOSTTYPE" = "Linux_x86_64"
then

	cat <<\EOF_LFLAGS
LFLAGS          = $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST) \
                  LDFLAGS='$$LDFLAGS $(XITE_LIB_RPATH)'

CC_LD           = $(CC) -shared
# If archive libraries: --whole-archive
CC_DSO_NAME_FLAGS = -Xlinker -soname -Xlinker
CC_LD_FLAGS     =

# 11) Set extra libraries
#
XLIB            = 
EOF_LFLAGS

elif test "$XITE_HOSTTYPE" = "Win32"
then

	cat <<\EOF_LFLAGS
LFLAGS          = /link $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST)

CC_LD           = $(CC) /nologo /LD
CC_DSO_NAME_FLAGS = /Fe
CC_LD_FLAGS     =

# 11) Set extra libraries
#
XLIB            = 
EOF_LFLAGS

else

	cat <<\EOF_LFLAGS
LFLAGS          = $(LFLAGS_XITE)
LFLAGS_MEX      = -L$(XITE_LIB_DEST)

CC_LD           =
CC_DSO_NAME_FLAGS =
CC_LD_FLAGS     =

# 11) Set extra libraries
#
XLIB            = 
EOF_LFLAGS

fi

echo "
GNU_LD          = gcc -shared
GNU_DSO_NAME_FLAGS = -Xlinker -soname -Xlinker
GNU_LD_FLAGS    = 
"

cat <<\EOF_LD
LD              = $(CC_LD)
DSO_NAME_FLAGS  = $(CC_DSO_NAME_FLAGS)
LD_FLAGS        = $(CC_LD_FLAGS)
EOF_LD

#############################################################################
#
# MATLAB, MATLAB_INC, MATLAB_LIB, MATLAB_MEX_DEST
#
#############################################################################

echo "MATLAB_HOSTTYPE   = "

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "MATLAB_HOME     = ${DIR_SEP}local${DIR_SEP}matlab"
else
echo "MATLAB_HOME     = C:${DIR_SEP}matlab"
fi
echo "
# 12) Set MATLAB_INC
MATLAB_INC      = \$(MATLAB_HOME)${DIR_SEP}extern${DIR_SEP}include

# 13) Set MATLAB libraries
#
MATLAB_LIB = \$(MATLAB_HOME)${DIR_SEP}extern${DIR_SEP}lib${DIR_SEP}\$(MATLAB_HOSTTYPE)
MATLAB_LIB_BIN  = \$(MATLAB_HOME)${DIR_SEP}bin${DIR_SEP}\$(MATLAB_HOSTTYPE)
MATLAB_LIB_BIN_RPATH = \$(RPATH_OPT) \$(MATLAB_LIB_BIN)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "MATLAB_LIB_SYS  = \$(MATLAB_HOME)${DIR_SEP}sys${DIR_SEP}os${DIR_SEP}\$(MATLAB_HOSTTYPE)
MATLAB_LIB_SYS_RPATH = \$(RPATH_OPT) \$(MATLAB_LIB_SYS)"

	if [ -n "$RPATH_OPT" ]; then
		echo "LFLAGS_MATLAB   = -L\$(MATLAB_LIB_BIN) \$(MATLAB_LIB_BIN_RPATH) -L\$(MATLAB_LIB_SYS) \$(MATLAB_LIB_SYS_RPATH)"
	else
		echo "LFLAGS_MATLAB   = -L\$(MATLAB_LIB_BIN) -L\$(MATLAB_LIB_SYS)"
	fi
	if [ "$XITE_HOSTTYPE" = "SunOS5" ]; then
		echo "LIB_MATLAB      = -lmat -lmx -lmex -lut"
	else
		echo "LIB_MATLAB      = -lmat -lmx -lmex"
	fi
else
	echo "LFLAGS_MATLAB   = /LIBPATH:\$(MATLAB_LIB)"
	echo "LIB_MATLAB      = libmat.lib libmx.lib libmex.lib"
fi #Win32

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_MATLAB_LIB   = lib\$(XITE)_matlab${LIB_EXT}
XITE_MATLAB_MAJ   = .3
XITE_MATLAB_MIN   = .4"
else
echo "XITE_MATLAB_LIB   = lib\$(XITE)_matlab_static${LIB_EXT}
XITE_MATLAB_MAJ   = 
XITE_MATLAB_MIN   = "
fi
echo "XITE_MATLAB_DSO   = lib\$(XITE)_matlab${DSO_EXT}
XITE_MATLAB_DSO_V = \$(XITE_MATLAB_DSO)\$(XITE_MATLAB_MAJ)\$(XITE_MATLAB_MIN)
"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_MEX_LIB   = lib\$(XITE)_mex${LIB_EXT}
XITE_MEX_MAJ   = .3
XITE_MEX_MIN   = .4"
else
echo "XITE_MEX_LIB   = lib\$(XITE)_mex_static${LIB_EXT}
XITE_MEX_MAJ   = 
XITE_MEX_MIN   = "
fi
echo "XITE_MEX_DSO   = lib\$(XITE)_mex${DSO_EXT}
XITE_MEX_DSO_V = \$(XITE_MEX_DSO)\$(XITE_MEX_MAJ)\$(XITE_MEX_MIN)
"

if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "LIB_XITE_MATLAB     = \$(XITE_MATLAB_LIB)"
	echo "LIB_XITE_MATLAB_IMP = lib\$(XITE)_matlab${LIB_EXT}"
	echo "LIB_XITE_MATLAB_IMP_MEX = -l\$(XITE)_matlab"

	echo "LIB_XITE_MEX     = \$(XITE_MEX_LIB)"
	echo "LIB_XITE_MEX_IMP = lib\$(XITE)_mex${LIB_EXT}"
	echo "LIB_XITE_MEX_IMP_MEX = -l\$(XITE)_mex"
else
	echo "LIB_XITE_MATLAB     = -l\$(XITE)_matlab"
	echo "LIB_XITE_MATLAB_IMP = \$(LIB_XITE_MATLAB)"
	echo "LIB_XITE_MATLAB_IMP_MEX = \$(LIB_XITE_MATLAB_IMP)"

	echo "LIB_XITE_MEX     = -l\$(XITE)_mex"
	echo "LIB_XITE_MEX_IMP = \$(LIB_XITE_MEX)"
	echo "LIB_XITE_MEX_IMP_MEX = \$(LIB_XITE_MEX_IMP)"
fi

echo "
# 14) Set MATLAB_MEX_DEST
#
MATLAB_MEX_DEST   = \$(MATLAB_HOME)${DIR_SEP}toolbox${DIR_SEP}xite"

#############################################################################
#
# TIFF_INC_DIR, TIFF_LIB_DIR
#
#############################################################################

echo "
# 15) Set TIFF_INC_DIR
#"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "TIFF_INC_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}include"
else
	echo "TIFF_INC_DIR    = C:${DIR_SEP}tiff${DIR_SEP}include"
fi

echo "
# 16) Set TIFF_LIB_DIR
#"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "TIFF_LIB_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}lib"
	if [ -n "$RPATH_OPT" ]; then
	    echo "TIFF_LIB_RPATH = \$(RPATH_OPT) \$(TIFF_LIB_DIR)"
		echo "LFLAGS_TIFF     = -L\$(TIFF_LIB_DIR) \$(TIFF_LIB_RPATH)"
	else
		echo "LFLAGS_TIFF     = -L\$(TIFF_LIB_DIR)"
	fi
else
	echo "TIFF_LIB_DIR    = C:${DIR_SEP}tiff${DIR_SEP}lib"
	echo "LFLAGS_TIFF     = /LIBPATH:\$(TIFF_LIB_DIR) /NODEFAULTLIB:LIBCMT.lib /NODEFAULTLIB:LIBC.lib"
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_TIFF_LIB    = lib\$(XITE)_tiff${LIB_EXT}
XITE_TIFF_MAJ    = .3
XITE_TIFF_MIN    = .4"
else
echo "XITE_TIFF_LIB    = lib\$(XITE)_tiff_static${LIB_EXT}
XITE_TIFF_MAJ    = 
XITE_TIFF_MIN    = "
fi
echo "XITE_TIFF_DSO    = lib\$(XITE)_tiff${DSO_EXT}
XITE_TIFF_DSO_V  = \$(XITE_TIFF_DSO)\$(XITE_TIFF_MAJ)\$(XITE_TIFF_MIN)
"

if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "LIB_XITE_TIFF     = \$(XITE_TIFF_LIB)"
	echo "LIB_XITE_TIFF_IMP = lib\$(XITE)_tiff${LIB_EXT}"
else
	echo "LIB_XITE_TIFF     = -l\$(XITE)_tiff"
	echo "LIB_XITE_TIFF_IMP = \$(LIB_XITE_TIFF)"
fi


#############################################################################
#
# PNG_INC_DIR, PNG_LIB_DIR
#
#############################################################################

echo "
# 17) Set PNG_INC_DIR
#"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "PNG_INC_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}include"
else
	echo "PNG_INC_DIR    = C:${DIR_SEP}PNG${DIR_SEP}include"
fi

echo "
# 18) Set PNG_LIB_DIR
#"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "PNG_LIB_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}lib"
	if [ -n "$RPATH_OPT" ]; then
	    echo "PNG_LIB_RPATH   = \$(RPATH_OPT) \$(PNG_LIB_DIR)"
		echo "LFLAGS_PNG     = -L\$(PNG_LIB_DIR) \$(PNG_LIB_RPATH)"
	else
		echo "LFLAGS_PNG     = -L\$(PNG_LIB_DIR)"
	fi
else
	echo "PNG_LIB_DIR    = C:${DIR_SEP}PNG${DIR_SEP}lib"
	echo "LFLAGS_PNG     = /LIBPATH:\$(PNG_LIB_DIR)"
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_PNG_LIB    = lib\$(XITE)_png${LIB_EXT}
XITE_PNG_MAJ    = .3
XITE_PNG_MIN    = .4"
else
echo "XITE_PNG_LIB    = lib\$(XITE)_png_static${LIB_EXT}
XITE_PNG_MAJ    = 
XITE_PNG_MIN    = "
fi
echo "XITE_PNG_DSO    = lib\$(XITE)_png${DSO_EXT}
XITE_PNG_DSO_V  = \$(XITE_PNG_DSO)\$(XITE_PNG_MAJ)\$(XITE_PNG_MIN)
"
 
if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "LIB_XITE_PNG     = \$(XITE_PNG_LIB)"
	echo "LIB_XITE_PNG_IMP = lib\$(XITE)_png${LIB_EXT}"
else
	echo "LIB_XITE_PNG     = -l\$(XITE)_png"
	echo "LIB_XITE_PNG_IMP = \$(LIB_XITE_PNG)"
fi

#############################################################################
#
# PNM_INC_DIR, PNM_LIB_DIR
#
#############################################################################

echo "
# 19) Set PNM_INC_DIR
#"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "PNM_INC_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}include"
else
	echo "PNM_INC_DIR    = C:${DIR_SEP}PNM${DIR_SEP}include"
fi

echo "
# 20) Set PNM_LIB_DIR
#"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "PNM_LIB_DIR    = ${DIR_SEP}usr${DIR_SEP}local${DIR_SEP}lib"
	if [ -n "$RPATH_OPT" ]; then
	    echo "PNM_LIB_RPATH = \$(RPATH_OPT) \$(PNM_LIB_DIR)"
		echo "LFLAGS_PNM     = -L\$(PNM_LIB_DIR) \$(PNM_LIB_RPATH)"
	else
		echo "LFLAGS_PNM     = -L\$(PNM_LIB_DIR)"
	fi
else
	echo "PNM_LIB_DIR    = C:${DIR_SEP}PNM${DIR_SEP}lib"
	echo "LFLAGS_PNM     = /LIBPATH:\$(PNM_LIB_DIR)"
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "XITE_PNM_LIB    = lib\$(XITE)_pnm${LIB_EXT}
XITE_PNM_MAJ    = .3
XITE_PNM_MIN    = .4"
else
echo "XITE_PNM_LIB    = lib\$(XITE)_pnm_static${LIB_EXT}
XITE_PNM_MAJ    = 
XITE_PNM_MIN    = "
fi
echo "XITE_PNM_DSO    = lib\$(XITE)_pnm${DSO_EXT}
XITE_PNM_DSO_V  = \$(XITE_PNM_DSO)\$(XITE_PNM_MAJ)\$(XITE_PNM_MIN)
"
 
if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "LIB_XITE_PNM     = \$(XITE_PNM_LIB)"
	echo "LIB_XITE_PNM_IMP = lib\$(XITE)_pnm${LIB_EXT}"
else
	echo "LIB_XITE_PNM     = -l\$(XITE)_pnm"
	echo "LIB_XITE_PNM_IMP = \$(LIB_XITE_PNM)"
fi

#############################################################################
#
# FWF_INC_DIR, FWF_LIB_DIR
#
#############################################################################

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "
# 19) Set FWF_INC_DIR
#
FWF_INC_DIR     = \$(XITE_INC_DEST)

# 20) Set FWF_LIB_DIR
#
FWF             = fwf
FWF_LIB_DIR     = \$(XITE_LIB_DEST)
FWF_LIB         = lib\$(FWF)${LIB_EXT}
FWF_MAJ         = .3
FWF_MIN         = .4
FWF_DSO         = lib\$(FWF)${DSO_EXT}
FWF_DSO_V       = \$(FWF_DSO)\$(FWF_MAJ)\$(FWF_MIN)
LIB_FWF         = -l\$(FWF)
LIB_FWF_IMP     = \$(LIB_FWF)
"

#############################################################################
#
# XPM_INC_DIR, XPM_LIB_DIR
#
#############################################################################

	echo "
# 21) Set XPM_INC_DIR
#
XPM_INC_DIR     = \$(XITE_INC_DEST)

# 22) Set XPM_LIB_DIR
#
XPM             = xpm
XPM_LIB_DIR     = \$(XITE_LIB_DEST)
XPM_LIB         = lib\$(XPM)${LIB_EXT}
XPM_MAJ         = .3
XPM_MIN         = .4
XPM_DSO         = lib\$(XPM)${DSO_EXT}
XPM_DSO_V       = \$(XPM_DSO)\$(XPM_MAJ)\$(XPM_MIN)
LIB_XPM         = -l\$(XPM)
LIB_XPM_IMP     = \$(LIB_XPM)
XPM_LIB_RPATH   = \$(RPATH_OPT) \$(XPM_LIB_DIR)
"

if [ -n "$RPATH_OPT" ]; then
	echo "LFLAGS_XPM      = -L\$(XPM_LIB_DIR) \$(XPM_LIB_RPATH)"
else
	echo "LFLAGS_XPM      = -L\$(XPM_LIB_DIR)"
fi


fi #!Win32

#############################################################################
#
# AR, RANLIB, SRC, WLIB
#
#############################################################################

cat <<\EOF_AR

######################################################################
#
# There should be no need to make changes below this point
#
######################################################################

EOF_AR


if test "$XITE_HOSTTYPE" = "Win32"
then
	echo "AR              = lib /nologo"
	echo "AR_A_OPT        = "
	echo "AR_X_OPT        = /extract:"
	echo "AR_T_OPT        = /list"
else
	echo "AR              = ar"
	echo "AR_A_OPT        = r"
	if [ "$XITE_HOSTTYPE" != SunOS ]; then
		echo "AR_X_OPT        = -x"
		echo "AR_T_OPT        = -t"
	else
		echo "AR_X_OPT        = x"
		echo "AR_T_OPT        = t"
	fi
fi

if test "$XITE_HOSTTYPE" = "SunOS" -o \
	"$XITE_HOSTTYPE" = "ULTRIX" -o \
	"$XITE_HOSTTYPE" = "CYGWIN32" -o \
	"$XITE_HOSTTYPE" = "Other"
then

	cat <<\EOF_RANLIB
RANLIB          = ranlib
SRC             = .
EOF_RANLIB

elif test "$XITE_HOSTTYPE" = "Win32"
then
	echo "RANLIB          ="
else

	cat <<\EOF_RANLIB
RANLIB          = echo
SRC             = .
EOF_RANLIB

fi

if test "$XITE_HOSTTYPE" = "AIX"
then

	echo "WLIB            = -lXaw -lXmu -lXt -lXext -lX11 -liconv"

elif test "$XITE_HOSTTYPE" = "SunOS5"
then

	echo "WLIB            = -lXaw -lXmu -lXt -lXext -lX11"

elif test "$XITE_HOSTTYPE" != "Win32"
then

        echo "XPM_DEP_LIB     = -lX11"
	echo "XITEX_DEP_LIB   = -lXaw -lXmu -lXt -lX11"
	echo "PNG_DEP_LIB     = "
	echo "PNM_DEP_LIB     = "
	echo "FWF_DEP_LIB     = -lXaw -lXmu -lXt -lX11"
	echo "WLIB            = -lXaw -lXmu -lXt -lXext -lX11"
fi

#############################################################################
#
# COMPILE, LINK, XLINK, DOC
#
#############################################################################

echo "

# For plain XITE C source
#
COMPILE_c       = \$(CC) \$(CFLAGS) -c
COMPILE_c_dso   = \$(COMPILE_c) \$(DSO_FLAGS) -DXITE_DLL
LINK_c          = \$(CC) \$(CFLAGS) -DMAIN \$(@).c \\
                  \$(LFLAGS) \$(LIB_XITE) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}
LINK_c_dso      = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN \$(@).c \\
                  \$(LFLAGS) \$(LIB_XITE_IMP) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}
"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "
# C source with X11
#
COMPILE_x       = \$(COMPILE_c) -I\$(X_INC_DIR)
COMPILE_x_dso   = \$(COMPILE_x) \$(DSO_FLAGS)

# ... link with libraries
#
LINK_x          = \$(CC) \$(CFLAGS) -I\$(X_INC_DIR) -DMAIN \$(@).c \\
                  \$(LFLAGS) \$(LFLAGS_X) \$(LIB_XITE_X) \$(LIB_XITE) \\
                  \$(LIB_FWF) \\
                  \$(LFLAGS_XPM) \$(LIB_XPM) \$(WLIB) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin
LINK_x_dso      = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(X_INC_DIR) \\
                  \$(@).c \$(LFLAGS) \$(LFLAGS_X) \$(LIB_XITE_X_IMP) \\
                  \$(LIB_XITE_IMP) \$(LIB_FWF_IMP) \\
                  \$(LFLAGS_XPM) \$(LIB_XPM_IMP) \$(WLIB) \$(XLIB) \\
                  \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin

# ... link with libraries and object file dependencies
#
LINK_x_obj      = \$(CC) \$(CFLAGS) -I\$(X_INC_DIR) -DMAIN \$(@).c \$(?) \\
                  \$(LFLAGS) \$(LFLAGS_X) \$(LIB_XITE_X) \$(LIB_XITE) \\
                  \$(LIB_FWF) \\
                  \$(LFLAGS_XPM) \$(LIB_XPM) \$(WLIB) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin
LINK_x_obj_dso  = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(X_INC_DIR) \\
                  \$(@).c \$(?) \\
                  \$(LFLAGS) \$(LFLAGS_X) \$(LIB_XITE_X_IMP) \\
                  \$(LIB_XITE_IMP) \$(LIB_FWF_IMP) \$(LFLAGS_XPM) \\
                  \$(LIB_XPM_IMP) \$(WLIB) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin
"

fi

echo "
# C source with libtiff
#
COMPILE_t       = \$(COMPILE_c) -I\$(TIFF_INC_DIR)
COMPILE_t_dso   = \$(COMPILE_t) \$(DSO_FLAGS) -DXITE_TIFF_DLL
LINK_t          = \$(CC) \$(CFLAGS) -DMAIN -I\$(TIFF_INC_DIR) \$(@).c \\
                  \$(LFLAGS) \$(LFLAGS_TIFF) \$(LIB_XITE_TIFF) \$(LIB_TIFF) \\
                  \$(LIB_XITE) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}
LINK_t_dso      = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(TIFF_INC_DIR) \\
                  \$(@).c \$(LFLAGS) \$(LFLAGS_TIFF) \$(LIB_XITE_TIFF_IMP) \\
                  \$(LIB_TIFF) \$(LIB_XITE_IMP) \$(XLIB) \\
                  \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}

# C source with png
#
COMPILE_png     = \$(COMPILE_c) -I\$(PNG_INC_DIR)
COMPILE_png_dso = \$(COMPILE_png) \$(DSO_FLAGS) -DXITE_PNG_DLL
LINK_png        = \$(CC) \$(CFLAGS) -DMAIN -I\$(PNG_INC_DIR) \$(@).c \\
                  \$(LFLAGS) \$(LFLAGS_PNG) \$(LIB_XITE_PNG) \$(LIB_PNG) \\
                  \$(LIB_XITE) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}
LINK_png_dso    = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(PNG_INC_DIR) \\
                  \$(@).c \$(LFLAGS) \$(LFLAGS_PNG) \$(LIB_XITE_PNG_IMP) \\
                  \$(LIB_PNG) \$(LIB_XITE_IMP) \$(XLIB) \\
                  \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}

# C source with pnm
#
COMPILE_p       = \$(COMPILE_c) -I\$(PNM_INC_DIR)
COMPILE_p_dso   = \$(COMPILE_p) \$(DSO_FLAGS) -DXITE_PNM_DLL
LINK_p          = \$(CC) \$(CFLAGS) -DMAIN -I\$(PNM_INC_DIR) \$(@).c \\
                  \$(LFLAGS) \$(LFLAGS_PNM) \$(LIB_XITE_PNM) \$(LIB_PNM) \\
                  \$(LIB_XITE) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}
LINK_p_dso      = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(PNM_INC_DIR) \\
                  \$(@).c \$(LFLAGS) \$(LFLAGS_PNM) \$(LIB_XITE_PNM_IMP) \\
                  \$(LIB_PNM) \$(LIB_XITE_IMP) \$(XLIB) \\
                  \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@)${EXE_EXT}

# C source with MATLAB
#
COMPILE_m       = \$(COMPILE_c) -I\$(MATLAB_INC) -DTMW_ENABLE_INT64
COMPILE_m_dso   = \$(COMPILE_m) \$(DSO_FLAGS) -DXITE_MATLAB_DLL
LINK_m          = \$(CC) \$(CFLAGS) -DMAIN -I\$(MATLAB_INC) \$(@).c \\
                  \$(LFLAGS) \$(LFLAGS_MATLAB) \$(LIB_XITE_MATLAB) \\
                  \$(LIB_MATLAB) \$(LIB_XITE) \$(XLIB) \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin
LINK_m_dso      = \$(CC) \$(CFLAGS) \$(DSO_FLAGS) -DMAIN -I\$(MATLAB_INC) \\
                  \$(@).c \$(LFLAGS) \$(LFLAGS_MATLAB) \$(LIB_XITE_MATLAB_IMP) \\
                  \$(LIB_MATLAB) \$(LIB_XITE_IMP) \$(XLIB) \\
                  \$(LIB_MATH) \\
                  ${OUT_OPT}\$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin
"
if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "
MEX             = \$(MATLAB_HOME)${DIR_SEP}bin${DIR_SEP}mex CC=\$(CC) \$(CFLAGS_MEX) \$(@).c \\
                  \$(LFLAGS_MEX) \$(LIB_XITE_IMP_MEX) \$(LIB_XITE_MATLAB_IMP_MEX) \\
                  -output \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(@)
MEX_C           = \$(MATLAB_HOME)${DIR_SEP}bin${DIR_SEP}mex CC=\$(CC) -c \$(CFLAGS_MEX)"
echo "MEX_XITE        = \$(MEX) \$(LIB_XITE_MEX_IMP_MEX)
"

else
echo "
MEX             = \$(MATLAB_HOME)${DIR_SEP}bin${DIR_SEP}mex \$(CFLAGS_MEX) \$(@).c \\
                  \$(LFLAGS_MEX) \$(LIB_XITE_IMP_MEX) \$(LIB_XITE_MATLAB_IMP_MEX) \\
                  -output \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(@)
MEX_C           = \$(MATLAB_HOME)${DIR_SEP}bin${DIR_SEP}mex -c \$(CFLAGS_MEX)"
echo "MEX_XITE        = \$(MEX) \$(LIB_XITE_MEX_IMP_MEX) -f \$(XITE_HOME)${DIR_SEP}src${DIR_SEP}matlab${DIR_SEP}mexopts.bat
"

fi


if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "
# C source with X11, fwf and xpm
#
COMPILE_f       = \$(COMPILE_x) -I\$(FWF_INC_DIR) -I\$(XPM_INC_DIR)
COMPILE_f_dso   = \$(COMPILE_f) \$(DSO_FLAGS)
"

fi

#echo "
# Documentation for C
#
#MANDOC          = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -t
#HTMLDOC         = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -h

# Make MATLAB .m-file for MATLAB help
#
#MFILE           = '/usr/bin/perl -ne "if \(/%\$\(@:.m=\) /../\*\//\) {next if length == 3; print;}"'

# Initialize directory-specific variables to avoid errors from make.
#
#"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
echo "
# Documentation for C
#
MANDOC          = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -t
HTMLDOC         = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -h

# Make MATLAB .m-file for MATLAB help
#
MFILE           = /usr/bin/perl -ne 'if (/%\$(@:.m=) /../\*\//) {next if length == 3; print;}'
"
else #!Win32
echo "
# Documentation for C
#
MANDOC          = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -t
HTMLDOC         = \$(XITE_BIN_DEST)${DIR_SEP}cdoc -h

# Make MATLAB .m-file for MATLAB help
#
MFILE           = /usr/bin/perl -ne \"if (/%%\$(@:.m=) /../\*\//) {next if length == 3; print;}\"
"
fi #Win32

# Initialize directory-specific variables to avoid errors from make.
#

cat <<\EOF_INITVAR
OBJ       = "_OBJ_"
PROG      = "_PROG_"
MANP      = "_MANP_"
MANP_SH   = "_MANP_SH_"
ROFF3     = "_ROFF3_"
CINCL     = "_CINCL_"
SCRIPTS   = "_SCRIPTS_"
XOBJ      = "_XOBJ_"
XPROG     = "_XPROG_"
TIFFOBJ   = "_TIFFOBJ_"
TIFFPROG  = "_TIFFPROG_"
PNGOBJ    = "_PNGOBJ_"
PNGPROG   = "_PNGPROG_"
PNMOBJ    = "_PNMOBJ_"
PNMPROG   = "_PNMPROG_"
MATOBJ    = "_MATOBJ_"
MEXOBJ    = "_MEXOBJ_"
MATPROG   = "_MATPROG_"
MATMEX    = "_MATMEX_"
XITEMEX   = "_XITEMEX_"
MATHELP   = "_MATHELP_"
MEXHELP   = "_MAXHELP_"
FWFOBJ    = "_FWFOBJ_"
FWFPROG   = "_FWFPROG_"
FWFINCL   = "_FWFINCL_"
XPMOBJ    = "_XPMOBJ_"
XPMPROG   = "_XPMPROG_"
XPMINCL   = "_XPMINCL_"

all:	     include lib dso program doc

# Get directory-specific variables and define the targets object, lib and
# program
#
EOF_INITVAR

if test "$XITE_HOSTTYPE" != "Win32"
then
	echo "include Makefile.defs"
else
	echo "!include Makefile.defs"
fi

#############################################################################
#
# Target rules
#
#############################################################################

echo "
# Overall rules
#
#include:     cincl fwfincl xpmincl
#object:      cobj xobj tiffobj pngobj pnmobj matobj mexobj
#lib:	      clib xlib tifflib pnglib pnmlib matlib mexlib
#program:     cprog xprog scripts tiffprog pngprog pnmprog matprog
#doc:         manpage roff3 mathelp mexhelp
#dso:         xite_dso xpm_dso fwf_dso xiteX_dso xite_tiff_dso xite_png_dso xite_pnm_dso xite_matlab_dso xite_mex_dso
"

if [ "$XITE_HOSTTYPE" = "ULTRIX" -o "$XITE_HOSTTYPE" = "SunOS" -o \
	"$XITE_HOSTTYPE" = "AIX" ]; then

    echo "xite_dso:
	@echo \"Can not (or don't know how to) build dynamic shared objects on this platform.\"

xpm_dso:         xite_dso
fwf_dso:         xite_dso
xiteX_dso:       xite_dso
xite_tiff_dso:   xite_dso
xite_png_dso:    xite_dso
xite_pnm_dso:    xite_dso
xite_matlab_dso: xite_dso
xite_mex_dso:    xite_dso
"

else

    if [ "$XITE_HOSTTYPE" = "SunOS5" -o \
	 "$XITE_HOSTTYPE" = "SunOS"  -o \
	 "$XITE_HOSTTYPE" = "IRIX64" -o \
	 "$XITE_HOSTTYPE" = "IRIX"   -o \
	 "$XITE_HOSTTYPE" = "OSF1"   -o \
	 "$XITE_HOSTTYPE" = "Linux"  -o \
	 "$XITE_HOSTTYPE" = "Linux_x86_64" ]; then

	dso_target xite_dso "\$(XITE_DSO)" "\$(XITE_LIB_DEST)" \
                            "\$(XITE_DSO_V)" \
			    "\$(XITE_LIB)" "\$(XITE_LIB_DEST)" \
			    "\$(LFLAGS_XITE) \$(LIB_MATH)"

    else

	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	    dso_target xite_dso "\$(XITE_DSO)" "\$(XITE_LIB_DEST)" \
				"\$(XITE_DSO_V)" \
				"\$(XITE_LIB)" "\$(XITE_LIB_DEST)" \
				"\$(LIB_MATH)"
	else
	    dso_target xite_dso "\$(XITE_DSO)" "\$(XITE_BIN_DEST)" \
				"\$(XITE_DSO_V)" \
				"\$(XITE_LIB)" "\$(XITE_LIB_DEST)" \
				"\$(LD_FLAGS)"
	fi
    fi

    if [ "$XITE_HOSTTYPE" != "Win32" ]; then

	if [ "$XITE_HOSTTYPE" = "SunOS5" -o \
	     "$XITE_HOSTTYPE" = "SunOS"  -o \
	     "$XITE_HOSTTYPE" = "IRIX"   -o \
	     "$XITE_HOSTTYPE" = "IRIX64" -o \
	     "$XITE_HOSTTYPE" = "OSF1"   -o \
	     "$XITE_HOSTTYPE" = "Linux"  -o \
	     "$XITE_HOSTTYPE" = "Linux_x86_64" ];
	then
	    dso_target xiteX_dso "\$(XITE_X_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(XITE_X_DSO_V)" \
				 "\$(XITE_LIB_X)" "\$(XITE_LIB_DEST)" \
				 "\$(LFLAGS) \$(LFLAGS_X) \$(LFLAGS_XPM) \$(LIB_FWF_IMP) \$(LIB_XPM_IMP) \$(XITEX_DEP_LIB) \$(LIB_XITE_IMP) \$(LIB_PTY) \$(LIB_MATH)"
	    dso_target fwf_dso   "\$(FWF_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(FWF_DSO_V)" \
				 "\$(FWF_LIB)" "\$(XITE_LIB_DEST)" \
				 "\$(LFLAGS) \$(LFLAGS_X) \$(LFLAGS_XPM) \$(LIB_XPM_IMP) \$(FWF_DEP_LIB) \$(LIB_XITE_IMP)"

	    dso_target xpm_dso   "\$(XPM_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(XPM_DSO_V)" \
				 "\$(XPM_LIB)" "\$(XITE_LIB_DEST)" \
				 "\$(LFLAGS) \$(LFLAGS_X) \$(XPM_DEP_LIB) \$(LIB_XITE_IMP)"

	else

	    dso_target xiteX_dso "\$(XITE_X_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(XITE_X_DSO_V)" \
				 "\$(XITE_LIB_X)" "\$(XITE_LIB_DEST)" \
				 "\$(XITEX_DEP_LIB) \$(LIB_MATH)"
	    dso_target fwf_dso   "\$(FWF_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(FWF_DSO_V)" \
				 "\$(FWF_LIB)" "\$(XITE_LIB_DEST)" \
				 "\$(FWF_DEP_LIB)"

	    dso_target xpm_dso   "\$(XPM_DSO)" "\$(XITE_LIB_DEST)" \
				 "\$(XPM_DSO_V)" \
				 "\$(XPM_LIB)" "\$(XITE_LIB_DEST)" \
				 "\$(XPM_DEP_LIB)"
	fi
    fi


    if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	dso_target xite_matlab_dso "\$(XITE_MATLAB_DSO)" "\$(XITE_LIB_DEST)" \
                             "\$(XITE_MATLAB_DSO_V)" \
                             "\$(XITE_MATLAB_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_MATLAB) \$(LIB_MATLAB) \$(LIB_MATH)"

	dso_target xite_mex_dso "\$(XITE_MEX_DSO)" "\$(XITE_LIB_DEST)" \
                             "\$(XITE_MEX_DSO_V)" \
                             "\$(XITE_MEX_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_MATLAB) \$(LIB_MATLAB) \$(LIB_MATH)"

    else
	dso_target xite_matlab_dso "\$(XITE_MATLAB_DSO)" "\$(XITE_BIN_DEST)" \
                             "\$(XITE_MATLAB_DSO_V)" \
                             "\$(XITE_MATLAB_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_MATLAB) \$(LIB_MATLAB) \$(LIB_MATH)"

	dso_target xite_mex_dso "\$(XITE_MEX_DSO)" "\$(XITE_BIN_DEST)" \
                             "\$(XITE_MEX_DSO_V)" \
                             "\$(XITE_MEX_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_MATLAB) \$(LIB_MATLAB) \$(LIB_MATH)"

    fi

    if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	dso_target xite_tiff_dso "\$(XITE_TIFF_DSO)" "\$(XITE_LIB_DEST)" \
                             "\$(XITE_TIFF_DSO_V)" \
                             "\$(XITE_TIFF_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_TIFF) \$(LIB_TIFF) \$(LIB_MATH)"

    else
	dso_target xite_tiff_dso "\$(XITE_TIFF_DSO)" "\$(XITE_BIN_DEST)" \
                             "\$(XITE_TIFF_DSO_V)" \
                             "\$(XITE_TIFF_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_TIFF) \$(LIB_TIFF) \$(LIB_MATH)"

    fi

    if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	dso_target xite_png_dso "\$(XITE_PNG_DSO)" "\$(XITE_LIB_DEST)" \
                             "\$(XITE_PNG_DSO_V)" \
                             "\$(XITE_PNG_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_PNG) \$(LIB_PNG) \$(PNG_DEP_LIB) \$(LIB_MATH)"

    else
	dso_target xite_png_dso "\$(XITE_PNG_DSO)" "\$(XITE_BIN_DEST)" \
                             "\$(XITE_PNG_DSO_V)" \
                             "\$(XITE_PNG_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_PNG) \$(LIB_PNG) \$(PNG_DEP_LIB) \$(LIB_MATH)"

    fi

    if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	dso_target xite_pnm_dso "\$(XITE_PNM_DSO)" "\$(XITE_LIB_DEST)" \
                             "\$(XITE_PNM_DSO_V)" \
                             "\$(XITE_PNM_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_PNM) \$(LIB_PNM) \$(PNM_DEP_LIB)"

    else
	dso_target xite_pnm_dso "\$(XITE_PNM_DSO)" "\$(XITE_BIN_DEST)" \
                             "\$(XITE_PNM_DSO_V)" \
                             "\$(XITE_PNM_LIB)" "\$(XITE_LIB_DEST)" \
                             "\$(LFLAGS) \$(LIB_XITE_IMP) \$(LFLAGS_PNM) \$(LIB_PNM) \$(PNM_DEP_LIB)"

    fi
fi

echo "
manpage:     \$(MANP) \$(MANP_SH)
roff3:       \$(ROFF3)
scripts:     \$(SCRIPTS)
clean:  
	     @\$(RM_F) *.${OBJ_EXT} \$(PROG) \$(XPROG) \$(TIFFPROG) \$(PNGPROG) \$(PNMPROG) \$(MATPROG) \\
	          ${TO_DEV_NULL}

# Rules for plain XITE C source
#
c :          cincl clib cprog
cincl:       \$(CINCL)
cobj:        \$(OBJ)
cprog:       \$(PROG)
clib:	     \$(OBJ)"

if_test '"\$(?)"' '!=' '"_OBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB); \\"
end_if

echo "
\$(OBJ):      \$(@:.o=.c)
	     \$(COMPILE_c_dso) \$(@:.o=.c)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(PROG):     \$(@:=.c)"
else
	echo "\$(PROG):     \$(@).c"
fi
echo "	     \$(LINK_c_dso)"

unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

echo "
\$(CINCL):    \$(@:.i=.h)
#	     Install include files"

if_test '"\$(@:.i=.h)"' '!=' '"_CINCL_"'
	cmd_and_echo "\$(COPY) \$(@:.i=.h) \$(XITE_INC_DEST)${DIR_SEP}xite"
	unix_only "  \$(CHMOD) u+w \$(XITE_INC_DEST)${DIR_SEP}xite${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\"
	unix_only "  \$(CHMOD) a+r \$(XITE_INC_DEST)${DIR_SEP}xite${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\"
end_if

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "
# Rules for C source using X11
#
x :          xlib xprog
xobj:        \$(XOBJ)
#xprog:       \$(XPROG)
xlib:        \$(XOBJ)
	     -@if test \"\$(?)\" != \"_XOBJ_\"; then \\"
             ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB_X)" "\$(?)"
	     unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB_X) ${TO_DEV_NULL}; \\"
	     unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_LIB_X); \\"
	echo "	fi
\$(XOBJ):     \$(@:.o=.c)
	     \$(COMPILE_x_dso) \$(@:.o=.c)"

	if [ "$XITE_HOSTTYPE" != "Win32" ]; then
		echo "\$(XPROG):    \$(@:=.c)"
	else
		echo "\$(XPROG):    \$(@).c"
	fi

	echo "	     \$(LINK_x_dso)
	     -@\$(RM) \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}
	     -@\$(LINK) \$(XITE_BIN_DEST)${DIR_SEP}xiteProg \$(XITE_BIN_DEST)${DIR_SEP}\$(@) \\
	       ${TO_DEV_NULL}
	     -@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin \$(XITE_BIN_DEST)${DIR_SEP}\$(@) \\
	       ${TO_DEV_NULL}"
fi

echo "
# Rules for C source using TIFF
#
tiff:        tifflib tiffprog
tiffobj:     \$(TIFFOBJ)
tiffprog:    \$(TIFFPROG)
tifflib:     \$(TIFFOBJ)"

if_test '"\$(?)"' '!=' '"_TIFFOBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_TIFF_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_TIFF_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_TIFF_LIB); \\"
end_if

echo "
\$(TIFFOBJ):  \$(@:.o=.c)
	     \$(COMPILE_t_dso) \$(@:.o=.c)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(TIFFPROG): \$(@:=.c)"
else
	echo "\$(TIFFPROG): \$(@).c"
fi

echo "	     \$(LINK_t_dso)"

unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

echo "
# Rules for C source using png
#
png:         pnglib pngprog
pngobj:      \$(PNGOBJ)
pngprog:     \$(PNGPROG)
pnglib:      \$(PNGOBJ)"

if_test '"\$(?)"' '!=' '"_PNGOBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNG_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNG_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNG_LIB); \\"
end_if

echo "
\$(PNGOBJ):  \$(@:.o=.c)
	     \$(COMPILE_png_dso) \$(@:.o=.c)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(PNGPROG):  \$(@:=.c)"
else
	echo "\$(PNGPROG):  \$(@).c"
fi

echo "	     \$(LINK_png_dso)"

unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

echo "
# Rules for C source using pnm
#
pnm:         pnmlib pnmprog
pnmobj:      \$(PNMOBJ)
pnmprog:     \$(PNMPROG)
pnmlib:      \$(PNMOBJ)"

if_test '"\$(?)"' '!=' '"_PNMOBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNM_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNM_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_PNM_LIB); \\"
end_if

echo "
\$(PNMOBJ):  \$(@:.o=.c)
	     \$(COMPILE_p_dso) \$(@:.o=.c)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(PNMPROG):  \$(@:=.c)"
else
	echo "\$(PNMPROG):  \$(@).c"
fi

echo "	     \$(LINK_p_dso)"

unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

echo "

# Rules for C source using MATLAB
#
matlab:      matlib mexlib matprog matmex mathelp mexhelp
matobj:      \$(MATOBJ)
mexobj:      \$(MEXOBJ)
matprog:     \$(MATPROG)
mathelp:     \$(MATHELP)"
if_test '!' '-d' "\$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)" "	     mkdir \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)"

echo "
	     \$(COPY) \$(?) \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(?)"

unix_only "-@\$(CHMOD) a+r \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(?) ${TO_DEV_NULL}"

echo "
mexhelp:     \$(MEXHELP)
matmex:      \$(MATMEX)
xitemex:     \$(XITEMEX)
matlib:      \$(MATOBJ)"

if_test '"\$(?)"' '!=' '"_MATOBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MATLAB_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MATLAB_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MATLAB_LIB); \\"
end_if

echo "
mexlib:      \$(MEXOBJ)"

if_test '"\$(?)"' '!=' '"_MEXOBJ_"'
	ar_cmd "\$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MEX_LIB)" "\$(?${OBJ_LIB_EXT})"
	unix_only "  \$(CHMOD) a+r \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MEX_LIB) ${TO_DEV_NULL}; \\"
	unix_only "  \$(RANLIB) \$(XITE_LIB_DEST)${DIR_SEP}\$(XITE_MEX_LIB); \\"
end_if

echo "
\$(MATOBJ):   \$(@:.o=.c)
	     \$(COMPILE_m_dso) \$(@:.o=.c)"
echo "
\$(MEXOBJ):   \$(@:.o=.c)
	     \$(MEX_C) \$(@:.o=.c)"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(MATPROG):  \$(@:=.c)"
else
	echo "\$(MATPROG):  \$(@).c"
fi

echo "	     \$(LINK_m_dso)
	     -@\$(RM) \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}
	     -@\$(LINK) \$(XITE_BIN_DEST)${DIR_SEP}matlabXite \$(XITE_BIN_DEST)${DIR_SEP}\$(@) \\
	       ${TO_DEV_NULL}
	     -@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@).bin \$(XITE_BIN_DEST)${DIR_SEP}\$(@) \\
	       ${TO_DEV_NULL}"

echo "	     "

#unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(MATMEX):   \$(@:=.c)"
else
	echo "\$(MATMEX):   \$(@).c"
fi

echo "#	     Create MATLAB mex-files.
	     \$(MEX)"

unix_only "-@\$(CHMOD) a+r \$(MATLAB_MEX_DEST)${DIR_SEP}\$(@).mex* ${TO_DEV_NULL}"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(XITEMEX):   \$(@:=.c)"
else
	echo "\$(XITEMEX):   \$(@).c"
fi
if_test '!' '-d' "\$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)" "	mkdir \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)"

echo "#	     Create MATLAB mex-files.
	     \$(MEX_XITE)"

unix_only "-@\$(CHMOD) a+r \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(@).mex* ${TO_DEV_NULL}"

echo "\$(MEXHELP):  \$(@:.m=.c)"
if_test '!' '-d' "\$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)" "	mkdir \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)"

echo "#            Make MATLAB .m-file help, from comment in C source file.
	     \$(MFILE) \$(@:.m=.c) > \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(@)"

unix_only "-@\$(CHMOD) a+r \$(MATLAB_MEX_DEST)${DIR_SEP}\$(XITE_SUB)${DIR_SEP}\$(@) ${TO_DEV_NULL}"

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "
# Rules for C source using fwf
#
fwf:         fwflib fwfprog
fwfobj:      \$(FWFOBJ)
fwfprog:     \$(FWFPROG)
fwflib:      \$(FWFOBJ)
	     -@if test \"\$(?)\" != \"_FWFOBJ_\"; then \\"
	       ar_cmd "\$(FWF_LIB_DIR)${DIR_SEP}\$(FWF_LIB)" "\$(?:.f=.o)"
	       unix_only "\$(CHMOD) a+r \$(FWF_LIB_DIR)${DIR_SEP}\$(FWF_LIB) ${TO_DEV_NULL}; \\"
	       unix_only "\$(RANLIB) \$(FWF_LIB_DIR)${DIR_SEP}\$(FWF_LIB); \\"
	     echo "	fi
fwfincl:     \$(FWFINCL)
\$(FWFOBJ):   \$(@:.o=.c)
	     \$(COMPILE_f_dso) \$(@:.o=.c)
\$(FWFINCL): \$(@:.i=.h)
#            Install include files
	     -@if test \"\$(@:.i=.h)\" != \"_FWFINCL_\"; then \\
	       echo \"\$(COPY) \$(@:.i=.h) \$(FWF_INC_DIR)${DIR_SEP}Xfwf\"; \\
	       \$(COPY) \$(@:.i=.h) \$(FWF_INC_DIR)${DIR_SEP}Xfwf; \\
	       \$(CHMOD) u+w \$(FWF_INC_DIR)${DIR_SEP}Xfwf${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\
	       \$(CHMOD) a+r \$(FWF_INC_DIR)${DIR_SEP}Xfwf${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\
	     fi

# Rules for C source using xpm
#
xpm:         xpmlib xpmprog
xpmobj:      \$(XPMOBJ)
xpmprog:     \$(XPMPROG)
xpmlib:      \$(XPMOBJ)
	     -@if test \"\$(?)\" != \"_XPMOBJ_\"; then \\"
	       ar_cmd "\$(XPM_LIB_DIR)${DIR_SEP}\$(XPM_LIB)" "\$(?:.f=.o)"
	       unix_only "\$(CHMOD) a+r \$(XPM_LIB_DIR)${DIR_SEP}\$(XPM_LIB) ${TO_DEV_NULL}; \\"
	       unix_only "\$(RANLIB) \$(XPM_LIB_DIR)${DIR_SEP}\$(XPM_LIB); \\"
	     echo "	fi
xpmincl:     \$(XPMINCL)
\$(XPMOBJ):   \$(@:.o=.c)
	     \$(COMPILE_f_dso) \$(@:.o=.c)
\$(XPMINCL): \$(@:.i=.h)
#            Install include files
	     -@if test \"\$(@:.i=.h)\" != \"_XPMINCL_\"; then \\
	       echo \"\$(COPY) \$(@:.i=.h) \$(XPM_INC_DIR)${DIR_SEP}xpm\"; \\
	       \$(COPY) \$(@:.i=.h) \$(XPM_INC_DIR)${DIR_SEP}xpm; \\
	       \$(CHMOD) u+w \$(XPM_INC_DIR)${DIR_SEP}xpm${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\
	       \$(CHMOD) a+r \$(XPM_INC_DIR)${DIR_SEP}xpm${DIR_SEP}\$(@:.i=.h) ${TO_DEV_NULL}; \\
	     fi

\$(MANP):     \$(@:.m=.c)
#	     Make manual-page descriptions
	     -@if test \"\$(@)\" != \"_MANP_\"; then \\
	       echo \$(MANDOC) \\
	       \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.c) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' |\\
	       sed 's/=.*//' \` \$(@:.m=.c) \$(XITE_MAN_DEST)/ ; \\
	       \$(MANDOC) \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.c) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' |\\
	       sed 's/=.*//' \` \$(@:.m=.c) \$(XITE_MAN_DEST)/ ; \\
	       echo \$(HTMLDOC) \\
	       \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.c) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' | sed 's/=.*//' \` \$(@:.m=.c) \\
	       \$(XITE_DOC_DEST)/ ; \\
	       \$(HTMLDOC) \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.c) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' | sed 's/=.*//' \` \$(@:.m=.c) \\
	       \$(XITE_DOC_DEST)/ ; \\
	     fi
\$(MANP_SH):  \$(@:.m=.sh)
#	     Make manual-page descriptions
	     -@if test \"\$(@)\" != \"_MANP_SH_\"; then \\
	       echo \$(MANDOC) -s '*.sh' \\
	       \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.sh) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' |\\
	       sed 's/=.*//' \` \$(@:.m=.sh) \$(XITE_MAN_DEST)/ ; \\
	       \$(MANDOC) -s '*.sh' \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.sh) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' |\\
	       sed 's/=.*//' \` \$(@:.m=.sh) \$(XITE_MAN_DEST)/ ; \\
	       echo \$(HTMLDOC) -s '*.sh' \\
	       \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.sh) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' | sed 's/=.*//' \` \$(@:.m=.sh) \\
	       \$(XITE_DOC_DEST)/ ; \\
	       \$(HTMLDOC) -s '*.sh' \`grep \"^#\{0,1\}\/\*[PFD]:\" \$(@:.m=.sh) |\\
	       sed 's/^#\{0,1\}../-e /' |\\
	       sed 's/.[ 	]*\$\$//' | sed 's/=.*//' \` \$(@:.m=.sh) \\
	       \$(XITE_DOC_DEST)/ ; \\
	     fi

\$(ROFF3):    \$(@:.man=.3)
#            Copy troff-files to manual page section 3 directory
#            and html files to html reference manual directory
	     \$(COPY) \$(@:.man=.3) \$(XITE_MAN_DEST)${DIR_SEP}man3${DIR_SEP}\$(@:.man=.3)
	     \$(COPY) \$(@:.man=_3.html) \$(XITE_DOC_DEST)${DIR_SEP}\$(@:.man=_3.html)
"
fi

if [ "$XITE_HOSTTYPE" != "Win32" ]; then
	echo "\$(SCRIPTS):  \$(@:=.sh)"
else
	echo "\$(SCRIPTS):  \$(@).sh"
fi

echo "#	     Install shell scripts
	     \$(COPY) \$(@).sh \$(XITE_BIN_DEST)${DIR_SEP}\$(@)"

unix_only "-@\$(CHMOD) u+w \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"
unix_only "-@\$(CHMOD) a+rx \$(XITE_BIN_DEST)${DIR_SEP}\$(@) ${TO_DEV_NULL}"
