Loading...
1/* -*- linux-c -*- ------------------------------------------------------- *
2 *
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright 2007 rPath, Inc. - All Rights Reserved
5 *
6 * This file is part of the Linux kernel, and is made available under
7 * the terms of the GNU General Public License version 2.
8 *
9 * ----------------------------------------------------------------------- */
10
11/*
12 * Very basic string functions
13 */
14
15#include "boot.h"
16
17/*
18 * This file gets included in compressed/string.c which might pull in
19 * string_32.h and which in turn maps memcmp to __builtin_memcmp(). Undo
20 * that first.
21 */
22#undef memcmp
23int memcmp(const void *s1, const void *s2, size_t len)
24{
25 u8 diff;
26 asm("repe; cmpsb; setnz %0"
27 : "=qm" (diff), "+D" (s1), "+S" (s2), "+c" (len));
28 return diff;
29}
30
31int strcmp(const char *str1, const char *str2)
32{
33 const unsigned char *s1 = (const unsigned char *)str1;
34 const unsigned char *s2 = (const unsigned char *)str2;
35 int delta = 0;
36
37 while (*s1 || *s2) {
38 delta = *s2 - *s1;
39 if (delta)
40 return delta;
41 s1++;
42 s2++;
43 }
44 return 0;
45}
46
47int strncmp(const char *cs, const char *ct, size_t count)
48{
49 unsigned char c1, c2;
50
51 while (count) {
52 c1 = *cs++;
53 c2 = *ct++;
54 if (c1 != c2)
55 return c1 < c2 ? -1 : 1;
56 if (!c1)
57 break;
58 count--;
59 }
60 return 0;
61}
62
63size_t strnlen(const char *s, size_t maxlen)
64{
65 const char *es = s;
66 while (*es && maxlen) {
67 es++;
68 maxlen--;
69 }
70
71 return (es - s);
72}
73
74unsigned int atou(const char *s)
75{
76 unsigned int i = 0;
77 while (isdigit(*s))
78 i = i * 10 + (*s++ - '0');
79 return i;
80}
81
82/* Works only for digits and letters, but small and fast */
83#define TOLOWER(x) ((x) | 0x20)
84
85static unsigned int simple_guess_base(const char *cp)
86{
87 if (cp[0] == '0') {
88 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
89 return 16;
90 else
91 return 8;
92 } else {
93 return 10;
94 }
95}
96
97/**
98 * simple_strtoull - convert a string to an unsigned long long
99 * @cp: The start of the string
100 * @endp: A pointer to the end of the parsed string will be placed here
101 * @base: The number base to use
102 */
103
104unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
105{
106 unsigned long long result = 0;
107
108 if (!base)
109 base = simple_guess_base(cp);
110
111 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
112 cp += 2;
113
114 while (isxdigit(*cp)) {
115 unsigned int value;
116
117 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
118 if (value >= base)
119 break;
120 result = result * base + value;
121 cp++;
122 }
123 if (endp)
124 *endp = (char *)cp;
125
126 return result;
127}
128
129/**
130 * strlen - Find the length of a string
131 * @s: The string to be sized
132 */
133size_t strlen(const char *s)
134{
135 const char *sc;
136
137 for (sc = s; *sc != '\0'; ++sc)
138 /* nothing */;
139 return sc - s;
140}
141
142/**
143 * strstr - Find the first substring in a %NUL terminated string
144 * @s1: The string to be searched
145 * @s2: The string to search for
146 */
147char *strstr(const char *s1, const char *s2)
148{
149 size_t l1, l2;
150
151 l2 = strlen(s2);
152 if (!l2)
153 return (char *)s1;
154 l1 = strlen(s1);
155 while (l1 >= l2) {
156 l1--;
157 if (!memcmp(s1, s2, l2))
158 return (char *)s1;
159 s1++;
160 }
161 return NULL;
162}
1/* -*- linux-c -*- ------------------------------------------------------- *
2 *
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright 2007 rPath, Inc. - All Rights Reserved
5 *
6 * This file is part of the Linux kernel, and is made available under
7 * the terms of the GNU General Public License version 2.
8 *
9 * ----------------------------------------------------------------------- */
10
11/*
12 * Very basic string functions
13 */
14
15#include <linux/types.h>
16#include "ctype.h"
17#include "string.h"
18
19/*
20 * Undef these macros so that the functions that we provide
21 * here will have the correct names regardless of how string.h
22 * may have chosen to #define them.
23 */
24#undef memcpy
25#undef memset
26#undef memcmp
27
28int memcmp(const void *s1, const void *s2, size_t len)
29{
30 bool diff;
31 asm("repe; cmpsb; setnz %0"
32 : "=qm" (diff), "+D" (s1), "+S" (s2), "+c" (len));
33 return diff;
34}
35
36int strcmp(const char *str1, const char *str2)
37{
38 const unsigned char *s1 = (const unsigned char *)str1;
39 const unsigned char *s2 = (const unsigned char *)str2;
40 int delta = 0;
41
42 while (*s1 || *s2) {
43 delta = *s1 - *s2;
44 if (delta)
45 return delta;
46 s1++;
47 s2++;
48 }
49 return 0;
50}
51
52int strncmp(const char *cs, const char *ct, size_t count)
53{
54 unsigned char c1, c2;
55
56 while (count) {
57 c1 = *cs++;
58 c2 = *ct++;
59 if (c1 != c2)
60 return c1 < c2 ? -1 : 1;
61 if (!c1)
62 break;
63 count--;
64 }
65 return 0;
66}
67
68size_t strnlen(const char *s, size_t maxlen)
69{
70 const char *es = s;
71 while (*es && maxlen) {
72 es++;
73 maxlen--;
74 }
75
76 return (es - s);
77}
78
79unsigned int atou(const char *s)
80{
81 unsigned int i = 0;
82 while (isdigit(*s))
83 i = i * 10 + (*s++ - '0');
84 return i;
85}
86
87/* Works only for digits and letters, but small and fast */
88#define TOLOWER(x) ((x) | 0x20)
89
90static unsigned int simple_guess_base(const char *cp)
91{
92 if (cp[0] == '0') {
93 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
94 return 16;
95 else
96 return 8;
97 } else {
98 return 10;
99 }
100}
101
102/**
103 * simple_strtoull - convert a string to an unsigned long long
104 * @cp: The start of the string
105 * @endp: A pointer to the end of the parsed string will be placed here
106 * @base: The number base to use
107 */
108
109unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
110{
111 unsigned long long result = 0;
112
113 if (!base)
114 base = simple_guess_base(cp);
115
116 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
117 cp += 2;
118
119 while (isxdigit(*cp)) {
120 unsigned int value;
121
122 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
123 if (value >= base)
124 break;
125 result = result * base + value;
126 cp++;
127 }
128 if (endp)
129 *endp = (char *)cp;
130
131 return result;
132}
133
134long simple_strtol(const char *cp, char **endp, unsigned int base)
135{
136 if (*cp == '-')
137 return -simple_strtoull(cp + 1, endp, base);
138
139 return simple_strtoull(cp, endp, base);
140}
141
142/**
143 * strlen - Find the length of a string
144 * @s: The string to be sized
145 */
146size_t strlen(const char *s)
147{
148 const char *sc;
149
150 for (sc = s; *sc != '\0'; ++sc)
151 /* nothing */;
152 return sc - s;
153}
154
155/**
156 * strstr - Find the first substring in a %NUL terminated string
157 * @s1: The string to be searched
158 * @s2: The string to search for
159 */
160char *strstr(const char *s1, const char *s2)
161{
162 size_t l1, l2;
163
164 l2 = strlen(s2);
165 if (!l2)
166 return (char *)s1;
167 l1 = strlen(s1);
168 while (l1 >= l2) {
169 l1--;
170 if (!memcmp(s1, s2, l2))
171 return (char *)s1;
172 s1++;
173 }
174 return NULL;
175}
176
177/**
178 * strchr - Find the first occurrence of the character c in the string s.
179 * @s: the string to be searched
180 * @c: the character to search for
181 */
182char *strchr(const char *s, int c)
183{
184 while (*s != (char)c)
185 if (*s++ == '\0')
186 return NULL;
187 return (char *)s;
188}