diff options
author | steve <steve@FreeBSD.org> | 1997-06-29 06:55:02 +0000 |
---|---|---|
committer | steve <steve@FreeBSD.org> | 1997-06-29 06:55:02 +0000 |
commit | 4b6324645f7223db0870236240d6e99eb4cda757 (patch) | |
tree | b91e93b575aeb975e736e614eaf2a0d0f8ea461a /contrib/patch/patch.c | |
download | FreeBSD-src-4b6324645f7223db0870236240d6e99eb4cda757.zip FreeBSD-src-4b6324645f7223db0870236240d6e99eb4cda757.tar.gz |
Import of GNU patch version 2.4.
Diffstat (limited to 'contrib/patch/patch.c')
-rw-r--r-- | contrib/patch/patch.c | 1293 |
1 files changed, 1293 insertions, 0 deletions
diff --git a/contrib/patch/patch.c b/contrib/patch/patch.c new file mode 100644 index 0000000..e976204 --- /dev/null +++ b/contrib/patch/patch.c @@ -0,0 +1,1293 @@ +/* patch - a program to apply diffs to original files */ + +/* $Id: patch.c,v 1.22 1997/06/17 22:32:49 eggert Exp $ */ + +/* +Copyright 1984, 1985, 1986, 1987, 1988 Larry Wall +Copyright 1989, 1990, 1991, 1992, 1993, 1997 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. +If not, write to the Free Software Foundation, +59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ + +#define XTERN +#include <common.h> +#undef XTERN +#define XTERN extern +#include <argmatch.h> +#include <backupfile.h> +#include <getopt.h> +#include <inp.h> +#include <pch.h> +#include <util.h> +#include <version.h> + +#if HAVE_UTIME_H +# include <utime.h> +#endif +/* Some nonstandard hosts don't declare this structure even in <utime.h>. */ +#if ! HAVE_STRUCT_UTIMBUF +struct utimbuf +{ + time_t actime; + time_t modtime; +}; +#endif + +/* Output stream state. */ +struct outstate +{ + FILE *ofp; + int after_newline; + int zero_output; +}; + +/* procedures */ + +static FILE *create_output_file PARAMS ((char const *)); +static LINENUM locate_hunk PARAMS ((LINENUM)); +static bool apply_hunk PARAMS ((struct outstate *, LINENUM)); +static bool copy_till PARAMS ((struct outstate *, LINENUM)); +static bool patch_match PARAMS ((LINENUM, LINENUM, LINENUM, LINENUM)); +static bool similar PARAMS ((char const *, size_t, char const *, size_t)); +static bool spew_output PARAMS ((struct outstate *)); +static char const *make_temp PARAMS ((int)); +static int numeric_string PARAMS ((char const *, int, char const *)); +static void abort_hunk PARAMS ((void)); +static void cleanup PARAMS ((void)); +static void get_some_switches PARAMS ((void)); +static void init_output PARAMS ((char const *, struct outstate *)); +static void init_reject PARAMS ((char const *)); +static void reinitialize_almost_everything PARAMS ((void)); +static void usage PARAMS ((FILE *, int)) __attribute__((noreturn)); + +static int backup_if_mismatch; +static int remove_empty_files; + +/* TRUE if -R was specified on command line. */ +static int reverse_flag_specified; + +/* how many input lines have been irretractably output */ +static LINENUM last_frozen_line; + +static char const *do_defines; /* symbol to patch using ifdef, ifndef, etc. */ +static char const if_defined[] = "\n#ifdef %s\n"; +static char const not_defined[] = "#ifndef %s\n"; +static char const else_defined[] = "\n#else\n"; +static char const end_defined[] = "\n#endif /* %s */\n"; + +static int Argc; +static char * const *Argv; + +static FILE *rejfp; /* reject file pointer */ + +static char const *patchname; +static char *rejname; +static char const * volatile TMPREJNAME; + +static LINENUM last_offset; +static LINENUM maxfuzz = 2; + +static char serrbuf[BUFSIZ]; + +char const program_name[] = "patch"; + +/* Apply a set of diffs as appropriate. */ + +int main PARAMS ((int, char **)); + +int +main(argc,argv) +int argc; +char **argv; +{ + char const *val; + bool somefailed = FALSE; + struct outstate outstate; + + init_time (); + + setbuf(stderr, serrbuf); + + bufsize = 8 * 1024; + buf = xmalloc (bufsize); + + strippath = INT_MAX; + + posixly_correct = getenv ("POSIXLY_CORRECT") != 0; + backup_if_mismatch = ! posixly_correct; + patch_get = ((val = getenv ("PATCH_GET")) + ? numeric_string (val, 1, "PATCH_GET value") + : posixly_correct - 1); + + { + char const *v; + + v = getenv ("SIMPLE_BACKUP_SUFFIX"); + if (v && *v) + simple_backup_suffix = v; + + v = getenv ("PATCH_VERSION_CONTROL"); + if (! v) + v = getenv ("VERSION_CONTROL"); + if (v && *v) + backup_type = get_version (v); + } + + /* Cons up the names of the global temporary files. + Do this before `cleanup' can possibly be called (e.g. by `pfatal'). */ + TMPOUTNAME = make_temp ('o'); + TMPINNAME = make_temp ('i'); + TMPREJNAME = make_temp ('r'); + TMPPATNAME = make_temp ('p'); + + /* parse switches */ + Argc = argc; + Argv = argv; + get_some_switches(); + + init_output (outfile, &outstate); + + /* Make sure we clean up in case of disaster. */ + set_signals(0); + + for ( + open_patch_file (patchname); + there_is_another_patch(); + reinitialize_almost_everything() + ) { /* for each patch in patch file */ + int hunk = 0; + int failed = 0; + int mismatch = 0; + char *outname = outfile ? outfile : inname; + + if (!skip_rest_of_patch) + get_input_file (inname, outname); + + if (diff_type == ED_DIFF) { + outstate.zero_output = 0; + if (! dry_run) + { + do_ed_script (outstate.ofp); + if (! outfile) + { + struct stat statbuf; + if (stat (TMPOUTNAME, &statbuf) != 0) + pfatal ("%s", TMPOUTNAME); + outstate.zero_output = statbuf.st_size == 0; + } + } + } else { + int got_hunk; + int apply_anyway = 0; + + /* initialize the patched file */ + if (! skip_rest_of_patch && ! outfile) + init_output (TMPOUTNAME, &outstate); + + /* initialize reject file */ + init_reject(TMPREJNAME); + + /* find out where all the lines are */ + if (!skip_rest_of_patch) + scan_input (inname); + + /* from here on, open no standard i/o files, because malloc */ + /* might misfire and we can't catch it easily */ + + /* apply each hunk of patch */ + while (0 < (got_hunk = another_hunk (diff_type, reverse))) { + LINENUM where = 0; /* Pacify `gcc -Wall'. */ + LINENUM newwhere; + LINENUM fuzz = 0; + LINENUM prefix_context = pch_prefix_context (); + LINENUM suffix_context = pch_suffix_context (); + LINENUM context = (prefix_context < suffix_context + ? suffix_context : prefix_context); + LINENUM mymaxfuzz = (maxfuzz < context ? maxfuzz : context); + hunk++; + if (!skip_rest_of_patch) { + do { + where = locate_hunk(fuzz); + if (! where || fuzz || last_offset) + mismatch = 1; + if (hunk == 1 && ! where && ! (force | apply_anyway) + && reverse == reverse_flag_specified) { + /* dwim for reversed patch? */ + if (!pch_swap()) { + say ( +"Not enough memory to try swapped hunk! Assuming unswapped.\n"); + continue; + } + /* Try again. */ + where = locate_hunk (fuzz); + if (where + && (ok_to_reverse + ("%s patch detected!", + (reverse + ? "Unreversed" + : "Reversed (or previously applied)")))) + reverse ^= 1; + else + { + /* Put it back to normal. */ + if (! pch_swap ()) + fatal ("lost hunk on alloc error!"); + if (where) + { + apply_anyway = 1; + fuzz--; /* Undo `++fuzz' below. */ + where = 0; + } + } + } + } while (!skip_rest_of_patch && !where + && ++fuzz <= mymaxfuzz); + + if (skip_rest_of_patch) { /* just got decided */ + if (outstate.ofp && ! outfile) + { + fclose (outstate.ofp); + outstate.ofp = 0; + } + } + } + + newwhere = pch_newfirst() + last_offset; + if (skip_rest_of_patch) { + abort_hunk(); + failed++; + if (verbosity == VERBOSE) + say ("Hunk #%d ignored at %ld.\n", hunk, newwhere); + } + else if (!where + || (where == 1 && pch_says_nonexistent (reverse) + && instat.st_size)) { + if (where) + say ("Patch attempted to create file `%s', which already exists.\n", inname); + abort_hunk(); + failed++; + if (verbosity != SILENT) + say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere); + } + else if (! apply_hunk (&outstate, where)) { + abort_hunk (); + failed++; + if (verbosity != SILENT) + say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere); + } else { + if (verbosity == VERBOSE + || (verbosity != SILENT && (fuzz || last_offset))) { + say ("Hunk #%d succeeded at %ld", hunk, newwhere); + if (fuzz) + say (" with fuzz %ld", fuzz); + if (last_offset) + say (" (offset %ld line%s)", + last_offset, last_offset==1?"":"s"); + say (".\n"); + } + } + } + + if (got_hunk < 0 && using_plan_a) { + if (outfile) + fatal ("out of memory using Plan A"); + say ("\n\nRan out of memory using Plan A -- trying again...\n\n"); + if (outstate.ofp) + { + fclose (outstate.ofp); + outstate.ofp = 0; + } + fclose (rejfp); + continue; + } + + /* finish spewing out the new file */ + if (!skip_rest_of_patch) + { + assert (hunk); + if (! spew_output (&outstate)) + { + say ("Skipping patch.\n"); + skip_rest_of_patch = TRUE; + } + } + } + + /* and put the output where desired */ + ignore_signals (); + if (! skip_rest_of_patch && ! outfile) { + if (outstate.zero_output + && (remove_empty_files + || (pch_says_nonexistent (reverse ^ 1) == 2 + && ! posixly_correct))) + { + if (verbosity == VERBOSE) + say ("Removing file `%s'%s.\n", outname, + dry_run ? " and any empty ancestor directories" : ""); + if (! dry_run) + { + move_file ((char *) 0, outname, (mode_t) 0, + (backup_type != none + || (backup_if_mismatch && (mismatch | failed)))); + removedirs (outname); + } + } + else + { + if (! outstate.zero_output + && pch_says_nonexistent (reverse ^ 1)) + { + mismatch = 1; + if (verbosity != SILENT) + say ("File `%s' is not empty after patch, as expected.\n", + outname); + } + + if (! dry_run) + { + time_t t; + + move_file (TMPOUTNAME, outname, instat.st_mode, + (backup_type != none + || (backup_if_mismatch && (mismatch | failed)))); + + if ((set_time | set_utc) + && (t = pch_timestamp (reverse ^ 1)) != (time_t) -1) + { + struct utimbuf utimbuf; + utimbuf.actime = utimbuf.modtime = t; + + if (! force && ! inerrno + && ! pch_says_nonexistent (reverse) + && (t = pch_timestamp (reverse)) != (time_t) -1 + && t != instat.st_mtime) + say ("not setting time of file `%s' (time mismatch)\n", + outname); + else if (! force && (mismatch | failed)) + say ("not setting time of file `%s' (contents mismatch)\n", + outname); + else if (utime (outname, &utimbuf) != 0) + pfatal ("can't set timestamp on file `%s'", outname); + } + + if (! inerrno && chmod (outname, instat.st_mode) != 0) + pfatal ("can't set permissions on file `%s'", outname); + } + } + } + if (diff_type != ED_DIFF) { + if (fclose (rejfp) != 0) + write_fatal (); + if (failed) { + somefailed = TRUE; + say ("%d out of %d hunk%s %s", failed, hunk, "s" + (hunk == 1), + skip_rest_of_patch ? "ignored" : "FAILED"); + if (outname) { + char *rej = rejname; + if (!rejname) { + rej = xmalloc (strlen (outname) + 5); + strcpy (rej, outname); + addext (rej, ".rej", '#'); + } + say (" -- saving rejects to %s", rej); + if (! dry_run) + { + move_file (TMPREJNAME, rej, instat.st_mode, FALSE); + if (! inerrno + && (chmod (rej, (instat.st_mode + & ~(S_IXUSR|S_IXGRP|S_IXOTH))) + != 0)) + pfatal ("can't set permissions on file `%s'", rej); + } + if (!rejname) + free (rej); + } + say ("\n"); + } + } + set_signals (1); + } + if (outstate.ofp && (ferror (outstate.ofp) || fclose (outstate.ofp) != 0)) + write_fatal (); + cleanup (); + if (somefailed) + exit (1); + return 0; +} + +/* Prepare to find the next patch to do in the patch file. */ + +static void +reinitialize_almost_everything() +{ + re_patch(); + re_input(); + + input_lines = 0; + last_frozen_line = 0; + + if (inname) { + free (inname); + inname = 0; + } + + last_offset = 0; + + diff_type = NO_DIFF; + + if (revision) { + free(revision); + revision = 0; + } + + reverse = reverse_flag_specified; + skip_rest_of_patch = FALSE; +} + +static char const shortopts[] = "bB:cd:D:eEfF:g:i:lnNo:p:r:RstTuvV:x:Y:z:Z"; +static struct option const longopts[] = +{ + {"backup", no_argument, NULL, 'b'}, + {"prefix", required_argument, NULL, 'B'}, + {"context", no_argument, NULL, 'c'}, + {"directory", required_argument, NULL, 'd'}, + {"ifdef", required_argument, NULL, 'D'}, + {"ed", no_argument, NULL, 'e'}, + {"remove-empty-files", no_argument, NULL, 'E'}, + {"force", no_argument, NULL, 'f'}, + {"fuzz", required_argument, NULL, 'F'}, + {"get", no_argument, NULL, 'g'}, + {"input", required_argument, NULL, 'i'}, + {"ignore-whitespace", no_argument, NULL, 'l'}, + {"normal", no_argument, NULL, 'n'}, + {"forward", no_argument, NULL, 'N'}, + {"output", required_argument, NULL, 'o'}, + {"strip", required_argument, NULL, 'p'}, + {"reject-file", required_argument, NULL, 'r'}, + {"reverse", no_argument, NULL, 'R'}, + {"quiet", no_argument, NULL, 's'}, + {"silent", no_argument, NULL, 's'}, + {"batch", no_argument, NULL, 't'}, + {"set-time", no_argument, NULL, 'T'}, + {"unified", no_argument, NULL, 'u'}, + {"version", no_argument, NULL, 'v'}, + {"version-control", required_argument, NULL, 'V'}, + {"debug", required_argument, NULL, 'x'}, + {"basename-prefix", required_argument, NULL, 'Y'}, + {"suffix", required_argument, NULL, 'z'}, + {"set-utc", no_argument, NULL, 'Z'}, + {"dry-run", no_argument, NULL, 129}, + {"verbose", no_argument, NULL, 130}, + {"binary", no_argument, NULL, 131}, + {"help", no_argument, NULL, 132}, + {"backup-if-mismatch", no_argument, NULL, 133}, + {"no-backup-if-mismatch", no_argument, NULL, 134}, + {NULL, no_argument, NULL, 0} +}; + +static char const *const option_help[] = +{ +"Input options:", +"", +" -p NUM --strip=NUM Strip NUM leading components from file names.", +" -F LINES --fuzz LINES Set the fuzz factor to LINES for inexact matching.", +" -l --ignore-whitespace Ignore white space changes between patch and input.", +"", +" -c --context Interpret the patch as a context difference.", +" -e --ed Interpret the patch as an ed script.", +" -n --normal Interpret the patch as a normal difference.", +" -u --unified Interpret the patch as a unified difference.", +"", +" -N --forward Ignore patches that appear to be reversed or already applied.", +" -R --reverse Assume patches were created with old and new files swapped.", +"", +" -i PATCHFILE --input=PATCHFILE Read patch from PATCHFILE instead of stdin.", +"", +"Output options:", +"", +" -o FILE --output=FILE Output patched files to FILE.", +" -r FILE --reject-file=FILE Output rejects to FILE.", +"", +" -D NAME --ifdef=NAME Make merged if-then-else output using NAME.", +" -E --remove-empty-files Remove output files that are empty after patching.", +"", +" -Z --set-utc Set times of patched files, assuming diff uses UTC (GMT).", +" -T --set-time Likewise, assuming local time.", +"", +"Backup and version control options:", +"", +" -V STYLE --version-control=STYLE Use STYLE version control.", +" STYLE is either 'simple', 'numbered', or 'existing'.", +"", +" -b --backup Back up the original contents of each file.", +" --backup-if-mismatch Back up if the patch does not match exactly.", +" --no-backup-if-mismatch Back up mismatches only if otherwise requested.", +" -B PREFIX --prefix=PREFIX Prepend PREFIX to backup file names.", +" -Y PREFIX --basename-prefix=PREFIX Prepend PREFIX to backup file basenames.", +" -z SUFFIX --suffix=SUFFIX Append SUFFIX to backup file names.", +"", +" -g NUM --get=NUM Get files from RCS or SCCS if positive; ask if negative.", +"", +"Miscellaneous options:", +"", +" -t --batch Ask no questions; skip bad-Prereq patches; assume reversed.", +" -f --force Like -t, but ignore bad-Prereq patches, and assume unreversed.", +" -s --quiet --silent Work silently unless an error occurs.", +" --verbose Output extra information about the work being done.", +" --dry-run Do not actually change any files; just print what would happen.", +"", +" -d DIR --directory=DIR Change the working directory to DIR first.", +#if HAVE_SETMODE +" --binary Read and write data in binary mode.", +#else +" --binary Read and write data in binary mode (no effect on this platform).", +#endif +"", +" -v --version Output version info.", +" --help Output this help.", +"", +"Report bugs to <bug-gnu-utils@prep.ai.mit.edu>.", +0 +}; + +static void +usage (stream, status) + FILE *stream; + int status; +{ + char const * const *p; + + if (status != 0) + { + fprintf (stream, "%s: Try `%s --help' for more information.\n", + program_name, Argv[0]); + } + else + { + fprintf (stream, "Usage: %s [OPTION]... [ORIGFILE [PATCHFILE]]\n\n", + Argv[0]); + for (p = option_help; *p; p++) + fprintf (stream, "%s\n", *p); + } + + exit (status); +} + +/* Process switches and filenames. */ + +static void +get_some_switches() +{ + register int optc; + + if (rejname) + free (rejname); + rejname = 0; + if (optind == Argc) + return; + while ((optc = getopt_long (Argc, Argv, shortopts, longopts, (int *) 0)) + != -1) { + switch (optc) { + case 'b': + /* Special hack for backward compatibility with CVS 1.9. + If the last 4 args are `-b SUFFIX ORIGFILE PATCHFILE', + treat `-b' as if it were `-z'. */ + if (Argc - optind == 3 + && strcmp (Argv[optind - 1], "-b") == 0 + && ! (Argv[optind + 0][0] == '-' && Argv[optind + 0][1]) + && ! (Argv[optind + 1][0] == '-' && Argv[optind + 1][1]) + && ! (Argv[optind + 2][0] == '-' && Argv[optind + 2][1])) + { + optarg = Argv[optind++]; + if (verbosity != SILENT) + say ("warning: the `-b %s' option is obsolete; use `-z %s' instead\n", + optarg, optarg); + goto case_z; + } + backup_type = simple; + break; + case 'B': + if (!*optarg) + fatal ("backup prefix is empty"); + origprae = savestr (optarg); + break; + case 'c': + diff_type = CONTEXT_DIFF; + break; + case 'd': + if (chdir(optarg) < 0) + pfatal ("can't change directory to `%s'", optarg); + break; + case 'D': + do_defines = savestr (optarg); + break; + case 'e': + diff_type = ED_DIFF; + break; + case 'E': + remove_empty_files = TRUE; + break; + case 'f': + force = TRUE; + break; + case 'F': + maxfuzz = numeric_string (optarg, 0, "fuzz factor"); + break; + case 'g': + patch_get = numeric_string (optarg, 1, "get option value"); + break; + case 'i': + patchname = savestr (optarg); + break; + case 'l': + canonicalize = TRUE; + break; + case 'n': + diff_type = NORMAL_DIFF; + break; + case 'N': + noreverse = TRUE; + break; + case 'o': + if (strcmp (optarg, "-") == 0) + fatal ("can't output patches to standard output"); + outfile = savestr (optarg); + break; + case 'p': + strippath = numeric_string (optarg, 0, "strip count"); + break; + case 'r': + rejname = savestr (optarg); + break; + case 'R': + reverse = 1; + reverse_flag_specified = 1; + break; + case 's': + verbosity = SILENT; + break; + case 't': + batch = TRUE; + break; + case 'T': + set_time = 1; + break; + case 'u': + diff_type = UNI_DIFF; + break; + case 'v': + version(); + exit (0); + break; + case 'V': + backup_type = get_version (optarg); + break; +#if DEBUGGING + case 'x': + debug = numeric_string (optarg, 1, "debugging option"); + break; +#endif + case 'Y': + if (!*optarg) + fatal ("backup basename prefix is empty"); + origbase = savestr (optarg); + break; + case 'z': + case_z: + if (!*optarg) + fatal ("backup suffix is empty"); + simple_backup_suffix = savestr (optarg); + break; + case 'Z': + set_utc = 1; + break; + case 129: + dry_run = TRUE; + break; + case 130: + verbosity = VERBOSE; + break; + case 131: +#if HAVE_SETMODE + binary_transput = O_BINARY; +#endif + break; + case 132: + usage (stdout, 0); + case 133: + backup_if_mismatch = 1; + break; + case 134: + backup_if_mismatch = 0; + break; + default: + usage (stderr, 2); + } + } + + /* Process any filename args. */ + if (optind < Argc) + { + inname = savestr (Argv[optind++]); + invc = -1; + if (optind < Argc) + { + patchname = savestr (Argv[optind++]); + if (optind < Argc) + { + fprintf (stderr, "%s: extra operand `%s'\n", + program_name, Argv[optind]); + usage (stderr, 2); + } + } + } +} + +/* Handle STRING (possibly negative if NEGATIVE_ALLOWED is nonzero) + of type ARGTYPE_MSGID by converting it to an integer, + returning the result. */ +static int +numeric_string (string, negative_allowed, argtype_msgid) + char const *string; + int negative_allowed; + char const *argtype_msgid; +{ + int value = 0; + char const *p = string; + int sign = *p == '-' ? -1 : 1; + + p += *p == '-' || *p == '+'; + + do + { + int v10 = value * 10; + int digit = *p - '0'; + int signed_digit = sign * digit; + int next_value = v10 + signed_digit; + + if (9 < (unsigned) digit) + fatal ("%s `%s' is not a number", argtype_msgid, string); + + if (v10 / 10 != value || (next_value < v10) != (signed_digit < 0)) + fatal ("%s `%s' is too large", argtype_msgid, string); + + value = next_value; + } + while (*++p); + + if (value < 0 && ! negative_allowed) + fatal ("%s `%s' is negative", argtype_msgid, string); + + return value; +} + +/* Attempt to find the right place to apply this hunk of patch. */ + +static LINENUM +locate_hunk(fuzz) +LINENUM fuzz; +{ + register LINENUM first_guess = pch_first () + last_offset; + register LINENUM offset; + LINENUM pat_lines = pch_ptrn_lines(); + LINENUM prefix_context = pch_prefix_context (); + LINENUM suffix_context = pch_suffix_context (); + LINENUM context = (prefix_context < suffix_context + ? suffix_context : prefix_context); + LINENUM prefix_fuzz = fuzz + prefix_context - context; + LINENUM suffix_fuzz = fuzz + suffix_context - context; + LINENUM max_where = input_lines - (pat_lines - suffix_fuzz) + 1; + LINENUM min_where = last_frozen_line + 1 - (prefix_context - prefix_fuzz); + LINENUM max_pos_offset = max_where - first_guess; + LINENUM max_neg_offset = first_guess - min_where; + LINENUM max_offset = (max_pos_offset < max_neg_offset + ? max_neg_offset : max_pos_offset); + + if (!pat_lines) /* null range matches always */ + return first_guess; + + /* Do not try lines <= 0. */ + if (first_guess <= max_neg_offset) + max_neg_offset = first_guess - 1; + + if (prefix_fuzz < 0) + { + /* Can only match start of file. */ + + if (suffix_fuzz < 0) + /* Can only match entire file. */ + if (pat_lines != input_lines || prefix_context < last_frozen_line) + return 0; + + offset = 1 - first_guess; + return + ((last_frozen_line <= prefix_context + && offset <= max_pos_offset + && patch_match (first_guess, offset, (LINENUM) 0, suffix_fuzz)) + ? first_guess : 0); + } + + if (suffix_fuzz < 0) + { + /* Can only match end of file. */ + offset = first_guess - (input_lines - pat_lines + 1); + return + ((offset <= max_neg_offset + && patch_match (first_guess, -offset, prefix_fuzz, (LINENUM) 0)) + ? first_guess : 0); + } + + for (offset = 0; offset <= max_offset; offset++) { + if (offset <= max_pos_offset + && patch_match (first_guess, offset, prefix_fuzz, suffix_fuzz)) { + if (debug & 1) + say ("Offset changing from %ld to %ld\n", last_offset, offset); + last_offset = offset; + return first_guess+offset; + } + if (0 < offset && offset <= max_neg_offset + && patch_match (first_guess, -offset, prefix_fuzz, suffix_fuzz)) { + if (debug & 1) + say ("Offset changing from %ld to %ld\n", last_offset, -offset); + last_offset = -offset; + return first_guess-offset; + } + } + return 0; +} + +/* We did not find the pattern, dump out the hunk so they can handle it. */ + +static void +abort_hunk() +{ + register LINENUM i; + register LINENUM pat_end = pch_end (); + /* add in last_offset to guess the same as the previous successful hunk */ + LINENUM oldfirst = pch_first() + last_offset; + LINENUM newfirst = pch_newfirst() + last_offset; + LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1; + LINENUM newlast = newfirst + pch_repl_lines() - 1; + char const *stars = + (int) NEW_CONTEXT_DIFF <= (int) diff_type ? " ****" : ""; + char const *minuses = + (int) NEW_CONTEXT_DIFF <= (int) diff_type ? " ----" : " -----"; + + fprintf(rejfp, "***************\n"); + for (i=0; i<=pat_end; i++) { + switch (pch_char(i)) { + case '*': + if (oldlast < oldfirst) + fprintf(rejfp, "*** 0%s\n", stars); + else if (oldlast == oldfirst) + fprintf(rejfp, "*** %ld%s\n", oldfirst, stars); + else + fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst, oldlast, stars); + break; + case '=': + if (newlast < newfirst) + fprintf(rejfp, "--- 0%s\n", minuses); + else if (newlast == newfirst) + fprintf(rejfp, "--- %ld%s\n", newfirst, minuses); + else + fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses); + break; + case ' ': case '-': case '+': case '!': + fprintf (rejfp, "%c ", pch_char (i)); + /* fall into */ + case '\n': + pch_write_line (i, rejfp); + break; + default: + fatal ("fatal internal error in abort_hunk"); + } + if (ferror (rejfp)) + write_fatal (); + } +} + +/* We found where to apply it (we hope), so do it. */ + +static bool +apply_hunk (outstate, where) + struct outstate *outstate; + LINENUM where; +{ + register LINENUM old = 1; + register LINENUM lastline = pch_ptrn_lines (); + register LINENUM new = lastline+1; + register enum {OUTSIDE, IN_IFNDEF, IN_IFDEF, IN_ELSE} def_state = OUTSIDE; + register char const *R_do_defines = do_defines; + register LINENUM pat_end = pch_end (); + register FILE *fp = outstate->ofp; + + where--; + while (pch_char(new) == '=' || pch_char(new) == '\n') + new++; + + while (old <= lastline) { + if (pch_char(old) == '-') { + assert (outstate->after_newline); + if (! copy_till (outstate, where + old - 1)) + return FALSE; + if (R_do_defines) { + if (def_state == OUTSIDE) { + fprintf (fp, outstate->after_newline + if_defined, + R_do_defines); + def_state = IN_IFNDEF; + } + else if (def_state == IN_IFDEF) { + fprintf (fp, outstate->after_newline + else_defined); + def_state = IN_ELSE; + } + if (ferror (fp)) + write_fatal (); + outstate->after_newline = pch_write_line (old, fp); + outstate->zero_output = 0; + } + last_frozen_line++; + old++; + } + else if (new > pat_end) { + break; + } + else if (pch_char(new) == '+') { + if (! copy_till (outstate, where + old - 1)) + return FALSE; + if (R_do_defines) { + if (def_state == IN_IFNDEF) { + fprintf (fp, outstate->after_newline + else_defined); + def_state = IN_ELSE; + } + else if (def_state == OUTSIDE) { + fprintf (fp, outstate->after_newline + if_defined, + R_do_defines); + def_state = IN_IFDEF; + } + if (ferror (fp)) + write_fatal (); + } + outstate->after_newline = pch_write_line (new, fp); + outstate->zero_output = 0; + new++; + } + else if (pch_char(new) != pch_char(old)) { + if (debug & 1) + say ("oldchar = '%c', newchar = '%c'\n", + pch_char (old), pch_char (new)); + fatal ("Out-of-sync patch, lines %ld,%ld -- mangled text or line numbers, maybe?", + pch_hunk_beg() + old, + pch_hunk_beg() + new); + } + else if (pch_char(new) == '!') { + assert (outstate->after_newline); + if (! copy_till (outstate, where + old - 1)) + return FALSE; + assert (outstate->after_newline); + if (R_do_defines) { + fprintf (fp, not_defined, R_do_defines); + if (ferror (fp)) + write_fatal (); + def_state = IN_IFNDEF; + } + + do + { + if (R_do_defines) { + outstate->after_newline = pch_write_line (old, fp); + } + last_frozen_line++; + old++; + } + while (pch_char (old) == '!'); + + if (R_do_defines) { + fprintf (fp, outstate->after_newline + else_defined); + if (ferror (fp)) + write_fatal (); + def_state = IN_ELSE; + } + + do + { + outstate->after_newline = pch_write_line (new, fp); + new++; + } + while (pch_char (new) == '!'); + outstate->zero_output = 0; + } + else { + assert(pch_char(new) == ' '); + old++; + new++; + if (R_do_defines && def_state != OUTSIDE) { + fprintf (fp, outstate->after_newline + end_defined, + R_do_defines); + if (ferror (fp)) + write_fatal (); + outstate->after_newline = 1; + def_state = OUTSIDE; + } + } + } + if (new <= pat_end && pch_char(new) == '+') { + if (! copy_till (outstate, where + old - 1)) + return FALSE; + if (R_do_defines) { + if (def_state == OUTSIDE) { + fprintf (fp, outstate->after_newline + if_defined, + R_do_defines); + def_state = IN_IFDEF; + } + else if (def_state == IN_IFNDEF) { + fprintf (fp, outstate->after_newline + else_defined); + def_state = IN_ELSE; + } + if (ferror (fp)) + write_fatal (); + outstate->zero_output = 0; + } + + do + { + if (! outstate->after_newline && putc ('\n', fp) == EOF) + write_fatal (); + outstate->after_newline = pch_write_line (new, fp); + outstate->zero_output = 0; + new++; + } + while (new <= pat_end && pch_char (new) == '+'); + } + if (R_do_defines && def_state != OUTSIDE) { + fprintf (fp, outstate->after_newline + end_defined, R_do_defines); + if (ferror (fp)) + write_fatal (); + outstate->after_newline = 1; + } + return TRUE; +} + +/* Create an output file. */ + +static FILE * +create_output_file (name) + char const *name; +{ + int fd = create_file (name, O_WRONLY | binary_transput, instat.st_mode); + FILE *f = fdopen (fd, binary_transput ? "wb" : "w"); + if (! f) + pfatal ("can't create `%s'", name); + return f; +} + +/* Open the new file. */ + +static void +init_output (name, outstate) + char const *name; + struct outstate *outstate; +{ + outstate->ofp = name ? create_output_file (name) : (FILE *) 0; + outstate->after_newline = 1; + outstate->zero_output = 1; +} + +/* Open a file to put hunks we can't locate. */ + +static void +init_reject(name) + char const *name; +{ + rejfp = create_output_file (name); +} + +/* Copy input file to output, up to wherever hunk is to be applied. */ + +static bool +copy_till (outstate, lastline) + register struct outstate *outstate; + register LINENUM lastline; +{ + register LINENUM R_last_frozen_line = last_frozen_line; + register FILE *fp = outstate->ofp; + register char const *s; + size_t size; + + if (R_last_frozen_line > lastline) + { + say ("misordered hunks! output would be garbled\n"); + return FALSE; + } + while (R_last_frozen_line < lastline) + { + s = ifetch (++R_last_frozen_line, 0, &size); + if (size) + { + if ((! outstate->after_newline && putc ('\n', fp) == EOF) + || ! fwrite (s, sizeof *s, size, fp)) + write_fatal (); + outstate->after_newline = s[size - 1] == '\n'; + outstate->zero_output = 0; + } + } + last_frozen_line = R_last_frozen_line; + return TRUE; +} + +/* Finish copying the input file to the output file. */ + +static bool +spew_output (outstate) + struct outstate *outstate; +{ + if (debug & 256) + say ("il=%ld lfl=%ld\n", input_lines, last_frozen_line); + + if (last_frozen_line < input_lines) + if (! copy_till (outstate, input_lines)) + return FALSE; + + if (outstate->ofp && ! outfile) + { + if (fclose (outstate->ofp) != 0) + write_fatal (); + outstate->ofp = 0; + } + + return TRUE; +} + +/* Does the patch pattern match at line base+offset? */ + +static bool +patch_match (base, offset, prefix_fuzz, suffix_fuzz) +LINENUM base; +LINENUM offset; +LINENUM prefix_fuzz; +LINENUM suffix_fuzz; +{ + register LINENUM pline = 1 + prefix_fuzz; + register LINENUM iline; + register LINENUM pat_lines = pch_ptrn_lines () - suffix_fuzz; + size_t size; + register char const *p; + + for (iline=base+offset+prefix_fuzz; pline <= pat_lines; pline++,iline++) { + p = ifetch (iline, offset >= 0, &size); + if (canonicalize) { + if (!similar(p, size, + pfetch(pline), + pch_line_len(pline) )) + return FALSE; + } + else if (size != pch_line_len (pline) + || memcmp (p, pfetch (pline), size) != 0) + return FALSE; + } + return TRUE; +} + +/* Do two lines match with canonicalized white space? */ + +static bool +similar (a, alen, b, blen) + register char const *a; + register size_t alen; + register char const *b; + register size_t blen; +{ + /* Ignore presence or absence of trailing newlines. */ + alen -= alen && a[alen - 1] == '\n'; + blen -= blen && b[blen - 1] == '\n'; + + for (;;) + { + if (!blen || (*b == ' ' || *b == '\t')) + { + while (blen && (*b == ' ' || *b == '\t')) + b++, blen--; + if (alen) + { + if (!(*a == ' ' || *a == '\t')) + return FALSE; + do a++, alen--; + while (alen && (*a == ' ' || *a == '\t')); + } + if (!alen || !blen) + return alen == blen; + } + else if (!alen || *a++ != *b++) + return FALSE; + else + alen--, blen--; + } +} + +/* Make a temporary file. */ + +#if HAVE_MKTEMP +char *mktemp PARAMS ((char *)); +#endif + +#ifndef TMPDIR +#define TMPDIR "/tmp" +#endif + +static char const * +make_temp (letter) + int letter; +{ + char *r; +#if HAVE_MKTEMP + char const *tmpdir = getenv ("TMPDIR"); /* Unix tradition */ + if (!tmpdir) tmpdir = getenv ("TMP"); /* DOS tradition */ + if (!tmpdir) tmpdir = getenv ("TEMP"); /* another DOS tradition */ + if (!tmpdir) tmpdir = TMPDIR; + r = xmalloc (strlen (tmpdir) + 10); + sprintf (r, "%s/p%cXXXXXX", tmpdir, letter); + mktemp (r); + if (!*r) + pfatal ("mktemp"); +#else + r = xmalloc (L_tmpnam); + if (! (tmpnam (r) == r && *r)) + pfatal ("tmpnam"); +#endif + return r; +} + +/* Fatal exit with cleanup. */ + +void +fatal_exit (sig) + int sig; +{ + cleanup (); + + if (sig) + exit_with_signal (sig); + + exit (2); +} + +static void +cleanup () +{ + unlink (TMPINNAME); + unlink (TMPOUTNAME); + unlink (TMPPATNAME); + unlink (TMPREJNAME); +} |