URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [lib/] [string.c] - Blame information for rev 1777

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  linux/lib/string.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */
 
/*
 * stupid library routines.. The optimized versions should generally be found
 * as inline code in <asm-xx/string.h>
 *
 * These are buggy as well..
 */
 
#include <linux/types.h>
#include <linux/string.h>
 
char * ___strtok = NULL;
 
#ifndef __HAVE_ARCH_STRCPY
char * strcpy(char * dest,const char *src)
{
        char *tmp = dest;
 
        while ((*dest++ = *src++) != '\0')
                /* nothing */;
        return tmp;
}
#endif
 
#ifndef __HAVE_ARCH_STRNCPY
char * strncpy(char * dest,const char *src,size_t count)
{
        char *tmp = dest;
 
        while (count-- && (*dest++ = *src++) != '\0')
                /* nothing */;
 
        return tmp;
}
#endif
 
#ifndef __HAVE_ARCH_STRCAT
char * strcat(char * dest, const char * src)
{
        char *tmp = dest;
 
        while (*dest)
                dest++;
        while ((*dest++ = *src++) != '\0')
                ;
 
        return tmp;
}
#endif
 
#ifndef __HAVE_ARCH_STRNCAT
char * strncat(char *dest, const char *src, size_t count)
{
        char *tmp = dest;
 
        if (count) {
                while (*dest)
                        dest++;
                while ((*dest++ = *src++)) {
                        if (--count == 0) {
                                *dest = '\0';
                                break;
                        }
                }
        }
 
        return tmp;
}
#endif
 
#ifndef __HAVE_ARCH_STRCMP
int strcmp(const char * cs,const char * ct)
{
        register signed char __res;
 
        while (1) {
                if ((__res = *cs - *ct++) != 0 || !*cs++)
                        break;
        }
 
        return __res;
}
#endif
 
#ifndef __HAVE_ARCH_STRNCMP
int strncmp(const char * cs,const char * ct,size_t count)
{
        register signed char __res = 0;
 
        while (count) {
                if ((__res = *cs - *ct++) != 0 || !*cs++)
                        break;
                count--;
        }
 
        return __res;
}
#endif
 
#ifndef __HAVE_ARCH_STRCHR
char * strchr(const char * s, int c)
{
        for(; *s != (char) c; ++s)
                if (*s == '\0')
                        return NULL;
        return (char *) s;
}
#endif
 
#ifndef __HAVE_ARCH_STRRCHR
char * strrchr(const char * s, int c)
{
       const char *p = s + strlen(s);
       do {
           if (*p == (char)c)
               return (char *)p;
       } while (--p >= s);
       return NULL;
}
#endif
 
#ifndef __HAVE_ARCH_STRLEN
size_t strlen(const char * s)
{
        const char *sc;
 
        for (sc = s; *sc != '\0'; ++sc)
                /* nothing */;
        return sc - s;
}
#endif
 
#ifndef __HAVE_ARCH_STRNLEN
size_t strnlen(const char * s, size_t count)
{
        const char *sc;
 
        for (sc = s; count-- && *sc != '\0'; ++sc)
                /* nothing */;
        return sc - s;
}
#endif
 
#ifndef __HAVE_ARCH_STRSPN
size_t strspn(const char *s, const char *accept)
{
        const char *p;
        const char *a;
        size_t count = 0;
 
        for (p = s; *p != '\0'; ++p) {
                for (a = accept; *a != '\0'; ++a) {
                        if (*p == *a)
                                break;
                }
                if (*a == '\0')
                        return count;
                ++count;
        }
 
        return count;
}
#endif
 
#ifndef __HAVE_ARCH_STRPBRK
char * strpbrk(const char * cs,const char * ct)
{
        const char *sc1,*sc2;
 
        for( sc1 = cs; *sc1 != '\0'; ++sc1) {
                for( sc2 = ct; *sc2 != '\0'; ++sc2) {
                        if (*sc1 == *sc2)
                                return (char *) sc1;
                }
        }
        return NULL;
}
#endif
 
#ifndef __HAVE_ARCH_STRTOK
char * strtok(char * s,const char * ct)
{
        char *sbegin, *send;
 
        sbegin  = s ? s : ___strtok;
        if (!sbegin) {
                return NULL;
        }
        sbegin += strspn(sbegin,ct);
        if (*sbegin == '\0') {
                ___strtok = NULL;
                return( NULL );
        }
        send = strpbrk( sbegin, ct);
        if (send && *send != '\0')
                *send++ = '\0';
        ___strtok = send;
        return (sbegin);
}
#endif
 
#ifndef __HAVE_ARCH_MEMSET
void * memset(void * s,int c,size_t count)
{
        char *xs = (char *) s;
 
        while (count--)
                *xs++ = c;
 
        return s;
}
#endif
 
#ifndef __HAVE_ARCH_BCOPY
char * bcopy(const char * src, char * dest, int count)
{
        char *tmp = dest;
 
        while (count--)
                *tmp++ = *src++;
 
        return dest;
}
#endif
 
#ifndef __HAVE_ARCH_MEMCPY
void * memcpy(void * dest,const void *src,size_t count)
{
        char *tmp = (char *) dest, *s = (char *) src;
 
        while (count--)
                *tmp++ = *s++;
 
        return dest;
}
#endif
 
#ifndef __HAVE_ARCH_MEMMOVE
void * memmove(void * dest,const void *src,size_t count)
{
        char *tmp, *s;
 
        if (dest <= src) {
                tmp = (char *) dest;
                s = (char *) src;
                while (count--)
                        *tmp++ = *s++;
                }
        else {
                tmp = (char *) dest + count;
                s = (char *) src + count;
                while (count--)
                        *--tmp = *--s;
                }
 
        return dest;
}
#endif
 
#ifndef __HAVE_ARCH_MEMCMP
int memcmp(const void * cs,const void * ct,size_t count)
{
        const unsigned char *su1, *su2;
        signed char res = 0;
 
        for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
                if ((res = *su1 - *su2) != 0)
                        break;
        return res;
}
#endif
 
/*
 * find the first occurrence of byte 'c', or 1 past the area if none
 */
#ifndef __HAVE_ARCH_MEMSCAN
void * memscan(void * addr, int c, size_t size)
{
        unsigned char * p = (unsigned char *) addr;
 
        while (size) {
                if (*p == c)
                        return (void *) p;
                p++;
                size--;
        }
        return (void *) p;
}
#endif
 
#ifndef __HAVE_ARCH_STRSTR
char * strstr(const char * s1,const char * s2)
{
        int l1, l2;
 
        l2 = strlen(s2);
        if (!l2)
                return (char *) s1;
        l1 = strlen(s1);
        while (l1 >= l2) {
                l1--;
                if (!memcmp(s1,s2,l2))
                        return (char *) s1;
                s1++;
        }
        return NULL;
}
#endif

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [lib/] [string.c] - Blame information for rev 1777

Line No.	Rev	Author	Line
1	1634	jcastillo	`/*`
2			`* linux/lib/string.c`
3			`*`
4			`* Copyright (C) 1991, 1992 Linus Torvalds`
5			`*/`
6
7			`/*`
8			`* stupid library routines.. The optimized versions should generally be found`
9			`* as inline code in <asm-xx/string.h>`
10			`*`
11			`* These are buggy as well..`
12			`*/`
13
14			`#include <linux/types.h>`
15			`#include <linux/string.h>`
16
17			`char * ___strtok = NULL;`
18
19			`#ifndef __HAVE_ARCH_STRCPY`
20			`char * strcpy(char * dest,const char *src)`
21			`{`
22			`char *tmp = dest;`
23
24			`while ((dest++ = src++) != '\0')`
25			`/* nothing */;`
26			`return tmp;`
27			`}`
28			`#endif`
29
30			`#ifndef __HAVE_ARCH_STRNCPY`
31			`char * strncpy(char * dest,const char *src,size_t count)`
32			`{`
33			`char *tmp = dest;`
34
35			`while (count-- && (dest++ = src++) != '\0')`
36			`/* nothing */;`
37
38			`return tmp;`
39			`}`
40			`#endif`
41
42			`#ifndef __HAVE_ARCH_STRCAT`
43			`char * strcat(char * dest, const char * src)`
44			`{`
45			`char *tmp = dest;`
46
47			`while (*dest)`
48			`dest++;`
49			`while ((dest++ = src++) != '\0')`
50			`;`
51
52			`return tmp;`
53			`}`
54			`#endif`
55
56			`#ifndef __HAVE_ARCH_STRNCAT`
57			`char * strncat(char dest, const char src, size_t count)`
58			`{`
59			`char *tmp = dest;`
60
61			`if (count) {`
62			`while (*dest)`
63			`dest++;`
64			`while ((dest++ = src++)) {`
65			`if (--count == 0) {`
66			`*dest = '\0';`
67			`break;`
68			`}`
69			`}`
70			`}`
71
72			`return tmp;`
73			`}`
74			`#endif`
75
76			`#ifndef __HAVE_ARCH_STRCMP`
77			`int strcmp(const char * cs,const char * ct)`
78			`{`
79			`register signed char __res;`
80
81			`while (1) {`
82			`if ((__res = cs - ct++) != 0 \|\| !*cs++)`
83			`break;`
84			`}`
85
86			`return __res;`
87			`}`
88			`#endif`
89
90			`#ifndef __HAVE_ARCH_STRNCMP`
91			`int strncmp(const char * cs,const char * ct,size_t count)`
92			`{`
93			`register signed char __res = 0;`
94
95			`while (count) {`
96			`if ((__res = cs - ct++) != 0 \|\| !*cs++)`
97			`break;`
98			`count--;`
99			`}`
100
101			`return __res;`
102			`}`
103			`#endif`
104
105			`#ifndef __HAVE_ARCH_STRCHR`
106			`char * strchr(const char * s, int c)`
107			`{`
108			`for(; *s != (char) c; ++s)`
109			`if (*s == '\0')`
110			`return NULL;`
111			`return (char *) s;`
112			`}`
113			`#endif`
114
115			`#ifndef __HAVE_ARCH_STRRCHR`
116			`char * strrchr(const char * s, int c)`
117			`{`
118			`const char *p = s + strlen(s);`
119			`do {`
120			`if (*p == (char)c)`
121			`return (char *)p;`
122			`} while (--p >= s);`
123			`return NULL;`
124			`}`
125			`#endif`
126
127			`#ifndef __HAVE_ARCH_STRLEN`
128			`size_t strlen(const char * s)`
129			`{`
130			`const char *sc;`
131
132			`for (sc = s; *sc != '\0'; ++sc)`
133			`/* nothing */;`
134			`return sc - s;`
135			`}`
136			`#endif`
137
138			`#ifndef __HAVE_ARCH_STRNLEN`
139			`size_t strnlen(const char * s, size_t count)`
140			`{`
141			`const char *sc;`
142
143			`for (sc = s; count-- && *sc != '\0'; ++sc)`
144			`/* nothing */;`
145			`return sc - s;`
146			`}`
147			`#endif`
148
149			`#ifndef __HAVE_ARCH_STRSPN`
150			`size_t strspn(const char s, const char accept)`
151			`{`
152			`const char *p;`
153			`const char *a;`
154			`size_t count = 0;`
155
156			`for (p = s; *p != '\0'; ++p) {`
157			`for (a = accept; *a != '\0'; ++a) {`
158			`if (p == a)`
159			`break;`
160			`}`
161			`if (*a == '\0')`
162			`return count;`
163			`++count;`
164			`}`
165
166			`return count;`
167			`}`
168			`#endif`
169
170			`#ifndef __HAVE_ARCH_STRPBRK`
171			`char * strpbrk(const char * cs,const char * ct)`
172			`{`
173			`const char sc1,sc2;`
174
175			`for( sc1 = cs; *sc1 != '\0'; ++sc1) {`
176			`for( sc2 = ct; *sc2 != '\0'; ++sc2) {`
177			`if (sc1 == sc2)`
178			`return (char *) sc1;`
179			`}`
180			`}`
181			`return NULL;`
182			`}`
183			`#endif`
184
185			`#ifndef __HAVE_ARCH_STRTOK`
186			`char * strtok(char * s,const char * ct)`
187			`{`
188			`char sbegin, send;`
189
190			`sbegin = s ? s : ___strtok;`
191			`if (!sbegin) {`
192			`return NULL;`
193			`}`
194			`sbegin += strspn(sbegin,ct);`
195			`if (*sbegin == '\0') {`
196			`___strtok = NULL;`
197			`return( NULL );`
198			`}`
199			`send = strpbrk( sbegin, ct);`
200			`if (send && *send != '\0')`
201			`*send++ = '\0';`
202			`___strtok = send;`
203			`return (sbegin);`
204			`}`
205			`#endif`
206
207			`#ifndef __HAVE_ARCH_MEMSET`
208			`void * memset(void * s,int c,size_t count)`
209			`{`
210			`char xs = (char ) s;`
211
212			`while (count--)`
213			`*xs++ = c;`
214
215			`return s;`
216			`}`
217			`#endif`
218
219			`#ifndef __HAVE_ARCH_BCOPY`
220			`char * bcopy(const char * src, char * dest, int count)`
221			`{`
222			`char *tmp = dest;`
223
224			`while (count--)`
225			`tmp++ = src++;`
226
227			`return dest;`
228			`}`
229			`#endif`
230
231			`#ifndef __HAVE_ARCH_MEMCPY`
232			`void * memcpy(void * dest,const void *src,size_t count)`
233			`{`
234			`char tmp = (char ) dest, s = (char ) src;`
235
236			`while (count--)`
237			`tmp++ = s++;`
238
239			`return dest;`
240			`}`
241			`#endif`
242
243			`#ifndef __HAVE_ARCH_MEMMOVE`
244			`void * memmove(void * dest,const void *src,size_t count)`
245			`{`
246			`char tmp, s;`
247
248			`if (dest <= src) {`
249			`tmp = (char *) dest;`
250			`s = (char *) src;`
251			`while (count--)`
252			`tmp++ = s++;`
253			`}`
254			`else {`
255			`tmp = (char *) dest + count;`
256			`s = (char *) src + count;`
257			`while (count--)`
258			`--tmp = --s;`
259			`}`
260
261			`return dest;`
262			`}`
263			`#endif`
264
265			`#ifndef __HAVE_ARCH_MEMCMP`
266			`int memcmp(const void * cs,const void * ct,size_t count)`
267			`{`
268			`const unsigned char su1, su2;`
269			`signed char res = 0;`
270
271			`for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)`
272			`if ((res = su1 - su2) != 0)`
273			`break;`
274			`return res;`
275			`}`
276			`#endif`
277
278			`/*`
279			`* find the first occurrence of byte 'c', or 1 past the area if none`
280			`*/`
281			`#ifndef __HAVE_ARCH_MEMSCAN`
282			`void * memscan(void * addr, int c, size_t size)`
283			`{`
284			`unsigned char * p = (unsigned char *) addr;`
285
286			`while (size) {`
287			`if (*p == c)`
288			`return (void *) p;`
289			`p++;`
290			`size--;`
291			`}`
292			`return (void *) p;`
293			`}`
294			`#endif`
295
296			`#ifndef __HAVE_ARCH_STRSTR`
297			`char * strstr(const char * s1,const char * s2)`
298			`{`
299			`int l1, l2;`
300
301			`l2 = strlen(s2);`
302			`if (!l2)`
303			`return (char *) s1;`
304			`l1 = strlen(s1);`
305			`while (l1 >= l2) {`
306			`l1--;`
307			`if (!memcmp(s1,s2,l2))`
308			`return (char *) s1;`
309			`s1++;`
310			`}`
311			`return NULL;`
312			`}`
313			`#endif`