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         uselargefiles usemorebits longsize ccflags
  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:.
  55 ?H:?%<:#ifndef USE_64_BIT_ALL
  56 ?H:?%<:#$use64bitall    USE_64_BIT_ALL          /**/
  57 ?H:?%<:#endif
  58 ?H:.
  59 ?LINT:set use64bitint
  60 ?LINT:extern ccflags
  61 ?LINT:change ccflags
  62 ?LINT:use uselargefiles
  63 ?LINT:use usemorebits
  64 ?LINT:extern uselonglong
  65 ?LINT:use uselonglong
  66 ?LINT:set use64bitall
  67 ?F:!use64bitint.cbu
  68 ?F:!use64bitall.cbu
  69
  70 # Backward compatibility (uselonglong is deprecated).
  71 case "$uselonglong" in
  72 "$define"|true|[yY]*)
  73         cat <<EOM >&4
  74
  75 *** Configure -Duselonglong is deprecated, using -Duse64bitint instead.
  76 EOM
  77         use64bitint="$define"
  78         ;;
  79 esac
  80 # Backward compatibility (use64bits is deprecated).
  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 # Thinko compatibility
  91 case "$use64bitints" in
  92 "$define"|true|[yY]*)
  93         cat <<EOM >&4
  94
  95 *** There is no Configure -Duse64bitints, using -Duse64bitint instead.
  96 EOM
  97         use64bitint="$define"
  98         ;;
  99 esac
 100
 101 case "$ccflags" in
 102 *-DUSE_LONG_LONG*|*-DUSE_64_BIT_INT*|*-DUSE_64_BIT_ALL*) use64bitint="$define";;
 103 esac
 104 case "$use64bitall" in
 105 "$define"|true|[yY]*) use64bitint="$define" ;;
 106 esac
 107
 108 case "$longsize" in
 109 8) cat <<EOM
 110
 111 You have natively 64-bit long integers.
 112 EOM
 113    val="$define"
 114    ;;
 115 *) case "$use64bitint" in
 116    "$define"|true|[yY]*) dflt='y';;
 117    *) dflt='n';;
 118    esac
 119    cat <<EOM
 120
 121 Perl can be built to take advantage of 64-bit integer types
 122 on some systems.  To do so, Configure can be run with -Duse64bitint.
 123 Choosing this option will most probably introduce binary incompatibilities.
 124
 125 If this doesn't make any sense to you, just accept the default '$dflt'.
 126 EOM
 127    rp='Try to use 64-bit integers, if available?'
 128    . ./myread
 129    case "$ans" in
 130    [yY]*) val="$define" ;;
 131    *)     val="$undef"  ;;
 132    esac
 133    ;;
 134 esac
 135 set use64bitint
 136 eval $setvar
 137
 138 case "$use64bitint" in
 139 "$define")      case "$longsize" in
 140                 8) dflt='y' ;;
 141                 *) dflt='n' ;;
 142                 esac
 143                 ;;
 144 *)      case "$use64bitall" in
 145         "$define"|true|[yY]*) dflt='y' ;;
 146         *) dflt='n' ;;
 147         esac
 148         ;;
 149 esac
 150 cat <<EOM
 151
 152 You may also choose to try maximal 64-bitness.  It means using as much
 153 64-bitness as possible on the platform.  This in turn means even more
 154 binary incompatibilities.  On the other hand, your platform may not
 155 have any more 64-bitness available than what you already have chosen.
 156
 157 If this doesn't make any sense to you, just accept the default '$dflt'.
 158 EOM
 159 rp='Try to use maximal 64-bit support, if available?'
 160 . ./myread
 161 case "$ans" in
 162 [yY]*) val="$define" ;;
 163 *)     val="$undef"  ;;
 164 esac
 165 set use64bitall
 166 eval $setvar
 167 case "$use64bitall" in
 168 "$define")
 169         case "$use64bitint" in
 170         "$undef")
 171                 cat <<EOM
 172
 173 Since you have chosen a maximally 64-bit build, I'm also turning on
 174 the use of 64-bit integers.
 175 EOM
 176                 use64bitint="$define" ;;
 177         esac
 178         ;;
 179 esac
 180
 181 case "$use64bitint" in
 182 "$define"|true|[yY]*)
 183 : Look for a hint-file generated 'call-back-unit'.  If the
 184 : user has specified that a 64-bit perl is to be built,
 185 : we may need to set or change some other defaults.
 186         if $test -f use64bitint.cbu; then
 187                 echo "Your platform has some specific hints for 64-bit integers, using them..."
 188                 . ./use64bitint.cbu
 189         fi
 190         case "$longsize" in
 191         4) case "$ccflags" in
 192            *-DUSE_64_BIT_INT*) ;;
 193            *) ccflags="$ccflags -DUSE_64_BIT_INT";;
 194            esac
 195            case "$archname64" in
 196            '') archname64=64int ;;
 197            esac
 198            ;;
 199         esac
 200         ;;
 201 esac
 202
 203 case "$use64bitall" in
 204 "$define"|true|[yY]*)
 205 : Look for a hint-file generated 'call-back-unit'.  If the
 206 : user has specified that a maximally 64-bit perl is to be built,
 207 : we may need to set or change some other defaults.
 208         if $test -f use64bitall.cbu; then
 209                 echo "Your platform has some specific hints for 64-bit builds, using them..."
 210                 . ./use64bitall.cbu
 211         fi
 212         case "$longsize" in
 213         4) case "$ccflags" in
 214            *-DUSE_64_BIT_ALL*) ;;
 215            *) ccflags="$ccflags -DUSE_64_BIT_ALL";;
 216            esac
 217            case "$archname64" in
 218            ''|64int) archname64=64all ;;
 219            esac
 220            ;;
 221         esac
 222         ;;
 223 esac
 224