← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/openhackware/src/libc/src/mem.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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