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