OLD | NEW |
| (Empty) |
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
2 /* | |
3 * The contents of this file are subject to the Mozilla Public | |
4 * License Version 1.1 (the "License"); you may not use this file | |
5 * except in compliance with the License. You may obtain a copy of | |
6 * the License at http://www.mozilla.org/MPL/ | |
7 * | |
8 * Software distributed under the License is distributed on an "AS | |
9 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or | |
10 * implied. See the License for the specific language governing | |
11 * rights and limitations under the License. | |
12 * | |
13 * The Original Code is the Netscape Portable Runtime (NSPR). | |
14 * | |
15 * The Initial Developer of the Original Code is Netscape | |
16 * Communications Corporation. Portions created by Netscape are | |
17 * Copyright (C) 1998-2000 Netscape Communications Corporation. All | |
18 * Rights Reserved. | |
19 * | |
20 * Contributor(s): | |
21 * Roland Mainz <roland mainz@informatik.med.uni-giessen.de> | |
22 * | |
23 * Alternatively, the contents of this file may be used under the | |
24 * terms of the GNU General Public License Version 2 or later (the | |
25 * "GPL"), in which case the provisions of the GPL are applicable | |
26 * instead of those above. If you wish to allow use of your | |
27 * version of this file only under the terms of the GPL and not to | |
28 * allow others to use your version of this file under the MPL, | |
29 * indicate your decision by deleting the provisions above and | |
30 * replace them with the notice and other provisions required by | |
31 * the GPL. If you do not delete the provisions above, a recipient | |
32 * may use your version of this file under either the MPL or the | |
33 * GPL. | |
34 */ | |
35 | |
36 #ifndef _plstr_h | |
37 #define _plstr_h | |
38 | |
39 /* | |
40 * plstr.h | |
41 * | |
42 * This header file exports the API to the NSPR portable library or string- | |
43 * handling functions. | |
44 * | |
45 * This API was not designed as an "optimal" or "ideal" string library; it | |
46 * was based on the good ol' unix string.3 functions, and was written to | |
47 * | |
48 * 1) replace the libc functions, for cross-platform consistancy, | |
49 * 2) complete the API on platforms lacking common functions (e.g., | |
50 * strcase*), and | |
51 * 3) to implement some obvious "closure" functions that I've seen | |
52 * people hacking around in our code. | |
53 * | |
54 * Point number three largely means that most functions have an "strn" | |
55 * limited-length version, and all comparison routines have a non-case- | |
56 * sensitive version available. | |
57 */ | |
58 | |
59 #include "prtypes.h" | |
60 | |
61 PR_BEGIN_EXTERN_C | |
62 /* | |
63 * PL_strlen | |
64 * | |
65 * Returns the length of the provided string, not including the trailing '\0'. | |
66 */ | |
67 | |
68 PR_EXTERN(PRUint32) | |
69 PL_strlen(const char *str); | |
70 | |
71 /* | |
72 * PL_strnlen | |
73 * | |
74 * Returns the length of the provided string, not including the trailing '\0', | |
75 * up to the indicated maximum. The string will not be examined beyond the | |
76 * maximum; if no terminating '\0' is found, the maximum will be returned. | |
77 */ | |
78 | |
79 PR_EXTERN(PRUint32) | |
80 PL_strnlen(const char *str, PRUint32 max); | |
81 | |
82 /* | |
83 * PL_strcpy | |
84 * | |
85 * Copies the source string, up to and including the trailing '\0', into the | |
86 * destination buffer. It does not (can not) verify that the destination | |
87 * buffer is large enough. It returns the "dest" argument. | |
88 */ | |
89 | |
90 PR_EXTERN(char *) | |
91 PL_strcpy(char *dest, const char *src); | |
92 | |
93 /* | |
94 * PL_strncpy | |
95 * | |
96 * Copies the source string into the destination buffer, up to and including | |
97 * the trailing '\0' or up to and including the max'th character, whichever | |
98 * comes first. It does not (can not) verify that the destination buffer is | |
99 * large enough. If the source string is longer than the maximum length, | |
100 * the result will *not* be null-terminated (JLRU). | |
101 */ | |
102 | |
103 PR_EXTERN(char *) | |
104 PL_strncpy(char *dest, const char *src, PRUint32 max); | |
105 | |
106 /* | |
107 * PL_strncpyz | |
108 * | |
109 * Copies the source string into the destination buffer, up to and including | |
110 * the trailing '\0' or up but not including the max'th character, whichever | |
111 * comes first. It does not (can not) verify that the destination buffer is | |
112 * large enough. The destination string is always terminated with a '\0', | |
113 * unlike the traditional libc implementation. It returns the "dest" argument. | |
114 * | |
115 * NOTE: If you call this with a source "abcdefg" and a max of 5, the | |
116 * destination will end up with "abcd\0" (i.e., it's strlen length will be 4)! | |
117 * | |
118 * This means you can do this: | |
119 * | |
120 * char buffer[ SOME_SIZE ]; | |
121 * PL_strncpyz(buffer, src, sizeof(buffer)); | |
122 * | |
123 * and the result will be properly terminated. | |
124 */ | |
125 | |
126 PR_EXTERN(char *) | |
127 PL_strncpyz(char *dest, const char *src, PRUint32 max); | |
128 | |
129 /* | |
130 * PL_strdup | |
131 * | |
132 * Returns a pointer to a malloc'd extent of memory containing a duplicate | |
133 * of the argument string. The size of the allocated extent is one greater | |
134 * than the length of the argument string, because of the terminator. A | |
135 * null argument, like a zero-length argument, will result in a pointer to | |
136 * a one-byte extent containing the null value. This routine returns null | |
137 * upon malloc failure. | |
138 */ | |
139 | |
140 PR_EXTERN(char *) | |
141 PL_strdup(const char *s); | |
142 | |
143 /* | |
144 * PL_strfree | |
145 * | |
146 * Free memory allocated by PL_strdup | |
147 */ | |
148 | |
149 PR_EXTERN(void) | |
150 PL_strfree(char *s); | |
151 | |
152 /* | |
153 * PL_strndup | |
154 * | |
155 * Returns a pointer to a malloc'd extent of memory containing a duplicate | |
156 * of the argument string, up to the maximum specified. If the argument | |
157 * string has a length greater than the value of the specified maximum, the | |
158 * return value will be a pointer to an extent of memory of length one | |
159 * greater than the maximum specified. A null string, a zero-length string, | |
160 * or a zero maximum will all result in a pointer to a one-byte extent | |
161 * containing the null value. This routine returns null upon malloc failure. | |
162 */ | |
163 | |
164 PR_EXTERN(char *) | |
165 PL_strndup(const char *s, PRUint32 max); | |
166 | |
167 /* | |
168 * PL_strcat | |
169 * | |
170 * Appends a copy of the string pointed to by the second argument to the | |
171 * end of the string pointed to by the first. The destination buffer is | |
172 * not (can not be) checked for sufficient size. A null destination | |
173 * argument returns null; otherwise, the first argument is returned. | |
174 */ | |
175 | |
176 PR_EXTERN(char *) | |
177 PL_strcat(char *dst, const char *src); | |
178 | |
179 /* | |
180 * PL_strncat | |
181 * | |
182 * Appends a copy of the string pointed to by the second argument, up to | |
183 * the maximum size specified, to the end of the string pointed to by the | |
184 * first. The destination buffer is not (can not be) checked for sufficient | |
185 * size. A null destination argument returns null; otherwise, the first | |
186 * argument is returned. If the maximum size limits the copy, then the | |
187 * result will *not* be null-terminated (JLRU). A null destination | |
188 * returns null; otherwise, the destination argument is returned. | |
189 */ | |
190 | |
191 PR_EXTERN(char *) | |
192 PL_strncat(char *dst, const char *src, PRUint32 max); | |
193 | |
194 /* | |
195 * PL_strcatn | |
196 * | |
197 * Appends a copy of the string pointed to by the third argument, to the | |
198 * end of the string pointed to by the first. The second argument specifies | |
199 * the maximum size of the destination buffer, including the null termination. | |
200 * If the existing string in dst is longer than the max, no action is taken. | |
201 * The resulting string will be null-terminated. A null destination returns | |
202 * null; otherwise, the destination argument is returned. | |
203 */ | |
204 | |
205 PR_EXTERN(char *) | |
206 PL_strcatn(char *dst, PRUint32 max, const char *src); | |
207 | |
208 /* | |
209 * PL_strcmp | |
210 * | |
211 * Returns an integer, the sign of which -- positive, zero, or negative -- | |
212 * reflects the lexical sorting order of the two strings indicated. The | |
213 * result is positive if the first string comes after the second. The | |
214 * NSPR implementation is not i18n. | |
215 */ | |
216 | |
217 PR_EXTERN(PRIntn) | |
218 PL_strcmp(const char *a, const char *b); | |
219 | |
220 /* | |
221 * PL_strncmp | |
222 * | |
223 * Returns an integer, the sign of which -- positive, zero, or negative -- | |
224 * reflects the lexical sorting order of the two strings indicated, up to | |
225 * the maximum specified. The result is positive if the first string comes | |
226 * after the second. The NSPR implementation is not i18n. If the maximum | |
227 * is zero, only the existance or non-existance (pointer is null) of the | |
228 * strings is compared. | |
229 */ | |
230 | |
231 PR_EXTERN(PRIntn) | |
232 PL_strncmp(const char *a, const char *b, PRUint32 max); | |
233 | |
234 /* | |
235 * PL_strcasecmp | |
236 * | |
237 * Returns an integer, the sign of which -- positive, zero or negative -- | |
238 * reflects the case-insensitive lexical sorting order of the two strings | |
239 * indicated. The result is positive if the first string comes after the | |
240 * second. The NSPR implementation is not i18n. | |
241 */ | |
242 | |
243 PR_EXTERN(PRIntn) | |
244 PL_strcasecmp(const char *a, const char *b); | |
245 | |
246 /* | |
247 * PL_strncasecmp | |
248 * | |
249 * Returns an integer, the sign of which -- positive, zero or negative -- | |
250 * reflects the case-insensitive lexical sorting order of the first n characters | |
251 * of the two strings indicated. The result is positive if the first string com
es | |
252 * after the second. The NSPR implementation is not i18n. | |
253 */ | |
254 | |
255 PR_EXTERN(PRIntn) | |
256 PL_strncasecmp(const char *a, const char *b, PRUint32 max); | |
257 | |
258 /* | |
259 * PL_strchr | |
260 * | |
261 * Returns a pointer to the first instance of the specified character in the | |
262 * provided string. It returns null if the character is not found, or if the | |
263 * provided string is null. The character may be the null character. | |
264 */ | |
265 | |
266 PR_EXTERN(char *) | |
267 PL_strchr(const char *s, char c); | |
268 | |
269 /* | |
270 * PL_strrchr | |
271 * | |
272 * Returns a pointer to the last instance of the specified character in the | |
273 * provided string. It returns null if the character is not found, or if the | |
274 * provided string is null. The character may be the null character. | |
275 */ | |
276 | |
277 PR_EXTERN(char *) | |
278 PL_strrchr(const char *s, char c); | |
279 | |
280 /* | |
281 * PL_strnchr | |
282 * | |
283 * Returns a pointer to the first instance of the specified character within the | |
284 * first n characters of the provided string. It returns null if the character | |
285 * is not found, or if the provided string is null. The character may be the | |
286 * null character. | |
287 */ | |
288 | |
289 PR_EXTERN(char *) | |
290 PL_strnchr(const char *s, char c, PRUint32 n); | |
291 | |
292 /* | |
293 * PL_strnrchr | |
294 * | |
295 * Returns a pointer to the last instance of the specified character within the | |
296 * first n characters of the provided string. It returns null if the character
is | |
297 * not found, or if the provided string is null. The character may be the null | |
298 * character. | |
299 */ | |
300 | |
301 PR_EXTERN(char *) | |
302 PL_strnrchr(const char *s, char c, PRUint32 n); | |
303 | |
304 /* | |
305 * NOTE: Looking for strcasechr, strcaserchr, strncasechr, or strncaserchr? | |
306 * Use strpbrk, strprbrk, strnpbrk or strnprbrk. | |
307 */ | |
308 | |
309 /* | |
310 * PL_strpbrk | |
311 * | |
312 * Returns a pointer to the first instance in the first string of any character | |
313 * (not including the terminating null character) of the second string. It retu
rns | |
314 * null if either string is null. | |
315 */ | |
316 | |
317 PR_EXTERN(char *) | |
318 PL_strpbrk(const char *s, const char *list); | |
319 | |
320 /* | |
321 * PL_strprbrk | |
322 * | |
323 * Returns a pointer to the last instance in the first string of any character | |
324 * (not including the terminating null character) of the second string. It retu
rns | |
325 * null if either string is null. | |
326 */ | |
327 | |
328 PR_EXTERN(char *) | |
329 PL_strprbrk(const char *s, const char *list); | |
330 | |
331 /* | |
332 * PL_strnpbrk | |
333 * | |
334 * Returns a pointer to the first instance (within the first n characters) of an
y | |
335 * character (not including the terminating null character) of the second string
. | |
336 * It returns null if either string is null. | |
337 */ | |
338 | |
339 PR_EXTERN(char *) | |
340 PL_strnpbrk(const char *s, const char *list, PRUint32 n); | |
341 | |
342 /* | |
343 * PL_strnprbrk | |
344 * | |
345 * Returns a pointer to the last instance (within the first n characters) of any | |
346 * character (not including the terminating null character) of the second string
. | |
347 * It returns null if either string is null. | |
348 */ | |
349 | |
350 PR_EXTERN(char *) | |
351 PL_strnprbrk(const char *s, const char *list, PRUint32 n); | |
352 | |
353 /* | |
354 * PL_strstr | |
355 * | |
356 * Returns a pointer to the first instance of the little string within the | |
357 * big one. It returns null if either string is null. | |
358 */ | |
359 | |
360 PR_EXTERN(char *) | |
361 PL_strstr(const char *big, const char *little); | |
362 | |
363 /* | |
364 * PL_strrstr | |
365 * | |
366 * Returns a pointer to the last instance of the little string within the big on
e. | |
367 * It returns null if either string is null. | |
368 */ | |
369 | |
370 PR_EXTERN(char *) | |
371 PL_strrstr(const char *big, const char *little); | |
372 | |
373 /* | |
374 * PL_strnstr | |
375 * | |
376 * Returns a pointer to the first instance of the little string within the first | |
377 * n characters of the big one. It returns null if either string is null. It | |
378 * returns null if the length of the little string is greater than n. | |
379 */ | |
380 | |
381 PR_EXTERN(char *) | |
382 PL_strnstr(const char *big, const char *little, PRUint32 n); | |
383 | |
384 /* | |
385 * PL_strnrstr | |
386 * | |
387 * Returns a pointer to the last instance of the little string within the first | |
388 * n characters of the big one. It returns null if either string is null. It | |
389 * returns null if the length of the little string is greater than n. | |
390 */ | |
391 | |
392 PR_EXTERN(char *) | |
393 PL_strnrstr(const char *big, const char *little, PRUint32 max); | |
394 | |
395 /* | |
396 * PL_strcasestr | |
397 * | |
398 * Returns a pointer to the first instance of the little string within the big o
ne, | |
399 * ignoring case. It returns null if either string is null. | |
400 */ | |
401 | |
402 PR_EXTERN(char *) | |
403 PL_strcasestr(const char *big, const char *little); | |
404 | |
405 /* | |
406 * PL_strcaserstr | |
407 * | |
408 * Returns a pointer to the last instance of the little string within the big on
e, | |
409 * ignoring case. It returns null if either string is null. | |
410 */ | |
411 | |
412 PR_EXTERN(char *) | |
413 PL_strcaserstr(const char *big, const char *little); | |
414 | |
415 /* | |
416 * PL_strncasestr | |
417 * | |
418 * Returns a pointer to the first instance of the listtle string within the firs
t | |
419 * n characters of the big one, ignoring case. It returns null if either string
is | |
420 * null. It returns null if the length of the little string is greater than n. | |
421 */ | |
422 | |
423 PR_EXTERN(char *) | |
424 PL_strncasestr(const char *big, const char *little, PRUint32 max); | |
425 | |
426 /* | |
427 * PL_strncaserstr | |
428 * | |
429 * Returns a pointer to the last instance of the little string within the first | |
430 * n characters of the big one, ignoring case. It returns null if either string
is | |
431 * null. It returns null if the length of the little string is greater than n. | |
432 */ | |
433 | |
434 PR_EXTERN(char *) | |
435 PL_strncaserstr(const char *big, const char *little, PRUint32 max); | |
436 | |
437 /* | |
438 * PL_strtok_r | |
439 * | |
440 * Splits the string s1 into tokens, separated by one or more characters | |
441 * from the separator string s2. The argument lasts points to a | |
442 * user-supplied char * pointer in which PL_strtok_r stores information | |
443 * for it to continue scanning the same string. | |
444 * | |
445 * In the first call to PL_strtok_r, s1 points to a string and the value | |
446 * of *lasts is ignored. PL_strtok_r returns a pointer to the first | |
447 * token, writes '\0' into the character following the first token, and | |
448 * updates *lasts. | |
449 * | |
450 * In subsequent calls, s1 is null and lasts must stay unchanged from the | |
451 * previous call. The separator string s2 may be different from call to | |
452 * call. PL_strtok_r returns a pointer to the next token in s1. When no | |
453 * token remains in s1, PL_strtok_r returns null. | |
454 */ | |
455 | |
456 PR_EXTERN(char *) | |
457 PL_strtok_r(char *s1, const char *s2, char **lasts); | |
458 | |
459 /* | |
460 * Things not (yet?) included: strspn/strcspn, strsep. | |
461 * memchr, memcmp, memcpy, memccpy, index, rindex, bcmp, bcopy, bzero. | |
462 * Any and all i18n/l10n stuff. | |
463 */ | |
464 | |
465 PR_END_EXTERN_C | |
466 | |
467 #endif /* _plstr_h */ | |
OLD | NEW |