?RCS: Revision 3.0 1993/08/18 12:08:52 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:intsize longsize shortsize: Compile Myread cat rm run i_stdlib
+?MAKE:intsize longsize shortsize: Compile Myread cat run i_stdlib rm_try
?MAKE: -pick add $@ %<
?S:intsize:
?S: This variable contains the value of the INTSIZE symbol, which
fi
;;
esac
-$rm -f try try.*
+$rm_try
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
?MAKE:Csym mistrustnm: Options contains libc libs runnm test \
- +cc +optimize +ccflags +ldflags run rm _exe d_cplusplus
+ +cc +optimize +ccflags +ldflags run rm_try _exe d_cplusplus
?MAKE: -pick add $@ %<
?LINT:define csym
?LINT:use libc
echo "extern $extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main() { if(p()) return(0); else return(1); }"> try.c;
$cc -o try $optimize $ccflags $ldflags try.c >/dev/null 2>&1 $libs && tval=true;
$test "$mistrustnm" = run -a -x try && { $run ./try$_exe >/dev/null 2>&1 || tval=false; };
- $rm -f try$_exe try.c core core.* try.core;
+ $rm_try;
fi;
else
echo "extern $extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main() { if(p()) return(0); else return(1); }"> try.c;
$cc -o try $optimize $ccflags $ldflags try.c $libs >/dev/null 2>&1 && tval=true;
- $rm -f try$_exe try.c;
+ $rm_try;
fi;
;;
*)
?RCS: Revision 3.0 1993/08/18 12:05:23 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:alignbytes: Myread Compile cat rm usecrosscompile multiarch run \
- d_longdbl uselongdouble test
+?MAKE:alignbytes: Myread Compile cat rm_try usecrosscompile multiarch run \
+ d_longdbl uselongdouble test
?MAKE: -pick add $@ %<
?S:alignbytes:
?S: This variable holds the number of bytes required to align a
rp="Doubles must be aligned on a how-many-byte boundary?"
. ./myread
alignbytes="$ans"
- $rm -f try.c try
+ $rm_try
;;
esac
?RCS: Revision 3.0 1993/08/18 12:05:28 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:byteorder: cat Myread Oldconfig Loc Compile rm run \
+?MAKE:byteorder: cat Myread Oldconfig Loc Compile rm_try run \
usecrosscompile multiarch uvtype uvsize i_stdlib
?MAKE: -pick add $@ %<
?S:byteorder:
?C: On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture
?C: Binaries (MAB) on either big endian or little endian machines.
?C: The endian-ness is available at compile-time. This only matters
-?C: for perl, where the config.h can be generated and installed on
+?C: for perl, where the config.h can be generated and installed on
?C: one system, and used by a different architecture to build an
?C: extension. Older versions of NeXT that might not have
?C: defined either *_ENDIAN__ were all on Motorola 680x0 series,
-?C: so the default case (for NeXT) is big endian to catch them.
+?C: so the default case (for NeXT) is big endian to catch them.
?C: This might matter for NeXT 3.0.
?C:.
?H:?%<:#if defined(USE_CROSS_COMPILE) || defined(MULTIARCH)
esac
;;
esac
- $rm -f try.c try
+ $rm_try
;;
esac
-
?MAKE:ccflags ldflags lkflags cppflags optimize locincpth: test cat \
Myread Guess Options Oldconfig +gccversion mips_type +usrinc \
package contains rm +cc cppstdin cppminus cpprun cpplast libpth \
- libs loclibpth hint usesocks sh run
+ libs loclibpth hint usesocks sh run rm_try
?MAKE: -pick add $@ %<
?S:ccflags:
?S: This variable contains any additional C compiler flags desired by
;;
n) echo "OK, that should do.";;
esac
-$rm -f try try.* core
+$rm_try
?RCS: Revision 3.0 1993/08/18 12:05:34 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:charsize: cat rm Myread Compile run i_stdlib
+?MAKE:charsize: cat rm_try Myread Compile run i_stdlib
?MAKE: -pick add $@ %<
?S:charsize:
?S: This variable contains the value of the CHARSIZE symbol, which
rp="What is the size of a character (in bytes)?"
. ./myread
charsize="$ans"
-$rm -f try.c try
+$rm_try
?X:
?X: Can the compiler cast large floats to 32-bit integers?
?X:
-?MAKE:d_casti32: cat Compile rm intsize Setvar test signal_t run i_stdlib
+?MAKE:d_casti32: cat Compile rm_try intsize Setvar test signal_t run i_stdlib
?MAKE: -pick add $@ %<
?S:d_casti32:
?S: This variable conditionally defines CASTI32, which indicates
char str[16];
signal(SIGFPE, blech);
- /* Don't let compiler optimize the test away. Store the number
+ /* Don't let compiler optimize the test away. Store the number
in a writable string for gcc to pass to sscanf under HP/UX.
*/
sprintf(str, "2147483647");
esac
set d_casti32
eval $setvar
-$rm -f try try.*
+$rm_try
?X:
?X: Can the compiler cast negative / odd floats to unsigned values.
?X:
-?MAKE:d_castneg castflags: cat Compile rm Setvar signal_t run i_stdlib
+?MAKE:d_castneg castflags: cat Compile rm_try Setvar signal_t run i_stdlib
?MAKE: -pick add $@ %<
?S:d_castneg:
?S: This variable conditionally defines CASTNEG, which indicates
unsigned short ashort;
int result = 0;
char str[16];
-
+
/* Frustrate gcc-2.7.2's optimizer which failed this test with
a direct f = -123. assignment. gcc-2.8.0 reportedly
optimized the whole file away
*/
- /* Store the number in a writable string for gcc to pass to
+ /* Store the number in a writable string for gcc to pass to
sscanf under HP/UX.
*/
sprintf(str, "-123");
esac
set d_castneg
eval $setvar
-$rm -f try try.*
+$rm_try
?RCS: patch32: created by ADO
?RCS:
?MAKE:d_closedir d_void_closedir: Inlibc i_dirent i_sysdir i_sysndir \
- i_systypes Compile Setvar rm run
+ i_systypes Compile Setvar rm_try run
?MAKE: -pick add $@ %<
?S:d_closedir:
?S: This variable conditionally defines HAS_CLOSEDIR if closedir() is
#endif
#endif
#endif
-#endif
+#endif
int main() { return closedir(opendir(".")); }
EOM
set try
esac
set d_void_closedir
eval $setvar
-$rm -f try try.*
+$rm_try
@end
+
?RCS: Revision 3.0 1993/08/18 12:06:02 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_fd_set d_fd_macros d_fds_bits: Compile cat rm Oldconfig \
+?MAKE:d_fd_set d_fd_macros d_fds_bits: Compile cat rm_try Oldconfig \
d_socket i_systime i_sysselct i_stdlib run
?MAKE: -pick add $@ %<
?S:d_fd_set:
d_fd_macros="$undef"
fi
fi
-$rm -f try try.*
+$rm_try
?RCS: patch36: created by ADO
?RCS:
?MAKE:d_Gconvert: \
- Compile cat Inlibc rm _o i_stdlib d_qgcvt run \
+ Compile cat Inlibc rm_try i_stdlib d_qgcvt run \
uselongdouble d_longdbl d_PRIgldbl sPRIgldbl
?MAKE: -pick add $@ %<
?S:d_Gconvert:
?S: long doubles, the macro uses the first of the following
?S: functions that pass Configure's tests: qgcvt, sprintf (if
?S: Configure knows how to make sprintf format long doubles--see
-?S: sPRIgldbl), gconvert, gcvt, and sprintf (casting to double).
-?S: The gconvert_preference and gconvert_ld_preference variables
+?S: sPRIgldbl), gconvert, gcvt, and sprintf (casting to double).
+?S: The gconvert_preference and gconvert_ld_preference variables
?S: can be used to alter Configure's preferences, for doubles and
-?S: long doubles, respectively. If present, they contain a
-?S: space-separated list of one or more of the above function
+?S: long doubles, respectively. If present, they contain a
+?S: space-separated list of one or more of the above function
?S: names in the order they should be tried.
?S:
?S: d_Gconvert may be set to override Configure with a platform-
?T: xxx_list xxx_convert xxx_ld_list
?LINT:extern gconvert_preference
?LINT:extern gconvert_ld_preference
-?X:
: Check how to convert floats to strings.
if test "X$d_Gconvert" = X; then
}
int main()
-{
- char buf[64];
+{
+ char buf[64];
buf[63] = '\0';
/* This must be 1st test on (which?) platform */
Gconvert((DOUBLETYPE)0.1, 8, 0, buf);
checkit("0.1", buf);
- Gconvert((DOUBLETYPE)0.01, 8, 0, buf);
+ Gconvert((DOUBLETYPE)0.01, 8, 0, buf);
checkit("0.01", buf);
- Gconvert((DOUBLETYPE)0.001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)0.001, 8, 0, buf);
checkit("0.001", buf);
- Gconvert((DOUBLETYPE)0.0001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)0.0001, 8, 0, buf);
checkit("0.0001", buf);
Gconvert((DOUBLETYPE)0.00009, 8, 0, buf);
else
checkit("9e-05", buf);
- Gconvert((DOUBLETYPE)1.0, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.0, 8, 0, buf);
checkit("1", buf);
- Gconvert((DOUBLETYPE)1.1, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.1, 8, 0, buf);
checkit("1.1", buf);
- Gconvert((DOUBLETYPE)1.01, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.01, 8, 0, buf);
checkit("1.01", buf);
- Gconvert((DOUBLETYPE)1.001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.001, 8, 0, buf);
checkit("1.001", buf);
- Gconvert((DOUBLETYPE)1.0001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.0001, 8, 0, buf);
checkit("1.0001", buf);
- Gconvert((DOUBLETYPE)1.00001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.00001, 8, 0, buf);
checkit("1.00001", buf);
- Gconvert((DOUBLETYPE)1.000001, 8, 0, buf);
+ Gconvert((DOUBLETYPE)1.000001, 8, 0, buf);
checkit("1.000001", buf);
- Gconvert((DOUBLETYPE)0.0, 8, 0, buf);
+ Gconvert((DOUBLETYPE)0.0, 8, 0, buf);
checkit("0", buf);
- Gconvert((DOUBLETYPE)-1.0, 8, 0, buf);
+ Gconvert((DOUBLETYPE)-1.0, 8, 0, buf);
checkit("-1", buf);
/* Some Linux gcvt's give 1.e+5 here. */
- Gconvert((DOUBLETYPE)100000.0, 8, 0, buf);
+ Gconvert((DOUBLETYPE)100000.0, 8, 0, buf);
checkit("100000", buf);
-
+
/* Some Linux gcvt's give -1.e+5 here. */
- Gconvert((DOUBLETYPE)-100000.0, 8, 0, buf);
+ Gconvert((DOUBLETYPE)-100000.0, 8, 0, buf);
checkit("-100000", buf);
- Gconvert((DOUBLETYPE)123.456, 8, 0, buf);
+ Gconvert((DOUBLETYPE)123.456, 8, 0, buf);
checkit("123.456", buf);
/* Testing of 1e+129 in bigintpm.t must not get extra '.' here. */
case $xxx_convert in
gcvt|gconvert|sprintf) xxx_list="$xxx_list $xxx_convert" ;;
*) echo "Discarding unrecognized gconvert_preference $xxx_convert" >&4 ;;
- esac
+ esac
done
: then add any others
for xxx_convert in gconvert gcvt sprintf; do
case "$xxx_list" in
*$xxx_convert*) ;;
*) xxx_list="$xxx_list $xxx_convert" ;;
- esac
+ esac
done
case "$d_longdbl$uselongdouble" in
for xxx_convert in $xxx_list; do
echo "Trying $xxx_convert..."
- $rm -f try try$_o
+ $rm_try
set try -DTRY_$xxx_convert
if eval $compile; then
echo "$xxx_convert() found." >&4
d_Gconvert='sprintf((b),"%.*g",(n),(double)(x))' ;;
*) d_Gconvert='sprintf((b),"%.*g",(n),(x))' ;;
esac
- ;;
+ ;;
esac
fi
?RCS: Revision 3.0.1.1 1997/02/28 15:34:33 ram
?RCS: patch61: created
?RCS:
-?MAKE:d_gnulibc gnulibc_version: Myread Oldconfig Setvar rm \
+?MAKE:d_gnulibc gnulibc_version: Myread Oldconfig Setvar rm_try \
cat Compile run
?MAKE: -pick add $@ %<
?S:d_gnulibc:
?S: is not the GNU C library, or if the version is unknown.
?S:.
?C:HAS_GNULIBC:
-?C: This symbol, if defined, indicates to the C program that
+?C: This symbol, if defined, indicates to the C program that
?C: the GNU C library is being used. A better check is to use
?C: the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc.
?C:.
?X: #define __GLIBC__ 2
?X: #define__GLIBC_MINOR__ 0.
?X: (The '6' isn't available :-(.
-?X: glibc2.1 will also have
+?X: glibc2.1 will also have
?X: extern const char * __gnu_get_libc_release(void);
?X: extern const char * __gnu_get_libc_version(void);
?X: functions. --thanks to Andreas Jaeger. --AD 6/1998.
gnulibc_version=''
echo "You are not using the GNU C Library"
fi
-$rm -f try try.* glibc.ver
+$rm_try glibc.ver
set d_gnulibc
eval $setvar
?RCS: Revision 3.0 1993/08/18 12:06:44 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_open3: Compile test cat h_fcntl h_sysfile rm Setvar Findhdr run i_stdlib
+?MAKE:d_open3: Compile test cat h_fcntl h_sysfile rm_try Setvar Findhdr run i_stdlib
?MAKE: -pick add $@ %<
?X: It would be easy to separate the h_O_stuff from this.
?X: Is there a reason to do so? -- HMS
fi
set d_open3
eval $setvar
-$rm -f try try.*
+$rm_try
?RCS: Revision 3.0 1993/08/18 12:06:58 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_safebcpy: cat d_bcopy Compile rm run \
+?MAKE:d_safebcpy: cat d_bcopy Compile rm_try run \
d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar
?MAKE: -pick add $@ %<
?S:d_safebcpy:
fi
;;
esac
- $rm -f try.* try core
+ $rm_try
;;
esac
set d_safebcpy
?RCS: Revision 3.0 1993/08/18 12:06:58 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_safemcpy: Compile cat d_memcpy rm run \
+?MAKE:d_safemcpy: Compile cat d_memcpy rm_try run \
d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar
?MAKE: -pick add $@ %<
?S:d_safemcpy:
fi
;;
esac
- $rm -f try.* try core
+ $rm_try
;;
esac
set d_safemcpy
?RCS: patch61: created
?RCS:
?RCS:
-?MAKE:d_sanemcmp: Compile cat d_memcmp rm run \
+?MAKE:d_sanemcmp: Compile cat d_memcmp rm_try run \
i_memory i_stdlib i_string i_unistd Oldconfig Setvar
?MAKE: -pick add $@ %<
?S:d_sanemcmp:
fi
;;
esac
-$rm -f try.* try core
+$rm_try
set d_sanemcmp
eval $setvar
?RCS: patch61: created
?RCS:
?RCS:
-?MAKE:d_sigaction: Csym Compile Setvar cat rm _o i_stdlib
+?MAKE:d_sigaction: Csym Compile Setvar cat rm_try i_stdlib
?MAKE: -pick add $@ %<
?S:d_sigaction:
?S: This variable conditionally defines the HAS_SIGACTION symbol, which
val="$undef"
fi
set d_sigaction; eval $setvar
-$rm -f try try$_o try.c
+$rm_try
?RCS: Revision 3.0.1.1 1997/02/28 15:44:33 ram
?RCS: patch61: created
?RCS:
-?MAKE:d_sigsetjmp: Compile Setvar cat rm run i_stdlib
+?MAKE:d_sigsetjmp: Compile Setvar cat rm_try run i_stdlib
?MAKE: -pick add $@ %<
?S:d_sigsetjmp:
?S: This variable conditionally defines the HAS_SIGSETJMP symbol,
esac
set d_sigsetjmp
eval $setvar
-$rm -f try.c try
+$rm_try
?MAKE:d_stdstdio d_stdiobase stdio_ptr stdio_cnt \
d_stdio_ptr_lval_sets_cnt d_stdio_ptr_lval_nochange_cnt stdio_base \
stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf: cat \
- Compile contains rm d_gnulibc gnulibc_version i_stdlib \
+ Compile contains rm_try d_gnulibc gnulibc_version i_stdlib \
Setvar Findhdr Oldconfig run to
?MAKE: -pick weed $@ %<
?S:d_stdstdio:
else
echo "Your stdio doesn't appear very std."
fi
-$rm -f try.c try
+$rm_try
# glibc 2.2.90 and above apparently change stdio streams so Perl's
# direct buffer manipulation no longer works. The Configure tests
else
echo "Hmm. $filbuf doesn't seem to work."
fi
- $rm -f try.c try
+ $rm_try
done
case "$xxx" in
notok) echo "I can't figure out how to access _filbuf"
if (cnt == FILE_cnt(fp)) {
puts("Pass_unchanged");
exit (0);
- }
+ }
if (FILE_cnt(fp) == (cnt - 42)) {
puts("Pass_changed");
exit (0);
else
echo "It seems we can't set ptr in your stdio. Nevermind." >&4
fi
- $rm -f try.c try
+ $rm_try
;;
esac
@end
else
echo "However, it seems to be lacking the _base field."
fi
- $rm -f try.c try
+ $rm_try
;;
esac
set d_stdiobase
?RCS: Revision 3.0 1993/08/18 12:07:59 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_vprintf d_charvspr: Compile Guess cat Csym Setvar run rm i_stdlib
+?MAKE:d_vprintf d_charvspr: Compile Guess cat Csym Setvar run rm_try i_stdlib
?MAKE: -pick add $@ %<
?S:d_vprintf:
?S: This variable conditionally defines the HAS_VPRINTF symbol, which
val="$undef"
val2="$undef"
fi
-$rm -f try try.*
+$rm_try
set d_vprintf
eval $setvar
val=$val2
?RCS: Revision 3.0 1993/08/18 12:08:06 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:doublesize: cat rm Myread Compile run i_stdlib
+?MAKE:doublesize: cat rm_try Myread Compile run i_stdlib
?MAKE: -pick add $@ %<
?S:doublesize:
?S: This variable contains the value of the DOUBLESIZE symbol, which
fi
;;
esac
-$rm -f try.c try
+$rm_try
?X:
?MAKE:i_time i_systime i_systimek timeincl d_tm_tm_zone d_tm_tm_gmtoff: \
Compile cat \
- contains rm echo n c +i_sysselct Findhdr Hasfield i_stdlib
+ contains rm_try echo n c +i_sysselct Findhdr Hasfield i_stdlib
?MAKE: -pick add $@ %<
?S:i_time:
?S: This variable conditionally defines I_TIME, which indicates
esac
esac
@end
- $rm -f try.c try
+ $rm_try
fi
: see if struct tm knows about tm_zone
case "$i_systime$i_time" in
-*$define*)
+*$define*)
echo " "
echo "Checking to see if your struct tm has tm_zone field..." >&4
set d_tm_tm_zone tm tm_zone $i_systime sys/time.h $i_time time.h
esac
: see if struct tm knows about tm_gmtoff
case "$i_systime$i_time" in
-*$define*)
+*$define*)
echo " "
echo "Checking to see if your struct tm has tm_gmtoff field..." >&4
set d_tm_tm_gmtoff tm tm_gmtoff $i_systime sys/time.h $i_time time.h
?X: Simplify here document for shells that can't handle them well.
?X: (Problem reported on FreeBSD; it's unclear if this helps.) --AD
?X:
-?MAKE:o_nonblock eagain rd_nodata d_eofnblk: cat rm Compile run \
+?MAKE:o_nonblock eagain rd_nodata d_eofnblk: cat rm_try Compile run \
d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar \
startsh i_unistd i_string i_fcntl i_stdlib
?MAKE: -pick add $@ %<
;;
*) echo "Using $hint value $o_nonblock.";;
esac
-$rm -f try try.* .out core
+$rm_try
echo " "
echo "Let's see what value errno gets from read() on a $o_nonblock file..." >&4
#include <errno.h>
#include <sys/types.h>
#include <signal.h>
-#include <stdio.h>
+#include <stdio.h>
#$i_stdlib I_STDLIB
#ifdef I_STDLIB
#include <stdlib.h>
esac
;;
esac
-$rm -f try try.* .out core head.c mtry
+$rm_try head.c mtry
?RCS: Revision 3.0 1993/08/18 12:09:37 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:ptrsize: cat rm Myread Compile voidflags run use64bitall i_stdlib d_quad
+?MAKE:ptrsize: cat rm_try Myread Compile voidflags run use64bitall i_stdlib d_quad
?MAKE: -pick add $@ %<
?S:ptrsize:
?S: This variable contains the value of the PTRSIZE symbol, which
fi
;;
esac
-$rm -f try.c try
+$rm_try
case "$use64bitall" in
"$define"|true|[yY]*)
case "$ptrsize" in
?X: Andy Dougherty July 1998
?X:
?MAKE:randfunc drand01 seedfunc randbits randseedtype: \
- cat rm test i_stdlib i_unistd Compile Myread Csym ccflags
+ cat rm_try test i_stdlib i_unistd Compile Myread Csym ccflags
?MAKE: -pick add $@ %<
?S:randfunc:
?S: Indicates the name of the random number function to use.
?H:.
?T:cont val
?LINT:change ccflags
-
: How can we generate normalized random numbers ?
echo " "
echo "Looking for a random number function..." >&4
rp="How many bits does your $randfunc() function produce?"
. ./myread
randbits="$ans"
- $rm -f try.c try
+ $rm_try
drand01="($randfunc() / (double) ((unsigned long)1 << $randbits))"
seedfunc="s$randfunc"
randseedtype=unsigned
?RCS: Revision 3.0.1.1 1994/08/29 16:33:06 ram
?RCS: patch32: created by ADO
?RCS:
-?MAKE:ssizetype: Myread Typedef sizetype cat rm Compile run i_stdlib
+?MAKE:ssizetype: Myread Typedef sizetype cat rm_try Compile run i_stdlib
?MAKE: -pick add $@ %<
?S:ssizetype:
-?S: This variable defines ssizetype to be something like ssize_t,
-?S: long or int. It is used by functions that return a count
+?S: This variable defines ssizetype to be something like ssize_t,
+?S: long or int. It is used by functions that return a count
?S: of bytes or an error condition. It must be a signed type.
?S: We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).
?S:.
printf("$dflt\n");
else if (sizeof(Size_t) == sizeof(int))
printf("int\n");
- else
+ else
printf("long\n");
exit(0);
}
. ./myread
ssizetype="$ans"
fi
-$rm -f try try.*
+$rm_try
?RCS: Original author Jarkko Hietaniemi <jhi@iki.fi>
?RCS: Merged into dist by Andy Dougherty July 13, 1998
?RCS:
-?MAKE:ebcdic: Compile Setvar cat rm run
+?MAKE:ebcdic: Compile Setvar cat rm_try run
?MAKE: -pick add $@ %<
?S:ebcdic:
?S: This variable conditionally defines EBCDIC if this
echo "I'm unable to compile the test program." >&4
echo "I'll assume ASCII or some ISO Latin. Or UTF8." >&4
fi
-$rm -f try try.*
+$rm_try
set ebcdic
eval $setvar
?RCS: Revision 3.0 1993/08/18 12:04:50 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?X:
?X: This unit produces a shell script called Cppsym, which can be used to
?X: determine whether any in a list of symbols is defined by the C compilation
?X: chain (C preprocessor symbols plus C compiler native ones).
?X: It can determine the status of any symbol, though the symbols in $al
?X: are more easily determined. If you want to add to $al you can do
?X: it in Myinit.U.
-?X:
?MAKE:Cppsym ccsymbols cppsymbols cppccsymbols: run \
- eunicefix Guess awk cat tr sed sort rm startsh osname \
+ eunicefix Guess awk cat tr sed sort rm rm_try startsh osname \
+cc +gccversion test comm uniq echo Options trnl \
optimize ccflags ldflags libs cpp_stuff
?MAKE: -pick add $@ %<
-A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A//' | $sed 's/\(.*\)(\(.*\))/\1=\2/';;
esac
done
-$rm -f try.c
+$rm_try
EOS
postprocess_cc_v=''
chmod +x ccsym
?X: files.
?X:
?MAKE:Unix _exe _a _o exe_ext lib_ext obj_ext path_sep \
- firstmakefile archobjs: Oldconfig
+ firstmakefile archobjs rm_try: Oldconfig rm
?MAKE: -pick add $@ %<
?S:_exe:
?S: This variable defines the extension used for executable files.
?S: This is an old synonym for p_ in Head.U, the character
?S: used to separate elements in the command shell search PATH.
?S:.
+?S:rm_try:
+?S: This is a cleanup variable for try test programs.
+?S: Internal Configure use only.
+?S:.
?LINT: change _a _exe _o p_
?INIT:: Trailing extension. Override this in a hint file, if needed.
?INIT:: Extra object files, if any, needed on this platform.
obj_ext=$_o
path_sep=$p_
+rm_try="$rm -f try try$_exe a.out .out try.[cho] try.$_o core core.try* try.core*"
+
@if firstmakefile
: Which makefile gets called first. This is used by make depend.
case "$firstmakefile" in
?RCS: Revision 3.0 1993/08/18 12:06:15 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_getpgrp d_bsdgetpgrp: Guess Inlibc Setvar cat rm \
+?MAKE:d_getpgrp d_bsdgetpgrp: Guess Inlibc Setvar cat rm_try \
+cc +ccflags +ldflags +libs i_unistd i_stdlib run
?MAKE: -pick add $@ %<
?S:d_getpgrp:
esac
set d_bsdgetpgrp
eval $setvar
-$rm -f try try.*
+$rm_try
@end
?RCS: $Log: d_longdbl.U,v $
?RCS:
?MAKE:d_longdbl longdblsize: Compile Setvar Myread run \
- cat rm test doublesize
+ cat rm_try test doublesize
?MAKE: -pick add $@ %<
?S:d_longdbl:
-?S: This variable conditionally defines HAS_LONG_DOUBLE if
+?S: This variable conditionally defines HAS_LONG_DOUBLE if
?S: the long double type is supported.
?S:.
?S:longdblsize:
?C: doubles.
?C:.
?C:LONG_DOUBLESIZE:
-?C: This symbol contains the size of a long double, so that the
+?C: This symbol contains the size of a long double, so that the
?C: C preprocessor can make decisions based on it. It is only
?C: defined if the system supports long doubles.
?C:.
val="$undef"
echo "You do not have long double."
fi
-$rm try.*
+$rm_try
set d_longdbl
eval $setvar
echo "That isn't any different from an ordinary double."
echo "I'll keep your setting anyway, but you may see some"
echo "harmless compilation warnings."
- fi
+ fi
;;
esac
-$rm -f try.* try
+$rm_try
@end
?RCS: $Log: d_longlong.U,v $
?RCS:
?MAKE:d_longlong longlongsize: Compile Setvar Myread run \
- cat rm test longsize
+ cat rm_try test longsize
?MAKE: -pick add $@ %<
?S:d_longlong:
-?S: This variable conditionally defines HAS_LONG_LONG if
+?S: This variable conditionally defines HAS_LONG_LONG if
?S: the long long type is supported.
?S:.
?S:longlongsize:
?C: This symbol will be defined if the C compiler supports long long.
?C:.
?C:LONGLONGSIZE:
-?C: This symbol contains the size of a long long, so that the
+?C: This symbol contains the size of a long long, so that the
?C: C preprocessor can make decisions based on it. It is only
?C: defined if the system supports long long.
?C:.
val="$undef"
echo "You do not have long long."
fi
-$rm try.*
+$rm_try
set d_longlong
eval $setvar
fi
if $test "X$longsize" = "X$longlongsize"; then
echo "(That isn't any different from an ordinary long.)"
- fi
+ fi
;;
esac
-$rm -f try.* try
+$rm_try
@end
?RCS: Revision 3.0 1993/08/18 12:07:09 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_setpgrp d_bsdsetpgrp: cat rm +cc +libs +ccflags \
+?MAKE:d_setpgrp d_bsdsetpgrp: cat rm_try +cc +libs +ccflags \
+ldflags Inlibc Guess Setvar i_unistd i_stdlib run
?MAKE: -pick add $@ %<
?S:d_setpgrp:
esac
set d_bsdsetpgrp
eval $setvar
-$rm -f try try.*
+$rm_try
@end
+
d_msg_ctrunc d_msg_dontroute d_msg_oob d_msg_peek d_msg_proxy \
d_scm_rights: \
contains libc echo n c ar nm nm_opt nm_extract Inlibc Csym _a \
- Compile cat rm Setvar Hasfield
+ Compile cat rm_try Setvar Hasfield
?MAKE: -pick add $@ %<
?S:d_socket:
?S: This variable conditionally defines HAS_SOCKET, which indicates
sockethdr="-I/usr/netinclude"
;;
esac
- echo "Found Berkeley sockets interface in lib$net." >&4
+ echo "Found Berkeley sockets interface in lib$net." >&4
?X: now check for advanced features
if $contains setsockopt libc.list >/dev/null 2>&1; then
d_oldsock="$undef"
val="$define"
fi
set d_${enum}; eval $setvar
- $rm -f try.c try
+ $rm_try
done
?RCS: Revision 3.0 1993/08/18 12:07:34 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_strctcpy: cat rm cc Setvar
+?MAKE:d_strctcpy: cat rm_try cc Setvar
?MAKE: -pick add $@ %<
?S:d_strctcpy:
?S: This variable conditionally defines the USE_STRUCT_COPY symbol, which
fi
set d_strctcpy
eval $setvar
-$rm -f try try.*
+$rm_try
?RCS: $Log: d_union_semun.U,v $
?RCS:
?MAKE:d_union_semun d_semctl_semun d_semctl_semid_ds: Compile Setvar Myread run \
- cat rm d_sem
+ cat rm_try d_sem
?MAKE: -pick add $@ %<
?S:d_union_semun:
?S: This variable conditionally defines HAS_UNION_SEMUN if the
echo "You do not have union semun in <sys/sem.h>." >&4
val="$undef"
fi
-$rm -f try try.c
+$rm_try
set d_union_semun
eval $setvar
semun) val="$define" ;;
esac
fi
- $rm -f try try.c
+ $rm_try
set d_semctl_semun
eval $setvar
;;
semid_ds) val="$define" ;;
esac
fi
- $rm -f try try.c
+ $rm_try
set d_semctl_semid_ds
eval $setvar
;;
*) echo "You cannot use struct semid_ds* for semctl IPC_STAT." >&4
;;
esac
- $rm -f try.h
+ $rm_try
;;
*) val="$undef"
?RCS: Revision 3.0 1993/08/18 12:07:57 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:d_volatile: cat +cc +ccflags rm Setvar
+?MAKE:d_volatile: cat +cc +ccflags rm_try Setvar
?MAKE: -pick add $@ %<
?S:d_volatile:
?S: This variable conditionally defines the HASVOLATILE symbol, which
fi
set d_volatile
eval $setvar
-$rm -f try try.*
+$rm_try
?X: This unit looks whether there is a dirent system or not
?X:
?MAKE:i_dirent d_dirnamlen direntrytype: test contains Setvar \
- Myread Findhdr cppstdin cppflags cppminus rm
+ Myread Findhdr cppstdin cppflags cppminus rm_try
?MAKE: -pick add $@ %<
?S:i_dirent:
?S: This variable conditionally defines I_DIRENT, which indicates
set i_dirent
eval $setvar
-?X: Use struct dirent or struct direct? If we're using dirent.h,
+?X: Use struct dirent or struct direct? If we're using dirent.h,
?X: it's probably struct dirent, but apparently not always.
?X: Assume $xinc still contains the name of the header file we're using.
@if direntrytype || Direntry_t
'struct dirent') guess2='struct direct' ;;
*) guess2='struct dirent' ;;
esac
-
+
if $contains "$guess1" try.c >/dev/null 2>&1; then
direntrytype="$guess1"
echo "Your directory entries are $direntrytype." >&4
. ./myread
direntrytype="$ans"
fi
-$rm -f try try.c
+$rm_try
@end
-
@if d_dirnamlen || DIRNAMLEN
: see if the directory entry stores field length
echo " "
fi
set d_dirnamlen
eval $setvar
-$rm -f try try.c
+$rm_try
@end
?RCS: Revision 3.0 1993/08/18 12:08:21 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:i_malloc: cat rm Compile Setvar
+?MAKE:i_malloc: cat rm_try Compile Setvar
?MAKE: -pick add $@ %<
?S:i_malloc:
?S: This variable conditionally defines the I_MALLOC symbol, and indicates
echo "<malloc.h> NOT found." >&4
val="$undef"
fi
-$rm -f try.c try
+$rm_try
set i_malloc
eval $setvar
--- /dev/null
+?RCS: $Id: i_neterrno.U,v 3.0.1.3 1994/10/29 16:20:29 ram Exp $
+?RCS:
+?RCS: Copyright (c) 1991-1993, Raphael Manfredi
+?RCS:
+?RCS: You may redistribute only under the terms of the Artistic Licence,
+?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 Licence; a copy of which may be found at the root
+?RCS: of the source tree for dist 3.0.
+?RCS:
+?RCS: Original Author: Andy Dougherty <doughera@lafcol.lafayette.edu>
+?RCS:
+?RCS: $Log: i_neterrno.U,v $
+?RCS: Revision 3.0.1.3 1994/10/29 16:20:29 ram
+?RCS: patch36: forgot to initialize 'val' to an empty value (ADO)
+?RCS:
+?RCS: Revision 3.0.1.2 1994/08/29 16:22:10 ram
+?RCS: patch32: removed spurious echo
+?RCS:
+?RCS: Revision 3.0.1.1 1994/06/20 07:02:05 ram
+?RCS: patch30: created by ADO
+?RCS:
+?MAKE:i_neterrno: Inhdr +cc +ccflags rm_try Setvar
+?MAKE: -pick add $@ %<
+?S:i_neterrno:
+?S: This variable conditionally defines the I_NET_ERRNO symbol, which
+?S: indicates to the C program that <net/errno.h> exists and should
+?S: be included.
+?S:.
+?C:I_NET_ERRNO:
+?C: This symbol, if defined, indicates that <net/errno.h> exists and
+?C: should be included.
+?C:.
+?H:#$i_neterrno I_NET_ERRNO /**/
+?H:.
+?LINT:set i_neterrno
+: see if net/errno.h is available
+val=''
+set net/errno.h val
+eval $inhdr
+
+: Unfortunately, it causes problems on some systems. Arrgh.
+case "$val" in
+$define)
+ cat > try.c <<'EOM'
+#include <stdio.h>
+#include <errno.h>
+#include <net/errno.h>
+int func()
+{
+ return ENOTSOCK;
+}
+EOM
+ if $cc $ccflags -c try.c >/dev/null 2>&1; then
+ echo "We'll be including <net/errno.h>." >&4
+ else
+ echo "We won't be including <net/errno.h>." >&4
+ val="$undef"
+ fi
+ $rm_try
+ ;;
+esac
+set i_neterrno
+eval $setvar
+
?RCS: Revision 3.0 1993/08/18 12:10:01 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:voidflags defvoidused: cat rm contains +cc +ccflags package \
+?MAKE:voidflags defvoidused: cat rm_try contains +cc +ccflags package \
Oldconfig Myread i_stdlib
?MAKE: -pick add $@ %<
?S:voidflags:
voidflags="$ans"
;;
esac
-$rm -f try try.* .out
+$rm_try
-?RCS: Copyright (c) 2006-2006, H.Merijn Brand
+?RCS: Copyright (c) 2006-2007, H.Merijn Brand
?RCS:
?RCS: You may redistribute only under the terms of the Artistic Licence,
?RCS: as specified in the README file that comes with the distribution.
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_builtin_choose_expr d_builtin_expect : Compile Setvar cat rm
+?MAKE:d_builtin_choose_expr d_builtin_expect : Compile Setvar cat rm_try
?MAKE: -pick add $@ %<
?S:d_builtin_choose_expr:
?S: This conditionally defines HAS_BUILTIN_CHOOSE_EXPR, which
set d_builtin_choose_expr
eval $setvar
-$rm -f try.* try core core.try.*
+$rm_try
: Look for GCC-style __builtin_expect
case "$d_builtin_expect" in
set d_builtin_expect
eval $setvar
-$rm -f try.* try core core.try.*
+$rm_try
-?RCS: Copyright (c) 2006-2006, H.Merijn Brand
+?RCS: Copyright (c) 2006-2007, H.Merijn Brand
?RCS:
?RCS: You may redistribute only under the terms of the Artistic Licence,
?RCS: as specified in the README file that comes with the distribution.
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_c99_variadic_macros: Compile Setvar cat rm run i_stdarg i_stdlib
+?MAKE:d_c99_variadic_macros: Compile Setvar cat rm_try run i_stdarg i_stdlib
?MAKE: -pick add $@ %<
?S:d_c99_variadic_macros:
?S: This variable conditionally defines the HAS_C99_VARIADIC_MACROS
echo "I couldn't compile and run the test program, so I assume that you don't have functional C99 variadic macros." >&4
d_c99_variadic_macros="$undef"
fi
- $rm -f try.* try core core.try.*
+ $rm_try
;;
*)
echo "You don't have <stdarg.h> and <stdlib.h>, so not checking for C99 variadic macros." >&4
-?RCS: $Id$
-?RCS:
-?RCS: Copyright (c) 2005 H.Merijn Brand
+?RCS: Copyright (c) 2005-2007 H.Merijn Brand
?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:d_cplusplus: Compile Setvar run cat rm
+?MAKE:d_cplusplus: Compile Setvar run cat rm_try
?MAKE: -pick add $@ %<
?S:d_cplusplus (d_cplusplus.U):
?S: This variable conditionally defines the USE_CPLUSPLUS symbol, which
val="$undef"
echo "You are not using a C++ compiler."
fi
-$rm -f try try.* cplusplus$$
+$rm_try cplusplus$$
set d_cplusplus
eval $setvar
-?RCS: $Id$
-?RCS:
-?RCS: Copyright (c) 2006-2006, H.Merijn Brand
+?RCS: Copyright (c) 2006-2007, H.Merijn Brand
?RCS:
?RCS: You may redistribute only under the terms of the Artistic Licence,
?RCS: as specified in the README file that comes with the distribution.
?RCS: of the source tree for dist 3.0.
?RCS:
?RCS:
-?MAKE:d_dir_dd_fd: Compile cat rm Setvar i_dirent i_stdlib
+?MAKE:d_dir_dd_fd: Compile cat rm_try Setvar i_dirent i_stdlib
?MAKE: -pick add $@ %<
?S:d_dir_dd_fd (d_dir_dd_fd.U):
?S: This variable conditionally defines the HAS_DIR_DD_FD symbol, which
esac
set d_dir_dd_fd
eval $setvar
-$rm -f try try.*
+$rm_try
?RCS:
?RCS: $Log: d_fcntl_can_lock.U,v $
?RCS:
-?MAKE:d_fcntl_can_lock: d_fcntl Compile Setvar cat rm run signal_t i_stdlib
+?MAKE:d_fcntl_can_lock: d_fcntl Compile Setvar cat rm_try run signal_t i_stdlib
?MAKE: -pick add $@ %<
?S:d_fcntl_can_lock:
?S: This variable conditionally defines the FCNTL_CAN_LOCK symbol
esac
set d_fcntl_can_lock
eval $setvar
-$rm -f try*
-
+$rm_try
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:d_fpos64_t: \
- Inlibc Setvar Compile rm cat fpossize
+ Inlibc Setvar Compile rm_try cat fpossize
?MAKE: -pick add $@ %<
?S:d_fpos64_t:
?S: This symbol will be defined if the C compiler supports fpos64_t.
8) echo "(Your fpos_t is 64 bits, so you could use that.)" ;;
esac
fi
-$rm -f try.* try
+$rm_try
set d_fpos64_t
eval $setvar
?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:d_futimes: Compile cat rm run
+?MAKE:d_futimes: Compile cat rm_try run
?MAKE: -pick add $@ %<
?S:d_futimes:
?S: This variable conditionally defines the HAS_FUTIMES symbol, which
d_futimes="$undef"
: check for a working futimes
echo " "
-echo "Checking for a working futimes()" >&4
+echo "Checking if you have a working futimes()" >&4
$cat >try.c <<EOCP
#include <stdio.h>
#include <sys/time.h>
`$run ./try`
rc=$?
case "$rc" in
- 0) echo "Yes, it does" >&4
+ 0) echo "Yes, you have" >&4
d_futimes="$define"
;;
- *) echo "No, it has futimes, but it isn't working ($rc) (probably harmless)" >&4
+ *) echo "No, you have futimes, but it isn't working ($rc) (probably harmless)" >&4
;;
esac
else
echo "No, it does not (probably harmless)" >&4
fi
-$rm -f try.* try core core.try.*
+$rm_try
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_int64_t: Inhdr cat rm Setvar Compile i_inttypes
+?MAKE:d_int64_t: Inhdr cat rm_try Setvar Compile i_inttypes
?MAKE: -pick add $@ %<
?S:d_int64_t:
?S: This symbol will be defined if the C compiler supports int64_t.
val="$undef"
echo "You do not have int64_t."
fi
-$rm -f try try.*
+$rm_try
set d_int64_t
eval $setvar
-?RCS: $Id$
-?RCS:
-?RCS: Copyright (c) 2005 H.Merijn Brand
+?RCS: Copyright (c) 2005-2007 H.Merijn Brand
?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:d_libm_lib_version: Compile cat run rm i_math
+?MAKE:d_libm_lib_version: Compile cat run rm_try i_math
?MAKE: -pick add $@ %<
?S:d_libm_lib_version:
?S: This variable conditionally defines the LIBM_LIB_VERSION symbol,
else
echo "No, it does not (probably harmless)\n" >&4
fi
- $rm -f try.* try core core.try.*
+ $rm_try
;;
esac
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:d_modfl d_modflproto d_modfl_pow32_bug: Inlibc Compile Hasproto cat \
- rm test sPRIfldbl d_longdbl osname gccversion ccflags run \
+ rm_try test sPRIfldbl d_longdbl osname gccversion ccflags run \
uselongdouble i_math \
d_sqrtl d_aintl d_copysignl d_ilogbl d_scalbnl d_frexpl
?MAKE: -pick add $@ %<
Checking to see whether your modfl() is okay for large values...
EOM
$cat >try.c <<EOCP
-#include <math.h>
+#include <math.h>
#include <stdio.h>
EOCP
if $test "X$d_modflproto" != "X$define"; then
$cat >>try.c <<EOCP
-/* Sigh. many current glibcs provide the function, but do not prototype it. */
+/* Sigh. many current glibcs provide the function, but do not prototype it. */
long double modfl (long double, long double *);
EOCP
fi
int main() {
long double nv = 4294967303.15;
long double v, w;
- v = modfl(nv, &w);
+ v = modfl(nv, &w);
#ifdef __GLIBC__
printf("glibc");
#endif
d_modfl="$undef"
;;
esac
- $rm -f try.* try core core.try.*
+ $rm_try
else
echo "I cannot figure out whether your modfl() is okay, assuming it isn't."
d_modfl="$undef"
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:d_off64_t: \
- Inlibc Setvar Compile rm cat lseeksize
+ Inlibc Setvar Compile rm_try cat lseeksize
?MAKE: -pick add $@ %<
?S:d_off64_t:
?S: This symbol will be defined if the C compiler supports off64_t.
?H:#$d_off64_t HAS_OFF64_T /**/
?H:.
?LINT:set d_off64_t
-
: check for off64_t
echo " "
echo "Checking to see if you have off64_t..." >&4
8) echo "(Your off_t is 64 bits, so you could use that.)" ;;
esac
fi
-$rm -f try.* try
+$rm_try
set d_off64_t
eval $setvar
?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:d_signbit: nvtype Compile Setvar cat run rm echo n c i_math i_sunmath
+?MAKE:d_signbit: nvtype Compile Setvar cat run rm_try echo n c i_math i_sunmath
?MAKE: -pick add $@ %<
?S:d_signbit:
?S: This variable conditionally defines the HAS_SIGNBIT symbol, which
fi
set d_signbit
eval $setvar
-$rm -f try.* try
+$rm_try
-?RCS: Copyright (c) 2006-2006, H.Merijn Brand
+?RCS: Copyright (c) 2006-2007, H.Merijn Brand
?RCS:
?RCS: You may redistribute only under the terms of the Artistic Licence,
?RCS: as specified in the README file that comes with the distribution.
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_snprintf d_vsnprintf : Inlibc Compile cat run rm
+?MAKE:d_snprintf d_vsnprintf : Inlibc Compile cat run rm_try
?MAKE: -pick add $@ %<
?S:d_snprintf:
?S: This variable conditionally defines the HAS_SNPRINTF symbol, which
d_snprintf="$undef"
d_vsnprintf="$undef"
fi
- $rm -f try.* try core core.try.*
+ $rm_try
;;
esac
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_socklen_t: Inhdr cat rm Setvar Compile d_socket sizetype
+?MAKE:d_socklen_t: Inhdr cat rm_try Setvar Compile d_socket sizetype
?MAKE: -pick add $@ %<
?S:d_socklen_t:
?S: This symbol will be defined if the C compiler supports socklen_t.
size_t) echo "(You do have size_t, that might work. Some people are happy with just an int.)" ;;
esac
fi
-$rm -f try try.*
+$rm_try
set d_socklen_t
eval $setvar
-?RCS: $Id$
-?RCS:
-?RCS: Copyright (c) 2005 H.Merijn Brand
+?RCS: Copyright (c) 2005-2007 H.Merijn Brand
?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:d_sprintf_returns_strlen: Compile cat rm run i_stdlib i_string i_math echo
+?MAKE:d_sprintf_returns_strlen: Compile cat rm_try run i_stdlib i_string i_math echo
?MAKE: -pick add $@ %<
?S:d_sprintf_returns_strlen:
?S: This variable defines whether sprintf returns the length of the string
;;
esac
fi
-
-$rm -f try.* try
+$rm_try
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:d_u32align: Compile cat rm Oldconfig run i_stdlib \
+?MAKE:d_u32align: Compile cat rm_try Oldconfig run i_stdlib \
byteorder u32type Myread Setvar u8type signal_t
?MAKE: -pick add $@ %<
?S:d_u32align:
*) d_u32align="$define" ;;
esac
fi
-$rm -f core core.try.* try.core
+$rm_try
;;
esac
?X: cc -c +z module_b.c
?X: ld -b module_a.o module_b.o -o module.sl
?X:
-?MAKE:usedl ld dlsrc cccdlflags lddlflags ccdlflags: \
+?MAKE:usedl ld dlsrc cccdlflags lddlflags ccdlflags: rm_try \
Getfile Myread test osname sed i_dld d_dlopen Findhdr Setvar src run \
cc ccflags ldflags optimize ls gccversion cat rsrc i_stdlib i_unistd
?MAKE: -pick add $@ %<
dflt='n'
usedl="$undef"
;;
-*)
+*)
dflt='n'
case "$d_dlopen" in
$define) dflt='y' ;;
int main() {
char b[4];
int i = open("a.out",O_RDONLY);
- if(i == -1)
+ if(i == -1)
exit(1); /* fail */
if(read(i,b,4)==4 && b[0]==127 && b[1]=='E' && b[2]=='L' && b[3]=='F')
exit(0); /* succeed (yes, it's ELF) */
echo "I'll use ld to build dynamic libraries."
dflt='ld'
fi
- rm -f try.c a.out
+ $rm_try
;;
*) dflt="$ld"
;;
case "$gccversion" in
'') dflt="$dflt +vnocompatwarnings" ;;
esac
- ;;
+ ;;
linux|irix*|gnu*) dflt="-shared $optimize" ;;
next) dflt='none' ;;
solaris) dflt='-G' ;;
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:fflushNULL fflushall: Compile cat rm test osname run to from \
+?MAKE:fflushNULL fflushall: Compile cat rm rm_try test osname run to from \
Oldconfig Myread Setvar exe_ext echo \
d_sysconf i_unistd d_stdio_stream_array stdio_stream_array i_stdlib
?MAKE: -pick add $@ %<
# endif
# endif
# endif
-# endif
+# endif
# ifdef HAS_STDIO_STREAM_ARRAY
if (open_max > 0) {
long i;
STDIO_STREAM_ARRAY[i]._file < open_max &&
STDIO_STREAM_ARRAY[i]._flag)
fflush(&STDIO_STREAM_ARRAY[i]);
- }
+ }
}
# endif
#endif
fi
fi
fi
- $rm -f core try.core core.try.*
+ $rm_try
case "$fflushNULL" in
x) $cat >&4 <<EOM
Your fflush(NULL) works okay for output streams.
fflushall="`$cat try.out`"
fi
fi
- $rm -f core try.core core.try.*
+ $rm_try
case "$fflushall" in
x) $cat >&4 <<EOM
Whew. Flushing explicitly all the stdio streams works.
EOM
;;
esac
-$rm -f try.* try$exe_ext
+$rm_try
?RCS:
?MAKE:i_db db_hashtype db_prefixtype \
db_version_major db_version_minor db_version_patch : \
- Inhdr +cc +ccflags rm contains cat \
+ Inhdr +cc +ccflags rm_try contains cat \
Compile d_const libs sed run i_stdlib
?MAKE: -pick add $@ %<
?S:i_db:
/* check that db.h & libdb are compatible */
if (DB_VERSION_MAJOR != Major || DB_VERSION_MINOR != Minor || DB_VERSION_PATCH != Patch) {
printf("db.h and libdb are incompatible.\n") ;
- exit(3);
+ exit(3);
}
printf("db.h and libdb are compatible.\n") ;
if (Version < 2003004) {
/* if (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && DB_VERSION_PATCH < 5) { */
printf("Perl needs Berkeley DB 2.3.4 or greater.\n") ;
- exit(2);
+ exit(2);
}
exit(0);
;;
esac
fi
- $rm -f try try.*
+ $rm_try
;;
esac
@if DB_Hash_t
case "$i_db" in
define)
- : Check the return type needed for hash
+ : Check the return type needed for hash
echo " "
echo "Checking return type needed for hash for Berkeley DB ..." >&4
$cat >try.c <<EOCP
echo "Help: I can't seem to compile the db test program." >&4
echo "Something's wrong, but I'll assume you use $db_hashtype." >&4
fi
- $rm -f try try.*
+ $rm_try
echo "Your version of Berkeley DB uses $db_hashtype for hash."
;;
*) db_hashtype=u_int32_t
@if DB_Prefix_t
case "$i_db" in
define)
- : Check the return type needed for prefix
+ : Check the return type needed for prefix
echo " "
echo "Checking return type needed for prefix for Berkeley DB ..." >&4
cat >try.c <<EOCP
echo "Help: I can't seem to compile the db test program." >&4
echo "Something's wrong, but I'll assume you use $db_prefixtype." >&4
fi
- $rm -f try try.*
+ $rm_try
echo "Your version of Berkeley DB uses $db_prefixtype for prefix."
;;
*) db_prefixtype='size_t'
;;
esac
-
@end
+
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:i_inttypes: Inhdr cat rm Setvar Compile
+?MAKE:i_inttypes: Inhdr cat rm_try Setvar Compile
?MAKE: -pick add $@ %<
?S:i_inttypes:
?S: This variable conditionally defines the I_INTTYPES symbol,
echo "<inttypes.h> NOT found." >&4
val="$undef"
fi
-$rm -f try.c try
+$rm_try
set i_inttypes
eval $setvar
sPRIgldbl d_PRIeldbl sPRIeldbl sPRIFUldbl d_PRIGUldbl sPRIEUldbl \
d_SCNfldbl \
sSCNfldbl: \
- d_longdbl longdblsize doublesize test cat rm \
+ d_longdbl longdblsize doublesize test cat rm_try \
Setvar Compile run
?MAKE: -pick add $@ %<
?S:d_PRIfldbl:
sSCNfldbl=$sPRIfldbl # expect consistency
fi
-$rm -f try try.*
+$rm_try
fi # d_longdbl
case "$sPRIfldbl" in
-'') d_PRIfldbl="$undef"; d_PRIgldbl="$undef"; d_PRIeldbl="$undef";
- d_PRIFUldbl="$undef"; d_PRIGUldbl="$undef"; d_PRIEUldbl="$undef";
+'') d_PRIfldbl="$undef"; d_PRIgldbl="$undef"; d_PRIeldbl="$undef";
+ d_PRIFUldbl="$undef"; d_PRIGUldbl="$undef"; d_PRIEUldbl="$undef";
d_SCNfldbl="$undef";
;;
-*) d_PRIfldbl="$define"; d_PRIgldbl="$define"; d_PRIeldbl="$define";
- d_PRIFUldbl="$define"; d_PRIGUldbl="$define"; d_PRIEUldbl="$define";
+*) d_PRIfldbl="$define"; d_PRIgldbl="$define"; d_PRIeldbl="$define";
+ d_PRIFUldbl="$define"; d_PRIGUldbl="$define"; d_PRIEUldbl="$define";
d_SCNfldbl="$define";
;;
esac
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:need_va_copy: +ccflags rm cat Compile i_stdarg i_stdlib run
+?MAKE:need_va_copy: +ccflags rm_try cat Compile i_stdarg i_stdlib run
?MAKE: -pick add $@ %<
?S:need_va_copy:
?S: This symbol, if defined, indicates that the system stores
{
return vfprintf(f, fmt, *valp);
}
-
-int
+
+int
myvfprintf(FILE *f, const char *fmt, va_list val)
{
return ivfprintf(f, fmt, &val);
}
-
+
int
-myprintf(char *fmt, ...)
+myprintf(char *fmt, ...)
{
va_list val;
va_start(val, fmt);
- return myvfprintf(stdout, fmt, val);
-}
+ return myvfprintf(stdout, fmt, val);
+}
int
main(int ac, char **av)
{
signal(SIGSEGV, exit);
- myprintf("%s%cs all right, then\n", "that", '\'');
- exit(0);
+ myprintf("%s%cs all right, then\n", "that", '\'');
+ exit(0);
}
EOCP
set try
need_va_copy="$define"
;;
esac
- $rm -f try.* core core.* *.core *.core.*
+ $rm_try
;;
*) echo "You don't have <stdarg.h>, not checking for va_copy()." >&4
;;
i8type u8type i16type u16type i32type u32type i64type u64type \
i8size u8size i16size u16size i32size u32size i64size u64size \
d_nv_preserves_uv nv_preserves_uv_bits d_nv_zero_is_allbits_zero: \
- echo rm use64bitint d_quad quadtype uquadtype \
+ echo rm_try use64bitint d_quad quadtype uquadtype \
d_longdbl uselongdouble longdblsize doublesize \
charsize shortsize intsize longsize i_stdlib i_string \
cat Compile i_inttypes test d_volatile signal_t run
nv_preserves_uv_bits="`$run ./try`"
fi
case "$nv_preserves_uv_bits" in
-\-[1-9]*)
+\-[1-9]*)
nv_preserves_uv_bits=`expr 0 - $nv_preserves_uv_bits`
$echo "Your NVs can preserve all $nv_preserves_uv_bits bits of your UVs." 2>&1
d_nv_preserves_uv="$define"
*) $echo "Can't figure out how many bits your NVs preserve." 2>&1
nv_preserves_uv_bits="0" ;;
esac
-
-$rm -f try.* try
+$rm_try
$echo "Checking whether NV 0.0 is all bits zero in memory..." >&4
: volatile so that the compiler has to store it out to memory.
printf("(gives %g)\n", d);
return 1;
}
-
+
#ifdef SIGFPE
if (bletched) {
printf("No - something bleched\n");
;;
esac
fi
-
-$rm -f try.* try
+$rm_try
?RCS:
?MAKE:d_PRId64 d_PRIi64 d_PRIu64 d_PRIo64 d_PRIx64 d_PRIXU64 \
sPRId64 sPRIi64 sPRIu64 sPRIo64 sPRIx64 sPRIXU64: \
- quadtype i_inttypes test cat rm Setvar Compile run
+ quadtype i_inttypes test cat rm_try Setvar Compile run
?MAKE: -pick add $@ %<
?S:d_PRId64:
?S: This variable conditionally defines the PERL_PRId64 symbol, which
if $test X"$sPRId64" = X; then
echo "Cannot figure out how to print 64-bit integers." >&4
fi
-
-$rm -f try try.*
+$rm_try
fi
case "$sPRId64" in
-'') d_PRId64="$undef"; d_PRIi64="$undef"; d_PRIu64="$undef";
- d_PRIo64="$undef"; d_PRIx64="$undef"; d_PRIXU64="$undef";
+'') d_PRId64="$undef"; d_PRIi64="$undef"; d_PRIu64="$undef";
+ d_PRIo64="$undef"; d_PRIx64="$undef"; d_PRIXU64="$undef";
;;
-*) d_PRId64="$define"; d_PRIi64="$define"; d_PRIu64="$define";
- d_PRIo64="$define"; d_PRIx64="$define"; d_PRIXU64="$define";
+*) d_PRId64="$define"; d_PRIi64="$define"; d_PRIu64="$define";
+ d_PRIo64="$define"; d_PRIx64="$define"; d_PRIXU64="$define";
;;
esac
?RCS: that same Artistic Licence; a copy of which may be found at the root
?RCS: of the source tree for dist 3.0.
?RCS:
-?MAKE:selectminbits: Compile cat rm Oldconfig d_select \
+?MAKE:selectminbits: Compile cat rm_try Oldconfig d_select \
i_time i_systime i_systimek i_sysselct selecttype d_socket \
byteorder Myread Setvar run i_stdlib ptrsize
?MAKE: -pick add $@ %<
val=$ans
selectminbits="$val"
fi
- $rm -f try.* try
+ $rm_try
;;
*) : no select, so pick a harmless default
selectminbits=$safebits
?RCS: of the source tree for dist 3.0.
?RCS:
?MAKE:d_stdio_stream_array stdio_stream_array: run \
- Compile cat rm Oldconfig Myread Setvar exe_ext
+ Compile cat rm_try Oldconfig Myread Setvar
?MAKE: -pick add $@ %<
?S:d_stdio_stream_array:
?S: This variable tells whether there is an array holding
esac
fi
done
- $rm -f try.* try$exe_ext
+ $rm_try
esac
case "$stdio_stream_array" in
'') $cat >&4 <<EOM
ldflags_uselargefiles \
libswanted_uselargefiles: \
Myread Oldconfig Setvar test lseeksize fpossize \
- fpostype Compile echo n c cat lseektype rm run \
+ fpostype Compile echo n c cat lseektype rm_try run \
use64bitint use64bitall i_stdlib
?MAKE: -pick add $@ %<
?Y:TOP
EOM
uselargefiles="$define"
;;
-esac
+esac
case "$lseeksize:$fpossize" in
8:8) cat <<EOM
int main()
{
printf("%d\n", (int)sizeof($lseektype));
- return(0);
+ return(0);
}
EOCP
set try
*_t) zzz="$fpostype" ;;
*) zzz="fpos_t" ;;
esac
- $echo $n "Rechecking the size of $zzz...$c" >&4
+ $echo $n "Rechecking the size of $zzz...$c" >&4
$cat > try.c <<EOCP
#include <sys/types.h>
#include <stdio.h>
. ./myread
fpossize="$ans"
fi
- $rm -f try.c try
+ $rm_try
fi
;;
esac
?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:
-?X: This unit generates a $hasfield string that is used internally
-?X: by Configure to check if this system has a field for a
+?X: This unit generates a $hasfield string that is used internally
+?X: by Configure to check if this system has a field for a
?X: particular struct (of if this system has a particular struct!)
?X:
?X: To use it, say something like:
?X: eval $hasfield
?X: Or, for more complicated sets of headers, do something like
?X: hdrs="$define sys/foo.h
-?X: $i_sysbar sys/bar.h
+?X: $i_sysbar sys/bar.h
?X: $i_syszot sys/zot.h
?X: $i_zappa zappa.h"
?X: set d_statblocks stat st_blocks $hdrs
?X: eval $hasfield
?X:
-?MAKE:Hasfield: Setvar rm test Compile
+?MAKE:Hasfield: Setvar rm_try test Compile
?MAKE: -pick add $@ %<
?T:varname struct field
?V:hasfield
fi;
set $varname;
eval $setvar;
-$rm -f try try.c try.o'
+$rm_try'
?X: set d_getnetent_proto getnetent $hdrs
?X: eval $hasproto
?X:
-?MAKE:Hasproto: Setvar cppstdin cppflags cppminus contains rm test
+?MAKE:Hasproto: Setvar cppstdin cppflags cppminus contains rm_try test
?MAKE: -pick add $@ %<
?T:func varname
?V:hasproto
fi;
set $varname;
eval $setvar;
-$rm -f try.c tryout.c'
+$rm_try tryout.c'
?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:
-?X: This unit generates a $hasstruct string that is used internally
-?X: by Configure to check if this system has a field for a
+?X: This unit generates a $hasstruct string that is used internally
+?X: by Configure to check if this system has a field for a
?X: particular struct (of if this system has a particular struct!)
?X:
?X: To use it, say something like:
?X: eval $hasstruct
?X: Or, for more complicated sets of headers, do something like
?X: hdrs="$define sys/foo.h
-?X: $i_sysbar sys/bar.h
+?X: $i_sysbar sys/bar.h
?X: $i_syszot sys/zot.h
?X: $i_zappa zappa.h"
?X: set d_statblocks stat $hdrs
?X: eval $hasstruct
?X:
-?MAKE:Hasstruct: Setvar rm test Compile
+?MAKE:Hasstruct: Setvar rm_try test Compile
?MAKE: -pick add $@ %<
?T:varname struct
?V:hasstruct
fi;
set $varname;
eval $setvar;
-$rm -f try try.c try.o'
+$rm_try'
?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:
-?X: This unit generates a ./protochk script that is used internally
-?X: by Configure to check if this system will accept a particular
+?X: This unit generates a ./protochk script that is used internally
+?X: by Configure to check if this system will accept a particular
?X: prototype.
?X:
?X: To use it, say something like:
?X: hdrs="$define sys/types.h
-?X: $i_systime sys/time.h
+?X: $i_systime sys/time.h
?X: $i_sysselct sys/select.h
?X: $d_socket sys/socket.h"
?X: $xxx='fd_set *'
?X: The C compiler on QNX warns about invalid pointer types, but
?X: still exits with a 0 exit status, so it's not much help here.
?X: (It does correctly detect incorrect non-pointer arguments).
-?X: Still, since QNX is a POSIX-ish system, just make your first
+?X: Still, since QNX is a POSIX-ish system, just make your first
?X: a POSIX-ish one, and QNX will probably accept it.
?X:
?X: For determining argument types, your compiler must support
?X: prototypes, and the header files must use them. Determining
?X: return types, however, is easier. Just give an ridiculuous
?X: return type, something like
-?X: ./protochk 'extern int atof _((void));' $i_stdlib stdlib.h
+?X: ./protochk 'extern int atof _((void));' $i_stdlib stdlib.h
?X: that should surely fail if atof() is defined in <stdlib.h>
?X:
?X: There is also an 'escape' hatch built in. If you have a pair
?X: of args 'literal 'stuff' then 'stuff' gets included literally
?X: into the test program. This could be useful for doing something
-?X: like
+?X: like
?X: hdrs="$define stdio.h
?X: $define sys/types.h"
?X: ./protochk 'extern int fsetpos(FILE *, Fpos_t);' $args \
?X: 'literal' '#define Fpos_t long long'
?X: but you have to be really careful about the spaces in "literal".
-?X:
+?X:
?X: Andy Dougherty Feb. 1998
-?MAKE:Protochk: cat rm startsh eunicefix +cc +optimize +ccflags \
+?MAKE:Protochk: cat rm_try startsh eunicefix +cc +optimize +ccflags \
prototype i_pthread usethreads
?MAKE: -pick add $@ %<
?F:./protochk
?X: Comfort metalint. All these are actually used in the protochk script.
?T:foo status pthread_h_done
-?LINT: change cc optimize ccflags prototype define rm
+?LINT: change cc optimize ccflags prototype define rm_try
?LINT: extern pthread_h_first
?LINT: change pthread_h_first
?LINT: change usethreads
ccflags="$ccflags"
prototype="$prototype"
define="$define"
-rm=$rm
+rm_try=$rm_try
usethreads=$usethreads
i_pthread=$i_pthread
pthread_h_first=$pthread_h_first
$cat >> protochk <<'EOSH'
-$rm -f try.c
+$rm_try
foo="$1"
shift
while test $# -ge 2; do
echo 'int no_real_function_has_this_name _((void)) { return 0; }' >> try.c
$cc $optimize $ccflags -c try.c > /dev/null 2>&1
status=$?
-$rm -f try.[co]
+$rm_try
exit $status
EOSH
chmod +x protochk
?RCS: $Id: d_localtime_r.U,v 0RCS:
?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi
-?RCS: Copyright (c) 2006,2006 H.Merijn Brand
+?RCS: Copyright (c) 2006,2007 H.Merijn Brand
?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:d_localtime_r d_localtime_r_needs_tzset localtime_r_proto: Inlibc \
cat run Protochk Hasproto i_systypes usethreads i_time i_systime \
- rm Compile
+ rm_try Compile
?MAKE: -pick add $@ %<
?S:d_localtime_r:
?S: This variable conditionally defines the HAS_LOCALTIME_R symbol,
d_localtime_r_needs_tzset=undef;
;;
esac
-$rm -f try try.* core
+$rm_try
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:d_old_pthread_create_joinable old_pthread_create_joinable: \
- cat Compile rm Setvar usethreads i_pthread
+ cat Compile rm_try Setvar usethreads i_pthread
?MAKE: -pick add $@ %<
?S:d_old_pthread_create_joinable:
?S: This variable conditionally defines pthread_create_joinable.
: how to create joinable pthreads
if test "X$usethreads" = "X$define" -a "X$i_pthread" = "X$define"; then
echo " "
- echo "Checking what constant to use for creating joinable pthreads..." >&4
+ echo "Checking what constant to use for creating joinable pthreads..." >&4
$cat >try.c <<'EOCP'
#include <pthread.h>
int main() {
val=PTHREAD_CREATE_UNDETACHED
set old_pthread_create_joinable
eval $setvar
- else
+ else
set try -DJOINABLE=__UNDETACHED
if eval $compile; then
echo "You seem to use __UNDETACHED." >&4
fi
fi
fi
- $rm -f try try.*
+ $rm_try
else
d_old_pthread_create_joinable="$undef"
old_pthread_create_joinable=""
?RCS: License or the Artistic License, as specified in the README file.
?RCS:
?MAKE:d_pthread_yield sched_yield d_sched_yield: \
- Compile Setvar cat rm usethreads
+ Compile Setvar cat rm_try usethreads
?MAKE: -pick add $@ %<
?S:d_pthread_yield:
?S: This variable conditionally defines the HAS_PTHREAD_YIELD
?S: the execution of the current thread.
?S:.
?C:HAS_PTHREAD_YIELD:
-?C: This symbol, if defined, indicates that the pthread_yield
+?C: This symbol, if defined, indicates that the pthread_yield
?C: routine is available to yield the execution of the current
?C: thread. sched_yield is preferable to pthread_yield.
?C:.
esac
set d_pthread_yield
eval $setvar
-
case "$sched_yield" in
'') sched_yield=undef ;;
esac
-
-$rm -f try try.*
+$rm_try
?RCS: Revision 3.0 1993/08/18 12:09:08 ram
?RCS: Baseline for dist 3.0 netwide release.
?RCS:
-?MAKE:lseektype lseeksize: Myread Typedef cat Compile rm longsize run
+?MAKE:lseektype lseeksize: Myread Typedef cat Compile rm_try longsize run
?MAKE: -pick add $@ %<
?S:lseektype:
-?S: This variable defines lseektype to be something like off_t, long,
+?S: This variable defines lseektype to be something like off_t, long,
?S: or whatever type is used to declare lseek offset's type in the
?S: kernel (which also appears to be lseek's return type).
?S:.
?S:lseeksize:
-?S: This variable defines lseektype to be something like off_t, long,
+?S: This variable defines lseektype to be something like off_t, long,
?S: or whatever type is used to declare lseek offset's type in the
?S: kernel (which also appears to be lseek's return type).
?S:.
int main()
{
printf("%d\n", (int)sizeof($lseektype));
- return(0);
+ return(0);
}
EOCP
set try
. ./myread
lseeksize="$ans"
fi
-$rm -f try.c try
+$rm_try
https://perl5.git.perl.org / metaconfig.git / commitdiff