str.c revision 1.65 1 1.65 rillig /* $NetBSD: str.c,v 1.65 2020/09/13 15:15:51 rillig Exp $ */
2 1.10 christos
3 1.1 cgd /*-
4 1.13 christos * Copyright (c) 1988, 1989, 1990, 1993
5 1.13 christos * The Regents of the University of California. All rights reserved.
6 1.20 agc *
7 1.20 agc * This code is derived from software contributed to Berkeley by
8 1.20 agc * Adam de Boor.
9 1.20 agc *
10 1.20 agc * Redistribution and use in source and binary forms, with or without
11 1.20 agc * modification, are permitted provided that the following conditions
12 1.20 agc * are met:
13 1.20 agc * 1. Redistributions of source code must retain the above copyright
14 1.20 agc * notice, this list of conditions and the following disclaimer.
15 1.20 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.20 agc * notice, this list of conditions and the following disclaimer in the
17 1.20 agc * documentation and/or other materials provided with the distribution.
18 1.20 agc * 3. Neither the name of the University nor the names of its contributors
19 1.20 agc * may be used to endorse or promote products derived from this software
20 1.20 agc * without specific prior written permission.
21 1.20 agc *
22 1.20 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.20 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.20 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.20 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.20 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.20 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.20 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.20 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.20 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.20 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.20 agc * SUCH DAMAGE.
33 1.20 agc */
34 1.20 agc
35 1.20 agc /*-
36 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
37 1.1 cgd * All rights reserved.
38 1.1 cgd *
39 1.1 cgd * This code is derived from software contributed to Berkeley by
40 1.1 cgd * Adam de Boor.
41 1.1 cgd *
42 1.1 cgd * Redistribution and use in source and binary forms, with or without
43 1.1 cgd * modification, are permitted provided that the following conditions
44 1.1 cgd * are met:
45 1.1 cgd * 1. Redistributions of source code must retain the above copyright
46 1.1 cgd * notice, this list of conditions and the following disclaimer.
47 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
48 1.1 cgd * notice, this list of conditions and the following disclaimer in the
49 1.1 cgd * documentation and/or other materials provided with the distribution.
50 1.1 cgd * 3. All advertising materials mentioning features or use of this software
51 1.1 cgd * must display the following acknowledgement:
52 1.1 cgd * This product includes software developed by the University of
53 1.1 cgd * California, Berkeley and its contributors.
54 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
55 1.1 cgd * may be used to endorse or promote products derived from this software
56 1.1 cgd * without specific prior written permission.
57 1.1 cgd *
58 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 1.1 cgd * SUCH DAMAGE.
69 1.1 cgd */
70 1.1 cgd
71 1.65 rillig #include "make.h"
72 1.1 cgd
73 1.65 rillig /* "@(#)str.c 5.8 (Berkeley) 6/1/90" */
74 1.65 rillig MAKE_RCSID("$NetBSD: str.c,v 1.65 2020/09/13 15:15:51 rillig Exp $");
75 1.1 cgd
76 1.59 rillig /* Return the concatenation of s1 and s2, freshly allocated. */
77 1.1 cgd char *
78 1.59 rillig str_concat2(const char *s1, const char *s2)
79 1.1 cgd {
80 1.57 rillig size_t len1 = strlen(s1);
81 1.57 rillig size_t len2 = strlen(s2);
82 1.59 rillig char *result = bmake_malloc(len1 + len2 + 1);
83 1.28 christos memcpy(result, s1, len1);
84 1.28 christos memcpy(result + len1, s2, len2 + 1);
85 1.59 rillig return result;
86 1.59 rillig }
87 1.1 cgd
88 1.59 rillig /* Return the concatenation of s1, s2 and s3, freshly allocated. */
89 1.59 rillig char *
90 1.59 rillig str_concat3(const char *s1, const char *s2, const char *s3)
91 1.59 rillig {
92 1.59 rillig size_t len1 = strlen(s1);
93 1.59 rillig size_t len2 = strlen(s2);
94 1.59 rillig size_t len3 = strlen(s3);
95 1.59 rillig char *result = bmake_malloc(len1 + len2 + len3 + 1);
96 1.59 rillig memcpy(result, s1, len1);
97 1.59 rillig memcpy(result + len1, s2, len2);
98 1.59 rillig memcpy(result + len1 + len2, s3, len3 + 1);
99 1.45 rillig return result;
100 1.1 cgd }
101 1.1 cgd
102 1.60 rillig /* Return the concatenation of s1, s2, s3 and s4, freshly allocated. */
103 1.60 rillig char *
104 1.60 rillig str_concat4(const char *s1, const char *s2, const char *s3, const char *s4)
105 1.60 rillig {
106 1.60 rillig size_t len1 = strlen(s1);
107 1.60 rillig size_t len2 = strlen(s2);
108 1.60 rillig size_t len3 = strlen(s3);
109 1.60 rillig size_t len4 = strlen(s4);
110 1.60 rillig char *result = bmake_malloc(len1 + len2 + len3 + len4 + 1);
111 1.60 rillig memcpy(result, s1, len1);
112 1.60 rillig memcpy(result + len1, s2, len2);
113 1.60 rillig memcpy(result + len1 + len2, s3, len3);
114 1.60 rillig memcpy(result + len1 + len2 + len3, s4, len4 + 1);
115 1.60 rillig return result;
116 1.60 rillig }
117 1.60 rillig
118 1.64 rillig /* Fracture a string into an array of words (as delineated by tabs or spaces)
119 1.64 rillig * taking quotation marks into account. Leading tabs/spaces are ignored.
120 1.64 rillig *
121 1.64 rillig * If expand is TRUE, quotes are removed and escape sequences such as \r, \t,
122 1.64 rillig * etc... are expanded. In this case, the return value is NULL on parse
123 1.64 rillig * errors.
124 1.64 rillig *
125 1.64 rillig * Returns the fractured words, which must be freed later using Words_Free.
126 1.64 rillig * If expand was TRUE and there was a parse error, words is NULL, and in that
127 1.64 rillig * case, nothing needs to be freed.
128 1.1 cgd */
129 1.64 rillig Words
130 1.64 rillig Str_Words(const char *str, Boolean expand)
131 1.1 cgd {
132 1.56 rillig size_t str_len;
133 1.56 rillig char *words_buf;
134 1.61 rillig size_t words_cap;
135 1.56 rillig char **words;
136 1.61 rillig size_t words_len;
137 1.56 rillig char inquote;
138 1.56 rillig char *word_start;
139 1.56 rillig char *word_end;
140 1.55 rillig const char *str_p;
141 1.55 rillig
142 1.4 cgd /* skip leading space chars. */
143 1.4 cgd for (; *str == ' ' || *str == '\t'; ++str)
144 1.4 cgd continue;
145 1.1 cgd
146 1.41 rillig /* words_buf holds the words, separated by '\0'. */
147 1.55 rillig str_len = strlen(str);
148 1.55 rillig words_buf = bmake_malloc(strlen(str) + 1);
149 1.1 cgd
150 1.55 rillig words_cap = MAX((str_len / 5), 50);
151 1.55 rillig words = bmake_malloc((words_cap + 1) * sizeof(char *));
152 1.35 sjg
153 1.35 sjg /*
154 1.1 cgd * copy the string; at the same time, parse backslashes,
155 1.41 rillig * quotes and build the word list.
156 1.1 cgd */
157 1.55 rillig words_len = 0;
158 1.55 rillig inquote = '\0';
159 1.55 rillig word_start = words_buf;
160 1.55 rillig word_end = words_buf;
161 1.41 rillig for (str_p = str;; ++str_p) {
162 1.41 rillig char ch = *str_p;
163 1.56 rillig switch (ch) {
164 1.1 cgd case '"':
165 1.1 cgd case '\'':
166 1.17 christos if (inquote) {
167 1.1 cgd if (inquote == ch)
168 1.4 cgd inquote = '\0';
169 1.1 cgd else
170 1.1 cgd break;
171 1.56 rillig } else {
172 1.56 rillig inquote = (char)ch;
173 1.6 jtc /* Don't miss "" or '' */
174 1.41 rillig if (word_start == NULL && str_p[1] == inquote) {
175 1.30 christos if (!expand) {
176 1.41 rillig word_start = word_end;
177 1.41 rillig *word_end++ = ch;
178 1.30 christos } else
179 1.41 rillig word_start = word_end + 1;
180 1.41 rillig str_p++;
181 1.25 christos inquote = '\0';
182 1.6 jtc break;
183 1.6 jtc }
184 1.6 jtc }
185 1.8 jtc if (!expand) {
186 1.41 rillig if (word_start == NULL)
187 1.41 rillig word_start = word_end;
188 1.41 rillig *word_end++ = ch;
189 1.8 jtc }
190 1.1 cgd continue;
191 1.1 cgd case ' ':
192 1.1 cgd case '\t':
193 1.8 jtc case '\n':
194 1.1 cgd if (inquote)
195 1.1 cgd break;
196 1.41 rillig if (word_start == NULL)
197 1.1 cgd continue;
198 1.1 cgd /* FALLTHROUGH */
199 1.1 cgd case '\0':
200 1.1 cgd /*
201 1.41 rillig * end of a token -- make sure there's enough words
202 1.1 cgd * space and save off a pointer.
203 1.1 cgd */
204 1.41 rillig if (word_start == NULL)
205 1.56 rillig goto done;
206 1.8 jtc
207 1.41 rillig *word_end++ = '\0';
208 1.41 rillig if (words_len == words_cap) {
209 1.56 rillig size_t new_size;
210 1.41 rillig words_cap *= 2; /* ramp up fast */
211 1.56 rillig new_size = (words_cap + 1) * sizeof(char *);
212 1.56 rillig words = bmake_realloc(words, new_size);
213 1.1 cgd }
214 1.41 rillig words[words_len++] = word_start;
215 1.41 rillig word_start = NULL;
216 1.31 christos if (ch == '\n' || ch == '\0') {
217 1.31 christos if (expand && inquote) {
218 1.41 rillig free(words);
219 1.41 rillig free(words_buf);
220 1.64 rillig return (Words){ NULL, 0, NULL };
221 1.31 christos }
222 1.1 cgd goto done;
223 1.31 christos }
224 1.1 cgd continue;
225 1.1 cgd case '\\':
226 1.8 jtc if (!expand) {
227 1.41 rillig if (word_start == NULL)
228 1.41 rillig word_start = word_end;
229 1.41 rillig *word_end++ = '\\';
230 1.41 rillig /* catch '\' at end of line */
231 1.41 rillig if (str_p[1] == '\0')
232 1.26 erh continue;
233 1.41 rillig ch = *++str_p;
234 1.8 jtc break;
235 1.8 jtc }
236 1.13 christos
237 1.41 rillig switch (ch = *++str_p) {
238 1.1 cgd case '\0':
239 1.1 cgd case '\n':
240 1.1 cgd /* hmmm; fix it up as best we can */
241 1.1 cgd ch = '\\';
242 1.41 rillig --str_p;
243 1.1 cgd break;
244 1.1 cgd case 'b':
245 1.1 cgd ch = '\b';
246 1.1 cgd break;
247 1.1 cgd case 'f':
248 1.1 cgd ch = '\f';
249 1.1 cgd break;
250 1.1 cgd case 'n':
251 1.1 cgd ch = '\n';
252 1.1 cgd break;
253 1.1 cgd case 'r':
254 1.1 cgd ch = '\r';
255 1.1 cgd break;
256 1.1 cgd case 't':
257 1.1 cgd ch = '\t';
258 1.1 cgd break;
259 1.1 cgd }
260 1.1 cgd break;
261 1.1 cgd }
262 1.41 rillig if (word_start == NULL)
263 1.41 rillig word_start = word_end;
264 1.41 rillig *word_end++ = ch;
265 1.1 cgd }
266 1.56 rillig done:
267 1.56 rillig words[words_len] = NULL;
268 1.64 rillig return (Words){ words, words_len, words_buf };
269 1.1 cgd }
270 1.1 cgd
271 1.1 cgd /*
272 1.1 cgd * Str_FindSubstring -- See if a string contains a particular substring.
273 1.13 christos *
274 1.18 wiz * Input:
275 1.18 wiz * string String to search.
276 1.18 wiz * substring Substring to find in string.
277 1.18 wiz *
278 1.1 cgd * Results: If string contains substring, the return value is the location of
279 1.1 cgd * the first matching instance of substring in string. If string doesn't
280 1.1 cgd * contain substring, the return value is NULL. Matching is done on an exact
281 1.1 cgd * character-for-character basis with no wildcards or special characters.
282 1.13 christos *
283 1.1 cgd * Side effects: None.
284 1.1 cgd */
285 1.1 cgd char *
286 1.19 christos Str_FindSubstring(const char *string, const char *substring)
287 1.1 cgd {
288 1.19 christos const char *a, *b;
289 1.1 cgd
290 1.1 cgd /*
291 1.1 cgd * First scan quickly through the two strings looking for a single-
292 1.1 cgd * character match. When it's found, then compare the rest of the
293 1.1 cgd * substring.
294 1.1 cgd */
295 1.1 cgd
296 1.44 rillig for (b = substring; *string != 0; string++) {
297 1.1 cgd if (*string != *b)
298 1.1 cgd continue;
299 1.1 cgd a = string;
300 1.1 cgd for (;;) {
301 1.1 cgd if (*b == 0)
302 1.19 christos return UNCONST(string);
303 1.1 cgd if (*a++ != *b++)
304 1.1 cgd break;
305 1.1 cgd }
306 1.1 cgd b = substring;
307 1.1 cgd }
308 1.19 christos return NULL;
309 1.1 cgd }
310 1.1 cgd
311 1.1 cgd /*
312 1.51 rillig * Str_Match -- Test if a string matches a pattern like "*.[ch]".
313 1.13 christos *
314 1.49 rillig * XXX this function does not detect or report malformed patterns.
315 1.13 christos *
316 1.49 rillig * Results:
317 1.49 rillig * Non-zero is returned if string matches the pattern, 0 otherwise. The
318 1.49 rillig * matching operation permits the following special characters in the
319 1.51 rillig * pattern: *?\[] (as in fnmatch(3)).
320 1.34 dholland *
321 1.1 cgd * Side effects: None.
322 1.1 cgd */
323 1.51 rillig Boolean
324 1.51 rillig Str_Match(const char *str, const char *pat)
325 1.1 cgd {
326 1.1 cgd for (;;) {
327 1.1 cgd /*
328 1.1 cgd * See if we're at the end of both the pattern and the
329 1.1 cgd * string. If, we succeeded. If we're at the end of the
330 1.1 cgd * pattern but not at the end of the string, we failed.
331 1.1 cgd */
332 1.51 rillig if (*pat == 0)
333 1.51 rillig return *str == 0;
334 1.51 rillig if (*str == 0 && *pat != '*')
335 1.51 rillig return FALSE;
336 1.51 rillig
337 1.1 cgd /*
338 1.51 rillig * A '*' in the pattern matches any substring. We handle this
339 1.51 rillig * by calling ourselves for each suffix of the string.
340 1.1 cgd */
341 1.51 rillig if (*pat == '*') {
342 1.51 rillig pat++;
343 1.51 rillig while (*pat == '*')
344 1.51 rillig pat++;
345 1.51 rillig if (*pat == 0)
346 1.51 rillig return TRUE;
347 1.51 rillig while (*str != 0) {
348 1.51 rillig if (Str_Match(str, pat))
349 1.51 rillig return TRUE;
350 1.51 rillig str++;
351 1.1 cgd }
352 1.51 rillig return FALSE;
353 1.1 cgd }
354 1.51 rillig
355 1.51 rillig /* A '?' in the pattern matches any single character. */
356 1.51 rillig if (*pat == '?')
357 1.1 cgd goto thisCharOK;
358 1.51 rillig
359 1.1 cgd /*
360 1.51 rillig * A '[' in the pattern matches a character from a list.
361 1.51 rillig * The '[' is followed by the list of acceptable characters,
362 1.51 rillig * or by ranges (two characters separated by '-'). In these
363 1.51 rillig * character lists, the backslash is an ordinary character.
364 1.1 cgd */
365 1.51 rillig if (*pat == '[') {
366 1.51 rillig Boolean neg = pat[1] == '^';
367 1.63 rillig pat += neg ? 2 : 1;
368 1.37 sjg
369 1.1 cgd for (;;) {
370 1.51 rillig if (*pat == ']' || *pat == 0) {
371 1.51 rillig if (neg)
372 1.38 sjg break;
373 1.51 rillig return FALSE;
374 1.38 sjg }
375 1.51 rillig if (*pat == *str)
376 1.1 cgd break;
377 1.51 rillig if (pat[1] == '-') {
378 1.51 rillig if (pat[2] == 0)
379 1.51 rillig return neg;
380 1.51 rillig if (*pat <= *str && pat[2] >= *str)
381 1.1 cgd break;
382 1.51 rillig if (*pat >= *str && pat[2] <= *str)
383 1.1 cgd break;
384 1.51 rillig pat += 2;
385 1.1 cgd }
386 1.51 rillig pat++;
387 1.1 cgd }
388 1.51 rillig if (neg && *pat != ']' && *pat != 0)
389 1.51 rillig return FALSE;
390 1.51 rillig while (*pat != ']' && *pat != 0)
391 1.51 rillig pat++;
392 1.51 rillig if (*pat == 0)
393 1.51 rillig pat--;
394 1.1 cgd goto thisCharOK;
395 1.1 cgd }
396 1.51 rillig
397 1.1 cgd /*
398 1.51 rillig * A backslash in the pattern matches the character following
399 1.51 rillig * it exactly.
400 1.1 cgd */
401 1.51 rillig if (*pat == '\\') {
402 1.51 rillig pat++;
403 1.51 rillig if (*pat == 0)
404 1.51 rillig return FALSE;
405 1.1 cgd }
406 1.51 rillig
407 1.51 rillig if (*pat != *str)
408 1.51 rillig return FALSE;
409 1.51 rillig
410 1.51 rillig thisCharOK:
411 1.51 rillig pat++;
412 1.51 rillig str++;
413 1.1 cgd }
414 1.4 cgd }
415