1 /* $NetBSD: str.c,v 1.15 2013/07/16 17:47:43 christos Exp $ */
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
35 static char sccsid
[] = "@(#)str.c 8.1 (Berkeley) 5/31/93";
37 __RCSID("$NetBSD: str.c,v 1.15 2013/07/16 17:47:43 christos Exp $");
41 #define MALLOC_INCR 128
44 * tc.str.c: Short string package
45 * This has been a lesson of how to write buggy code!
48 #include <sys/types.h>
67 for (n
= 0; src
[n
] != NULL
; n
++)
69 sdst
= dst
= xmalloc((size_t)((n
+ 1) * sizeof(*dst
)));
71 for (; *src
!= NULL
; src
++)
78 short2blk(Char
*const *src
)
86 for (n
= 0; src
[n
] != NULL
; n
++)
88 sdst
= dst
= xmalloc((size_t)((n
+ 1) * sizeof(*dst
)));
90 for (; *src
!= NULL
; src
++)
91 *dst
++ = strsave(short2str(*src
));
97 str2short(const char *src
)
101 static size_t dstsize
= 0;
106 if (sdst
== (NULL
)) {
107 dstsize
= MALLOC_INCR
;
108 sdst
= xmalloc((size_t)dstsize
* sizeof(*sdst
));
112 edst
= &dst
[dstsize
];
114 *dst
++ = (Char
) ((unsigned char) *src
++);
116 dstsize
+= MALLOC_INCR
;
117 sdst
= xrealloc((ptr_t
)sdst
,
118 (size_t)dstsize
* sizeof(*sdst
));
119 edst
= &sdst
[dstsize
];
120 dst
= &edst
[-MALLOC_INCR
];
128 short2str(const Char
*src
)
130 static char *sdst
= NULL
;
131 static size_t dstsize
= 0;
138 dstsize
= MALLOC_INCR
;
139 sdst
= xmalloc((size_t)dstsize
* sizeof(*sdst
));
142 edst
= &dst
[dstsize
];
144 *dst
++ = (char) *src
++;
146 dstsize
+= MALLOC_INCR
;
147 sdst
= xrealloc((ptr_t
)sdst
,
148 (size_t)dstsize
* sizeof(*sdst
));
149 edst
= &sdst
[dstsize
];
150 dst
= &edst
[-MALLOC_INCR
];
158 s_strcpy(Char
*dst
, const Char
*src
)
163 while ((*dst
++ = *src
++) != '\0')
169 s_strncpy(Char
*dst
, const Char
*src
, size_t n
)
178 if ((*dst
++ = *src
++) == '\0') {
188 s_strcat(Char
*dst
, const Char
*src
)
196 while ((*dst
++ = *src
++) != '\0')
203 s_strncat(Char
*dst
, Char
*src
, size_t n
)
217 if ((*dst
++ = *src
++) == '\0')
229 s_strchr(const Char
*str
, int ch
)
233 return __UNCONST(str
);
239 s_strrchr(const Char
*str
, int ch
)
248 return __UNCONST(rstr
);
252 s_strlen(const Char
*str
)
256 for (n
= 0; *str
++; n
++)
262 s_strcmp(const Char
*str1
, const Char
*str2
)
264 for (; *str1
&& *str1
== *str2
; str1
++, str2
++)
267 * The following case analysis is necessary so that characters which look
268 * negative collate low against normal characters but high against the
271 if (*str1
== '\0' && *str2
== '\0')
273 else if (*str1
== '\0')
275 else if (*str2
== '\0')
278 return (*str1
- *str2
);
282 s_strncmp(const Char
*str1
, const Char
*str2
, size_t n
)
287 if (*str1
!= *str2
) {
289 * The following case analysis is necessary so that characters
290 * which look negative collate low against normal characters
291 * but high against the end-of-string NUL.
295 else if (*str2
== '\0')
298 return (*str1
- *str2
);
308 s_strsave(const Char
*s
)
317 p
= n
= xmalloc((size_t)(p
- s
) * sizeof(*n
));
318 while ((*n
++ = *s
++) != '\0')
324 s_strspl(const Char
*cp
, const Char
*dp
)
337 ep
= xmalloc((size_t)((p
- cp
) + (q
- dp
) - 1) * sizeof(*ep
));
338 for (d
= ep
, q
= cp
; (*d
++ = *q
++) != '\0';)
340 for (d
--, q
= dp
; (*d
++ = *q
++) != '\0';)
346 s_strend(const Char
*cp
)
349 return __UNCONST(cp
);
352 return __UNCONST(cp
);
356 s_strstr(const Char
*s
, const Char
*t
)
365 while (*ss
++ == *tt
++);
366 } while (*s
++ != '\0');
369 #endif /* SHORT_STRINGS */
372 short2qstr(const Char
*src
)
374 static char *sdst
= NULL
;
375 static size_t dstsize
= 0;
382 dstsize
= MALLOC_INCR
;
383 sdst
= xmalloc((size_t)dstsize
* sizeof(*sdst
));
386 edst
= &dst
[dstsize
];
392 dstsize
+= MALLOC_INCR
;
393 sdst
= xrealloc((ptr_t
) sdst
,
394 (size_t)dstsize
* sizeof(*sdst
));
395 edst
= &sdst
[dstsize
];
396 dst
= &edst
[-MALLOC_INCR
];
399 *dst
++ = (char) *src
++;
401 dstsize
+= MALLOC_INCR
;
402 sdst
= xrealloc((ptr_t
) sdst
,
403 (size_t)dstsize
* sizeof(*sdst
));
404 edst
= &sdst
[dstsize
];
405 dst
= &edst
[-MALLOC_INCR
];
413 * XXX: Should we worry about QUOTE'd chars?
416 vis_str(const Char
*cp
)
418 static char *sdst
= NULL
;
419 static size_t dstsize
= 0;
426 for (dp
= cp
; *dp
++;)
428 n
= ((size_t)(dp
- cp
) << 2) + 1; /* 4 times + NULL */
431 xrealloc(sdst
, (size_t)n
* sizeof(*sdst
)) :
432 xmalloc((size_t)n
* sizeof(*sdst
)));
436 * XXX: When we are in AsciiOnly we want all characters >= 0200 to
437 * be encoded, but currently there is no way in vis to do that.
439 (void)strvis(sdst
, short2str(cp
), VIS_NOSLASH
);