1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/*
FUNCTION
<<memccpy>>---copy memory regions with end-token check
SYNOPSIS
#include <string.h>
void* memccpy(void *restrict <[out]>, const void *restrict <[in]>,
int <[endchar]>, size_t <[n]>);
DESCRIPTION
This function copies up to <[n]> bytes from the memory region
pointed to by <[in]> to the memory region pointed to by
<[out]>. If a byte matching the <[endchar]> is encountered,
the byte is copied and copying stops.
If the regions overlap, the behavior is undefined.
RETURNS
<<memccpy>> returns a pointer to the first byte following the
<[endchar]> in the <[out]> region. If no byte matching
<[endchar]> was copied, then <<NULL>> is returned.
PORTABILITY
<<memccpy>> is a GNU extension.
<<memccpy>> requires no supporting OS subroutines.
*/
#include <_ansi.h>
#include <stddef.h>
#include <string.h>
#include <limits.h>
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
/* How many bytes are copied each iteration of the word copy loop. */
#define LITTLEBLOCKSIZE (sizeof (long))
/* Threshhold for punting to the byte copier. */
#define TOO_SMALL(LEN) ((LEN) < LITTLEBLOCKSIZE)
/* Macros for detecting endchar */
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
_PTR
_DEFUN (memccpy, (dst0, src0, endchar, len0),
_PTR __restrict dst0,
_CONST _PTR __restrict src0,
int endchar0,
size_t len0)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
_PTR ptr = NULL;
char *dst = (char *) dst0;
char *src = (char *) src0;
char endchar = endchar0 & 0xff;
while (len0--)
{
if ((*dst++ = *src++) == endchar)
{
ptr = dst;
break;
}
}
return ptr;
#else
_PTR ptr = NULL;
char *dst = dst0;
_CONST char *src = src0;
long *aligned_dst;
_CONST long *aligned_src;
char endchar = endchar0 & 0xff;
/* If the size is small, or either SRC or DST is unaligned,
then punt into the byte copy loop. This should be rare. */
if (!TOO_SMALL(len0) && !UNALIGNED (src, dst))
{
unsigned int i;
unsigned long mask = 0;
aligned_dst = (long*)dst;
aligned_src = (long*)src;
/* The fast code reads the ASCII one word at a time and only
performs the bytewise search on word-sized segments if they
contain the search character, which is detected by XORing
the word-sized segment with a word-sized block of the search
character and then detecting for the presence of NULL in the
result. */
for (i = 0; i < LITTLEBLOCKSIZE; i++)
mask = (mask << 8) + endchar;
/* Copy one long word at a time if possible. */
while (len0 >= LITTLEBLOCKSIZE)
{
unsigned long buffer = (unsigned long)(*aligned_src);
buffer ^= mask;
if (DETECTNULL (buffer))
break; /* endchar is found, go byte by byte from here */
*aligned_dst++ = *aligned_src++;
len0 -= LITTLEBLOCKSIZE;
}
/* Pick up any residual with a byte copier. */
dst = (char*)aligned_dst;
src = (char*)aligned_src;
}
while (len0--)
{
if ((*dst++ = *src++) == endchar)
{
ptr = dst;
break;
}
}
return ptr;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
|
