| // SPDX-License-Identifier: BSD-3-Clause |
| /* |
| * Copyright (c) 1994-2009 Red Hat, Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * 3. Neither the name of the copyright holder nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| FUNCTION |
| <<memchr>>---find character in memory |
| |
| INDEX |
| memchr |
| |
| ANSI_SYNOPSIS |
| #include <string.h> |
| void *memchr(const void *<[src]>, int <[c]>, size_t <[length]>); |
| |
| TRAD_SYNOPSIS |
| #include <string.h> |
| void *memchr(<[src]>, <[c]>, <[length]>) |
| void *<[src]>; |
| void *<[c]>; |
| size_t <[length]>; |
| |
| DESCRIPTION |
| This function searches memory starting at <<*<[src]>>> for the |
| character <[c]>. The search only ends with the first |
| occurrence of <[c]>, or after <[length]> characters; in |
| particular, <<NUL>> does not terminate the search. |
| |
| RETURNS |
| If the character <[c]> is found within <[length]> characters |
| of <<*<[src]>>>, a pointer to the character is returned. If |
| <[c]> is not found, then <<NULL>> is returned. |
| |
| PORTABILITY |
| <<memchr>> is ANSI C. |
| |
| <<memchr>> requires no supporting OS subroutines. |
| |
| QUICKREF |
| memchr ansi pure |
| */ |
| |
| #include "_ansi.h" |
| #include <string.h> |
| #include <limits.h> |
| |
| /* Nonzero if either X or Y is not aligned on a "long" boundary. */ |
| #define UNALIGNED(X) ((long)X & (sizeof(long) - 1)) |
| |
| /* How many bytes are loaded each iteration of the word copy loop. */ |
| #define LBLOCKSIZE (sizeof(long)) |
| |
| /* Threshhold for punting to the bytewise iterator. */ |
| #define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) |
| |
| #if LONG_MAX == 2147483647L |
| #define DETECTNULL(X) (((X) - 0x01010101L) & ~(X) & 0x80808080UL) |
| #else |
| #if LONG_MAX == 9223372036854775807L |
| /* Nonzero if X (a long int) contains a NULL byte. */ |
| #define DETECTNULL(X) (((X) - 0x0101010101010101L) & ~(X) & \ |
| 0x8080808080808080UL) |
| #else |
| #error long int is not a 32bit or 64bit type. |
| #endif |
| #endif |
| |
| #ifndef DETECTNULL |
| #error long int is not a 32bit or 64bit byte |
| #endif |
| |
| /* DETECTCHAR returns nonzero if (long)X contains the byte used |
| to fill (long)MASK. */ |
| #define DETECTCHAR(X, MASK) (DETECTNULL(X ^ MASK)) |
| |
| _PTR |
| _DEFUN(memchr, (src_void, c, length), _CONST _PTR src_void _AND int c |
| _AND size_t length) |
| { |
| _CONST unsigned char *src = (_CONST unsigned char *)src_void; |
| unsigned char d = c; |
| |
| #if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__) |
| unsigned long *asrc; |
| unsigned long mask; |
| int i; |
| |
| while (UNALIGNED(src)) { |
| if (!length--) |
| return NULL; |
| if (*src == d) |
| return (void *)src; |
| src++; |
| } |
| |
| if (!TOO_SMALL(length)) { |
| /* If we get this far, we know that length is large and src is |
| word-aligned. */ |
| /* The fast code reads the source 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 NUL in the |
| result. */ |
| asrc = (unsigned long *)src; |
| mask = d << 8 | d; |
| mask = mask << 16 | mask; |
| for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) |
| mask = (mask << i) | mask; |
| |
| while (length >= LBLOCKSIZE) { |
| if (DETECTCHAR(*asrc, mask)) |
| break; |
| length -= LBLOCKSIZE; |
| asrc++; |
| } |
| |
| /* If there are fewer than LBLOCKSIZE characters left, |
| then we resort to the bytewise loop. */ |
| |
| src = (unsigned char *)asrc; |
| } |
| #endif /* not PREFER_SIZE_OVER_SPEED */ |
| |
| while (length--) { |
| if (*src == d) |
| return (void *)src; |
| src++; |
| } |
| |
| return NULL; |
| } |