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

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [include/] [asm-m68k/] [string.h] - Blame information for rev 1765

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


#ifndef _M68K_STRING_H_
#define _M68K_STRING_H_
 
#define __HAVE_ARCH_STRCPY
extern inline char * strcpy(char * dest,const char *src)
{
  char *xdest = dest;
 
  __asm__ __volatile__
       ("1:\tmoveb %1@+,%0@+\n\t"
        "jne 1b"
        : "=a" (dest), "=a" (src)
        : "0" (dest), "1" (src) : "memory");
  return xdest;
}
 
#define __HAVE_ARCH_STRNCPY
extern inline char * strncpy(char *dest, const char *src, size_t n)
{
  char *xdest = dest;
 
  if (n == 0)
    return xdest;
 
  __asm__ __volatile__
       ("1:\tmoveb %1@+,%0@+\n\t"
        "jeq 2f\n\t"
        "subql #1,%2\n\t"
        "jne 1b\n\t"
        "2:"
        : "=a" (dest), "=a" (src), "=d" (n)
        : "0" (dest), "1" (src), "2" (n)
        : "memory");
  return xdest;
}
 
#define __HAVE_ARCH_STRCAT
extern inline char * strcat(char * dest, const char * src)
{
        char *tmp = dest;
 
        while (*dest)
                dest++;
        while ((*dest++ = *src++))
                ;
 
        return tmp;
}
 
#define __HAVE_ARCH_STRNCAT
extern inline 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;
}
 
#define __HAVE_ARCH_STRCHR
extern inline char * strchr(const char * s, int c)
{
  const char ch = c;
 
  for(; *s != ch; ++s)
    if (*s == '\0')
      return( NULL );
  return( (char *) s);
}
 
#define __HAVE_ARCH_STRPBRK
extern inline 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 );
}
 
#define __HAVE_ARCH_STRSPN
extern inline 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;
      else
        ++count;
    }
 
  return count;
}
 
#define __HAVE_ARCH_STRTOK
extern inline 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);
}
 
/* strstr !! */
 
#define __HAVE_ARCH_STRLEN
extern inline size_t strlen(const char * s)
{
  const char *sc;
  for (sc = s; *sc != '\0'; ++sc) ;
  return(sc - s);
}
 
/* strnlen !! */
 
#define __HAVE_ARCH_STRCMP
extern inline int strcmp(const char * cs,const char * ct)
{
  char __res;
 
  __asm__
       ("1:\tmoveb %0@+,%2\n\t" /* get *cs */
        "cmpb %1@+,%2\n\t"      /* compare a byte */
        "jne  2f\n\t"           /* not equal, break out */
        "tstb %2\n\t"           /* at end of cs? */
        "jne  1b\n\t"           /* no, keep going */
        "jra  3f\n\t"           /* strings are equal */
        "2:\tsubb %1@-,%2\n\t"  /* *cs - *ct */
        "3:"
        : "=a" (cs), "=a" (ct), "=d" (__res)
        : "0" (cs), "1" (ct));
  return __res;
}
 
#define __HAVE_ARCH_STRNCMP
extern inline int strncmp(const char * cs,const char * ct,size_t count)
{
  char __res;
 
  if (!count)
    return 0;
  __asm__
       ("1:\tmovb %0@+,%3\n\t"          /* get *cs */
        "cmpb   %1@+,%3\n\t"            /* compare a byte */
        "jne    3f\n\t"                 /* not equal, break out */
        "tstb   %3\n\t"                 /* at end of cs? */
        "jeq    4f\n\t"                 /* yes, all done */
        "subql  #1,%2\n\t"              /* no, adjust count */
        "jne    1b\n\t"                 /* more to do, keep going */
        "2:\tmoveq #0,%3\n\t"           /* strings are equal */
        "jra    4f\n\t"
        "3:\tsubb %1@-,%3\n\t"          /* *cs - *ct */
        "4:"
        : "=a" (cs), "=a" (ct), "=d" (count), "=d" (__res)
        : "0" (cs), "1" (ct), "2" (count));
  return __res;
}
 
#define __HAVE_ARCH_MEMSET
extern inline void * memset(void * s,int c,size_t count)
{
  void *xs = s;
  size_t temp;
 
  if (!count)
    return xs;
  c &= 0xff;
  if ((long) s & 1)
    {
      char *cs = s;
      *cs++ = c;
      s = cs;
      count--;
    }
  c |= c << 8;
  if (count > 2 && (long) s & 2)
    {
      short *ss = s;
      *ss++ = c;
      s = ss;
      count -= 2;
    }
  temp = count >> 2;
  if (temp)
    {
      long *ls = s;
      c |= c << 16;
      temp--;
      do
        *ls++ = c;
      while (temp--);
      s = ls;
    }
  if (count & 2)
    {
      short *ss = s;
      *ss++ = c;
      s = ss;
    }
  if (count & 1)
    {
      char *cs = s;
      *cs = c;
    }
  return xs;
}
 
#define __HAVE_ARCH_MEMCPY
#define memcpy(to, from, n) \
(__builtin_constant_p(n) ? \
 __builtin_memcpy((to),(from),(n)) : \
 memcpy((to),(from),(n)))
 
#define __HAVE_ARCH_MEMMOVE
extern inline void * memmove(void * dest,const void * src, size_t n)
{
  void *xdest = dest;
  size_t temp;
 
  if (!n)
    return xdest;
 
  if (dest < src)
    {
      if ((long) dest & 1)
        {
          char *cdest = dest;
          const char *csrc = src;
          *cdest++ = *csrc++;
          dest = cdest;
          src = csrc;
          n--;
        }
      if (n > 2 && (long) dest & 2)
        {
          short *sdest = dest;
          const short *ssrc = src;
          *sdest++ = *ssrc++;
          dest = sdest;
          src = ssrc;
          n -= 2;
        }
      temp = n >> 2;
      if (temp)
        {
          long *ldest = dest;
          const long *lsrc = src;
          temp--;
          do
            *ldest++ = *lsrc++;
          while (temp--);
          dest = ldest;
          src = lsrc;
        }
      if (n & 2)
        {
          short *sdest = dest;
          const short *ssrc = src;
          *sdest++ = *ssrc++;
          dest = sdest;
          src = ssrc;
        }
      if (n & 1)
        {
          char *cdest = dest;
          const char *csrc = src;
          *cdest = *csrc;
        }
    }
  else
    {
      dest = (char *) dest + n;
      src = (const char *) src + n;
      if ((long) dest & 1)
        {
          char *cdest = dest;
          const char *csrc = src;
          *--cdest = *--csrc;
          dest = cdest;
          src = csrc;
          n--;
        }
      if (n > 2 && (long) dest & 2)
        {
          short *sdest = dest;
          const short *ssrc = src;
          *--sdest = *--ssrc;
          dest = sdest;
          src = ssrc;
          n -= 2;
        }
      temp = n >> 2;
      if (temp)
        {
          long *ldest = dest;
          const long *lsrc = src;
          temp--;
          do
            *--ldest = *--lsrc;
          while (temp--);
          dest = ldest;
          src = lsrc;
        }
      if (n & 2)
        {
          short *sdest = dest;
          const short *ssrc = src;
          *--sdest = *--ssrc;
          dest = sdest;
          src = ssrc;
        }
      if (n & 1)
        {
          char *cdest = dest;
          const char *csrc = src;
          *--cdest = *--csrc;
        }
    }
  return xdest;
}
 
#define __HAVE_ARCH_MEMCMP
#define memcmp(cs, ct, n) \
(__builtin_constant_p(n) ? \
 __builtin_memcmp((cs),(ct),(n)) : \
 memcmp((cs),(ct),(n)))
 
#endif /* _M68K_STRING_H_ */

Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [include/] [asm-m68k/] [string.h] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1633	jcastillo	`#ifndef _M68K_STRING_H_`
2			`#define _M68K_STRING_H_`
3
4			`#define __HAVE_ARCH_STRCPY`
5			`extern inline char * strcpy(char * dest,const char *src)`
6			`{`
7			`char *xdest = dest;`
8
9			`__asm__ __volatile__`
10			`("1:\tmoveb %1@+,%0@+\n\t"`
11			`"jne 1b"`
12			`: "=a" (dest), "=a" (src)`
13			`: "0" (dest), "1" (src) : "memory");`
14			`return xdest;`
15			`}`
16
17			`#define __HAVE_ARCH_STRNCPY`
18			`extern inline char * strncpy(char dest, const char src, size_t n)`
19			`{`
20			`char *xdest = dest;`
21
22			`if (n == 0)`
23			`return xdest;`
24
25			`__asm__ __volatile__`
26			`("1:\tmoveb %1@+,%0@+\n\t"`
27			`"jeq 2f\n\t"`
28			`"subql #1,%2\n\t"`
29			`"jne 1b\n\t"`
30			`"2:"`
31			`: "=a" (dest), "=a" (src), "=d" (n)`
32			`: "0" (dest), "1" (src), "2" (n)`
33			`: "memory");`
34			`return xdest;`
35			`}`
36
37			`#define __HAVE_ARCH_STRCAT`
38			`extern inline char * strcat(char * dest, const char * src)`
39			`{`
40			`char *tmp = dest;`
41
42			`while (*dest)`
43			`dest++;`
44			`while ((dest++ = src++))`
45			`;`
46
47			`return tmp;`
48			`}`
49
50			`#define __HAVE_ARCH_STRNCAT`
51			`extern inline char * strncat(char dest, const char src, size_t count)`
52			`{`
53			`char *tmp = dest;`
54
55			`if (count) {`
56			`while (*dest)`
57			`dest++;`
58			`while ((dest++ = src++)) {`
59			`if (--count == 0) {`
60			`*dest++='\0';`
61			`break;`
62			`}`
63			`}`
64			`}`
65
66			`return tmp;`
67			`}`
68
69			`#define __HAVE_ARCH_STRCHR`
70			`extern inline char * strchr(const char * s, int c)`
71			`{`
72			`const char ch = c;`
73
74			`for(; *s != ch; ++s)`
75			`if (*s == '\0')`
76			`return( NULL );`
77			`return( (char *) s);`
78			`}`
79
80			`#define __HAVE_ARCH_STRPBRK`
81			`extern inline char * strpbrk(const char * cs,const char * ct)`
82			`{`
83			`const char sc1,sc2;`
84
85			`for( sc1 = cs; *sc1 != '\0'; ++sc1)`
86			`for( sc2 = ct; *sc2 != '\0'; ++sc2)`
87			`if (sc1 == sc2)`
88			`return((char *) sc1);`
89			`return( NULL );`
90			`}`
91
92			`#define __HAVE_ARCH_STRSPN`
93			`extern inline size_t strspn(const char s, const char accept)`
94			`{`
95			`const char *p;`
96			`const char *a;`
97			`size_t count = 0;`
98
99			`for (p = s; *p != '\0'; ++p)`
100			`{`
101			`for (a = accept; *a != '\0'; ++a)`
102			`if (p == a)`
103			`break;`
104			`if (*a == '\0')`
105			`return count;`
106			`else`
107			`++count;`
108			`}`
109
110			`return count;`
111			`}`
112
113			`#define __HAVE_ARCH_STRTOK`
114			`extern inline char * strtok(char * s,const char * ct)`
115			`{`
116			`char sbegin, send;`
117
118			`sbegin = s ? s : ___strtok;`
119			`if (!sbegin) {`
120			`return NULL;`
121			`}`
122			`sbegin += strspn(sbegin,ct);`
123			`if (*sbegin == '\0') {`
124			`___strtok = NULL;`
125			`return( NULL );`
126			`}`
127			`send = strpbrk( sbegin, ct);`
128			`if (send && *send != '\0')`
129			`*send++ = '\0';`
130			`___strtok = send;`
131			`return (sbegin);`
132			`}`
133
134			`/* strstr !! */`
135
136			`#define __HAVE_ARCH_STRLEN`
137			`extern inline size_t strlen(const char * s)`
138			`{`
139			`const char *sc;`
140			`for (sc = s; *sc != '\0'; ++sc) ;`
141			`return(sc - s);`
142			`}`
143
144			`/* strnlen !! */`
145
146			`#define __HAVE_ARCH_STRCMP`
147			`extern inline int strcmp(const char * cs,const char * ct)`
148			`{`
149			`char __res;`
150
151			`__asm__`
152			`("1:\tmoveb %0@+,%2\n\t" /* get cs /`
153			`"cmpb %1@+,%2\n\t" /* compare a byte */`
154			`"jne 2f\n\t" /* not equal, break out */`
155			`"tstb %2\n\t" /* at end of cs? */`
156			`"jne 1b\n\t" /* no, keep going */`
157			`"jra 3f\n\t" /* strings are equal */`
158			`"2:\tsubb %1@-,%2\n\t" /* cs - ct */`
159			`"3:"`
160			`: "=a" (cs), "=a" (ct), "=d" (__res)`
161			`: "0" (cs), "1" (ct));`
162			`return __res;`
163			`}`
164
165			`#define __HAVE_ARCH_STRNCMP`
166			`extern inline int strncmp(const char * cs,const char * ct,size_t count)`
167			`{`
168			`char __res;`
169
170			`if (!count)`
171			`return 0;`
172			`__asm__`
173			`("1:\tmovb %0@+,%3\n\t" /* get cs /`
174			`"cmpb %1@+,%3\n\t" /* compare a byte */`
175			`"jne 3f\n\t" /* not equal, break out */`
176			`"tstb %3\n\t" /* at end of cs? */`
177			`"jeq 4f\n\t" /* yes, all done */`
178			`"subql #1,%2\n\t" /* no, adjust count */`
179			`"jne 1b\n\t" /* more to do, keep going */`
180			`"2:\tmoveq #0,%3\n\t" /* strings are equal */`
181			`"jra 4f\n\t"`
182			`"3:\tsubb %1@-,%3\n\t" /* cs - ct */`
183			`"4:"`
184			`: "=a" (cs), "=a" (ct), "=d" (count), "=d" (__res)`
185			`: "0" (cs), "1" (ct), "2" (count));`
186			`return __res;`
187			`}`
188
189			`#define __HAVE_ARCH_MEMSET`
190			`extern inline void * memset(void * s,int c,size_t count)`
191			`{`
192			`void *xs = s;`
193			`size_t temp;`
194
195			`if (!count)`
196			`return xs;`
197			`c &= 0xff;`
198			`if ((long) s & 1)`
199			`{`
200			`char *cs = s;`
201			`*cs++ = c;`
202			`s = cs;`
203			`count--;`
204			`}`
205			`c \|= c << 8;`
206			`if (count > 2 && (long) s & 2)`
207			`{`
208			`short *ss = s;`
209			`*ss++ = c;`
210			`s = ss;`
211			`count -= 2;`
212			`}`
213			`temp = count >> 2;`
214			`if (temp)`
215			`{`
216			`long *ls = s;`
217			`c \|= c << 16;`
218			`temp--;`
219			`do`
220			`*ls++ = c;`
221			`while (temp--);`
222			`s = ls;`
223			`}`
224			`if (count & 2)`
225			`{`
226			`short *ss = s;`
227			`*ss++ = c;`
228			`s = ss;`
229			`}`
230			`if (count & 1)`
231			`{`
232			`char *cs = s;`
233			`*cs = c;`
234			`}`
235			`return xs;`
236			`}`
237
238			`#define __HAVE_ARCH_MEMCPY`
239			`#define memcpy(to, from, n) \`
240			`(__builtin_constant_p(n) ? \`
241			`__builtin_memcpy((to),(from),(n)) : \`
242			`memcpy((to),(from),(n)))`
243
244			`#define __HAVE_ARCH_MEMMOVE`
245			`extern inline void * memmove(void * dest,const void * src, size_t n)`
246			`{`
247			`void *xdest = dest;`
248			`size_t temp;`
249
250			`if (!n)`
251			`return xdest;`
252
253			`if (dest < src)`
254			`{`
255			`if ((long) dest & 1)`
256			`{`
257			`char *cdest = dest;`
258			`const char *csrc = src;`
259			`cdest++ = csrc++;`
260			`dest = cdest;`
261			`src = csrc;`
262			`n--;`
263			`}`
264			`if (n > 2 && (long) dest & 2)`
265			`{`
266			`short *sdest = dest;`
267			`const short *ssrc = src;`
268			`sdest++ = ssrc++;`
269			`dest = sdest;`
270			`src = ssrc;`
271			`n -= 2;`
272			`}`
273			`temp = n >> 2;`
274			`if (temp)`
275			`{`
276			`long *ldest = dest;`
277			`const long *lsrc = src;`
278			`temp--;`
279			`do`
280			`ldest++ = lsrc++;`
281			`while (temp--);`
282			`dest = ldest;`
283			`src = lsrc;`
284			`}`
285			`if (n & 2)`
286			`{`
287			`short *sdest = dest;`
288			`const short *ssrc = src;`
289			`sdest++ = ssrc++;`
290			`dest = sdest;`
291			`src = ssrc;`
292			`}`
293			`if (n & 1)`
294			`{`
295			`char *cdest = dest;`
296			`const char *csrc = src;`
297			`cdest = csrc;`
298			`}`
299			`}`
300			`else`
301			`{`
302			`dest = (char *) dest + n;`
303			`src = (const char *) src + n;`
304			`if ((long) dest & 1)`
305			`{`
306			`char *cdest = dest;`
307			`const char *csrc = src;`
308			`--cdest = --csrc;`
309			`dest = cdest;`
310			`src = csrc;`
311			`n--;`
312			`}`
313			`if (n > 2 && (long) dest & 2)`
314			`{`
315			`short *sdest = dest;`
316			`const short *ssrc = src;`
317			`--sdest = --ssrc;`
318			`dest = sdest;`
319			`src = ssrc;`
320			`n -= 2;`
321			`}`
322			`temp = n >> 2;`
323			`if (temp)`
324			`{`
325			`long *ldest = dest;`
326			`const long *lsrc = src;`
327			`temp--;`
328			`do`
329			`--ldest = --lsrc;`
330			`while (temp--);`
331			`dest = ldest;`
332			`src = lsrc;`
333			`}`
334			`if (n & 2)`
335			`{`
336			`short *sdest = dest;`
337			`const short *ssrc = src;`
338			`--sdest = --ssrc;`
339			`dest = sdest;`
340			`src = ssrc;`
341			`}`
342			`if (n & 1)`
343			`{`
344			`char *cdest = dest;`
345			`const char *csrc = src;`
346			`--cdest = --csrc;`
347			`}`
348			`}`
349			`return xdest;`
350			`}`
351
352			`#define __HAVE_ARCH_MEMCMP`
353			`#define memcmp(cs, ct, n) \`
354			`(__builtin_constant_p(n) ? \`
355			`__builtin_memcmp((cs),(ct),(n)) : \`
356			`memcmp((cs),(ct),(n)))`
357
358			`#endif /* _M68K_STRING_H_ */`