xref: /freebsd/contrib/tcsh/tc.str.c (revision 1669d8afc64812c8d2d1d147ae1fd42ff441e1b1) 
1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.str.c,v 3.26 2006/03/02 18:46:45 christos Exp $ */
2 /*
3  * tc.str.c: Short string package
4  * 	     This has been a lesson of how to write buggy code!
5  */
6 /*-
7  * Copyright (c) 1980, 1991 The Regents of the University of California.
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 #include "sh.h"
35 
36 #include <limits.h>
37 
38 RCSID("$tcsh: tc.str.c,v 3.26 2006/03/02 18:46:45 christos Exp $")
39 
40 #define MALLOC_INCR	128
41 #ifdef WIDE_STRINGS
42 #define MALLOC_SURPLUS	MB_LEN_MAX /* Space for one multibyte character */
43 #else
44 #define MALLOC_SURPLUS	0
45 #endif
46 
47 #ifdef WIDE_STRINGS
48 size_t
49 one_mbtowc(wchar_t *pwc, const char *s, size_t n)
50 {
51     int len;
52 
53     len = rt_mbtowc(pwc, s, n);
54     if (len == -1) {
55         mbtowc(NULL, NULL, 0);
56 	*pwc = (unsigned char)*s | INVALID_BYTE;
57     }
58     if (len <= 0)
59 	len = 1;
60     return len;
61 }
62 
63 size_t
64 one_wctomb(char *s, wchar_t wchar)
65 {
66     int len;
67 
68     if (wchar & INVALID_BYTE) {
69 	s[0] = wchar & 0xFF;
70 	len = 1;
71     } else {
72 	len = wctomb(s, wchar);
73 	if (len == -1)
74 	    s[0] = wchar;
75 	if (len <= 0)
76 	    len = 1;
77     }
78     return len;
79 }
80 
81 int
82 rt_mbtowc(wchar_t *pwc, const char *s, size_t n)
83 {
84     int ret;
85     char back[MB_LEN_MAX];
86 
87     ret = mbtowc(pwc, s, n);
88     if (ret > 0 && (wctomb(back, *pwc) != ret || memcmp(s, back, ret) != 0))
89 	ret = -1;
90     return ret;
91 }
92 #endif
93 
94 #ifdef SHORT_STRINGS
95 Char  **
96 blk2short(char **src)
97 {
98     size_t     n;
99     Char **sdst, **dst;
100 
101     /*
102      * Count
103      */
104     for (n = 0; src[n] != NULL; n++)
105 	continue;
106     sdst = dst = xmalloc((n + 1) * sizeof(Char *));
107 
108     for (; *src != NULL; src++)
109 	*dst++ = SAVE(*src);
110     *dst = NULL;
111     return (sdst);
112 }
113 
114 char  **
115 short2blk(Char **src)
116 {
117     size_t     n;
118     char **sdst, **dst;
119 
120     /*
121      * Count
122      */
123     for (n = 0; src[n] != NULL; n++)
124 	continue;
125     sdst = dst = xmalloc((n + 1) * sizeof(char *));
126 
127     for (; *src != NULL; src++)
128 	*dst++ = strsave(short2str(*src));
129     *dst = NULL;
130     return (sdst);
131 }
132 
133 Char   *
134 str2short(const char *src)
135 {
136     static struct Strbuf buf; /* = Strbuf_INIT; */
137 
138     if (src == NULL)
139 	return (NULL);
140 
141     buf.len = 0;
142     while (*src) {
143 	Char wc;
144 
145 	src += one_mbtowc(&wc, src, MB_LEN_MAX);
146 	Strbuf_append1(&buf, wc);
147     }
148     Strbuf_terminate(&buf);
149     return buf.s;
150 }
151 
152 char   *
153 short2str(const Char *src)
154 {
155     static char *sdst = NULL;
156     static size_t dstsize = 0;
157     char *dst, *edst;
158 
159     if (src == NULL)
160 	return (NULL);
161 
162     if (sdst == NULL) {
163 	dstsize = MALLOC_INCR;
164 	sdst = xmalloc((dstsize + MALLOC_SURPLUS) * sizeof(char));
165     }
166     dst = sdst;
167     edst = &dst[dstsize];
168     while (*src) {
169 	dst += one_wctomb(dst, *src & CHAR);
170 	src++;
171 	if (dst >= edst) {
172 	    dstsize += MALLOC_INCR;
173 	    sdst = xrealloc(sdst, (dstsize + MALLOC_SURPLUS) * sizeof(char));
174 	    edst = &sdst[dstsize];
175 	    dst = &edst[-MALLOC_INCR];
176 	}
177     }
178     *dst = 0;
179     return (sdst);
180 }
181 
182 #ifndef WIDE_STRINGS
183 Char   *
184 s_strcpy(Char *dst, const Char *src)
185 {
186     Char *sdst;
187 
188     sdst = dst;
189     while ((*dst++ = *src++) != '\0')
190 	continue;
191     return (sdst);
192 }
193 
194 Char   *
195 s_strncpy(Char *dst, const Char *src, size_t n)
196 {
197     Char *sdst;
198 
199     if (n == 0)
200 	return(dst);
201 
202     sdst = dst;
203     do
204 	if ((*dst++ = *src++) == '\0') {
205 	    while (--n != 0)
206 		*dst++ = '\0';
207 	    return(sdst);
208 	}
209     while (--n != 0);
210     return (sdst);
211 }
212 
213 Char   *
214 s_strcat(Char *dst, const Char *src)
215 {
216     Strcpy(Strend(dst), src);
217     return dst;
218 }
219 
220 #ifdef NOTUSED
221 Char   *
222 s_strncat(Char *dst, const Char *src, size_t n)
223 {
224     Char *sdst;
225 
226     if (n == 0)
227 	return (dst);
228 
229     sdst = dst;
230 
231     while (*dst)
232 	dst++;
233 
234     do
235 	if ((*dst++ = *src++) == '\0')
236 	    return(sdst);
237     while (--n != 0)
238 	continue;
239 
240     *dst = '\0';
241     return (sdst);
242 }
243 
244 #endif
245 
246 Char   *
247 s_strchr(const Char *str, int ch)
248 {
249     do
250 	if (*str == ch)
251 	    return ((Char *)(intptr_t)str);
252     while (*str++);
253     return (NULL);
254 }
255 
256 Char   *
257 s_strrchr(const Char *str, int ch)
258 {
259     const Char *rstr;
260 
261     rstr = NULL;
262     do
263 	if (*str == ch)
264 	    rstr = str;
265     while (*str++);
266     return ((Char *)(intptr_t)rstr);
267 }
268 
269 size_t
270 s_strlen(const Char *str)
271 {
272     size_t n;
273 
274     for (n = 0; *str++; n++)
275 	continue;
276     return (n);
277 }
278 
279 int
280 s_strcmp(const Char *str1, const Char *str2)
281 {
282     for (; *str1 && *str1 == *str2; str1++, str2++)
283 	continue;
284     /*
285      * The following case analysis is necessary so that characters which look
286      * negative collate low against normal characters but high against the
287      * end-of-string NUL.
288      */
289     if (*str1 == '\0' && *str2 == '\0')
290 	return (0);
291     else if (*str1 == '\0')
292 	return (-1);
293     else if (*str2 == '\0')
294 	return (1);
295     else
296 	return (*str1 - *str2);
297 }
298 
299 int
300 s_strncmp(const Char *str1, const Char *str2, size_t n)
301 {
302     if (n == 0)
303 	return (0);
304     do {
305 	if (*str1 != *str2) {
306 	    /*
307 	     * The following case analysis is necessary so that characters
308 	     * which look negative collate low against normal characters
309 	     * but high against the end-of-string NUL.
310 	     */
311 	    if (*str1 == '\0')
312 		return (-1);
313 	    else if (*str2 == '\0')
314 		return (1);
315 	    else
316 		return (*str1 - *str2);
317 	}
318         if (*str1 == '\0')
319 	    return(0);
320 	str1++, str2++;
321     } while (--n != 0);
322     return(0);
323 }
324 #endif /* not WIDE_STRINGS */
325 
326 int
327 s_strcasecmp(const Char *str1, const Char *str2)
328 {
329 #ifdef WIDE_STRINGS
330     wchar_t l1 = 0, l2 = 0;
331     for (; *str1 && ((*str1 == *str2 && (l1 = l2 = 0) == 0) ||
332 	(l1 = towlower(*str1)) == (l2 = towlower(*str2))); str1++, str2++)
333 	continue;
334 
335 #else
336     unsigned char c1, c2, l1 = 0, l2 = 0;
337     for (; *str1 && ((*str1 == *str2 && (l1 = l2 = 0) == 0) ||
338 	((c1 = (unsigned char)*str1) == *str1 &&
339 	 (c2 = (unsigned char)*str2) == *str2 &&
340 	(l1 = tolower(c1)) == (l2 = tolower(c2)))); str1++, str2++)
341 	continue;
342 #endif
343     /*
344      * The following case analysis is necessary so that characters which look
345      * negative collate low against normal characters but high against the
346      * end-of-string NUL.
347      */
348     if (*str1 == '\0' && *str2 == '\0')
349 	return (0);
350     else if (*str1 == '\0')
351 	return (-1);
352     else if (*str2 == '\0')
353 	return (1);
354     else if (l1 == l2)	/* They are zero when they are equal */
355 	return (*str1 - *str2);
356     else
357 	return (l1 - l2);
358 }
359 
360 Char   *
361 s_strnsave(const Char *s, size_t len)
362 {
363     Char *n;
364 
365     n = xmalloc((len + 1) * sizeof (*n));
366     memcpy(n, s, len * sizeof (*n));
367     n[len] = '\0';
368     return n;
369 }
370 
371 Char   *
372 s_strsave(const Char *s)
373 {
374     Char   *n;
375     size_t size;
376 
377     if (s == NULL)
378 	s = STRNULL;
379     size = (Strlen(s) + 1) * sizeof(*n);
380     n = xmalloc(size);
381     memcpy(n, s, size);
382     return (n);
383 }
384 
385 Char   *
386 s_strspl(const Char *cp, const Char *dp)
387 {
388     Char *res, *ep;
389     const Char *p, *q;
390 
391     if (!cp)
392 	cp = STRNULL;
393     if (!dp)
394 	dp = STRNULL;
395     for (p = cp; *p++;)
396 	continue;
397     for (q = dp; *q++;)
398 	continue;
399     res = xmalloc(((p - cp) + (q - dp) - 1) * sizeof(Char));
400     for (ep = res, q = cp; (*ep++ = *q++) != '\0';)
401 	continue;
402     for (ep--, q = dp; (*ep++ = *q++) != '\0';)
403 	continue;
404     return (res);
405 }
406 
407 Char   *
408 s_strend(const Char *cp)
409 {
410     if (!cp)
411 	return ((Char *)(intptr_t) cp);
412     while (*cp)
413 	cp++;
414     return ((Char *)(intptr_t) cp);
415 }
416 
417 Char   *
418 s_strstr(const Char *s, const Char *t)
419 {
420     do {
421 	const Char *ss = s;
422 	const Char *tt = t;
423 
424 	do
425 	    if (*tt == '\0')
426 		return ((Char *)(intptr_t) s);
427 	while (*ss++ == *tt++);
428     } while (*s++ != '\0');
429     return (NULL);
430 }
431 
432 #else /* !SHORT_STRINGS */
433 char *
434 caching_strip(const char *s)
435 {
436     static char *buf = NULL;
437     static size_t buf_size = 0;
438     size_t size;
439 
440     if (s == NULL)
441       return NULL;
442     size = strlen(s) + 1;
443     if (buf_size < size) {
444 	buf = xrealloc(buf, size);
445 	buf_size = size;
446     }
447     memcpy(buf, s, size);
448     strip(buf);
449     return buf;
450 }
451 #endif
452 
453 char   *
454 short2qstr(const Char *src)
455 {
456     static char *sdst = NULL;
457     static size_t dstsize = 0;
458     char *dst, *edst;
459 
460     if (src == NULL)
461 	return (NULL);
462 
463     if (sdst == NULL) {
464 	dstsize = MALLOC_INCR;
465 	sdst = xmalloc((dstsize + MALLOC_SURPLUS) * sizeof(char));
466     }
467     dst = sdst;
468     edst = &dst[dstsize];
469     while (*src) {
470 	if (*src & QUOTE) {
471 	    *dst++ = '\\';
472 	    if (dst == edst) {
473 		dstsize += MALLOC_INCR;
474 		sdst = xrealloc(sdst,
475 				(dstsize + MALLOC_SURPLUS) * sizeof(char));
476 		edst = &sdst[dstsize];
477 		dst = &edst[-MALLOC_INCR];
478 	    }
479 	}
480 	dst += one_wctomb(dst, *src & CHAR);
481 	src++;
482 	if (dst >= edst) {
483 	    dstsize += MALLOC_INCR;
484 	    sdst = xrealloc(sdst, (dstsize + MALLOC_SURPLUS) * sizeof(char));
485 	    edst = &sdst[dstsize];
486 	    dst = &edst[-MALLOC_INCR];
487 	}
488     }
489     *dst = 0;
490     return (sdst);
491 }
492 
493 static void
494 bb_store(struct blk_buf *bb, Char *str)
495 {
496     if (bb->len == bb->size) { /* Keep space for terminating NULL */
497 	if (bb->size == 0)
498 	    bb->size = 16; /* Arbitrary */
499 	else
500 	    bb->size *= 2;
501 	bb->vec = xrealloc(bb->vec, bb->size * sizeof (*bb->vec));
502     }
503     bb->vec[bb->len] = str;
504 }
505 
506 void
507 bb_append(struct blk_buf *bb, Char *str)
508 {
509     bb_store(bb, str);
510     bb->len++;
511 }
512 
513 void
514 bb_cleanup(void *xbb)
515 {
516     struct blk_buf *bb;
517     size_t i;
518 
519     bb = xbb;
520     for (i = 0; i < bb->len; i++)
521 	xfree(bb->vec[i]);
522     xfree(bb->vec);
523 }
524 
525 Char **
526 bb_finish(struct blk_buf *bb)
527 {
528     bb_store(bb, NULL);
529     return xrealloc(bb->vec, (bb->len + 1) * sizeof (*bb->vec));
530 }
531 
532 #define DO_STRBUF(STRBUF, CHAR, STRLEN)				\
533 static void							\
534 STRBUF##_store1(struct STRBUF *buf, CHAR c)			\
535 {								\
536     if (buf->size == buf->len) {				\
537 	if (buf->size == 0)					\
538 	    buf->size = 64; /* Arbitrary */			\
539 	else							\
540 	    buf->size *= 2;					\
541 	buf->s = xrealloc(buf->s, buf->size * sizeof(*buf->s));	\
542     }								\
543     buf->s[buf->len] = c;					\
544 }								\
545 								\
546 /* Like strbuf_append1(buf, '\0'), but don't advance len */	\
547 void								\
548 STRBUF##_terminate(struct STRBUF *buf)				\
549 {								\
550     STRBUF##_store1(buf, '\0');					\
551 }								\
552 								\
553 void								\
554 STRBUF##_append1(struct STRBUF *buf, CHAR c)			\
555 {								\
556     STRBUF##_store1(buf, c);					\
557     buf->len++;							\
558 }								\
559 								\
560 void								\
561 STRBUF##_appendn(struct STRBUF *buf, const CHAR *s, size_t len)	\
562 {								\
563     if (buf->size < buf->len + len) {				\
564 	if (buf->size == 0)					\
565 	    buf->size = 64; /* Arbitrary */			\
566 	while (buf->size < buf->len + len)			\
567 	    buf->size *= 2;					\
568 	buf->s = xrealloc(buf->s, buf->size * sizeof(*buf->s));	\
569     }								\
570     memcpy(buf->s + buf->len, s, len * sizeof(*buf->s));	\
571     buf->len += len;						\
572 }								\
573 								\
574 void								\
575 STRBUF##_append(struct STRBUF *buf, const CHAR *s)		\
576 {								\
577     STRBUF##_appendn(buf, s, STRLEN(s));			\
578 }								\
579 								\
580 CHAR *								\
581 STRBUF##_finish(struct STRBUF *buf)				\
582 {								\
583     STRBUF##_append1(buf, 0);					\
584     return xrealloc(buf->s, buf->len * sizeof(*buf->s));	\
585 }								\
586 								\
587 void								\
588 STRBUF##_cleanup(void *xbuf)					\
589 {								\
590     struct STRBUF *buf;						\
591 								\
592     buf = xbuf;							\
593     xfree(buf->s);						\
594 }								\
595 								\
596 const struct STRBUF STRBUF##_init /* = STRBUF##_INIT; */
597 
598 DO_STRBUF(strbuf, char, strlen);
599 DO_STRBUF(Strbuf, Char, Strlen);
600