We can therefore also avoid probing for and/or using BSD bcopy().
d_printf_format_null=''
d_backtrace=''
d_bcmp=''
-d_bcopy=''
d_builtin_choose_expr=''
d_builtin_expect=''
d_builtin_add_overflow=''
d_mbtowc=''
d_memchr=''
d_memcmp=''
-d_memcpy=''
d_memmem=''
-d_memmove=''
d_memrchr=''
d_mkdir=''
d_mkdtemp=''
d_rint=''
d_rmdir=''
d_round=''
-d_safebcpy=''
d_sanemcmp=''
d_sbrkproto=''
d_scalbn=''
set bcmp d_bcmp
eval $inlibc
-: see if bcopy exists
-set bcopy d_bcopy
-eval $inlibc
-
: see if getpgrp exists
set getpgrp d_getpgrp
eval $inlibc
set memcmp d_memcmp
eval $inlibc
-: see if memcpy exists
-set memcpy d_memcpy
-eval $inlibc
-
: see if memmem exists
set memmem d_memmem
eval $inlibc
-: see if memmove exists
-set memmove d_memmove
-eval $inlibc
-
: see if memrchr exists
set memrchr d_memrchr
eval $inlibc
set i_memory
eval $setvar
-: can bcopy handle overlapping blocks?
-echo " "
-val="$undef"
-case "$d_memmove" in
-"$define") echo "I'll use memmove() instead of bcopy() for overlapping copies." ;;
-*) case "$d_bcopy" in
- "$define")
- echo "Checking to see if bcopy() can do overlapping copies..." >&4
- $cat >try.c <<EOCP
-#$i_memory I_MEMORY
-#$i_stdlib I_STDLIB
-#$i_string I_STRING
-#$i_unistd I_UNISTD
-EOCP
- $cat >>try.c <<'EOCP'
-#include <stdio.h>
-#ifdef I_MEMORY
-# include <memory.h>
-#endif
-#ifdef I_STDLIB
-# include <stdlib.h>
-#endif
-#ifdef I_STRING
-# include <string.h>
-#else
-# include <strings.h>
-#endif
-#ifdef I_UNISTD
-# include <unistd.h> /* Needed for NetBSD */
-#endif
-int main()
-{
-char buf[128], abc[128];
-char *b;
-int len;
-int off;
-int align;
-
-/* Copy "abcde..." string to char abc[] so that gcc doesn't
- try to store the string in read-only memory. */
-bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);
-
-for (align = 7; align >= 0; align--) {
- for (len = 36; len; len--) {
- b = buf+align;
- bcopy(abc, b, len);
- for (off = 1; off <= len; off++) {
- bcopy(b, b+off, len);
- bcopy(b+off, b, len);
- if (bcmp(b, abc, len))
- exit(1);
- }
- }
-}
-exit(0);
-}
-EOCP
- set try
- if eval $compile_ok; then
- if $run ./try 2>/dev/null; then
- echo "Yes, it can."
- val="$define"
- else
- echo "It can't, sorry."
- fi
- else
- echo "(I can't compile the test program, so we'll assume not...)"
- fi
- ;;
- esac
- $rm_try
- ;;
-esac
-set d_safebcpy
-eval $setvar
-
: can memcmp be trusted to compare relative magnitude?
val="$undef"
case "$d_memcmp" in
d_attribute_warn_unused_result='$d_attribute_warn_unused_result'
d_backtrace='$d_backtrace'
d_bcmp='$d_bcmp'
-d_bcopy='$d_bcopy'
d_bsd='$d_bsd'
d_bsdgetpgrp='$d_bsdgetpgrp'
d_bsdsetpgrp='$d_bsdsetpgrp'
d_mbtowc='$d_mbtowc'
d_memchr='$d_memchr'
d_memcmp='$d_memcmp'
-d_memcpy='$d_memcpy'
d_memmem='$d_memmem'
-d_memmove='$d_memmove'
d_memrchr='$d_memrchr'
d_mkdir='$d_mkdir'
d_mkdtemp='$d_mkdtemp'
d_rint='$d_rint'
d_rmdir='$d_rmdir'
d_round='$d_round'
-d_safebcpy='$d_safebcpy'
d_sanemcmp='$d_sanemcmp'
d_sbrkproto='$d_sbrkproto'
d_scalbn='$d_scalbn'
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='define'
-d_bcopy='define'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='define'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='define'
d_scalbn='undef'
d_attribute_unused='undef'
d_attribute_warn_unused_result='undef'
d_bcmp='define'
-d_bcopy='define'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
-d_memmove='define'
d_mkdir='define'
d_mkdtemp='define'
d_mkfifo='define'
d_rename='define'
d_rewinddir='define'
d_rmdir='define'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='define'
d_scalbnl='define'
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='define'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='undef'
d_scalbn='undef'
*/
/*#define HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-/*#define HAS_BCOPY /**/
-
/* HAS_CHOWN:
* This symbol, if defined, indicates that the chown routine is
* available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_RECVMSG /**/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Otherwise you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY /**/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
This variable conditionally defines the HAS_BCMP symbol if
the bcmp() routine is available to compare strings.
-d_bcopy (d_bcopy.U):
- This variable conditionally defines the HAS_BCOPY symbol if
- the bcopy() routine is available to copy strings.
-
d_bsd (Guess.U):
This symbol conditionally defines the symbol BSD when running on a
BSD system.
indicates to the C program that the memcmp() routine is available
to compare blocks of memory.
-d_memcpy (d_memcpy.U):
- This variable conditionally defines the HAS_MEMCPY symbol, which
- indicates to the C program that the memcpy() routine is available
- to copy blocks of memory.
-
d_memmem (d_memmem.U):
This variable conditionally defines the HAS_MEMMEM symbol, which
indicates to the C program that the memmem() routine is available
to return a pointer to the start of the first occurance of a
substring in a memory area (or NULL if not found).
-d_memmove (d_memmove.U):
- This variable conditionally defines the HAS_MEMMOVE symbol, which
- indicates to the C program that the memmove() routine is available
- to copy potentially overlapping blocks of memory.
-
d_memrchr (d_memrchr.U):
This variable conditionally defines the HAS_MEMRCHR symbol, which
indicates to the C program that the memrchr() routine is available
This variable conditionally defines the HAS_ROUND symbol, which
indicates to the C program that the round() routine is available.
-d_safebcpy (d_safebcpy.U):
- This variable conditionally defines the HAS_SAFE_BCOPY symbol if
- the bcopy() routine can do overlapping copies. Normally, you
- should probably use memmove().
-
d_sanemcmp (d_sanemcmp.U):
This variable conditionally defines the HAS_SANE_MEMCMP symbol if
the memcpy() routine is available and can be used to compare relative
d_attribute_warn_unused_result='define'
d_backtrace='define'
d_bcmp='define'
-d_bcopy='define'
d_bsd='define'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='define'
-d_memmove='define'
d_memrchr='define'
d_mkdir='define'
d_mkdtemp='define'
d_rint='define'
d_rmdir='define'
d_round='define'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='define'
d_scalbn='define'
*/
#define HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-#define HAS_BCOPY /**/
-
/* HAS_CHOWN:
* This symbol, if defined, indicates that the chown routine is
* available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MEMRCHR:
* This symbol, if defined, indicates that the memrchr routine is
* available to return a pointer to the last occurrence of a byte in
/*#define HAS_READDIR_R / **/
#define READDIR_R_PROTO 0 /**/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
*/
#$d_bcmp HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-#$d_bcopy HAS_BCOPY /**/
-
/* HAS_CBRT:
* This symbol, if defined, indicates that the cbrt() (cube root)
* function is available.
*/
#$d_memcmp HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#$d_memcpy HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#$d_memmove HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
#$d_open3 HAS_OPEN3 /**/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-#$d_safebcpy HAS_SAFE_BCOPY /**/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
$ CS
$ tmp = "bcopy"
$ GOSUB inlibc
-$ d_bcopy = tmp
$!
$! Check for mkstemp
$!
$ WC "d_prctl_set_name='undef'"
$ WC "d_printf_format_null='undef'"
$ WC "d_bcmp='" + d_bcmp + "'"
-$ WC "d_bcopy='" + d_bcopy + "'"
$ WC "d_bincompat3='undef'"
$ WC "d_bsd='undef'"
$ WC "d_bsdgetpgrp='undef'"
$ WC "d_mbtowc='" + d_mbtowc + "'"
$ WC "d_memchr='" + d_memchr + "'"
$ WC "d_memcmp='define'"
-$ WC "d_memcpy='define'"
$ WC "d_memmem='undef'"
-$ WC "d_memmove='define'"
$ WC "d_memrchr='" + d_memrchr + "'"
$ WC "d_mkdir='define'"
$ WC "d_mkdtemp='" + d_mkdtemp + "'"
$ WC "d_rint='" + d_rint + "'"
$ WC "d_rmdir='define'"
$ WC "d_round='undef'"
-$ WC "d_safebcpy='undef'"
$ WC "d_sanemcmp='define'"
$ WC "d_sbrkproto='define'"
$ WC "d_scalbn='undef'"
p |int |mode_from_discipline|NULLOK const char* s|STRLEN len
Ap |const char* |moreswitches |NN const char* s
Ap |NV |my_atof |NN const char *s
-#if !defined(HAS_MEMCPY) || !defined(HAS_MEMMOVE)
-Anp |void* |my_bcopy |NN const void* vfrom|NN void* vto|size_t len
-#endif
Apr |void |my_exit |U32 status
Apr |void |my_failure_exit
Ap |I32 |my_fflush_all
#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
#define my_memcmp Perl_my_memcmp
#endif
-#if !defined(HAS_MEMCPY) || !defined(HAS_MEMMOVE)
-#define my_bcopy Perl_my_bcopy
-#endif
#if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
#define my_chsize(a,b) Perl_my_chsize(aTHX_ a,b)
#endif
}
}
#else
-#ifdef HAS_MEMMOVE
dst -= m;
src -= m;
memmove(dst, src, m);
-#else
- while (m--)
- *--dst = *--src;
-#endif
#endif
/*
* adjust offset index up
#include <memory.h>
#endif
-#ifdef __cplusplus
-#define HAS_MEMCPY
-#endif
-
-#ifdef HAS_MEMCPY
-# if !defined(STANDARD_C) && !defined(I_STRING) && !defined(I_MEMORY)
-# ifndef memcpy
- extern char * memcpy proto((char*, char*, int));
-# endif
-# endif
-#else
-# ifndef memcpy
-# ifdef HAS_BCOPY
-# define memcpy(d,s,l) bcopy(s,d,l)
-# else
-# define memcpy(d,s,l) my_bcopy(s,d,l)
-# endif
-# endif
-#endif /* HAS_MEMCPY */
-
#define memzero(d,l) memset(d,0,l)
#if defined(mips) && defined(ultrix) && !defined(__STDC__)
# it is needed for ODBM_File and NDBM_File extensions.
if [ -r /usr/ucblib/libucb.a ]; then # If using BSD-compat. library:
# Use the "native" counterparts, not the BSD emulation stuff:
- d_bcmp='undef'; d_bcopy='undef'; d_safebcpy='undef'
+ d_bcmp='undef';
d_index='undef'; d_killpg='undef'; d_getprior='undef'; d_setprior='undef'
d_setlinebuf='undef'; d_setregid='undef'; d_setreuid='undef'
fi
if [ -r /usr/ucblib/libucb.a ]; then # If using BSD-compat. library:
gconvert_preference='gcvt sprintf' # Try gcvt() before gconvert().
# Use the "native" counterparts, not the BSD emulation stuff:
- d_bcmp='undef' d_bcopy='undef' d_safebcpy='undef'
+ d_bcmp='undef'
d_index='undef' d_killpg='undef' d_getprior='undef' d_setprior='undef'
d_setlinebuf='undef'
# d_setregid='undef' d_setreuid='undef' # ???
case $uw_ver in
2.1)
d_csh='undef'
- d_memcpy='define'
;;
2.1.*)
d_csh='undef'
- d_memcpy='define'
stdio_cnt='((fp)->__cnt)'
d_stdio_cnt_lval='define'
stdio_ptr='((fp)->__ptr)'
case $uw_ver in
7)
d_csh='undef'
- d_memcpy='define'
stdio_cnt='((fp)->__cnt)'
d_stdio_cnt_lval='define'
stdio_ptr='((fp)->__ptr)'
# Don't use BSD emulation pieces (/usr/ucblib) regardless
# these would probably be autonondetected anyway but ...
gconvert_preference='gcvt sprintf' # Try gcvt() before gconvert().
-d_bcopy='undef' d_bcmp='undef' d_safebcpy='undef'
+d_bcmp='undef'
d_index='undef' d_killpg='undef' d_getprior='undef' d_setprior='undef'
d_setlinebuf='undef'
d_setregid='undef' d_setreuid='undef' # -- in /usr/lib/libc.so.1
case $uw_ver in
8.*|7.1*)
d_csh='undef'
- d_memcpy='define'
stdio_cnt='((fp)->__cnt)'
d_stdio_cnt_lval='define'
stdio_ptr='((fp)->__ptr)'
d_stdio_ptr_lval='define'
- d_bcopy='define' # In /usr/lib/libc.so.1
d_setregid='define' # "
d_setreuid='define' # "
;;
7*)
d_csh='undef'
- d_memcpy='define'
stdio_cnt='((fp)->__cnt)'
d_stdio_cnt_lval='define'
stdio_ptr='((fp)->__ptr)'
# include <memory.h>
#endif
-#ifdef HAS_MEMCPY
-# if !defined(STANDARD_C) && !defined(I_STRING) && !defined(I_MEMORY)
-# ifndef memcpy
- extern char * memcpy (char*, char*, int);
-# endif
-# endif
-#else
-# ifndef memcpy
-# define memcpy(d,s,l) my_bcopy(s,d,l)
-# endif
-#endif /* HAS_MEMCPY */
-
-#if !defined(HAS_MEMMOVE) && !defined(memmove)
-# define memmove(d,s,l) my_bcopy(s,d,l)
-#endif
-
#if defined(mips) && defined(ultrix) && !defined(__STDC__)
# undef HAS_MEMCMP
#endif
*/
#define HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-#define HAS_BCOPY /**/
-
/* HAS_CHOWN:
* This symbol, if defined, indicates that the chown routine is
* available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_RECVMSG / **/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
*/
#define HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-#define HAS_BCOPY /**/
-
/* HAS_CHOWN:
* This symbol, if defined, indicates that the chown routine is
* available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_RECVMSG / **/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='define'
-d_bcopy='define'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='undef'
d_scalbn='undef'
assert(vs1); assert(vs2)
#endif
-#if !defined(HAS_MEMCPY) || !defined(HAS_MEMMOVE)
-PERL_CALLCONV void* Perl_my_bcopy(const void* vfrom, void* vto, size_t len);
-#define PERL_ARGS_ASSERT_MY_BCOPY \
- assert(vfrom); assert(vto)
-#endif
#if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
# if defined(PERL_IN_PP_SYS_C)
STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename)
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='undef'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='undef'
d_sbrkproto='undef'
d_scalbn='undef'
*/
/*#define HAS_BCMP / **/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-/*#define HAS_BCOPY / **/
-
/* HAS_CBRT:
* This symbol, if defined, indicates that the cbrt() (cube root)
* function is available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-/*#define HAS_MEMMOVE / **/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_OPEN3 / **/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
#endif
/* Generated from:
- * d9687e4eb62ebccd02be4a08612dc1bcfd95119f0008203aee08f29c997ebfc3 config_h.SH
- * 4fb77492d82d8e37400b5d34c71f1c2489d5dc04e82e61ec78998af0fdd60d99 uconfig.sh
+ * 1cf368f3ea2fec4f94f386fdea4cdeeaa97c85016d4890593bf9f9883b0efddd config_h.SH
+ * 0aaf1bf7863e3a8c2c9ebd5150ba593f980e174203d159deac8f83b981da6037 uconfig.sh
* ex: set ro: */
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='undef'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='undef'
d_memrchr='undef'
d_mkdir='undef'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='undef'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='undef'
d_sbrkproto='undef'
d_scalbn='undef'
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='undef'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='undef'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='undef'
d_memrchr='undef'
d_mkdir='undef'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='undef'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='undef'
d_sbrkproto='undef'
d_scalbn='undef'
}
#endif
-/* this is a drop-in replacement for bcopy(), except for the return
- * value, which we need to be able to emulate memcpy() */
-#if !defined(HAS_MEMCPY) || !defined(HAS_MEMMOVE)
-void *
-Perl_my_bcopy(const void *vfrom, void *vto, size_t len)
-{
-#if defined(HAS_BCOPY) && defined(HAS_SAFE_BCOPY)
- bcopy(vfrom, vto, len);
-#else
- const unsigned char *from = (const unsigned char *)vfrom;
- unsigned char *to = (unsigned char *)vto;
-
- PERL_ARGS_ASSERT_MY_BCOPY;
-
- if (from - to >= 0) {
- while (len--)
- *to++ = *from++;
- }
- else {
- to += len;
- from += len;
- while (len--)
- *(--to) = *(--from);
- }
-#endif
-
- return vto;
-}
-#endif
-
/* this is a drop-in replacement for memcmp() */
#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
int
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='define'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='undef'
d_scalbn='undef'
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='define'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='undef'
d_scalbn='undef'
d_attribute_warn_unused_result='undef'
d_backtrace='undef'
d_bcmp='undef'
-d_bcopy='undef'
d_bsd='define'
d_bsdgetpgrp='undef'
d_bsdsetpgrp='undef'
d_mbtowc='define'
d_memchr='define'
d_memcmp='define'
-d_memcpy='define'
d_memmem='undef'
-d_memmove='define'
d_memrchr='undef'
d_mkdir='define'
d_mkdtemp='undef'
d_rint='undef'
d_rmdir='define'
d_round='undef'
-d_safebcpy='undef'
d_sanemcmp='define'
d_sbrkproto='undef'
d_scalbn='undef'
*/
/*#define HAS_BCMP /**/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-/*#define HAS_BCOPY /**/
-
/* HAS_CHOWN:
* This symbol, if defined, indicates that the chown routine is
* available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_RECVMSG /**/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY /**/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
*/
/*#define HAS_BCMP / **/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-/*#define HAS_BCOPY / **/
-
/* HAS_CBRT:
* This symbol, if defined, indicates that the cbrt() (cube root)
* function is available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_OPEN3 / **/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
*/
/*#define HAS_BCMP / **/
-/* HAS_BCOPY:
- * This symbol is defined if the bcopy() routine is available to
- * copy blocks of memory.
- */
-/*#define HAS_BCOPY / **/
-
/* HAS_CBRT:
* This symbol, if defined, indicates that the cbrt() (cube root)
* function is available.
*/
#define HAS_MEMCMP /**/
-/* HAS_MEMCPY:
- * This symbol, if defined, indicates that the memcpy routine is available
- * to copy blocks of memory.
- */
-#define HAS_MEMCPY /**/
-
-/* HAS_MEMMOVE:
- * This symbol, if defined, indicates that the memmove routine is available
- * to copy potentially overlapping blocks of memory. This should be used
- * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
- * own version.
- */
-#define HAS_MEMMOVE /**/
-
/* HAS_MKDIR:
* This symbol, if defined, indicates that the mkdir routine is available
* to create directories. Otherwise you should fork off a new process to
*/
/*#define HAS_OPEN3 / **/
-/* HAS_SAFE_BCOPY:
- * This symbol, if defined, indicates that the bcopy routine is available
- * to copy potentially overlapping memory blocks. Normally, you should
- * probably use memmove() or memcpy(). If neither is defined, roll your
- * own version.
- */
-/*#define HAS_SAFE_BCOPY / **/
-
/* HAS_SANE_MEMCMP:
* This symbol, if defined, indicates that the memcmp routine is available
* and can be used to compare relative magnitudes of chars with their high
https://perl5.git.perl.org / perl5.git / commitdiff