15027f2b8SJohn Marino /*-
248d201a5SJoerg Sonnenberger * Copyright 1986, Larry Wall
348d201a5SJoerg Sonnenberger *
448d201a5SJoerg Sonnenberger * Redistribution and use in source and binary forms, with or without
548d201a5SJoerg Sonnenberger * modification, are permitted provided that the following condition is met:
648d201a5SJoerg Sonnenberger * 1. Redistributions of source code must retain the above copyright notice,
748d201a5SJoerg Sonnenberger * this condition and the following disclaimer.
848d201a5SJoerg Sonnenberger *
948d201a5SJoerg Sonnenberger * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
1048d201a5SJoerg Sonnenberger * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1148d201a5SJoerg Sonnenberger * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
1248d201a5SJoerg Sonnenberger * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
1348d201a5SJoerg Sonnenberger * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1448d201a5SJoerg Sonnenberger * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
1548d201a5SJoerg Sonnenberger * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
1648d201a5SJoerg Sonnenberger * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1748d201a5SJoerg Sonnenberger * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1848d201a5SJoerg Sonnenberger * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1948d201a5SJoerg Sonnenberger * SUCH DAMAGE.
2048d201a5SJoerg Sonnenberger *
215027f2b8SJohn Marino * patch - a program to apply diffs to original files
225027f2b8SJohn Marino *
2348d201a5SJoerg Sonnenberger * -C option added in 1998, original code by Marc Espie, based on FreeBSD
2448d201a5SJoerg Sonnenberger * behaviour
255027f2b8SJohn Marino *
26*b94b84caSDaniel Fojt * $OpenBSD: patch.c,v 1.54 2014/12/13 10:31:07 tobias Exp $
27*b94b84caSDaniel Fojt * $FreeBSD: head/usr.bin/patch/patch.c 354328 2019-11-04 03:07:01Z kevans $
285027f2b8SJohn Marino *
2948d201a5SJoerg Sonnenberger */
3048d201a5SJoerg Sonnenberger
3148d201a5SJoerg Sonnenberger #include <sys/types.h>
3248d201a5SJoerg Sonnenberger #include <sys/stat.h>
3348d201a5SJoerg Sonnenberger
34*b94b84caSDaniel Fojt #include <assert.h>
3548d201a5SJoerg Sonnenberger #include <ctype.h>
3648d201a5SJoerg Sonnenberger #include <getopt.h>
3748d201a5SJoerg Sonnenberger #include <limits.h>
3848d201a5SJoerg Sonnenberger #include <stdio.h>
3948d201a5SJoerg Sonnenberger #include <string.h>
4048d201a5SJoerg Sonnenberger #include <stdlib.h>
41f7e25d55SSascha Wildner #include <unistd.h>
4248d201a5SJoerg Sonnenberger
4348d201a5SJoerg Sonnenberger #include "common.h"
4448d201a5SJoerg Sonnenberger #include "util.h"
4548d201a5SJoerg Sonnenberger #include "pch.h"
4648d201a5SJoerg Sonnenberger #include "inp.h"
4748d201a5SJoerg Sonnenberger #include "backupfile.h"
4848d201a5SJoerg Sonnenberger #include "pathnames.h"
4948d201a5SJoerg Sonnenberger
509d62a0f9SSascha Wildner mode_t filemode = 0644;
5148d201a5SJoerg Sonnenberger
525027f2b8SJohn Marino char *buf; /* general purpose buffer */
535027f2b8SJohn Marino size_t buf_size; /* size of the general purpose buffer */
5448d201a5SJoerg Sonnenberger
5548d201a5SJoerg Sonnenberger bool using_plan_a = true; /* try to keep everything in memory */
5648d201a5SJoerg Sonnenberger bool out_of_mem = false; /* ran out of memory in plan a */
57*b94b84caSDaniel Fojt bool nonempty_patchf_seen = false; /* seen nonempty patch file? */
5848d201a5SJoerg Sonnenberger
5948d201a5SJoerg Sonnenberger #define MAXFILEC 2
6048d201a5SJoerg Sonnenberger
6148d201a5SJoerg Sonnenberger char *filearg[MAXFILEC];
6248d201a5SJoerg Sonnenberger bool ok_to_create_file = false;
6348d201a5SJoerg Sonnenberger char *outname = NULL;
6448d201a5SJoerg Sonnenberger char *origprae = NULL;
6548d201a5SJoerg Sonnenberger char *TMPOUTNAME;
6648d201a5SJoerg Sonnenberger char *TMPINNAME;
6748d201a5SJoerg Sonnenberger char *TMPREJNAME;
6848d201a5SJoerg Sonnenberger char *TMPPATNAME;
6948d201a5SJoerg Sonnenberger bool toutkeep = false;
7048d201a5SJoerg Sonnenberger bool trejkeep = false;
7148d201a5SJoerg Sonnenberger bool warn_on_invalid_line;
7248d201a5SJoerg Sonnenberger bool last_line_missing_eol;
7348d201a5SJoerg Sonnenberger
7448d201a5SJoerg Sonnenberger #ifdef DEBUGGING
7548d201a5SJoerg Sonnenberger int debug = 0;
7648d201a5SJoerg Sonnenberger #endif
7748d201a5SJoerg Sonnenberger
7848d201a5SJoerg Sonnenberger bool force = false;
7948d201a5SJoerg Sonnenberger bool batch = false;
8048d201a5SJoerg Sonnenberger bool verbose = true;
8148d201a5SJoerg Sonnenberger bool reverse = false;
8248d201a5SJoerg Sonnenberger bool noreverse = false;
8348d201a5SJoerg Sonnenberger bool skip_rest_of_patch = false;
8448d201a5SJoerg Sonnenberger int strippath = 957;
8548d201a5SJoerg Sonnenberger bool canonicalize = false;
8648d201a5SJoerg Sonnenberger bool check_only = false;
8748d201a5SJoerg Sonnenberger int diff_type = 0;
8848d201a5SJoerg Sonnenberger char *revision = NULL; /* prerequisite revision, if any */
8948d201a5SJoerg Sonnenberger LINENUM input_lines = 0; /* how long is input file in lines */
9048d201a5SJoerg Sonnenberger int posix = 0; /* strict POSIX mode? */
9148d201a5SJoerg Sonnenberger
9248d201a5SJoerg Sonnenberger static void reinitialize_almost_everything(void);
9348d201a5SJoerg Sonnenberger static void get_some_switches(void);
9448d201a5SJoerg Sonnenberger static LINENUM locate_hunk(LINENUM);
95f7e25d55SSascha Wildner static void abort_context_hunk(void);
96f7e25d55SSascha Wildner static void rej_line(int, LINENUM);
9748d201a5SJoerg Sonnenberger static void abort_hunk(void);
9848d201a5SJoerg Sonnenberger static void apply_hunk(LINENUM);
9948d201a5SJoerg Sonnenberger static void init_output(const char *);
10048d201a5SJoerg Sonnenberger static void init_reject(const char *);
10148d201a5SJoerg Sonnenberger static void copy_till(LINENUM, bool);
10232fe83a8SJoerg Sonnenberger static bool spew_output(void);
10348d201a5SJoerg Sonnenberger static void dump_line(LINENUM, bool);
10448d201a5SJoerg Sonnenberger static bool patch_match(LINENUM, LINENUM, LINENUM);
10548d201a5SJoerg Sonnenberger static bool similar(const char *, const char *, int);
10648d201a5SJoerg Sonnenberger static void usage(void);
107*b94b84caSDaniel Fojt static bool handle_creation(bool, bool *);
10848d201a5SJoerg Sonnenberger
10948d201a5SJoerg Sonnenberger /* true if -E was specified on command line. */
11048d201a5SJoerg Sonnenberger static bool remove_empty_files = false;
11148d201a5SJoerg Sonnenberger
11248d201a5SJoerg Sonnenberger /* true if -R was specified on command line. */
11348d201a5SJoerg Sonnenberger static bool reverse_flag_specified = false;
11448d201a5SJoerg Sonnenberger
115*b94b84caSDaniel Fojt static bool Vflag = false;
116*b94b84caSDaniel Fojt
11748d201a5SJoerg Sonnenberger /* buffer holding the name of the rejected patch file. */
118*b94b84caSDaniel Fojt static char rejname[PATH_MAX];
11948d201a5SJoerg Sonnenberger
12048d201a5SJoerg Sonnenberger /* how many input lines have been irretractibly output */
12148d201a5SJoerg Sonnenberger static LINENUM last_frozen_line = 0;
12248d201a5SJoerg Sonnenberger
12348d201a5SJoerg Sonnenberger static int Argc; /* guess */
12448d201a5SJoerg Sonnenberger static char **Argv;
12548d201a5SJoerg Sonnenberger static int Argc_last; /* for restarting plan_b */
12648d201a5SJoerg Sonnenberger static char **Argv_last;
12748d201a5SJoerg Sonnenberger
12848d201a5SJoerg Sonnenberger static FILE *ofp = NULL; /* output file pointer */
12948d201a5SJoerg Sonnenberger static FILE *rejfp = NULL; /* reject file pointer */
13048d201a5SJoerg Sonnenberger
13148d201a5SJoerg Sonnenberger static int filec = 0; /* how many file arguments? */
13248d201a5SJoerg Sonnenberger static LINENUM last_offset = 0;
13348d201a5SJoerg Sonnenberger static LINENUM maxfuzz = 2;
13448d201a5SJoerg Sonnenberger
13548d201a5SJoerg Sonnenberger /* patch using ifdef, ifndef, etc. */
13648d201a5SJoerg Sonnenberger static bool do_defines = false;
13748d201a5SJoerg Sonnenberger /* #ifdef xyzzy */
13848d201a5SJoerg Sonnenberger static char if_defined[128];
13948d201a5SJoerg Sonnenberger /* #ifndef xyzzy */
14048d201a5SJoerg Sonnenberger static char not_defined[128];
14148d201a5SJoerg Sonnenberger /* #else */
14248d201a5SJoerg Sonnenberger static const char else_defined[] = "#else\n";
14348d201a5SJoerg Sonnenberger /* #endif xyzzy */
14448d201a5SJoerg Sonnenberger static char end_defined[128];
14548d201a5SJoerg Sonnenberger
14648d201a5SJoerg Sonnenberger
14748d201a5SJoerg Sonnenberger /* Apply a set of diffs as appropriate. */
14848d201a5SJoerg Sonnenberger
14948d201a5SJoerg Sonnenberger int
main(int argc,char * argv[])15048d201a5SJoerg Sonnenberger main(int argc, char *argv[])
15148d201a5SJoerg Sonnenberger {
152*b94b84caSDaniel Fojt struct stat statbuf;
153f7e25d55SSascha Wildner int error = 0, hunk, failed, i, fd;
154*b94b84caSDaniel Fojt bool out_creating, out_existed, patch_seen, remove_file;
155*b94b84caSDaniel Fojt bool reverse_seen;
15648d201a5SJoerg Sonnenberger LINENUM where = 0, newwhere, fuzz, mymaxfuzz;
15748d201a5SJoerg Sonnenberger const char *tmpdir;
15848d201a5SJoerg Sonnenberger char *v;
15948d201a5SJoerg Sonnenberger
160*b94b84caSDaniel Fojt setvbuf(stdout, NULL, _IOLBF, 0);
161*b94b84caSDaniel Fojt setvbuf(stderr, NULL, _IOLBF, 0);
16248d201a5SJoerg Sonnenberger for (i = 0; i < MAXFILEC; i++)
16348d201a5SJoerg Sonnenberger filearg[i] = NULL;
16448d201a5SJoerg Sonnenberger
1655027f2b8SJohn Marino buf_size = INITLINELEN;
1665027f2b8SJohn Marino buf = malloc((unsigned)(buf_size));
1675027f2b8SJohn Marino if (buf == NULL)
1685027f2b8SJohn Marino fatal("out of memory\n");
1695027f2b8SJohn Marino
17048d201a5SJoerg Sonnenberger /* Cons up the names of the temporary files. */
17148d201a5SJoerg Sonnenberger if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '\0')
17248d201a5SJoerg Sonnenberger tmpdir = _PATH_TMP;
17348d201a5SJoerg Sonnenberger for (i = strlen(tmpdir) - 1; i > 0 && tmpdir[i] == '/'; i--)
17448d201a5SJoerg Sonnenberger ;
17548d201a5SJoerg Sonnenberger i++;
17648d201a5SJoerg Sonnenberger if (asprintf(&TMPOUTNAME, "%.*s/patchoXXXXXXXXXX", i, tmpdir) == -1)
17748d201a5SJoerg Sonnenberger fatal("cannot allocate memory");
17848d201a5SJoerg Sonnenberger if ((fd = mkstemp(TMPOUTNAME)) < 0)
17948d201a5SJoerg Sonnenberger pfatal("can't create %s", TMPOUTNAME);
18048d201a5SJoerg Sonnenberger close(fd);
18148d201a5SJoerg Sonnenberger
18248d201a5SJoerg Sonnenberger if (asprintf(&TMPINNAME, "%.*s/patchiXXXXXXXXXX", i, tmpdir) == -1)
18348d201a5SJoerg Sonnenberger fatal("cannot allocate memory");
18448d201a5SJoerg Sonnenberger if ((fd = mkstemp(TMPINNAME)) < 0)
18548d201a5SJoerg Sonnenberger pfatal("can't create %s", TMPINNAME);
18648d201a5SJoerg Sonnenberger close(fd);
18748d201a5SJoerg Sonnenberger
18848d201a5SJoerg Sonnenberger if (asprintf(&TMPREJNAME, "%.*s/patchrXXXXXXXXXX", i, tmpdir) == -1)
18948d201a5SJoerg Sonnenberger fatal("cannot allocate memory");
19048d201a5SJoerg Sonnenberger if ((fd = mkstemp(TMPREJNAME)) < 0)
19148d201a5SJoerg Sonnenberger pfatal("can't create %s", TMPREJNAME);
19248d201a5SJoerg Sonnenberger close(fd);
19348d201a5SJoerg Sonnenberger
19448d201a5SJoerg Sonnenberger if (asprintf(&TMPPATNAME, "%.*s/patchpXXXXXXXXXX", i, tmpdir) == -1)
19548d201a5SJoerg Sonnenberger fatal("cannot allocate memory");
19648d201a5SJoerg Sonnenberger if ((fd = mkstemp(TMPPATNAME)) < 0)
19748d201a5SJoerg Sonnenberger pfatal("can't create %s", TMPPATNAME);
19848d201a5SJoerg Sonnenberger close(fd);
19948d201a5SJoerg Sonnenberger
20048d201a5SJoerg Sonnenberger v = getenv("SIMPLE_BACKUP_SUFFIX");
20148d201a5SJoerg Sonnenberger if (v)
20248d201a5SJoerg Sonnenberger simple_backup_suffix = v;
20348d201a5SJoerg Sonnenberger else
20448d201a5SJoerg Sonnenberger simple_backup_suffix = ORIGEXT;
20548d201a5SJoerg Sonnenberger
20648d201a5SJoerg Sonnenberger /* parse switches */
20748d201a5SJoerg Sonnenberger Argc = argc;
20848d201a5SJoerg Sonnenberger Argv = argv;
20948d201a5SJoerg Sonnenberger get_some_switches();
21048d201a5SJoerg Sonnenberger
211*b94b84caSDaniel Fojt if (!Vflag) {
21248d201a5SJoerg Sonnenberger if ((v = getenv("PATCH_VERSION_CONTROL")) == NULL)
21348d201a5SJoerg Sonnenberger v = getenv("VERSION_CONTROL");
21448d201a5SJoerg Sonnenberger if (v != NULL || !posix)
21548d201a5SJoerg Sonnenberger backup_type = get_version(v); /* OK to pass NULL. */
21648d201a5SJoerg Sonnenberger }
21748d201a5SJoerg Sonnenberger
21848d201a5SJoerg Sonnenberger /* make sure we clean up /tmp in case of disaster */
21948d201a5SJoerg Sonnenberger set_signals(0);
22048d201a5SJoerg Sonnenberger
2215027f2b8SJohn Marino patch_seen = false;
22248d201a5SJoerg Sonnenberger for (open_patch_file(filearg[1]); there_is_another_patch();
22348d201a5SJoerg Sonnenberger reinitialize_almost_everything()) {
22448d201a5SJoerg Sonnenberger /* for each patch in patch file */
22548d201a5SJoerg Sonnenberger
226*b94b84caSDaniel Fojt if (source_file != NULL && (diff_type == CONTEXT_DIFF ||
227*b94b84caSDaniel Fojt diff_type == NEW_CONTEXT_DIFF ||
228*b94b84caSDaniel Fojt diff_type == UNI_DIFF))
229*b94b84caSDaniel Fojt out_creating = strcmp(source_file, _PATH_DEVNULL) == 0;
230*b94b84caSDaniel Fojt else
231*b94b84caSDaniel Fojt out_creating = false;
2325027f2b8SJohn Marino patch_seen = true;
2335027f2b8SJohn Marino
23448d201a5SJoerg Sonnenberger warn_on_invalid_line = true;
23548d201a5SJoerg Sonnenberger
23648d201a5SJoerg Sonnenberger if (outname == NULL)
237*b94b84caSDaniel Fojt outname = xstrdup(filearg[0]);
238*b94b84caSDaniel Fojt
239*b94b84caSDaniel Fojt /*
240*b94b84caSDaniel Fojt * At this point, we know if we're supposed to be creating the
241*b94b84caSDaniel Fojt * file and we know if we should be trying to handle a conflict
242*b94b84caSDaniel Fojt * between the patch and the file already existing. We defer
243*b94b84caSDaniel Fojt * handling it until hunk processing because we want to swap
244*b94b84caSDaniel Fojt * the hunk if they opt to reverse it, but we want to make sure
245*b94b84caSDaniel Fojt * we *can* swap the hunk without running into memory issues
246*b94b84caSDaniel Fojt * before we offer it. We also want to be verbose if flags or
247*b94b84caSDaniel Fojt * user decision cause us to skip -- this is explained a little
248*b94b84caSDaniel Fojt * more later.
249*b94b84caSDaniel Fojt */
250*b94b84caSDaniel Fojt out_existed = stat(outname, &statbuf) == 0;
25148d201a5SJoerg Sonnenberger
25248d201a5SJoerg Sonnenberger /* for ed script just up and do it and exit */
25348d201a5SJoerg Sonnenberger if (diff_type == ED_DIFF) {
25448d201a5SJoerg Sonnenberger do_ed_script();
25548d201a5SJoerg Sonnenberger continue;
25648d201a5SJoerg Sonnenberger }
25748d201a5SJoerg Sonnenberger /* initialize the patched file */
25848d201a5SJoerg Sonnenberger if (!skip_rest_of_patch)
25948d201a5SJoerg Sonnenberger init_output(TMPOUTNAME);
26048d201a5SJoerg Sonnenberger
26148d201a5SJoerg Sonnenberger /* initialize reject file */
26248d201a5SJoerg Sonnenberger init_reject(TMPREJNAME);
26348d201a5SJoerg Sonnenberger
26448d201a5SJoerg Sonnenberger /* find out where all the lines are */
26548d201a5SJoerg Sonnenberger if (!skip_rest_of_patch)
26648d201a5SJoerg Sonnenberger scan_input(filearg[0]);
26748d201a5SJoerg Sonnenberger
2685027f2b8SJohn Marino /*
2695027f2b8SJohn Marino * from here on, open no standard i/o files, because
2705027f2b8SJohn Marino * malloc might misfire and we can't catch it easily
2715027f2b8SJohn Marino */
27248d201a5SJoerg Sonnenberger
27348d201a5SJoerg Sonnenberger /* apply each hunk of patch */
27448d201a5SJoerg Sonnenberger hunk = 0;
27548d201a5SJoerg Sonnenberger failed = 0;
2765027f2b8SJohn Marino reverse_seen = false;
27748d201a5SJoerg Sonnenberger out_of_mem = false;
278*b94b84caSDaniel Fojt remove_file = false;
27948d201a5SJoerg Sonnenberger while (another_hunk()) {
280*b94b84caSDaniel Fojt assert(!out_creating || hunk == 0);
28148d201a5SJoerg Sonnenberger hunk++;
28248d201a5SJoerg Sonnenberger fuzz = 0;
283*b94b84caSDaniel Fojt
284*b94b84caSDaniel Fojt /*
285*b94b84caSDaniel Fojt * There are only three cases in handle_creation() that
286*b94b84caSDaniel Fojt * results in us skipping hunk location, in order:
287*b94b84caSDaniel Fojt *
288*b94b84caSDaniel Fojt * 1.) Potentially reversed but -f/--force'd,
289*b94b84caSDaniel Fojt * 2.) Potentially reversed but -N/--forward'd
290*b94b84caSDaniel Fojt * 3.) Reversed and the user's opted to not apply it.
291*b94b84caSDaniel Fojt *
292*b94b84caSDaniel Fojt * In all three cases, we still want to inform the user
293*b94b84caSDaniel Fojt * that we're ignoring it in the standard way, which is
294*b94b84caSDaniel Fojt * also tied to this hunk processing loop.
295*b94b84caSDaniel Fojt */
296*b94b84caSDaniel Fojt if (out_creating)
297*b94b84caSDaniel Fojt reverse_seen = handle_creation(out_existed,
298*b94b84caSDaniel Fojt &remove_file);
299*b94b84caSDaniel Fojt
30048d201a5SJoerg Sonnenberger mymaxfuzz = pch_context();
30148d201a5SJoerg Sonnenberger if (maxfuzz < mymaxfuzz)
30248d201a5SJoerg Sonnenberger mymaxfuzz = maxfuzz;
30348d201a5SJoerg Sonnenberger if (!skip_rest_of_patch) {
30448d201a5SJoerg Sonnenberger do {
30548d201a5SJoerg Sonnenberger where = locate_hunk(fuzz);
3065027f2b8SJohn Marino if (hunk == 1 && where == 0 && !force && !reverse_seen) {
30748d201a5SJoerg Sonnenberger /* dwim for reversed patch? */
30848d201a5SJoerg Sonnenberger if (!pch_swap()) {
30948d201a5SJoerg Sonnenberger if (fuzz == 0)
31048d201a5SJoerg Sonnenberger say("Not enough memory to try swapped hunk! Assuming unswapped.\n");
31148d201a5SJoerg Sonnenberger continue;
31248d201a5SJoerg Sonnenberger }
31348d201a5SJoerg Sonnenberger reverse = !reverse;
31448d201a5SJoerg Sonnenberger /* try again */
31548d201a5SJoerg Sonnenberger where = locate_hunk(fuzz);
31648d201a5SJoerg Sonnenberger if (where == 0) {
31748d201a5SJoerg Sonnenberger /* didn't find it swapped */
31848d201a5SJoerg Sonnenberger if (!pch_swap())
31948d201a5SJoerg Sonnenberger /* put it back to normal */
32048d201a5SJoerg Sonnenberger fatal("lost hunk on alloc error!\n");
32148d201a5SJoerg Sonnenberger reverse = !reverse;
32248d201a5SJoerg Sonnenberger } else if (noreverse) {
32348d201a5SJoerg Sonnenberger if (!pch_swap())
32448d201a5SJoerg Sonnenberger /* put it back to normal */
32548d201a5SJoerg Sonnenberger fatal("lost hunk on alloc error!\n");
32648d201a5SJoerg Sonnenberger reverse = !reverse;
32748d201a5SJoerg Sonnenberger say("Ignoring previously applied (or reversed) patch.\n");
32848d201a5SJoerg Sonnenberger skip_rest_of_patch = true;
32948d201a5SJoerg Sonnenberger } else if (batch) {
33048d201a5SJoerg Sonnenberger if (verbose)
33148d201a5SJoerg Sonnenberger say("%seversed (or previously applied) patch detected! %s -R.",
33248d201a5SJoerg Sonnenberger reverse ? "R" : "Unr",
33348d201a5SJoerg Sonnenberger reverse ? "Assuming" : "Ignoring");
33448d201a5SJoerg Sonnenberger } else {
33548d201a5SJoerg Sonnenberger ask("%seversed (or previously applied) patch detected! %s -R? [y] ",
33648d201a5SJoerg Sonnenberger reverse ? "R" : "Unr",
33748d201a5SJoerg Sonnenberger reverse ? "Assume" : "Ignore");
33848d201a5SJoerg Sonnenberger if (*buf == 'n') {
33948d201a5SJoerg Sonnenberger ask("Apply anyway? [n] ");
34048d201a5SJoerg Sonnenberger if (*buf != 'y')
34148d201a5SJoerg Sonnenberger skip_rest_of_patch = true;
3425027f2b8SJohn Marino else
3435027f2b8SJohn Marino reverse_seen = true;
34448d201a5SJoerg Sonnenberger where = 0;
34548d201a5SJoerg Sonnenberger reverse = !reverse;
34648d201a5SJoerg Sonnenberger if (!pch_swap())
34748d201a5SJoerg Sonnenberger /* put it back to normal */
34848d201a5SJoerg Sonnenberger fatal("lost hunk on alloc error!\n");
34948d201a5SJoerg Sonnenberger }
35048d201a5SJoerg Sonnenberger }
35148d201a5SJoerg Sonnenberger }
35248d201a5SJoerg Sonnenberger } while (!skip_rest_of_patch && where == 0 &&
35348d201a5SJoerg Sonnenberger ++fuzz <= mymaxfuzz);
35448d201a5SJoerg Sonnenberger
35548d201a5SJoerg Sonnenberger if (skip_rest_of_patch) { /* just got decided */
35632fe83a8SJoerg Sonnenberger if (ferror(ofp) || fclose(ofp)) {
35732fe83a8SJoerg Sonnenberger say("Error writing %s\n",
35832fe83a8SJoerg Sonnenberger TMPOUTNAME);
35932fe83a8SJoerg Sonnenberger error = 1;
36032fe83a8SJoerg Sonnenberger }
36148d201a5SJoerg Sonnenberger ofp = NULL;
36248d201a5SJoerg Sonnenberger }
36348d201a5SJoerg Sonnenberger }
36448d201a5SJoerg Sonnenberger newwhere = pch_newfirst() + last_offset;
36548d201a5SJoerg Sonnenberger if (skip_rest_of_patch) {
36648d201a5SJoerg Sonnenberger abort_hunk();
36748d201a5SJoerg Sonnenberger failed++;
36848d201a5SJoerg Sonnenberger if (verbose)
36948d201a5SJoerg Sonnenberger say("Hunk #%d ignored at %ld.\n",
37048d201a5SJoerg Sonnenberger hunk, newwhere);
37148d201a5SJoerg Sonnenberger } else if (where == 0) {
37248d201a5SJoerg Sonnenberger abort_hunk();
37348d201a5SJoerg Sonnenberger failed++;
37448d201a5SJoerg Sonnenberger if (verbose)
37548d201a5SJoerg Sonnenberger say("Hunk #%d failed at %ld.\n",
37648d201a5SJoerg Sonnenberger hunk, newwhere);
37748d201a5SJoerg Sonnenberger } else {
37848d201a5SJoerg Sonnenberger apply_hunk(where);
37948d201a5SJoerg Sonnenberger if (verbose) {
38048d201a5SJoerg Sonnenberger say("Hunk #%d succeeded at %ld",
38148d201a5SJoerg Sonnenberger hunk, newwhere);
38248d201a5SJoerg Sonnenberger if (fuzz != 0)
38348d201a5SJoerg Sonnenberger say(" with fuzz %ld", fuzz);
38448d201a5SJoerg Sonnenberger if (last_offset)
38548d201a5SJoerg Sonnenberger say(" (offset %ld line%s)",
38648d201a5SJoerg Sonnenberger last_offset,
38748d201a5SJoerg Sonnenberger last_offset == 1L ? "" : "s");
38848d201a5SJoerg Sonnenberger say(".\n");
38948d201a5SJoerg Sonnenberger }
39048d201a5SJoerg Sonnenberger }
39148d201a5SJoerg Sonnenberger }
39248d201a5SJoerg Sonnenberger
39348d201a5SJoerg Sonnenberger if (out_of_mem && using_plan_a) {
39448d201a5SJoerg Sonnenberger Argc = Argc_last;
39548d201a5SJoerg Sonnenberger Argv = Argv_last;
39648d201a5SJoerg Sonnenberger say("\n\nRan out of memory using Plan A--trying again...\n\n");
39748d201a5SJoerg Sonnenberger if (ofp)
39848d201a5SJoerg Sonnenberger fclose(ofp);
39948d201a5SJoerg Sonnenberger ofp = NULL;
40048d201a5SJoerg Sonnenberger if (rejfp)
40148d201a5SJoerg Sonnenberger fclose(rejfp);
40248d201a5SJoerg Sonnenberger rejfp = NULL;
40348d201a5SJoerg Sonnenberger continue;
40448d201a5SJoerg Sonnenberger }
40548d201a5SJoerg Sonnenberger if (hunk == 0)
40648d201a5SJoerg Sonnenberger fatal("Internal error: hunk should not be 0\n");
40748d201a5SJoerg Sonnenberger
40848d201a5SJoerg Sonnenberger /* finish spewing out the new file */
40932fe83a8SJoerg Sonnenberger if (!skip_rest_of_patch && !spew_output()) {
41032fe83a8SJoerg Sonnenberger say("Can't write %s\n", TMPOUTNAME);
41132fe83a8SJoerg Sonnenberger error = 1;
41232fe83a8SJoerg Sonnenberger }
41348d201a5SJoerg Sonnenberger
41448d201a5SJoerg Sonnenberger /* and put the output where desired */
41548d201a5SJoerg Sonnenberger ignore_signals();
41648d201a5SJoerg Sonnenberger if (!skip_rest_of_patch) {
41748d201a5SJoerg Sonnenberger char *realout = outname;
41848d201a5SJoerg Sonnenberger
41948d201a5SJoerg Sonnenberger if (!check_only) {
42048d201a5SJoerg Sonnenberger if (move_file(TMPOUTNAME, outname) < 0) {
42148d201a5SJoerg Sonnenberger toutkeep = true;
42248d201a5SJoerg Sonnenberger realout = TMPOUTNAME;
42348d201a5SJoerg Sonnenberger chmod(TMPOUTNAME, filemode);
42448d201a5SJoerg Sonnenberger } else
42548d201a5SJoerg Sonnenberger chmod(outname, filemode);
42648d201a5SJoerg Sonnenberger
427*b94b84caSDaniel Fojt /*
428*b94b84caSDaniel Fojt * remove_file is a per-patch flag indicating
429*b94b84caSDaniel Fojt * whether it's OK to remove the empty file.
430*b94b84caSDaniel Fojt * This is specifically set when we're reversing
431*b94b84caSDaniel Fojt * the creation of a file and it ends up empty.
432*b94b84caSDaniel Fojt * This is an exception to the global policy
433*b94b84caSDaniel Fojt * (remove_empty_files) because the user would
434*b94b84caSDaniel Fojt * likely not expect the reverse of file
435*b94b84caSDaniel Fojt * creation to leave an empty file laying
436*b94b84caSDaniel Fojt * around.
437*b94b84caSDaniel Fojt */
438*b94b84caSDaniel Fojt if ((remove_empty_files || remove_file) &&
43948d201a5SJoerg Sonnenberger stat(realout, &statbuf) == 0 &&
44048d201a5SJoerg Sonnenberger statbuf.st_size == 0) {
44148d201a5SJoerg Sonnenberger if (verbose)
44248d201a5SJoerg Sonnenberger say("Removing %s (empty after patching).\n",
44348d201a5SJoerg Sonnenberger realout);
44448d201a5SJoerg Sonnenberger unlink(realout);
44548d201a5SJoerg Sonnenberger }
44648d201a5SJoerg Sonnenberger }
44748d201a5SJoerg Sonnenberger }
44832fe83a8SJoerg Sonnenberger if (ferror(rejfp) || fclose(rejfp)) {
44932fe83a8SJoerg Sonnenberger say("Error writing %s\n", rejname);
45032fe83a8SJoerg Sonnenberger error = 1;
45132fe83a8SJoerg Sonnenberger }
45248d201a5SJoerg Sonnenberger rejfp = NULL;
45348d201a5SJoerg Sonnenberger if (failed) {
45448d201a5SJoerg Sonnenberger error = 1;
45548d201a5SJoerg Sonnenberger if (*rejname == '\0') {
45648d201a5SJoerg Sonnenberger if (strlcpy(rejname, outname,
45748d201a5SJoerg Sonnenberger sizeof(rejname)) >= sizeof(rejname))
45848d201a5SJoerg Sonnenberger fatal("filename %s is too long\n", outname);
45948d201a5SJoerg Sonnenberger if (strlcat(rejname, REJEXT,
46048d201a5SJoerg Sonnenberger sizeof(rejname)) >= sizeof(rejname))
46148d201a5SJoerg Sonnenberger fatal("filename %s is too long\n", outname);
46248d201a5SJoerg Sonnenberger }
4635027f2b8SJohn Marino if (!check_only)
464cfc96340SSascha Wildner say("%d out of %d hunks %s--saving rejects to %s\n",
465cfc96340SSascha Wildner failed, hunk, skip_rest_of_patch ? "ignored" : "failed", rejname);
4665027f2b8SJohn Marino else
4675027f2b8SJohn Marino say("%d out of %d hunks %s while patching %s\n",
4685027f2b8SJohn Marino failed, hunk, skip_rest_of_patch ? "ignored" : "failed", filearg[0]);
46948d201a5SJoerg Sonnenberger if (!check_only && move_file(TMPREJNAME, rejname) < 0)
47048d201a5SJoerg Sonnenberger trejkeep = true;
47148d201a5SJoerg Sonnenberger }
47248d201a5SJoerg Sonnenberger set_signals(1);
47348d201a5SJoerg Sonnenberger }
4745027f2b8SJohn Marino
475*b94b84caSDaniel Fojt if (!patch_seen && nonempty_patchf_seen)
4765027f2b8SJohn Marino error = 2;
4775027f2b8SJohn Marino
47848d201a5SJoerg Sonnenberger my_exit(error);
47948d201a5SJoerg Sonnenberger /* NOTREACHED */
48048d201a5SJoerg Sonnenberger }
48148d201a5SJoerg Sonnenberger
48248d201a5SJoerg Sonnenberger /* Prepare to find the next patch to do in the patch file. */
48348d201a5SJoerg Sonnenberger
48448d201a5SJoerg Sonnenberger static void
reinitialize_almost_everything(void)48548d201a5SJoerg Sonnenberger reinitialize_almost_everything(void)
48648d201a5SJoerg Sonnenberger {
48748d201a5SJoerg Sonnenberger re_patch();
48848d201a5SJoerg Sonnenberger re_input();
48948d201a5SJoerg Sonnenberger
49048d201a5SJoerg Sonnenberger input_lines = 0;
49148d201a5SJoerg Sonnenberger last_frozen_line = 0;
49248d201a5SJoerg Sonnenberger
49348d201a5SJoerg Sonnenberger filec = 0;
49448d201a5SJoerg Sonnenberger if (!out_of_mem) {
49548d201a5SJoerg Sonnenberger free(filearg[0]);
49648d201a5SJoerg Sonnenberger filearg[0] = NULL;
49748d201a5SJoerg Sonnenberger }
49848d201a5SJoerg Sonnenberger
499*b94b84caSDaniel Fojt free(source_file);
500*b94b84caSDaniel Fojt source_file = NULL;
501*b94b84caSDaniel Fojt
50248d201a5SJoerg Sonnenberger free(outname);
50348d201a5SJoerg Sonnenberger outname = NULL;
50448d201a5SJoerg Sonnenberger
50548d201a5SJoerg Sonnenberger last_offset = 0;
50648d201a5SJoerg Sonnenberger diff_type = 0;
50748d201a5SJoerg Sonnenberger
50848d201a5SJoerg Sonnenberger free(revision);
50948d201a5SJoerg Sonnenberger revision = NULL;
51048d201a5SJoerg Sonnenberger
51148d201a5SJoerg Sonnenberger reverse = reverse_flag_specified;
51248d201a5SJoerg Sonnenberger skip_rest_of_patch = false;
51348d201a5SJoerg Sonnenberger
51448d201a5SJoerg Sonnenberger get_some_switches();
51548d201a5SJoerg Sonnenberger }
51648d201a5SJoerg Sonnenberger
51748d201a5SJoerg Sonnenberger /* Process switches and filenames. */
51848d201a5SJoerg Sonnenberger
51948d201a5SJoerg Sonnenberger static void
get_some_switches(void)52048d201a5SJoerg Sonnenberger get_some_switches(void)
52148d201a5SJoerg Sonnenberger {
522f7e25d55SSascha Wildner const char *options = "b::B:cCd:D:eEfF:i:lnNo:p:r:RstuvV:x:z:";
52348d201a5SJoerg Sonnenberger static struct option longopts[] = {
52448d201a5SJoerg Sonnenberger {"backup", no_argument, 0, 'b'},
52548d201a5SJoerg Sonnenberger {"batch", no_argument, 0, 't'},
52648d201a5SJoerg Sonnenberger {"check", no_argument, 0, 'C'},
52748d201a5SJoerg Sonnenberger {"context", no_argument, 0, 'c'},
52848d201a5SJoerg Sonnenberger {"debug", required_argument, 0, 'x'},
52948d201a5SJoerg Sonnenberger {"directory", required_argument, 0, 'd'},
530c4be1ed5SRobin Hahling {"dry-run", no_argument, 0, 'C'},
53148d201a5SJoerg Sonnenberger {"ed", no_argument, 0, 'e'},
53248d201a5SJoerg Sonnenberger {"force", no_argument, 0, 'f'},
53348d201a5SJoerg Sonnenberger {"forward", no_argument, 0, 'N'},
53448d201a5SJoerg Sonnenberger {"fuzz", required_argument, 0, 'F'},
53548d201a5SJoerg Sonnenberger {"ifdef", required_argument, 0, 'D'},
53648d201a5SJoerg Sonnenberger {"input", required_argument, 0, 'i'},
53748d201a5SJoerg Sonnenberger {"ignore-whitespace", no_argument, 0, 'l'},
53848d201a5SJoerg Sonnenberger {"normal", no_argument, 0, 'n'},
53948d201a5SJoerg Sonnenberger {"output", required_argument, 0, 'o'},
54048d201a5SJoerg Sonnenberger {"prefix", required_argument, 0, 'B'},
54148d201a5SJoerg Sonnenberger {"quiet", no_argument, 0, 's'},
54248d201a5SJoerg Sonnenberger {"reject-file", required_argument, 0, 'r'},
54348d201a5SJoerg Sonnenberger {"remove-empty-files", no_argument, 0, 'E'},
54448d201a5SJoerg Sonnenberger {"reverse", no_argument, 0, 'R'},
54548d201a5SJoerg Sonnenberger {"silent", no_argument, 0, 's'},
54648d201a5SJoerg Sonnenberger {"strip", required_argument, 0, 'p'},
54748d201a5SJoerg Sonnenberger {"suffix", required_argument, 0, 'z'},
54848d201a5SJoerg Sonnenberger {"unified", no_argument, 0, 'u'},
54948d201a5SJoerg Sonnenberger {"version", no_argument, 0, 'v'},
55048d201a5SJoerg Sonnenberger {"version-control", required_argument, 0, 'V'},
55148d201a5SJoerg Sonnenberger {"posix", no_argument, &posix, 1},
55248d201a5SJoerg Sonnenberger {NULL, 0, 0, 0}
55348d201a5SJoerg Sonnenberger };
55448d201a5SJoerg Sonnenberger int ch;
55548d201a5SJoerg Sonnenberger
55648d201a5SJoerg Sonnenberger rejname[0] = '\0';
55748d201a5SJoerg Sonnenberger Argc_last = Argc;
55848d201a5SJoerg Sonnenberger Argv_last = Argv;
55948d201a5SJoerg Sonnenberger if (!Argc)
56048d201a5SJoerg Sonnenberger return;
56148d201a5SJoerg Sonnenberger optreset = optind = 1;
56248d201a5SJoerg Sonnenberger while ((ch = getopt_long(Argc, Argv, options, longopts, NULL)) != -1) {
56348d201a5SJoerg Sonnenberger switch (ch) {
56448d201a5SJoerg Sonnenberger case 'b':
56548d201a5SJoerg Sonnenberger if (backup_type == none)
56648d201a5SJoerg Sonnenberger backup_type = numbered_existing;
56748d201a5SJoerg Sonnenberger if (optarg == NULL)
56848d201a5SJoerg Sonnenberger break;
56948d201a5SJoerg Sonnenberger if (verbose)
57048d201a5SJoerg Sonnenberger say("Warning, the ``-b suffix'' option has been"
57148d201a5SJoerg Sonnenberger " obsoleted by the -z option.\n");
57248d201a5SJoerg Sonnenberger /* FALLTHROUGH */
57348d201a5SJoerg Sonnenberger case 'z':
57448d201a5SJoerg Sonnenberger /* must directly follow 'b' case for backwards compat */
575*b94b84caSDaniel Fojt simple_backup_suffix = xstrdup(optarg);
57648d201a5SJoerg Sonnenberger break;
57748d201a5SJoerg Sonnenberger case 'B':
578*b94b84caSDaniel Fojt origprae = xstrdup(optarg);
57948d201a5SJoerg Sonnenberger break;
58048d201a5SJoerg Sonnenberger case 'c':
58148d201a5SJoerg Sonnenberger diff_type = CONTEXT_DIFF;
58248d201a5SJoerg Sonnenberger break;
58348d201a5SJoerg Sonnenberger case 'C':
58448d201a5SJoerg Sonnenberger check_only = true;
58548d201a5SJoerg Sonnenberger break;
58648d201a5SJoerg Sonnenberger case 'd':
58748d201a5SJoerg Sonnenberger if (chdir(optarg) < 0)
58848d201a5SJoerg Sonnenberger pfatal("can't cd to %s", optarg);
58948d201a5SJoerg Sonnenberger break;
59048d201a5SJoerg Sonnenberger case 'D':
59148d201a5SJoerg Sonnenberger do_defines = true;
59241871674SJoerg Sonnenberger if (!isalpha((unsigned char)*optarg) && *optarg != '_')
59348d201a5SJoerg Sonnenberger fatal("argument to -D is not an identifier\n");
59448d201a5SJoerg Sonnenberger snprintf(if_defined, sizeof if_defined,
59548d201a5SJoerg Sonnenberger "#ifdef %s\n", optarg);
59648d201a5SJoerg Sonnenberger snprintf(not_defined, sizeof not_defined,
59748d201a5SJoerg Sonnenberger "#ifndef %s\n", optarg);
59848d201a5SJoerg Sonnenberger snprintf(end_defined, sizeof end_defined,
59948d201a5SJoerg Sonnenberger "#endif /* %s */\n", optarg);
60048d201a5SJoerg Sonnenberger break;
60148d201a5SJoerg Sonnenberger case 'e':
60248d201a5SJoerg Sonnenberger diff_type = ED_DIFF;
60348d201a5SJoerg Sonnenberger break;
60448d201a5SJoerg Sonnenberger case 'E':
60548d201a5SJoerg Sonnenberger remove_empty_files = true;
60648d201a5SJoerg Sonnenberger break;
60748d201a5SJoerg Sonnenberger case 'f':
60848d201a5SJoerg Sonnenberger force = true;
60948d201a5SJoerg Sonnenberger break;
61048d201a5SJoerg Sonnenberger case 'F':
61148d201a5SJoerg Sonnenberger maxfuzz = atoi(optarg);
61248d201a5SJoerg Sonnenberger break;
61348d201a5SJoerg Sonnenberger case 'i':
61448d201a5SJoerg Sonnenberger if (++filec == MAXFILEC)
61548d201a5SJoerg Sonnenberger fatal("too many file arguments\n");
616*b94b84caSDaniel Fojt filearg[filec] = xstrdup(optarg);
61748d201a5SJoerg Sonnenberger break;
61848d201a5SJoerg Sonnenberger case 'l':
61948d201a5SJoerg Sonnenberger canonicalize = true;
62048d201a5SJoerg Sonnenberger break;
62148d201a5SJoerg Sonnenberger case 'n':
62248d201a5SJoerg Sonnenberger diff_type = NORMAL_DIFF;
62348d201a5SJoerg Sonnenberger break;
62448d201a5SJoerg Sonnenberger case 'N':
62548d201a5SJoerg Sonnenberger noreverse = true;
62648d201a5SJoerg Sonnenberger break;
62748d201a5SJoerg Sonnenberger case 'o':
628*b94b84caSDaniel Fojt outname = xstrdup(optarg);
62948d201a5SJoerg Sonnenberger break;
63048d201a5SJoerg Sonnenberger case 'p':
63148d201a5SJoerg Sonnenberger strippath = atoi(optarg);
63248d201a5SJoerg Sonnenberger break;
63348d201a5SJoerg Sonnenberger case 'r':
63448d201a5SJoerg Sonnenberger if (strlcpy(rejname, optarg,
63548d201a5SJoerg Sonnenberger sizeof(rejname)) >= sizeof(rejname))
63648d201a5SJoerg Sonnenberger fatal("argument for -r is too long\n");
63748d201a5SJoerg Sonnenberger break;
63848d201a5SJoerg Sonnenberger case 'R':
63948d201a5SJoerg Sonnenberger reverse = true;
64048d201a5SJoerg Sonnenberger reverse_flag_specified = true;
64148d201a5SJoerg Sonnenberger break;
64248d201a5SJoerg Sonnenberger case 's':
64348d201a5SJoerg Sonnenberger verbose = false;
64448d201a5SJoerg Sonnenberger break;
64548d201a5SJoerg Sonnenberger case 't':
64648d201a5SJoerg Sonnenberger batch = true;
64748d201a5SJoerg Sonnenberger break;
64848d201a5SJoerg Sonnenberger case 'u':
64948d201a5SJoerg Sonnenberger diff_type = UNI_DIFF;
65048d201a5SJoerg Sonnenberger break;
65148d201a5SJoerg Sonnenberger case 'v':
65248d201a5SJoerg Sonnenberger version();
65348d201a5SJoerg Sonnenberger break;
65448d201a5SJoerg Sonnenberger case 'V':
65548d201a5SJoerg Sonnenberger backup_type = get_version(optarg);
656*b94b84caSDaniel Fojt Vflag = true;
65748d201a5SJoerg Sonnenberger break;
65848d201a5SJoerg Sonnenberger #ifdef DEBUGGING
65948d201a5SJoerg Sonnenberger case 'x':
66048d201a5SJoerg Sonnenberger debug = atoi(optarg);
66148d201a5SJoerg Sonnenberger break;
66248d201a5SJoerg Sonnenberger #endif
66348d201a5SJoerg Sonnenberger default:
66448d201a5SJoerg Sonnenberger if (ch != '\0')
66548d201a5SJoerg Sonnenberger usage();
66648d201a5SJoerg Sonnenberger break;
66748d201a5SJoerg Sonnenberger }
66848d201a5SJoerg Sonnenberger }
66948d201a5SJoerg Sonnenberger Argc -= optind;
67048d201a5SJoerg Sonnenberger Argv += optind;
67148d201a5SJoerg Sonnenberger
67248d201a5SJoerg Sonnenberger if (Argc > 0) {
673*b94b84caSDaniel Fojt filearg[0] = xstrdup(*Argv++);
67448d201a5SJoerg Sonnenberger Argc--;
67548d201a5SJoerg Sonnenberger while (Argc > 0) {
67648d201a5SJoerg Sonnenberger if (++filec == MAXFILEC)
67748d201a5SJoerg Sonnenberger fatal("too many file arguments\n");
678*b94b84caSDaniel Fojt filearg[filec] = xstrdup(*Argv++);
67948d201a5SJoerg Sonnenberger Argc--;
68048d201a5SJoerg Sonnenberger }
68148d201a5SJoerg Sonnenberger }
68248d201a5SJoerg Sonnenberger
68348d201a5SJoerg Sonnenberger if (getenv("POSIXLY_CORRECT") != NULL)
68448d201a5SJoerg Sonnenberger posix = 1;
68548d201a5SJoerg Sonnenberger }
68648d201a5SJoerg Sonnenberger
68748d201a5SJoerg Sonnenberger static void
usage(void)68848d201a5SJoerg Sonnenberger usage(void)
68948d201a5SJoerg Sonnenberger {
69048d201a5SJoerg Sonnenberger fprintf(stderr,
6919d62a0f9SSascha Wildner "usage: patch [-bCcEeflNnRstuv] [-B backup-prefix] [-D symbol] [-d directory]\n"
69248d201a5SJoerg Sonnenberger " [-F max-fuzz] [-i patchfile] [-o out-file] [-p strip-count]\n"
693*b94b84caSDaniel Fojt " [-r rej-name] [-V t | nil | never | none] [-x number]\n"
694*b94b84caSDaniel Fojt " [-z backup-ext] [--posix] [origfile [patchfile]]\n"
6959d62a0f9SSascha Wildner " patch <patchfile\n");
696*b94b84caSDaniel Fojt my_exit(EXIT_FAILURE);
69748d201a5SJoerg Sonnenberger }
69848d201a5SJoerg Sonnenberger
69948d201a5SJoerg Sonnenberger /*
70048d201a5SJoerg Sonnenberger * Attempt to find the right place to apply this hunk of patch.
70148d201a5SJoerg Sonnenberger */
70248d201a5SJoerg Sonnenberger static LINENUM
locate_hunk(LINENUM fuzz)70348d201a5SJoerg Sonnenberger locate_hunk(LINENUM fuzz)
70448d201a5SJoerg Sonnenberger {
70548d201a5SJoerg Sonnenberger LINENUM first_guess = pch_first() + last_offset;
70648d201a5SJoerg Sonnenberger LINENUM offset;
70748d201a5SJoerg Sonnenberger LINENUM pat_lines = pch_ptrn_lines();
70848d201a5SJoerg Sonnenberger LINENUM max_pos_offset = input_lines - first_guess - pat_lines + 1;
70948d201a5SJoerg Sonnenberger LINENUM max_neg_offset = first_guess - last_frozen_line - 1 + pch_context();
71048d201a5SJoerg Sonnenberger
71148d201a5SJoerg Sonnenberger if (pat_lines == 0) { /* null range matches always */
71248d201a5SJoerg Sonnenberger if (verbose && fuzz == 0 && (diff_type == CONTEXT_DIFF
71348d201a5SJoerg Sonnenberger || diff_type == NEW_CONTEXT_DIFF
71448d201a5SJoerg Sonnenberger || diff_type == UNI_DIFF)) {
71548d201a5SJoerg Sonnenberger say("Empty context always matches.\n");
71648d201a5SJoerg Sonnenberger }
71748d201a5SJoerg Sonnenberger return (first_guess);
71848d201a5SJoerg Sonnenberger }
71948d201a5SJoerg Sonnenberger if (max_neg_offset >= first_guess) /* do not try lines < 0 */
72048d201a5SJoerg Sonnenberger max_neg_offset = first_guess - 1;
72148d201a5SJoerg Sonnenberger if (first_guess <= input_lines && patch_match(first_guess, 0, fuzz))
72248d201a5SJoerg Sonnenberger return first_guess;
72348d201a5SJoerg Sonnenberger for (offset = 1; ; offset++) {
72448d201a5SJoerg Sonnenberger bool check_after = (offset <= max_pos_offset);
72548d201a5SJoerg Sonnenberger bool check_before = (offset <= max_neg_offset);
72648d201a5SJoerg Sonnenberger
72748d201a5SJoerg Sonnenberger if (check_after && patch_match(first_guess, offset, fuzz)) {
72848d201a5SJoerg Sonnenberger #ifdef DEBUGGING
72948d201a5SJoerg Sonnenberger if (debug & 1)
73048d201a5SJoerg Sonnenberger say("Offset changing from %ld to %ld\n",
73148d201a5SJoerg Sonnenberger last_offset, offset);
73248d201a5SJoerg Sonnenberger #endif
73348d201a5SJoerg Sonnenberger last_offset = offset;
73448d201a5SJoerg Sonnenberger return first_guess + offset;
73548d201a5SJoerg Sonnenberger } else if (check_before && patch_match(first_guess, -offset, fuzz)) {
73648d201a5SJoerg Sonnenberger #ifdef DEBUGGING
73748d201a5SJoerg Sonnenberger if (debug & 1)
73848d201a5SJoerg Sonnenberger say("Offset changing from %ld to %ld\n",
73948d201a5SJoerg Sonnenberger last_offset, -offset);
74048d201a5SJoerg Sonnenberger #endif
74148d201a5SJoerg Sonnenberger last_offset = -offset;
74248d201a5SJoerg Sonnenberger return first_guess - offset;
74348d201a5SJoerg Sonnenberger } else if (!check_before && !check_after)
74448d201a5SJoerg Sonnenberger return 0;
74548d201a5SJoerg Sonnenberger }
74648d201a5SJoerg Sonnenberger }
74748d201a5SJoerg Sonnenberger
74848d201a5SJoerg Sonnenberger /* We did not find the pattern, dump out the hunk so they can handle it. */
74948d201a5SJoerg Sonnenberger
75048d201a5SJoerg Sonnenberger static void
abort_context_hunk(void)751f7e25d55SSascha Wildner abort_context_hunk(void)
75248d201a5SJoerg Sonnenberger {
75348d201a5SJoerg Sonnenberger LINENUM i;
75448d201a5SJoerg Sonnenberger const LINENUM pat_end = pch_end();
75548d201a5SJoerg Sonnenberger /*
75648d201a5SJoerg Sonnenberger * add in last_offset to guess the same as the previous successful
75748d201a5SJoerg Sonnenberger * hunk
75848d201a5SJoerg Sonnenberger */
75948d201a5SJoerg Sonnenberger const LINENUM oldfirst = pch_first() + last_offset;
76048d201a5SJoerg Sonnenberger const LINENUM newfirst = pch_newfirst() + last_offset;
76148d201a5SJoerg Sonnenberger const LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
76248d201a5SJoerg Sonnenberger const LINENUM newlast = newfirst + pch_repl_lines() - 1;
76348d201a5SJoerg Sonnenberger const char *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
76448d201a5SJoerg Sonnenberger const char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
76548d201a5SJoerg Sonnenberger
76648d201a5SJoerg Sonnenberger fprintf(rejfp, "***************\n");
76748d201a5SJoerg Sonnenberger for (i = 0; i <= pat_end; i++) {
76848d201a5SJoerg Sonnenberger switch (pch_char(i)) {
76948d201a5SJoerg Sonnenberger case '*':
77048d201a5SJoerg Sonnenberger if (oldlast < oldfirst)
77148d201a5SJoerg Sonnenberger fprintf(rejfp, "*** 0%s\n", stars);
77248d201a5SJoerg Sonnenberger else if (oldlast == oldfirst)
77348d201a5SJoerg Sonnenberger fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
77448d201a5SJoerg Sonnenberger else
77548d201a5SJoerg Sonnenberger fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst,
77648d201a5SJoerg Sonnenberger oldlast, stars);
77748d201a5SJoerg Sonnenberger break;
77848d201a5SJoerg Sonnenberger case '=':
77948d201a5SJoerg Sonnenberger if (newlast < newfirst)
78048d201a5SJoerg Sonnenberger fprintf(rejfp, "--- 0%s\n", minuses);
78148d201a5SJoerg Sonnenberger else if (newlast == newfirst)
78248d201a5SJoerg Sonnenberger fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
78348d201a5SJoerg Sonnenberger else
78448d201a5SJoerg Sonnenberger fprintf(rejfp, "--- %ld,%ld%s\n", newfirst,
78548d201a5SJoerg Sonnenberger newlast, minuses);
78648d201a5SJoerg Sonnenberger break;
78748d201a5SJoerg Sonnenberger case '\n':
78848d201a5SJoerg Sonnenberger fprintf(rejfp, "%s", pfetch(i));
78948d201a5SJoerg Sonnenberger break;
79048d201a5SJoerg Sonnenberger case ' ':
79148d201a5SJoerg Sonnenberger case '-':
79248d201a5SJoerg Sonnenberger case '+':
79348d201a5SJoerg Sonnenberger case '!':
79448d201a5SJoerg Sonnenberger fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
79548d201a5SJoerg Sonnenberger break;
79648d201a5SJoerg Sonnenberger default:
797f7e25d55SSascha Wildner fatal("fatal internal error in abort_context_hunk\n");
798f7e25d55SSascha Wildner }
799f7e25d55SSascha Wildner }
800f7e25d55SSascha Wildner }
801f7e25d55SSascha Wildner
802f7e25d55SSascha Wildner static void
rej_line(int ch,LINENUM i)803f7e25d55SSascha Wildner rej_line(int ch, LINENUM i)
804f7e25d55SSascha Wildner {
805f7e25d55SSascha Wildner size_t len;
806f7e25d55SSascha Wildner const char *line = pfetch(i);
807f7e25d55SSascha Wildner
808f7e25d55SSascha Wildner len = strlen(line);
809f7e25d55SSascha Wildner
810f7e25d55SSascha Wildner fprintf(rejfp, "%c%s", ch, line);
811*b94b84caSDaniel Fojt if (len == 0 || line[len - 1] != '\n') {
812*b94b84caSDaniel Fojt if (len >= USHRT_MAX)
813*b94b84caSDaniel Fojt fprintf(rejfp, "\n\\ Line too long\n");
814*b94b84caSDaniel Fojt else
815*b94b84caSDaniel Fojt fprintf(rejfp, "\n\\ No newline at end of line\n");
816*b94b84caSDaniel Fojt }
817f7e25d55SSascha Wildner }
818f7e25d55SSascha Wildner
819f7e25d55SSascha Wildner static void
abort_hunk(void)820f7e25d55SSascha Wildner abort_hunk(void)
821f7e25d55SSascha Wildner {
822f7e25d55SSascha Wildner LINENUM i, j, split;
823f7e25d55SSascha Wildner int ch1, ch2;
824f7e25d55SSascha Wildner const LINENUM pat_end = pch_end();
825f7e25d55SSascha Wildner const LINENUM oldfirst = pch_first() + last_offset;
826f7e25d55SSascha Wildner const LINENUM newfirst = pch_newfirst() + last_offset;
827f7e25d55SSascha Wildner
828f7e25d55SSascha Wildner if (diff_type != UNI_DIFF) {
829f7e25d55SSascha Wildner abort_context_hunk();
830f7e25d55SSascha Wildner return;
831f7e25d55SSascha Wildner }
832f7e25d55SSascha Wildner split = -1;
833f7e25d55SSascha Wildner for (i = 0; i <= pat_end; i++) {
834f7e25d55SSascha Wildner if (pch_char(i) == '=') {
835f7e25d55SSascha Wildner split = i;
836f7e25d55SSascha Wildner break;
837f7e25d55SSascha Wildner }
838f7e25d55SSascha Wildner }
839f7e25d55SSascha Wildner if (split == -1) {
840f7e25d55SSascha Wildner fprintf(rejfp, "malformed hunk: no split found\n");
841f7e25d55SSascha Wildner return;
842f7e25d55SSascha Wildner }
843f7e25d55SSascha Wildner i = 0;
844f7e25d55SSascha Wildner j = split + 1;
845f7e25d55SSascha Wildner fprintf(rejfp, "@@ -%ld,%ld +%ld,%ld @@\n",
846f7e25d55SSascha Wildner pch_ptrn_lines() ? oldfirst : 0,
847f7e25d55SSascha Wildner pch_ptrn_lines(), newfirst, pch_repl_lines());
848f7e25d55SSascha Wildner while (i < split || j <= pat_end) {
849f7e25d55SSascha Wildner ch1 = i < split ? pch_char(i) : -1;
850f7e25d55SSascha Wildner ch2 = j <= pat_end ? pch_char(j) : -1;
851f7e25d55SSascha Wildner if (ch1 == '-') {
852f7e25d55SSascha Wildner rej_line('-', i);
853f7e25d55SSascha Wildner i++;
854f7e25d55SSascha Wildner } else if (ch1 == ' ' && ch2 == ' ') {
855f7e25d55SSascha Wildner rej_line(' ', i);
856f7e25d55SSascha Wildner i++;
857f7e25d55SSascha Wildner j++;
858f7e25d55SSascha Wildner } else if (ch1 == '!' && ch2 == '!') {
859f7e25d55SSascha Wildner while (i < split && ch1 == '!') {
860f7e25d55SSascha Wildner rej_line('-', i);
861f7e25d55SSascha Wildner i++;
862f7e25d55SSascha Wildner ch1 = i < split ? pch_char(i) : -1;
863f7e25d55SSascha Wildner }
864f7e25d55SSascha Wildner while (j <= pat_end && ch2 == '!') {
865f7e25d55SSascha Wildner rej_line('+', j);
866f7e25d55SSascha Wildner j++;
867f7e25d55SSascha Wildner ch2 = j <= pat_end ? pch_char(j) : -1;
868f7e25d55SSascha Wildner }
869f7e25d55SSascha Wildner } else if (ch1 == '*') {
870f7e25d55SSascha Wildner i++;
871f7e25d55SSascha Wildner } else if (ch2 == '+' || ch2 == ' ') {
872f7e25d55SSascha Wildner rej_line(ch2, j);
873f7e25d55SSascha Wildner j++;
874f7e25d55SSascha Wildner } else {
875f7e25d55SSascha Wildner fprintf(rejfp, "internal error on (%ld %ld %ld)\n",
876f7e25d55SSascha Wildner i, split, j);
877f7e25d55SSascha Wildner rej_line(ch1, i);
878f7e25d55SSascha Wildner rej_line(ch2, j);
879f7e25d55SSascha Wildner return;
88048d201a5SJoerg Sonnenberger }
88148d201a5SJoerg Sonnenberger }
88248d201a5SJoerg Sonnenberger }
88348d201a5SJoerg Sonnenberger
88448d201a5SJoerg Sonnenberger /* We found where to apply it (we hope), so do it. */
88548d201a5SJoerg Sonnenberger
88648d201a5SJoerg Sonnenberger static void
apply_hunk(LINENUM where)88748d201a5SJoerg Sonnenberger apply_hunk(LINENUM where)
88848d201a5SJoerg Sonnenberger {
88948d201a5SJoerg Sonnenberger LINENUM old = 1;
89048d201a5SJoerg Sonnenberger const LINENUM lastline = pch_ptrn_lines();
89148d201a5SJoerg Sonnenberger LINENUM new = lastline + 1;
89248d201a5SJoerg Sonnenberger #define OUTSIDE 0
89348d201a5SJoerg Sonnenberger #define IN_IFNDEF 1
89448d201a5SJoerg Sonnenberger #define IN_IFDEF 2
89548d201a5SJoerg Sonnenberger #define IN_ELSE 3
89648d201a5SJoerg Sonnenberger int def_state = OUTSIDE;
89748d201a5SJoerg Sonnenberger const LINENUM pat_end = pch_end();
89848d201a5SJoerg Sonnenberger
89948d201a5SJoerg Sonnenberger where--;
90048d201a5SJoerg Sonnenberger while (pch_char(new) == '=' || pch_char(new) == '\n')
90148d201a5SJoerg Sonnenberger new++;
90248d201a5SJoerg Sonnenberger
90348d201a5SJoerg Sonnenberger while (old <= lastline) {
90448d201a5SJoerg Sonnenberger if (pch_char(old) == '-') {
90548d201a5SJoerg Sonnenberger copy_till(where + old - 1, false);
90648d201a5SJoerg Sonnenberger if (do_defines) {
90748d201a5SJoerg Sonnenberger if (def_state == OUTSIDE) {
90848d201a5SJoerg Sonnenberger fputs(not_defined, ofp);
90948d201a5SJoerg Sonnenberger def_state = IN_IFNDEF;
91048d201a5SJoerg Sonnenberger } else if (def_state == IN_IFDEF) {
91148d201a5SJoerg Sonnenberger fputs(else_defined, ofp);
91248d201a5SJoerg Sonnenberger def_state = IN_ELSE;
91348d201a5SJoerg Sonnenberger }
91448d201a5SJoerg Sonnenberger fputs(pfetch(old), ofp);
91548d201a5SJoerg Sonnenberger }
91648d201a5SJoerg Sonnenberger last_frozen_line++;
91748d201a5SJoerg Sonnenberger old++;
91848d201a5SJoerg Sonnenberger } else if (new > pat_end) {
91948d201a5SJoerg Sonnenberger break;
92048d201a5SJoerg Sonnenberger } else if (pch_char(new) == '+') {
92148d201a5SJoerg Sonnenberger copy_till(where + old - 1, false);
92248d201a5SJoerg Sonnenberger if (do_defines) {
92348d201a5SJoerg Sonnenberger if (def_state == IN_IFNDEF) {
92448d201a5SJoerg Sonnenberger fputs(else_defined, ofp);
92548d201a5SJoerg Sonnenberger def_state = IN_ELSE;
92648d201a5SJoerg Sonnenberger } else if (def_state == OUTSIDE) {
92748d201a5SJoerg Sonnenberger fputs(if_defined, ofp);
92848d201a5SJoerg Sonnenberger def_state = IN_IFDEF;
92948d201a5SJoerg Sonnenberger }
93048d201a5SJoerg Sonnenberger }
93148d201a5SJoerg Sonnenberger fputs(pfetch(new), ofp);
93248d201a5SJoerg Sonnenberger new++;
93348d201a5SJoerg Sonnenberger } else if (pch_char(new) != pch_char(old)) {
93448d201a5SJoerg Sonnenberger say("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
93548d201a5SJoerg Sonnenberger pch_hunk_beg() + old,
93648d201a5SJoerg Sonnenberger pch_hunk_beg() + new);
93748d201a5SJoerg Sonnenberger #ifdef DEBUGGING
93848d201a5SJoerg Sonnenberger say("oldchar = '%c', newchar = '%c'\n",
93948d201a5SJoerg Sonnenberger pch_char(old), pch_char(new));
94048d201a5SJoerg Sonnenberger #endif
94148d201a5SJoerg Sonnenberger my_exit(2);
94248d201a5SJoerg Sonnenberger } else if (pch_char(new) == '!') {
94348d201a5SJoerg Sonnenberger copy_till(where + old - 1, false);
94448d201a5SJoerg Sonnenberger if (do_defines) {
94548d201a5SJoerg Sonnenberger fputs(not_defined, ofp);
94648d201a5SJoerg Sonnenberger def_state = IN_IFNDEF;
94748d201a5SJoerg Sonnenberger }
94848d201a5SJoerg Sonnenberger while (pch_char(old) == '!') {
94948d201a5SJoerg Sonnenberger if (do_defines) {
95048d201a5SJoerg Sonnenberger fputs(pfetch(old), ofp);
95148d201a5SJoerg Sonnenberger }
95248d201a5SJoerg Sonnenberger last_frozen_line++;
95348d201a5SJoerg Sonnenberger old++;
95448d201a5SJoerg Sonnenberger }
95548d201a5SJoerg Sonnenberger if (do_defines) {
95648d201a5SJoerg Sonnenberger fputs(else_defined, ofp);
95748d201a5SJoerg Sonnenberger def_state = IN_ELSE;
95848d201a5SJoerg Sonnenberger }
95948d201a5SJoerg Sonnenberger while (pch_char(new) == '!') {
96048d201a5SJoerg Sonnenberger fputs(pfetch(new), ofp);
96148d201a5SJoerg Sonnenberger new++;
96248d201a5SJoerg Sonnenberger }
96348d201a5SJoerg Sonnenberger } else {
96448d201a5SJoerg Sonnenberger if (pch_char(new) != ' ')
96548d201a5SJoerg Sonnenberger fatal("Internal error: expected ' '\n");
96648d201a5SJoerg Sonnenberger old++;
96748d201a5SJoerg Sonnenberger new++;
96848d201a5SJoerg Sonnenberger if (do_defines && def_state != OUTSIDE) {
96948d201a5SJoerg Sonnenberger fputs(end_defined, ofp);
97048d201a5SJoerg Sonnenberger def_state = OUTSIDE;
97148d201a5SJoerg Sonnenberger }
97248d201a5SJoerg Sonnenberger }
97348d201a5SJoerg Sonnenberger }
97448d201a5SJoerg Sonnenberger if (new <= pat_end && pch_char(new) == '+') {
97548d201a5SJoerg Sonnenberger copy_till(where + old - 1, false);
97648d201a5SJoerg Sonnenberger if (do_defines) {
97748d201a5SJoerg Sonnenberger if (def_state == OUTSIDE) {
97848d201a5SJoerg Sonnenberger fputs(if_defined, ofp);
97948d201a5SJoerg Sonnenberger def_state = IN_IFDEF;
98048d201a5SJoerg Sonnenberger } else if (def_state == IN_IFNDEF) {
98148d201a5SJoerg Sonnenberger fputs(else_defined, ofp);
98248d201a5SJoerg Sonnenberger def_state = IN_ELSE;
98348d201a5SJoerg Sonnenberger }
98448d201a5SJoerg Sonnenberger }
98548d201a5SJoerg Sonnenberger while (new <= pat_end && pch_char(new) == '+') {
98648d201a5SJoerg Sonnenberger fputs(pfetch(new), ofp);
98748d201a5SJoerg Sonnenberger new++;
98848d201a5SJoerg Sonnenberger }
98948d201a5SJoerg Sonnenberger }
99048d201a5SJoerg Sonnenberger if (do_defines && def_state != OUTSIDE) {
99148d201a5SJoerg Sonnenberger fputs(end_defined, ofp);
99248d201a5SJoerg Sonnenberger }
99348d201a5SJoerg Sonnenberger }
99448d201a5SJoerg Sonnenberger
99548d201a5SJoerg Sonnenberger /*
99648d201a5SJoerg Sonnenberger * Open the new file.
99748d201a5SJoerg Sonnenberger */
99848d201a5SJoerg Sonnenberger static void
init_output(const char * name)99948d201a5SJoerg Sonnenberger init_output(const char *name)
100048d201a5SJoerg Sonnenberger {
100148d201a5SJoerg Sonnenberger ofp = fopen(name, "w");
100248d201a5SJoerg Sonnenberger if (ofp == NULL)
100348d201a5SJoerg Sonnenberger pfatal("can't create %s", name);
100448d201a5SJoerg Sonnenberger }
100548d201a5SJoerg Sonnenberger
100648d201a5SJoerg Sonnenberger /*
100748d201a5SJoerg Sonnenberger * Open a file to put hunks we can't locate.
100848d201a5SJoerg Sonnenberger */
100948d201a5SJoerg Sonnenberger static void
init_reject(const char * name)101048d201a5SJoerg Sonnenberger init_reject(const char *name)
101148d201a5SJoerg Sonnenberger {
101248d201a5SJoerg Sonnenberger rejfp = fopen(name, "w");
101348d201a5SJoerg Sonnenberger if (rejfp == NULL)
101448d201a5SJoerg Sonnenberger pfatal("can't create %s", name);
101548d201a5SJoerg Sonnenberger }
101648d201a5SJoerg Sonnenberger
101748d201a5SJoerg Sonnenberger /*
101848d201a5SJoerg Sonnenberger * Copy input file to output, up to wherever hunk is to be applied.
101948d201a5SJoerg Sonnenberger * If endoffile is true, treat the last line specially since it may
102048d201a5SJoerg Sonnenberger * lack a newline.
102148d201a5SJoerg Sonnenberger */
102248d201a5SJoerg Sonnenberger static void
copy_till(LINENUM lastline,bool endoffile)102348d201a5SJoerg Sonnenberger copy_till(LINENUM lastline, bool endoffile)
102448d201a5SJoerg Sonnenberger {
102548d201a5SJoerg Sonnenberger if (last_frozen_line > lastline)
102648d201a5SJoerg Sonnenberger fatal("misordered hunks! output would be garbled\n");
102748d201a5SJoerg Sonnenberger while (last_frozen_line < lastline) {
102848d201a5SJoerg Sonnenberger if (++last_frozen_line == lastline && endoffile)
102948d201a5SJoerg Sonnenberger dump_line(last_frozen_line, !last_line_missing_eol);
103048d201a5SJoerg Sonnenberger else
103148d201a5SJoerg Sonnenberger dump_line(last_frozen_line, true);
103248d201a5SJoerg Sonnenberger }
103348d201a5SJoerg Sonnenberger }
103448d201a5SJoerg Sonnenberger
103548d201a5SJoerg Sonnenberger /*
103648d201a5SJoerg Sonnenberger * Finish copying the input file to the output file.
103748d201a5SJoerg Sonnenberger */
103832fe83a8SJoerg Sonnenberger static bool
spew_output(void)103948d201a5SJoerg Sonnenberger spew_output(void)
104048d201a5SJoerg Sonnenberger {
104132fe83a8SJoerg Sonnenberger int rv;
104232fe83a8SJoerg Sonnenberger
104348d201a5SJoerg Sonnenberger #ifdef DEBUGGING
104448d201a5SJoerg Sonnenberger if (debug & 256)
104548d201a5SJoerg Sonnenberger say("il=%ld lfl=%ld\n", input_lines, last_frozen_line);
104648d201a5SJoerg Sonnenberger #endif
104748d201a5SJoerg Sonnenberger if (input_lines)
104848d201a5SJoerg Sonnenberger copy_till(input_lines, true); /* dump remainder of file */
1049d649bbf2SJoerg Sonnenberger rv = ferror(ofp) == 0 && fclose(ofp) == 0;
105048d201a5SJoerg Sonnenberger ofp = NULL;
105132fe83a8SJoerg Sonnenberger return rv;
105248d201a5SJoerg Sonnenberger }
105348d201a5SJoerg Sonnenberger
105448d201a5SJoerg Sonnenberger /*
105548d201a5SJoerg Sonnenberger * Copy one line from input to output.
105648d201a5SJoerg Sonnenberger */
105748d201a5SJoerg Sonnenberger static void
dump_line(LINENUM line,bool write_newline)105848d201a5SJoerg Sonnenberger dump_line(LINENUM line, bool write_newline)
105948d201a5SJoerg Sonnenberger {
106048d201a5SJoerg Sonnenberger char *s;
106148d201a5SJoerg Sonnenberger
106248d201a5SJoerg Sonnenberger s = ifetch(line, 0);
106348d201a5SJoerg Sonnenberger if (s == NULL)
106448d201a5SJoerg Sonnenberger return;
106548d201a5SJoerg Sonnenberger /* Note: string is not NUL terminated. */
106648d201a5SJoerg Sonnenberger for (; *s != '\n'; s++)
106748d201a5SJoerg Sonnenberger putc(*s, ofp);
106848d201a5SJoerg Sonnenberger if (write_newline)
106948d201a5SJoerg Sonnenberger putc('\n', ofp);
107048d201a5SJoerg Sonnenberger }
107148d201a5SJoerg Sonnenberger
107248d201a5SJoerg Sonnenberger /*
107348d201a5SJoerg Sonnenberger * Does the patch pattern match at line base+offset?
107448d201a5SJoerg Sonnenberger */
107548d201a5SJoerg Sonnenberger static bool
patch_match(LINENUM base,LINENUM offset,LINENUM fuzz)107648d201a5SJoerg Sonnenberger patch_match(LINENUM base, LINENUM offset, LINENUM fuzz)
107748d201a5SJoerg Sonnenberger {
107848d201a5SJoerg Sonnenberger LINENUM pline = 1 + fuzz;
107948d201a5SJoerg Sonnenberger LINENUM iline;
108048d201a5SJoerg Sonnenberger LINENUM pat_lines = pch_ptrn_lines() - fuzz;
108148d201a5SJoerg Sonnenberger const char *ilineptr;
108248d201a5SJoerg Sonnenberger const char *plineptr;
1083*b94b84caSDaniel Fojt unsigned short plinelen;
108448d201a5SJoerg Sonnenberger
1085*b94b84caSDaniel Fojt /* Patch does not match if we don't have any more context to use */
1086*b94b84caSDaniel Fojt if (pline > pat_lines)
1087*b94b84caSDaniel Fojt return false;
108848d201a5SJoerg Sonnenberger for (iline = base + offset + fuzz; pline <= pat_lines; pline++, iline++) {
108948d201a5SJoerg Sonnenberger ilineptr = ifetch(iline, offset >= 0);
109048d201a5SJoerg Sonnenberger if (ilineptr == NULL)
109148d201a5SJoerg Sonnenberger return false;
109248d201a5SJoerg Sonnenberger plineptr = pfetch(pline);
109348d201a5SJoerg Sonnenberger plinelen = pch_line_len(pline);
109448d201a5SJoerg Sonnenberger if (canonicalize) {
109548d201a5SJoerg Sonnenberger if (!similar(ilineptr, plineptr, plinelen))
109648d201a5SJoerg Sonnenberger return false;
109748d201a5SJoerg Sonnenberger } else if (strnNE(ilineptr, plineptr, plinelen))
109848d201a5SJoerg Sonnenberger return false;
109948d201a5SJoerg Sonnenberger if (iline == input_lines) {
110048d201a5SJoerg Sonnenberger /*
110148d201a5SJoerg Sonnenberger * We are looking at the last line of the file.
110248d201a5SJoerg Sonnenberger * If the file has no eol, the patch line should
110348d201a5SJoerg Sonnenberger * not have one either and vice-versa. Note that
110448d201a5SJoerg Sonnenberger * plinelen > 0.
110548d201a5SJoerg Sonnenberger */
110648d201a5SJoerg Sonnenberger if (last_line_missing_eol) {
110748d201a5SJoerg Sonnenberger if (plineptr[plinelen - 1] == '\n')
110848d201a5SJoerg Sonnenberger return false;
110948d201a5SJoerg Sonnenberger } else {
111048d201a5SJoerg Sonnenberger if (plineptr[plinelen - 1] != '\n')
111148d201a5SJoerg Sonnenberger return false;
111248d201a5SJoerg Sonnenberger }
111348d201a5SJoerg Sonnenberger }
111448d201a5SJoerg Sonnenberger }
111548d201a5SJoerg Sonnenberger return true;
111648d201a5SJoerg Sonnenberger }
111748d201a5SJoerg Sonnenberger
111848d201a5SJoerg Sonnenberger /*
111948d201a5SJoerg Sonnenberger * Do two lines match with canonicalized white space?
112048d201a5SJoerg Sonnenberger */
112148d201a5SJoerg Sonnenberger static bool
similar(const char * a,const char * b,int len)112248d201a5SJoerg Sonnenberger similar(const char *a, const char *b, int len)
112348d201a5SJoerg Sonnenberger {
112448d201a5SJoerg Sonnenberger while (len) {
112541871674SJoerg Sonnenberger if (isspace((unsigned char)*b)) { /* whitespace (or \n) to match? */
112641871674SJoerg Sonnenberger if (!isspace((unsigned char)*a)) /* no corresponding whitespace? */
112748d201a5SJoerg Sonnenberger return false;
112841871674SJoerg Sonnenberger while (len && isspace((unsigned char)*b) && *b != '\n')
112948d201a5SJoerg Sonnenberger b++, len--; /* skip pattern whitespace */
113041871674SJoerg Sonnenberger while (isspace((unsigned char)*a) && *a != '\n')
113148d201a5SJoerg Sonnenberger a++; /* skip target whitespace */
113248d201a5SJoerg Sonnenberger if (*a == '\n' || *b == '\n')
113348d201a5SJoerg Sonnenberger return (*a == *b); /* should end in sync */
113448d201a5SJoerg Sonnenberger } else if (*a++ != *b++) /* match non-whitespace chars */
113548d201a5SJoerg Sonnenberger return false;
113648d201a5SJoerg Sonnenberger else
113748d201a5SJoerg Sonnenberger len--; /* probably not necessary */
113848d201a5SJoerg Sonnenberger }
113948d201a5SJoerg Sonnenberger return true; /* actually, this is not reached */
114048d201a5SJoerg Sonnenberger /* since there is always a \n */
114148d201a5SJoerg Sonnenberger }
1142*b94b84caSDaniel Fojt
1143*b94b84caSDaniel Fojt static bool
handle_creation(bool out_existed,bool * remove)1144*b94b84caSDaniel Fojt handle_creation(bool out_existed, bool *remove)
1145*b94b84caSDaniel Fojt {
1146*b94b84caSDaniel Fojt bool reverse_seen;
1147*b94b84caSDaniel Fojt
1148*b94b84caSDaniel Fojt reverse_seen = false;
1149*b94b84caSDaniel Fojt if (reverse && out_existed) {
1150*b94b84caSDaniel Fojt /*
1151*b94b84caSDaniel Fojt * If the patch creates the file and we're reversing the patch,
1152*b94b84caSDaniel Fojt * then we need to indicate to the patch processor that it's OK
1153*b94b84caSDaniel Fojt * to remove this file.
1154*b94b84caSDaniel Fojt */
1155*b94b84caSDaniel Fojt *remove = true;
1156*b94b84caSDaniel Fojt } else if (!reverse && out_existed) {
1157*b94b84caSDaniel Fojt /*
1158*b94b84caSDaniel Fojt * Otherwise, we need to blow the horn because the patch appears
1159*b94b84caSDaniel Fojt * to be reversed/already applied. For non-batch jobs, we'll
1160*b94b84caSDaniel Fojt * prompt to figure out what we should be trying to do to raise
1161*b94b84caSDaniel Fojt * awareness of the issue. batch (-t) processing suppresses the
1162*b94b84caSDaniel Fojt * questions and just assumes that we're reversed if it looks
1163*b94b84caSDaniel Fojt * like we are, which is always the case if we've reached this
1164*b94b84caSDaniel Fojt * branch.
1165*b94b84caSDaniel Fojt */
1166*b94b84caSDaniel Fojt if (force) {
1167*b94b84caSDaniel Fojt skip_rest_of_patch = true;
1168*b94b84caSDaniel Fojt return (false);
1169*b94b84caSDaniel Fojt }
1170*b94b84caSDaniel Fojt if (noreverse) {
1171*b94b84caSDaniel Fojt /* If -N is supplied, however, we bail out/ignore. */
1172*b94b84caSDaniel Fojt say("Ignoring previously applied (or reversed) patch.\n");
1173*b94b84caSDaniel Fojt skip_rest_of_patch = true;
1174*b94b84caSDaniel Fojt return (false);
1175*b94b84caSDaniel Fojt }
1176*b94b84caSDaniel Fojt
1177*b94b84caSDaniel Fojt /* Unreversed... suspicious if the file existed. */
1178*b94b84caSDaniel Fojt if (!pch_swap())
1179*b94b84caSDaniel Fojt fatal("lost hunk on alloc error!\n");
1180*b94b84caSDaniel Fojt
1181*b94b84caSDaniel Fojt reverse = !reverse;
1182*b94b84caSDaniel Fojt
1183*b94b84caSDaniel Fojt if (batch) {
1184*b94b84caSDaniel Fojt if (verbose)
1185*b94b84caSDaniel Fojt say("Patch creates file that already exists, %s %seversed",
1186*b94b84caSDaniel Fojt reverse ? "Assuming" : "Ignoring",
1187*b94b84caSDaniel Fojt reverse ? "R" : "Unr");
1188*b94b84caSDaniel Fojt } else {
1189*b94b84caSDaniel Fojt ask("Patch creates file that already exists! %s -R? [y] ",
1190*b94b84caSDaniel Fojt reverse ? "Assume" : "Ignore");
1191*b94b84caSDaniel Fojt
1192*b94b84caSDaniel Fojt if (*buf == 'n') {
1193*b94b84caSDaniel Fojt ask("Apply anyway? [n]");
1194*b94b84caSDaniel Fojt if (*buf != 'y')
1195*b94b84caSDaniel Fojt /* Don't apply; error out. */
1196*b94b84caSDaniel Fojt skip_rest_of_patch = true;
1197*b94b84caSDaniel Fojt else
1198*b94b84caSDaniel Fojt /* Attempt to apply. */
1199*b94b84caSDaniel Fojt reverse_seen = true;
1200*b94b84caSDaniel Fojt reverse = !reverse;
1201*b94b84caSDaniel Fojt if (!pch_swap())
1202*b94b84caSDaniel Fojt fatal("lost hunk on alloc error!\n");
1203*b94b84caSDaniel Fojt } else {
1204*b94b84caSDaniel Fojt /*
1205*b94b84caSDaniel Fojt * They've opted to assume -R; effectively the
1206*b94b84caSDaniel Fojt * same as the first branch in this function,
1207*b94b84caSDaniel Fojt * but the decision is here rather than in a
1208*b94b84caSDaniel Fojt * prior patch/hunk as in that branch.
1209*b94b84caSDaniel Fojt */
1210*b94b84caSDaniel Fojt *remove = true;
1211*b94b84caSDaniel Fojt }
1212*b94b84caSDaniel Fojt }
1213*b94b84caSDaniel Fojt }
1214*b94b84caSDaniel Fojt
1215*b94b84caSDaniel Fojt /*
1216*b94b84caSDaniel Fojt * The return value indicates if we offered a chance to reverse but the
1217*b94b84caSDaniel Fojt * user declined. This keeps the main patch processor in the loop since
1218*b94b84caSDaniel Fojt * we've taken this out of the normal flow of hunk processing to
1219*b94b84caSDaniel Fojt * simplify logic a little bit.
1220*b94b84caSDaniel Fojt */
1221*b94b84caSDaniel Fojt return (reverse_seen);
1222*b94b84caSDaniel Fojt }
1223