This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Move the thrice-repeated "64bitint is buggy?" test from hints to Configure.
[metaconfig.git] / 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
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=`./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