Home | History | Annotate | Line # | Download | only in make
str.c revision 1.25
      1  1.25  christos /*	$NetBSD: str.c,v 1.25 2006/08/11 19:11:00 christos 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.22      ross #ifndef MAKE_NATIVE
     72  1.25  christos static char rcsid[] = "$NetBSD: str.c,v 1.25 2006/08/11 19:11:00 christos Exp $";
     73  1.15     lukem #else
     74  1.14  christos #include <sys/cdefs.h>
     75   1.1       cgd #ifndef lint
     76  1.10  christos #if 0
     77  1.10  christos static char     sccsid[] = "@(#)str.c	5.8 (Berkeley) 6/1/90";
     78  1.10  christos #else
     79  1.25  christos __RCSID("$NetBSD: str.c,v 1.25 2006/08/11 19:11:00 christos Exp $");
     80  1.10  christos #endif
     81   1.1       cgd #endif				/* not lint */
     82  1.15     lukem #endif
     83   1.1       cgd 
     84   1.1       cgd #include "make.h"
     85   1.1       cgd 
     86   1.1       cgd /*-
     87   1.1       cgd  * str_concat --
     88   1.1       cgd  *	concatenate the two strings, inserting a space or slash between them,
     89   1.1       cgd  *	freeing them if requested.
     90   1.1       cgd  *
     91   1.1       cgd  * returns --
     92   1.1       cgd  *	the resulting string in allocated space.
     93   1.1       cgd  */
     94   1.1       cgd char *
     95  1.19  christos str_concat(const char *s1, const char *s2, int flags)
     96   1.1       cgd {
     97  1.18       wiz 	int len1, len2;
     98  1.18       wiz 	char *result;
     99   1.1       cgd 
    100   1.1       cgd 	/* get the length of both strings */
    101   1.1       cgd 	len1 = strlen(s1);
    102   1.1       cgd 	len2 = strlen(s2);
    103   1.1       cgd 
    104   1.1       cgd 	/* allocate length plus separator plus EOS */
    105   1.1       cgd 	result = emalloc((u_int)(len1 + len2 + 2));
    106   1.1       cgd 
    107   1.1       cgd 	/* copy first string into place */
    108   1.4       cgd 	memcpy(result, s1, len1);
    109   1.1       cgd 
    110   1.1       cgd 	/* add separator character */
    111   1.1       cgd 	if (flags & STR_ADDSPACE) {
    112   1.1       cgd 		result[len1] = ' ';
    113   1.1       cgd 		++len1;
    114   1.1       cgd 	} else if (flags & STR_ADDSLASH) {
    115   1.1       cgd 		result[len1] = '/';
    116   1.1       cgd 		++len1;
    117   1.1       cgd 	}
    118   1.1       cgd 
    119   1.1       cgd 	/* copy second string plus EOS into place */
    120   1.4       cgd 	memcpy(result + len1, s2, len2 + 1);
    121   1.1       cgd 
    122   1.1       cgd 	return(result);
    123   1.1       cgd }
    124   1.1       cgd 
    125   1.1       cgd /*-
    126   1.1       cgd  * brk_string --
    127   1.1       cgd  *	Fracture a string into an array of words (as delineated by tabs or
    128   1.1       cgd  *	spaces) taking quotation marks into account.  Leading tabs/spaces
    129   1.1       cgd  *	are ignored.
    130   1.1       cgd  *
    131   1.1       cgd  * returns --
    132  1.21       sjg  *	Pointer to the array of pointers to the words.
    133   1.1       cgd  */
    134   1.1       cgd char **
    135  1.19  christos brk_string(const char *str, int *store_argc, Boolean expand, char **buffer)
    136   1.1       cgd {
    137  1.18       wiz 	int argc, ch;
    138  1.19  christos 	char inquote, *start, *t;
    139  1.19  christos 	const char *p;
    140   1.1       cgd 	int len;
    141  1.16  christos 	int argmax = 50, curlen = 0;
    142  1.23  christos     	char **argv = emalloc((argmax + 1) * sizeof(char *));
    143   1.1       cgd 
    144   1.4       cgd 	/* skip leading space chars. */
    145   1.4       cgd 	for (; *str == ' ' || *str == '\t'; ++str)
    146   1.4       cgd 		continue;
    147   1.1       cgd 
    148   1.1       cgd 	/* allocate room for a copy of the string */
    149  1.16  christos 	if ((len = strlen(str) + 1) > curlen)
    150  1.16  christos 		*buffer = emalloc(curlen = len);
    151   1.1       cgd 
    152   1.1       cgd 	/*
    153   1.1       cgd 	 * copy the string; at the same time, parse backslashes,
    154   1.1       cgd 	 * quotes and build the argument list.
    155   1.1       cgd 	 */
    156  1.16  christos 	argc = 0;
    157   1.1       cgd 	inquote = '\0';
    158  1.16  christos 	for (p = str, start = t = *buffer;; ++p) {
    159   1.1       cgd 		switch(ch = *p) {
    160   1.1       cgd 		case '"':
    161   1.1       cgd 		case '\'':
    162  1.17  christos 			if (inquote) {
    163   1.1       cgd 				if (inquote == ch)
    164   1.4       cgd 					inquote = '\0';
    165   1.1       cgd 				else
    166   1.1       cgd 					break;
    167  1.17  christos 			}
    168   1.6       jtc 			else {
    169   1.4       cgd 				inquote = (char) ch;
    170   1.6       jtc 				/* Don't miss "" or '' */
    171   1.6       jtc 				if (start == NULL && p[1] == inquote) {
    172   1.6       jtc 					start = t + 1;
    173  1.25  christos 					p++;
    174  1.25  christos 					inquote = '\0';
    175   1.6       jtc 					break;
    176   1.6       jtc 				}
    177   1.6       jtc 			}
    178   1.8       jtc 			if (!expand) {
    179   1.8       jtc 				if (!start)
    180   1.8       jtc 					start = t;
    181   1.8       jtc 				*t++ = ch;
    182   1.8       jtc 			}
    183   1.1       cgd 			continue;
    184   1.1       cgd 		case ' ':
    185   1.1       cgd 		case '\t':
    186   1.8       jtc 		case '\n':
    187   1.1       cgd 			if (inquote)
    188   1.1       cgd 				break;
    189   1.1       cgd 			if (!start)
    190   1.1       cgd 				continue;
    191   1.1       cgd 			/* FALLTHROUGH */
    192   1.1       cgd 		case '\0':
    193   1.1       cgd 			/*
    194   1.1       cgd 			 * end of a token -- make sure there's enough argv
    195   1.1       cgd 			 * space and save off a pointer.
    196   1.1       cgd 			 */
    197   1.8       jtc 			if (!start)
    198   1.8       jtc 			    goto done;
    199   1.8       jtc 
    200   1.1       cgd 			*t++ = '\0';
    201   1.1       cgd 			if (argc == argmax) {
    202   1.1       cgd 				argmax *= 2;		/* ramp up fast */
    203  1.12       jtc 				argv = (char **)erealloc(argv,
    204  1.12       jtc 				    (argmax + 1) * sizeof(char *));
    205   1.1       cgd 			}
    206   1.1       cgd 			argv[argc++] = start;
    207  1.24  christos 			start = NULL;
    208   1.1       cgd 			if (ch == '\n' || ch == '\0')
    209   1.1       cgd 				goto done;
    210   1.1       cgd 			continue;
    211   1.1       cgd 		case '\\':
    212   1.8       jtc 			if (!expand) {
    213   1.8       jtc 				if (!start)
    214   1.8       jtc 					start = t;
    215   1.8       jtc 				*t++ = '\\';
    216   1.8       jtc 				ch = *++p;
    217   1.8       jtc 				break;
    218   1.8       jtc 			}
    219  1.13  christos 
    220   1.1       cgd 			switch (ch = *++p) {
    221   1.1       cgd 			case '\0':
    222   1.1       cgd 			case '\n':
    223   1.1       cgd 				/* hmmm; fix it up as best we can */
    224   1.1       cgd 				ch = '\\';
    225   1.1       cgd 				--p;
    226   1.1       cgd 				break;
    227   1.1       cgd 			case 'b':
    228   1.1       cgd 				ch = '\b';
    229   1.1       cgd 				break;
    230   1.1       cgd 			case 'f':
    231   1.1       cgd 				ch = '\f';
    232   1.1       cgd 				break;
    233   1.1       cgd 			case 'n':
    234   1.1       cgd 				ch = '\n';
    235   1.1       cgd 				break;
    236   1.1       cgd 			case 'r':
    237   1.1       cgd 				ch = '\r';
    238   1.1       cgd 				break;
    239   1.1       cgd 			case 't':
    240   1.1       cgd 				ch = '\t';
    241   1.1       cgd 				break;
    242   1.1       cgd 			}
    243   1.1       cgd 			break;
    244   1.1       cgd 		}
    245   1.1       cgd 		if (!start)
    246   1.1       cgd 			start = t;
    247   1.4       cgd 		*t++ = (char) ch;
    248   1.1       cgd 	}
    249  1.24  christos done:	argv[argc] = NULL;
    250   1.1       cgd 	*store_argc = argc;
    251   1.1       cgd 	return(argv);
    252   1.1       cgd }
    253   1.1       cgd 
    254   1.1       cgd /*
    255   1.1       cgd  * Str_FindSubstring -- See if a string contains a particular substring.
    256  1.13  christos  *
    257  1.18       wiz  * Input:
    258  1.18       wiz  *	string		String to search.
    259  1.18       wiz  *	substring	Substring to find in string.
    260  1.18       wiz  *
    261   1.1       cgd  * Results: If string contains substring, the return value is the location of
    262   1.1       cgd  * the first matching instance of substring in string.  If string doesn't
    263   1.1       cgd  * contain substring, the return value is NULL.  Matching is done on an exact
    264   1.1       cgd  * character-for-character basis with no wildcards or special characters.
    265  1.13  christos  *
    266   1.1       cgd  * Side effects: None.
    267   1.1       cgd  */
    268   1.1       cgd char *
    269  1.19  christos Str_FindSubstring(const char *string, const char *substring)
    270   1.1       cgd {
    271  1.19  christos 	const char *a, *b;
    272   1.1       cgd 
    273   1.1       cgd 	/*
    274   1.1       cgd 	 * First scan quickly through the two strings looking for a single-
    275   1.1       cgd 	 * character match.  When it's found, then compare the rest of the
    276   1.1       cgd 	 * substring.
    277   1.1       cgd 	 */
    278   1.1       cgd 
    279   1.1       cgd 	for (b = substring; *string != 0; string += 1) {
    280   1.1       cgd 		if (*string != *b)
    281   1.1       cgd 			continue;
    282   1.1       cgd 		a = string;
    283   1.1       cgd 		for (;;) {
    284   1.1       cgd 			if (*b == 0)
    285  1.19  christos 				return UNCONST(string);
    286   1.1       cgd 			if (*a++ != *b++)
    287   1.1       cgd 				break;
    288   1.1       cgd 		}
    289   1.1       cgd 		b = substring;
    290   1.1       cgd 	}
    291  1.19  christos 	return NULL;
    292   1.1       cgd }
    293   1.1       cgd 
    294   1.1       cgd /*
    295   1.1       cgd  * Str_Match --
    296  1.13  christos  *
    297   1.1       cgd  * See if a particular string matches a particular pattern.
    298  1.13  christos  *
    299   1.1       cgd  * Results: Non-zero is returned if string matches pattern, 0 otherwise. The
    300   1.1       cgd  * matching operation permits the following special characters in the
    301   1.1       cgd  * pattern: *?\[] (see the man page for details on what these mean).
    302  1.13  christos  *
    303   1.1       cgd  * Side effects: None.
    304   1.1       cgd  */
    305   1.4       cgd int
    306  1.19  christos Str_Match(const char *string, const char *pattern)
    307   1.1       cgd {
    308   1.1       cgd 	char c2;
    309   1.1       cgd 
    310   1.1       cgd 	for (;;) {
    311   1.1       cgd 		/*
    312   1.1       cgd 		 * See if we're at the end of both the pattern and the
    313   1.1       cgd 		 * string. If, we succeeded.  If we're at the end of the
    314   1.1       cgd 		 * pattern but not at the end of the string, we failed.
    315   1.1       cgd 		 */
    316   1.1       cgd 		if (*pattern == 0)
    317   1.1       cgd 			return(!*string);
    318   1.1       cgd 		if (*string == 0 && *pattern != '*')
    319   1.1       cgd 			return(0);
    320   1.1       cgd 		/*
    321   1.1       cgd 		 * Check for a "*" as the next pattern character.  It matches
    322   1.1       cgd 		 * any substring.  We handle this by calling ourselves
    323   1.1       cgd 		 * recursively for each postfix of string, until either we
    324   1.1       cgd 		 * match or we reach the end of the string.
    325   1.1       cgd 		 */
    326   1.1       cgd 		if (*pattern == '*') {
    327   1.1       cgd 			pattern += 1;
    328   1.1       cgd 			if (*pattern == 0)
    329   1.1       cgd 				return(1);
    330   1.1       cgd 			while (*string != 0) {
    331   1.1       cgd 				if (Str_Match(string, pattern))
    332   1.1       cgd 					return(1);
    333   1.1       cgd 				++string;
    334   1.1       cgd 			}
    335   1.1       cgd 			return(0);
    336   1.1       cgd 		}
    337   1.1       cgd 		/*
    338   1.1       cgd 		 * Check for a "?" as the next pattern character.  It matches
    339   1.1       cgd 		 * any single character.
    340   1.1       cgd 		 */
    341   1.1       cgd 		if (*pattern == '?')
    342   1.1       cgd 			goto thisCharOK;
    343   1.1       cgd 		/*
    344   1.1       cgd 		 * Check for a "[" as the next pattern character.  It is
    345   1.1       cgd 		 * followed by a list of characters that are acceptable, or
    346   1.1       cgd 		 * by a range (two characters separated by "-").
    347   1.1       cgd 		 */
    348   1.1       cgd 		if (*pattern == '[') {
    349   1.1       cgd 			++pattern;
    350   1.1       cgd 			for (;;) {
    351   1.1       cgd 				if ((*pattern == ']') || (*pattern == 0))
    352   1.1       cgd 					return(0);
    353   1.1       cgd 				if (*pattern == *string)
    354   1.1       cgd 					break;
    355   1.1       cgd 				if (pattern[1] == '-') {
    356   1.1       cgd 					c2 = pattern[2];
    357   1.1       cgd 					if (c2 == 0)
    358   1.1       cgd 						return(0);
    359   1.1       cgd 					if ((*pattern <= *string) &&
    360   1.1       cgd 					    (c2 >= *string))
    361   1.1       cgd 						break;
    362   1.1       cgd 					if ((*pattern >= *string) &&
    363   1.1       cgd 					    (c2 <= *string))
    364   1.1       cgd 						break;
    365   1.1       cgd 					pattern += 2;
    366   1.1       cgd 				}
    367   1.1       cgd 				++pattern;
    368   1.1       cgd 			}
    369   1.1       cgd 			while ((*pattern != ']') && (*pattern != 0))
    370   1.1       cgd 				++pattern;
    371   1.1       cgd 			goto thisCharOK;
    372   1.1       cgd 		}
    373   1.1       cgd 		/*
    374   1.1       cgd 		 * If the next pattern character is '/', just strip off the
    375   1.1       cgd 		 * '/' so we do exact matching on the character that follows.
    376   1.1       cgd 		 */
    377   1.1       cgd 		if (*pattern == '\\') {
    378   1.1       cgd 			++pattern;
    379   1.1       cgd 			if (*pattern == 0)
    380   1.1       cgd 				return(0);
    381   1.1       cgd 		}
    382   1.1       cgd 		/*
    383   1.1       cgd 		 * There's no special character.  Just make sure that the
    384   1.1       cgd 		 * next characters of each string match.
    385   1.1       cgd 		 */
    386   1.1       cgd 		if (*pattern != *string)
    387   1.1       cgd 			return(0);
    388   1.1       cgd thisCharOK:	++pattern;
    389   1.1       cgd 		++string;
    390   1.1       cgd 	}
    391   1.4       cgd }
    392   1.4       cgd 
    393   1.4       cgd 
    394   1.4       cgd /*-
    395   1.4       cgd  *-----------------------------------------------------------------------
    396   1.4       cgd  * Str_SYSVMatch --
    397  1.13  christos  *	Check word against pattern for a match (% is wild),
    398  1.13  christos  *
    399  1.18       wiz  * Input:
    400  1.18       wiz  *	word		Word to examine
    401  1.18       wiz  *	pattern		Pattern to examine against
    402  1.18       wiz  *	len		Number of characters to substitute
    403  1.18       wiz  *
    404   1.4       cgd  * Results:
    405   1.4       cgd  *	Returns the beginning position of a match or null. The number
    406   1.4       cgd  *	of characters matched is returned in len.
    407   1.4       cgd  *
    408   1.4       cgd  * Side Effects:
    409   1.4       cgd  *	None
    410   1.4       cgd  *
    411   1.4       cgd  *-----------------------------------------------------------------------
    412   1.4       cgd  */
    413   1.4       cgd char *
    414  1.19  christos Str_SYSVMatch(const char *word, const char *pattern, int *len)
    415   1.4       cgd {
    416  1.19  christos     const char *p = pattern;
    417  1.19  christos     const char *w = word;
    418  1.19  christos     const char *m;
    419   1.4       cgd 
    420   1.5       jtc     if (*p == '\0') {
    421   1.5       jtc 	/* Null pattern is the whole string */
    422   1.5       jtc 	*len = strlen(w);
    423  1.19  christos 	return UNCONST(w);
    424   1.5       jtc     }
    425   1.4       cgd 
    426   1.4       cgd     if ((m = strchr(p, '%')) != NULL) {
    427   1.4       cgd 	/* check that the prefix matches */
    428   1.4       cgd 	for (; p != m && *w && *w == *p; w++, p++)
    429   1.4       cgd 	     continue;
    430   1.4       cgd 
    431   1.4       cgd 	if (p != m)
    432   1.4       cgd 	    return NULL;	/* No match */
    433   1.4       cgd 
    434   1.4       cgd 	if (*++p == '\0') {
    435   1.4       cgd 	    /* No more pattern, return the rest of the string */
    436   1.4       cgd 	    *len = strlen(w);
    437  1.19  christos 	    return UNCONST(w);
    438   1.4       cgd 	}
    439   1.4       cgd     }
    440   1.4       cgd 
    441   1.4       cgd     m = w;
    442   1.4       cgd 
    443   1.4       cgd     /* Find a matching tail */
    444   1.4       cgd     do
    445   1.4       cgd 	if (strcmp(p, w) == 0) {
    446   1.4       cgd 	    *len = w - m;
    447  1.19  christos 	    return UNCONST(m);
    448   1.4       cgd 	}
    449   1.4       cgd     while (*w++ != '\0');
    450  1.13  christos 
    451   1.4       cgd     return NULL;
    452   1.4       cgd }
    453   1.4       cgd 
    454   1.4       cgd 
    455   1.4       cgd /*-
    456   1.4       cgd  *-----------------------------------------------------------------------
    457   1.4       cgd  * Str_SYSVSubst --
    458   1.4       cgd  *	Substitute '%' on the pattern with len characters from src.
    459   1.4       cgd  *	If the pattern does not contain a '%' prepend len characters
    460   1.4       cgd  *	from src.
    461  1.13  christos  *
    462   1.4       cgd  * Results:
    463   1.4       cgd  *	None
    464   1.4       cgd  *
    465   1.4       cgd  * Side Effects:
    466   1.4       cgd  *	Places result on buf
    467   1.4       cgd  *
    468   1.4       cgd  *-----------------------------------------------------------------------
    469   1.4       cgd  */
    470   1.4       cgd void
    471  1.18       wiz Str_SYSVSubst(Buffer buf, char *pat, char *src, int len)
    472   1.4       cgd {
    473   1.4       cgd     char *m;
    474   1.4       cgd 
    475   1.4       cgd     if ((m = strchr(pat, '%')) != NULL) {
    476   1.4       cgd 	/* Copy the prefix */
    477  1.24  christos 	Buf_AddBytes(buf, m - pat, (Byte *)pat);
    478   1.4       cgd 	/* skip the % */
    479   1.4       cgd 	pat = m + 1;
    480   1.4       cgd     }
    481   1.4       cgd 
    482   1.4       cgd     /* Copy the pattern */
    483  1.24  christos     Buf_AddBytes(buf, len, (Byte *)src);
    484   1.4       cgd 
    485   1.4       cgd     /* append the rest */
    486  1.24  christos     Buf_AddBytes(buf, strlen(pat), (Byte *)pat);
    487   1.1       cgd }
    488