U/perl/use64bits.U

   1 ?RCS: $Id$
   2 ?RCS:
   3 ?RCS: Copyright (c) 1998 Andy Dougherty
   4 ?RCS:
   5 ?RCS: You may distribute under the terms of either the GNU General Public
   6 ?RCS: License or the Artistic License, as specified in the README file.
   7 ?RCS:
   8 ?MAKE:use64bitint use64bitall archname64: Myread Oldconfig Setvar test \
   9         usemorebits longsize ccflags d_quad uquadtype Compile rm_try run
  10 ?MAKE:  -pick add $@ %<
  11 ?Y:TOP
  12 ?S:use64bitint:
  13 ?S:     This variable conditionally defines the USE_64_BIT_INT symbol,
  14 ?S:     and indicates that 64-bit integer types should be used
  15 ?S:     when available.  The minimal possible 64-bitness
  16 ?S:     is employed, just enough to get 64-bit integers into Perl.
  17 ?S:     This may mean using for example "long longs", while your memory
  18 ?S:     may still be limited to 2 gigabytes.
  19 ?S:.
  20 ?S:use64bitall:
  21 ?S:     This variable conditionally defines the USE_64_BIT_ALL symbol,
  22 ?S:     and indicates that 64-bit integer types should be used
  23 ?S:     when available.  The maximal possible
  24 ?S:     64-bitness is employed: LP64 or ILP64, meaning that you will
  25 ?S:     be able to use more than 2 gigabytes of memory.  This mode is
  26 ?S:     even more binary incompatible than USE_64_BIT_INT. You may not
  27 ?S:     be able to run the resulting executable in a 32-bit CPU at all or
  28 ?S:     you may need at least to reboot your OS to 64-bit mode.
  29 ?S:.
  30 ?S:archname64:
  31 ?S:     This variable is used for the 64-bitness part of $archname.
  32 ?S:.
  33 ?C:USE_64_BIT_INT:
  34 ?C:     This symbol, if defined, indicates that 64-bit integers should
  35 ?C:     be used when available.  If not defined, the native integers
  36 ?C:     will be employed (be they 32 or 64 bits).  The minimal possible
  37 ?C:     64-bitness is used, just enough to get 64-bit integers into Perl.
  38 ?C:     This may mean using for example "long longs", while your memory
  39 ?C:     may still be limited to 2 gigabytes.
  40 ?C:.
  41 ?C:USE_64_BIT_ALL:
  42 ?C:     This symbol, if defined, indicates that 64-bit integers should
  43 ?C:     be used when available.  If not defined, the native integers
  44 ?C:     will be used (be they 32 or 64 bits).  The maximal possible
  45 ?C:     64-bitness is employed: LP64 or ILP64, meaning that you will
  46 ?C:     be able to use more than 2 gigabytes of memory.  This mode is
  47 ?C:     even more binary incompatible than USE_64_BIT_INT. You may not
  48 ?C:     be able to run the resulting executable in a 32-bit CPU at all or
  49 ?C:     you may need at least to reboot your OS to 64-bit mode.
  50 ?C:.
  51 ?H:?%<:#ifndef USE_64_BIT_INT
  52 ?H:?%<:#$use64bitint    USE_64_BIT_INT          /**/
  53 ?H:?%<:#endif
  54 ?H:?%<:#ifndef USE_64_BIT_ALL
  55 ?H:?%<:#$use64bitall    USE_64_BIT_ALL          /**/
  56 ?H:?%<:#endif
  57 ?H:.
  58 ?INIT:archname64=''
  59 ?LINT:extern ccflags
  60 ?LINT:use usemorebits
  61 ?LINT:extern use64bits
  62 ?LINT:extern uselonglong
  63 ?LINT:extern uselonglongs
  64 ?LINT:extern use64bitints
  65 ?LINT:extern use64bitsint
  66 ?LINT:extern use64bitsall
  67 ?T:libcquad
  68 ?F:!try
  69 ?F:!use64bitint.cbu
  70 ?F:!use64bitall.cbu
  71 : Do we want 64bit support
  72 case "$uselonglong" in
  73 "$define"|true|[yY]*)
  74         cat <<EOM >&4
  75
  76 *** Configure -Duselonglong is deprecated, using -Duse64bitint instead.
  77 EOM
  78         use64bitint="$define"
  79         ;;
  80 esac
  81 case "$use64bits" in
  82 "$define"|true|[yY]*)
  83         cat <<EOM >&4
  84
  85 *** Configure -Duse64bits is deprecated, using -Duse64bitint instead.
  86 EOM
  87         use64bitint="$define"
  88         ;;
  89 esac
  90 case "$use64bitints" in
  91 "$define"|true|[yY]*)
  92         cat <<EOM >&4
  93
  94 *** There is no Configure -Duse64bitints, using -Duse64bitint instead.
  95 EOM
  96         use64bitint="$define"
  97         ;;
  98 esac
  99 case "$use64bitsint" in
 100 "$define"|true|[yY]*)
 101         cat <<EOM >&4
 102
 103 *** There is no Configure -Duse64bitsint, using -Duse64bitint instead.
 104 EOM
 105         use64bitint="$define"
 106         ;;
 107 esac
 108 case "$uselonglongs" in
 109 "$define"|true|[yY]*)
 110         cat <<EOM >&4
 111
 112 *** There is no Configure -Duselonglongs, using -Duse64bitint instead.
 113 EOM
 114         use64bitint="$define"
 115         ;;
 116 esac
 117 case "$use64bitsall" in
 118 "$define"|true|[yY]*)
 119         cat <<EOM >&4
 120
 121 *** There is no Configure -Duse64bitsall, using -Duse64bitall instead.
 122 EOM
 123         use64bitall="$define"
 124         ;;
 125 esac
 126
 127 case "$ccflags" in
 128 *-DUSE_LONG_LONG*|*-DUSE_64_BIT_INT*|*-DUSE_64_BIT_ALL*) use64bitint="$define";;
 129 esac
 130 case "$use64bitall" in
 131 "$define"|true|[yY]*) use64bitint="$define" ;;
 132 esac
 133
 134 case "$longsize" in
 135 8) cat <<EOM
 136
 137 You have natively 64-bit long integers.
 138 EOM
 139    val="$define"
 140    ;;
 141 *) case "$use64bitint" in
 142    "$define"|true|[yY]*) dflt='y';;
 143    *) dflt='n';;
 144    esac
 145    case "$d_quad" in
 146    "$define") ;;
 147    *) dflt='n' ;;
 148    esac
 149    cat <<EOM
 150
 151 Perl can be built to take advantage of 64-bit integer types
 152 on some systems.  To do so, Configure can be run with -Duse64bitint.
 153 Choosing this option will most probably introduce binary incompatibilities.
 154
 155 If this doesn't make any sense to you, just accept the default '$dflt'.
 156 (The default has been chosen based on your configuration.)
 157 EOM
 158    rp='Try to use 64-bit integers, if available?'
 159    . ./myread
 160    case "$ans" in
 161    [yY]*) val="$define" ;;
 162    *)     val="$undef"  ;;
 163    esac
 164    ;;
 165 esac
 166 set use64bitint
 167 eval $setvar
 168
 169 case "$use64bitall" in
 170 "$define"|true|[yY]*) dflt='y' ;;
 171 *) case "$longsize" in
 172    8) dflt='y' ;;
 173    *) dflt='n' ;;
 174    esac
 175    ;;
 176 esac
 177 cat <<EOM
 178
 179 You may also choose to try maximal 64-bitness.  It means using as much
 180 64-bitness as possible on the platform.  This in turn means even more
 181 binary incompatibilities.  On the other hand, your platform may not
 182 have any more 64-bitness available than what you already have chosen.
 183
 184 If this doesn't make any sense to you, just accept the default '$dflt'.
 185 (The default has been chosen based on your configuration.)
 186 EOM
 187 rp='Try to use maximal 64-bit support, if available?'
 188 . ./myread
 189 case "$ans" in
 190 [yY]*) val="$define" ;;
 191 *)     val="$undef"  ;;
 192 esac
 193 set use64bitall
 194 eval $setvar
 195 case "$use64bitall" in
 196 "$define")
 197         case "$use64bitint" in
 198         "$undef")
 199                 cat <<EOM
 200
 201 Since you have chosen a maximally 64-bit build, I'm also turning on
 202 the use of 64-bit integers.
 203 EOM
 204                 use64bitint="$define" ;;
 205         esac
 206         ;;
 207 esac
 208
 209 : Look for a hint-file generated 'call-back-unit'.  If the
 210 : user has specified that a 64-bit perl is to be built,
 211 : we may need to set or change some other defaults.
 212 if $test -f use64bitint.cbu; then
 213         echo "Your platform has some specific hints regarding 64-bit integers, using them..."
 214         . ./use64bitint.cbu
 215 fi
 216 case "$use64bitint" in
 217 "$define"|true|[yY]*)
 218         : This test was common to all the OpenBSD forks, and seems harmless for
 219         : other platforms:
 220         echo " "
 221         echo "Checking if your C library has broken 64-bit functions..." >&4
 222         cat >try.c <<EOCP
 223 #include <stdio.h>
 224 typedef $uquadtype myULL;
 225 int main (void)
 226 {
 227     struct {
 228         double d;
 229         myULL  u;
 230     } *p, test[] = {
 231         {4294967303.15, 4294967303ULL},
 232         {4294967294.2,  4294967294ULL},
 233         {4294967295.7,  4294967295ULL},
 234         {0.0, 0ULL}
 235     };
 236     for (p = test; p->u; p++) {
 237         myULL x = (myULL)p->d;
 238         if (x != p->u) {
 239             printf("buggy\n");
 240             return 0;
 241         }
 242     }
 243     printf("ok\n");
 244     return 0;
 245 }
 246 EOCP
 247         set try
 248         if eval $compile_ok; then
 249             libcquad=`$run ./try`
 250             echo "Your C library's 64-bit functions are $libcquad."
 251         else
 252             echo "(I can't seem to compile the test program.)"
 253             echo "Assuming that your C library's 64-bit functions are ok."
 254             libcquad="ok"
 255         fi
 256         $rm_try
 257
 258         case "$libcquad" in
 259             buggy*)
 260                 cat >&4 <<EOM
 261
 262 *** You have a C library with broken 64-bit functions.
 263 *** 64-bit support does not work reliably in this configuration.
 264 *** Please rerun Configure without -Duse64bitint and/or -Dusemorebits.
 265 *** Cannot continue, aborting.
 266
 267 EOM
 268                 exit 1
 269                 ;;
 270         esac
 271         case "$longsize" in
 272         4) case "$archname64" in
 273            '') archname64=64int ;;
 274            esac
 275            ;;
 276         esac
 277         ;;
 278 esac
 279
 280 : Look for a hint-file generated 'call-back-unit'.  If the
 281 : user has specified that a maximally 64-bit perl is to be built,
 282 : we may need to set or change some other defaults.
 283 if $test -f use64bitall.cbu; then
 284         echo "Your platform has some specific hints regarding 64-bit builds, using them..."
 285         . ./use64bitall.cbu
 286 fi
 287 case "$use64bitall" in
 288 "$define"|true|[yY]*)
 289         case "$longsize" in
 290         4) case "$archname64" in
 291            ''|64int) archname64=64all ;;
 292            esac
 293            ;;
 294         esac
 295         ;;
 296 esac
 297
 298 case "$d_quad:$use64bitint" in
 299 $undef:$define)
 300         cat >&4 <<EOF
 301
 302 *** You have chosen to use 64-bit integers,
 303 *** but none can be found.
 304 *** Please rerun Configure without -Duse64bitint and/or -Dusemorebits.
 305 *** Cannot continue, aborting.
 306
 307 EOF
 308         exit 1
 309         ;;
 310 esac
 311