Spelling - megapatch

[metaconfig.git] / U / modified / Oldconfig.U

?RCS: $Id: Oldconfig.U,v 3.0.1.10 1997/02/28 15:06:39 ram Exp $
?RCS:
?RCS: Copyright (c) 1991-1993, Raphael Manfredi
?RCS:
?RCS: You may redistribute only under the terms of the Artistic License,
?RCS: as specified in the README file that comes with the distribution.
?RCS: You may reuse parts of this distribution only within the terms of
?RCS: that same Artistic License; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
?RCS: $Log: Oldconfig.U,v $
?RCS: Revision 3.0.1.10  1997/02/28  15:06:39  ram
?RCS: patch61: added support for src.U
?RCS: patch61: new OSNAME define
?RCS: patch61: can now sense new OSes
?RCS:
?RCS: Revision 3.0.1.9  1995/07/25  13:40:51  ram
?RCS: patch56: now knows about OS/2 platforms
?RCS:
?RCS: Revision 3.0.1.8  1995/05/12  12:04:18  ram
?RCS: patch54: config.sh reload logic now knows about new -K switch
?RCS: patch54: cleaned up and extended osvers for DEC OSF/1 (ADO)
?RCS: patch54: added MachTen detection (ADO)
?RCS:
?RCS: Revision 3.0.1.7  1995/02/15  14:13:41  ram
?RCS: patch51: adapted osvers computation for AIX (ADO)
?RCS:
?RCS: Revision 3.0.1.6  1995/01/30  14:27:15  ram
?RCS: patch49: unit Options.U now exports file optdef.sh, not a variable
?RCS: patch49: update code for myuname changed (WED)
?RCS:
?RCS: Revision 3.0.1.5  1995/01/11  15:15:36  ram
?RCS: patch45: added quotes around the INITPROG variable (ADO)
?RCS: patch45: allows variable overriding after config file loading
?RCS:
?RCS: Revision 3.0.1.4  1994/10/29  15:57:05  ram
?RCS: patch36: added ?F: line for metalint file checking
?RCS: patch36: merged with the version used for perl5's Configure (ADO)
?RCS:
?RCS: Revision 3.0.1.3  1994/05/06  14:24:17  ram
?RCS: patch23: added support for osf1 hints
?RCS: patch23: new support for solaris and i386 systems (ADO)
?RCS:
?RCS: Revision 3.0.1.2  1994/01/24  14:05:02  ram
?RCS: patch16: added post-processing on myuname for Xenix targets
?RCS: patch16: message proposing config.sh defaults made consistent
?RCS:
?RCS: Revision 3.0.1.1  1993/09/13  15:56:32  ram
?RCS: patch10: force use of config.sh when -d option is used (WAD)
?RCS: patch10: complain about non-existent hint files (WAD)
?RCS: patch10: added Options dependency for fastread variable
?RCS:
?RCS: Revision 3.0  1993/08/18  12:05:12  ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
?X:
?X: This unit tries to remember what we did last time we ran Configure, mostly
?X: for the sake of setting defaults.
?X:
?MAKE:Oldconfig hint myuname osname osvers: Instruct Myread uname \
	Checkcc Mksymlinks run \
	sh awk sed test cat rm lns tr n c contains Loc Options Tr src trnl ln
?MAKE:	-pick wipe $@ %<
?S:myuname:
?S:	The output of 'uname -a' if available, otherwise the hostname.
?S:	The whole thing is then lower-cased and slashes and single quotes are
?S:	removed.
?S:.
?S:hint:
?S:	Gives the type of hints used for previous answers. May be one of
?S:	"default", "recommended" or "previous".
?S:.
?S:osname:
?S:	This variable contains the operating system name (e.g. sunos,
?S:	solaris, hpux, etc.).  It can be useful later on for setting
?S:	defaults.  Any spaces are replaced with underscores.  It is set
?S:	to a null string if we can't figure it out.
?S:.
?S:osvers:
?S:	This variable contains the operating system version (e.g.
?S:	4.1.3, 5.2, etc.).  It is primarily used for helping select
?S:	an appropriate hints file, but might be useful elsewhere for
?S:	setting defaults.  It is set to '' if we can't figure it out.
?S:	We try to be flexible about how much of the version number
?S:	to keep, e.g. if 4.1.1, 4.1.2, and 4.1.3 are essentially the
?S:	same for this package, hints files might just be os_4.0 or
?S:	os_4.1, etc., not keeping separate files for each little release.
?S:.
?C:OSNAME:
?C:	This symbol contains the name of the operating system, as determined
?C:	by Configure.  You shouldn't rely on it too much; the specific
?C:	feature tests from Configure are generally more reliable.
?C:.
?C:OSVERS:
?C:	This symbol contains the version of the operating system, as determined
?C:	by Configure.  You shouldn't rely on it too much; the specific
?C:	feature tests from Configure are generally more reliable.
?C:.
?H:#define OSNAME "$osname"		/**/
?H:#define OSVERS "$osvers"		/**/
?H:.
?F:!config.sh
?T:tmp tmp_n tmp_c tmp_sh file
?T:xxxxfile xxxfile xxfile xfile hintfile newmyuname
?T:tans _ isesix INITPROG DJGPP
?D:osname=''
?LINT:change n c sh
?LINT:extern targetarch
?LINT:extern hostarch
?LINT:change hostarch
?LINT:use run
?LINT:extern is_os2
: Try to determine whether config.sh was made on this system
case "$config_sh" in
'')
?X: indentation wrong on purpose--RAM
?X: Leave a white space between first two '(' for ksh. The sub-shell is needed
?X: on some machines to avoid the error message when uname is not found; e.g.
?X: old SUN-OS 3.2 would not execute hostname in (uname -a || hostname). Sigh!
?X: Now not using a subshell but instead $test.
myuname=`$uname -a 2>/dev/null`
$test -z "$myuname" && myuname=`hostname 2>/dev/null`
# Downcase everything to avoid ambiguity.
# Remove slashes and single quotes so we can use parts of this in
# directory and file names.
# Remove newlines so myuname is sane to use elsewhere.
# tr '[A-Z]' '[a-z]' would not work in EBCDIC
# because the A-Z/a-z are not consecutive.
myuname=`echo $myuname | $sed -e "s,['/],,g" | \
	./tr '[A-Z]' '[a-z]' | $tr $trnl ' '`
?X: Save the value we just computed to reset myuname after we get done here.
newmyuname="$myuname"
dflt=n
case "$knowitall" in
'')
	if test -f ../config.sh; then
		if $contains myuname= ../config.sh >/dev/null 2>&1; then
			eval "`grep myuname= ../config.sh`"
		fi
		if test "X$myuname" = "X$newmyuname"; then
			dflt=y
		fi
	fi
	;;
*) dflt=y;;
esac

@if {test -d ../hints}
: Get old answers from old config file if Configure was run on the
: same system, otherwise use the hints.
hint=default
cd ..
?X: Since we are now at the root of the source tree, we must use $src
?X: to access the sources and not $rsrc. See src.U for details...
if test -f config.sh; then
	echo " "
	rp="I see a config.sh file.  Shall I use it to set the defaults?"
	. UU/myread
	case "$ans" in
	n*|N*) echo "OK, I'll ignore it."
		mv config.sh config.sh.old
		myuname="$newmyuname"
		;;
	*)  echo "Fetching default answers from your old config.sh file..." >&4
		tmp_n="$n"
		tmp_c="$c"
		tmp_sh="$sh"
		. ./config.sh
		cp config.sh UU
		n="$tmp_n"
		c="$tmp_c"
		: Older versions did not always set $sh.  Catch re-use of such
		: an old config.sh.
		case "$sh" in
		'') sh="$tmp_sh" ;;
		esac
		hint=previous
		;;
	esac
fi
. ./UU/checkcc
if test ! -f config.sh; then
	$cat <<EOM

First time through, eh?  I have some defaults handy for some systems
that need some extra help getting the Configure answers right:

EOM
	(cd $src/hints; ls -C *.sh) | $sed 's/\.sh/   /g' >&4
	dflt=''
	: Half the following guesses are probably wrong... If you have better
	: tests or hints, please send them to <MAINTLOC>
	: The metaconfig authors would also appreciate a copy...
	$test -f /irix && osname=irix
	$test -f /xenix && osname=sco_xenix
	$test -f /dynix && osname=dynix
	$test -f /dnix && osname=dnix
	$test -f /lynx.os && osname=lynxos
	$test -f /unicos && osname=unicos && osvers=`$uname -r`
	$test -f /unicosmk && osname=unicosmk && osvers=`$uname -r`
	$test -f /unicosmk.ar && osname=unicosmk && osvers=`$uname -r`
	$test -f /bin/mips && /bin/mips && osname=mips
	$test -d /NextApps && set X `hostinfo | grep 'NeXT Mach.*:' | \
		$sed -e 's/://' -e 's/\./_/'` && osname=next && osvers=$4
	$test -d /usr/apollo/bin && osname=apollo
	$test -f /etc/saf/_sactab && osname=svr4
	$test -d /usr/include/minix && osname=minix
	$test -f /system/gnu_library/bin/ar.pm && osname=vos
	if $test -d /MachTen -o -d /MachTen_Folder; then
?X:		MachTen uname -a output looks like
?X:		xxx 4 0.0 Macintosh
?X:		MachTen /sbin/version output looks like
?X:		MachTen 4.0 Mon Aug 28 10:18:00 1995
?X:		MachTen 3.x had the 'version' command in /usr/etc/version.
		osname=machten
		if $test -x /sbin/version; then
			osvers=`/sbin/version | $awk '{print $2}' |
			$sed -e 's/[A-Za-z]$//'`
		elif $test -x /usr/etc/version; then
			osvers=`/usr/etc/version | $awk '{print $2}' |
			$sed -e 's/[A-Za-z]$//'`
		else
			osvers="$2.$3"
		fi
	fi

	$test -f /sys/posix.dll &&
		$test -f /usr/bin/what &&
		set X `/usr/bin/what /sys/posix.dll` &&
		$test "$3" = UWIN &&
		osname=uwin &&
		osvers="$5"

?X: If we have uname, we already computed a suitable uname -a output,
?X: and it lies in $myuname.
	if $test -f $uname; then
		set X $myuname
		shift

		case "$5" in
		fps*) osname=fps ;;
		mips*)
			case "$4" in
			umips) osname=umips ;;
			*) osname=mips ;;
			esac;;
		[23]100) osname=mips ;;
		next*) osname=next ;;
?X: Interactive Unix.
		i386*)
			tmp=`/bin/uname -X 2>/dev/null|awk '/3\.2v[45]/{ print $(NF) }'`
			if $test "$tmp" != "" -a "$3" = "3.2" -a -f '/etc/systemid'; then
				osname='sco'
				osvers=$tmp
			elif $test -f /etc/kconfig; then
				osname=isc
				if test "$lns" = "$ln -s"; then
					osvers=4
				elif $contains _SYSV3 /usr/include/stdio.h > /dev/null 2>&1 ; then
					osvers=3
				elif $contains _POSIX_SOURCE /usr/include/stdio.h > /dev/null 2>&1 ; then
					osvers=2
				fi
			fi
			tmp=''
			;;
?X: MS-DOS djgpp uname -a output looks like:
?X: ms-dos xxx 6 22 pc
?X:  $1 is the "dos flavor" (need not be "ms-dos").
?X:  $2 is the node name
?X:  $3 and $4 are version/subversion
?X:  $5 is always "pc", but that might not be unique to DJGPP.
?X: (e.g. Solaris_x86 has $5 = i86pc, which doesn't actually conflict,
?X: but it's close enough that I can easily imagine other vendors also
?X: using variants of pc* in $5.)
?X:  The "DJGPP" environment variable is always set when djgpp is active.
		pc*)
			if test -n "$DJGPP"; then
				osname=dos
				osvers=djgpp
			fi
			;;
		esac

		case "$1" in
		aix) osname=aix
?X: aix 4.1 uname -a output looks like
?X:		AIX  foo  1 4 000123456789
?X: where $4 is the major release number and $3 is the (minor) version.
?X: More detail on the version is available with the oslevel command.
?X: in 3.2.x, it output a string (see case statements below).  In 4.1,
?X: it puts out something like  4.1.1.0
			tmp=`( (oslevel) 2>/dev/null || echo "not found") 2>&1`
			case "$tmp" in
			# oslevel can fail with:
			# oslevel: Unable to acquire lock.
			*not\ found) osvers="$4"."$3" ;;
			'<3240'|'<>3240') osvers=3.2.0 ;;
			'=3240'|'>3240'|'<3250'|'<>3250') osvers=3.2.4 ;;
			'=3250'|'>3250') osvers=3.2.5 ;;
			*) osvers=$tmp;;
			esac
			;;
		bsd386) osname=bsd386
			osvers=`$uname -r`
			;;
		cygwin*) osname=cygwin
			osvers="$3"
			;;
		*dc.osx) osname=dcosx
			osvers="$3"
			;;
		dnix) osname=dnix
			osvers="$3"
			;;
		domainos) osname=apollo
			osvers="$3"
			;;
		dgux)	osname=dgux
			osvers="$3"
			;;
		dragonfly) osname=dragonfly
			osvers="$3"
			;;
?X:		uname -a returns
?X:		DYNIX/ptx xxx 4.0 V4.1.2 i386
		dynixptx*) osname=dynixptx
			osvers=`echo "$4"|sed 's/^v//'`
			;;
		freebsd) osname=freebsd
			osvers="$3" ;;
		genix)	osname=genix ;;
?X: GNU/Hurd uname -a gives something like:
?X: GNU foo 0.3 GNU-Mach 1.4/Hurd-0.3 i386-AT386 GNU
?X: GNU gnu 0.3 GNUmach-1.2/Hurd-0.3 i386-AT386 GNU
?X: Note the hostname on the second one, which will fool Configure
?X: into using the SysV case!
		gnu)	osname=gnu
			osvers="$3" ;;
?X: HP-UX uname -a gives something like
?X: HP-UX foobar B.10.20 A 9000/735 2016483812 two-user license
?X: Preserve the full 10.20 string instead of the previous plain '10'.
?X:  Thanks to Graham Barr.    --AD 6/30/1998
		hp*)	osname=hpux
			osvers=`echo "$3" | $sed 's,.*\.\([0-9]*\.[0-9]*\),\1,'`
			;;
		irix*)	osname=irix
			case "$3" in
			4*) osvers=4 ;;
			5*) osvers=5 ;;
			*)	osvers="$3" ;;
			esac
			;;
		linux)	osname=linux
			case "$3" in
			*)	osvers="$3" ;;
			esac
			;;
		MiNT)	osname=mint
			;;
		netbsd*) osname=netbsd
			osvers="$3"
			;;
		news-os) osvers="$3"
			case "$3" in
			4*) osname=newsos4 ;;
			*) osname=newsos ;;
			esac
			;;
		next*) osname=next ;;
		nonstop-ux) osname=nonstopux ;;
		openbsd) osname=openbsd
                	osvers="$3"
                	;;
		os2)	osname=os2
			osvers="$4"
			;;
		POSIX-BC | posix-bc ) osname=posix-bc
			osvers="$3"
			;;
		powerux | power_ux | powermax_os | powermaxos | \
		powerunix | power_unix) osname=powerux
			osvers="$3"
			;;
		qnx) osname=qnx
			osvers="$4"
			;;
		solaris) osname=solaris
			case "$3" in
			5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;;
			*)	osvers="$3" ;;
			esac
			;;
		sunos) osname=sunos
			case "$3" in
			5*) osname=solaris
				osvers=`echo $3 | $sed 's/^5/2/g'` ;;
			*)	osvers="$3" ;;
			esac
			;;
		titanos) osname=titanos
			case "$3" in
			1*) osvers=1 ;;
			2*) osvers=2 ;;
			3*) osvers=3 ;;
			4*) osvers=4 ;;
			*)	osvers="$3" ;;
			esac
			;;
		ultrix) osname=ultrix
			osvers="$3"
			;;
		osf1|mls+)	case "$5" in
				alpha)
?X: DEC OSF/1 myuname -a output looks like:  osf1 xxxx t3.2 123.4 alpha
?X: where the version number can be something like [xvt]n.n
					osname=dec_osf
?X: sizer knows the minor minor version: the letter
					osvers=`sizer -v | awk -FUNIX '{print $2}' | awk '{print $1}' |  tr '[A-Z]' '[a-z]' | sed 's/^[xvt]//'`
					case "$osvers" in
					[1-9].[0-9]*) ;;
					*) osvers=`echo "$3" | sed 's/^[xvt]//'` ;;
					esac
					;;
			hp*)	osname=hp_osf1	;;
			mips)	osname=mips_osf1 ;;
?X:	hp and mips were unsupported Technology Releases -- ADO, 24/10/94
			esac
			;;
		# UnixWare 7.1.2 is known as Open UNIX 8
		openunix|unixware) osname=svr5
			osvers="$4"
			;;
		uts)	osname=uts
			osvers="$3"
			;;
		vos) osvers="$3"
			;;
		$2) case "$osname" in
			*isc*) ;;
			*freebsd*) ;;
			svr*)
				: svr4.x or possibly later
				case "svr$3" in
				${osname}*)
					osname=svr$3
					osvers=$4
					;;
				esac
				case "$osname" in
				svr4.0)
					: Check for ESIX
					if test -f /stand/boot ; then
						eval `grep '^INITPROG=[a-z/0-9]*$' /stand/boot`
						if test -n "$INITPROG" -a -f "$INITPROG"; then
			isesix=`strings -a $INITPROG|grep 'ESIX SYSTEM V/386 Release 4.0'`
							if test -n "$isesix"; then
								osname=esix4
							fi
						fi
					fi
					;;
				esac
				;;
			*)	if test -f /etc/systemid; then
					osname=sco
					set `echo $3 | $sed 's/\./ /g'` $4
					if $test -f $src/hints/sco_$1_$2_$3.sh; then
						osvers=$1.$2.$3
					elif $test -f $src/hints/sco_$1_$2.sh; then
						osvers=$1.$2
					elif $test -f $src/hints/sco_$1.sh; then
						osvers=$1
					fi
				else
					case "$osname" in
					'') : Still unknown.  Probably a generic Sys V.
						osname="sysv"
						osvers="$3"
						;;
					esac
				fi
				;;
			esac
			;;
		*)	case "$osname" in
			'') : Still unknown.  Probably a generic BSD.
				osname="$1"
				osvers="$3"
				;;
			esac
			;;
		esac
	else
?X: Try to identify sony's NEWS-OS (BSD unix)
		if test -f /vmunix -a -f $src/hints/news_os.sh; then
			(what /vmunix | UU/tr '[A-Z]' '[a-z]') > UU/kernel.what 2>&1
			if $contains news-os UU/kernel.what >/dev/null 2>&1; then
				osname=news_os
			fi
			$rm -f UU/kernel.what
?X: Maybe it's OS/2 or DOS or something similar
		elif test -d c:/. -o -n "$is_os2" ; then
			set X $myuname
			osname=os2
			osvers="$5"
		fi
	fi

        case "$targetarch" in
        '') ;;
        *)  hostarch=$osname
            osname=`echo $targetarch|sed 's,^[^-]*-,,'`
            osvers=''
            ;;
        esac

	: Now look for a hint file osname_osvers, unless one has been
	: specified already.
	case "$hintfile" in
	''|' ')
		file=`echo "${osname}_${osvers}" | $sed -e 's%\.%_%g' -e 's%_$%%'`
		: Also try without trailing minor version numbers.
		xfile=`echo $file | $sed -e 's%_[^_]*$%%'`
		xxfile=`echo $xfile | $sed -e 's%_[^_]*$%%'`
		xxxfile=`echo $xxfile | $sed -e 's%_[^_]*$%%'`
		xxxxfile=`echo $xxxfile | $sed -e 's%_[^_]*$%%'`
		case "$file" in
		'') dflt=none ;;
		*)  case "$osvers" in
			'') dflt=$file
				;;
			*)  if $test -f $src/hints/$file.sh ; then
					dflt=$file
				elif $test -f $src/hints/$xfile.sh ; then
					dflt=$xfile
				elif $test -f $src/hints/$xxfile.sh ; then
					dflt=$xxfile
				elif $test -f $src/hints/$xxxfile.sh ; then
					dflt=$xxxfile
				elif $test -f $src/hints/$xxxxfile.sh ; then
					dflt=$xxxxfile
				elif $test -f "$src/hints/${osname}.sh" ; then
					dflt="${osname}"
				else
					dflt=none
				fi
				;;
			esac
			;;
		esac
		if $test -f Policy.sh ; then
			case "$dflt" in
			*Policy*) ;;
			none) dflt="Policy" ;;
			*) dflt="Policy $dflt" ;;
			esac
		fi
		;;
	*)
		dflt=`echo $hintfile | $sed 's/\.sh$//'`
		;;
	esac

	if $test -f Policy.sh ; then
		$cat <<EOM

There's also a Policy hint file available, which should make the
site-specific (policy) questions easier to answer.
EOM

	fi

	$cat <<EOM

You may give one or more space-separated answers, or "none" if appropriate.
If you have a handcrafted Policy.sh file or a Policy.sh file generated by a
previous run of Configure, you may specify it as well as or instead of
OS-specific hints.  If hints are provided for your OS, you should use them:
although Perl can probably be built without hints on many platforms, using
hints often improve performance and may enable features that Configure can't
set up on its own. If there are no hints that match your OS, specify "none";
DO NOT give a wrong version or a wrong OS.

EOM

	rp="Which of these apply, if any?"
	. UU/myread
	tans=$ans
	for file in $tans; do
		if $test X$file = XPolicy -a -f Policy.sh; then
			. Policy.sh
			$cat Policy.sh >> UU/config.sh
		elif $test -f $src/hints/$file.sh; then
			. $src/hints/$file.sh
			$cat $src/hints/$file.sh >> UU/config.sh
		elif $test X"$tans" = X -o X"$tans" = Xnone ; then
			: nothing
		else
			: Give one chance to correct a possible typo.
			echo "$file.sh does not exist"
			dflt=$file
			rp="hint to use instead?"
			. UU/myread
			for file in $ans; do
				if $test -f "$src/hints/$file.sh"; then
					. $src/hints/$file.sh
					$cat $src/hints/$file.sh >> UU/config.sh
				elif $test X$ans = X -o X$ans = Xnone ; then
					: nothing
				else
					echo "$file.sh does not exist -- ignored."
				fi
			done
		fi
	done

	hint=recommended
	: Remember our hint file for later.
	if $test -f "$src/hints/$file.sh" ; then
		hintfile="$file"
	else
		hintfile=''
	fi
fi
cd UU
?X: From here on, we must use $rsrc instead of $src
@else
: Get old answers, if there is a config file out there
hint=default
hintfile=''
if test -f ../config.sh; then
	echo " "
	rp="I see a config.sh file.  Shall I use it to set the defaults?"
	. ./myread
	case "$ans" in
	n*|N*) echo "OK, I'll ignore it.";;
	*)  echo "Fetching default answers from your old config.sh file..." >&4
		tmp_n="$n"
		tmp_c="$c"
		. ../config.sh
		cp ../config.sh .
		n="$tmp_n"
		c="$tmp_c"
		hint=previous
		;;
	esac
fi
@end
?X: remember, indentation is wrong--RAM
;;
*)
	echo " "
	echo "Fetching default answers from $config_sh..." >&4
	tmp_n="$n"
	tmp_c="$c"
	cd ..
?X: preserve symbolic links, if any
	cp $config_sh config.sh 2>/dev/null
	chmod +w config.sh
	. ./config.sh
	cd UU
	cp ../config.sh .
	n="$tmp_n"
	c="$tmp_c"
	hint=previous
	;;
esac
test "$override" && . ./optdef.sh

: Restore computed paths
for file in $loclist $trylist; do
	eval $file="\$_$file"
done

@if osname || osvers
cat << EOM

Configure uses the operating system name and version to set some defaults.
The default value is probably right if the name rings a bell. Otherwise,
since spelling matters for me, either accept the default or answer "none"
to leave it blank.

EOM
@end
@if osname
case "$osname" in
	''|' ')
		case "$hintfile" in
		''|' '|none) dflt=none ;;
		*)  dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/_.*$//'` ;;
		esac
		;;
	*) dflt="$osname" ;;
esac
rp="Operating system name?"
. ./myread
case "$ans" in
none)  osname='' ;;
*) osname=`echo "$ans" | $sed -e 's/[ 	][	]*/_/g' | ./tr '[A-Z]' '[a-z]'`;;
esac
@end
@if osvers
@if osname
echo " "
@end
case "$osvers" in
	''|' ')
		case "$hintfile" in
		''|' '|none) dflt=none ;;
		*)	dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/^[^_]*//'`
			dflt=`echo $dflt | $sed -e 's/^_//' -e 's/_/./g'`
			case "$dflt" in
			''|' ') dflt=none ;;
			esac
			;;
		esac
		;;
	*) dflt="$osvers" ;;
esac
rp="Operating system version?"
. ./myread
case "$ans" in
none)  osvers='' ;;
*) osvers="$ans" ;;
esac

@end

. ./posthint.sh