tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

memmove.c (4567B)

      1 #if defined(__sun) && !defined(__SVR4)
      2 /*-
      3 * Copyright (c) 1990, 1993
      4 *  The Regents of the University of California.  All rights reserved.
      5 *
      6 * This code is derived from software contributed to Berkeley by
      7 * Chris Torek.
      8 *
      9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions
     11 * are met:
     12 * 1. Redistributions of source code must retain the above copyright
     13 *    notice, this list of conditions and the following disclaimer.
     14 * 2. Redistributions in binary form must reproduce the above copyright
     15 *    notice, this list of conditions and the following disclaimer in the
     16 *    documentation and/or other materials provided with the distribution.
     17 * 3. ***REMOVED*** - see
     18 *    ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change
     19 * 4. Neither the name of the University nor the names of its contributors
     20 *    may be used to endorse or promote products derived from this software
     21 *    without specific prior written permission.
     22 *
     23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33 * SUCH DAMAGE.
     34 */
     35 
     36 #if defined(LIBC_SCCS) && !defined(lint)
     37 static char sccsid[] = "@(#)bcopy.c 8.1 (Berkeley) 6/4/93";
     38 #endif /* LIBC_SCCS and not lint */
     39 
     40 #include <string.h>
     41 
     42 /*
     43 * sizeof(word) MUST BE A POWER OF TWO
     44 * SO THAT wmask BELOW IS ALL ONES
     45 */
     46 typedef int word; /* "word" used for optimal copy speed */
     47 
     48 #define wsize sizeof(word)
     49 #define wmask (wsize - 1)
     50 
     51 /*
     52 * Copy a block of memory, handling overlap.
     53 * This is the routine that actually implements
     54 * (the portable versions of) bcopy, memcpy, and memmove.
     55 */
     56 #ifdef MEMCOPY
     57 void *
     58    memcpy(dst0, src0, length)
     59 #else
     60 #ifdef MEMMOVE
     61 void *
     62    memmove(dst0, src0, length)
     63 #else
     64 void
     65    bcopy(src0, dst0, length)
     66 #endif
     67 #endif
     68        void *dst0;
     69 const void *src0;
     70 register size_t length;
     71 {
     72    register char *dst = dst0;
     73    register const char *src = src0;
     74    register size_t t;
     75 
     76    if (length == 0 || dst == src) /* nothing to do */
     77        goto done;
     78 
     79 /*
     80 * Macros: loop-t-times; and loop-t-times, t>0
     81 */
     82 #define TLOOP(s) \
     83    if (t)       \
     84    TLOOP1(s)
     85 #define TLOOP1(s) \
     86    do {          \
     87        s;        \
     88    } while (--t)
     89 
     90    if ((unsigned long)dst < (unsigned long)src) {
     91        /*
     92         * Copy forward.
     93         */
     94        t = (int)src; /* only need low bits */
     95        if ((t | (int)dst) & wmask) {
     96            /*
     97             * Try to align operands.  This cannot be done
     98             * unless the low bits match.
     99             */
    100            if ((t ^ (int)dst) & wmask || length < wsize)
    101                t = length;
    102            else
    103                t = wsize - (t & wmask);
    104            length -= t;
    105            TLOOP1(*dst++ = *src++);
    106        }
    107        /*
    108         * Copy whole words, then mop up any trailing bytes.
    109         */
    110        t = length / wsize;
    111        TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
    112        t = length & wmask;
    113        TLOOP(*dst++ = *src++);
    114    } else {
    115        /*
    116         * Copy backwards.  Otherwise essentially the same.
    117         * Alignment works as before, except that it takes
    118         * (t&wmask) bytes to align, not wsize-(t&wmask).
    119         */
    120        src += length;
    121        dst += length;
    122        t = (int)src;
    123        if ((t | (int)dst) & wmask) {
    124            if ((t ^ (int)dst) & wmask || length <= wsize)
    125                t = length;
    126            else
    127                t &= wmask;
    128            length -= t;
    129            TLOOP1(*--dst = *--src);
    130        }
    131        t = length / wsize;
    132        TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
    133        t = length & wmask;
    134        TLOOP(*--dst = *--src);
    135    }
    136 done:
    137 #if defined(MEMCOPY) || defined(MEMMOVE)
    138    return (dst0);
    139 #else
    140    return;
    141 #endif
    142 }
    143 #endif /* no __sgi */
    144 
    145 /* Some compilers don't like an empty source file. */
    146 static int dummy = 0;