str.c revision 5814 
1/*-
2 * Copyright (c) 1988, 1989, 1990, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 * Copyright (c) 1989 by Berkeley Softworks
5 * 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. All advertising materials mentioning features or use of this software
19 *    must display the following acknowledgement:
20 *	This product includes software developed by the University of
21 *	California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 *    may be used to endorse or promote products derived from this software
24 *    without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38
39#ifndef lint
40/* from: static char     sccsid[] = "@(#)str.c	5.8 (Berkeley) 6/1/90"; */
41static char *rcsid = "$Id: str.c,v 1.8 1994/06/16 18:50:18 jtc Exp $";
42#endif				/* not lint */
43
44#include "make.h"
45
46static char **argv, *buffer;
47static int argmax, curlen;
48
49/*
50 * str_init --
51 *	Initialize the strings package
52 *
53 */
54void
55str_init()
56{
57    char *p1;
58    argv = (char **)emalloc((argmax = 50) * sizeof(char *));
59    argv[0] = Var_Value(".MAKE", VAR_GLOBAL, &p1);
60}
61
62
63/*
64 * str_end --
65 *	Cleanup the strings package
66 *
67 */
68void
69str_end()
70{
71    free(argv[0]);
72    free((Address) argv);
73    if (buffer)
74	free(buffer);
75}
76
77/*-
78 * str_concat --
79 *	concatenate the two strings, inserting a space or slash between them,
80 *	freeing them if requested.
81 *
82 * returns --
83 *	the resulting string in allocated space.
84 */
85char *
86str_concat(s1, s2, flags)
87	char *s1, *s2;
88	int flags;
89{
90	register int len1, len2;
91	register char *result;
92
93	/* get the length of both strings */
94	len1 = strlen(s1);
95	len2 = strlen(s2);
96
97	/* allocate length plus separator plus EOS */
98	result = emalloc((u_int)(len1 + len2 + 2));
99
100	/* copy first string into place */
101	memcpy(result, s1, len1);
102
103	/* add separator character */
104	if (flags & STR_ADDSPACE) {
105		result[len1] = ' ';
106		++len1;
107	} else if (flags & STR_ADDSLASH) {
108		result[len1] = '/';
109		++len1;
110	}
111
112	/* copy second string plus EOS into place */
113	memcpy(result + len1, s2, len2 + 1);
114
115	/* free original strings */
116	if (flags & STR_DOFREE) {
117		(void)free(s1);
118		(void)free(s2);
119	}
120	return(result);
121}
122
123/*-
124 * brk_string --
125 *	Fracture a string into an array of words (as delineated by tabs or
126 *	spaces) taking quotation marks into account.  Leading tabs/spaces
127 *	are ignored.
128 *
129 * returns --
130 *	Pointer to the array of pointers to the words.  To make life easier,
131 *	the first word is always the value of the .MAKE variable.
132 */
133char **
134brk_string(str, store_argc, expand)
135	register char *str;
136	int *store_argc;
137	Boolean expand;
138{
139	register int argc, ch;
140	register char inquote, *p, *start, *t;
141	int len;
142
143	/* skip leading space chars. */
144	for (; *str == ' ' || *str == '\t'; ++str)
145		continue;
146
147	/* allocate room for a copy of the string */
148	if ((len = strlen(str) + 1) > curlen) {
149		if (buffer)
150		    free(buffer);
151		buffer = emalloc(curlen = len);
152	}
153
154	/*
155	 * copy the string; at the same time, parse backslashes,
156	 * quotes and build the argument list.
157	 */
158	argc = 1;
159	inquote = '\0';
160	for (p = str, start = t = buffer;; ++p) {
161		switch(ch = *p) {
162		case '"':
163		case '\'':
164			if (inquote)
165				if (inquote == ch)
166					inquote = '\0';
167				else
168					break;
169			else {
170				inquote = (char) ch;
171				/* Don't miss "" or '' */
172				if (start == NULL && p[1] == inquote) {
173					start = t + 1;
174					break;
175				}
176			}
177			if (!expand) {
178				if (!start)
179					start = t;
180				*t++ = ch;
181			}
182			continue;
183		case ' ':
184		case '\t':
185		case '\n':
186			if (inquote)
187				break;
188			if (!start)
189				continue;
190			/* FALLTHROUGH */
191		case '\0':
192			/*
193			 * end of a token -- make sure there's enough argv
194			 * space and save off a pointer.
195			 */
196			if (!start)
197			    goto done;
198
199			*t++ = '\0';
200			if (argc == argmax) {
201				argmax *= 2;		/* ramp up fast */
202				if (!(argv = (char **)realloc(argv,
203				    argmax * sizeof(char *))))
204				enomem();
205			}
206			argv[argc++] = start;
207			start = (char *)NULL;
208			if (ch == '\n' || ch == '\0')
209				goto done;
210			continue;
211		case '\\':
212			if (!expand) {
213				if (!start)
214					start = t;
215				*t++ = '\\';
216				ch = *++p;
217				break;
218			}
219
220			switch (ch = *++p) {
221			case '\0':
222			case '\n':
223				/* hmmm; fix it up as best we can */
224				ch = '\\';
225				--p;
226				break;
227			case 'b':
228				ch = '\b';
229				break;
230			case 'f':
231				ch = '\f';
232				break;
233			case 'n':
234				ch = '\n';
235				break;
236			case 'r':
237				ch = '\r';
238				break;
239			case 't':
240				ch = '\t';
241				break;
242			}
243			break;
244		}
245		if (!start)
246			start = t;
247		*t++ = (char) ch;
248	}
249done:	argv[argc] = (char *)NULL;
250	*store_argc = argc;
251	return(argv);
252}
253
254/*
255 * Str_FindSubstring -- See if a string contains a particular substring.
256 *
257 * Results: If string contains substring, the return value is the location of
258 * the first matching instance of substring in string.  If string doesn't
259 * contain substring, the return value is NULL.  Matching is done on an exact
260 * character-for-character basis with no wildcards or special characters.
261 *
262 * Side effects: None.
263 */
264char *
265Str_FindSubstring(string, substring)
266	register char *string;		/* String to search. */
267	char *substring;		/* Substring to find in string */
268{
269	register char *a, *b;
270
271	/*
272	 * First scan quickly through the two strings looking for a single-
273	 * character match.  When it's found, then compare the rest of the
274	 * substring.
275	 */
276
277	for (b = substring; *string != 0; string += 1) {
278		if (*string != *b)
279			continue;
280		a = string;
281		for (;;) {
282			if (*b == 0)
283				return(string);
284			if (*a++ != *b++)
285				break;
286		}
287		b = substring;
288	}
289	return((char *) NULL);
290}
291
292/*
293 * Str_Match --
294 *
295 * See if a particular string matches a particular pattern.
296 *
297 * Results: Non-zero is returned if string matches pattern, 0 otherwise. The
298 * matching operation permits the following special characters in the
299 * pattern: *?\[] (see the man page for details on what these mean).
300 *
301 * Side effects: None.
302 */
303int
304Str_Match(string, pattern)
305	register char *string;		/* String */
306	register char *pattern;		/* Pattern */
307{
308	char c2;
309
310	for (;;) {
311		/*
312		 * See if we're at the end of both the pattern and the
313		 * string. If, we succeeded.  If we're at the end of the
314		 * pattern but not at the end of the string, we failed.
315		 */
316		if (*pattern == 0)
317			return(!*string);
318		if (*string == 0 && *pattern != '*')
319			return(0);
320		/*
321		 * Check for a "*" as the next pattern character.  It matches
322		 * any substring.  We handle this by calling ourselves
323		 * recursively for each postfix of string, until either we
324		 * match or we reach the end of the string.
325		 */
326		if (*pattern == '*') {
327			pattern += 1;
328			if (*pattern == 0)
329				return(1);
330			while (*string != 0) {
331				if (Str_Match(string, pattern))
332					return(1);
333				++string;
334			}
335			return(0);
336		}
337		/*
338		 * Check for a "?" as the next pattern character.  It matches
339		 * any single character.
340		 */
341		if (*pattern == '?')
342			goto thisCharOK;
343		/*
344		 * Check for a "[" as the next pattern character.  It is
345		 * followed by a list of characters that are acceptable, or
346		 * by a range (two characters separated by "-").
347		 */
348		if (*pattern == '[') {
349			++pattern;
350			for (;;) {
351				if ((*pattern == ']') || (*pattern == 0))
352					return(0);
353				if (*pattern == *string)
354					break;
355				if (pattern[1] == '-') {
356					c2 = pattern[2];
357					if (c2 == 0)
358						return(0);
359					if ((*pattern <= *string) &&
360					    (c2 >= *string))
361						break;
362					if ((*pattern >= *string) &&
363					    (c2 <= *string))
364						break;
365					pattern += 2;
366				}
367				++pattern;
368			}
369			while ((*pattern != ']') && (*pattern != 0))
370				++pattern;
371			goto thisCharOK;
372		}
373		/*
374		 * If the next pattern character is '/', just strip off the
375		 * '/' so we do exact matching on the character that follows.
376		 */
377		if (*pattern == '\\') {
378			++pattern;
379			if (*pattern == 0)
380				return(0);
381		}
382		/*
383		 * There's no special character.  Just make sure that the
384		 * next characters of each string match.
385		 */
386		if (*pattern != *string)
387			return(0);
388thisCharOK:	++pattern;
389		++string;
390	}
391}
392
393
394/*-
395 *-----------------------------------------------------------------------
396 * Str_SYSVMatch --
397 *	Check word against pattern for a match (% is wild),
398 *
399 * Results:
400 *	Returns the beginning position of a match or null. The number
401 *	of characters matched is returned in len.
402 *
403 * Side Effects:
404 *	None
405 *
406 *-----------------------------------------------------------------------
407 */
408char *
409Str_SYSVMatch(word, pattern, len)
410    char	*word;		/* Word to examine */
411    char	*pattern;	/* Pattern to examine against */
412    int		*len;		/* Number of characters to substitute */
413{
414    char *p = pattern;
415    char *w = word;
416    char *m;
417
418    if (*p == '\0') {
419	/* Null pattern is the whole string */
420	*len = strlen(w);
421	return w;
422    }
423
424    if ((m = strchr(p, '%')) != NULL) {
425	/* check that the prefix matches */
426	for (; p != m && *w && *w == *p; w++, p++)
427	     continue;
428
429	if (p != m)
430	    return NULL;	/* No match */
431
432	if (*++p == '\0') {
433	    /* No more pattern, return the rest of the string */
434	    *len = strlen(w);
435	    return w;
436	}
437    }
438
439    m = w;
440
441    /* Find a matching tail */
442    do
443	if (strcmp(p, w) == 0) {
444	    *len = w - m;
445	    return m;
446	}
447    while (*w++ != '\0');
448
449    return NULL;
450}
451
452
453/*-
454 *-----------------------------------------------------------------------
455 * Str_SYSVSubst --
456 *	Substitute '%' on the pattern with len characters from src.
457 *	If the pattern does not contain a '%' prepend len characters
458 *	from src.
459 *
460 * Results:
461 *	None
462 *
463 * Side Effects:
464 *	Places result on buf
465 *
466 *-----------------------------------------------------------------------
467 */
468void
469Str_SYSVSubst(buf, pat, src, len)
470    Buffer buf;
471    char *pat;
472    char *src;
473    int   len;
474{
475    char *m;
476
477    if ((m = strchr(pat, '%')) != NULL) {
478	/* Copy the prefix */
479	Buf_AddBytes(buf, m - pat, (Byte *) pat);
480	/* skip the % */
481	pat = m + 1;
482    }
483
484    /* Copy the pattern */
485    Buf_AddBytes(buf, len, (Byte *) src);
486
487    /* append the rest */
488    Buf_AddBytes(buf, strlen(pat), (Byte *) pat);
489}
490