diff options
Diffstat (limited to 'patch.c')
| -rw-r--r-- | patch.c | 1256 |
1 files changed, 719 insertions, 537 deletions
@@ -1,303 +1,255 @@ -char rcsid[] = - "$Header: patch.c,v 2.0.2.0 90/05/01 22:17:50 davison Locked $"; - -/* patch - a program to apply diffs to original files - * - * Copyright 1986, Larry Wall - * - * This program may be copied as long as you don't try to make any - * money off of it, or pretend that you wrote it. - * - * $Log: patch.c,v $ - * Revision 2.0.2.0 90/05/01 22:17:50 davison - * patch12u: unidiff support added - * - * Revision 2.0.1.6 88/06/22 20:46:39 lwall - * patch12: rindex() wasn't declared - * - * Revision 2.0.1.5 88/06/03 15:09:37 lwall - * patch10: exit code improved. - * patch10: better support for non-flexfilenames. - * - * Revision 2.0.1.4 87/02/16 14:00:04 lwall - * Short replacement caused spurious "Out of sync" message. - * - * Revision 2.0.1.3 87/01/30 22:45:50 lwall - * Improved diagnostic on sync error. - * Moved do_ed_script() to pch.c. - * - * Revision 2.0.1.2 86/11/21 09:39:15 lwall - * Fuzz factor caused offset of installed lines. - * - * Revision 2.0.1.1 86/10/29 13:10:22 lwall - * Backwards search could terminate prematurely. - * - * Revision 2.0 86/09/17 15:37:32 lwall - * Baseline for netwide release. - * - * Revision 1.5 86/08/01 20:53:24 lwall - * Changed some %d's to %ld's. - * Linted. - * - * Revision 1.4 86/08/01 19:17:29 lwall - * Fixes for machines that can't vararg. - * Added fuzz factor. - * Generalized -p. - * General cleanup. - * - * 85/08/15 van%ucbmonet@berkeley - * Changes for 4.3bsd diff -c. - * - * Revision 1.3 85/03/26 15:07:43 lwall - * Frozen. - * - * Revision 1.2.1.9 85/03/12 17:03:35 lwall - * Changed pfp->_file to fileno(pfp). - * - * Revision 1.2.1.8 85/03/12 16:30:43 lwall - * Check i_ptr and i_womp to make sure they aren't null before freeing. - * Also allow ed output to be suppressed. - * - * Revision 1.2.1.7 85/03/12 15:56:13 lwall - * Added -p option from jromine@uci-750a. - * - * Revision 1.2.1.6 85/03/12 12:12:51 lwall - * Now checks for normalness of file to patch. - * - * Revision 1.2.1.5 85/03/12 11:52:12 lwall - * Added -D (#ifdef) option from joe@fluke. - * - * Revision 1.2.1.4 84/12/06 11:14:15 lwall - * Made smarter about SCCS subdirectories. - * - * Revision 1.2.1.3 84/12/05 11:18:43 lwall - * Added -l switch to do loose string comparison. - * - * Revision 1.2.1.2 84/12/04 09:47:13 lwall - * Failed hunk count not reset on multiple patch file. - * - * Revision 1.2.1.1 84/12/04 09:42:37 lwall - * Branch for sdcrdcf changes. - * - * Revision 1.2 84/11/29 13:29:51 lwall - * Linted. Identifiers uniqified. Fixed i_ptr malloc() bug. Fixed - * multiple calls to mktemp(). Will now work on machines that can only - * read 32767 chars. Added -R option for diffs with new and old swapped. - * Various cosmetic changes. - * - * Revision 1.1 84/11/09 17:03:58 lwall - * Initial revision - * - */ - -#include "INTERN.h" -#include "common.h" -#include "EXTERN.h" -#include "version.h" -#include "util.h" -#include "pch.h" -#include "inp.h" -#include "backupfile.h" -#include "getopt.h" +/* patch - a program to apply diffs to original files */ + +/* $Id: patch.c,v 1.11 1997/04/14 05:32:30 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> /* procedures */ -void reinitialize_almost_everything(); -void get_some_switches(); -LINENUM locate_hunk(); -void abort_hunk(); -void apply_hunk(); -void init_output(); -void init_reject(); -void copy_till(); -void spew_output(); -void dump_line(); -bool patch_match(); -bool similar(); -void re_input(); -void my_exit(); +static LINENUM locate_hunk PARAMS ((LINENUM, LINENUM)); +static bool apply_hunk PARAMS ((bool *, LINENUM)); +static bool copy_till PARAMS ((bool *, 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 ((bool *)); +static char const *make_temp PARAMS ((int)); +static int numeric_optarg PARAMS ((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 *)); +static void init_reject PARAMS ((char const *)); +static void reinitialize_almost_everything PARAMS ((void)); +static void usage PARAMS ((FILE *, int)) __attribute__((noreturn)); /* TRUE if -E was specified on command line. */ -static int remove_empty_files = FALSE; +static int remove_empty_files; /* TRUE if -R was specified on command line. */ -static int reverse_flag_specified = FALSE; +static int reverse_flag_specified; + +static bool backup; +static bool noreverse; + +/* 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 *ofp; /* output file pointer */ +static FILE *rejfp; /* reject file pointer */ + +static char *output; +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; { - LINENUM where; - LINENUM newwhere; - LINENUM fuzz; - LINENUM mymaxfuzz; - int hunk = 0; - int failed = 0; - int failtotal = 0; - bool rev_okayed = 0; - int i; + bool somefailed = FALSE; setbuf(stderr, serrbuf); - for (i = 0; i<MAXFILEC; i++) - filearg[i] = Nullch; - - myuid = getuid(); - /* Cons up the names of the temporary files. */ - { - /* Directory for temporary files. */ - char *tmpdir; - int tmpname_len; + bufsize = 8 * 1024; + buf = xmalloc (bufsize); - tmpdir = getenv ("TMPDIR"); - if (tmpdir == NULL) { - tmpdir = "/tmp"; - } - tmpname_len = strlen (tmpdir) + 20; - - TMPOUTNAME = (char *) malloc (tmpname_len); - strcpy (TMPOUTNAME, tmpdir); - strcat (TMPOUTNAME, "/patchoXXXXXX"); - Mktemp(TMPOUTNAME); - - TMPINNAME = (char *) malloc (tmpname_len); - strcpy (TMPINNAME, tmpdir); - strcat (TMPINNAME, "/patchiXXXXXX"); - Mktemp(TMPINNAME); - - TMPREJNAME = (char *) malloc (tmpname_len); - strcpy (TMPREJNAME, tmpdir); - strcat (TMPREJNAME, "/patchrXXXXXX"); - Mktemp(TMPREJNAME); - - TMPPATNAME = (char *) malloc (tmpname_len); - strcpy (TMPPATNAME, tmpdir); - strcat (TMPPATNAME, "/patchpXXXXXX"); - Mktemp(TMPPATNAME); - } + strippath = INT_MAX; { - char *v; + char const *v; v = getenv ("SIMPLE_BACKUP_SUFFIX"); - if (v) - simple_backup_suffix = v; - else - simple_backup_suffix = ".orig"; -#ifndef NODIR + if (v && *v) + { + simple_backup_suffix = v; + backup = TRUE; + } v = getenv ("VERSION_CONTROL"); + if (v && *v) + backup = TRUE; backup_type = get_version (v); /* OK to pass NULL. */ -#endif } /* parse switches */ Argc = argc; Argv = argv; get_some_switches(); - - /* make sure we clean up /tmp in case of disaster */ + + /* Cons up the names of the global temporary files. */ + TMPOUTNAME = make_temp ('o'); + TMPINNAME = make_temp ('i'); + TMPREJNAME = make_temp ('r'); + TMPPATNAME = make_temp ('p'); + + if (output) + init_output (output); + + /* Make sure we clean up in case of disaster. */ set_signals(0); for ( - open_patch_file(filearg[1]); + open_patch_file (patchname); there_is_another_patch(); reinitialize_almost_everything() ) { /* for each patch in patch file */ + int hunk = 0; + int failed = 0; + char const *outname = output ? output : inname; + + if (!skip_rest_of_patch) + get_input_file (inname, outname); + + if (diff_type == ED_DIFF) { + if (! dry_run) + do_ed_script (ofp); + } else { + int got_hunk; + bool rev_okayed = FALSE; + bool after_newline = TRUE; - if (outname == Nullch) - outname = savestr(filearg[0]); - - /* for ed script just up and do it and exit */ - if (diff_type == ED_DIFF) { - do_ed_script(); - continue; - } - /* initialize the patched file */ - if (!skip_rest_of_patch) + if (!skip_rest_of_patch && !output) init_output(TMPOUTNAME); - + /* initialize reject file */ init_reject(TMPREJNAME); - + /* find out where all the lines are */ if (!skip_rest_of_patch) - scan_input(filearg[0]); - + 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 */ - hunk = 0; - failed = 0; - rev_okayed = FALSE; - out_of_mem = FALSE; - while (another_hunk()) { + while (0 < (got_hunk = another_hunk (diff_type))) { + LINENUM where = 0; /* Pacify `gcc -Wall'. */ + LINENUM newwhere; + LINENUM fuzz = 0; + LINENUM max_prefix_fuzz = pch_prefix_context (); + LINENUM max_suffix_fuzz = pch_suffix_context (); hunk++; - fuzz = Nulline; - mymaxfuzz = pch_context(); - if (maxfuzz < mymaxfuzz) - mymaxfuzz = maxfuzz; + if (maxfuzz < max_prefix_fuzz) + max_prefix_fuzz = maxfuzz; + if (maxfuzz < max_suffix_fuzz) + max_suffix_fuzz = maxfuzz; if (!skip_rest_of_patch) { do { - where = locate_hunk(fuzz); - if (hunk == 1 && where == Nulline && !(force|rev_okayed)) { + LINENUM prefix_fuzz = + fuzz < max_prefix_fuzz ? fuzz : max_prefix_fuzz; + LINENUM suffix_fuzz = + fuzz < max_suffix_fuzz ? fuzz : max_suffix_fuzz; + where = locate_hunk (prefix_fuzz, suffix_fuzz); + if (hunk == 1 && !where && !(force|rev_okayed)) { /* dwim for reversed patch? */ if (!pch_swap()) { - if (fuzz == Nulline) - say1( + if (!fuzz) + say ( "Not enough memory to try swapped hunk! Assuming unswapped.\n"); continue; } reverse = !reverse; - where = locate_hunk(fuzz); /* try again */ - if (where == Nulline) { /* didn't find it swapped */ - if (!pch_swap()) /* put it back to normal */ - fatal1("lost hunk on alloc error!\n"); + /* Try again. */ + where = locate_hunk (prefix_fuzz, suffix_fuzz); + if (!where) { /* didn't find it swapped */ + if (!pch_swap()) /* put it back to normal */ + fatal ("lost hunk on alloc error!"); reverse = !reverse; } else if (noreverse) { - if (!pch_swap()) /* put it back to normal */ - fatal1("lost hunk on alloc error!\n"); + if (!pch_swap()) /* put it back to normal */ + fatal ("lost hunk on alloc error!"); reverse = !reverse; - say1( + say ( "Ignoring previously applied (or reversed) patch.\n"); skip_rest_of_patch = TRUE; } else if (batch) { - if (verbose) - say3( -"%seversed (or previously applied) patch detected! %s -R.", + if (verbosity != SILENT) + say ( +"%seversed (or previously applied) patch detected! %s -R.\n", reverse ? "R" : "Unr", reverse ? "Assuming" : "Ignoring"); } else { - ask3( + ask ( "%seversed (or previously applied) patch detected! %s -R? [y] ", reverse ? "R" : "Unr", reverse ? "Assume" : "Ignore"); if (*buf == 'n') { - ask1("Apply anyway? [n] "); + ask ("Apply anyway? [n] "); if (*buf == 'y') rev_okayed = TRUE; else skip_rest_of_patch = TRUE; - where = Nulline; + where = 0; reverse = !reverse; if (!pch_swap()) /* put it back to normal */ - fatal1("lost hunk on alloc error!\n"); + fatal ("lost hunk on alloc error!"); } } } - } while (!skip_rest_of_patch && where == Nulline && - ++fuzz <= mymaxfuzz); + } while (!skip_rest_of_patch && !where + && (++fuzz <= max_prefix_fuzz + || fuzz <= max_suffix_fuzz)); if (skip_rest_of_patch) { /* just got decided */ - Fclose(ofp); - ofp = Nullfp; + if (ofp && !output) + { + fclose (ofp); + ofp = 0; + } } } @@ -305,95 +257,115 @@ char **argv; if (skip_rest_of_patch) { abort_hunk(); failed++; - if (verbose) - say3("Hunk #%d ignored at %ld.\n", hunk, newwhere); + if (verbosity != SILENT) + say ("Hunk #%d ignored at %ld.\n", hunk, newwhere); } - else if (where == Nulline) { + else if (!where + || (where == 1 && ok_to_create_file && input_lines)) { + if (where) + say ("\nPatch attempted to create file `%s', which already exists.\n", inname); abort_hunk(); failed++; - if (verbose) - say3("Hunk #%d failed at %ld.\n", hunk, newwhere); + if (verbosity != SILENT) + say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere); } else { - apply_hunk(where); - if (verbose) { - say3("Hunk #%d succeeded at %ld", hunk, newwhere); + if (! apply_hunk (&after_newline, where)) { + abort_hunk (); + failed++; + if (verbosity != SILENT) + say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere); + } else if (verbosity == VERBOSE) { + say ("Hunk #%d succeeded at %ld", hunk, newwhere); if (fuzz) - say2(" with fuzz %ld", fuzz); + say (" with fuzz %ld", fuzz); if (last_offset) - say3(" (offset %ld line%s)", - last_offset, last_offset==1L?"":"s"); - say1(".\n"); + say (" (offset %ld line%s)", + last_offset, last_offset==1?"":"s"); + say (".\n"); } } } - if (out_of_mem && using_plan_a) { - optind = optind_last; - say1("\n\nRan out of memory using Plan A--trying again...\n\n"); + if (got_hunk < 0 && using_plan_a) { + if (output) + fatal ("out of memory using Plan A"); + say ("\n\nRan out of memory using Plan A--trying again...\n\n"); if (ofp) - Fclose(ofp); - ofp = Nullfp; - if (rejfp) - Fclose(rejfp); - rejfp = Nullfp; + { + fclose (ofp); + ofp = 0; + } + fclose (rejfp); continue; } - + assert(hunk); - + /* finish spewing out the new file */ if (!skip_rest_of_patch) - spew_output(); - - /* and put the output where desired */ - ignore_signals(); - if (!skip_rest_of_patch) { - struct stat statbuf; - char *realout = outname; - - if (move_file(TMPOUTNAME, outname) < 0) { - toutkeep = TRUE; - realout = TMPOUTNAME; - chmod(TMPOUTNAME, filemode); - } - else - chmod(outname, filemode); + skip_rest_of_patch = ! spew_output (&after_newline); + } - if (remove_empty_files && stat(realout, &statbuf) == 0 - && statbuf.st_size == 0) { - if (verbose) - say2("Removing %s (empty after patching).\n", realout); - while (unlink(realout) >= 0) ; /* while is for Eunice. */ + /* and put the output where desired */ + ignore_signals (); + if (!skip_rest_of_patch && !output) { + struct stat statbuf; + + if (remove_empty_files + && stat (TMPOUTNAME, &statbuf) == 0 + && statbuf.st_size == 0) + { + if (verbosity == VERBOSE) + say ("Removing %s (empty after patching).\n", outname); + if (! dry_run) + unlink (outname); } - } - Fclose(rejfp); - rejfp = Nullfp; - if (failed) { - failtotal += failed; - if (!*rejname) { - Strcpy(rejname, outname); - addext(rejname, ".rej", '#'); - } - if (skip_rest_of_patch) { - say4("%d out of %d hunks ignored--saving rejects to %s\n", - failed, hunk, rejname); + else + { + if (! dry_run) + { + move_file (TMPOUTNAME, outname, backup); + chmod (outname, instat.st_mode); + } } - else { - say4("%d out of %d hunks failed--saving rejects to %s\n", - failed, hunk, rejname); + } + 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, FALSE); + if (!rejname) + free (rej); } - if (move_file(TMPREJNAME, rejname) < 0) - trejkeep = TRUE; + say ("\n"); } - set_signals(1); + } + set_signals (1); } - my_exit(failtotal); + if (ofp && (ferror (ofp) || fclose (ofp) != 0)) + write_fatal (); + cleanup (); + if (somefailed) + exit (1); + return 0; } /* Prepare to find the next patch to do in the patch file. */ -void +static void reinitialize_almost_everything() { re_patch(); @@ -402,107 +374,182 @@ reinitialize_almost_everything() input_lines = 0; last_frozen_line = 0; - filec = 0; - if (filearg[0] != Nullch && !out_of_mem) { - free(filearg[0]); - filearg[0] = Nullch; - } - - if (outname != Nullch) { - free(outname); - outname = Nullch; + if (inname) { + free (inname); + inname = 0; } last_offset = 0; - diff_type = 0; + diff_type = NO_DIFF; - if (revision != Nullch) { + if (revision) { free(revision); - revision = Nullch; + revision = 0; } reverse = reverse_flag_specified; skip_rest_of_patch = FALSE; - - get_some_switches(); - - if (filec >= 2) - fatal1("you may not change to a different patch file\n"); } -static char *shortopts = "-b:B:cd:D:eEfF:lnNo:p::r:RsStuvV:x:"; -static struct option longopts[] = +static char const shortopts[] = "bB:cd:D:eEfF:i:lnNo:p:r:RstuvV:x:Y:z:"; +static struct option const longopts[] = { - {"suffix", 1, NULL, 'b'}, - {"prefix", 1, NULL, 'B'}, - {"context", 0, NULL, 'c'}, - {"directory", 1, NULL, 'd'}, - {"ifdef", 1, NULL, 'D'}, - {"ed", 0, NULL, 'e'}, - {"remove-empty-files", 0, NULL, 'E'}, - {"force", 0, NULL, 'f'}, - {"fuzz", 1, NULL, 'F'}, - {"ignore-whitespace", 0, NULL, 'l'}, - {"normal", 0, NULL, 'n'}, - {"forward", 0, NULL, 'N'}, - {"output", 1, NULL, 'o'}, - {"strip", 2, NULL, 'p'}, - {"reject-file", 1, NULL, 'r'}, - {"reverse", 0, NULL, 'R'}, - {"quiet", 0, NULL, 's'}, - {"silent", 0, NULL, 's'}, - {"skip", 0, NULL, 'S'}, - {"batch", 0, NULL, 't'}, - {"unified", 0, NULL, 'u'}, - {"version", 0, NULL, 'v'}, - {"version-control", 1, NULL, 'V'}, - {"debug", 1, NULL, 'x'}, - {0, 0, 0, 0} + {"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'}, + {"help", no_argument, NULL, 'h'}, + {"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'}, + {"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'}, + {"dry-run", no_argument, NULL, 129}, + {"verbose", no_argument, NULL, 130}, + {NULL, no_argument, NULL, 0} }; -/* Process switches and filenames up to next '+' or end of list. */ +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.", +"", +"Backup file options:", +"", +" -V STYLE --version-control=STYLE Use STYLE version control.", +" STYLE is either 'simple', 'numbered', or 'existing'.", +"", +" -b --backup Save the original contents of each file F into F.orig.", +" -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.", +"", +"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.", +"", +" -v --version Output version info.", +" --help Output this help.", +0 +}; -void +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() { - Reg1 int optc; + register int optc; - rejname[0] = '\0'; - optind_last = optind; + if (rejname) + free (rejname); + rejname = 0; if (optind == Argc) return; while ((optc = getopt_long (Argc, Argv, shortopts, longopts, (int *) 0)) != -1) { - if (optc == 1) { - if (strEQ(optarg, "+")) - return; - if (filec == MAXFILEC) - fatal1("too many file arguments\n"); - filearg[filec++] = savestr(optarg); - } - else { - switch (optc) { + switch (optc) { case 'b': - simple_backup_suffix = savestr(optarg); + /* 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 = TRUE; + backup_type = simple; break; case 'B': - origprae = savestr(optarg); + if (!*optarg) + pfatal ("backup prefix is empty"); + origprae = savestr (optarg); + backup = TRUE; + backup_type = simple; break; case 'c': diff_type = CONTEXT_DIFF; break; case 'd': if (chdir(optarg) < 0) - pfatal2("can't cd to %s", optarg); + pfatal ("can't cd to %s", optarg); break; case 'D': - do_defines = TRUE; - if (!isalpha(*optarg) && '_' != *optarg) - fatal1("argument to -D is not an identifier\n"); - Sprintf(if_defined, "#ifdef %s\n", optarg); - Sprintf(not_defined, "#ifndef %s\n", optarg); - Sprintf(end_defined, "#endif /* %s */\n", optarg); + do_defines = savestr (optarg); break; case 'e': diff_type = ED_DIFF; @@ -514,7 +561,12 @@ get_some_switches() force = TRUE; break; case 'F': - maxfuzz = atoi(optarg); + maxfuzz = numeric_optarg ("fuzz factor"); + break; + case 'h': + usage (stdout, 0); + case 'i': + patchname = savestr (optarg); break; case 'l': canonicalize = TRUE; @@ -526,26 +578,22 @@ get_some_switches() noreverse = TRUE; break; case 'o': - outname = savestr(optarg); + if (strcmp (optarg, "-") == 0) + fatal ("cannot output patches to standard output"); + output = savestr (optarg); break; case 'p': - if (optarg) - strippath = atoi(optarg); - else - strippath = 0; + strippath = numeric_optarg ("strip count"); break; case 'r': - Strcpy(rejname, optarg); + rejname = savestr (optarg); break; case 'R': reverse = TRUE; reverse_flag_specified = TRUE; break; case 's': - verbose = FALSE; - break; - case 'S': - skip_rest_of_patch = TRUE; + verbosity = SILENT; break; case 't': batch = TRUE; @@ -555,105 +603,149 @@ get_some_switches() break; case 'v': version(); + exit (0); break; case 'V': -#ifndef NODIR + backup = TRUE; backup_type = get_version (optarg); -#endif break; -#ifdef DEBUGGING +#if DEBUGGING case 'x': - debug = atoi(optarg); + debug = numeric_optarg ("debugging option"); break; #endif + case 'Y': + if (!*optarg) + pfatal ("backup basename prefix is empty"); + origbase = savestr (optarg); + backup = TRUE; + backup_type = simple; + break; + case 'z': + case_z: + if (!*optarg) + pfatal ("backup suffix is empty"); + simple_backup_suffix = savestr (optarg); + backup = TRUE; + backup_type = simple; + break; + case 129: + dry_run = TRUE; + break; + case 130: + verbosity = VERBOSE; + break; default: - fprintf(stderr, "\ -Usage: %s [options] [origfile [patchfile]] [+ [options] [origfile]]...\n", - Argv[0]); - fprintf(stderr, "\ -Options:\n\ - [-ceEflnNRsStuv] [-b backup-ext] [-B backup-prefix] [-d directory]\n\ - [-D symbol] [-F max-fuzz] [-o out-file] [-p[strip-count]]\n\ - [-r rej-name] [-V {numbered,existing,simple}] [--context]\n\ - [--prefix=backup-prefix] [--suffix=backup-ext] [--ifdef=symbol]\n\ - [--directory=directory] [--ed] [--fuzz=max-fuzz] [--force] [--batch]\n\ - [--ignore-whitespace] [--forward] [--reverse] [--output=out-file]\n"); - fprintf(stderr, "\ - [--strip[=strip-count]] [--normal] [--reject-file=rej-name] [--skip]\n\ - [--remove-empty-files] [--quiet] [--silent] [--unified] [--version]\n\ - [--version-control={numbered,existing,simple}]\n"); - my_exit(1); - } + usage (stderr, 2); } } - /* Process any filename args given after "--". */ - for (; optind < Argc; ++optind) { - if (filec == MAXFILEC) - fatal1("too many file arguments\n"); - filearg[filec++] = savestr(Argv[optind]); + /* Process any filename args. */ + if (optind < Argc) + { + inname = savestr (Argv[optind++]); + 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 a numeric option of type ARGTYPE_MSGID by converting + optarg to a nonnegative integer, returning the result. */ +static int +numeric_optarg (argtype_msgid) + char const *argtype_msgid; +{ + int value = 0; + char const *p = optarg; + + do + { + int v10 = value * 10; + int digit = *p - '0'; + + if (9 < (unsigned) digit) + fatal ("%s `%s' is not a number", argtype_msgid, optarg); + + if (v10 / 10 != value || v10 + digit < v10) + fatal ("%s `%s' is too large", argtype_msgid, optarg); + + value = v10 + digit; } + while (*++p); + + return value; } /* Attempt to find the right place to apply this hunk of patch. */ -LINENUM -locate_hunk(fuzz) -LINENUM fuzz; +static LINENUM +locate_hunk (prefix_fuzz, suffix_fuzz) + LINENUM prefix_fuzz; + LINENUM suffix_fuzz; { - Reg1 LINENUM first_guess = pch_first() + last_offset; - Reg2 LINENUM offset; + register LINENUM first_guess = pch_first () + last_offset; + register LINENUM offset; LINENUM pat_lines = pch_ptrn_lines(); - Reg3 LINENUM max_pos_offset = input_lines - first_guess - - pat_lines + 1; - Reg4 LINENUM max_neg_offset = first_guess - last_frozen_line - 1 - + pch_context(); + register LINENUM max_pos_offset + = input_lines - first_guess - pat_lines + 1; + register LINENUM max_neg_offset + = first_guess - last_frozen_line - 1 + pch_prefix_context (); if (!pat_lines) /* null range matches always */ return first_guess; if (max_neg_offset >= first_guess) /* do not try lines < 0 */ max_neg_offset = first_guess - 1; - if (first_guess <= input_lines && patch_match(first_guess, Nulline, fuzz)) + if (first_guess <= input_lines + && patch_match (first_guess, (LINENUM) 0, prefix_fuzz, suffix_fuzz)) return first_guess; for (offset = 1; ; offset++) { - Reg5 bool check_after = (offset <= max_pos_offset); - Reg6 bool check_before = (offset <= max_neg_offset); + register bool check_after = offset <= max_pos_offset; + register bool check_before = offset <= max_neg_offset; - if (check_after && patch_match(first_guess, offset, fuzz)) { -#ifdef DEBUGGING + if (check_after + && patch_match (first_guess, offset, prefix_fuzz, suffix_fuzz)) { if (debug & 1) - say3("Offset changing from %ld to %ld\n", last_offset, offset); -#endif + say ("Offset changing from %ld to %ld\n", last_offset, offset); last_offset = offset; return first_guess+offset; } - else if (check_before && patch_match(first_guess, -offset, fuzz)) { -#ifdef DEBUGGING + else if (check_before + && patch_match (first_guess, -offset, + prefix_fuzz, suffix_fuzz)) { if (debug & 1) - say3("Offset changing from %ld to %ld\n", last_offset, -offset); -#endif + say ("Offset changing from %ld to %ld\n", last_offset, -offset); last_offset = -offset; return first_guess-offset; } else if (!check_before && !check_after) - return Nulline; + return 0; } } /* We did not find the pattern, dump out the hunk so they can handle it. */ -void +static void abort_hunk() { - Reg1 LINENUM i; - Reg2 LINENUM pat_end = pch_end(); + 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 *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : ""); - char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----"); + 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++) { @@ -674,52 +766,56 @@ abort_hunk() else fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses); break; - case '\n': - fprintf(rejfp, "%s", pfetch(i)); - break; case ' ': case '-': case '+': case '!': - fprintf(rejfp, "%c %s", pch_char(i), pfetch(i)); + fprintf (rejfp, "%c ", pch_char (i)); + /* fall into */ + case '\n': + pch_write_line (i, rejfp); break; default: - fatal1("fatal internal error in abort_hunk\n"); + fatal ("fatal internal error in abort_hunk"); } + if (ferror (rejfp)) + write_fatal (); } } /* We found where to apply it (we hope), so do it. */ -void -apply_hunk(where) +static bool +apply_hunk (after_newline, where) +bool *after_newline; LINENUM where; { - Reg1 LINENUM old = 1; - Reg2 LINENUM lastline = pch_ptrn_lines(); - Reg3 LINENUM new = lastline+1; -#define OUTSIDE 0 -#define IN_IFNDEF 1 -#define IN_IFDEF 2 -#define IN_ELSE 3 - Reg4 int def_state = OUTSIDE; - Reg5 bool R_do_defines = do_defines; - Reg6 LINENUM pat_end = pch_end(); + 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 = ofp; where--; while (pch_char(new) == '=' || pch_char(new) == '\n') new++; - + while (old <= lastline) { if (pch_char(old) == '-') { - copy_till(where + old - 1); + assert (*after_newline); + if (! copy_till (after_newline, where + old - 1)) + return FALSE; if (R_do_defines) { if (def_state == OUTSIDE) { - fputs(not_defined, ofp); + fprintf (fp, *after_newline + if_defined, R_do_defines); def_state = IN_IFNDEF; } else if (def_state == IN_IFDEF) { - fputs(else_defined, ofp); + fprintf (fp, *after_newline + else_defined); def_state = IN_ELSE; } - fputs(pfetch(old), ofp); + if (ferror (fp)) + write_fatal (); + *after_newline = pch_write_line (old, fp); } last_frozen_line++; old++; @@ -728,172 +824,216 @@ LINENUM where; break; } else if (pch_char(new) == '+') { - copy_till(where + old - 1); + if (! copy_till (after_newline, where + old - 1)) + return FALSE; if (R_do_defines) { if (def_state == IN_IFNDEF) { - fputs(else_defined, ofp); + fprintf (fp, *after_newline + else_defined); def_state = IN_ELSE; } else if (def_state == OUTSIDE) { - fputs(if_defined, ofp); + fprintf (fp, *after_newline + if_defined, R_do_defines); def_state = IN_IFDEF; } + if (ferror (fp)) + write_fatal (); } - fputs(pfetch(new), ofp); + *after_newline = pch_write_line (new, fp); new++; } else if (pch_char(new) != pch_char(old)) { - say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n", + 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); -#ifdef DEBUGGING - say3("oldchar = '%c', newchar = '%c'\n", - pch_char(old), pch_char(new)); -#endif - my_exit(1); } else if (pch_char(new) == '!') { - copy_till(where + old - 1); + assert (*after_newline); + if (! copy_till (after_newline, where + old - 1)) + return FALSE; + assert (*after_newline); if (R_do_defines) { - fputs(not_defined, ofp); + fprintf (fp, not_defined, R_do_defines); + if (ferror (fp)) + write_fatal (); def_state = IN_IFNDEF; } - while (pch_char(old) == '!') { + + do + { if (R_do_defines) { - fputs(pfetch(old), ofp); + *after_newline = pch_write_line (old, fp); } last_frozen_line++; old++; - } + } + while (pch_char (old) == '!'); + if (R_do_defines) { - fputs(else_defined, ofp); + fprintf (fp, *after_newline + else_defined); + if (ferror (fp)) + write_fatal (); def_state = IN_ELSE; } - while (pch_char(new) == '!') { - fputs(pfetch(new), ofp); + + do + { + *after_newline = pch_write_line (new, fp); new++; - } + } + while (pch_char (new) == '!'); } else { assert(pch_char(new) == ' '); old++; new++; if (R_do_defines && def_state != OUTSIDE) { - fputs(end_defined, ofp); + fprintf (fp, *after_newline + end_defined, R_do_defines); + if (ferror (fp)) + write_fatal (); + *after_newline = TRUE; def_state = OUTSIDE; } } } if (new <= pat_end && pch_char(new) == '+') { - copy_till(where + old - 1); + if (! copy_till (after_newline, where + old - 1)) + return FALSE; if (R_do_defines) { if (def_state == OUTSIDE) { - fputs(if_defined, ofp); + fprintf (fp, *after_newline + if_defined, R_do_defines); def_state = IN_IFDEF; } else if (def_state == IN_IFNDEF) { - fputs(else_defined, ofp); + fprintf (fp, *after_newline + else_defined); def_state = IN_ELSE; } + if (ferror (fp)) + write_fatal (); } - while (new <= pat_end && pch_char(new) == '+') { - fputs(pfetch(new), ofp); + + do + { + if (!*after_newline && putc ('\n', fp) == EOF) + write_fatal (); + *after_newline = pch_write_line (new, fp); new++; - } + } + while (new <= pat_end && pch_char (new) == '+'); } if (R_do_defines && def_state != OUTSIDE) { - fputs(end_defined, ofp); + fprintf (fp, *after_newline + end_defined, R_do_defines); + if (ferror (fp)) + write_fatal (); + *after_newline = TRUE; } + return TRUE; } /* Open the new file. */ -void +static void init_output(name) -char *name; + char const *name; { ofp = fopen(name, "w"); - if (ofp == Nullfp) - pfatal2("can't create %s", name); + if (! ofp) + pfatal ("can't create %s", name); } /* Open a file to put hunks we can't locate. */ -void +static void init_reject(name) -char *name; + char const *name; { rejfp = fopen(name, "w"); - if (rejfp == Nullfp) - pfatal2("can't create %s", name); + if (!rejfp) + pfatal ("can't create %s", name); } /* Copy input file to output, up to wherever hunk is to be applied. */ -void -copy_till(lastline) -Reg1 LINENUM lastline; +static bool +copy_till (after_newline, lastline) + register bool *after_newline; + register LINENUM lastline; { - Reg2 LINENUM R_last_frozen_line = last_frozen_line; + register LINENUM R_last_frozen_line = last_frozen_line; + register FILE *fp = ofp; + register char const *s; + size_t size; if (R_last_frozen_line > lastline) - fatal1("misordered hunks! output would be garbled\n"); - while (R_last_frozen_line < lastline) { - dump_line(++R_last_frozen_line); - } + { + 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 ((!*after_newline && putc ('\n', fp) == EOF) + || ! fwrite (s, sizeof *s, size, fp)) + write_fatal (); + *after_newline = s[size - 1] == '\n'; + } + } last_frozen_line = R_last_frozen_line; + return TRUE; } /* Finish copying the input file to the output file. */ -void -spew_output() +static bool +spew_output (after_newline) + bool *after_newline; { -#ifdef DEBUGGING if (debug & 256) - say3("il=%ld lfl=%ld\n",input_lines,last_frozen_line); -#endif - if (input_lines) - copy_till(input_lines); /* dump remainder of file */ - Fclose(ofp); - ofp = Nullfp; -} + say ("il=%ld lfl=%ld\n", input_lines, last_frozen_line); -/* Copy one line from input to output. */ + if (last_frozen_line < input_lines) + if (! copy_till (after_newline, input_lines)) + return FALSE; -void -dump_line(line) -LINENUM line; -{ - Reg1 char *s; - Reg2 char R_newline = '\n'; + if (ofp && !output) + { + if (fclose (ofp) != 0) + write_fatal (); + ofp = 0; + } - /* Note: string is not null terminated. */ - for (s=ifetch(line, 0); putc(*s, ofp) != R_newline; s++) ; + return TRUE; } /* Does the patch pattern match at line base+offset? */ -bool -patch_match(base, offset, fuzz) +static bool +patch_match (base, offset, prefix_fuzz, suffix_fuzz) LINENUM base; LINENUM offset; -LINENUM fuzz; +LINENUM prefix_fuzz; +LINENUM suffix_fuzz; { - Reg1 LINENUM pline = 1 + fuzz; - Reg2 LINENUM iline; - Reg3 LINENUM pat_lines = pch_ptrn_lines() - fuzz; - - for (iline=base+offset+fuzz; pline <= pat_lines; pline++,iline++) { + 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(ifetch(iline, (offset >= 0)), + if (!similar(p, size, pfetch(pline), pch_line_len(pline) )) return FALSE; } - else if (strnNE(ifetch(iline, (offset >= 0)), - pfetch(pline), - pch_line_len(pline) )) + else if (size != pch_line_len (pline) + || memcmp (p, pfetch (pline), size) != 0) return FALSE; } return TRUE; @@ -901,45 +1041,87 @@ LINENUM fuzz; /* Do two lines match with canonicalized white space? */ -bool -similar(a,b,len) -Reg1 char *a; -Reg2 char *b; -Reg3 int len; +static bool +similar (a, alen, b, blen) + register char const *a; + register size_t alen; + register char const *b; + register size_t blen; { - while (len) { - if (isspace(*b)) { /* whitespace (or \n) to match? */ - if (!isspace(*a)) /* no corresponding whitespace? */ + /* 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; - while (len && isspace(*b) && *b != '\n') - b++,len--; /* skip pattern whitespace */ - while (isspace(*a) && *a != '\n') - a++; /* skip target whitespace */ - if (*a == '\n' || *b == '\n') - return (*a == *b); /* should end in sync */ + do a++, alen--; + while (alen && (*a == ' ' || *a == '\t')); + } + if (!alen || !blen) + return alen == blen; } - else if (*a++ != *b++) /* match non-whitespace chars */ - return FALSE; - else - len--; /* probably not necessary */ + else if (!alen || *a++ != *b++) + return FALSE; + else + alen--, blen--; } - return TRUE; /* actually, this is not reached */ - /* since there is always a \n */ } -/* Exit with cleanup. */ +/* Make a temporary file. */ + +#if HAVE_MKTEMP +char *mktemp PARAMS ((char *)); +#endif + +static char const * +make_temp (letter) + int letter; +{ + char *r; +#if HAVE_MKTEMP + char const *tmpdir = getenv ("TMPDIR"); + if (!tmpdir) + tmpdir = "/tmp"; + r = xmalloc (strlen (tmpdir) + 14); + sprintf (r, "%s/patch%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 -my_exit(status) -int status; +fatal_exit (sig) + int sig; { - Unlink(TMPINNAME); - if (!toutkeep) { - Unlink(TMPOUTNAME); - } - if (!trejkeep) { - Unlink(TMPREJNAME); - } - Unlink(TMPPATNAME); - exit(status); + cleanup (); + + if (sig) + exit_with_signal (sig); + + exit (2); +} + +static void +cleanup () +{ + unlink (TMPINNAME); + unlink (TMPOUTNAME); + unlink (TMPPATNAME); + unlink (TMPREJNAME); } |