← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/arm/boot/compressed/string.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/arm/boot/compressed/string.c
 
1
/*
 
2
 * arch/arm/boot/compressed/string.c
 
3
 *
 
4
 * Small subset of simple string routines
 
5
 */
 
6
 
 
7
#include <linux/string.h>
 
8
 
 
9
void *memcpy(void *__dest, __const void *__src, size_t __n)
 
10
{
 
11
        int i = 0;
 
12
        unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src;
 
13
 
 
14
        for (i = __n >> 3; i > 0; i--) {
 
15
                *d++ = *s++;
 
16
                *d++ = *s++;
 
17
                *d++ = *s++;
 
18
                *d++ = *s++;
 
19
                *d++ = *s++;
 
20
                *d++ = *s++;
 
21
                *d++ = *s++;
 
22
                *d++ = *s++;
 
23
        }
 
24
 
 
25
        if (__n & 1 << 2) {
 
26
                *d++ = *s++;
 
27
                *d++ = *s++;
 
28
                *d++ = *s++;
 
29
                *d++ = *s++;
 
30
        }
 
31
 
 
32
        if (__n & 1 << 1) {
 
33
                *d++ = *s++;
 
34
                *d++ = *s++;
 
35
        }
 
36
 
 
37
        if (__n & 1)
 
38
                *d++ = *s++;
 
39
 
 
40
        return __dest;
 
41
}
 
42
 
 
43
void *memmove(void *__dest, __const void *__src, size_t count)
 
44
{
 
45
        unsigned char *d = __dest;
 
46
        const unsigned char *s = __src;
 
47
 
 
48
        if (__dest == __src)
 
49
                return __dest;
 
50
 
 
51
        if (__dest < __src)
 
52
                return memcpy(__dest, __src, count);
 
53
 
 
54
        while (count--)
 
55
                d[count] = s[count];
 
56
        return __dest;
 
57
}
 
58
 
 
59
size_t strlen(const char *s)
 
60
{
 
61
        const char *sc = s;
 
62
 
 
63
        while (*sc != '\0')
 
64
                sc++;
 
65
        return sc - s;
 
66
}
 
67
 
 
68
int memcmp(const void *cs, const void *ct, size_t count)
 
69
{
 
70
        const unsigned char *su1 = cs, *su2 = ct, *end = su1 + count;
 
71
        int res = 0;
 
72
 
 
73
        while (su1 < end) {
 
74
                res = *su1++ - *su2++;
 
75
                if (res)
 
76
                        break;
 
77
        }
 
78
        return res;
 
79
}
 
80
 
 
81
int strcmp(const char *cs, const char *ct)
 
82
{
 
83
        unsigned char c1, c2;
 
84
        int res = 0;
 
85
 
 
86
        do {
 
87
                c1 = *cs++;
 
88
                c2 = *ct++;
 
89
                res = c1 - c2;
 
90
                if (res)
 
91
                        break;
 
92
        } while (c1);
 
93
        return res;
 
94
}
 
95
 
 
96
void *memchr(const void *s, int c, size_t count)
 
97
{
 
98
        const unsigned char *p = s;
 
99
 
 
100
        while (count--)
 
101
                if ((unsigned char)c == *p++)
 
102
                        return (void *)(p - 1);
 
103
        return NULL;
 
104
}
 
105
 
 
106
char *strchr(const char *s, int c)
 
107
{
 
108
        while (*s != (char)c)
 
109
                if (*s++ == '\0')
 
110
                        return NULL;
 
111
        return (char *)s;
 
112
}
 
113
 
 
114
#undef memset
 
115
 
 
116
void *memset(void *s, int c, size_t count)
 
117
{
 
118
        char *xs = s;
 
119
        while (count--)
 
120
                *xs++ = c;
 
121
        return s;
 
122
}
 
123
 
 
124
void __memzero(void *s, size_t count)
 
125
{
 
126
        memset(s, 0, count);
 
127
}