Even better use64bitall logic.

[metaconfig.git] / U / perl / use64bits.U

?RCS: $Id$
?RCS:
?RCS: Copyright (c) 1998 Andy Dougherty
?RCS:
?RCS: You may distribute under the terms of either the GNU General Public
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:use64bitint use64bitall archname64: Myread Oldconfig Setvar test \
	uselargefiles usemorebits longsize ccflags
?MAKE:	-pick add $@ %<
?Y:TOP
?S:use64bitint:
?S:	This variable conditionally defines the USE_64_BIT_INT symbol,
?S:	and indicates that 64-bit integer types should be used
?S:	when available.  The minimal possible 64-bitness
?S:	is employed, just enough to get 64-bit integers into Perl.
?S:	This may mean using for example "long longs", while your memory
?S:	may still be limited to 2 gigabytes.
?S:.
?S:use64bitall:
?S:	This variable conditionally defines the USE_64_BIT_ALL symbol,
?S:	and indicates that 64-bit integer types should be used
?S:	when available.  The maximal possible
?S:	64-bitness is employed: LP64 or ILP64, meaning that you will
?S:	be able to use more than 2 gigabytes of memory.  This mode is
?S:	even more binary incompatible than USE_64_BIT_INT. You may not
?S:	be able to run the resulting executable in a 32-bit CPU at all or
?S:	you may need at least to reboot your OS to 64-bit mode.
?S:.
?S:archname64:
?S:	This variable is used for the 64-bitness part of $archname.
?S:.
?C:USE_64_BIT_INT:
?C:	This symbol, if defined, indicates that 64-bit integers should
?C:	be used when available.  If not defined, the native integers
?C:	will be employed (be they 32 or 64 bits).  The minimal possible
?C:	64-bitness is used, just enough to get 64-bit integers into Perl.
?C:	This may mean using for example "long longs", while your memory
?C:	may still be limited to 2 gigabytes.
?C:.
?C:USE_64_BIT_ALL:
?C:	This symbol, if defined, indicates that 64-bit integers should
?C:	be used when available.  If not defined, the native integers
?C:	will be used (be they 32 or 64 bits).  The maximal possible
?C:	64-bitness is employed: LP64 or ILP64, meaning that you will
?C:	be able to use more than 2 gigabytes of memory.  This mode is
?C:	even more binary incompatible than USE_64_BIT_INT. You may not
?C:	be able to run the resulting executable in a 32-bit CPU at all or
?C:	you may need at least to reboot your OS to 64-bit mode.
?C:.
?H:?%<:#ifndef USE_64_BIT_INT
?H:?%<:#$use64bitint	USE_64_BIT_INT		/**/
?H:?%<:#endif
?H:.
?H:?%<:#ifndef USE_64_BIT_ALL
?H:?%<:#$use64bitall	USE_64_BIT_ALL		/**/
?H:?%<:#endif
?H:.
?LINT:set use64bitint
?LINT:extern ccflags
?LINT:change ccflags
?LINT:use uselargefiles
?LINT:use usemorebits
?LINT:extern uselonglong
?LINT:use uselonglong
?LINT:set use64bitall
?F:!use64bitint.cbu
?F:!use64bitall.cbu

# Backward compatibility (uselonglong is deprecated).
case "$uselonglong" in
"$define"|true|[yY]*)
	cat <<EOM >&4

*** Configure -Duselonglong is deprecated, using -Duse64bitint instead.
EOM
	use64bitint="$define"
	;;
esac                          
# Backward compatibility (use64bits is deprecated).
case "$use64bits" in
"$define"|true|[yY]*)
	cat <<EOM >&4

*** Configure -Duse64bits is deprecated, using -Duse64bitint instead.
EOM
	use64bitint="$define"
	;;
esac                          
# Thinko compatibility
case "$use64bitints" in
"$define"|true|[yY]*)
	cat <<EOM >&4

*** There is no Configure -Duse64bitints, using -Duse64bitint instead.
EOM
	use64bitint="$define"
	;;
esac                          

case "$ccflags" in
*-DUSE_LONG_LONG*|*-DUSE_64_BIT_INT*|*-DUSE_64_BIT_ALL*) use64bitint="$define";;
esac
case "$use64bitall" in
"$define"|true|[yY]*) use64bitint="$define" ;;
esac

case "$longsize" in
8) cat <<EOM

You have natively 64-bit long integers.
EOM
   val="$define"
   ;;
*) case "$use64bitint" in
   "$define"|true|[yY]*) dflt='y';;
   *) dflt='n';;
   esac
   cat <<EOM

Perl can be built to take advantage of 64-bit integer types
on some systems.  To do so, Configure can be run with -Duse64bitint.
Choosing this option will most probably introduce binary incompatibilities.

If this doesn't make any sense to you, just accept the default '$dflt'.
EOM
   rp='Try to use 64-bit integers, if available?'
   . ./myread
   case "$ans" in
   [yY]*) val="$define" ;;
   *)     val="$undef"  ;;
   esac
   ;;
esac
set use64bitint
eval $setvar

case "$use64bitint" in
"$define")	case "$longsize" in
		8) dflt='y' ;;
		*) dflt='n' ;;
		esac
		;;
*)	case "$use64bitall" in
	"$define"|true|[yY]*) dflt='y' ;;
	*) dflt='n' ;;
	esac
	;;
esac 
cat <<EOM

You may also choose to try maximal 64-bitness.  It means using as much
64-bitness as possible on the platform.  This in turn means even more
binary incompatibilities.  On the other hand, your platform may not
have any more 64-bitness available than what you already have chosen.

If this doesn't make any sense to you, just accept the default '$dflt'.
EOM
rp='Try to use maximal 64-bit support, if available?'
. ./myread
case "$ans" in
[yY]*) val="$define" ;;
*)     val="$undef"  ;;
esac
set use64bitall
eval $setvar
case "$use64bitall" in
"$define")
	case "$use64bitint" in
	"$undef")
		cat <<EOM

Since you have chosen a maximally 64-bit build, I'm also turning on
the use of 64-bit integers.
EOM
		use64bitint="$define" ;;
	esac
	;;
esac

case "$use64bitint" in
"$define"|true|[yY]*)
: Look for a hint-file generated 'call-back-unit'.  If the
: user has specified that a 64-bit perl is to be built,
: we may need to set or change some other defaults.
	if $test -f use64bitint.cbu; then
		echo "Your platform has some specific hints for 64-bit integers, using them..."
		. ./use64bitint.cbu
	fi
	case "$longsize" in
	4) case "$ccflags" in
	   *-DUSE_64_BIT_INT*) ;;
	   *) ccflags="$ccflags -DUSE_64_BIT_INT";;
	   esac
	   case "$archname64" in
	   '') archname64=64int ;;
	   esac
	   ;;
	esac
	;;
esac

case "$use64bitall" in
"$define"|true|[yY]*)
: Look for a hint-file generated 'call-back-unit'.  If the
: user has specified that a maximally 64-bit perl is to be built,
: we may need to set or change some other defaults.
	if $test -f use64bitall.cbu; then
		echo "Your platform has some specific hints for 64-bit builds, using them..."
		. ./use64bitall.cbu
	fi
	case "$longsize" in
	4) case "$ccflags" in
	   *-DUSE_64_BIT_ALL*) ;;
      	   *) ccflags="$ccflags -DUSE_64_BIT_ALL";;
	   esac
	   case "$archname64" in
	   ''|64) archname64=64all ;;
	   esac
	   ;;
	esac
	;;
esac