#!/bin/sh
# @(#)inst_dl.sh	128.5 06 Oct 1993 11:59:03
#
#
# Copyright 1991 Lotus Development Corporation, All Rights Reserved
#
#


PROGNAME=inst_dl
VERSION=12
ARCH=sun4sol2

echo

# check command line

case "$#" in
  2)
	LANGUAGE=$2
	;;
  1)
	if [ -z "$LANGUAGE" -o ! -f $1/123.v$VERSION/ri/$LANGUAGE/inst_dl.ri ]
	then
		LANGUAGE=Intl-English
	fi
	;;
  *)
	echo "usage: $PROGNAME base_directory [LANGUAGE]"
	echo

	exit 1
	;;
esac

# set VERSIONDIR, pick up resource strings

VERSIONDIR=${1}/123.v${VERSION}
if [ ! -d "$VERSIONDIR" ]
then
	echo "$PROGNAME: '$VERSIONDIR' is not a directory"
	echo "$PROGNAME: '$VERSIONDIR' n'est pas un repertoire"
	echo

	exit 1
fi


RIFILE=$VERSIONDIR/ri/$LANGUAGE/inst_dl.ri
if [ ! -r "$RIFILE" ]
then
	echo "$PROGNAME: cannot load resource file -- $RIFILE"
	echo "$PROGNAME: impossible de charger le fichier ressource -- $RIFILE"
	echo

	exit 1
fi

. $RIFILE

# set the echo(1) style:  ECHOSTYLE is null for BSD, nonnull for SystemV
#
# echo_n() is a routine to echo without a newline

ECHOSTYLE=`echo -n`

echo_n() {
	if [ -z "$ECHOSTYLE" ]
	then
		echo -n "$*"
	else
		echo "$*\c"
	fi
}


# routines to verify existance of files and directories

check_file() {
	if [ ! -r "$1" ]
	then
		FILE1=$1
		eval echo ${MSG17}
		echo

		exit 1
	fi
}

check_dir() {
	if [ ! -d "$1" ]
	then
		ANSWER=$1
		eval echo ${MSG10}
		echo

		exit 1
	fi
}

# check that the BCF file exists and is writable

BCFFILE=$VERSIONDIR/$ARCH/lotus.bcf
if [ ! -w "$BCFFILE" ]
then
	eval echo ${MSG01}
	echo

	exit 1
fi

# on PCs check the ulimit

if [ "$ARCH" = "sysV386" ]
then
	ULIMIT=`ulimit`

	if [ "$ULIMIT" -lt "8192" -a "$ULIMIT" != "unlimited" ]
	then
		echo "${MSG30}"
		echo

		exit 1
	fi
fi

# check that the lotus bin & lib directories exist

DLBINDIR=$VERSIONDIR/$ARCH/bin
check_dir "$DLBINDIR"

DLLIBDIR=$VERSIONDIR/$ARCH/lib
check_dir "$DLLIBDIR"

# locate the system loader program

case $ARCH in
  sysV386)
	MESS_FILE=$DLLIBDIR/messages
	check_file "$MESS_FILE"

	OS_STRING=`grep -s OS_TYPE $MESS_FILE`

	if [ $? -ne 0 ]
	then
		eval echo ${MSG31}
		echo

		exit 1
	fi

	eval $OS_STRING

	if [ -n "$LOTUS_LD" -a -x "$LOTUS_LD" ]
	then
		LD=$LOTUS_LD
	elif [ -x "/bin/ld" ]
	then
		LD=/bin/ld
	elif [ -x "/bin/idld" ]
	then
		LD=/bin/idld
	elif [ -x "$DLBINDIR/ld_lotus" ]
	then
		LD=$DLBINDIR/ld_lotus
	else
		LD=/bin/ld
	fi
	;;
  sun4sol2)
	LD=/usr/ccs/bin/ld
	;;
  *)
	LD=/bin/ld
	;;
esac

if [ ! -x "$LD" ]
then
	eval echo ${MSG21}
	echo

	exit 1
fi

# pick up the architecture-specific libraries and loader options

case $ARCH in
  sysV386)
	SYSLIBS=
	;;
  sun386)
	SYSLIBS="-lc"
	LDOPTS="-dc -dp -e _start -x"
	;;
  sun3)
	SYSLIBS="-lc"
	LDOPTS="-dc -dp -e start -x"
	;;
  sun4|sun4sol1)
	SYSLIBS="-ldl -lc"
	LDOPTS="-dc -dp -e start -x"
	;;
  sun4sol2)
	SYSLIBS="-lsocket -lnsl -lelf -ldl -lc"
	LDOPTS=
	;;
  decs)
	SYSLIBS="$VERSIONDIR/$ARCH/addins/lib/staticcat.o $VERSIONDIR/$ARCH/addins/lib/static_lib.a -llmf"
	CCOPTS=
	;;
  hp300)
	SYSLIBS="$VERSIONDIR/$ARCH/addins/lib/staticcat.o $VERSIONDIR/$ARCH/addins/lib/static_lib.a"
	CCOPTS=
	;;
  hp700)
	SYSLIBS="$VERSIONDIR/$ARCH/addins/lib/staticcat.o $VERSIONDIR/$ARCH/addins/lib/static_lib.a"
	CCOPTS="-Wl,-a,archive"
	;;
  rs6000)
	SYSLIBS="$VERSIONDIR/$ARCH/addins/lib/staticcat.o $VERSIONDIR/$ARCH/addins/lib/static_lib.a /lib/crt0.o -lcurses -lm"
	CCOPTS=
	;;
  m88k_r3)
	SYSLIBS="$VERSIONDIR/$ARCH/addins/lib/staticcat.o $VERSIONDIR/$ARCH/addins/lib/static_lib.a"
	CCOPTS=
	;;
esac

# pick up the architecture-specific object files

if [ "$ARCH" = "sysV386" ]
then
	OBJS123X=$DLLIBDIR/123x.o
	check_file "$OBJS123X"

	OBJS123=$DLLIBDIR/123.o
	check_file "$OBJS123"

	OBJS123Y=$DLLIBDIR/123y.o
	check_file "$OBJS123Y"

	DLADDINLIBDIR=$VERSIONDIR/$ARCH/addins/lib
	check_dir "$DLADDINLIBDIR"

	# Use site-specific CAT file if one exists.  Else use generic CAT files.
	OBJSCAT="$DLLIBDIR/123addins.o"
	if [ ! -r "$OBJSCAT" -o ! -s "$OBJSCAT" ]
	then
		OBJSCATLIB=$DLADDINLIBDIR/static_lib.a
		check_file "$OBJSCATLIB"

		OBJSCATTBL=$DLADDINLIBDIR/staticcat.o
		check_file "$OBJSCATTBL"

		OBJSCAT="$OBJSCATLIB $OBJSCATTBL"
	fi

	OBJS123="$OBJS123X $OBJS123 $OBJS123Y $OBJSCAT"

	TAILOBJ=$DLLIBDIR/tail.o
	check_file "$TAILOBJ"

	DLFINAL="$DLLIBDIR/123datalens.o"
else
	OBJS123=$DLLIBDIR/123.o
	check_file "$OBJS123"
fi

DLOBJ=$DLLIBDIR/dl_init.o
check_file "$DLOBJ"

if [ "$ARCH" = "sun3" ]
then
	DLLIBDIRF=$VERSIONDIR/sun3f/lib
	check_dir "$DLLIBDIRF"

	OBJS123F=$DLLIBDIRF/123.o
	check_file "$OBJS123F"

	DLOBJF=$DLLIBDIRF/dl_init.o
	check_file "$DLOBJF"
fi

# check that the mkdlobj program exists

MKDLOBJ=$DLLIBDIR/mkdlobj
check_file "$MKDLOBJ"

# define locations of various temporary files

case $ARCH in
  sun3)
	TMP123=$DLBINDIR/123_exe_fsoft.$$
	NEW123S=$DLBINDIR/123_exe_fsoft
	TMP123F=$DLBINDIR/123_exe_f68881.$$
	NEW123F=$DLBINDIR/123_exe_f68881
	;;
  sun386|hp300)
	TMP123=$DLBINDIR/123.$$
	NEW123X=$DLBINDIR/123
	;;
  *)
	TMP123=$DLBINDIR/123.$$
	NEW123X=$DLBINDIR/123_exe
	;;
esac

DLOBJ1=/tmp/dlobj${$}_1.o
DLOBJ2=/tmp/dlobj${$}_2.o
TMPBCF=/tmp/inst_dl.$$
TMPBCFFILE=/tmp/inst_dl2.$$

# routine to read a BCF file record into shell variables

DN01= DL01= DD01= DC01= AC01= IL01=
DN02= DL02= DD02= DC02= AC02= IL02=
DN03= DL03= DD03= DC03= AC03= IL03=
DN04= DL04= DD04= DC04= AC04= IL04=
DN05= DL05= DD05= DC05= AC05= IL05=
DN06= DL06= DD06= DC06= AC06= IL06=
DN07= DL07= DD07= DC07= AC07= IL07=
DN08= DL08= DD08= DC08= AC08= IL08=

parse_bcf_rec() {
	BCFLINE=$1

	DN=`expr "$BCFLINE " : '^ *DN="\([^"]*\)" '`
	if [ -z "$DN" ];  then return 42;  fi

	DL=`expr "$BCFLINE " : '.* DL="\([^"]*\)" '`
	DD=`expr "$BCFLINE " : '.* DD="\([^"]*\)" '`
	DC=`expr "$BCFLINE " : '.* DC="\([^"]*\)" '`
	AC=`expr "$BCFLINE " : '.* AC=\([^ ]*\) '`
	IL=`expr "$BCFLINE " : '.* IL=\([^ ]*\) '`

	if [ -z "$DL" -o -z "$DD" ]
	then
		eval echo ${MSG22}
		echo

		rm -f $TMPBCF $TMPBCFFILE

		exit 1
	fi

	FILE1=$DLLIBDIR/$DL.o
	if [ ! -r "$FILE1" ]
	then
		eval echo ${MSG17}
		echo

		rm -f $TMPBCF $TMPBCFFILE

		exit 1
	fi

	if [ -z "$DN01" ]
	then
		DN01="$DN" DL01="$DL" DD01="$DD" DC01="$DC" AC01="$AC" IL01="$IL"

	elif [ -z "$DN02" ]
	then
		DN02="$DN" DL02="$DL" DD02="$DD" DC02="$DC" AC02="$AC" IL02="$IL"

	elif [ -z "$DN03" ]
	then
		DN03="$DN" DL03="$DL" DD03="$DD" DC03="$DC" AC03="$AC" IL03="$IL"

	elif [ -z "$DN04" ]
	then
		DN04="$DN" DL04="$DL" DD04="$DD" DC04="$DC" AC04="$AC" IL04="$IL"

	elif [ -z "$DN05" ]
	then
		DN05="$DN" DL05="$DL" DD05="$DD" DC05="$DC" AC05="$AC" IL05="$IL"

	elif [ -z "$DN06" ]
	then
		DN06="$DN" DL06="$DL" DD06="$DD" DC06="$DC" AC06="$AC" IL06="$IL"

	elif [ -z "$DN07" ]
	then
		DN07="$DN" DL07="$DL" DD07="$DD" DC07="$DC" AC07="$AC" IL07="$IL"

	elif [ -z "$DN08" ]
	then
		DN08="$DN" DL08="$DL" DD08="$DD" DC08="$DC" AC08="$AC" IL08="$IL"

	else
		eval echo ${MSG22}
		echo

		rm -f $TMPBCF $TMPBCFFILE

		exit 1
	fi

	return 0
}


# read the BCF file's driver records into shell variables,
# save the other records in a temporary file
#
# the BCF file's records are terminated by ';' and {LF,HT,SP} count as
# whitespace.
#
# NB: We can't use "while read ... do ... done <FILE" syntax since the shell
#     puts redirected loops into a subshell and only the subshell's variables
#     would get set.  Instead we assign the file to channel 0 and preserve STDIN
#     on channel 9, putting things back afterwards - yukky I know.

rm -f $TMPBCF
> $TMPBCF

tr -s ';\012\011 ' '\012 ' <$BCFFILE >$TMPBCFFILE

exec 9<&0 0<$TMPBCFFILE

while read BCFLINE
do
	if [ -n "$BCFLINE" ]
	then
		parse_bcf_rec "$BCFLINE"
		if [ $? -eq 42 ]
		then
			echo "$BCFLINE;" >>$TMPBCF
		fi
	fi
done

exec 0<&9 9<&-

# exit routines

quit_it() {
	rm -f $DLOBJ1 $DLOBJ2 $TMP123 $TMP123F $TMPBCF $TMPBCFFILE

	echo >&2
	echo ${MSG18} >&2
	echo ${MSG19} >&2
	echo >&2

	exit 1
}

ld_failed() {
	rm -f $DLOBJ1 $DLOBJ2 $TMP123 $TMP123F $TMPBCF $TMPBCFFILE

	eval echo ${MSG26}
	echo

	exit 1
}

# yes_or_no routine

yes_or_no() {
	while :
	do
		read response

		case "${response}" in
		  ${INT_YES1}*|${INT_YES2}*)
			answer="y"
			break
			;;
		  ${INT_NO1}*|${INT_NO2}*)
			answer="n"
			break
			;;
		  *)
			echo_n "${MSG05}"
			;;
		esac
	done
}

# routines to print driver info

print_dvr_info() {
	if [ -z "$2" ]
	then
		echo "$1. ${MSG03}"
	else
		echo "$1. $2 -- $4"

		eval echo ${MSG27}
	fi
}

print_dvr_info_all() {
	print_dvr_info 1 "$DN01" "$DL01" "$DD01" "$DC01" "$AC01"
	print_dvr_info 2 "$DN02" "$DL02" "$DD02" "$DC02" "$AC02"
	print_dvr_info 3 "$DN03" "$DL03" "$DD03" "$DC03" "$AC03"
	print_dvr_info 4 "$DN04" "$DL04" "$DD04" "$DC04" "$AC04"
	print_dvr_info 5 "$DN05" "$DL05" "$DD05" "$DC05" "$AC05"
	print_dvr_info 6 "$DN06" "$DL06" "$DD06" "$DC06" "$AC06"
	print_dvr_info 7 "$DN07" "$DL07" "$DD07" "$DC07" "$AC07"
	print_dvr_info 8 "$DN08" "$DL08" "$DD08" "$DC08" "$AC08"
}

# routines to print BCF file

print_bcf_rec() {
	if [ -n "$1" ]
	then
		echo "DN=\"$1\" DL=\"$2\" DD=\"$3\" DC=\"$4\"${5:+ AC=}$5${6:+ IL=}$6;"
	fi
}

print_bcf_file() {
	print_bcf_rec "$DN01" "$DL01" "$DD01" "$DC01" "$AC01" "$IL01"
	print_bcf_rec "$DN02" "$DL02" "$DD02" "$DC02" "$AC02" "$IL02"
	print_bcf_rec "$DN03" "$DL03" "$DD03" "$DC03" "$AC03" "$IL03"
	print_bcf_rec "$DN04" "$DL04" "$DD04" "$DC04" "$AC04" "$IL04"
	print_bcf_rec "$DN05" "$DL05" "$DD05" "$DC05" "$AC05" "$IL05"
	print_bcf_rec "$DN06" "$DL06" "$DD06" "$DC06" "$AC06" "$IL06"
	print_bcf_rec "$DN07" "$DL07" "$DD07" "$DC07" "$AC07" "$IL07"
	print_bcf_rec "$DN08" "$DL08" "$DD08" "$DC08" "$AC08" "$IL08"

	cat $TMPBCF
}

# routines to remake 1-2-3

add_dl_dvr() {
	if [ -n "$2" ]
	then
		$MKDLOBJ $DLOBJ1 $DLOBJ2 dl_drivername_0${1}_init_dvr ${3}_init_dvr
		if [ $? -ne 0 ]
		then
			ld_failed 100
		fi
		$MKDLOBJ $DLOBJ2 $DLOBJ1 dl_drivername_0${1} $3
		if [ $? -ne 0 ]
		then
			ld_failed 101
		fi
		rm -f $DLOBJ2

		DLLIBS="$DLLIBS $4/$3.o"
	fi
}

add_dl_dvrs() {
	LIBDIR=$1
	add_dl_dvr 1 "$DN01" "$DL01" "$LIBDIR"
	add_dl_dvr 2 "$DN02" "$DL02" "$LIBDIR"
	add_dl_dvr 3 "$DN03" "$DL03" "$LIBDIR"
	add_dl_dvr 4 "$DN04" "$DL04" "$LIBDIR"
	add_dl_dvr 5 "$DN05" "$DL05" "$LIBDIR"
	add_dl_dvr 6 "$DN06" "$DL06" "$LIBDIR"
	add_dl_dvr 7 "$DN07" "$DL07" "$LIBDIR"
	add_dl_dvr 8 "$DN08" "$DL08" "$LIBDIR"
}

make_dl() {
	echo
	echo ${MSG25}
	echo

	DLLIBS=
	rm -f $DLOBJ1
	cp $DLOBJ $DLOBJ1

	add_dl_dvrs "$DLLIBDIR"

	rm -f $TMP123
	case $ARCH in
	  sysV386)
		$LD -r -o $DLFINAL $DLOBJ1 $DLLIBS
		$LD -s -o $TMP123 $OBJS123 $DLFINAL $SYSLIBS $TAILOBJ
		;;
	  sun*)
		$LD -s $LDOPTS -o $TMP123 $OBJS123 $DLOBJ1 $DLLIBS $SYSLIBS
		;;
	  *)
		cc -s $CCOPTS -o $TMP123 $OBJS123 $DLOBJ1 $DLLIBS $SYSLIBS
		;;
	esac
	if [ $? -ne 0 ]
	then
		ld_failed 102
	fi
	if [ "$ARCH" = "sun3" ]
	then
		DLLIBS=
		cp $DLOBJF $DLOBJ1

		add_dl_dvrs "$DLLIBDIRF"

		rm -f $TMP123F
		$LD -s $LDOPTS -o $TMP123F $OBJS123F $DLOBJ1 $DLLIBS $SYSLIBS
		if [ $? -ne 0 ]
		then
			ld_failed 103
		fi
		rm -f $DLOBJ1 $NEW123F $NEW123S
		mv $TMP123F $NEW123F
		mv $TMP123  $NEW123S
	else
		rm -f $DLOBJ1 $NEW123X
		mv $TMP123 $NEW123X
	fi

	if [ "$ARCH" = "sysV386" ]
	then
		if [ "$OS_TYPE" = "s" -o "$OS_TYPE" = "x" ]
		then
			echo
			echo "${DL_MSG2026}"
			echo
			echo_n "${DL_MSG2027} ${INT_YESNO}"
			yes_or_no
			echo

			if [ "${answer}" = "y" ]
			then
				chmod 4755 $NEW123X
			fi
		fi
	fi

	print_bcf_file > $BCFFILE

	eval echo ${MSG28}
}

# routine to update shell variables via user prompting

handle_request() {
	DN="$1" DL="$2" DD="$3" DC="$4" AC="$5"

	echo

	case "$FUNCTION" in
	  ${MSGADD})
		if [ ! -z "$DN" ]
		then
			eval echo ${MSG06}
			return
		fi

		echo

		while [ -z "$DN" ]
		do
			echo ${MSG07}
			read DN
		done

		DD=
		while [ -z "$DD" ]
		do
			echo ${MSG08}
			read DD
		done

		echo ${MSG04}
		read DC

		echo ${MSG32}
		read AC

		LIBDIR=$VERSIONDIR
		while :
		do
			eval echo ${MSG09}
			read ANSWER
			if [ -z "$ANSWER" ]
			then
				ANSWER=$LIBDIR
			fi

			if [ ! -d "$ANSWER" ]
			then
				echo
				eval echo ${MSG10}
				echo
			else
				break
			fi
		done
		LIBDIR=$ANSWER

		DBNAME=$DN.o
		eval echo ${MSG11}
		read DBNAME
		if [ -z "$DBNAME" ]
		then
			DBNAME=$DN.o
		fi

		echo

		DL=`echo $DBNAME | sed 's/\.[ao]$//'`
		if [ "$DL" = "$DBNAME" ]
		then
			eval echo ${MSG24}
			echo

			DN= DL= DD= DC= AC=
			return
		fi

		FILE1=$LIBDIR/$ARCH/lib/$DBNAME
		if [ ! -r "$FILE1" ]
		then
			eval echo ${MSG17}
			echo

			DN= DL= DD= DC= AC=
			return
		fi

		for j in "$DL01" "$DL02" "$DL03" "$DL04"     \
			 "$DL05" "$DL06" "$DL07" "$DL08"
		do
			if [ "$j" = "$DL" ]
			then
				eval echo ${MSG29}
				echo

				DN= DL= DD= DC= AC=
				return
			fi
		done

		FILE2=$DLLIBDIR/$DL.o

		if [ "$FILE1" != "$FILE2" ]
		then
			rm -f $FILE2
			cp $FILE1 $FILE2
			if [ $? -ne 0 ]
			then
				eval echo ${MSG13}

				DN= DL= DD= DC= AC=
				return
			fi
			eval echo ${MSG12}
		fi

		if [ "$ARCH" = "sun3" ]
		then
			FILE1=$LIBDIR/sun3f/lib/$DBNAME
			if [ ! -r "$FILE1" ]
			then
				FILE1=$LIBDIR/sun3/lib/$DBNAME
			fi
			FILE2=$DLLIBDIRF/$DL.o

			if [ "$FILE1" != "$FILE2" ]
			then
				rm -f $FILE2
				cp $FILE1 $FILE2
				if [ $? -ne 0 ]
				then
					eval echo ${MSG13}

					DN= DL= DD= DC= AC=
					return
				fi
				eval echo ${MSG12}
			fi
		fi
		;;

	  ${MSGDELETE})
		if [ -z "$DN" ]
		then
			eval echo ${MSG14}
			return
		fi

		DN= DL= DD= DC= AC=
		;;

	  ${MSGRENAME})
		if [ -z "$DN" ]
		then
			eval echo ${MSG14}
			return
		fi

		eval echo ${MSG15}
		read ANSWER
		if [ -n "$ANSWER" ]
		then
			DN=$ANSWER
		fi

		eval echo ${MSG16}
		read ANSWER
		if [ -n "$ANSWER" ]
		then
			DD=$ANSWER
		fi

		eval echo ${MSG20}
		read ANSWER
		if [ -n "$ANSWER" ]
		then
			DC=$ANSWER
		fi

		eval echo ${MSG33}
		read ANSWER
		if [ -n "$ANSWER" ]
		then
			AC=$ANSWER
		fi
		;;
	esac
}

#

trap 'quit_it' 1 2 3 9 15

while :
do
	# display currently configured drivers

	echo
	echo ${MSG02}
	echo
	echo "-------------------------------------------------------------------------------"
	print_dvr_info_all
	echo "-------------------------------------------------------------------------------"

	# get the user's function request

	while :
	do
		echo
		eval echo_n ${MSG23}
		read ANSWER

		case "$ANSWER" in
		  ${MSGADD1}*|${MSGADD2}*)
			FUNCTION=${MSGADD}
			break
			;;
		  ${MSGDELETE1}*|${MSGDELETE2}*)
			FUNCTION=${MSGDELETE}
			break
			;;
		  ${MSGRENAME1}*|${MSGRENAME2}*)
			FUNCTION=${MSGRENAME}
			break
			;;
		  ${MSGMAKE1}*|${MSGMAKE2}*)
			make_dl
			;;
		  ${MSGQUIT1}*|${MSGQUIT2}*)
			rm -f $TMPBCF $TMPBCFFILE

			exit 0
			;;
		esac
	done

	# get the number of the driver to be altered
	# and handle the user's function request

	while :
	do
		echo
		eval echo_n ${MSG05}
		read DLNUM

		case "$DLNUM" in
		  1)
			handle_request "$DN01" "$DL01" "$DD01" "$DC01" "$AC01"
			DN01="$DN" DL01="$DL" DD01="$DD" DC01="$DC" AC01="$AC"
			break
			;;
		  2)
			handle_request "$DN02" "$DL02" "$DD02" "$DC02" "$AC02"
			DN02="$DN" DL02="$DL" DD02="$DD" DC02="$DC" AC02="$AC"
			break
			;;
		  3)
			handle_request "$DN03" "$DL03" "$DD03" "$DC03" "$AC03"
			DN03="$DN" DL03="$DL" DD03="$DD" DC03="$DC" AC03="$AC"
			break
			;;
		  4)
			handle_request "$DN04" "$DL04" "$DD04" "$DC04" "$AC04"
			DN04="$DN" DL04="$DL" DD04="$DD" DC04="$DC" AC04="$AC"
			break
			;;
		  5)
			handle_request "$DN05" "$DL05" "$DD05" "$DC05" "$AC05"
			DN05="$DN" DL05="$DL" DD05="$DD" DC05="$DC" AC05="$AC"
			break
			;;
		  6)
			handle_request "$DN06" "$DL06" "$DD06" "$DC06" "$AC06"
			DN06="$DN" DL06="$DL" DD06="$DD" DC06="$DC" AC06="$AC"
			break
			;;
		  7)
			handle_request "$DN07" "$DL07" "$DD07" "$DC07" "$AC07"
			DN07="$DN" DL07="$DL" DD07="$DD" DC07="$DC" AC07="$AC"
			break
			;;
		  8)
			handle_request "$DN08" "$DL08" "$DD08" "$DC08" "$AC08"
			DN08="$DN" DL08="$DL" DD08="$DD" DC08="$DC" AC08="$AC"
			break
			;;
		  ${MSGQUIT1}*|${MSGQUIT2}*)
			rm -f $TMPBCF $TMPBCFFILE

			exit 0
			;;
		esac
	done
done
