qemu/roms/openhackware/src/libc/src/mem.c

   1 /*
   2  * <mem.c>
   3  *
   4  * Open Hack'Ware BIOS: mem<xxx> functions
   5  *
   6  * Copyright (c) 2004-2005 Jocelyn Mayer
   7  *
   8  *   This program is free software; you can redistribute it and/or
   9  *   modify it under the terms of the GNU General Public License V2
  10  *   as published by the Free Software Foundation
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* functions prototypes are here */
  23 #include <string.h>
  24 /* NULL is declared here */
  25 #include <stdlib.h>
  26
  27 /* mem___ functions */
  28 #if defined (__USE_memcpy__)
  29 void *memcpy (void *dest, const void *src, size_t n)
  30 {
  31     const char *p;
  32     char *q;
  33
  34     p = src;
  35     q = dest;
  36     for (; n != 0; n--)
  37         *q++ = *p++;
  38
  39     return dest;
  40 }
  41 #endif
  42
  43 #if defined (__USE_memccpy__)
  44 void *memccpy (void *dest, const void *src, int c, size_t n)
  45 {
  46     const char *p;
  47     char *q, *r;
  48
  49     p = src;
  50     q = dest;
  51     r = NULL;
  52     for (; n != 0; n--, q++) {
  53         *q = *p++;
  54         if (*q == c) {
  55             r = q;
  56             break;
  57         }
  58     }
  59
  60     return r;
  61 }
  62 #endif
  63
  64 #if defined (__USE_mempcpy__)
  65 /* GNU extension */
  66 void *mempcpy (void *dest, const void *src, size_t n)
  67 {
  68     const char *p;
  69     char *q;
  70
  71     p = src;
  72     q = dest;
  73     for (; n != 0; n--)
  74         *q++ = *p++;
  75
  76     return q;
  77 }
  78 #endif
  79
  80 #if defined (__USE_memmove__)
  81 void *memmove (void *dest, const void *src, size_t n)
  82 {
  83     const char *p;
  84     char *q;
  85
  86     p = src;
  87     q = dest;
  88     if (dest <= src) {
  89         for (; n != 0; n--)
  90             *q++ = *p++;
  91     } else {
  92         p += n;
  93         q += n;
  94         for (; n != 0; n--)
  95             *--q = *--p;
  96     }
  97
  98     return dest;
  99 }
 100 #endif
 101
 102 #if defined (__USE_memcmove__)
 103 /* OHW extension */
 104 void *memcmove (void *dest, const void *src, int c, size_t n)
 105 {
 106     const char *p;
 107     char *q, *r;
 108
 109     p = src;
 110     q = dest;
 111     r = NULL;
 112     if (dest <= src) {
 113         for (; n != 0; n--, q++) {
 114             *q++ = *p++;
 115             if (*q == c) {
 116                 r = q;
 117                 break;
 118             }
 119         }
 120     } else {
 121         p += n;
 122         q += n;
 123         for (; n != 0; n--, q--) {
 124             *--q = *--p;
 125             if (*q == c) {
 126                 r = q;
 127                 break;
 128             }
 129         }
 130     }
 131
 132     return dest;
 133 }
 134 #endif
 135
 136 #if defined (__USE_mempmove__)
 137 /* OHW extension */
 138 void *mempmove (void *dest, const void *src, size_t n)
 139 {
 140     const char *p;
 141     char *q, *r;
 142
 143     p = src;
 144     q = dest;
 145     r = q + n;
 146     if (dest <= src) {
 147         for (; n != 0; n--)
 148             *q++ = *p++;
 149     } else {
 150         p += n;
 151         q = r;
 152         for (; n != 0; n--)
 153             *--q = *--p;
 154     }
 155
 156     return r;
 157 }
 158 #endif
 159
 160 #if defined (__USE_memset__)
 161 void *memset (void *s, int c, size_t n)
 162 {
 163     char *p;
 164
 165     for (p = s; n != 0; n--)
 166         *p++ = c;
 167
 168     return s;
 169 }
 170 #endif
 171
 172 #if defined (__USE_memcmp__)
 173 int memcmp (const void *s1, const void *s2, size_t n)
 174 {
 175     const char *p, *q;
 176     int ret;
 177
 178     p = s1;
 179     q = s2;
 180     for (ret = 0; n != 0 && ret == 0; n--)
 181         ret = *p++ - *q++;
 182
 183     return ret;
 184 }
 185 #endif
 186
 187 #if defined (__USE_memchr__)
 188 void *memchr (const void *s, int c, size_t n)
 189 {
 190     const char *p, *r;
 191
 192     r = NULL;
 193     for (p = s; n != 0; n--, p++) {
 194         if (*p == c) {
 195             r = p;
 196             break;
 197         }
 198     }
 199
 200     return (void *)r;
 201 }
 202 #endif
 203
 204 #if defined (__USE_rawmemchr__)
 205 /* GNU extension */
 206 void *rawmemchr (const void *s, int c)
 207 {
 208     const char *p;
 209
 210     for (p = s; *p != c; p++)
 211         continue;
 212
 213     return (void *)p;
 214 }
 215 #endif
 216
 217 #if defined (__USE_memrchr__)
 218 void *memrchr (const void *s, int c, size_t n)
 219 {
 220     const char *p, *r;
 221
 222     r = NULL;
 223     for (p = s + n; n != 0; n--, p--) {
 224         if (*p == c) {
 225             r = p;
 226             break;
 227         }
 228     }
 229
 230     return (void *)r;
 231 }
 232 #endif
 233
 234 #if defined (__USE_memmem__)
 235 /* GNU extension */
 236 void *memmem (const void *haystack, size_t haystacklen,
 237               const void *needle, size_t neddlelen)
 238 {
 239     const char *p, *r;
 240
 241     r = NULL;
 242     for (p = haystack; haystacklen > neddlelen; haystacklen--, p++) {
 243         if (memcmp(p, needle, neddlelen) == 0) {
 244             r = p;
 245             break;
 246         }
 247     }
 248
 249     return (void *)r;
 250 }
 251 #endif