2 * Copyright (c) 1992 Keith Muller.
3 * Copyright (c) 1992, 1993
4 * The Regents of the University of California. All rights reserved.
6 * This code is derived from software contributed to Berkeley by
7 * Keith Muller of the University of California, San Diego.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * @(#)pat_rep.c 8.2 (Berkeley) 4/18/94
38 * $FreeBSD: src/bin/pax/pat_rep.c,v 1.15.2.1 2001/08/01 05:03:11 obrien Exp $
39 * $DragonFly: src/bin/pax/pat_rep.c,v 1.6 2004/11/07 20:54:51 eirikn Exp $
42 #include <sys/types.h>
59 * routines to handle pattern matching, name modification (regular expression
60 * substitution and interactive renames), and destination name modification for
61 * copy (-rw). Both file name and link names are adjusted as required in these
65 #define MAXSUBEXP 10 /* max subexpressions, DO NOT CHANGE */
66 static PATTERN
*pathead
= NULL
; /* file pattern match list head */
67 static PATTERN
*pattail
= NULL
; /* file pattern match list tail */
68 static REPLACE
*rephead
= NULL
; /* replacement string list head */
69 static REPLACE
*reptail
= NULL
; /* replacement string list tail */
71 static int rep_name (char *, int *, int);
72 static int tty_rename (ARCHD
*);
73 static int fix_path (char *, int *, char *, int);
74 static int fn_match (char *, char *, char **);
75 static char * range_match (char *, int);
77 static int resub (regexp
*, char *, char *, char *);
79 static int resub (regex_t
*, regmatch_t
*, char *, char *, char *);
84 * parses the -s replacement string; compiles the regular expression
85 * and stores the compiled value and it's replacement string together in
86 * replacement string list. Input to this function is of the form:
88 * The first char in the string specifies the delimiter used by this
89 * replacement string. "Old" is a regular expression in "ed" format which
90 * is compiled by regcomp() and is applied to filenames. "new" is the
91 * substitution string; p and g are options flags for printing and global
92 * replacement (over the single filename)
94 * 0 if a proper replacement string and regular expression was added to
95 * the list of replacement patterns; -1 otherwise.
110 * throw out the bad parameters
112 if ((str
== NULL
) || (*str
== '\0')) {
113 paxwarn(1, "Empty replacement string");
118 * first character in the string specifies what the delimiter is for
121 if ((pt1
= strchr(str
+1, *str
)) == NULL
) {
122 paxwarn(1, "Invalid replacement string %s", str
);
127 * allocate space for the node that handles this replacement pattern
128 * and split out the regular expression and try to compile it
130 if ((rep
= (REPLACE
*)malloc(sizeof(REPLACE
))) == NULL
) {
131 paxwarn(1, "Unable to allocate memory for replacement string");
137 if ((rep
->rcmp
= regcomp(str
+1)) == NULL
) {
139 if ((res
= regcomp(&(rep
->rcmp
), str
+1, 0)) != 0) {
140 regerror(res
, &(rep
->rcmp
), rebuf
, sizeof(rebuf
));
141 paxwarn(1, "%s while compiling regular expression %s", rebuf
, str
);
148 * put the delimiter back in case we need an error message and
149 * locate the delimiter at the end of the replacement string
150 * we then point the node at the new substitution string
153 if ((pt2
= strchr(pt1
, *str
)) == NULL
) {
155 free((char *)rep
->rcmp
);
157 regfree(&(rep
->rcmp
));
160 paxwarn(1, "Invalid replacement string %s", str
);
170 * set the options if any
172 while (*pt2
!= '\0') {
184 free((char *)rep
->rcmp
);
186 regfree(&(rep
->rcmp
));
190 paxwarn(1, "Invalid replacement string option %s", str
);
197 * all done, link it in at the end
200 if (rephead
== NULL
) {
201 reptail
= rephead
= rep
;
211 * add a pattern match to the pattern match list. Pattern matches are used
212 * to select which archive members are extracted. (They appear as
213 * arguments to pax in the list and read modes). If no patterns are
214 * supplied to pax, all members in the archive will be selected (and the
215 * pattern match list is empty).
217 * 0 if the pattern was added to the list, -1 otherwise
221 pat_add(char *str
, char *chdname
)
228 if ((str
== NULL
) || (*str
== '\0')) {
229 paxwarn(1, "Empty pattern string");
234 * allocate space for the pattern and store the pattern. the pattern is
235 * part of argv so do not bother to copy it, just point at it. Add the
236 * node to the end of the pattern list
238 if ((pt
= (PATTERN
*)malloc(sizeof(PATTERN
))) == NULL
) {
239 paxwarn(1, "Unable to allocate memory for pattern string");
245 pt
->plen
= strlen(str
);
248 pt
->chdname
= chdname
;
250 if (pathead
== NULL
) {
251 pattail
= pathead
= pt
;
261 * complain if any the user supplied pattern did not result in a match to
262 * a selected archive member.
272 * walk down the list checking the flags to make sure MTCH was set,
275 for (pt
= pathead
; pt
!= NULL
; pt
= pt
->fow
) {
279 paxwarn(1, "WARNING! These patterns were not matched:");
282 fprintf(stderr
, "%s\n", pt
->pstr
);
288 * the archive member which matches a pattern was selected. Mark the
289 * pattern as having selected an archive member. arcn->pat points at the
290 * pattern that was matched. arcn->pat is set in pat_match()
292 * NOTE: When the -c option is used, we are called when there was no match
293 * by pat_match() (that means we did match before the inverted sense of
294 * the logic). Now this seems really strange at first, but with -c we
295 * need to keep track of those patterns that cause a archive member to NOT
296 * be selected (it found an archive member with a specified pattern)
298 * 0 if the pattern pointed at by arcn->pat was tagged as creating a
299 * match, -1 otherwise.
310 * if no patterns just return
312 if ((pathead
== NULL
) || ((pt
= arcn
->pat
) == NULL
))
316 * when we are NOT limited to a single match per pattern mark the
325 * we reach this point only when we allow a single selected match per
326 * pattern, if the pattern matches a directory and we do not have -d
327 * (dflag) we are done with this pattern. We may also be handed a file
328 * in the subtree of a directory. in that case when we are operating
329 * with -d, this pattern was already selected and we are done
331 if (pt
->flgs
& DIR_MTCH
)
334 if (!dflag
&& ((pt
->pend
!= NULL
) || (arcn
->type
== PAX_DIR
))) {
336 * ok we matched a directory and we are allowing
337 * subtree matches but because of the -n only its children will
338 * match. This is tagged as a DIR_MTCH type.
339 * WATCH IT, the code assumes that pt->pend points
340 * into arcn->name and arcn->name has not been modified.
341 * If not we will have a big mess. Yup this is another kludge
345 * if this was a prefix match, remove trailing part of path
346 * so we can copy it. Future matches will be exact prefix match
348 if (pt
->pend
!= NULL
)
351 if ((pt
->pstr
= strdup(arcn
->name
)) == NULL
) {
352 paxwarn(1, "Pattern select out of memory");
353 if (pt
->pend
!= NULL
)
360 * put the trailing / back in the source string
362 if (pt
->pend
!= NULL
) {
366 pt
->plen
= strlen(pt
->pstr
);
369 * strip off any trailing /, this should really never happen
372 if (*(pt
->pstr
+ len
) == '/') {
373 *(pt
->pstr
+ len
) = '\0';
376 pt
->flgs
= DIR_MTCH
| MTCH
;
382 * we are then done with this pattern, so we delete it from the list
383 * because it can never be used for another match.
384 * Seems kind of strange to do for a -c, but the pax spec is really
385 * vague on the interaction of -c -n and -d. We assume that when -c
386 * and the pattern rejects a member (i.e. it matched it) it is done.
387 * In effect we place the order of the flags as having -c last.
391 while ((pt
!= NULL
) && (pt
!= arcn
->pat
)) {
398 * should never happen....
400 paxwarn(1, "Pattern list inconsistant");
411 * see if this archive member matches any supplied pattern, if a match
412 * is found, arcn->pat is set to point at the potential pattern. Later if
413 * this archive member is "selected" we process and mark the pattern as
414 * one which matched a selected archive member (see pat_sel())
416 * 0 if this archive member should be processed, 1 if it should be
417 * skipped and -1 if we are done with all patterns (and pax should quit
418 * looking for more members)
422 pat_match(ARCHD
*arcn
)
429 * if there are no more patterns and we have -n (and not -c) we are
430 * done. otherwise with no patterns to match, matches all
432 if (pathead
== NULL
) {
439 * have to search down the list one at a time looking for a match.
444 * check for a file name match unless we have DIR_MTCH set in
445 * this pattern then we want a prefix match
447 if (pt
->flgs
& DIR_MTCH
) {
449 * this pattern was matched before to a directory
450 * as we must have -n set for this (but not -d). We can
451 * only match CHILDREN of that directory so we must use
452 * an exact prefix match (no wildcards).
454 if ((arcn
->name
[pt
->plen
] == '/') &&
455 (strncmp(pt
->pstr
, arcn
->name
, pt
->plen
) == 0))
457 } else if (fn_match(pt
->pstr
, arcn
->name
, &pt
->pend
) == 0)
463 * return the result, remember that cflag (-c) inverts the sense of a
467 return(cflag
? 0 : 1);
470 * we had a match, now when we invert the sense (-c) we reject this
471 * member. However we have to tag the pattern a being successful, (in a
472 * match, not in selecting a archive member) so we call pat_sel() here.
478 if (pat_sel(arcn
) < 0)
487 * 0 if this archive member should be processed, 1 if it should be
488 * skipped and -1 if we are done with all patterns (and pax should quit
489 * looking for more members)
490 * Note: *pend may be changed to show where the prefix ends.
494 fn_match(char *pattern
, char *string
, char **pend
)
501 switch (c
= *pattern
++) {
504 * Ok we found an exact match
510 * Check if it is a prefix match
512 if ((dflag
== 1) || (*string
!= '/'))
516 * It is a prefix match, remember where the trailing
522 if ((test
= *string
++) == '\0')
528 * Collapse multiple *'s.
534 * Optimized hack for pattern with a * at the end
540 * General case, use recursion.
542 while ((test
= *string
) != '\0') {
543 if (!fn_match(pattern
, string
, pend
))
552 if (((test
= *string
++) == '\0') ||
553 ((pattern
= range_match(pattern
, test
)) == NULL
))
567 range_match(char *pattern
, int test
)
574 if ((negate
= (*pattern
== '!')) != 0)
577 while ((c
= *pattern
++) != ']') {
584 if ((*pattern
== '-') && ((c2
= pattern
[1]) != '\0') &&
586 if ((c
<= test
) && (test
<= c2
))
589 } else if (c
== test
)
592 return (ok
== negate
? NULL
: pattern
);
597 * modify a selected file name. first attempt to apply replacement string
598 * expressions, then apply interactive file rename. We apply replacement
599 * string expressions to both filenames and file links (if we didn't the
600 * links would point to the wrong place, and we could never be able to
601 * move an archive that has a file link in it). When we rename files
602 * interactively, we store that mapping (old name to user input name) so
603 * if we spot any file links to the old file name in the future, we will
604 * know exactly how to fix the file link.
606 * 0 continue to process file, 1 skip this file, -1 pax is finished
610 mod_name(ARCHD
*arcn
)
615 * Strip off leading '/' if appropriate.
616 * Currently, this option is only set for the tar format.
618 if (rmleadslash
&& arcn
->name
[0] == '/') {
619 if (arcn
->name
[1] == '\0') {
622 memmove(arcn
->name
, &arcn
->name
[1],
626 if (rmleadslash
< 2) {
628 paxwarn(0, "Removing leading / from absolute path names in the archive");
631 if (rmleadslash
&& arcn
->ln_name
[0] == '/' &&
632 (arcn
->type
== PAX_HLK
|| arcn
->type
== PAX_HRG
)) {
633 if (arcn
->ln_name
[1] == '\0') {
634 arcn
->ln_name
[0] = '.';
636 memmove(arcn
->ln_name
, &arcn
->ln_name
[1],
637 strlen(arcn
->ln_name
));
640 if (rmleadslash
< 2) {
642 paxwarn(0, "Removing leading / from absolute path names in the archive");
647 * IMPORTANT: We have a problem. what do we do with symlinks?
648 * Modifying a hard link name makes sense, as we know the file it
649 * points at should have been seen already in the archive (and if it
650 * wasn't seen because of a read error or a bad archive, we lose
651 * anyway). But there are no such requirements for symlinks. On one
652 * hand the symlink that refers to a file in the archive will have to
653 * be modified to so it will still work at its new location in the
654 * file system. On the other hand a symlink that points elsewhere (and
655 * should continue to do so) should not be modified. There is clearly
656 * no perfect solution here. So we handle them like hardlinks. Clearly
657 * a replacement made by the interactive rename mapping is very likely
658 * to be correct since it applies to a single file and is an exact
659 * match. The regular expression replacements are a little harder to
660 * justify though. We claim that the symlink name is only likely
661 * to be replaced when it points within the file tree being moved and
662 * in that case it should be modified. what we really need to do is to
663 * call an oracle here. :)
665 if (rephead
!= NULL
) {
667 * we have replacement strings, modify the name and the link
670 if ((res
= rep_name(arcn
->name
, &(arcn
->nlen
), 1)) != 0)
673 if (((arcn
->type
== PAX_SLK
) || (arcn
->type
== PAX_HLK
) ||
674 (arcn
->type
== PAX_HRG
)) &&
675 ((res
= rep_name(arcn
->ln_name
, &(arcn
->ln_nlen
), 0)) != 0))
681 * perform interactive file rename, then map the link if any
683 if ((res
= tty_rename(arcn
)) != 0)
685 if ((arcn
->type
== PAX_SLK
) || (arcn
->type
== PAX_HLK
) ||
686 (arcn
->type
== PAX_HRG
))
687 sub_name(arcn
->ln_name
, &(arcn
->ln_nlen
), sizeof(arcn
->ln_name
));
694 * Prompt the user for a replacement file name. A "." keeps the old name,
695 * a empty line skips the file, and an EOF on reading the tty, will cause
696 * pax to stop processing and exit. Otherwise the file name input, replaces
699 * 0 process this file, 1 skip this file, -1 we need to exit pax
703 tty_rename(ARCHD
*arcn
)
705 char tmpname
[PAXPATHLEN
+2];
709 * prompt user for the replacement name for a file, keep trying until
710 * we get some reasonable input. Archives may have more than one file
711 * on them with the same name (from updates etc). We print verbose info
712 * on the file so the user knows what is up.
714 tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0
);
718 tty_prnt("Input new name, or a \".\" to keep the old name, ");
719 tty_prnt("or a \"return\" to skip this file.\n");
720 tty_prnt("Input > ");
721 if (tty_read(tmpname
, sizeof(tmpname
)) < 0)
723 if (strcmp(tmpname
, "..") == 0) {
724 tty_prnt("Try again, illegal file name: ..\n");
727 if (strlen(tmpname
) > PAXPATHLEN
) {
728 tty_prnt("Try again, file name too long\n");
735 * empty file name, skips this file. a "." leaves it alone
737 if (tmpname
[0] == '\0') {
738 tty_prnt("Skipping file.\n");
741 if ((tmpname
[0] == '.') && (tmpname
[1] == '\0')) {
742 tty_prnt("Processing continues, name unchanged.\n");
747 * ok the name changed. We may run into links that point at this
748 * file later. we have to remember where the user sent the file
749 * in order to repair any links.
751 tty_prnt("Processing continues, name changed to: %s\n", tmpname
);
752 res
= add_name(arcn
->name
, arcn
->nlen
, tmpname
);
753 arcn
->nlen
= l_strncpy(arcn
->name
, tmpname
, sizeof(arcn
->name
) - 1);
754 arcn
->name
[arcn
->nlen
] = '\0';
762 * fix up the file name and the link name (if any) so this file will land
763 * in the destination directory (used during copy() -rw).
765 * 0 if ok, -1 if failure (name too long)
769 set_dest(ARCHD
*arcn
, char *dest_dir
, int dir_len
)
771 if (fix_path(arcn
->name
, &(arcn
->nlen
), dest_dir
, dir_len
) < 0)
775 * It is really hard to deal with symlinks here, we cannot be sure
776 * if the name they point was moved (or will be moved). It is best to
779 if ((arcn
->type
!= PAX_HLK
) && (arcn
->type
!= PAX_HRG
))
782 if (fix_path(arcn
->ln_name
, &(arcn
->ln_nlen
), dest_dir
, dir_len
) < 0)
789 * concatenate dir_name and or_name and store the result in or_name (if
790 * it fits). This is one ugly function.
792 * 0 if ok, -1 if the final name is too long
796 fix_path( char *or_name
, int *or_len
, char *dir_name
, int dir_len
)
804 * we shift the or_name to the right enough to tack in the dir_name
805 * at the front. We make sure we have enough space for it all before
806 * we start. since dest always ends in a slash, we skip of or_name
807 * if it also starts with one.
810 src
= start
+ *or_len
;
811 dest
= src
+ dir_len
;
816 if ((len
= dest
- or_name
) > PAXPATHLEN
) {
817 paxwarn(1, "File name %s/%s, too long", dir_name
, start
);
823 * enough space, shift
827 src
= dir_name
+ dir_len
- 1;
830 * splice in the destination directory name
832 while (src
>= dir_name
)
835 *(or_name
+ len
) = '\0';
841 * walk down the list of replacement strings applying each one in order.
842 * when we find one with a successful substitution, we modify the name
843 * as specified. if required, we print the results. if the resulting name
844 * is empty, we will skip this archive member. We use the regexp(3)
845 * routines (regexp() ought to win a prize as having the most cryptic
846 * library function manual page).
848 * name is the file name we are going to apply the regular expressions to
849 * (and may be modified)
850 * nlen is the length of this name (and is modified to hold the length of
852 * prnt is a flag that says whether to print the final result.
854 * 0 if substitution was successful, 1 if we are to skip the file (the name
859 rep_name(char *name
, int *nlen
, int prnt
)
869 regmatch_t pm
[MAXSUBEXP
];
871 char nname
[PAXPATHLEN
+1]; /* final result of all replacements */
872 char buf1
[PAXPATHLEN
+1]; /* where we work on the name */
875 * copy the name into buf1, where we will work on it. We need to keep
876 * the orig string around so we can print out the result of the final
877 * replacement. We build up the final result in nname. inpt points at
878 * the string we apply the regular expression to. prnt is used to
879 * suppress printing when we handle replacements on the link field
880 * (the user already saw that substitution go by)
886 endpt
= outpt
+ PAXPATHLEN
;
889 * try each replacement string in order
894 * check for a successful substitution, if not go to
895 * the next pattern, or cleanup if we were global
898 if (regexec(pt
->rcmp
, inpt
) == 0)
900 if (regexec(&(pt
->rcmp
), inpt
, MAXSUBEXP
, pm
, 0) != 0)
905 * ok we found one. We have three parts, the prefix
906 * which did not match, the section that did and the
907 * tail (that also did not match). Copy the prefix to
908 * the final output buffer (watching to make sure we
909 * do not create a string too long).
913 rpt
= pt
->rcmp
->startp
[0];
915 rpt
= inpt
+ pm
[0].rm_so
;
918 while ((inpt
< rpt
) && (outpt
< endpt
))
924 * for the second part (which matched the regular
925 * expression) apply the substitution using the
926 * replacement string and place it the prefix in the
927 * final output. If we have problems, skip it.
930 if ((res
= resub(pt
->rcmp
,pt
->nstr
,outpt
,endpt
)) < 0) {
932 if ((res
= resub(&(pt
->rcmp
),pm
,pt
->nstr
,outpt
,endpt
))
936 paxwarn(1, "Replacement name error %s",
943 * we set up to look again starting at the first
944 * character in the tail (of the input string right
945 * after the last character matched by the regular
946 * expression (inpt always points at the first char in
947 * the string to process). If we are not doing a global
948 * substitution, we will use inpt to copy the tail to
949 * the final result. Make sure we do not overrun the
953 inpt
= pt
->rcmp
->endp
[0];
955 inpt
+= pm
[0].rm_eo
- pm
[0].rm_so
;
958 if ((outpt
== endpt
) || (*inpt
== '\0'))
962 * if the user wants global we keep trying to
963 * substitute until it fails, then we are done.
965 } while (pt
->flgs
& GLOB
);
971 * a successful substitution did NOT occur, try the next one
978 * we had a substitution, copy the last tail piece (if there is
979 * room) to the final result
981 while ((outpt
< endpt
) && (*inpt
!= '\0'))
985 if ((outpt
== endpt
) && (*inpt
!= '\0')) {
987 paxwarn(1,"Replacement name too long %s >> %s",
993 * inform the user of the result if wanted
995 if (prnt
&& (pt
->flgs
& PRNT
)) {
997 fprintf(stderr
,"%s >> <empty string>\n",
1000 fprintf(stderr
,"%s >> %s\n", name
, nname
);
1004 * if empty inform the caller this file is to be skipped
1005 * otherwise copy the new name over the orig name and return
1009 *nlen
= l_strncpy(name
, nname
, PAXPATHLEN
+ 1);
1010 name
[PAXPATHLEN
] = '\0';
1018 * apply the replacement to the matched expression. expand out the old
1019 * style ed(1) subexpression expansion.
1021 * -1 if error, or the number of characters added to the destination.
1025 resub(regexp
*prog
, char *src
, char *dest
, char *destend
)
1035 while ((dpt
< destend
) && ((c
= *spt
++) != '\0')) {
1038 else if ((c
== '\\') && (*spt
>= '0') && (*spt
<= '9'))
1041 if ((c
== '\\') && ((*spt
== '\\') || (*spt
== '&')))
1046 if ((prog
->startp
[no
] == NULL
) || (prog
->endp
[no
] == NULL
) ||
1047 ((len
= prog
->endp
[no
] - prog
->startp
[no
]) <= 0))
1051 * copy the subexpression to the destination.
1052 * fail if we run out of space or the match string is damaged
1054 if (len
> (destend
- dpt
))
1055 len
= destend
- dpt
;
1056 if (l_strncpy(dpt
, prog
->startp
[no
], len
) != len
)
1067 * apply the replacement to the matched expression. expand out the old
1068 * style ed(1) subexpression expansion.
1070 * -1 if error, or the number of characters added to the destination.
1074 resub(regex_t
*rp
, regmatch_t
*pm
, char *src
, char *dest
,
1086 subexcnt
= rp
->re_nsub
;
1087 while ((dpt
< destend
) && ((c
= *spt
++) != '\0')) {
1089 * see if we just have an ordinary replacement character
1090 * or we refer to a subexpression.
1094 } else if ((c
== '\\') && (*spt
>= '0') && (*spt
<= '9')) {
1096 * make sure there is a subexpression as specified
1098 if ((len
= *spt
++ - '0') > subexcnt
)
1103 * Ordinary character, just copy it
1105 if ((c
== '\\') && ((*spt
== '\\') || (*spt
== '&')))
1112 * continue if the subexpression is bogus
1114 if ((pmpt
->rm_so
< 0) || (pmpt
->rm_eo
< 0) ||
1115 ((len
= pmpt
->rm_eo
- pmpt
->rm_so
) <= 0))
1119 * copy the subexpression to the destination.
1120 * fail if we run out of space or the match string is damaged
1122 if (len
> (destend
- dpt
))
1123 len
= destend
- dpt
;
1124 if (l_strncpy(dpt
, src
+ pmpt
->rm_so
, len
) != len
)