2 * Copyright 1986, Larry Wall
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following condition is met:
6 * 1. Redistributions of source code must retain the above copyright notice,
7 * this condition and the following disclaimer.
9 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
10 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
11 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
12 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
13 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
14 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
15 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
16 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
17 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
18 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
21 * patch - a program to apply diffs to original files
23 * -C option added in 1998, original code by Marc Espie, based on FreeBSD
26 * $OpenBSD: patch.c,v 1.50 2012/05/15 19:32:02 millert Exp $
27 * $FreeBSD: head/usr.bin/patch/patch.c 255894 2013-09-26 18:00:45Z delphij $
31 #include <sys/types.h>
46 #include "backupfile.h"
47 #include "pathnames.h"
49 mode_t filemode
= 0644;
51 char *buf
; /* general purpose buffer */
52 size_t buf_size
; /* size of the general purpose buffer */
54 bool using_plan_a
= true; /* try to keep everything in memory */
55 bool out_of_mem
= false; /* ran out of memory in plan a */
59 char *filearg
[MAXFILEC
];
60 bool ok_to_create_file
= false;
62 char *origprae
= NULL
;
67 bool toutkeep
= false;
68 bool trejkeep
= false;
69 bool warn_on_invalid_line
;
70 bool last_line_missing_eol
;
80 bool noreverse
= false;
81 bool skip_rest_of_patch
= false;
83 bool canonicalize
= false;
84 bool check_only
= false;
86 char *revision
= NULL
; /* prerequisite revision, if any */
87 LINENUM input_lines
= 0; /* how long is input file in lines */
88 int posix
= 0; /* strict POSIX mode? */
90 static void reinitialize_almost_everything(void);
91 static void get_some_switches(void);
92 static LINENUM
locate_hunk(LINENUM
);
93 static void abort_context_hunk(void);
94 static void rej_line(int, LINENUM
);
95 static void abort_hunk(void);
96 static void apply_hunk(LINENUM
);
97 static void init_output(const char *);
98 static void init_reject(const char *);
99 static void copy_till(LINENUM
, bool);
100 static bool spew_output(void);
101 static void dump_line(LINENUM
, bool);
102 static bool patch_match(LINENUM
, LINENUM
, LINENUM
);
103 static bool similar(const char *, const char *, int);
104 static void usage(void);
106 /* true if -E was specified on command line. */
107 static bool remove_empty_files
= false;
109 /* true if -R was specified on command line. */
110 static bool reverse_flag_specified
= false;
112 /* buffer holding the name of the rejected patch file. */
113 static char rejname
[NAME_MAX
+ 1];
115 /* how many input lines have been irretractibly output */
116 static LINENUM last_frozen_line
= 0;
118 static int Argc
; /* guess */
120 static int Argc_last
; /* for restarting plan_b */
121 static char **Argv_last
;
123 static FILE *ofp
= NULL
; /* output file pointer */
124 static FILE *rejfp
= NULL
; /* reject file pointer */
126 static int filec
= 0; /* how many file arguments? */
127 static LINENUM last_offset
= 0;
128 static LINENUM maxfuzz
= 2;
130 /* patch using ifdef, ifndef, etc. */
131 static bool do_defines
= false;
133 static char if_defined
[128];
135 static char not_defined
[128];
137 static const char else_defined
[] = "#else\n";
139 static char end_defined
[128];
142 /* Apply a set of diffs as appropriate. */
145 main(int argc
, char *argv
[])
147 int error
= 0, hunk
, failed
, i
, fd
;
148 bool patch_seen
, reverse_seen
;
149 LINENUM where
= 0, newwhere
, fuzz
, mymaxfuzz
;
155 for (i
= 0; i
< MAXFILEC
; i
++)
158 buf_size
= INITLINELEN
;
159 buf
= malloc((unsigned)(buf_size
));
161 fatal("out of memory\n");
163 /* Cons up the names of the temporary files. */
164 if ((tmpdir
= getenv("TMPDIR")) == NULL
|| *tmpdir
== '\0')
166 for (i
= strlen(tmpdir
) - 1; i
> 0 && tmpdir
[i
] == '/'; i
--)
169 if (asprintf(&TMPOUTNAME
, "%.*s/patchoXXXXXXXXXX", i
, tmpdir
) == -1)
170 fatal("cannot allocate memory");
171 if ((fd
= mkstemp(TMPOUTNAME
)) < 0)
172 pfatal("can't create %s", TMPOUTNAME
);
175 if (asprintf(&TMPINNAME
, "%.*s/patchiXXXXXXXXXX", i
, tmpdir
) == -1)
176 fatal("cannot allocate memory");
177 if ((fd
= mkstemp(TMPINNAME
)) < 0)
178 pfatal("can't create %s", TMPINNAME
);
181 if (asprintf(&TMPREJNAME
, "%.*s/patchrXXXXXXXXXX", i
, tmpdir
) == -1)
182 fatal("cannot allocate memory");
183 if ((fd
= mkstemp(TMPREJNAME
)) < 0)
184 pfatal("can't create %s", TMPREJNAME
);
187 if (asprintf(&TMPPATNAME
, "%.*s/patchpXXXXXXXXXX", i
, tmpdir
) == -1)
188 fatal("cannot allocate memory");
189 if ((fd
= mkstemp(TMPPATNAME
)) < 0)
190 pfatal("can't create %s", TMPPATNAME
);
193 v
= getenv("SIMPLE_BACKUP_SUFFIX");
195 simple_backup_suffix
= v
;
197 simple_backup_suffix
= ORIGEXT
;
204 if (backup_type
== none
) {
205 if ((v
= getenv("PATCH_VERSION_CONTROL")) == NULL
)
206 v
= getenv("VERSION_CONTROL");
207 if (v
!= NULL
|| !posix
)
208 backup_type
= get_version(v
); /* OK to pass NULL. */
211 /* make sure we clean up /tmp in case of disaster */
215 for (open_patch_file(filearg
[1]); there_is_another_patch();
216 reinitialize_almost_everything()) {
217 /* for each patch in patch file */
221 warn_on_invalid_line
= true;
224 outname
= savestr(filearg
[0]);
226 /* for ed script just up and do it and exit */
227 if (diff_type
== ED_DIFF
) {
231 /* initialize the patched file */
232 if (!skip_rest_of_patch
)
233 init_output(TMPOUTNAME
);
235 /* initialize reject file */
236 init_reject(TMPREJNAME
);
238 /* find out where all the lines are */
239 if (!skip_rest_of_patch
)
240 scan_input(filearg
[0]);
243 * from here on, open no standard i/o files, because
244 * malloc might misfire and we can't catch it easily
247 /* apply each hunk of patch */
250 reverse_seen
= false;
252 while (another_hunk()) {
255 mymaxfuzz
= pch_context();
256 if (maxfuzz
< mymaxfuzz
)
258 if (!skip_rest_of_patch
) {
260 where
= locate_hunk(fuzz
);
261 if (hunk
== 1 && where
== 0 && !force
&& !reverse_seen
) {
262 /* dwim for reversed patch? */
265 say("Not enough memory to try swapped hunk! Assuming unswapped.\n");
270 where
= locate_hunk(fuzz
);
272 /* didn't find it swapped */
274 /* put it back to normal */
275 fatal("lost hunk on alloc error!\n");
277 } else if (noreverse
) {
279 /* put it back to normal */
280 fatal("lost hunk on alloc error!\n");
282 say("Ignoring previously applied (or reversed) patch.\n");
283 skip_rest_of_patch
= true;
286 say("%seversed (or previously applied) patch detected! %s -R.",
287 reverse
? "R" : "Unr",
288 reverse
? "Assuming" : "Ignoring");
290 ask("%seversed (or previously applied) patch detected! %s -R? [y] ",
291 reverse
? "R" : "Unr",
292 reverse
? "Assume" : "Ignore");
294 ask("Apply anyway? [n] ");
296 skip_rest_of_patch
= true;
302 /* put it back to normal */
303 fatal("lost hunk on alloc error!\n");
307 } while (!skip_rest_of_patch
&& where
== 0 &&
308 ++fuzz
<= mymaxfuzz
);
310 if (skip_rest_of_patch
) { /* just got decided */
311 if (ferror(ofp
) || fclose(ofp
)) {
312 say("Error writing %s\n",
319 newwhere
= pch_newfirst() + last_offset
;
320 if (skip_rest_of_patch
) {
324 say("Hunk #%d ignored at %ld.\n",
326 } else if (where
== 0) {
330 say("Hunk #%d failed at %ld.\n",
335 say("Hunk #%d succeeded at %ld",
338 say(" with fuzz %ld", fuzz
);
340 say(" (offset %ld line%s)",
342 last_offset
== 1L ? "" : "s");
348 if (out_of_mem
&& using_plan_a
) {
351 say("\n\nRan out of memory using Plan A--trying again...\n\n");
361 fatal("Internal error: hunk should not be 0\n");
363 /* finish spewing out the new file */
364 if (!skip_rest_of_patch
&& !spew_output()) {
365 say("Can't write %s\n", TMPOUTNAME
);
369 /* and put the output where desired */
371 if (!skip_rest_of_patch
) {
373 char *realout
= outname
;
376 if (move_file(TMPOUTNAME
, outname
) < 0) {
378 realout
= TMPOUTNAME
;
379 chmod(TMPOUTNAME
, filemode
);
381 chmod(outname
, filemode
);
383 if (remove_empty_files
&&
384 stat(realout
, &statbuf
) == 0 &&
385 statbuf
.st_size
== 0) {
387 say("Removing %s (empty after patching).\n",
393 if (ferror(rejfp
) || fclose(rejfp
)) {
394 say("Error writing %s\n", rejname
);
400 if (*rejname
== '\0') {
401 if (strlcpy(rejname
, outname
,
402 sizeof(rejname
)) >= sizeof(rejname
))
403 fatal("filename %s is too long\n", outname
);
404 if (strlcat(rejname
, REJEXT
,
405 sizeof(rejname
)) >= sizeof(rejname
))
406 fatal("filename %s is too long\n", outname
);
409 say("%d out of %d hunks %s--saving rejects to %s\n",
410 failed
, hunk
, skip_rest_of_patch
? "ignored" : "failed", rejname
);
412 say("%d out of %d hunks %s while patching %s\n",
413 failed
, hunk
, skip_rest_of_patch
? "ignored" : "failed", filearg
[0]);
414 if (!check_only
&& move_file(TMPREJNAME
, rejname
) < 0)
427 /* Prepare to find the next patch to do in the patch file. */
430 reinitialize_almost_everything(void)
436 last_frozen_line
= 0;
453 reverse
= reverse_flag_specified
;
454 skip_rest_of_patch
= false;
459 /* Process switches and filenames. */
462 get_some_switches(void)
464 const char *options
= "b::B:cCd:D:eEfF:i:lnNo:p:r:RstuvV:x:z:";
465 static struct option longopts
[] = {
466 {"backup", no_argument
, 0, 'b'},
467 {"batch", no_argument
, 0, 't'},
468 {"check", no_argument
, 0, 'C'},
469 {"context", no_argument
, 0, 'c'},
470 {"debug", required_argument
, 0, 'x'},
471 {"directory", required_argument
, 0, 'd'},
472 {"dry-run", no_argument
, 0, 'C'},
473 {"ed", no_argument
, 0, 'e'},
474 {"force", no_argument
, 0, 'f'},
475 {"forward", no_argument
, 0, 'N'},
476 {"fuzz", required_argument
, 0, 'F'},
477 {"ifdef", required_argument
, 0, 'D'},
478 {"input", required_argument
, 0, 'i'},
479 {"ignore-whitespace", no_argument
, 0, 'l'},
480 {"normal", no_argument
, 0, 'n'},
481 {"output", required_argument
, 0, 'o'},
482 {"prefix", required_argument
, 0, 'B'},
483 {"quiet", no_argument
, 0, 's'},
484 {"reject-file", required_argument
, 0, 'r'},
485 {"remove-empty-files", no_argument
, 0, 'E'},
486 {"reverse", no_argument
, 0, 'R'},
487 {"silent", no_argument
, 0, 's'},
488 {"strip", required_argument
, 0, 'p'},
489 {"suffix", required_argument
, 0, 'z'},
490 {"unified", no_argument
, 0, 'u'},
491 {"version", no_argument
, 0, 'v'},
492 {"version-control", required_argument
, 0, 'V'},
493 {"posix", no_argument
, &posix
, 1},
503 optreset
= optind
= 1;
504 while ((ch
= getopt_long(Argc
, Argv
, options
, longopts
, NULL
)) != -1) {
507 if (backup_type
== none
)
508 backup_type
= numbered_existing
;
512 say("Warning, the ``-b suffix'' option has been"
513 " obsoleted by the -z option.\n");
516 /* must directly follow 'b' case for backwards compat */
517 simple_backup_suffix
= savestr(optarg
);
520 origprae
= savestr(optarg
);
523 diff_type
= CONTEXT_DIFF
;
529 if (chdir(optarg
) < 0)
530 pfatal("can't cd to %s", optarg
);
534 if (!isalpha((unsigned char)*optarg
) && *optarg
!= '_')
535 fatal("argument to -D is not an identifier\n");
536 snprintf(if_defined
, sizeof if_defined
,
537 "#ifdef %s\n", optarg
);
538 snprintf(not_defined
, sizeof not_defined
,
539 "#ifndef %s\n", optarg
);
540 snprintf(end_defined
, sizeof end_defined
,
541 "#endif /* %s */\n", optarg
);
547 remove_empty_files
= true;
553 maxfuzz
= atoi(optarg
);
556 if (++filec
== MAXFILEC
)
557 fatal("too many file arguments\n");
558 filearg
[filec
] = savestr(optarg
);
564 diff_type
= NORMAL_DIFF
;
570 outname
= savestr(optarg
);
573 strippath
= atoi(optarg
);
576 if (strlcpy(rejname
, optarg
,
577 sizeof(rejname
)) >= sizeof(rejname
))
578 fatal("argument for -r is too long\n");
582 reverse_flag_specified
= true;
591 diff_type
= UNI_DIFF
;
597 backup_type
= get_version(optarg
);
601 debug
= atoi(optarg
);
614 filearg
[0] = savestr(*Argv
++);
617 if (++filec
== MAXFILEC
)
618 fatal("too many file arguments\n");
619 filearg
[filec
] = savestr(*Argv
++);
624 if (getenv("POSIXLY_CORRECT") != NULL
)
632 "usage: patch [-bCcEeflNnRstuv] [-B backup-prefix] [-D symbol] [-d directory]\n"
633 " [-F max-fuzz] [-i patchfile] [-o out-file] [-p strip-count]\n"
634 " [-r rej-name] [-V t | nil | never] [-x number] [-z backup-ext]\n"
635 " [--posix] [origfile [patchfile]]\n"
636 " patch <patchfile\n");
637 my_exit(EXIT_SUCCESS
);
641 * Attempt to find the right place to apply this hunk of patch.
644 locate_hunk(LINENUM fuzz
)
646 LINENUM first_guess
= pch_first() + last_offset
;
648 LINENUM pat_lines
= pch_ptrn_lines();
649 LINENUM max_pos_offset
= input_lines
- first_guess
- pat_lines
+ 1;
650 LINENUM max_neg_offset
= first_guess
- last_frozen_line
- 1 + pch_context();
652 if (pat_lines
== 0) { /* null range matches always */
653 if (verbose
&& fuzz
== 0 && (diff_type
== CONTEXT_DIFF
654 || diff_type
== NEW_CONTEXT_DIFF
655 || diff_type
== UNI_DIFF
)) {
656 say("Empty context always matches.\n");
658 return (first_guess
);
660 if (max_neg_offset
>= first_guess
) /* do not try lines < 0 */
661 max_neg_offset
= first_guess
- 1;
662 if (first_guess
<= input_lines
&& patch_match(first_guess
, 0, fuzz
))
664 for (offset
= 1; ; offset
++) {
665 bool check_after
= (offset
<= max_pos_offset
);
666 bool check_before
= (offset
<= max_neg_offset
);
668 if (check_after
&& patch_match(first_guess
, offset
, fuzz
)) {
671 say("Offset changing from %ld to %ld\n",
672 last_offset
, offset
);
674 last_offset
= offset
;
675 return first_guess
+ offset
;
676 } else if (check_before
&& patch_match(first_guess
, -offset
, fuzz
)) {
679 say("Offset changing from %ld to %ld\n",
680 last_offset
, -offset
);
682 last_offset
= -offset
;
683 return first_guess
- offset
;
684 } else if (!check_before
&& !check_after
)
689 /* We did not find the pattern, dump out the hunk so they can handle it. */
692 abort_context_hunk(void)
695 const LINENUM pat_end
= pch_end();
697 * add in last_offset to guess the same as the previous successful
700 const LINENUM oldfirst
= pch_first() + last_offset
;
701 const LINENUM newfirst
= pch_newfirst() + last_offset
;
702 const LINENUM oldlast
= oldfirst
+ pch_ptrn_lines() - 1;
703 const LINENUM newlast
= newfirst
+ pch_repl_lines() - 1;
704 const char *stars
= (diff_type
>= NEW_CONTEXT_DIFF
? " ****" : "");
705 const char *minuses
= (diff_type
>= NEW_CONTEXT_DIFF
? " ----" : " -----");
707 fprintf(rejfp
, "***************\n");
708 for (i
= 0; i
<= pat_end
; i
++) {
709 switch (pch_char(i
)) {
711 if (oldlast
< oldfirst
)
712 fprintf(rejfp
, "*** 0%s\n", stars
);
713 else if (oldlast
== oldfirst
)
714 fprintf(rejfp
, "*** %ld%s\n", oldfirst
, stars
);
716 fprintf(rejfp
, "*** %ld,%ld%s\n", oldfirst
,
720 if (newlast
< newfirst
)
721 fprintf(rejfp
, "--- 0%s\n", minuses
);
722 else if (newlast
== newfirst
)
723 fprintf(rejfp
, "--- %ld%s\n", newfirst
, minuses
);
725 fprintf(rejfp
, "--- %ld,%ld%s\n", newfirst
,
729 fprintf(rejfp
, "%s", pfetch(i
));
735 fprintf(rejfp
, "%c %s", pch_char(i
), pfetch(i
));
738 fatal("fatal internal error in abort_context_hunk\n");
744 rej_line(int ch
, LINENUM i
)
747 const char *line
= pfetch(i
);
751 fprintf(rejfp
, "%c%s", ch
, line
);
752 if (len
== 0 || line
[len
-1] != '\n')
753 fprintf(rejfp
, "\n\\ No newline at end of file\n");
761 const LINENUM pat_end
= pch_end();
762 const LINENUM oldfirst
= pch_first() + last_offset
;
763 const LINENUM newfirst
= pch_newfirst() + last_offset
;
765 if (diff_type
!= UNI_DIFF
) {
766 abort_context_hunk();
770 for (i
= 0; i
<= pat_end
; i
++) {
771 if (pch_char(i
) == '=') {
777 fprintf(rejfp
, "malformed hunk: no split found\n");
782 fprintf(rejfp
, "@@ -%ld,%ld +%ld,%ld @@\n",
783 pch_ptrn_lines() ? oldfirst
: 0,
784 pch_ptrn_lines(), newfirst
, pch_repl_lines());
785 while (i
< split
|| j
<= pat_end
) {
786 ch1
= i
< split
? pch_char(i
) : -1;
787 ch2
= j
<= pat_end
? pch_char(j
) : -1;
791 } else if (ch1
== ' ' && ch2
== ' ') {
795 } else if (ch1
== '!' && ch2
== '!') {
796 while (i
< split
&& ch1
== '!') {
799 ch1
= i
< split
? pch_char(i
) : -1;
801 while (j
<= pat_end
&& ch2
== '!') {
804 ch2
= j
<= pat_end
? pch_char(j
) : -1;
806 } else if (ch1
== '*') {
808 } else if (ch2
== '+' || ch2
== ' ') {
812 fprintf(rejfp
, "internal error on (%ld %ld %ld)\n",
821 /* We found where to apply it (we hope), so do it. */
824 apply_hunk(LINENUM where
)
827 const LINENUM lastline
= pch_ptrn_lines();
828 LINENUM
new = lastline
+ 1;
833 int def_state
= OUTSIDE
;
834 const LINENUM pat_end
= pch_end();
837 while (pch_char(new) == '=' || pch_char(new) == '\n')
840 while (old
<= lastline
) {
841 if (pch_char(old
) == '-') {
842 copy_till(where
+ old
- 1, false);
844 if (def_state
== OUTSIDE
) {
845 fputs(not_defined
, ofp
);
846 def_state
= IN_IFNDEF
;
847 } else if (def_state
== IN_IFDEF
) {
848 fputs(else_defined
, ofp
);
851 fputs(pfetch(old
), ofp
);
855 } else if (new > pat_end
) {
857 } else if (pch_char(new) == '+') {
858 copy_till(where
+ old
- 1, false);
860 if (def_state
== IN_IFNDEF
) {
861 fputs(else_defined
, ofp
);
863 } else if (def_state
== OUTSIDE
) {
864 fputs(if_defined
, ofp
);
865 def_state
= IN_IFDEF
;
868 fputs(pfetch(new), ofp
);
870 } else if (pch_char(new) != pch_char(old
)) {
871 say("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
872 pch_hunk_beg() + old
,
873 pch_hunk_beg() + new);
875 say("oldchar = '%c', newchar = '%c'\n",
876 pch_char(old
), pch_char(new));
879 } else if (pch_char(new) == '!') {
880 copy_till(where
+ old
- 1, false);
882 fputs(not_defined
, ofp
);
883 def_state
= IN_IFNDEF
;
885 while (pch_char(old
) == '!') {
887 fputs(pfetch(old
), ofp
);
893 fputs(else_defined
, ofp
);
896 while (pch_char(new) == '!') {
897 fputs(pfetch(new), ofp
);
901 if (pch_char(new) != ' ')
902 fatal("Internal error: expected ' '\n");
905 if (do_defines
&& def_state
!= OUTSIDE
) {
906 fputs(end_defined
, ofp
);
911 if (new <= pat_end
&& pch_char(new) == '+') {
912 copy_till(where
+ old
- 1, false);
914 if (def_state
== OUTSIDE
) {
915 fputs(if_defined
, ofp
);
916 def_state
= IN_IFDEF
;
917 } else if (def_state
== IN_IFNDEF
) {
918 fputs(else_defined
, ofp
);
922 while (new <= pat_end
&& pch_char(new) == '+') {
923 fputs(pfetch(new), ofp
);
927 if (do_defines
&& def_state
!= OUTSIDE
) {
928 fputs(end_defined
, ofp
);
936 init_output(const char *name
)
938 ofp
= fopen(name
, "w");
940 pfatal("can't create %s", name
);
944 * Open a file to put hunks we can't locate.
947 init_reject(const char *name
)
949 rejfp
= fopen(name
, "w");
951 pfatal("can't create %s", name
);
955 * Copy input file to output, up to wherever hunk is to be applied.
956 * If endoffile is true, treat the last line specially since it may
960 copy_till(LINENUM lastline
, bool endoffile
)
962 if (last_frozen_line
> lastline
)
963 fatal("misordered hunks! output would be garbled\n");
964 while (last_frozen_line
< lastline
) {
965 if (++last_frozen_line
== lastline
&& endoffile
)
966 dump_line(last_frozen_line
, !last_line_missing_eol
);
968 dump_line(last_frozen_line
, true);
973 * Finish copying the input file to the output file.
982 say("il=%ld lfl=%ld\n", input_lines
, last_frozen_line
);
985 copy_till(input_lines
, true); /* dump remainder of file */
986 rv
= ferror(ofp
) == 0 && fclose(ofp
) == 0;
992 * Copy one line from input to output.
995 dump_line(LINENUM line
, bool write_newline
)
1002 /* Note: string is not NUL terminated. */
1003 for (; *s
!= '\n'; s
++)
1010 * Does the patch pattern match at line base+offset?
1013 patch_match(LINENUM base
, LINENUM offset
, LINENUM fuzz
)
1015 LINENUM pline
= 1 + fuzz
;
1017 LINENUM pat_lines
= pch_ptrn_lines() - fuzz
;
1018 const char *ilineptr
;
1019 const char *plineptr
;
1022 for (iline
= base
+ offset
+ fuzz
; pline
<= pat_lines
; pline
++, iline
++) {
1023 ilineptr
= ifetch(iline
, offset
>= 0);
1024 if (ilineptr
== NULL
)
1026 plineptr
= pfetch(pline
);
1027 plinelen
= pch_line_len(pline
);
1029 if (!similar(ilineptr
, plineptr
, plinelen
))
1031 } else if (strnNE(ilineptr
, plineptr
, plinelen
))
1033 if (iline
== input_lines
) {
1035 * We are looking at the last line of the file.
1036 * If the file has no eol, the patch line should
1037 * not have one either and vice-versa. Note that
1040 if (last_line_missing_eol
) {
1041 if (plineptr
[plinelen
- 1] == '\n')
1044 if (plineptr
[plinelen
- 1] != '\n')
1053 * Do two lines match with canonicalized white space?
1056 similar(const char *a
, const char *b
, int len
)
1059 if (isspace((unsigned char)*b
)) { /* whitespace (or \n) to match? */
1060 if (!isspace((unsigned char)*a
)) /* no corresponding whitespace? */
1062 while (len
&& isspace((unsigned char)*b
) && *b
!= '\n')
1063 b
++, len
--; /* skip pattern whitespace */
1064 while (isspace((unsigned char)*a
) && *a
!= '\n')
1065 a
++; /* skip target whitespace */
1066 if (*a
== '\n' || *b
== '\n')
1067 return (*a
== *b
); /* should end in sync */
1068 } else if (*a
++ != *b
++) /* match non-whitespace chars */
1071 len
--; /* probably not necessary */
1073 return true; /* actually, this is not reached */
1074 /* since there is always a \n */