/usr/src/usr.bin/patch/pch.c

Bug Summary

File:	src/usr.bin/patch/pch.c
Warning:	line 1004, column 24 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name pch.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/patch/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/patch/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/patch/pch.c
1/*	$OpenBSD: pch.c,v 1.62 2019/12/02 22:23:19 jca Exp $	*/

3/*
* patch - a program to apply diffs to original files
* 
* Copyright 1986, Larry Wall
* 
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following condition is met:
* 1. Redistributions of source code must retain the above copyright notice,
* this condition and the following disclaimer.
* 
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* 
* -C option added in 1998, original code by Marc Espie, based on FreeBSD
* behaviour
*/

29#include <sys/types.h>
30#include <sys/stat.h>

32#include <ctype.h>
33#include <libgen.h>
34#include <limits.h>
35#include <stdint.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <unistd.h>

41#include "common.h"
42#include "util.h"
43#include "pch.h"

45/* Patch (diff listing) abstract type. */

47FILE	*pfp = NULL((void *)0);		/* patch file pointer */
48LINENUM	 p_input_line = 0;	/* current line # from patch file */

50static off_t	p_filesize;	/* size of the patch file */
51static LINENUM	p_first;	/* 1st line number */
52static LINENUM	p_newfirst;	/* 1st line number of replacement */
53static LINENUM	p_ptrn_lines;	/* # lines in pattern */
54static LINENUM	p_repl_lines;	/* # lines in replacement text */
55static LINENUM	p_end = -1;	/* last line in hunk */
56static LINENUM	p_max;		/* max allowed value of p_end */
57static LINENUM	p_context = 3;	/* # of context lines */
58static char	**p_line = NULL((void *)0);/* the text of the hunk */
59static short	*p_len = NULL((void *)0);	/* length of each line */
60static char	*p_char = NULL((void *)0);	/* +, -, and ! */
61static int	hunkmax = INITHUNKMAX125;	/* size of above arrays to begin with */
62static int	p_indent;	/* indent to patch */
63static off_t	p_base;		/* where to intuit this time */
64static LINENUM	p_bline;	/* line # of p_base */
65static off_t	p_start;	/* where intuit found a patch */
66static LINENUM	p_sline;	/* and the line number for it */
67static LINENUM	p_hunk_beg;	/* line number of current hunk */
68static LINENUM	p_efake = -1;	/* end of faked up lines--don't free */
69static LINENUM	p_bfake = -1;	/* beg of faked up lines */
70static char	*bestguess = NULL((void *)0);	/* guess at correct filename */

72static void	grow_hunkmax(void);
73static int	intuit_diff_type(void);
74static void	skip_to(off_t, LINENUM);
75static char	*best_name(const struct file_name *, bool_Bool);
76static char	*posix_name(const struct file_name *, bool_Bool);
77static size_t	num_components(const char *);

79/*
* Prepare to look for the next patch in the patch file.
*/
82void
83re_patch(void)
84{
p_first = 0;
p_newfirst = 0;
p_ptrn_lines = 0;
p_repl_lines = 0;
p_end = (LINENUM) - 1;
p_max = 0;
p_indent = 0;
92}

94/*
* Open the patch file at the beginning of time.
*/
97void
98open_patch_file(const char *filename)
99{
struct stat filestat;

if (filename == NULL((void *)0) || *filename == '\0' || strEQ(filename, "-")(!strcmp(filename, "-"))) {
pfp = fopen(TMPPATNAME, "w");
if (pfp == NULL((void *)0))
	pfatal("can't create %s", TMPPATNAME);
while (getline(&buf, &bufsz, stdin(&__sF[0])) != -1)
	fputs(buf, pfp);
fclose(pfp);
filename = TMPPATNAME;
}
pfp = fopen(filename, "r");
if (pfp == NULL((void *)0))
pfatal("patch file %s not found", filename);
if (fstat(fileno(pfp)(!__isthreaded ? ((pfp)->_file) : (fileno)(pfp)), &filestat))
pfatal("can't stat %s", filename);
p_filesize = filestat.st_size;
next_intuit_at(0, 1L);	/* start at the beginning */
set_hunkmax();
119}

121/*
* Make sure our dynamically realloced tables are malloced to begin with.
*/
124void
125set_hunkmax(void)
126{
if (p_line == NULL((void *)0))
p_line = calloc((size_t) hunkmax, sizeof(char *));
if (p_len == NULL((void *)0))
p_len = calloc((size_t) hunkmax, sizeof(short));
if (p_char == NULL((void *)0))
p_char = calloc((size_t) hunkmax, sizeof(char));
133}

135/*
* Enlarge the arrays containing the current hunk of patch.
*/
138static void
139grow_hunkmax(void)
140{
int		new_hunkmax;
char		**new_p_line;
short		*new_p_len;
char		*new_p_char;

new_hunkmax = hunkmax * 2;

if (p_line == NULL((void *)0) || p_len == NULL((void *)0) || p_char == NULL((void *)0))
fatal("Internal memory allocation error\n");

new_p_line = reallocarray(p_line, new_hunkmax, sizeof(char *));
if (new_p_line == NULL((void *)0))
free(p_line);

new_p_len = reallocarray(p_len, new_hunkmax, sizeof(short));
if (new_p_len == NULL((void *)0))
free(p_len);

new_p_char = recallocarray(p_char, hunkmax, new_hunkmax, sizeof(char));
if (new_p_char == NULL((void *)0))
free(p_char);

p_char = new_p_char;
p_len = new_p_len;
p_line = new_p_line;

if (p_line != NULL((void *)0) && p_len != NULL((void *)0) && p_char != NULL((void *)0)) {
hunkmax = new_hunkmax;
return;
}

if (!using_plan_a)
fatal("out of memory\n");
out_of_mem = true1;	/* whatever is null will be allocated again */
		/* from within plan_a(), of all places */
176}

178/* True if the remainder of the patch file contains a diff of some sort. */

180bool_Bool
181there_is_another_patch(void)
182{
bool_Bool exists = false0;

if (p_base != 0 && p_base >= p_filesize) {
if (verbose)
	say("done\n");
return false0;
}
if (verbose)
say("Hmm...");
diff_type = intuit_diff_type();
if (!diff_type) {
if (p_base != 0) {
	if (verbose)
		say("  Ignoring the trailing garbage.\ndone\n");
} else
	say("  I can't seem to find a patch in there anywhere.\n");
return false0;
}
if (verbose)
say("  %sooks like %s to me...\n",
    (p_base == 0 ? "L" : "The next patch l"),
    diff_type == UNI_DIFF5 ? "a unified diff" :
    diff_type == CONTEXT_DIFF1 ? "a context diff" :
diff_type == NEW_CONTEXT_DIFF4 ? "a new-style context diff" :
    diff_type == NORMAL_DIFF2 ? "a normal diff" :
    "an ed script");
if (p_indent && verbose)
say("(Patch is indented %d space%s.)\n", p_indent,
    p_indent == 1 ? "" : "s");
skip_to(p_start, p_sline);
while (filearg[0] == NULL((void *)0)) {
if (force || batch) {
	say("No file to patch.  Skipping...\n");
	filearg[0] = xstrdup(bestguess);
	skip_rest_of_patch = true1;
	return true1;
}
ask("File to patch: ");
if (*buf != '\n') {
	free(bestguess);
	bestguess = xstrdup(buf);
	filearg[0] = fetchname(buf, &exists, 0);
}
if (!exists) {
	int def_skip = *bestguess == '\0';
	ask("No file found--skip this patch? [%c] ",
	    def_skip  ? 'y' : 'n');
	if (*buf == 'n' || (!def_skip && *buf != 'y'))
		continue;
	if (verbose)
		say("Skipping patch...\n");
	free(filearg[0]);
	filearg[0] = fetchname(bestguess, &exists, 0);
	skip_rest_of_patch = true1;
	return true1;
}
}
return true1;
241}

243/* Determine what kind of diff is in the remaining part of the patch file. */

245static int
246intuit_diff_type(void)
247{
off_t	this_line = 0, previous_line;
off_t	first_command_line = -1;
LINENUM	fcl_line = -1;
bool_Bool	last_line_was_command = false0, this_is_a_command = false0;
bool_Bool	stars_last_line = false0, stars_this_line = false0;
char	*s, *t;
int	indent, retval;
struct file_name names[MAX_FILE3];
int	piece_of_git = 0;

memset(names, 0, sizeof(names));
ok_to_create_file = false0;
fseeko(pfp, p_base, SEEK_SET0);
p_input_line = p_bline - 1;
for (;;) {
previous_line = this_line;
last_line_was_command = this_is_a_command;
stars_last_line = stars_this_line;
this_line = ftello(pfp);
indent = 0;
p_input_line++;
if (getline(&buf, &bufsz, pfp) == -1) {
	if (first_command_line >= 0) {
		/* nothing but deletes!? */
		p_start = first_command_line;
		p_sline = fcl_line;
		retval = ED_DIFF3;
		goto scan_exit;
	} else {
		p_start = this_line;
		p_sline = p_input_line;
		retval = 0;
		goto scan_exit;
	}
}
for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
	if (*s == '\t')
		indent += 8 - (indent % 8);
	else
		indent++;
}
for (t = s; isdigit((unsigned char)*t) || *t == ','; t++)
	;
this_is_a_command = (isdigit((unsigned char)*s) &&
    (*t == 'd' || *t == 'c' || *t == 'a'));
if (first_command_line < 0 && this_is_a_command) {
	first_command_line = this_line;
	fcl_line = p_input_line;
	p_indent = indent;	/* assume this for now */
}
if (!stars_last_line && strnEQ(s, "*** ", 4)(!strncmp(s, "*** ", 4)))
	names[OLD_FILE0].path = fetchname(s + 4,
	    &names[OLD_FILE0].exists, strippath);
else if (strnEQ(s, "--- ", 4)(!strncmp(s, "--- ", 4))) {
	size_t off = 4;
	if (piece_of_git && strippath == 957 &&
	    strnEQ(s, "--- a/", 6)(!strncmp(s, "--- a/", 6)))
		off = 6;
	names[NEW_FILE1].path = fetchname(s + off,
	    &names[NEW_FILE1].exists, strippath);
} else if (strnEQ(s, "+++ ", 4)(!strncmp(s, "+++ ", 4))) {
	/* pretend it is the old name */
	size_t off = 4;
	if (piece_of_git && strippath == 957 &&
	    strnEQ(s, "+++ b/", 6)(!strncmp(s, "+++ b/", 6)))
		off = 6;
	names[OLD_FILE0].path = fetchname(s + off,
	    &names[OLD_FILE0].exists, strippath);
} else if (strnEQ(s, "Index:", 6)(!strncmp(s, "Index:", 6)))
	names[INDEX_FILE2].path = fetchname(s + 6,
	    &names[INDEX_FILE2].exists, strippath);
else if (strnEQ(s, "Prereq:", 7)(!strncmp(s, "Prereq:", 7))) {
	for (t = s + 7; isspace((unsigned char)*t); t++)
		;
	revision = xstrdup(t);
	for (t = revision;
	    *t && !isspace((unsigned char)*t); t++)
		;
	*t = '\0';
	if (*revision == '\0') {
		free(revision);
		revision = NULL((void *)0);
	}
} else if (strnEQ(s, "diff --git a/", 13)(!strncmp(s, "diff --git a/", 13)))
	piece_of_git = 1;
if ((!diff_type || diff_type == ED_DIFF3) &&
    first_command_line >= 0 &&
    strEQ(s, ".\n")(!strcmp(s, ".\n"))) {
	p_indent = indent;
	p_start = first_command_line;
	p_sline = fcl_line;
	retval = ED_DIFF3;
	goto scan_exit;
}
if ((!diff_type || diff_type == UNI_DIFF5) && strnEQ(s, "@@ -", 4)(!strncmp(s, "@@ -", 4))) {
	if (strnEQ(s + 4, "0,0", 3)(!strncmp(s + 4, "0,0", 3)))
		ok_to_create_file = true1;
	p_indent = indent;
	p_start = this_line;
	p_sline = p_input_line;
	retval = UNI_DIFF5;
	goto scan_exit;
}
stars_this_line = strnEQ(s, "********", 8)(!strncmp(s, "********", 8));
if ((!diff_type || diff_type == CONTEXT_DIFF1) && stars_last_line &&
    strnEQ(s, "*** ", 4)(!strncmp(s, "*** ", 4))) {
	if (strtolinenum(s + 4, &s) == 0)
		ok_to_create_file = true1;
	/*
	 * If this is a new context diff the character just
	 * at the end of the line is a '*'.
	 */
	while (*s && *s != '\n')
		s++;
	p_indent = indent;
	p_start = previous_line;
	p_sline = p_input_line - 1;
	retval = (*(s - 1) == '*' ? NEW_CONTEXT_DIFF4 : CONTEXT_DIFF1);
	goto scan_exit;
}
if ((!diff_type || diff_type == NORMAL_DIFF2) &&
    last_line_was_command &&
    (strnEQ(s, "< ", 2)(!strncmp(s, "< ", 2)) || strnEQ(s, "> ", 2)(!strncmp(s, "> ", 2)))) {
	p_start = previous_line;
	p_sline = p_input_line - 1;
	p_indent = indent;
	retval = NORMAL_DIFF2;
	goto scan_exit;
}
}
378scan_exit:
if (retval == UNI_DIFF5) {
/* unswap old and new */
struct file_name tmp = names[OLD_FILE0];
names[OLD_FILE0] = names[NEW_FILE1];
names[NEW_FILE1] = tmp;
}
if (filearg[0] == NULL((void *)0)) {
if (posix)
	filearg[0] = posix_name(names, ok_to_create_file);
else {
	/* Ignore the Index: name for context diffs, like GNU */
	if (names[OLD_FILE0].path != NULL((void *)0) ||
	    names[NEW_FILE1].path != NULL((void *)0)) {
		free(names[INDEX_FILE2].path);
		names[INDEX_FILE2].path = NULL((void *)0);
	}
	filearg[0] = best_name(names, ok_to_create_file);
}
}

free(bestguess);
bestguess = NULL((void *)0);
if (filearg[0] != NULL((void *)0))
bestguess = xstrdup(filearg[0]);
else if (!ok_to_create_file) {
/*
 * We don't want to create a new file but we need a
 * filename to set bestguess.  Avoid setting filearg[0]
 * so the file is not created automatically.
 */
if (posix)
	bestguess = posix_name(names, true1);
else
	bestguess = best_name(names, true1);
}
free(names[OLD_FILE0].path);
free(names[NEW_FILE1].path);
free(names[INDEX_FILE2].path);
return retval;
418}

420/*
* Remember where this patch ends so we know where to start up again.
*/
423void
424next_intuit_at(off_t file_pos, LINENUM file_line)
425{
p_base = file_pos;
p_bline = file_line;
428}

430/*
* Basically a verbose fseeko() to the actual diff listing.
*/
433static void
434skip_to(off_t file_pos, LINENUM file_line)
435{
int	ret;

if (p_base > file_pos)
fatal("Internal error: seek %lld>%lld\n",
    (long long)p_base, (long long)file_pos);
if (verbose && p_base < file_pos) {
fseeko(pfp, p_base, SEEK_SET0);
say("The text leading up to this was:\n--------------------------\n");
while (ftello(pfp) < file_pos) {
	ret = getline(&buf, &bufsz, pfp);
	if (ret == -1)
		fatal("Unexpected end of file\n");
	say("|%s", buf);
}
say("--------------------------\n");
} else
fseeko(pfp, file_pos, SEEK_SET0);
p_input_line = file_line - 1;
454}

456/* Make this a function for better debugging.  */
457static void
458malformed(void)
459{
fatal("malformed patch at line %ld: %s", p_input_line, buf);
/* about as informative as "Syntax error" in C */
462}

464/*
* True if the line has been discarded (i.e. it is a line saying
*  "\ No newline at end of file".)
*/
468static bool_Bool
469remove_special_line(void)
470{
int	c;

c = fgetc(pfp);
if (c == '\\') {
do {
	c = fgetc(pfp);
} while (c != EOF(-1) && c != '\n');

return true1;
}
if (c != EOF(-1))
fseeko(pfp, -1, SEEK_CUR1);

return false0;
485}

487/*
* True if there is more of the current diff listing to process.
*/
490bool_Bool
491another_hunk(void)
492{
off_t	line_beginning;			/* file pos of the current line */
LINENUM	repl_beginning;			/* index of --- line */
LINENUM	fillcnt;			/* #lines of missing ptrn or repl */
LINENUM	fillsrc;			/* index of first line to copy */
LINENUM	filldst;			/* index of first missing line */
bool_Bool	ptrn_spaces_eaten;		/* ptrn was slightly misformed */
bool_Bool	repl_could_be_missing;		/* no + or ! lines in this hunk */
bool_Bool	repl_missing;			/* we are now backtracking */
off_t	repl_backtrack_position;	/* file pos of first repl line */
LINENUM	repl_patch_line;		/* input line number for same */
LINENUM	ptrn_copiable;			/* # of copiable lines in ptrn */
char	*s;
int	context = 0;
int	ret;

while (p_end >= 0) {
1
Assuming 'p_end' is < 0→
2
←
Loop condition is false. Execution continues on line 515→
if (p_end == p_efake)
	p_end = p_bfake;	/* don't free twice */
else
	free(p_line[p_end]);
p_end--;
}
p_efake = -1;

p_max = hunkmax;	/* gets reduced when --- found */
if (diff_type == CONTEXT_DIFF1 || diff_type == NEW_CONTEXT_DIFF4) {
3
←
Assuming 'diff_type' is not equal to CONTEXT_DIFF→
4
←
Assuming 'diff_type' is not equal to NEW_CONTEXT_DIFF→
5
←
Taking false branch→
line_beginning = ftello(pfp);
repl_beginning = 0;
fillcnt = 0;
fillsrc = 0;
ptrn_spaces_eaten = false0;
repl_could_be_missing = true1;
repl_missing = false0;
repl_backtrack_position = 0;
repl_patch_line = 0;
ptrn_copiable = 0;

ret = pgetline(&buf, &bufsz, pfp);
p_input_line++;
if (ret == -1 || strnNE(buf, "********", 8)(strncmp(buf, "********", 8))) {
	next_intuit_at(line_beginning, p_input_line);
	return false0;
}
p_context = 100;
p_hunk_beg = p_input_line + 1;
while (p_end < p_max) {
	line_beginning = ftello(pfp);
	ret = pgetline(&buf, &bufsz, pfp);
	p_input_line++;
	if (ret == -1) {
		if (p_max - p_end < 4) {
			/* assume blank lines got chopped */
			strlcpy(buf, "  \n", bufsz);
		} else {
			if (repl_beginning && repl_could_be_missing) {
				repl_missing = true1;
				goto hunk_done;
			}
			fatal("unexpected end of file in patch\n");
		}
	}
	p_end++;
	if (p_end >= hunkmax)
		fatal("Internal error: hunk larger than hunk "
		    "buffer size");
	p_char[p_end] = *buf;
	p_line[p_end] = NULL((void *)0);
	switch (*buf) {
	case '*':
		if (strnEQ(buf, "********", 8)(!strncmp(buf, "********", 8))) {
			if (repl_beginning && repl_could_be_missing) {
				repl_missing = true1;
				goto hunk_done;
			} else
				fatal("unexpected end of hunk "
				    "at line %ld\n",
				    p_input_line);
		}
		if (p_end != 0) {
			if (repl_beginning && repl_could_be_missing) {
				repl_missing = true1;
				goto hunk_done;
			}
			fatal("unexpected *** at line %ld: %s",
			    p_input_line, buf);
		}
		context = 0;
		p_line[p_end] = savestr(buf);
		if (out_of_mem) {
			p_end--;
			return false0;
		}
		for (s = buf;
		    *s && !isdigit((unsigned char)*s); s++)
			;
		if (!*s)
			malformed();
		if (strnEQ(s, "0,0", 3)(!strncmp(s, "0,0", 3)))
			memmove(s, s + 2, strlen(s + 2) + 1);
		p_first = strtolinenum(s, &s);
		if (*s == ',') {
			for (; *s && !isdigit((unsigned char)*s); s++)
				;
			if (!*s)
				malformed();
			p_ptrn_lines = strtolinenum(s, &s) - p_first + 1;
			if (p_ptrn_lines < 0)
				malformed();
		} else if (p_first)
			p_ptrn_lines = 1;
		else {
			p_ptrn_lines = 0;
			p_first = 1;
		}
		if (p_first >= LINENUM_MAX9223372036854775807L - p_ptrn_lines ||
		    p_ptrn_lines >= LINENUM_MAX9223372036854775807L - 6)
			malformed();

		/* we need this much at least */
		p_max = p_ptrn_lines + 6;
		while (p_max >= hunkmax)
			grow_hunkmax();
		p_max = hunkmax;
		break;
	case '-':
		if (buf[1] == '-') {
			if (repl_beginning ||
			    (p_end != p_ptrn_lines + 1 +
			    (p_char[p_end - 1] == '\n'))) {
				if (p_end == 1) {
					/*
					 * `old' lines were omitted;
					 * set up to fill them in
					 * from 'new' context lines.
					 */
					p_end = p_ptrn_lines + 1;
					fillsrc = p_end + 1;
					filldst = 1;
					fillcnt = p_ptrn_lines;
				} else {
					if (repl_beginning) {
						if (repl_could_be_missing) {
							repl_missing = true1;
							goto hunk_done;
						}
						fatal("duplicate \"---\" at line %ld--check line numbers at line %ld\n",
						    p_input_line, p_hunk_beg + repl_beginning);
					} else {
						fatal("%s \"---\" at line %ld--check line numbers at line %ld\n",
						    (p_end <= p_ptrn_lines
						    ? "Premature"
						    : "Overdue"),
						    p_input_line, p_hunk_beg);
					}
				}
			}
			repl_beginning = p_end;
			repl_backtrack_position = ftello(pfp);
			repl_patch_line = p_input_line;
			p_line[p_end] = savestr(buf);
			if (out_of_mem) {
				p_end--;
				return false0;
			}
			p_char[p_end] = '=';
			for (s = buf;
			    *s && !isdigit((unsigned char)*s); s++)
				;
			if (!*s)
				malformed();
			p_newfirst = strtolinenum(s, &s);
			if (*s == ',') {
				for (; *s && !isdigit((unsigned char)*s); s++)
					;
				if (!*s)
					malformed();
				p_repl_lines = strtolinenum(s, &s) -
				    p_newfirst + 1;
				if (p_repl_lines < 0)
					malformed();
			} else if (p_newfirst)
				p_repl_lines = 1;
			else {
				p_repl_lines = 0;
				p_newfirst = 1;
			}
			if (p_newfirst >= LINENUM_MAX9223372036854775807L - p_repl_lines ||
			    p_repl_lines >= LINENUM_MAX9223372036854775807L - p_end)
				malformed();
			p_max = p_repl_lines + p_end;
			if (p_max > MAXHUNKSIZE100000)
				fatal("hunk too large (%ld lines) at line %ld: %s",
				    p_max, p_input_line, buf);
			while (p_max >= hunkmax)
				grow_hunkmax();
			if (p_repl_lines != ptrn_copiable &&
			    (p_context != 0 || p_repl_lines != 1))
				repl_could_be_missing = false0;
			break;
		}
		goto change_line;
	case '+':
	case '!':
		repl_could_be_missing = false0;
change_line:
		if (buf[1] == '\n' && canonicalize)
			strlcpy(buf + 1, " \n", bufsz - 1);
		if (!isspace((unsigned char)buf[1]) &&
		    buf[1] != '>' && buf[1] != '<' &&
		    repl_beginning && repl_could_be_missing) {
			repl_missing = true1;
			goto hunk_done;
		}
		if (context >= 0) {
			if (context < p_context)
				p_context = context;
			context = -1000;
		}
		p_line[p_end] = savestr(buf + 2);
		if (out_of_mem) {
			p_end--;
			return false0;
		}
		if (p_end == p_ptrn_lines) {
			if (remove_special_line()) {
				int	len;

				len = strlen(p_line[p_end]) - 1;
				(p_line[p_end])[len] = 0;
			}
		}
		break;
	case '\t':
	case '\n':	/* assume the 2 spaces got eaten */
		if (repl_beginning && repl_could_be_missing &&
		    (!ptrn_spaces_eaten ||
		    diff_type == NEW_CONTEXT_DIFF4)) {
			repl_missing = true1;
			goto hunk_done;
		}
		p_line[p_end] = savestr(buf);
		if (out_of_mem) {
			p_end--;
			return false0;
		}
		if (p_end != p_ptrn_lines + 1) {
			ptrn_spaces_eaten |= (repl_beginning != 0);
			context++;
			if (!repl_beginning)
				ptrn_copiable++;
			p_char[p_end] = ' ';
		}
		break;
	case ' ':
		if (!isspace((unsigned char)buf[1]) &&
		    repl_beginning && repl_could_be_missing) {
			repl_missing = true1;
			goto hunk_done;
		}
		context++;
		if (!repl_beginning)
			ptrn_copiable++;
		p_line[p_end] = savestr(buf + 2);
		if (out_of_mem) {
			p_end--;
			return false0;
		}
		break;
	default:
		if (repl_beginning && repl_could_be_missing) {
			repl_missing = true1;
			goto hunk_done;
		}
		malformed();
	}
	/* set up p_len for strncmp() so we don't have to */
	/* assume null termination */
	if (p_line[p_end])
		p_len[p_end] = strlen(p_line[p_end]);
	else
		p_len[p_end] = 0;
}

776hunk_done:
if (p_end >= 0 && !repl_beginning)
	fatal("no --- found in patch at line %ld\n", pch_hunk_beg());

if (repl_missing) {

	/* reset state back to just after --- */
	p_input_line = repl_patch_line;
	for (p_end--; p_end > repl_beginning; p_end--)
		free(p_line[p_end]);
	fseeko(pfp, repl_backtrack_position, SEEK_SET0);

	/* redundant 'new' context lines were omitted - set */
	/* up to fill them in from the old file context */
	if (!p_context && p_repl_lines == 1) {
		p_repl_lines = 0;
		p_max--;
	}
	fillsrc = 1;
	filldst = repl_beginning + 1;
	fillcnt = p_repl_lines;
	p_end = p_max;
} else if (!p_context && fillcnt == 1) {
	/* the first hunk was a null hunk with no context */
	/* and we were expecting one line -- fix it up. */
	while (filldst < p_end) {
		p_line[filldst] = p_line[filldst + 1];
		p_char[filldst] = p_char[filldst + 1];
		p_len[filldst] = p_len[filldst + 1];
		filldst++;
	}
807#if 0
	repl_beginning--;	/* this doesn't need to be fixed */
809#endif
	p_end--;
	p_first++;	/* do append rather than insert */
	fillcnt = 0;
	p_ptrn_lines = 0;
}
if (diff_type == CONTEXT_DIFF1 &&
    (fillcnt || (p_first > 1 && ptrn_copiable > 2 * p_context))) {
	if (verbose)
		say("%s\n%s\n%s\n",
		    "(Fascinating--this is really a new-style context diff but without",
		    "the telltale extra asterisks on the *** line that usually indicate",
		    "the new style...)");
	diff_type = NEW_CONTEXT_DIFF4;
}
/* if there were omitted context lines, fill them in now */
if (fillcnt) {
	p_bfake = filldst;	/* remember where not to free() */
	p_efake = filldst + fillcnt - 1;
	while (fillcnt-- > 0) {
		while (fillsrc <= p_end && p_char[fillsrc] != ' ')
			fillsrc++;
		if (fillsrc > p_end)
			fatal("replacement text or line numbers mangled in hunk at line %ld\n",
			    p_hunk_beg);
		p_line[filldst] = p_line[fillsrc];
		p_char[filldst] = p_char[fillsrc];
		p_len[filldst] = p_len[fillsrc];
		fillsrc++;
		filldst++;
	}
	while (fillsrc <= p_end && fillsrc != repl_beginning &&
	    p_char[fillsrc] != ' ')
		fillsrc++;
843#ifdef DEBUGGING
	if (debug & 64)
		printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
		fillsrc, filldst, repl_beginning, p_end + 1);
847#endif
	if (fillsrc != p_end + 1 && fillsrc != repl_beginning)
		malformed();
	if (filldst != p_end + 1 && filldst != repl_beginning)
		malformed();
}
if (p_line[p_end] != NULL((void *)0)) {
	if (remove_special_line()) {
		p_len[p_end] -= 1;
		(p_line[p_end])[p_len[p_end]] = 0;
	}
}
} else if (diff_type == UNI_DIFF5) {
6
←
Assuming 'diff_type' is equal to UNI_DIFF→
7
←
Taking true branch→
off_t	line_beginning = ftello(pfp); /* file pos of the current line */
LINENUM	fillsrc;	/* index of old lines */
LINENUM	filldst;	/* index of new lines */
char	ch;

ret = pgetline(&buf, &bufsz, pfp);
p_input_line++;
if (ret == -1 || strnNE(buf, "@@ -", 4)(strncmp(buf, "@@ -", 4))) {
8
←
Assuming the condition is false→
9
←
Assuming the condition is false→
10
←
Taking false branch→
	next_intuit_at(line_beginning, p_input_line);
	return false0;
}
s = buf + 4;
if (!*s)
11
←
Assuming the condition is false→
12
←
Taking false branch→
	malformed();
p_first = strtolinenum(s, &s);
if (*s == ',') {
13
←
Assuming the condition is false→
14
←
Taking false branch→
	p_ptrn_lines = strtolinenum(s + 1, &s);
} else
	p_ptrn_lines = 1;
if (*s == ' ')
15
←
Assuming the condition is false→
16
←
Taking false branch→
	s++;
if (*s != '+' || !*++s)
17
←
Assuming the condition is false→
18
←
Assuming the condition is false→
19
←
Taking false branch→
	malformed();
p_newfirst = strtolinenum(s, &s);
if (*s == ',') {
20
←
Assuming the condition is false→
21
←
Taking false branch→
	p_repl_lines = strtolinenum(s + 1, &s);
} else
	p_repl_lines = 1;
if (*s == ' ')
22
←
Assuming the condition is false→
23
←
Taking false branch→
	s++;
if (*s != '@')
24
←
Assuming the condition is false→
25
←
Taking false branch→
	malformed();
if (p_first >= LINENUM_MAX9223372036854775807L - p_ptrn_lines ||
26
←
Assuming the condition is false→
29
←
Taking false branch→
    p_newfirst > LINENUM_MAX9223372036854775807L - p_repl_lines ||
27
←
Assuming the condition is false→
    p_ptrn_lines >= LINENUM_MAX9223372036854775807L - p_repl_lines - 1)
28
←
Assuming the condition is false→
	malformed();
if (!p_ptrn_lines)
30
←
Assuming 'p_ptrn_lines' is not equal to 0→
31
←
Taking false branch→
	p_first++;	/* do append rather than insert */
p_max = p_ptrn_lines + p_repl_lines + 1;
while (p_max >= hunkmax)
32
←
Assuming 'p_max' is < 'hunkmax'→
33
←
Loop condition is false. Execution continues on line 901→
	grow_hunkmax();
fillsrc = 1;
filldst = fillsrc + p_ptrn_lines;
p_end = filldst + p_repl_lines;
snprintf(buf, bufsz, "*** %ld,%ld ****\n", p_first,
    p_first + p_ptrn_lines - 1);
p_line[0] = savestr(buf);
if (out_of_mem) {
34
←
Assuming 'out_of_mem' is false→
35
←
Taking false branch→
	p_end = -1;
	return false0;
}
p_char[0] = '*';
snprintf(buf, bufsz, "--- %ld,%ld ----\n", p_newfirst,
    p_newfirst + p_repl_lines - 1);
p_line[filldst] = savestr(buf);
if (out_of_mem) {
36
←
Assuming 'out_of_mem' is false→
37
←
Taking false branch→
	p_end = 0;
	return false0;
}
p_char[filldst++] = '=';
p_context = 100;
context = 0;
p_hunk_beg = p_input_line + 1;
while (fillsrc <= p_ptrn_lines || filldst <= p_end) {
38
←
Assuming 'fillsrc' is > 'p_ptrn_lines'→
39
←
Assuming 'filldst' is <= 'p_end'→
40
←
Loop condition is true.  Entering loop body→
	line_beginning = ftello(pfp);
	ret = pgetline(&buf, &bufsz, pfp);
	p_input_line++;
	if (ret == -1) {
41
←
Assuming the condition is false→
42
←
Taking false branch→
		if (p_max - filldst < 3) {
			/* assume blank lines got chopped */
			strlcpy(buf, " \n", bufsz);
		} else {
			fatal("unexpected end of file in patch\n");
		}
	}
	if (*buf == '\t' || *buf == '\n') {
43
←
Assuming the condition is false→
44
←
Assuming the condition is false→
45
←
Taking false branch→
		ch = ' ';	/* assume the space got eaten */
		s = savestr(buf);
	} else {
		ch = *buf;
		s = savestr(buf + 1);
	}
	if (out_of_mem) {
46
←
Assuming 'out_of_mem' is false→
47
←
Taking false branch→
		while (--filldst > p_ptrn_lines)
			free(p_line[filldst]);
		p_end = fillsrc - 1;
		return false0;
	}
	switch (ch) {
48
←
Control jumps to 'case 43:'  at line 994→
	case '-':
		if (fillsrc > p_ptrn_lines) {
			free(s);
			p_end = filldst - 1;
			malformed();
		}
		p_char[fillsrc] = ch;
		p_line[fillsrc] = s;
		p_len[fillsrc++] = strlen(s);
		if (fillsrc > p_ptrn_lines) {
			if (remove_special_line()) {
				p_len[fillsrc - 1] -= 1;
				s[p_len[fillsrc - 1]] = 0;
			}
		}
		break;
	case '=':
		ch = ' ';
		/* FALL THROUGH */
	case ' ':
		if (fillsrc > p_ptrn_lines) {
			free(s);
			while (--filldst > p_ptrn_lines)
				free(p_line[filldst]);
			p_end = fillsrc - 1;
			malformed();
		}
		context++;
		p_char[fillsrc] = ch;
		p_line[fillsrc] = s;
		p_len[fillsrc++] = strlen(s);
		s = savestr(s);
		if (out_of_mem) {
			while (--filldst > p_ptrn_lines)
				free(p_line[filldst]);
			p_end = fillsrc - 1;
			return false0;
		}
		if (fillsrc > p_ptrn_lines) {
			if (remove_special_line()) {
				p_len[fillsrc - 1] -= 1;
				s[p_len[fillsrc - 1]] = 0;
			}
		}
		/* FALL THROUGH */
	case '+':
		if (filldst > p_end) {
49
←
Assuming 'filldst' is > 'p_end'→
50
←
Taking true branch→
			free(s);
51
←
Memory is released→
			while (--filldst > p_ptrn_lines)
52
←
Assuming the condition is false→
53
←
Loop condition is false. Execution continues on line 999→
				free(p_line[filldst]);
			p_end = fillsrc - 1;
			malformed();
		}
		p_char[filldst] = ch;
		p_line[filldst] = s;
		p_len[filldst++] = strlen(s);
54
←
Use of memory after it is freed
		if (fillsrc > p_ptrn_lines) {
			if (remove_special_line()) {
				p_len[filldst - 1] -= 1;
				s[p_len[filldst - 1]] = 0;
			}
		}
		break;
	default:
		p_end = filldst;
		malformed();
	}
	if (ch != ' ' && context > 0) {
		if (context < p_context)
			p_context = context;
		context = -1000;
	}
}		/* while */
} else {		/* normal diff--fake it up */
char	hunk_type;
int	i;
LINENUM	min, max;
off_t	line_beginning = ftello(pfp);

p_context = 0;
ret = pgetline(&buf, &bufsz, pfp);
p_input_line++;
if (ret == -1 || !isdigit((unsigned char)*buf)) {
	next_intuit_at(line_beginning, p_input_line);
	return false0;
}
p_first = strtolinenum(buf, &s);
if (*s == ',') {
	p_ptrn_lines = strtolinenum(s + 1, &s) - p_first + 1;
	if (p_ptrn_lines < 0)
		malformed();
} else
	p_ptrn_lines = (*s != 'a');
if (p_first >= LINENUM_MAX9223372036854775807L - p_ptrn_lines)
	malformed();
hunk_type = *s;
if (hunk_type == 'a')
	p_first++;	/* do append rather than insert */
min = strtolinenum(s + 1, &s);
if (*s == ',')
	max = strtolinenum(s + 1, &s);
else
	max = min;
if (min < 0 || min > max || max - min == LINENUM_MAX9223372036854775807L)
	malformed();
if (hunk_type == 'd')
	min++;
p_newfirst = min;
p_repl_lines = max - min + 1;
if (p_newfirst > LINENUM_MAX9223372036854775807L - p_repl_lines ||
    p_ptrn_lines >= LINENUM_MAX9223372036854775807L - p_repl_lines - 1)
	malformed();
p_end = p_ptrn_lines + p_repl_lines + 1;
if (p_end > MAXHUNKSIZE100000)
	fatal("hunk too large (%ld lines) at line %ld: %s",
	    p_end, p_input_line, buf);
while (p_end >= hunkmax)
	grow_hunkmax();
snprintf(buf, bufsz, "*** %ld,%ld\n", p_first,
    p_first + p_ptrn_lines - 1);
p_line[0] = savestr(buf);
if (out_of_mem) {
	p_end = -1;
	return false0;
}
p_char[0] = '*';
for (i = 1; i <= p_ptrn_lines; i++) {
	ret = pgetline(&buf, &bufsz, pfp);
	p_input_line++;
	if (ret == -1)
		fatal("unexpected end of file in patch at line %ld\n",
		    p_input_line);
	if (*buf != '<')
		fatal("< expected at line %ld of patch\n",
		    p_input_line);
	p_line[i] = savestr(buf + 2);
	if (out_of_mem) {
		p_end = i - 1;
		return false0;
	}
	p_len[i] = strlen(p_line[i]);
	p_char[i] = '-';
}

if (remove_special_line()) {
	p_len[i - 1] -= 1;
	(p_line[i - 1])[p_len[i - 1]] = 0;
}
if (hunk_type == 'c') {
	ret = pgetline(&buf, &bufsz, pfp);
	p_input_line++;
	if (ret == -1)
		fatal("unexpected end of file in patch at line %ld\n",
		    p_input_line);
	if (*buf != '-')
		fatal("--- expected at line %ld of patch\n",
		    p_input_line);
}
snprintf(buf, bufsz, "--- %ld,%ld\n", min, max);
p_line[i] = savestr(buf);
if (out_of_mem) {
	p_end = i - 1;
	return false0;
}
p_char[i] = '=';
for (i++; i <= p_end; i++) {
	ret = pgetline(&buf, &bufsz, pfp);
	p_input_line++;
	if (ret == -1)
		fatal("unexpected end of file in patch at line %ld\n",
		    p_input_line);
	if (*buf != '>')
		fatal("> expected at line %ld of patch\n",
		    p_input_line);
	p_line[i] = savestr(buf + 2);
	if (out_of_mem) {
		p_end = i - 1;
		return false0;
	}
	p_len[i] = strlen(p_line[i]);
	p_char[i] = '+';
}

if (remove_special_line()) {
	p_len[i - 1] -= 1;
	(p_line[i - 1])[p_len[i - 1]] = 0;
}
}
if (reverse)		/* backwards patch? */
if (!pch_swap())
	say("Not enough memory to swap next hunk!\n");
1140#ifdef DEBUGGING
if (debug & 2) {
int	i;
char	special;

for (i = 0; i <= p_end; i++) {
	if (i == p_ptrn_lines)
		special = '^';
	else
		special = ' ';
	fprintf(stderr(&__sF[2]), "%3d %c %c %s", i, p_char[i],
	    special, p_line[i]);
	fflush(stderr(&__sF[2]));
}
}
1155#endif
if (p_end + 1 < hunkmax)/* paranoia reigns supreme... */
p_char[p_end + 1] = '^';	/* add a stopper for apply_hunk */
return true1;
1159}

1161/*
* Input a line from the patch file, worrying about indentation.
*/
1164int
1165pgetline(char **bf, size_t *sz, FILE *fp)
1166{
char	*s;
int	indent = 0;
int	ret;

ret = getline(bf, sz, fp);

if (p_indent && ret != -1) {
for (s = buf;
    indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X');
    s++) {
	if (*s == '\t')
		indent += 8 - (indent % 7);
	else
		indent++;
}
if (buf != s && strlcpy(buf, s, bufsz) >= bufsz)
	fatal("buffer too small in pgetline()\n");
}
return ret;
1186}

1188/*
* Reverse the old and new portions of the current hunk.
*/
1191bool_Bool
1192pch_swap(void)
1193{
char	**tp_line;	/* the text of the hunk */
short	*tp_len;	/* length of each line */
char	*tp_char;	/* +, -, and ! */
LINENUM	i;
LINENUM	n;
bool_Bool	blankline = false0;
char	*s;

i = p_first;
p_first = p_newfirst;
p_newfirst = i;

/* make a scratch copy */

tp_line = p_line;
tp_len = p_len;
tp_char = p_char;
p_line = NULL((void *)0);	/* force set_hunkmax to allocate again */
p_len = NULL((void *)0);
p_char = NULL((void *)0);
set_hunkmax();
if (p_line == NULL((void *)0) || p_len == NULL((void *)0) || p_char == NULL((void *)0)) {

free(p_line);
p_line = tp_line;
free(p_len);
p_len = tp_len;
free(p_char);
p_char = tp_char;
return false0;	/* not enough memory to swap hunk! */
}
/* now turn the new into the old */

i = p_ptrn_lines + 1;
if (tp_char[i] == '\n') {	/* account for possible blank line */
blankline = true1;
i++;
}
if (p_efake >= 0) {	/* fix non-freeable ptr range */
if (p_efake <= i)
	n = p_end - i + 1;
else
	n = -i;
p_efake += n;
p_bfake += n;
}
for (n = 0; i <= p_end; i++, n++) {
p_line[n] = tp_line[i];
p_char[n] = tp_char[i];
if (p_char[n] == '+')
	p_char[n] = '-';
p_len[n] = tp_len[i];
}
if (blankline) {
i = p_ptrn_lines + 1;
p_line[n] = tp_line[i];
p_char[n] = tp_char[i];
p_len[n] = tp_len[i];
n++;
}
if (p_char[0] != '=')
fatal("Malformed patch at line %ld: expected '=' found '%c'\n",
    p_input_line, p_char[0]);
p_char[0] = '*';
for (s = p_line[0]; *s; s++)
if (*s == '-')
	*s = '*';

/* now turn the old into the new */

if (p_char[0] != '*')
fatal("Malformed patch at line %ld: expected '*' found '%c'\n",
    p_input_line, p_char[0]);
tp_char[0] = '=';
for (s = tp_line[0]; *s; s++)
if (*s == '*')
	*s = '-';
for (i = 0; n <= p_end; i++, n++) {
p_line[n] = tp_line[i];
p_char[n] = tp_char[i];
if (p_char[n] == '-')
	p_char[n] = '+';
p_len[n] = tp_len[i];
}

if (i != p_ptrn_lines + 1)
fatal("Malformed patch at line %ld: expected %ld lines, "
    "got %ld\n",
    p_input_line, p_ptrn_lines + 1, i);

i = p_ptrn_lines;
p_ptrn_lines = p_repl_lines;
p_repl_lines = i;

free(tp_line);
free(tp_len);
free(tp_char);

return true1;
1293}

1295/*
* Return the specified line position in the old file of the old context.
*/
1298LINENUM
1299pch_first(void)
1300{
return p_first;
1302}

1304/*
* Return the number of lines of old context.
*/
1307LINENUM
1308pch_ptrn_lines(void)
1309{
return p_ptrn_lines;
1311}

1313/*
* Return the probable line position in the new file of the first line.
*/
1316LINENUM
1317pch_newfirst(void)
1318{
return p_newfirst;
1320}

1322/*
* Return the number of lines in the replacement text including context.
*/
1325LINENUM
1326pch_repl_lines(void)
1327{
return p_repl_lines;
1329}

1331/*
* Return the number of lines in the whole hunk.
*/
1334LINENUM
1335pch_end(void)
1336{
return p_end;
1338}

1340/*
* Return the number of context lines before the first changed line.
*/
1343LINENUM
1344pch_context(void)
1345{
return p_context;
1347}

1349/*
* Return the length of a particular patch line.
*/
1352short
1353pch_line_len(LINENUM line)
1354{
return p_len[line];
1356}

1358/*
* Return the control character (+, -, *, !, etc) for a patch line.
*/
1361char
1362pch_char(LINENUM line)
1363{
return p_char[line];
1365}

1367/*
* Return a pointer to a particular patch line.
*/
1370char *
1371pfetch(LINENUM line)
1372{
return p_line[line];
1374}

1376/*
* Return where in the patch file this hunk began, for error messages.
*/
1379LINENUM
1380pch_hunk_beg(void)
1381{
return p_hunk_beg;
1383}

1385/*
* Choose the name of the file to be patched based on POSIX rules.
* NOTE: the POSIX rules are amazingly stupid and we only follow them
*       if the user specified --posix or set POSIXLY_CORRECT.
*/
1390static char *
1391posix_name(const struct file_name *names, bool_Bool assume_exists)
1392{
char *path = NULL((void *)0);
int i;

/*
* POSIX states that the filename will be chosen from one
* of the old, new and index names (in that order) if
* the file exists relative to CWD after -p stripping.
*/
for (i = 0; i < MAX_FILE3; i++) {
if (names[i].path != NULL((void *)0) && names[i].exists) {
	path = names[i].path;
	break;
}
}
if (path == NULL((void *)0) && !assume_exists) {
/*
 * No files found, check to see if the diff could be
 * creating a new file.
 */
if (path == NULL((void *)0) && ok_to_create_file &&
    names[NEW_FILE1].path != NULL((void *)0))
	path = names[NEW_FILE1].path;
}

return path ? xstrdup(path) : NULL((void *)0);
1418}

1420static char *
1421compare_names(const struct file_name *names, bool_Bool assume_exists)
1422{
size_t min_components, min_baselen, min_len, tmp;
char *best = NULL((void *)0);
char *path;
int i;

/*
* The "best" name is the one with the fewest number of path
* components, the shortest basename length, and the shortest
* overall length (in that order).  We only use the Index: file
* if neither of the old or new files could be intuited from
* the diff header.
*/
min_components = min_baselen = min_len = SIZE_MAX0xffffffffffffffffUL;
for (i = INDEX_FILE2; i >= OLD_FILE0; i--) {
path = names[i].path;
if (path == NULL((void *)0) || (!names[i].exists && !assume_exists))
	continue;
if ((tmp = num_components(path)) > min_components)
	continue;
if (tmp < min_components) {
	min_components = tmp;
	best = path;
}
if ((tmp = strlen(basename(path))) > min_baselen)
	continue;
if (tmp < min_baselen) {
	min_baselen = tmp;
	best = path;
}
if ((tmp = strlen(path)) > min_len)
	continue;
min_len = tmp;
best = path;
}
return best;
1458}

1460/*
* Choose the name of the file to be patched based the "best" one
* available.
*/
1464static char *
1465best_name(const struct file_name *names, bool_Bool assume_exists)
1466{
char *best;

best = compare_names(names, assume_exists);

/* No match?  Check to see if the diff could be creating a new file. */
if (best == NULL((void *)0) && ok_to_create_file)
best = names[NEW_FILE1].path;

return best ? xstrdup(best) : NULL((void *)0);
1476}

1478static size_t
1479num_components(const char *path)
1480{
size_t n;
const char *cp;

for (n = 0, cp = path; (cp = strchr(cp, '/')) != NULL((void *)0); n++, cp++) {
while (*cp == '/')
	cp++;		/* skip consecutive slashes */
}
return n;
1489}

1491/*
* Convert number at NPTR into LINENUM and save address of first
* character that is not a digit in ENDPTR.  If conversion is not
* possible, call fatal.
*/
1496LINENUM
1497strtolinenum(char *nptr, char **endptr)
1498{
LINENUM rv;
char c;
char *p;
const char *errstr;

for (p = nptr; isdigit((unsigned char)*p); p++)
;

if (p == nptr)
malformed();

c = *p;
*p = '\0';

rv = strtonum(nptr, 0, LINENUM_MAX9223372036854775807L, &errstr);
if (errstr != NULL((void *)0))
fatal("invalid line number at line %ld: `%s' is %s\n",
    p_input_line, nptr, errstr);

*p = c;
*endptr = p;

return rv;
1522}