1 | /*--------------------------------*-C-*---------------------------------* |
1 | /*--------------------------------*-C-*---------------------------------* |
2 | * File: strings.c |
2 | * File: strings.c |
3 | *----------------------------------------------------------------------* |
3 | *----------------------------------------------------------------------* |
4 | * $Id: strings.C,v 1.2 2003/11/24 17:31:28 pcg Exp $ |
4 | * $Id: strings.C,v 1.3 2004/01/31 00:20:21 pcg Exp $ |
5 | * |
5 | * |
6 | * All portions of code are copyright by their respective author/s. |
6 | * All portions of code are copyright by their respective author/s. |
7 | * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com> |
7 | * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com> |
8 | * |
8 | * |
9 | * This program is free software; you can redistribute it and/or modify |
9 | * This program is free software; you can redistribute it and/or modify |
… | |
… | |
29 | /*----------------------------------------------------------------------*/ |
29 | /*----------------------------------------------------------------------*/ |
30 | /* |
30 | /* |
31 | * a replacement for strcasecmp() to avoid linking an entire library. |
31 | * a replacement for strcasecmp() to avoid linking an entire library. |
32 | * Mark Olesen added this in 2.15 but for which OS & library? - Geoff Wing |
32 | * Mark Olesen added this in 2.15 but for which OS & library? - Geoff Wing |
33 | */ |
33 | */ |
34 | /* EXTPROTO */ |
|
|
35 | int |
34 | int |
36 | strcasecmp(const char *s1, const char *s2) |
35 | strcasecmp(const char *s1, const char *s2) |
37 | { |
36 | { |
38 | for ( ; tolower(*s1) == tolower(*s2); s1++, s2++) |
37 | for ( ; tolower(*s1) == tolower(*s2); s1++, s2++) |
39 | if (!*s1) |
38 | if (!*s1) |
40 | return 0; |
39 | return 0; |
41 | return (int)(tolower(*s1) - tolower(*s2)); |
40 | return (int)(tolower(*s1) - tolower(*s2)); |
42 | } |
41 | } |
43 | |
42 | |
44 | /* EXTPROTO */ |
|
|
45 | int |
43 | int |
46 | strncasecmp(const char *s1, const char *s2, size_t n) |
44 | strncasecmp(const char *s1, const char *s2, size_t n) |
47 | { |
45 | { |
48 | for ( ; n-- && (tolower(*s1) == tolower(*s2)); s1++, s2++) |
46 | for ( ; n-- && (tolower(*s1) == tolower(*s2)); s1++, s2++) |
49 | if (!*s1) |
47 | if (!*s1) |
… | |
… | |
51 | if (n == 0) |
49 | if (n == 0) |
52 | return 0; |
50 | return 0; |
53 | return (int)(tolower(*s1) - tolower(*s2)); |
51 | return (int)(tolower(*s1) - tolower(*s2)); |
54 | } |
52 | } |
55 | |
53 | |
56 | /* EXTPROTO */ |
|
|
57 | char * |
54 | char * |
58 | strcpy(char *d, const char *s) |
55 | strcpy(char *d, const char *s) |
59 | { |
56 | { |
60 | char *r = d; |
57 | char *r = d; |
61 | |
58 | |
62 | for ( ; (*r++ = *s++) != '\0'; ) ; |
59 | for ( ; (*r++ = *s++) != '\0'; ) ; |
63 | return d; |
60 | return d; |
64 | } |
61 | } |
65 | |
62 | |
66 | /* EXTPROTO */ |
|
|
67 | char * |
63 | char * |
68 | strncpy(char *d, const char *s, size_t len) |
64 | strncpy(char *d, const char *s, size_t len) |
69 | { |
65 | { |
70 | char *r = d; |
66 | char *r = d; |
71 | |
67 | |
… | |
… | |
77 | break; |
73 | break; |
78 | } |
74 | } |
79 | return d; |
75 | return d; |
80 | } |
76 | } |
81 | |
77 | |
82 | /* EXTPROTO */ |
|
|
83 | int |
78 | int |
84 | strcmp(const char *s1, const char *s2) |
79 | strcmp(const char *s1, const char *s2) |
85 | { |
80 | { |
86 | for ( ; (*s1 == *s2++); ) |
81 | for ( ; (*s1 == *s2++); ) |
87 | if (*s1++ == '\0') |
82 | if (*s1++ == '\0') |
88 | return 0; |
83 | return 0; |
89 | return (int) ((unsigned char) *s1 - (unsigned char) *--s2); |
84 | return (int) ((unsigned char) *s1 - (unsigned char) *--s2); |
90 | } |
85 | } |
91 | |
86 | |
92 | /* EXTPROTO */ |
|
|
93 | int |
87 | int |
94 | strncmp(const char *s1, const char *s2, size_t len) |
88 | strncmp(const char *s1, const char *s2, size_t len) |
95 | { |
89 | { |
96 | if (len) { |
90 | if (len) { |
97 | for ( ; len-- && (*s1++ == *s2++); ) ; |
91 | for ( ; len-- && (*s1++ == *s2++); ) ; |
… | |
… | |
99 | return (int) ((unsigned char) *--s1 - (unsigned char) *--s2); |
93 | return (int) ((unsigned char) *--s1 - (unsigned char) *--s2); |
100 | } |
94 | } |
101 | return 0; |
95 | return 0; |
102 | } |
96 | } |
103 | |
97 | |
104 | /* EXTPROTO */ |
|
|
105 | char * |
98 | char * |
106 | strcat(char *s1, const char *s2) |
99 | strcat(char *s1, const char *s2) |
107 | { |
100 | { |
108 | char *r = s1; |
101 | char *r = s1; |
109 | |
102 | |
… | |
… | |
112 | for ( ; (*r++ = *s2++) != '\0'; ) ; |
105 | for ( ; (*r++ = *s2++) != '\0'; ) ; |
113 | |
106 | |
114 | return s1; |
107 | return s1; |
115 | } |
108 | } |
116 | |
109 | |
117 | /* EXTPROTO */ |
|
|
118 | char * |
110 | char * |
119 | strncat(char *s1, const char *s2, size_t len) |
111 | strncat(char *s1, const char *s2, size_t len) |
120 | { |
112 | { |
121 | char *r = s1; |
113 | char *r = s1; |
122 | |
114 | |
… | |
… | |
126 | *r = '\0'; |
118 | *r = '\0'; |
127 | |
119 | |
128 | return s1; |
120 | return s1; |
129 | } |
121 | } |
130 | |
122 | |
131 | /* EXTPROTO */ |
|
|
132 | size_t |
123 | size_t |
133 | strlen(const char *s) |
124 | strlen(const char *s) |
134 | { |
125 | { |
135 | size_t len = 0; |
126 | size_t len = 0; |
136 | |
127 | |
137 | for ( ; *s++ != '\0'; len++) ; |
128 | for ( ; *s++ != '\0'; len++) ; |
138 | return len; |
129 | return len; |
139 | } |
130 | } |
140 | |
131 | |
141 | /* EXTPROTO */ |
|
|
142 | char * |
132 | char * |
143 | strdup(const char *s) |
133 | strdup(const char *s) |
144 | { |
134 | { |
145 | size_t len = STRLEN(s) + 1; |
135 | size_t len = STRLEN(s) + 1; |
146 | char *c; |
136 | char *c; |
… | |
… | |
148 | if ((c = malloc(len)) != NULL) |
138 | if ((c = malloc(len)) != NULL) |
149 | MEMCPY(c, s, len); |
139 | MEMCPY(c, s, len); |
150 | return c; |
140 | return c; |
151 | } |
141 | } |
152 | |
142 | |
153 | /* EXTPROTO */ |
|
|
154 | char * |
143 | char * |
155 | index(const char *s, int c) |
144 | index(const char *s, int c) |
156 | { |
145 | { |
157 | return STRCHR(s, c); |
146 | return STRCHR(s, c); |
158 | } |
147 | } |
159 | |
148 | |
160 | /* EXTPROTO */ |
|
|
161 | char * |
149 | char * |
162 | strchr(const char *s, int c) |
150 | strchr(const char *s, int c) |
163 | { |
151 | { |
164 | char *p = NULL; |
152 | char *p = NULL; |
165 | |
153 | |
… | |
… | |
173 | } |
161 | } |
174 | return p; |
162 | return p; |
175 | |
163 | |
176 | } |
164 | } |
177 | |
165 | |
178 | /* EXTPROTO */ |
|
|
179 | char * |
166 | char * |
180 | rindex(const char *s, int c) |
167 | rindex(const char *s, int c) |
181 | { |
168 | { |
182 | return STRRCHR(s, c); |
169 | return STRRCHR(s, c); |
183 | } |
170 | } |
184 | |
171 | |
185 | /* EXTPROTO */ |
|
|
186 | char * |
172 | char * |
187 | strrchr(const char *s, int c) |
173 | strrchr(const char *s, int c) |
188 | { |
174 | { |
189 | char *p = NULL; |
175 | char *p = NULL; |
190 | |
176 | |
… | |
… | |
195 | break; |
181 | break; |
196 | } |
182 | } |
197 | return p; |
183 | return p; |
198 | } |
184 | } |
199 | |
185 | |
200 | /* EXTPROTO */ |
|
|
201 | void * |
186 | void * |
202 | memcpy(void *s1, const void *s2, size_t len) |
187 | memcpy(void *s1, const void *s2, size_t len) |
203 | { |
188 | { |
204 | /* has extra stack and time but less code space */ |
189 | /* has extra stack and time but less code space */ |
205 | return MEMMOVE(s1, s2, len); |
190 | return MEMMOVE(s1, s2, len); |
206 | } |
191 | } |
207 | |
192 | |
208 | /*--------------------------------------------------------------------------* |
193 | /*--------------------------------------------------------------------------* |
209 | * Possibly faster memmove() by Geoff Wing <mason@primenet.com.au> |
194 | * Possibly faster memmove() by Geoff Wing <mason@primenet.com.au> |
210 | *--------------------------------------------------------------------------*/ |
195 | *--------------------------------------------------------------------------*/ |
211 | /* EXTPROTO */ |
|
|
212 | void * |
196 | void * |
213 | memmove(void *d, const void *s, size_t len) |
197 | memmove(void *d, const void *s, size_t len) |
214 | { |
198 | { |
215 | u_intp_t i; |
199 | u_intp_t i; |
216 | unsigned char *dst = (unsigned char *)d; |
200 | unsigned char *dst = (unsigned char *)d; |
… | |
… | |
257 | * presumptions: |
241 | * presumptions: |
258 | * 1) intp_t write the best |
242 | * 1) intp_t write the best |
259 | * 2) SIZEOF_INT_P == power of 2 |
243 | * 2) SIZEOF_INT_P == power of 2 |
260 | *--------------------------------------------------------------------------*/ |
244 | *--------------------------------------------------------------------------*/ |
261 | |
245 | |
262 | /* EXTPROTO */ |
|
|
263 | void |
246 | void |
264 | bzero(void *b, size_t len) |
247 | bzero(void *b, size_t len) |
265 | { |
248 | { |
266 | MEMSET(b, 0, len); |
249 | MEMSET(b, 0, len); |
267 | } |
250 | } |
268 | |
251 | |
269 | /* EXTPROTO */ |
|
|
270 | void * |
252 | void * |
271 | memset(void *p, int c1, size_t len) |
253 | memset(void *p, int c1, size_t len) |
272 | { |
254 | { |
273 | u_intp_t i, val; |
255 | u_intp_t i, val; |
274 | unsigned char c = (unsigned char) c1; |
256 | unsigned char c = (unsigned char) c1; |