ain@j.cc.purdue.edu (Patrick White) (03/06/88)
Program Name: patch (docs)
Submitted By: Johan Widen <jw@sics.se>
Summary: This is patch ported to the Amiga.
Poster Boy: Pat White (ain@j.cc.purdue.edu)
NOTES:
I've separated this from the origional zoo that it was sent in so we can
post the bin and src separately.. and made the docs a separate shar too.
-- Pat White (co-moderator comp.sources/binaries.amiga)
UUCP: j.cc.purdue.edu!ain BITNET: PATWHITE@PURCCVM PHONE: (317) 743-8421
U.S. Mail: 320 Brown St. apt. 406, West Lafayette, IN 47906
========================================
# This is a shell archive.
# Remove everything above and including the cut line.
# Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: Shell Archiver
# Run the following text with /bin/sh to create:
# README
# patch.man.nroffed
# README.lwall
# WARNING
# README.880212
# MANIFEST
# patch.man
# This archive created: Sun Mar 6 02:38:00 1988
# By: Patrick White (PUCC Land, USA)
echo shar: extracting README '(769 characters)'
cat << \SHAR_EOF > README
This is a port of the UNIX patch program to the Amiga.
Patch is an expert at updating source files by applying context diffs to them
(context diffs are produced by the BSD UNIX program diff).
Acknowledgements:
Larry Wall is the author of patch.
Peter da Silva is the author of the file requester.
Matt Dillon has improved the file requester code and is the author of
newwildcmp.c.
The files filereq.c and newwildcmp.c are from Matt Dillon's original
posting of the disk cataloger "files".
Compiling:
I have only compiled this with the Lattice compiler. Modifications for the
Manx compiler should be straight forward.
Warning:
Please read the file 'WARNING' before you use patch.
23-JAN-88 Johan Widen
USENET: jw@sics.se
SHAR_EOF
if test 769 -ne "`wc -c README`"
then
echo shar: error transmitting README '(should have been 769 characters)'
fi
echo shar: extracting patch.man.nroffed '(14782 characters)'
cat << \SHAR_EOF > patch.man.nroffed
PATCH(1) UNIX Programmer's Manual PATCH(1)
NAME
patch - a program for applying a diff file to an original
SYNOPSIS
patch [options] orig patchfile [+ [options] orig]
but usually just
patch <patchfile
DESCRIPTION
_P_a_t_c_h will take a patch file containing any of the three
forms of difference listing produced by the _d_i_f_f program and
apply those differences to an original file, producing a
patched version. By default, the patched version is put in
place of the original, with the original file backed up to
the same name with the extension ".orig", or as specified by
the -b switch. You may also specify where you want the out-
put to go with a -o switch. If _p_a_t_c_h_f_i_l_e is omitted, or is
a hyphen, the patch will be read from standard input.
Upon startup, patch will attempt to determine the type of
the diff listing, unless over-ruled by a -c, -e, or -n
switch. Context diffs and normal diffs are applied by the
_p_a_t_c_h program itself, while ed diffs are simply fed to the
_e_d editor via a pipe.
_P_a_t_c_h will try to skip any leading garbage, apply the diff,
and then skip any trailing garbage. Thus you could feed an
article or message containing a diff listing to _p_a_t_c_h, and
it should work. If the entire diff is indented by a con-
sistent amount, this will be taken into account.
With context diffs, and to a lesser extent with normal
diffs, _p_a_t_c_h can detect when the line numbers mentioned in
the patch are incorrect, and will attempt to find the
correct place to apply each hunk of the patch. As a first
guess, it takes the line number mentioned for the hunk, plus
or minus any offset used in applying the previous hunk. If
that is not the correct place, _p_a_t_c_h will scan both forwards
and backwards for a set of lines matching the context given
in the hunk. First _p_a_t_c_h looks for a place where all lines
of the context match. If no such place is found, and it's a
context diff, and the maximum fuzz factor is set to 1 or
more, then another scan takes place ignoring the first and
last line of context. If that fails, and the maximum fuzz
factor is set to 2 or more, the first two and last two lines
of context are ignored, and another scan is made. (The
default maximum fuzz factor is 2.) If _p_a_t_c_h cannot find a
place to install that hunk of the patch, it will put the
hunk out to a reject file, which normally is the name of the
output file plus ".rej". (Note that the rejected hunk will
Printed 3/6/88 LOCAL 1
PATCH(1) UNIX Programmer's Manual PATCH(1)
come out in context diff form whether the input patch was a
context diff or a normal diff. If the input was a normal
diff, many of the contexts will simply be null.) The line
numbers on the hunks in the reject file may be different
than in the patch file: they reflect the approximate loca-
tion patch thinks the failed hunks belong in the new file
rather than the old one.
As each hunk is completed, you will be told whether the hunk
succeeded or failed, and which line (in the new file) _p_a_t_c_h
thought the hunk should go on. If this is different from
the line number specified in the diff you will be told the
offset. A single large offset MAY be an indication that a
hunk was installed in the wrong place. You will also be
told if a fuzz factor was used to make the match, in which
case you should also be slightly suspicious.
If no original file is specified on the command line, _p_a_t_c_h
will try to figure out from the leading garbage what the
name of the file to edit is. In the header of a context
diff, the filename is found from lines beginning with "***"
or "---", with the shortest name of an existing file win-
ning. Only context diffs have lines like that, but if there
is an "Index:" line in the leading garbage, _p_a_t_c_h will try
to use the filename from that line. The context diff header
takes precedence over an Index line. If no filename can be
intuited from the leading garbage, you will be asked for the
name of the file to patch.
(If the original file cannot be found, but a suitable SCCS
or RCS file is handy, _p_a_t_c_h will attempt to get or check out
the file.)
Additionally, if the leading garbage contains a "Prereq: "
line, _p_a_t_c_h will take the first word from the prerequisites
line (normally a version number) and check the input file to
see if that word can be found. If not, _p_a_t_c_h will ask for
confirmation before proceeding.
The upshot of all this is that you should be able to say,
while in a news interface, the following:
| patch -d /usr/src/local/blurfl
and patch a file in the blurfl directory directly from the
article containing the patch.
If the patch file contains more than one patch, _p_a_t_c_h will
try to apply each of them as if they came from separate
patch files. This means, among other things, that it is
assumed that the name of the file to patch must be deter-
mined for each diff listing, and that the garbage before
Printed 3/6/88 LOCAL 2
PATCH(1) UNIX Programmer's Manual PATCH(1)
each diff listing will be examined for interesting things
such as filenames and revision level, as mentioned previ-
ously. You can give switches (and another original file
name) for the second and subsequent patches by separating
the corresponding argument lists by a '+'. (The argument
list for a second or subsequent patch may not specify a new
patch file, however.)
_P_a_t_c_h recognizes the following switches:
-b causes the next argument to be interpreted as the
backup extension, to be used in place of ".orig".
-c forces _p_a_t_c_h to interpret the patch file as a context
diff.
-d causes _p_a_t_c_h to interpret the next argument as a direc-
tory, and cd to it before doing anything else.
-D causes _p_a_t_c_h to use the "#ifdef...#endif" construct to
mark changes. The argument following will be used as
the differentiating symbol. Note that, unlike the C
compiler, there must be a space between the -D and the
argument.
-e forces _p_a_t_c_h to interpret the patch file as an ed
script.
-f forces _p_a_t_c_h to assume that the user knows exactly what
he or she is doing, and to not ask any questions. It
does not suppress commentary, however. Use -s for
that.
-F<number>
sets the maximum fuzz factor. This switch only applied
to context diffs, and causes _p_a_t_c_h to ignore up to that
many lines in looking for places to install a hunk.
Note that a larger fuzz factor increases the odds of a
faulty patch. The default fuzz factor is 2, and it may
not be set to more than the number of lines of context
in the context diff, ordinarily 3.
-l causes the pattern matching to be done loosely, in case
the tabs and spaces have been munged in your input
file. Any sequence of whitespace in the pattern line
will match any sequence in the input file. Normal
characters must still match exactly. Each line of the
context must still match a line in the input file.
-n forces _p_a_t_c_h to interpret the patch file as a normal
diff.
Printed 3/6/88 LOCAL 3
PATCH(1) UNIX Programmer's Manual PATCH(1)
-N causes _p_a_t_c_h to ignore patches that it thinks are
reversed or already applied. See also -R .
-o causes the next argument to be interpreted as the out-
put file name.
-p<number>
sets the pathname strip count, which controls how path-
names found in the patch file are treated, in case the
you keep your files in a different directory than the
person who sent out the patch. The strip count speci-
fies how many backslashes are to be stripped from the
front of the pathname. (Any intervening directory
names also go away.) For example, supposing the
filename in the patch file was
/u/howard/src/blurfl/blurfl.c
setting -p or -p0 gives the entire pathname unmodified,
-p1 gives
u/howard/src/blurfl/blurfl.c
without the leading slash, -p4 gives
blurfl/blurfl.c
and not specifying -p at all just gives you "blurfl.c".
Whatever you end up with is looked for either in the
current directory, or the directory specified by the -d
switch.
-r causes the next argument to be interpreted as the
reject file name.
-R tells _p_a_t_c_h that this patch was created with the old
and new files swapped. (Yes, I'm afraid that does hap-
pen occasionally, human nature being what it is.) _P_a_t_c_h
will attempt to swap each hunk around before applying
it. Rejects will come out in the swapped format. The
-R switch will not work with ed diff scripts because
there is too little information to reconstruct the
reverse operation.
If the first hunk of a patch fails, _p_a_t_c_h will reverse
the hunk to see if it can be applied that way. If it
can, you will be asked if you want to have the -R
switch set. If it can't, the patch will continue to be
applied normally. (Note: this method cannot detect a
reversed patch if it is a normal diff and if the first
command is an append (i.e. it should have been a
delete) since appends always succeed, due to the fact
Printed 3/6/88 LOCAL 4
PATCH(1) UNIX Programmer's Manual PATCH(1)
that a null context will match anywhere. Luckily, most
patches add or change lines rather than delete them, so
most reversed normal diffs will begin with a delete,
which will fail, triggering the heuristic.)
-s makes _p_a_t_c_h do its work silently, unless an error
occurs.
-S causes _p_a_t_c_h to ignore this patch from the patch file,
but continue on looking for the next patch in the file.
Thus
patch -S + -S + <patchfile
will ignore the first and second of three patches.
-v causes _p_a_t_c_h to print out it's revision header and
patch level.
-x<number>
sets internal debugging flags, and is of interest only
to _p_a_t_c_h patchers.
ENVIRONMENT
No environment variables are used by _p_a_t_c_h.
FILES
/tmp/patch*
SEE ALSO
diff(1)
NOTES FOR PATCH SENDERS
There are several things you should bear in mind if you are
going to be sending out patches. First, you can save people
a lot of grief by keeping a patchlevel.h file which is
patched to increment the patch level as the first diff in
the patch file you send out. If you put a Prereq: line in
with the patch, it won't let them apply patches out of order
without some warning. Second, make sure you've specified
the filenames right, either in a context diff header, or
with an Index: line. If you are patching something in a
subdirectory, be sure to tell the patch user to specify a -p
switch as needed. Third, you can create a file by sending
out a diff that compares a null file to the file you want to
create. This will only work if the file you want to create
doesn't exist already in the target directory. Fourth, take
care not to send out reversed patches, since it makes people
wonder whether they already applied the patch. Fifth, while
you may be able to get away with putting 582 diff listings
into one file, it is probably wiser to group related patches
into separate files in case something goes haywire.
Printed 3/6/88 LOCAL 5
PATCH(1) UNIX Programmer's Manual PATCH(1)
DIAGNOSTICS
Too many to list here, but generally indicative that _p_a_t_c_h
couldn't parse your patch file.
The message "Hmm..." indicates that there is unprocessed
text in the patch file and that _p_a_t_c_h is attempting to
intuit whether there is a patch in that text and, if so,
what kind of patch it is.
CAVEATS
_P_a_t_c_h cannot tell if the line numbers are off in an ed
script, and can only detect bad line numbers in a normal
diff when it finds a "change" or a "delete" command. A con-
text diff using fuzz factor 3 may have the same problem.
Until a suitable interactive interface is added, you should
probably do a context diff in these cases to see if the
changes made sense. Of course, compiling without errors is
a pretty good indication that the patch worked, but not
always.
_P_a_t_c_h usually produces the correct results, even when it has
to do a lot of guessing. However, the results are
guaranteed to be correct only when the patch is applied to
exactly the same version of the file that the patch was gen-
erated from.
BUGS
Could be smarter about partial matches, excessively deviant
offsets and swapped code, but that would take an extra pass.
If code has been duplicated (for instance with #ifdef OLD-
CODE ... #else ... #endif), _p_a_t_c_h is incapable of patching
both versions, and, if it works at all, will likely patch
the wrong one, and tell you that it succeeded to boot.
If you apply a patch you've already applied, _p_a_t_c_h will
think it is a reversed patch, and offer to un-apply the
patch. This could be construed as a feature.
Printed 3/6/88 LOCAL 6
SHAR_EOF
if test 14782 -ne "`wc -c patch.man.nroffed`"
then
echo shar: error transmitting patch.man.nroffed '(should have been 14782 characters)'
fi
echo shar: extracting README.lwall '(2963 characters)'
cat << \SHAR_EOF > README.lwall
Patch Kit, Version 2.0
Copyright (c) 1986, Larry Wall
You may copy the patch kit in whole or in part as long as you don't try to
make money off it, or pretend that you wrote it.
--------------------------------------------------------------------------
Please read all the directions below before you proceed any further, and
then follow them carefully. Failure to do so may void your warranty. :-)
After you have unpacked your kit, you should have all the files listed
in MANIFEST.
Installation
1) Run Configure. This will figure out various things about your system.
Some things Configure will figure out for itself, other things it will
ask you about. It will then proceed to make config.h, config.sh, and
Makefile.
You might possibly have to trim # comments from the front of Configure
if your sh doesn't handle them, but all other # comments will be taken
care of.
If you don't have sh, you'll have to rip the prototype of config.h out
of Configure and generate the defines by hand.
2) Glance through config.h to make sure system dependencies are correct.
Most of them should have been taken care of by running the Configure script.
If you have any additional changes to make to the C definitions, they
can be done in the Makefile, or in config.h. Bear in mind that they may
get undone next time you run Configure.
3) make
This will attempt to make patch in the current directory.
4) make install
This will put patch into a public directory (normally /usr/local/bin).
It will also try to put the man pages in a reasonable place. It will not
nroff the man page, however.
5) Read the manual entry before running patch.
6) IMPORTANT! Help save the world! Communicate any problems and
suggested patches to me, lwall@sdcrdcf.UUCP (Larry Wall), so we can
keep the world in sync. If you have a problem, there's someone else
out there who either has had or will have the same problem.
If possible, send in patches such that the patch program will apply them.
Context diffs are the best, then normal diffs. Don't send ed scripts--
I've probably changed my copy since the version you have.
Watch for patch patches in net.sources.bugs. Patches will generally be
in a form usable by the patch program. If you are just now bringing up
patch and aren't sure how many patches there are, write to me and I'll
send any you don't have. Your current patch level is shown in patchlevel.h.
NEW FEATURES IN THIS RELEASE
(Correct) support for 4.3bsd-style context diffs.
Files can be created from scratch.
You can specify a fuzz-factor for context matching.
You can force patch to ask no questions.
You can specify how much of the leading pathname to strip off filenames.
Uses a Configure script for greater portability.
You are now asked if you want to apply a reversed patch.
No limit (apart from memory) on the size of hunks.
SHAR_EOF
if test 2963 -ne "`wc -c README.lwall`"
then
echo shar: error transmitting README.lwall '(should have been 2963 characters)'
fi
echo shar: extracting WARNING '(426 characters)'
cat << \SHAR_EOF > WARNING
WARNING: This program may destroy your files.
The business of patch is to update source files. Bugs may have been introduced
when patch was ported to the Amiga. Although I am not aware of any dangerous
bugs at present, they may well be there! Always backup your files before you
apply patch to them.
I disclaim any responsibility for damages caused by the use of patch.
23-JAN-88 Johan Widen
USENET: jw@sics.se
SHAR_EOF
if test 426 -ne "`wc -c WARNING`"
then
echo shar: error transmitting WARNING '(should have been 426 characters)'
fi
echo shar: extracting README.880212 '(160 characters)'
cat << \SHAR_EOF > README.880212
12-FEB-88
The following diffs fix a moderately serious bug in patch for the Amiga.
Patch did not remove all file locks.
Johan Widen
USENET: jw@sics.se
SHAR_EOF
if test 160 -ne "`wc -c README.880212`"
then
echo shar: error transmitting README.880212 '(should have been 160 characters)'
fi
echo shar: extracting MANIFEST '(204 characters)'
cat << \SHAR_EOF > MANIFEST
MANIFEST
README
WARNING
README.lwall
patch.man
Makefile
EXTERN.h
INTERN.h
common.h
config.h
filereq.c
inp.c
inp.h
newwildcmp.c
patch.c
patchlevel.h
pch.c
pch.h
request.c
util.c
util.h
version.c
version.h
SHAR_EOF
if test 204 -ne "`wc -c MANIFEST`"
then
echo shar: error transmitting MANIFEST '(should have been 204 characters)'
fi
echo shar: extracting patch.man '(13700 characters)'
cat << \SHAR_EOF > patch.man
''' $Header: patch.man,v 2.0 86/09/17 15:39:09 lwall Exp $
'''
''' $Log: patch.man,v $
''' Revision 2.0 86/09/17 15:39:09 lwall
''' Baseline for netwide release.
'''
''' Revision 1.4 86/08/01 19:23:22 lwall
''' Documented -v, -p, -F.
''' Added notes to patch senders.
'''
''' Revision 1.3 85/03/26 15:11:06 lwall
''' Frozen.
'''
''' Revision 1.2.1.4 85/03/12 16:14:27 lwall
''' Documented -p.
'''
''' Revision 1.2.1.3 85/03/12 16:09:41 lwall
''' Documented -D.
'''
''' Revision 1.2.1.2 84/12/05 11:06:55 lwall
''' Added -l switch, and noted bistability bug.
'''
''' Revision 1.2.1.1 84/12/04 17:23:39 lwall
''' Branch for sdcrdcf changes.
'''
''' Revision 1.2 84/12/04 17:22:02 lwall
''' Baseline version.
'''
.de Sh
.br
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp
.if t .sp .5v
.if n .sp
..
'''
''' Set up \*(-- to give an unbreakable dash;
''' string Tr holds user defined translation string.
''' Bell System Logo is used as a dummy character.
'''
.ie n \{\
.tr \(bs-\*(Tr
.ds -- \(bs-
.if (\n(.H=4u)&(1m=24u) .ds -- \(bs\h'-12u'\(bs\h'-12u'-\" diablo 10 pitch
.if (\n(.H=4u)&(1m=20u) .ds -- \(bs\h'-12u'\(bs\h'-8u'-\" diablo 12 pitch
.ds L" ""
.ds R" ""
.ds L' '
.ds R' '
'br\}
.el\{\
.ds -- \(em\|
.tr \*(Tr
.ds L" ``
.ds R" ''
.ds L' `
.ds R' '
'br\}
.TH PATCH 1 LOCAL
.SH NAME
patch - a program for applying a diff file to an original
.SH SYNOPSIS
.B patch
[options] orig patchfile [+ [options] orig]
.sp
but usually just
.sp
.B patch
<patchfile
.SH DESCRIPTION
.I Patch
will take a patch file containing any of the three forms of difference
listing produced by the
.I diff
program and apply those differences to an original file, producing a patched
version.
By default, the patched version is put in place of the original, with
the original file backed up to the same name with the
extension \*(L".orig\*(R", or as specified by the
.B -b
switch.
You may also specify where you want the output to go with a
.B -o
switch.
If
.I patchfile
is omitted, or is a hyphen, the patch will be read from standard input.
.PP
Upon startup, patch will attempt to determine the type of the diff listing,
unless over-ruled by a
.BR -c ,
.BR -e ,
or
.B -n
switch.
Context diffs and normal diffs are applied by the
.I patch
program itself, while ed diffs are simply fed to the
.I ed
editor via a pipe.
.PP
.I Patch
will try to skip any leading garbage, apply the diff,
and then skip any trailing garbage.
Thus you could feed an article or message containing a
diff listing to
.IR patch ,
and it should work.
If the entire diff is indented by a consistent amount,
this will be taken into account.
.PP
With context diffs, and to a lesser extent with normal diffs,
.I patch
can detect when the line numbers mentioned in the patch are incorrect,
and will attempt to find the correct place to apply each hunk of the patch.
As a first guess, it takes the line number mentioned for the hunk, plus or
minus any offset used in applying the previous hunk.
If that is not the correct place,
.I patch
will scan both forwards and backwards for a set of lines matching the context
given in the hunk.
First
.I patch
looks for a place where all lines of the context match.
If no such place is found, and it's a context diff, and the maximum fuzz factor
is set to 1 or more, then another scan takes place ignoring the first and last
line of context.
If that fails, and the maximum fuzz factor is set to 2 or more,
the first two and last two lines of context are ignored,
and another scan is made.
(The default maximum fuzz factor is 2.)
If
.I patch
cannot find a place to install that hunk of the patch, it will put the
hunk out to a reject file, which normally is the name of the output file
plus \*(L".rej\*(R".
(Note that the rejected hunk will come out in context diff form whether the
input patch was a context diff or a normal diff.
If the input was a normal diff, many of the contexts will simply be null.)
The line numbers on the hunks in the reject file may be different than
in the patch file: they reflect the approximate location patch thinks the
failed hunks belong in the new file rather than the old one.
.PP
As each hunk is completed, you will be told whether the hunk succeeded or
failed, and which line (in the new file)
.I patch
thought the hunk should go on.
If this is different from the line number specified in the diff you will
be told the offset.
A single large offset MAY be an indication that a hunk was installed in the
wrong place.
You will also be told if a fuzz factor was used to make the match, in which
case you should also be slightly suspicious.
.PP
If no original file is specified on the command line,
.I patch
will try to figure out from the leading garbage what the name of the file
to edit is.
In the header of a context diff, the filename is found from lines beginning
with \*(L"***\*(R" or \*(L"---\*(R", with the shortest name of an existing
file winning.
Only context diffs have lines like that, but if there is an \*(L"Index:\*(R"
line in the leading garbage,
.I patch
will try to use the filename from that line.
The context diff header takes precedence over an Index line.
If no filename can be intuited from the leading garbage, you will be asked
for the name of the file to patch.
.PP
(If the original file cannot be found, but a suitable SCCS or RCS file is
handy,
.I patch
will attempt to get or check out the file.)
.PP
Additionally, if the leading garbage contains a \*(L"Prereq: \*(R" line,
.I patch
will take the first word from the prerequisites line (normally a version
number) and check the input file to see if that word can be found.
If not,
.I patch
will ask for confirmation before proceeding.
.PP
The upshot of all this is that you should be able to say, while in a news
interface, the following:
.Sp
| patch -d /usr/src/local/blurfl
.Sp
and patch a file in the blurfl directory directly from the article containing
the patch.
.PP
If the patch file contains more than one patch,
.I patch
will try to apply each of them as if they came from separate patch files.
This means, among other things, that it is assumed that the name of the file
to patch must be determined for each diff listing,
and that the garbage before each diff listing will
be examined for interesting things such as filenames and revision level, as
mentioned previously.
You can give switches (and another original file name) for the second and
subsequent patches by separating the corresponding argument lists
by a \*(L'+\*(R'.
(The argument list for a second or subsequent patch may not specify a new
patch file, however.)
.PP
.I Patch
recognizes the following switches:
.TP 5
.B \-b
causes the next argument to be interpreted as the backup extension, to be
used in place of \*(L".orig\*(R".
.TP 5
.B \-c
forces
.I patch
to interpret the patch file as a context diff.
.TP 5
.B \-d
causes
.I patch
to interpret the next argument as a directory, and cd to it before doing
anything else.
.TP 5
.B \-D
causes
.I patch
to use the "#ifdef...#endif" construct to mark changes.
The argument following will be used as the differentiating symbol.
Note that, unlike the C compiler, there must be a space between the
.B \-D
and the argument.
.TP 5
.B \-e
forces
.I patch
to interpret the patch file as an ed script.
.TP 5
.B \-f
forces
.I patch
to assume that the user knows exactly what he or she is doing, and to not
ask any questions.
It does not suppress commentary, however.
Use
.B \-s
for that.
.TP 5
.B \-F<number>
sets the maximum fuzz factor.
This switch only applied to context diffs, and causes
.I patch
to ignore up to that many lines in looking for places to install a hunk.
Note that a larger fuzz factor increases the odds of a faulty patch.
The default fuzz factor is 2, and it may not be set to more than
the number of lines of context in the context diff, ordinarily 3.
.TP 5
.B \-l
causes the pattern matching to be done loosely, in case the tabs and
spaces have been munged in your input file.
Any sequence of whitespace in the pattern line will match any sequence
in the input file.
Normal characters must still match exactly.
Each line of the context must still match a line in the input file.
.TP 5
.B \-n
forces
.I patch
to interpret the patch file as a normal diff.
.TP 5
.B \-N
causes
.I patch
to ignore patches that it thinks are reversed or already applied.
See also
.B \-R .
.TP 5
.B \-o
causes the next argument to be interpreted as the output file name.
.TP 5
.B \-p<number>
sets the pathname strip count,
which controls how pathnames found in the patch file are treated, in case
the you keep your files in a different directory than the person who sent
out the patch.
The strip count specifies how many backslashes are to be stripped from
the front of the pathname.
(Any intervening directory names also go away.)
For example, supposing the filename in the patch file was
.sp
/u/howard/src/blurfl/blurfl.c
.sp
setting
.B \-p
or
.B \-p0
gives the entire pathname unmodified,
.B \-p1
gives
.sp
u/howard/src/blurfl/blurfl.c
.sp
without the leading slash,
.B \-p4
gives
.sp
blurfl/blurfl.c
.sp
and not specifying
.B \-p
at all just gives you "blurfl.c".
Whatever you end up with is looked for either in the current directory,
or the directory specified by the
.B \-d
switch.
.TP 5
.B \-r
causes the next argument to be interpreted as the reject file name.
.TP 5
.B \-R
tells
.I patch
that this patch was created with the old and new files swapped.
(Yes, I'm afraid that does happen occasionally, human nature being what it
is.)
.I Patch
will attempt to swap each hunk around before applying it.
Rejects will come out in the swapped format.
The
.B \-R
switch will not work with ed diff scripts because there is too little
information to reconstruct the reverse operation.
.Sp
If the first hunk of a patch fails,
.I patch
will reverse the hunk to see if it can be applied that way.
If it can, you will be asked if you want to have the
.B \-R
switch set.
If it can't, the patch will continue to be applied normally.
(Note: this method cannot detect a reversed patch if it is a normal diff
and if the first command is an append (i.e. it should have been a delete)
since appends always succeed, due to the fact that a null context will match
anywhere.
Luckily, most patches add or change lines rather than delete them, so most
reversed normal diffs will begin with a delete, which will fail, triggering
the heuristic.)
.TP 5
.B \-s
makes
.I patch
do its work silently, unless an error occurs.
.TP 5
.B \-S
causes
.I patch
to ignore this patch from the patch file, but continue on looking
for the next patch in the file.
Thus
.sp
patch -S + -S + <patchfile
.sp
will ignore the first and second of three patches.
.TP 5
.B \-v
causes
.I patch
to print out it's revision header and patch level.
.TP 5
.B \-x<number>
sets internal debugging flags, and is of interest only to
.I patch
patchers.
.SH ENVIRONMENT
No environment variables are used by
.IR patch .
.SH FILES
/tmp/patch*
.SH SEE ALSO
diff(1)
.SH NOTES FOR PATCH SENDERS
There are several things you should bear in mind if you are going to
be sending out patches.
First, you can save people a lot of grief by keeping a patchlevel.h file
which is patched to increment the patch level as the first diff in the
patch file you send out.
If you put a Prereq: line in with the patch, it won't let them apply
patches out of order without some warning.
Second, make sure you've specified the filenames right, either in a
context diff header, or with an Index: line.
If you are patching something in a subdirectory, be sure to tell the patch
user to specify a
.B \-p
switch as needed.
Third, you can create a file by sending out a diff that compares a
null file to the file you want to create.
This will only work if the file you want to create doesn't exist already in
the target directory.
Fourth, take care not to send out reversed patches, since it makes people wonder
whether they already applied the patch.
Fifth, while you may be able to get away with putting 582 diff listings into
one file, it is probably wiser to group related patches into separate files in
case something goes haywire.
.SH DIAGNOSTICS
Too many to list here, but generally indicative that
.I patch
couldn't parse your patch file.
.PP
The message \*(L"Hmm...\*(R" indicates that there is unprocessed text in
the patch file and that
.I patch
is attempting to intuit whether there is a patch in that text and, if so,
what kind of patch it is.
.SH CAVEATS
.I Patch
cannot tell if the line numbers are off in an ed script, and can only detect
bad line numbers in a normal diff when it finds a \*(L"change\*(R" or
a \*(L"delete\*(R" command.
A context diff using fuzz factor 3 may have the same problem.
Until a suitable interactive interface is added, you should probably do
a context diff in these cases to see if the changes made sense.
Of course, compiling without errors is a pretty good indication that the patch
worked, but not always.
.PP
.I Patch
usually produces the correct results, even when it has to do a lot of
guessing.
However, the results are guaranteed to be correct only when the patch is
applied to exactly the same version of the file that the patch was
generated from.
.SH BUGS
Could be smarter about partial matches, excessively \&deviant offsets and
swapped code, but that would take an extra pass.
.PP
If code has been duplicated (for instance with #ifdef OLDCODE ... #else ...
#endif),
.I patch
is incapable of patching both versions, and, if it works at all, will likely
patch the wrong one, and tell you that it succeeded to boot.
.PP
If you apply a patch you've already applied,
.I patch
will think it is a reversed patch, and offer to un-apply the patch.
This could be construed as a feature.
SHAR_EOF
if test 13700 -ne "`wc -c patch.man`"
then
echo shar: error transmitting patch.man '(should have been 13700 characters)'
fi
# End of shell archive
exit 0ain@j.cc.purdue.edu (Patrick White) (03/06/88)
Program Name: patch (part 1 of 2)
Submitted By: Johan Widen <jw@sics.se>
Summary: Patch ported to the Amiga.
Poster Boy: Pat White (ain@j.cc.purdue.edu)
Untested.
NOTES:
This is the unix patch program ported to the Amiga. The Makefile
appears to be for unix, but the program is supposed to be for the Amiga.
I've reshared this from the orgional zoo file so the binary and sources
could be separated, and so the docs could be posted separately.
-- Pat White (co-moderator comp.sources/binaries.amiga)
UUCP: j.cc.purdue.edu!ain BITNET: PATWHITE@PURCCVM PHONE: (317) 743-8421
U.S. Mail: 320 Brown St. apt. 406, West Lafayette, IN 47906
========================================
# This is a shell archive.
# Remove everything above and including the cut line.
# Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: Shell Archiver
# Run the following text with /bin/sh to create:
# Makefile
# EXTERN.h
# INTERN.h
# common.h
# config.h
# dfindOne.c
# filereq.c
# inp.c
# inp.h
# newwildcmp.c
# patchlevel.h
# pch.h
# request.c
# util.c
# util.h
# This archive created: Sun Mar 6 02:43:18 1988
# By: Patrick White (PUCC Land, USA)
echo shar: extracting Makefile '(1860 characters)'
cat << \SHAR_EOF > Makefile
# $Header: Makefile.SH,v 2.0 86/09/17 15:36:15 lwall Exp $
#
# $Log: Makefile.SH,v $
# Revision 2.0 86/09/17 15:36:15 lwall
# Baseline for netwide release.
#
# Revision 1.2 86/09/08 14:07:42 lwall
# Split up patch.c.
#
# Revision 1.1 86/08/01 20:18:35 lwall
# Initial revision
#
CC = cc
bin = /usr/local/bin
mansrc = /usr/man/mann
manext = n
CFLAGS =-b -r
LDFLAGS =
public = patch
private =
manpages = patch.man
util = Makefile
c = patch.c pch.c inp.c version.c util.c request.c filereq.c newwildcmp.c \
dfindOne.c
obj = patch.o pch.o inp.o util.o version.o request.o filereq.o newwildcmp.o \
dfindOne.o
lintflags = -phbvxac
addedbyconf = Makefile.old bsd config.h config.sh eunice loc pdp11 usg v7
# grrr
SHELL = /bin/sh
#.c.o:
# $(CC) -c $(CFLAGS) $*.c
#all: $(public) $(private) $(util)
# touch all
patch: $(obj)
$(CC) $(LDFLAGS) $(obj) $(libs) -o patch
# won't work with csh
#install: patch
# export PATH || exit 1
# - mv $(bin)/patch $(bin)/patch.old
# - if test `pwd` != $(bin); then cp $(public) $(bin); fi
# cd $(bin); chmod 755 $(public)
# - if test `pwd` != $(mansrc); then \
#for page in $(manpages); do \
#cp $$page $(mansrc)/`basename $$page .man`.$(manext); \
#done; \
#fi
clean:
rm -f *.o *.orig core
realclean:
rm -f patch *.o *.orig core $(addedbyconf)
# The following lint has practically everything turned on. Unfortunately,
# you have to wade through a lot of mumbo jumbo that can't be suppressed.
# If the source file has a /*NOSTRICT*/ somewhere, ignore the lint message
# for that spot.
lint:
lint $(lintflags) $(defs) $(c) > patch.fuzz
patch.o: config.h common.h patch.c inp.h pch.h util.h version.h
pch.o: config.h common.h pch.c pch.h util.h
inp.o: config.h common.h inp.c inp.h util.h
util.o: config.h common.h util.c util.h
version.o: config.h common.h version.c version.h patchlevel.h util.h
SHAR_EOF
if test 1860 -ne "`wc -c Makefile`"
then
echo shar: error transmitting Makefile '(should have been 1860 characters)'
fi
echo shar: extracting EXTERN.h '(241 characters)'
cat << \SHAR_EOF > EXTERN.h
/* $Header: EXTERN.h,v 2.0 86/09/17 15:35:37 lwall Exp $
*
* $Log: EXTERN.h,v $
* Revision 2.0 86/09/17 15:35:37 lwall
* Baseline for netwide release.
*
*/
#undef EXT
#define EXT extern
#undef INIT
#define INIT(x)
#undef DOINIT
SHAR_EOF
if test 241 -ne "`wc -c EXTERN.h`"
then
echo shar: error transmitting EXTERN.h '(should have been 241 characters)'
fi
echo shar: extracting INTERN.h '(239 characters)'
cat << \SHAR_EOF > INTERN.h
/* $Header: INTERN.h,v 2.0 86/09/17 15:35:58 lwall Exp $
*
* $Log: INTERN.h,v $
* Revision 2.0 86/09/17 15:35:58 lwall
* Baseline for netwide release.
*
*/
#undef EXT
#define EXT
#undef INIT
#define INIT(x) = x
#define DOINIT
SHAR_EOF
if test 239 -ne "`wc -c INTERN.h`"
then
echo shar: error transmitting INTERN.h '(should have been 239 characters)'
fi
echo shar: extracting common.h '(4136 characters)'
cat << \SHAR_EOF > common.h
/* $Header: common.h,v 2.0 86/09/17 15:36:39 lwall Exp $
*
* $Log: common.h,v $
* Revision 2.0 86/09/17 15:36:39 lwall
* Baseline for netwide release.
*
*/
#define DEBUGGING
#include "config.h"
/* shut lint up about the following when return value ignored */
#define Signal (void)signal
#define Unlink (void)unlink
#define Lseek (void)lseek
#define Fseek (void)fseek
#define Fstat (void)fstat
#define Pclose (void)pclose
#define Close (void)close
#define Fclose (void)fclose
#define Fflush (void)fflush
#define Sprintf (void)sprintf
#define Mktemp (void)mktemp
#define Strcpy (void)strcpy
#define Strcat (void)strcat
#ifdef AMIGA
#include <exec/types.h>
#include <dos.h>
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#else
#include <stdio.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <signal.h>
#endif
/* constants */
#ifndef AMIGA
#define TRUE (1)
#define FALSE (0)
#endif
#define MAXHUNKSIZE 100000 /* is this enough lines? */
#define INITHUNKMAX 125 /* initial dynamic allocation size */
#define MAXLINELEN 1024
#define BUFFERSIZE 1024
#define ORIGEXT ".orig"
#define SCCSPREFIX "s."
#define GET "get -e %s"
#define RCSSUFFIX ",v"
#define CHECKOUT "co -l %s"
/* handy definitions */
#define Null(t) ((t)0)
#define Nullch Null(char *)
#define Nullfp Null(FILE *)
#define Nulline Null(LINENUM)
#define Ctl(ch) ((ch) & 037)
#define strNE(s1,s2) (strcmp(s1, s2))
#define strEQ(s1,s2) (!strcmp(s1, s2))
#define strnNE(s1,s2,l) (strncmp(s1, s2, l))
#define strnEQ(s1,s2,l) (!strncmp(s1, s2, l))
/* typedefs */
typedef char bool;
typedef long LINENUM; /* must be signed */
typedef unsigned MEM; /* what to feed malloc */
/* globals */
EXT int Argc; /* guess */
EXT char **Argv;
EXT int Argc_last; /* for restarting plan_b */
EXT char **Argv_last;
#ifdef AMIGA
EXT struct FILEINFO filestat;
#else
EXT struct stat filestat; /* file statistics area */
#endif
EXT int filemode INIT(0644);
EXT char buf[MAXLINELEN]; /* general purpose buffer */
EXT FILE *ofp INIT(Nullfp); /* output file pointer */
EXT FILE *rejfp INIT(Nullfp); /* reject file pointer */
EXT bool using_plan_a INIT(TRUE); /* try to keep everything in memory */
EXT bool out_of_mem INIT(FALSE); /* ran out of memory in plan a */
#define MAXFILEC 2
EXT int filec INIT(0); /* how many file arguments? */
EXT char *filearg[MAXFILEC];
EXT bool ok_to_create_file INIT(FALSE);
EXT char *bestguess INIT(Nullch); /* guess at correct filename */
EXT char *outname INIT(Nullch);
EXT char rejname[128];
EXT char *origext INIT(Nullch);
#ifdef AMIGA
EXT char TMPOUTNAME[] INIT(":t/patchoXXXXXX");
EXT char TMPINNAME[] INIT(":t/patchiXXXXXX"); /* might want /usr/tmp here */
EXT char TMPREJNAME[] INIT(":t/patchrXXXXXX");
EXT char TMPPATNAME[] INIT(":t/patchpXXXXXX");
#else
EXT char TMPOUTNAME[] INIT("/tmp/patchoXXXXXX");
EXT char TMPINNAME[] INIT("/tmp/patchiXXXXXX"); /* might want /usr/tmp here */
EXT char TMPREJNAME[] INIT("/tmp/patchrXXXXXX");
EXT char TMPPATNAME[] INIT("/tmp/patchpXXXXXX");
#endif
EXT bool toutkeep INIT(FALSE);
EXT bool trejkeep INIT(FALSE);
EXT LINENUM last_offset INIT(0);
#ifdef DEBUGGING
EXT int debug INIT(0);
#endif
EXT LINENUM maxfuzz INIT(2);
EXT bool force INIT(FALSE);
EXT bool verbose INIT(TRUE);
EXT bool reverse INIT(FALSE);
EXT bool noreverse INIT(FALSE);
EXT bool skip_rest_of_patch INIT(FALSE);
EXT int strippath INIT(957);
EXT bool canonicalize INIT(FALSE);
#define CONTEXT_DIFF 1
#define NORMAL_DIFF 2
#define ED_DIFF 3
#define NEW_CONTEXT_DIFF 4
EXT int diff_type INIT(0);
EXT bool do_defines INIT(FALSE); /* patch using ifdef, ifndef, etc. */
EXT char if_defined[128]; /* #ifdef xyzzy */
EXT char not_defined[128]; /* #ifndef xyzzy */
EXT char else_defined[] INIT("#else\n");/* #else */
EXT char end_defined[128]; /* #endif xyzzy */
EXT char *revision INIT(Nullch); /* prerequisite revision, if any */
#ifndef AMIGA
char *malloc();
char *realloc();
char *strcpy();
char *strcat();
char *sprintf(); /* usually */
long atol();
long lseek();
char *mktemp();
#endif
SHAR_EOF
if test 4136 -ne "`wc -c common.h`"
then
echo shar: error transmitting common.h '(should have been 4136 characters)'
fi
echo shar: extracting config.h '(781 characters)'
cat << \SHAR_EOF > config.h
/* config.h
* This file was produced by running the Configure script.
* Feel free to modify any of this as the need arises.
*/
#/*undef EUNICE /* no file linking? */
#/*undef VMS /* other assorted ickies? */
#define index strchr /* cultural */
#define rindex strrchr /* differences? */
#/*undef void int /* is void to be avoided? */
/* How many register declarations are paid attention to? */
#define Reg1 register /**/
#define Reg2 register /**/
#define Reg3 register /**/
#define Reg4 register /**/
#define Reg5 register /**/
#define Reg6 register /**/
#define Reg7 /**/
#define Reg8 /**/
#define Reg9 /**/
#define Reg10 /**/
#define Reg11 /**/
#define Reg12 /**/
#define Reg13 /**/
#define Reg14 /**/
#define Reg15 /**/
#define Reg16 /**/
SHAR_EOF
if test 781 -ne "`wc -c config.h`"
then
echo shar: error transmitting config.h '(should have been 781 characters)'
fi
echo shar: extracting dfindOne.c '(731 characters)'
cat << \SHAR_EOF > dfindOne.c
#ifdef AMIGA
#include <dos.h>
#include <exec/memory.h>
#include <proto/exec.h>
#include <proto/dos.h>
/* Behaves almost like the Lattice dfind function, but dfindOne will not
* keep a lock.
*/
int dfindOne(info, name, attr)
struct FILEINFO *info;
char *name;
int attr;
{
BPTR lock;
struct FILEINFO *tmpInfo;
int retVal;
if(!(lock = Lock(name, ACCESS_READ)))
return(-1);
tmpInfo = (struct FILEINFO *) AllocMem(sizeof(*tmpInfo), MEMF_CLEAR);
if(retVal = Examine(lock, tmpInfo))
movmem((char *) tmpInfo, (char *) info, sizeof(*tmpInfo));
FreeMem((char *) tmpInfo, sizeof(*tmpInfo));
UnLock(lock);
if(retVal && (attr || info->fib_DirEntryType < 0))
return(0);
else
return(-1);
}
#endif
SHAR_EOF
if test 731 -ne "`wc -c dfindOne.c`"
then
echo shar: error transmitting dfindOne.c '(should have been 731 characters)'
fi
echo shar: extracting filereq.c '(22900 characters)'
cat << \SHAR_EOF > filereq.c
/*
* STDFILE -- Standard File Requestor. Version 2.0a 15 June 1987
*
* AUTHOR -- Peter da Silva US (713) 497-4372
*
* Reorganized by Matthew Dillon for use with * and ?. Added:
* -device name in File string gadget transfered to directory
* gadget without closing the window.
* -bug when requesting volume ""... current directory lock would
* get unlocked!
* -additional intuitive features added
* -coding reorganized
*
* Copyright (c) 1987 Peter da Silva, all rights reserved.
* Changes (c)Copyright 1987 Matthew Dillon, all rights reserved.
*
* This module may be freely used in any product, commercial or
* otherwise, provided credit is given for this module and
* and provided this notice remains intact in the source. The
* intent of this module is to provide a standard file requestor
* such as is available on the Macintosh, in GEM on the IBM-PC
* and Atari ST, and in the Microsoft Windows software on the
* IBM-PC. The advantage this module has over other requestors
* is that it minimises disk accesses: an important consideration
* given the structure of AmigaDos directories. If you need to
* modify it for your needs, by all means go ahead... but please
* conform to the intent of this program as stated above. If you
* have suggestions for improvements, by all means call me at
* the number listed above.
*
* Enhancements in the current version:
*
* Gadgets now boxed. Display generally cleaned up.
*
* True "dictionary order" for searches.
*
* Default pattern can now be specified. Default file name now
* specified in a single argument.
*
* Directories always match.
*
* Null pattern converted to "#?" universal wildcard.
*
* If you attempt to build a file name longer than 128 characters the
* screen will flash and the operation will be aborted.
*
* "Volumes" gadget, using the device list code in "mounted". This
* gadget brings up a list of all currently mounted volumes for
* selection. Volumes leaves the directory specification intact, so
* you can quickly return to where you left off.
*
* With these enhancements it is now possible to select any file on
* any device without touching the keyboard. This is now release 2.0,
* as it is significantly better than 1.0.
*
* Acknowledgements:
*
* Thanks to Jeff Lydiatt for the pattern matching code in PatMatch.c
* Thanks to Jay Miner, =RJ= and the whole Amiga team for the Amiga
* itself.
*
* Environment:
*
* IntuitionBase and GfxBase must be open. dos.library must be open
* under the name "DosLibrary". Link with PatMatch.o and VolList.o.
*
* Usage:
*
* #define MAXFILENAME 128
*
* int stdfile(title, default_file, default_pat, name);
* char *title;
* char *default_file;
* char *default_pattern;
* char name[MAXFILENAME];
*
* +-----------------------------------+
* |o| Title ------------------- | | | title parameter, or "File Name"
* |-----------------------------------|
* | Directory: [ ] | Directory parameter, or current.
* | File name: [ ] | Default parameter, or empty.
* | Pattern: [ ] | Initially empty, if the user
* | +-------------------------------+ | enters anything here it will
* | | [Filename] | | | be used to select files. The
* | | [Filename] | | | file display will also be empty
* | | [Filename] |@@| | to start with to avoid excess
* | | [Filename] |@@| | disk I/O. If the user selects
* | | |@@| | here the directory will be
* | | |@@| | scanned looking for files
* | | | | | matching the specified pattern,
* | | | | | or "*" if no pattern is given.
* | | | | |
* | +-------------------------------+ | ACCEPT returns 1. CANCEL
* | [ACCEPT] [VOLUMES] [CANCEL] | or the close gadget return 0.
* +-----------------------------------+ VOLUMES displays volume names.
*
* The number of filenames displayed is specified at compile time in the
* constant MAXFILES. The maximum size of a filename is specified in the
* constant MAXNAME. The parameter "Default file" will be broken into
* directory and file parts.
*/
char *Copyright =
"stdfile V2.0a. Copyright (c) 1987 Peter da Silva. All rights reserved.";
#include <intuition/intuitionbase.h>
#include <intuition/intuition.h>
#include <libraries/dos.h>
#include <libraries/dosextens.h>
#include <exec/memory.h>
typedef unsigned char ubyte;
typedef unsigned short uword;
typedef unsigned long ulong;
typedef struct FileInfoBlock FIB;
typedef struct DeviceList DEVLIST;
typedef struct DosLibrary DOSLIB;
typedef struct DosInfo DOSINFO;
typedef struct RootNode ROOTNODE;
typedef struct IntuiMessage IMESS;
extern void CalcPropGadget();
extern void ProcessFileName();
extern void *malloc();
extern void *GetMsg();
extern struct Window *OpenWindow();
#define MAXFILES 8
#define MAXNAME 32
#define MAXFULL (MAXNAME*4)
/* SIZING PARAMS */
#define Z NULL
#define INDENT 6
#define LEFTMAR (INDENT-1)
#define BORDER 3
#define CHSIZ 8
#define HT CHSIZ
#define BASELINE 6
/* GADGET BORDERS */
#define IN1 LEFTMAR+10*CHSIZ
#define IN3 LEFTMAR+3
#define IN4 -(INDENT+6*CHSIZ+1)
#define IN5 -(INDENT+CHSIZ*2)
#define IN6 ((WINWD-WD6)/2)
#define WD1 -(INDENT+IN1)
#define WD3 (6*CHSIZ)
#define WD4 (6*CHSIZ)
#define WD5 (CHSIZ*2+2)
#define WD6 (7*CHSIZ)
#define TP1 (CHSIZ+BORDER)
#define TP2 (TP1+HT+1)
#define TP3 (TP2+HT+1)
#define TP4 -(BORDER+HT4-1)
#define TP5 (TP3+HT+BORDER)
#define HT4 (HT+1)
#define HT5 CHSIZ*MAXFILES+INDENT
#define WINHT (TP5 + HT5 + (-TP4) + BORDER)
#define WINWD (INDENT*4 + (MAXNAME+2)*CHSIZ)
#define WININ (640-WINWD)/2
#define WINTP (200-WINHT)/2
#define HOMEX (INDENT+LEFTMAR)
#define HOMEY (TP5+BORDER)
#define LASTX (HOMEX+MAXNAME*CHSIZ)
#define LASTY (HOMEY+MAXFILES*CHSIZ)
#define BTP TP5
#define BIN LEFTMAR
#define BWD (WINWD-INDENT-BIN)
#define BHT (WINHT-BTP-(-TP4+BORDER+1))
#define SF GADGHCOMP|GRELWIDTH
#define SEL SELECTED
#define BF1 GADGHCOMP|GRELBOTTOM
#define BF2 GADGHCOMP|GRELBOTTOM|GRELRIGHT
#define PF GRELRIGHT
#define SA RELVERIFY
#define CEN STRINGCENTER
#define BA RELVERIFY
#define PA RELVERIFY
#define SI(n) (APTR)&STD_String[n]
#define G(n) &STD_Gadget[n]
#define IMAG (APTR)&STD_Image
#define PROP (APTR)&STD_Prop
#define SG STRGADGET
#define BG BOOLGADGET
#define PG PROPGADGET
#define FP AUTOBACKPEN
#define BP AUTOFRONTPEN
#define OKTEXT &STD_OK
#define NOTEXT &STD_CANCEL
#define VLTEXT &STD_VOLUME
static int DoneFlag;
#define DirName SBuffer[0]
#define FileName SBuffer[1]
#define PatName SBuffer[2]
#define STRINGS 3
static UBYTE SBuffer[STRINGS][MAXFULL];
static UBYTE Undo[MAXFULL];
static struct StringInfo STD_String[STRINGS] = {
{SBuffer[0],Undo,0,MAXFULL,0},
{SBuffer[1],Undo,0,MAXFULL,0},
{SBuffer[2],Undo,0,MAXFULL,0}
};
static struct PropInfo STD_Prop = { AUTOKNOB|FREEVERT, 0, 0, 0, 0 };
static struct IntuiText STD_OK =
{ FP, BP, JAM2, 0, 1, Z, (UBYTE *)"ACCEPT", Z };
static struct IntuiText STD_CANCEL =
{ FP, BP, JAM2, 0, 1, Z, (UBYTE *)"CANCEL", Z };
static struct IntuiText STD_VOLUME =
{ FP, BP, JAM2, 0, 1, Z, (UBYTE *)"VOLUMES", Z };
#define BUTTONS 3
#define BUTVEC 8
static SHORT butvecs[BUTTONS][BUTVEC*2] = {
{-2,HT4,-2,-1, WD3+1,-1, WD3+1,HT4, -3, HT4, -3,-1, WD3+2,-1, WD3+2, HT4 },
{-2,HT4,-2,-1, WD4+1,-1, WD4+1,HT4, -3, HT4, -3,-1, WD4+2,-1, WD4+2, HT4 },
{-2,HT4,-2,-1, WD6+1,-1, WD6+1,HT4, -3, HT4, -3,-1, WD6+2,-1, WD6+2, HT4 }
};
static struct Border ButBorder[BUTTONS] = {
{0, 0, FP, BP, JAM1, BUTVEC, butvecs[0], NULL},
{0, 0, FP, BP, JAM1, BUTVEC, butvecs[1], NULL},
{0, 0, FP, BP, JAM1, BUTVEC, butvecs[2], NULL}
};
#define BB(n) (APTR)&ButBorder[n]
static struct Image STD_Image;
#define DIRID 0
#define FILID 1
#define PATID 2
#define YESID 3
#define CANID 4
#define VOLID 5
#define BARID 6
#define GADGETS 7
static struct Gadget STD_Gadget[GADGETS] = {
/*NEXT, LFT, TP,WDTH, H, FLAG, ACT, TYP, REND, Z, TXT, Z, SPEC, ID, Z */
{ G(1), IN1,TP1, WD1,HT, SF, SA, SG, Z, Z, Z, Z, SI(0), 0, 0 },
{ G(2), IN1,TP2, WD1,HT, SF|SEL, SA, SG, Z, Z, Z, Z, SI(1), 1, 0 },
{ G(3), IN1,TP3, WD1,HT, SF, SA, SG, Z, Z, Z, Z, SI(2), 2, 0 },
{ G(4), IN3,TP4, WD3,HT4,BF1, BA, BG,BB(0), Z, OKTEXT, Z, Z, 3, 0 },
{ G(5), IN4,TP4, WD4,HT4,BF2, BA, BG,BB(1), Z, NOTEXT, Z, Z, 4, 0 },
{ G(6), IN6,TP4, WD6,HT4,BF1, BA, BG,BB(2), Z, VLTEXT, Z, Z, 5, 0 },
{ NULL, IN5,TP5, WD5,HT5,PF, PA, PG, IMAG, Z, Z, Z, PROP, 6, 0 }
};
static struct NewWindow STD_NewWindow = {
WININ, WINTP, WINWD, WINHT, -1, -1,
REFRESHWINDOW|MOUSEBUTTONS|GADGETUP|CLOSEWINDOW,
WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|SIMPLE_REFRESH|ACTIVATE,
G(0), NULL, (ubyte *)"File Name Requestor",
NULL, NULL, 0, 0, 0, 0, WBENCHSCREEN
};
static struct Window *STD_Window;
#define NVEC 6
static SHORT Vectors[NVEC*2] = {
BIN+1, BTP,
BIN+1, BTP+BHT,
BIN+BWD, BTP+BHT,
BIN+BWD, BTP,
BIN, BTP,
BIN, BTP+BHT
};
static struct Border STD_FileBox = {
0, 0, FP, BP, JAM1, NVEC, Vectors, NULL
};
static struct IntuiText STD_Text[3] = {
{ FP, BP, JAM2, 0, 0, NULL, (UBYTE *)"Directory:", NULL },
{ FP, BP, JAM2, 0, 0, NULL, (UBYTE *)"File Name:", NULL },
{ FP, BP, JAM2, 0, 0, NULL, (UBYTE *)"Pattern:", NULL }
};
static
OpenFileWindow()
{
extern struct IntuitionBase *IntuitionBase;
int i;
/* Rebuild gadget list */
STD_NewWindow.FirstGadget = &STD_Gadget[0];
for(i = 0; i < GADGETS; i++)
STD_Gadget[i].NextGadget = (i==GADGETS-1)?(0):(&STD_Gadget[i+1]);
for(i = 0; i < STRINGS; i++) {
STD_String[i].BufferPos = strlen(SBuffer[i]);
STD_String[i].DispPos = 0;
}
STD_Prop.VertBody = 0xFFFF;
STD_Prop.VertPot = 0;
if (!(STD_Window = OpenWindow(&STD_NewWindow)))
return(0);
/* This optional line will activate a string gadget */
if (IntuitionBase->LibNode.lib_Version > 32)
ActivateGadget(G(1),STD_Window,0L);
CalcPropGadget();
PaintFileWindow();
return (1);
}
static
CloseFileWindow()
{
STD_NewWindow.LeftEdge = STD_Window->LeftEdge;
STD_NewWindow.TopEdge = STD_Window->TopEdge;
if (STD_Window)
CloseWindow(STD_Window);
}
static int State;
#define INITIAL 0
#define DIRECTORY 1
static
PaintFileWindow()
{
DrawBorder(STD_Window->RPort, &STD_FileBox, 0, 0);
PrintIText(STD_Window->RPort, &STD_Text[0], LEFTMAR, TP1);
PrintIText(STD_Window->RPort, &STD_Text[1], LEFTMAR, TP2);
PrintIText(STD_Window->RPort, &STD_Text[2], LEFTMAR, TP3);
if (State == DIRECTORY)
PrintFileNames();
}
static int FirstFile;
static int Selected;
static int NumFiles;
static struct dirent {
struct dirent *nextfile;
SHORT filetype;
char *filename;
} *NameList, **NameTable;
#define FILETYPE 0
#define DIRTYPE 1
#define VOLTYPE 2
static
PrintFileNames()
{
int i;
for (i = 0; i < MAXFILES; ++i) {
SetBPen(STD_Window->RPort, BP);
SetAPen(STD_Window->RPort, BP);
RectFill(STD_Window->RPort, HOMEX, HOMEY+i*CHSIZ,
LASTX, HOMEY+(i+1)*CHSIZ);
if (i+FirstFile < NumFiles)
PrintName(i+FirstFile, i+FirstFile == Selected);
}
}
static
PrintName(file, hilite)
int file;
int hilite;
{
int i;
i = file - FirstFile;
Move(STD_Window->RPort, HOMEX, HOMEY+i*CHSIZ+BASELINE);
if (hilite == 0) {
SetBPen(STD_Window->RPort, BP);
if(NameTable[file]->filetype == FILETYPE)
SetAPen(STD_Window->RPort, FP);
else
SetAPen(STD_Window->RPort, 3);
} else {
SetAPen(STD_Window->RPort, BP);
if(NameTable[file]->filetype == FILETYPE)
SetBPen(STD_Window->RPort, FP);
else
SetBPen(STD_Window->RPort, 3);
}
Text(STD_Window->RPort, NameTable[file]->filename,
strlen(NameTable[file]->filename));
}
static
void
CalcPropGadget()
{
int VertPot, VertBody;
if (State == INITIAL)
return;
if (NumFiles <= MAXFILES) {
VertBody = 0xFFFF;
VertPot = 0;
FirstFile = 0;
} else {
VertBody = ((MAXFILES<<16)-1) / NumFiles;
VertPot = 0;
FirstFile = 0;
}
ModifyProp(&STD_Gadget[BARID], STD_Window, NULL,
STD_Prop.Flags, 0, VertPot, 0, VertBody
);
}
static
void
CalcFilePosition()
{
short old_pos;
if (State == INITIAL)
return;
old_pos = FirstFile;
if (NumFiles<=MAXFILES) {
FirstFile = 0;
} else {
int VertPot = STD_Prop.VertPot;
FirstFile = ((VertPot+1)*(NumFiles-MAXFILES))>>16;
}
if (old_pos != FirstFile)
PrintFileNames();
}
FreeList(list)
struct dirent *list;
{
struct dirent *ptr;
while(list) {
ptr = list->nextfile;
if (list->filename)
free(list->filename);
free(list);
list = ptr;
}
}
static
ReadNewDir()
{
struct dirent *NewList, **NewTable, *ptr;
int NewCount;
FIB *fib;
BPTR dirlock;
if (State != DIRECTORY) {
NameTable = 0;
NameList = 0;
}
if (DirName[0]) {
dirlock = Lock(DirName, ACCESS_READ);
} else {
BPTR ram;
if (ram = Lock("RAM:", ACCESS_READ)) {
dirlock = CurrentDir(ram);
CurrentDir(dirlock);
dirlock = DupLock(dirlock); /* added */
UnLock(ram);
}
}
if (!dirlock)
return(0);
if ((fib = (FIB *)malloc(sizeof(FIB))) == NULL) {
UnLock(dirlock);
return 0;
}
if (!Examine(dirlock, fib)) {
UnLock(dirlock);
free(fib);
return 0;
}
if (fib->fib_DirEntryType < 0) {
UnLock(dirlock);
free(fib);
return 0;
}
NewList = 0;
NewCount = 0;
while(ExNext(dirlock, fib)) {
NewCount += 1;
ptr = (struct dirent *)malloc(sizeof(struct dirent));
if (ptr == 0) {
FreeList(NewList);
UnLock(dirlock);
free(fib);
return(0);
}
ptr->nextfile = NewList;
ptr->filetype = (fib->fib_DirEntryType<0)?FILETYPE:DIRTYPE;
ptr->filename = malloc(strlen(fib->fib_FileName)+1);
if (ptr->filename == 0) {
FreeList(ptr);
UnLock(dirlock);
free(fib);
return(0);
}
strcpy(ptr->filename, fib->fib_FileName);
NewList = ptr;
}
free(fib);
if (DirName[0])
UnLock(dirlock);
NewTable = malloc(sizeof(struct dirent *) * NewCount);
if (NewTable==0) {
FreeList(NewList);
return(0);
}
FreeList(NameList);
NameList = NewList;
if (NameTable)
free(NameTable);
NameTable = NewTable;
if (PatName[0]==0)
SetPatName("*");
State = DIRECTORY;
Selected = -1;
ReCalcPattern();
}
static
ReadVol()
{
struct dirent *NewList, **NewTable, *ptr;
int NewCount;
char name[MAXNAME];
if (State != DIRECTORY) {
NameTable = 0;
NameList = 0;
}
OpenVolList();
NewList = 0;
NewCount = 0;
while(ReadVolList(name)) {
NewCount += 1;
ptr = (struct dirent *)malloc(sizeof(struct dirent));
if (ptr==0) {
FreeList(NewList);
return(0);
}
ptr->nextfile = NewList;
ptr->filetype = VOLTYPE;
ptr->filename = malloc(strlen(name)+1);
if (ptr->filename == 0) {
FreeList(ptr);
return(0);
}
strcpy(ptr->filename, name);
NewList = ptr;
}
CloseVolList();
NewTable = malloc(sizeof(struct dirent *)*NewCount);
if (NewTable==0) {
FreeList(NewList);
return(0);
}
FreeList(NameList);
NameList = NewList;
if (NameTable)
free(NameTable);
NameTable = NewTable;
if (PatName[0]==0)
SetPatName("*");
State = DIRECTORY;
Selected = -1;
ReCalcPattern();
}
/* this routine does a true dictionary search:
*
* Devs < devs but Devs > devices
*/
static
table_compare(p1, p2)
struct dirent **p1, **p2;
{
char *s1, *s2;
char c1, c2;
char firstdiff;
s1 = (*p1)->filename;
s2 = (*p2)->filename;
firstdiff = 0;
while(*s1 && *s2) {
c1 = *s1++;
c2 = *s2++;
if (firstdiff==0)
firstdiff = c1 - c2;
if (c1 >= 'A' && c1 <= 'Z') c1 = c1+'@';
if (c2 >= 'A' && c2 <= 'Z') c2 = c2+'@';
if (c1 != c2)
return c1 - c2;
}
return firstdiff;
}
static
sort_table()
{
qsort(NameTable, NumFiles, sizeof(struct dirent *), table_compare);
return 1;
}
static
ReCalcPattern()
{
if (State != DIRECTORY) {
ReadNewDir();
} else {
struct dirent *ptr;
if (!PatName[0])
SetPatName("*");
NumFiles = 0;
for (ptr = NameList; ptr; ptr=ptr->nextfile) {
/* Directories always match. Is this good? */
if (ptr->filetype == DIRTYPE || ptr->filetype == VOLTYPE ||
newwildcmp(PatName, ptr->filename)) {
NameTable[NumFiles] = ptr;
NumFiles++;
}
}
sort_table();
CalcPropGadget();
Selected = -1;
PrintFileNames();
}
}
static
SetGadgetText(id, text)
int id;
char *text;
{
int position;
position = RemoveGadget(STD_Window, G(id));
if (position != -1) {
strcpy(SBuffer[id], text);
STD_String[id].BufferPos = strlen(text);
position = AddGadget(STD_Window, G(id), -1);
if (position != -1)
RefreshGadgets(G(id), STD_Window, NULL);
}
}
static
SetDirName(name)
char *name;
{
char buffer[MAXFULL+1], *ptr;
int index;
char lastchar;
/* Can't enter a file name too long. */
if (strlen(DirName) + strlen(name) + 1 > MAXFULL) {
DisplayBeep();
return(0);
}
index = 0;
lastchar = 0;
for (ptr = (char *)DirName; *ptr; ptr++)
buffer[index++] = lastchar = *ptr;
if (lastchar != ':' && lastchar != 0)
buffer[index++] = '/';
strcpy(&buffer[index], name);
SetGadgetText(DIRID, buffer);
SetGadgetText(FILID, "");
return(1);
}
static
SetFileName(name)
char *name;
{
/* Can't enter a file name too long. */
if (strlen(DirName) + strlen(name) + 1 > MAXFULL) {
DisplayBeep();
return(0);
}
SetGadgetText(FILID, name);
return(1);
}
static
SetPatName(name)
char *name;
{
SetGadgetText(PATID, name);
}
static
ProcessGadget(id)
int id;
{
switch(id) {
case DIRID: ReadNewDir(); break;
case FILID: ProcessFileName(); break;
case PATID: ReCalcPattern(); break;
case BARID: CalcFilePosition(); break;
case YESID: DoneFlag = 1; break;
case CANID: DoneFlag = -1; break;
case VOLID: ReadVol(); break;
}
}
/*
* ProcessFileName() added by Matthew Dillon. If the requested file is
* actually a directory, do a ReadNewDir() instead of quiting.
*/
void
ProcessFileName()
{
register char *ptr;
register short len;
BPTR fillock;
char buf[128];
FIB *fib = (FIB *)malloc(sizeof(FIB));
if (fib == NULL) {
DoneFlag = 1;
return;
}
for (ptr = (char *)FileName; *ptr; ++ptr) {
if (*ptr == ':') {
DirName[0] = '\0';
break;
}
}
strcpy(buf, DirName);
if (FileName[0]) {
if (len = strlen(buf)) {
if (buf[len-1]!=':')
strcat(buf, "/");
}
strcat(buf, FileName);
if (fillock = Lock(buf, ACCESS_READ)) {
if (Examine(fillock, fib)) {
if (fib->fib_DirEntryType > 0) {
SetGadgetText(DIRID, buf);
SetGadgetText(FILID, "");
ReadNewDir();
free(fib);
UnLock(fillock);
return;
}
}
UnLock(fillock);
}
}
free(fib);
DoneFlag = 1;
}
static
ProcessMouse(x, y, code, seconds, micros)
{
int NewSelected;
static int oseconds = 0, omicros = 0;
if (x < HOMEX || y < HOMEY || x >= LASTX || y >= LASTY)
return;
if ((code & SELECTUP) == SELECTUP)
return;
if (State != DIRECTORY) {
ReadNewDir();
return;
}
NewSelected = (y-HOMEY)/CHSIZ + FirstFile;
if (NewSelected == Selected) {
if (Selected != -1) {
if (DoubleClick(oseconds, omicros, seconds, micros)) {
if (NameTable[Selected]->filetype == DIRTYPE) {
if (SetDirName(NameTable[Selected]->filename))
ReadNewDir();
} else if (NameTable[Selected]->filetype == VOLTYPE) {
SetGadgetText(DIRID, NameTable[Selected]->filename);
SetGadgetText(FILID, "");
ReadNewDir();
} else if (!SetFileName(NameTable[Selected]->filename)) {
Selected = -1;
DoneFlag = 1;
}
}
}
} else {
if (Selected != -1 && Selected >= FirstFile &&
Selected < FirstFile+MAXFILES)
PrintName(Selected, 0);
Selected = NewSelected;
if (Selected >= NumFiles) {
Selected = -1;
} else {
if (SetFileName(NameTable[Selected]->filename))
PrintName(Selected, 1);
else
Selected = -1;
if (IntuitionBase->LibNode.lib_Version > 32)
ActivateGadget(G(1),STD_Window,0L);
}
}
oseconds = seconds;
omicros = micros;
}
stdfile(title, deffile, defpat, name)
char *title, *deffile, *defpat, *name;
{
IMESS *im;
if(title)
STD_NewWindow.Title = (UBYTE *)title;
else
STD_NewWindow.Title = (UBYTE *)"Enter File Name";
if (deffile) {
int i;
for (i = strlen(deffile)-1; i >= 0; --i) {
if (deffile[i]==':' || deffile[i]=='/') {
int hold;
strcpy(FileName, &deffile[i+1]);
if (deffile[i]==':')
i++;
hold = deffile[i];
deffile[i] = 0;
strcpy(DirName, deffile);
deffile[i] = hold;
break;
}
}
if (i < 0) {
strcpy(FileName, deffile);
DirName[0] = 0;
}
} else {
DirName[0] = 0;
FileName[0] = 0;
}
if (defpat)
strcpy(PatName, defpat);
else
PatName[0] = 0;
State = INITIAL;
NameTable = 0;
NameList = 0;
if(!OpenFileWindow())
return(0);
DoneFlag = 0;
while (!DoneFlag) {
Wait(1<<STD_Window->UserPort->mp_SigBit);
while(im = GetMsg(STD_Window->UserPort)) {
switch(im->Class) {
case CLOSEWINDOW:
DoneFlag = -1;
break;
case MOUSEBUTTONS:
ProcessMouse(im->MouseX, im->MouseY, im->Code, im->Seconds,
im->Micros);
break;
case GADGETUP:
ProcessGadget(((struct Gadget *)im->IAddress)->GadgetID);
break;
case REFRESHWINDOW:
BeginRefresh(STD_Window);
PaintFileWindow();
EndRefresh(STD_Window, 1);
break;
}
ReplyMsg(im);
}
}
CloseFileWindow();
FreeList(NameList);
if (NameTable)
free(NameTable);
if (DoneFlag == 1) {
int len;
strcpy(name, DirName);
if (FileName[0]) {
if (len = strlen(name)) {
if (name[len-1]!=':')
strcat(name, "/");
}
strcat(name, FileName);
return(1);
}
}
return(0);
}
/*
* VOLLIST.C
*/
#define toAPTR(b) ((b)<<2)
#define toBPTR(a) ((a)>>2)
struct DeviceList *list;
OpenVolList()
{
extern DOSLIB *DOSBase;
ROOTNODE *root;
DOSINFO *info;
root = (ROOTNODE *)DOSBase->dl_Root;
info = (DOSINFO *)toAPTR(root->rn_Info);
list = (DEVLIST *)toAPTR(info->di_DevInfo);
}
ReadVolList(name)
char *name;
{
register DEVLIST *next;
while(list) {
next = (DEVLIST *)toAPTR(list->dl_Next);
if (list->dl_Type == DLT_VOLUME) {
char *ptr;
int count;
ptr = (char *)toAPTR((BPTR)list->dl_Name);
count = *ptr++;
if (count > 30)
count = 30;
strncpy(name, ptr, count);
name[count++] = ':';
name[count] = 0;
list = next;
return(1);
}
list = next;
}
return(0);
}
CloseVolList()
{
}
SHAR_EOF
if test 22900 -ne "`wc -c filereq.c`"
then
echo shar: error transmitting filereq.c '(should have been 22900 characters)'
fi
echo shar: extracting inp.c '(8471 characters)'
cat << \SHAR_EOF > inp.c
/* $Header: inp.c,v 2.0 86/09/17 15:37:02 lwall Exp $
*
* $Log: inp.c,v $
* Revision 2.0 86/09/17 15:37:02 lwall
* Baseline for netwide release.
*
*/
#include "EXTERN.h"
#include "common.h"
#include "util.h"
#include "pch.h"
#include "INTERN.h"
#include "inp.h"
/* Input-file-with-indexable-lines abstract type */
static long i_size; /* size of the input file */
static char *i_womp; /* plan a buffer for entire file */
static char **i_ptr; /* pointers to lines in i_womp */
static int tifd = -1; /* plan b virtual string array */
static char *tibuf[2]; /* plan b buffers */
static LINENUM tiline[2] = {-1, -1}; /* 1st line in each buffer */
static LINENUM lines_per_buf; /* how many lines per buffer */
static int tireclen; /* length of records in tmp file */
/* New patch--prepare to edit another file. */
void
re_input()
{
if (using_plan_a) {
i_size = 0;
#ifndef lint
if (i_ptr != Null(char**))
free((char *)i_ptr);
#endif
if (i_womp != Nullch)
free(i_womp);
i_womp = Nullch;
i_ptr = Null(char **);
}
else {
using_plan_a = TRUE; /* maybe the next one is smaller */
Close(tifd);
tifd = -1;
free(tibuf[0]);
free(tibuf[1]);
tibuf[0] = tibuf[1] = Nullch;
tiline[0] = tiline[1] = -1;
tireclen = 0;
}
}
/* Constuct the line index, somehow or other. */
void
scan_input(filename)
char *filename;
{
if (!plan_a(filename))
plan_b(filename);
if (verbose) {
say3("Patching file %s using Plan %s...\n", filename,
(using_plan_a ? "A" : "B") );
}
}
/* Try keeping everything in memory. */
bool
plan_a(filename)
char *filename;
{
int ifd;
Reg1 char *s;
Reg2 LINENUM iline;
#ifdef AMIGA
if (ok_to_create_file && dfindOne(&filestat, filename, 1)) {
#else
if (ok_to_create_file && stat(filename, &filestat) < 0) {
#endif
if (verbose)
say2("(Creating file %s...)\n",filename);
makedirs(filename, TRUE);
close(creat(filename, 0666));
}
#ifdef AMIGA
if (dfindOne(&filestat, filename, 0))
fatal2("Can't find %s.\n", filename);
#else
if (stat(filename, &filestat) < 0) {
Sprintf(buf, "RCS/%s%s", filename, RCSSUFFIX);
if (stat(buf, &filestat) >= 0 || stat(buf+4, &filestat) >= 0) {
Sprintf(buf, CHECKOUT, filename);
if (verbose)
say2("Can't find %s--attempting to check it out from RCS.\n",
filename);
if (system(buf) || stat(filename, &filestat))
fatal2("Can't check out %s.\n", filename);
}
else {
Sprintf(buf, "SCCS/%s%s", SCCSPREFIX, filename);
if (stat(buf, &filestat) >= 0 || stat(buf+5, &filestat) >= 0) {
Sprintf(buf, GET, filename);
if (verbose)
say2("Can't find %s--attempting to get it from SCCS.\n",
filename);
if (system(buf) || stat(filename, &filestat))
fatal2("Can't get %s.\n", filename);
}
else
fatal2("Can't find %s.\n", filename);
}
}
#endif
#ifdef AMIGA
filemode = filestat.fib_Protection ^ 15;
i_size = filestat.fib_Size;
#else
filemode = filestat.st_mode;
if ((filemode & S_IFMT) & ~S_IFREG)
fatal2("%s is not a normal file--can't patch.\n", filename);
i_size = filestat.st_size;
#endif
if (out_of_mem) {
set_hunkmax(); /* make sure dynamic arrays are allocated */
out_of_mem = FALSE;
return FALSE; /* force plan b because plan a bombed */
}
#ifdef lint
i_womp = Nullch;
#else
i_womp = malloc((MEM)(i_size+2)); /* lint says this may alloc less than */
/* i_size, but that's okay, I think. */
#endif
if (i_womp == Nullch)
return FALSE;
if ((ifd = open(filename, 0)) < 0)
fatal2("Can't open file %s\n", filename);
#ifndef lint
if (read(ifd, i_womp, (int)i_size) != i_size) {
Close(ifd); /* probably means i_size > 15 or 16 bits worth */
free(i_womp); /* at this point it doesn't matter if i_womp was */
return FALSE; /* undersized. */
}
#endif
Close(ifd);
if (i_size && i_womp[i_size-1] != '\n')
i_womp[i_size++] = '\n';
i_womp[i_size] = '\0';
/* count the lines in the buffer so we know how many pointers we need */
iline = 0;
for (s=i_womp; *s; s++) {
if (*s == '\n')
iline++;
}
#ifdef lint
i_ptr = Null(char**);
#else
i_ptr = (char **)malloc((MEM)((iline + 2) * sizeof(char *)));
#endif
if (i_ptr == Null(char **)) { /* shucks, it was a near thing */
free((char *)i_womp);
return FALSE;
}
/* now scan the buffer and build pointer array */
iline = 1;
i_ptr[iline] = i_womp;
for (s=i_womp; *s; s++) {
if (*s == '\n')
i_ptr[++iline] = s+1; /* these are NOT null terminated */
}
input_lines = iline - 1;
/* now check for revision, if any */
if (revision != Nullch) {
if (!rev_in_string(i_womp)) {
if (force) {
if (verbose)
say2(
"Warning: this file doesn't appear to be the %s version--patching anyway.\n",
revision);
}
else {
#ifdef AMIGA
ask2(
"This file doesn't appear to be the %s version--patch anyway?",
revision);
#else
ask2("\
This file doesn't appear to be the %s version--patch anyway? [n] ",
revision);
#endif
if (*buf != 'y')
fatal1("Aborted.\n");
}
}
else if (verbose)
say2("Good. This file appears to be the %s version.\n",
revision);
}
return TRUE; /* plan a will work */
}
/* Keep (virtually) nothing in memory. */
void
plan_b(filename)
char *filename;
{
Reg3 FILE *ifp;
Reg1 int i = 0;
Reg2 int maxlen = 1;
Reg4 bool found_revision = (revision == Nullch);
using_plan_a = FALSE;
if ((ifp = fopen(filename, "r")) == Nullfp)
fatal2("Can't open file %s\n", filename);
if ((tifd = creat(TMPINNAME, 0666)) < 0)
fatal2("Can't open file %s\n", TMPINNAME);
while (fgets(buf, sizeof buf, ifp) != Nullch) {
if (revision != Nullch && !found_revision && rev_in_string(buf))
found_revision = TRUE;
if ((i = strlen(buf)) > maxlen)
maxlen = i; /* find longest line */
}
if (revision != Nullch) {
if (!found_revision) {
if (force) {
if (verbose)
say2(
"Warning: this file doesn't appear to be the %s version--patching anyway.\n",
revision);
}
else {
#ifdef AMIGA
ask2(
"This file doesn't appear to be the %s version--patch anyway?",
revision);
#else
ask2("\
This file doesn't appear to be the %s version--patch anyway? [n] ",
revision);
#endif
if (*buf != 'y')
fatal1("Aborted.\n");
}
}
else if (verbose)
say2("Good. This file appears to be the %s version.\n",
revision);
}
Fseek(ifp, 0L, 0); /* rewind file */
lines_per_buf = BUFFERSIZE / maxlen;
tireclen = maxlen;
tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
tibuf[1] = malloc((MEM)(BUFFERSIZE + 1));
if (tibuf[1] == Nullch)
fatal1("Can't seem to get enough memory.\n");
for (i=1; ; i++) {
if (! (i % lines_per_buf)) /* new block */
if (write(tifd, tibuf[0], BUFFERSIZE) < BUFFERSIZE)
fatal1("patch: can't write temp file.\n");
if (fgets(tibuf[0] + maxlen * (i%lines_per_buf), maxlen + 1, ifp)
== Nullch) {
input_lines = i - 1;
if (i % lines_per_buf)
if (write(tifd, tibuf[0], BUFFERSIZE) < BUFFERSIZE)
fatal1("patch: can't write temp file.\n");
break;
}
}
Fclose(ifp);
Close(tifd);
if ((tifd = open(TMPINNAME, 0)) < 0) {
fatal2("Can't reopen file %s\n", TMPINNAME);
}
}
/* Fetch a line from the input file, \n terminated, not necessarily \0. */
char *
ifetch(line,whichbuf)
Reg1 LINENUM line;
int whichbuf; /* ignored when file in memory */
{
if (line < 1 || line > input_lines)
return "";
if (using_plan_a)
return i_ptr[line];
else {
LINENUM offline = line % lines_per_buf;
LINENUM baseline = line - offline;
if (tiline[0] == baseline)
whichbuf = 0;
else if (tiline[1] == baseline)
whichbuf = 1;
else {
tiline[whichbuf] = baseline;
#ifndef lint /* complains of long accuracy */
Lseek(tifd, (long)baseline / lines_per_buf * BUFFERSIZE, 0);
#endif
if (read(tifd, tibuf[whichbuf], BUFFERSIZE) < 0)
fatal2("Error reading tmp file %s.\n", TMPINNAME);
}
return tibuf[whichbuf] + (tireclen*offline);
}
}
/* True if the string argument contains the revision number we want. */
bool
rev_in_string(string)
char *string;
{
Reg1 char *s;
Reg2 int patlen;
if (revision == Nullch)
return TRUE;
patlen = strlen(revision);
for (s = string; *s; s++) {
if (isspace(*s) && strnEQ(s+1, revision, patlen) &&
isspace(s[patlen+1] )) {
return TRUE;
}
}
return FALSE;
}
SHAR_EOF
if test 8471 -ne "`wc -c inp.c`"
then
echo shar: error transmitting inp.c '(should have been 8471 characters)'
fi
echo shar: extracting inp.h '(473 characters)'
cat << \SHAR_EOF > inp.h
/* $Header: inp.h,v 2.0 86/09/17 15:37:25 lwall Exp $
*
* $Log: inp.h,v $
* Revision 2.0 86/09/17 15:37:25 lwall
* Baseline for netwide release.
*
*/
EXT LINENUM input_lines INIT(0); /* how long is input file in lines */
EXT LINENUM last_frozen_line INIT(0); /* how many input lines have been */
/* irretractibly output */
bool rev_in_string();
void scan_input();
bool plan_a(); /* returns false if insufficient memory */
void plan_b();
char *ifetch();
SHAR_EOF
if test 473 -ne "`wc -c inp.h`"
then
echo shar: error transmitting inp.h '(should have been 473 characters)'
fi
echo shar: extracting newwildcmp.c '(1351 characters)'
cat << \SHAR_EOF > newwildcmp.c
/*
* NEWWILDCMP.C
*
* (c)Copyright 1987 Matthew Dillon, All Rights Reserved.
*
* Compare a wild card name with a normal name
*
* This function replaces wildcmp() in SUP32.LIB (as not everybody will
* have the latest SUP32.LIB). The only difference is that this call
* is case insensitive. Later releases of SUP32.LIB will fix the
* case-sensitive bug.
*/
#define MAXB 8
newwildcmp(wild, name)
char *wild, *name;
{
register char *w = wild;
register char *n = name;
char *back[MAXB][2];
register short bi = 0;
register char c1, c2;
while (*n || *w) {
switch (*w) {
case '*':
if (bi == MAXB) {
puts ("Too many levels of '*'");
return (0);
}
back[bi][0] = w;
back[bi][1] = n;
++bi;
++w;
continue;
goback:
--bi;
while (bi >= 0 && *back[bi][1] == '\0')
--bi;
if (bi < 0)
return (0);
w = back[bi][0] + 1;
n = ++back[bi][1];
++bi;
continue;
case '?':
if (!*n) {
if (bi)
goto goback;
return (0);
}
break;
default:
c1 = *n;
c2 = *w;
if (c1 >= 'A' && c1 <= 'Z') /* to lower case */
c1 |= 0x20;
if (c2 >= 'A' && c2 <= 'Z')
c2 |= 0x20;
if (c1 != c2) {
if (bi)
goto goback;
return (0);
}
break;
}
if (*n) ++n;
if (*w) ++w;
}
return (1);
}
SHAR_EOF
if test 1351 -ne "`wc -c newwildcmp.c`"
then
echo shar: error transmitting newwildcmp.c '(should have been 1351 characters)'
fi
echo shar: extracting patchlevel.h '(21 characters)'
cat << \SHAR_EOF > patchlevel.h
#define PATCHLEVEL 9
SHAR_EOF
if test 21 -ne "`wc -c patchlevel.h`"
then
echo shar: error transmitting patchlevel.h '(should have been 21 characters)'
fi
echo shar: extracting pch.h '(780 characters)'
cat << \SHAR_EOF > pch.h
/* $Header: pch.h,v 2.0.1.1 87/01/30 22:47:16 lwall Exp $
*
* $Log: pch.h,v $
* Revision 2.0.1.1 87/01/30 22:47:16 lwall
* Added do_ed_script().
*
* Revision 2.0 86/09/17 15:39:57 lwall
* Baseline for netwide release.
*
*/
EXT FILE *pfp INIT(Nullfp); /* patch file pointer */
void re_patch();
void open_patch_file();
void set_hunkmax();
void grow_hunkmax();
bool there_is_another_patch();
int intuit_diff_type();
void next_intuit_at();
void skip_to();
bool another_hunk();
bool pch_swap();
char *pfetch();
short pch_line_len();
LINENUM pch_first();
LINENUM pch_ptrn_lines();
LINENUM pch_newfirst();
LINENUM pch_repl_lines();
LINENUM pch_end();
LINENUM pch_context();
LINENUM pch_hunk_beg();
char pch_char();
char *pfetch();
char *pgets();
void do_ed_script();
SHAR_EOF
if test 780 -ne "`wc -c pch.h`"
then
echo shar: error transmitting pch.h '(should have been 780 characters)'
fi
echo shar: extracting request.c '(1842 characters)'
cat << \SHAR_EOF > request.c
/* put up a simple requester */
#include <exec/types.h>
#include <intuition/intuitionbase.h>
#ifndef MANX
#include <proto/exec.h>
#include <proto/intuition.h>
#endif
#include <stdio.h>
#include <string.h>
#ifndef MANX
#include <stdlib.h>
#endif
extern struct Library *OpenLibrary();
extern struct IntuitionBase *IntuitionBase;
extern struct GfxBase *GfxBase;
/* AutoRequest data structures */
#define REDP 3
#define BLKP 2
#define WHTP 1
#define BLUP 0
static struct IntuiText questionText = {
REDP, WHTP,
JAM2,
5, /* LeftEdge */
5, /* TopEdge */
NULL, /* Default font */
NULL, /* Text (to be filled in) */
NULL /* No pointer to next text */
};
/** YES TEXT **/
static struct IntuiText yesText = {
BLUP, WHTP,
JAM2,
7, /* LeftEdge */
3, /* TopEdge */
NULL, /* Default font */
(UBYTE *) "Yes", /* Text */
NULL /* No pointer to next text */
};
/** NO TEXT **/
static struct IntuiText noText = {
REDP, WHTP,
JAM2,
7, /* LeftEdge */
3, /* TopEdge */
NULL, /* Default font */
(UBYTE *) "No", /* Text */
NULL
};
initMachSpecific()
{
if ((GfxBase = (struct GfxBase *)
OpenLibrary("graphics.library", 0)) == 0) {
fprintf(stderr,"Unable to open graphics.library\n");
my_exit(20);
}
if ((IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library", 0)) == 0) {
fprintf(stderr,"Unable to open intuition.library\n");
my_exit(21);
}
}
cleanMachSpecific()
{
if (IntuitionBase)
CloseLibrary((struct Library *) IntuitionBase);
if (GfxBase)
CloseLibrary((struct Library *) GfxBase);
}
simpleRequest(question)
char *question;
{
questionText.IText = (UBYTE *) question;
return(AutoRequest(0, &questionText, &yesText, &noText, 0, 0,
max(strlen(question)*8 + 34, 150), 60));
}
SHAR_EOF
if test 1842 -ne "`wc -c request.c`"
then
echo shar: error transmitting request.c '(should have been 1842 characters)'
fi
echo shar: extracting util.c '(7997 characters)'
cat << \SHAR_EOF > util.c
#include "EXTERN.h"
#include "common.h"
#include "INTERN.h"
#include "util.h"
/* Rename a file, copying it if necessary. */
int
move_file(from,to)
char *from, *to;
{
char bakname[512];
Reg1 char *s;
Reg2 int i;
Reg3 int fromfd;
/* to stdout? */
if (strEQ(to, "-")) {
#ifdef DEBUGGING
if (debug & 4)
say2("Moving %s to stdout.\n", from);
#endif
fromfd = open(from, 0);
if (fromfd < 0)
fatal2("patch: internal error, can't reopen %s\n", from);
while ((i=read(fromfd, buf, sizeof buf)) > 0)
if (write(1, buf, i) != 1)
fatal1("patch: write failed\n");
Close(fromfd);
return 0;
}
Strcpy(bakname, to);
Strcat(bakname, origext?origext:ORIGEXT);
#ifdef AMIGA
if (!dfindOne(&filestat, to, 1)) { /* output file exists */
unlink(bakname);
#else
if (stat(to, &filestat) >= 0) { /* output file exists */
dev_t to_device = filestat.st_dev;
ino_t to_inode = filestat.st_ino;
char *simplename = bakname;
for (s=bakname; *s; s++) {
if (*s == '/')
simplename = s+1;
}
/* find a backup name that is not the same file */
while (stat(bakname, &filestat) >= 0 &&
to_device == filestat.st_dev && to_inode == filestat.st_ino) {
for (s=simplename; *s && !islower(*s); s++) ;
if (*s)
*s = toupper(*s);
else
Strcpy(simplename, simplename+1);
}
while (unlink(bakname) >= 0) ; /* while() is for benefit of Eunice */
#endif
#ifdef DEBUGGING
if (debug & 4)
say3("Moving %s to %s.\n", to, bakname);
#endif
#ifdef AMIGA
if (rename(to, bakname)) {
say3("patch: can't backup %s, output is in %s\n",
to, from);
return -1;
}
#else
if (link(to, bakname) < 0) {
say3("patch: can't backup %s, output is in %s\n",
to, from);
return -1;
}
while (unlink(to) >= 0) ;
#endif
}
#ifdef DEBUGGING
if (debug & 4)
say3("Moving %s to %s.\n", from, to);
#endif
#ifdef AMIGA
if (rename(from, to)) { /* different file system? */
#else
if (link(from, to) < 0) { /* different file system? */
#endif
Reg4 int tofd;
tofd = creat(to, 0666);
if (tofd < 0) {
say3("patch: can't create %s, output is in %s.\n",
to, from);
return -1;
}
fromfd = open(from, 0);
if (fromfd < 0)
fatal2("patch: internal error, can't reopen %s\n", from);
while ((i=read(fromfd, buf, sizeof buf)) > 0)
if (write(tofd, buf, i) != i)
fatal1("patch: write failed\n");
Close(fromfd);
Close(tofd);
}
Unlink(from);
return 0;
}
/* Copy a file. */
void
copy_file(from,to)
char *from, *to;
{
Reg3 int tofd;
Reg2 int fromfd;
Reg1 int i;
tofd = creat(to, 0666);
if (tofd < 0)
fatal2("patch: can't create %s.\n", to);
fromfd = open(from, 0);
if (fromfd < 0)
fatal2("patch: internal error, can't reopen %s\n", from);
while ((i=read(fromfd, buf, sizeof buf)) > 0)
if (write(tofd, buf, i) != i)
fatal2("patch: write (%s) failed\n", to);
Close(fromfd);
Close(tofd);
}
/* Allocate a unique area for a string. */
char *
savestr(s)
Reg1 char *s;
{
Reg3 char *rv;
Reg2 char *t;
if (!s)
s = "Oops";
t = s;
while (*t++);
rv = malloc((MEM) (t - s));
if (rv == Nullch) {
if (using_plan_a)
out_of_mem = TRUE;
else
fatal1("patch: out of memory (savestr)\n");
}
else {
t = rv;
while (*t++ = *s++);
}
return rv;
}
#ifdef lint
#ifdef CANVARARG
/*VARARGS ARGSUSED*/
say(pat) char *pat; { ; }
/*VARARGS ARGSUSED*/
fatal(pat) char *pat; { ; }
/*VARARGS ARGSUSED*/
ask(pat) char *pat; { ; }
#endif
#else
/* Vanilla terminal output (buffered). */
void
say(pat,arg1,arg2,arg3)
char *pat;
int arg1,arg2,arg3;
{
fprintf(stderr, pat, arg1, arg2, arg3);
Fflush(stderr);
}
/* Terminal output, pun intended. */
void /* very void */
fatal(pat,arg1,arg2,arg3)
char *pat;
int arg1,arg2,arg3;
{
void my_exit();
say(pat, arg1, arg2, arg3);
my_exit(1);
}
#ifdef AMIGA
/* Ask user for a file name */
void
fileRequest(prompt)
char *prompt;
{
if(!stdfile(prompt, NULL, NULL, buf)) {
strcpy(buf,"\n");
}
}
#endif
/* Get a response from the user, somehow or other. */
#ifdef AMIGA
void
ask(pat,arg1,arg2,arg3)
char *pat;
int arg1,arg2,arg3;
{
Sprintf(buf, pat, arg1, arg2, arg3);
if(simpleRequest(buf)) {
strcpy(buf,"y\n");
} else {
strcpy(buf,"n\n");
}
}
#else
void
ask(pat,arg1,arg2,arg3)
char *pat;
int arg1,arg2,arg3;
{
int ttyfd;
int r;
bool tty2 = isatty(2);
Sprintf(buf, pat, arg1, arg2, arg3);
Fflush(stderr);
write(2, buf, strlen(buf));
if (tty2) { /* might be redirected to a file */
r = read(2, buf, sizeof buf);
}
else if (isatty(1)) { /* this may be new file output */
Fflush(stdout);
write(1, buf, strlen(buf));
r = read(1, buf, sizeof buf);
}
else if ((ttyfd = open("/dev/tty", 2)) >= 0 && isatty(ttyfd)) {
/* might be deleted or unwriteable */
write(ttyfd, buf, strlen(buf));
r = read(ttyfd, buf, sizeof buf);
Close(ttyfd);
}
else if (isatty(0)) { /* this is probably patch input */
Fflush(stdin);
write(0, buf, strlen(buf));
r = read(0, buf, sizeof buf);
}
else { /* no terminal at all--default it */
buf[0] = '\n';
r = 1;
}
if (r <= 0)
buf[0] = 0;
else
buf[r] = '\0';
if (!tty2)
say1(buf);
}
#endif lint
/* How to handle certain events when not in a critical region. */
void
set_signals()
{
void my_exit();
#ifndef lint
#ifndef AMIGA
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
Signal(SIGHUP, my_exit);
#endif
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
Signal(SIGINT, my_exit);
#endif
}
/* How to handle certain events when in a critical region. */
void
ignore_signals()
{
#ifndef lint
#ifndef AMIGA
Signal(SIGHUP, SIG_IGN);
#endif
Signal(SIGINT, SIG_IGN);
#endif
}
/* Make sure we'll have the directories to create a file. */
void
makedirs(filename,striplast)
Reg1 char *filename;
bool striplast;
{
char tmpbuf[256];
Reg2 char *s = tmpbuf;
char *dirv[20];
Reg3 int i;
Reg4 int dirvp = 0;
while (*filename) {
if (*filename == '/') {
filename++;
dirv[dirvp++] = s;
*s++ = '\0';
}
else {
*s++ = *filename++;
}
}
*s = '\0';
dirv[dirvp] = s;
if (striplast)
dirvp--;
if (dirvp < 0)
return;
#ifdef AMIGA
for (i=0; i<=dirvp; i++) {
strcpy(buf, tmpbuf);
*dirv[i] = '/';
mkdir(buf);
}
#else
strcpy(buf, "mkdir");
s = buf;
for (i=0; i<=dirvp; i++) {
while (*s) s++;
*s++ = ' ';
strcpy(s, tmpbuf);
*dirv[i] = '/';
}
system(buf);
#endif
}
/* Make filenames more reasonable. */
char *
fetchname(at,strip_leading,assume_exists)
char *at;
int strip_leading;
int assume_exists;
{
char *s;
char *name;
Reg1 char *t;
char tmpbuf[200];
if (!at)
return Nullch;
s = savestr(at);
for (t=s; isspace(*t); t++) ;
name = t;
#ifdef DEBUGGING
if (debug & 128)
say4("fetchname %s %d %d\n",name,strip_leading,assume_exists);
#endif
if (strnEQ(name, "/dev/null", 9)) /* so files can be created by diffing */
return Nullch; /* against /dev/null. */
for (; *t && !isspace(*t); t++)
if (*t == '/')
if (--strip_leading >= 0)
name = t+1;
*t = '\0';
if (name != s && *s != '/') {
name[-1] = '\0';
#ifdef AMIGA
if (!dfindOne(&filestat, s, 1) && filestat.fib_DirEntryType > 0) {
#else
if (stat(s, &filestat) && filestat.st_mode & S_IFDIR) {
#endif
name[-1] = '/';
name=s;
}
}
name = savestr(name);
#ifdef AMIGA
free(s);
if (dfindOne(&filestat, name, 0) && !assume_exists) {
free(name);
name = Nullch;
}
#else
Sprintf(tmpbuf, "RCS/%s", name);
free(s);
if (stat(name, &filestat) < 0 && !assume_exists) {
Strcat(tmpbuf, RCSSUFFIX);
if (stat(tmpbuf, &filestat) < 0 && stat(tmpbuf+4, &filestat) < 0) {
Sprintf(tmpbuf, "SCCS/%s%s", SCCSPREFIX, name);
if (stat(tmpbuf, &filestat) < 0 && stat(tmpbuf+5, &filestat) < 0) {
free(name);
name = Nullch;
}
}
}
#endif
return name;
}
SHAR_EOF
if test 7997 -ne "`wc -c util.c`"
then
echo shar: error transmitting util.c '(should have been 7997 characters)'
fi
echo shar: extracting util.h '(1972 characters)'
cat << \SHAR_EOF > util.h
/* $Header: util.h,v 2.0 86/09/17 15:40:06 lwall Exp $
*
* $Log: util.h,v $
* Revision 2.0 86/09/17 15:40:06 lwall
* Baseline for netwide release.
*
*/
/* and for those machine that can't handle a variable argument list */
#ifdef CANVARARG
#define say1 say
#define say2 say
#define say3 say
#define say4 say
#define ask1 ask
#define ask2 ask
#define ask3 ask
#define ask4 ask
#define fatal1 fatal
#define fatal2 fatal
#define fatal3 fatal
#define fatal4 fatal
#else /* hope they allow multi-line macro actual arguments */
#ifdef lint
#define say1(a) say(a, 0, 0, 0)
#define say2(a,b) say(a, (b)==(b), 0, 0)
#define say3(a,b,c) say(a, (b)==(b), (c)==(c), 0)
#define say4(a,b,c,d) say(a, (b)==(b), (c)==(c), (d)==(d))
#define ask1(a) ask(a, 0, 0, 0)
#define ask2(a,b) ask(a, (b)==(b), 0, 0)
#define ask3(a,b,c) ask(a, (b)==(b), (c)==(c), 0)
#define ask4(a,b,c,d) ask(a, (b)==(b), (c)==(c), (d)==(d))
#define fatal1(a) fatal(a, 0, 0, 0)
#define fatal2(a,b) fatal(a, (b)==(b), 0, 0)
#define fatal3(a,b,c) fatal(a, (b)==(b), (c)==(c), 0)
#define fatal4(a,b,c,d) fatal(a, (b)==(b), (c)==(c), (d)==(d))
#else /* lint */
/* if this doesn't work, try defining CANVARARG above */
#define say1(a) say(a, Nullch, Nullch, Nullch)
#define say2(a,b) say(a, b, Nullch, Nullch)
#define say3(a,b,c) say(a, b, c, Nullch)
#define say4 say
#define ask1(a) ask(a, Nullch, Nullch, Nullch)
#define ask2(a,b) ask(a, b, Nullch, Nullch)
#define ask3(a,b,c) ask(a, b, c, Nullch)
#define ask4 ask
#define fatal1(a) fatal(a, Nullch, Nullch, Nullch)
#define fatal2(a,b) fatal(a, b, Nullch, Nullch)
#define fatal3(a,b,c) fatal(a, b, c, Nullch)
#define fatal4 fatal
#endif /* lint */
/* if neither of the above work, join all multi-line macro calls. */
#endif
EXT char serrbuf[BUFSIZ]; /* buffer for stderr */
char *fetchname();
int move_file();
void copy_file();
void say();
void fatal();
void ask();
char *savestr();
void set_signals();
void ignore_signals();
void makedirs();
SHAR_EOF
if test 1972 -ne "`wc -c util.h`"
then
echo shar: error transmitting util.h '(should have been 1972 characters)'
fi
# End of shell archive
exit 0ain@j.cc.purdue.edu (Patrick White) (03/07/88)
Program Name: patch (2 fo 2)
Submitted By: Johan Widen <jw@sics.se>
Summary: patch for the Amiga.
Poster Boy: Pat White (ain@j.cc.purdue.edu)
untested.
NOTES:
I didn't try compiling this.
-- Pat White (co-moderator comp.sources/binaries.amiga)
UUCP: j.cc.purdue.edu!ain BITNET: PATWHITE@PURCCVM PHONE: (317) 743-8421
U.S. Mail: 320 Brown St. apt. 406, West Lafayette, IN 47906
========================================
# This is a shell archive.
# Remove everything above and including the cut line.
# Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: Shell Archiver
# Run the following text with /bin/sh to create:
# patch.c
# pch.c
# version.c
# version.h
# This archive created: Sun Mar 6 02:44:02 1988
# By: Patrick White (PUCC Land, USA)
echo shar: extracting patch.c '(18746 characters)'
cat << \SHAR_EOF > patch.c
char rcsid[] =
"$Header: patch.c,v 2.0.1.4 87/02/16 14:00:04 lwall Exp $";
/* 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.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"
/* 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();
/* Apply a set of diffs as appropriate. */
main(argc,argv)
int argc;
char **argv;
{
LINENUM where;
LINENUM newwhere;
LINENUM fuzz;
LINENUM mymaxfuzz;
int hunk = 0;
int failed = 0;
int i;
setbuf(stderr, serrbuf);
for (i = 0; i<MAXFILEC; i++)
filearg[i] = Nullch;
#ifndef AMIGA
Mktemp(TMPOUTNAME);
Mktemp(TMPINNAME);
Mktemp(TMPREJNAME);
Mktemp(TMPPATNAME);
#endif
initMachSpecific();
/* parse switches */
Argc = argc;
Argv = argv;
get_some_switches();
/* make sure we clean up /tmp in case of disaster */
set_signals();
for (
open_patch_file(filearg[1]);
there_is_another_patch();
reinitialize_almost_everything()
) { /* for each patch in patch file */
if (outname == Nullch)
outname = savestr(filearg[0]);
/* initialize the patched file */
if (!skip_rest_of_patch)
init_output(TMPOUTNAME);
/* for ed script just up and do it and exit */
if (diff_type == ED_DIFF) {
#ifdef AMIGA
say1("Handling of ed diffs not implemented.\n");
skip_rest_of_patch = TRUE;
#else
do_ed_script();
#endif
continue;
}
/* initialize reject file */
init_reject(TMPREJNAME);
/* find out where all the lines are */
if (!skip_rest_of_patch)
scan_input(filearg[0]);
/* 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;
out_of_mem = FALSE;
while (another_hunk()) {
hunk++;
fuzz = Nulline;
mymaxfuzz = pch_context();
if (maxfuzz < mymaxfuzz)
mymaxfuzz = maxfuzz;
if (!skip_rest_of_patch) {
do {
where = locate_hunk(fuzz);
if (hunk == 1 && where == Nulline && !force) {
/* dwim for reversed patch? */
if (!pch_swap()) {
if (fuzz == Nulline)
say1(
"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");
reverse = !reverse;
}
else if (noreverse) {
if (!pch_swap()) /* put it back to normal */
fatal1("Lost hunk on alloc error!\n");
reverse = !reverse;
say1(
"Ignoring previously applied (or reversed) patch.\n");
skip_rest_of_patch = TRUE;
}
else {
#ifdef AMIGA
ask3(
"%seversed (or previously applied) patch detected! %s -R?",
reverse ? "R" : "Unr",
reverse ? "Assume" : "Ignore");
#else
ask3(
"%seversed (or previously applied) patch detected! %s -R? [y] ",
reverse ? "R" : "Unr",
reverse ? "Assume" : "Ignore");
#endif
if (*buf == 'n') {
#ifdef AMIGA
ask1("Apply anyway?");
#else
ask1("Apply anyway? [n] ");
#endif
if (*buf != 'y')
skip_rest_of_patch = TRUE;
where = Nulline;
reverse = !reverse;
if (!pch_swap()) /* put it back to normal */
fatal1("Lost hunk on alloc error!\n");
}
}
}
} while (!skip_rest_of_patch && where == Nulline &&
++fuzz <= mymaxfuzz);
if (skip_rest_of_patch) { /* just got decided */
Fclose(ofp);
ofp = Nullfp;
}
}
newwhere = pch_newfirst() + last_offset;
if (skip_rest_of_patch) {
abort_hunk();
failed++;
if (verbose)
say3("Hunk #%d ignored at %ld.\n", hunk, newwhere);
}
else if (where == Nulline) {
abort_hunk();
failed++;
if (verbose)
say3("Hunk #%d failed at %ld.\n", hunk, newwhere);
}
else {
apply_hunk(where);
if (verbose) {
say3("Hunk #%d succeeded at %ld", hunk, newwhere);
if (fuzz)
say2(" with fuzz %ld", fuzz);
if (last_offset)
say3(" (offset %ld line%s)",
last_offset, last_offset==1L?"":"s");
say1(".\n");
}
}
}
if (out_of_mem && using_plan_a) {
Argc = Argc_last;
Argv = Argv_last;
say1("\n\nRan out of memory using Plan A--trying again...\n\n");
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) {
if (move_file(TMPOUTNAME, outname) < 0) {
toutkeep = TRUE;
chmod(TMPOUTNAME, filemode);
}
else
chmod(outname, filemode);
}
Fclose(rejfp);
rejfp = Nullfp;
if (failed) {
if (!*rejname) {
Strcpy(rejname, outname);
Strcat(rejname, ".rej");
}
if (skip_rest_of_patch) {
say4("%d out of %d hunks ignored--saving rejects to %s\n",
failed, hunk, rejname);
}
else {
say4("%d out of %d hunks failed--saving rejects to %s\n",
failed, hunk, rejname);
}
if (move_file(TMPREJNAME, rejname) < 0)
trejkeep = TRUE;
}
set_signals();
}
my_exit(0);
}
/* Prepare to find the next patch to do in the patch file. */
void
reinitialize_almost_everything()
{
re_patch();
re_input();
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;
}
last_offset = 0;
diff_type = 0;
if (revision != Nullch) {
free(revision);
revision = Nullch;
}
reverse = FALSE;
skip_rest_of_patch = FALSE;
get_some_switches();
if (filec >= 2)
fatal1("You may not change to a different patch file.\n");
}
/* Process switches and filenames up to next '+' or end of list. */
void
get_some_switches()
{
Reg1 char *s;
rejname[0] = '\0';
Argc_last = Argc;
Argv_last = Argv;
if (!Argc)
return;
for (Argc--,Argv++; Argc; Argc--,Argv++) {
s = Argv[0];
if (strEQ(s, "+")) {
return; /* + will be skipped by for loop */
}
if (*s != '-' || !s[1]) {
if (filec == MAXFILEC)
fatal1("Too many file arguments.\n");
filearg[filec++] = savestr(s);
}
else {
switch (*++s) {
case 'b':
origext = savestr(Argv[1]);
Argc--,Argv++;
break;
case 'c':
diff_type = CONTEXT_DIFF;
break;
case 'd':
if (!*++s) {
Argc--,Argv++;
s = Argv[0];
}
if (chdir(s) < 0)
fatal2("Can't cd to %s.\n", s);
break;
case 'D':
do_defines = TRUE;
if (!*++s) {
Argc--,Argv++;
s = Argv[0];
}
Sprintf(if_defined, "#ifdef %s\n", s);
Sprintf(not_defined, "#ifndef %s\n", s);
Sprintf(end_defined, "#endif /* %s */\n", s);
break;
case 'e':
diff_type = ED_DIFF;
break;
case 'f':
force = TRUE;
break;
case 'F':
if (*++s == '=')
s++;
maxfuzz = atoi(s);
break;
case 'l':
canonicalize = TRUE;
break;
case 'n':
diff_type = NORMAL_DIFF;
break;
case 'N':
noreverse = TRUE;
break;
case 'o':
outname = savestr(Argv[1]);
Argc--,Argv++;
break;
case 'p':
if (*++s == '=')
s++;
strippath = atoi(s);
break;
case 'r':
Strcpy(rejname, Argv[1]);
Argc--,Argv++;
break;
case 'R':
reverse = TRUE;
break;
case 's':
verbose = FALSE;
break;
case 'S':
skip_rest_of_patch = TRUE;
break;
case 'v':
version();
break;
#ifdef DEBUGGING
case 'x':
debug = atoi(s+1);
break;
#endif
default:
fatal2("Unrecognized switch: %s\n", Argv[0]);
}
}
}
}
/* Attempt to find the right place to apply this hunk of patch. */
LINENUM
locate_hunk(fuzz)
LINENUM fuzz;
{
Reg1 LINENUM first_guess = pch_first() + last_offset;
Reg2 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();
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))
return first_guess;
for (offset = 1; ; offset++) {
Reg5 bool check_after = (offset <= max_pos_offset);
Reg6 bool check_before = (offset <= max_neg_offset);
if (check_after && patch_match(first_guess, offset, fuzz)) {
#ifdef DEBUGGING
if (debug & 1)
say3("Offset changing from %ld to %ld\n", last_offset, offset);
#endif
last_offset = offset;
return first_guess+offset;
}
else if (check_before && patch_match(first_guess, -offset, fuzz)) {
#ifdef DEBUGGING
if (debug & 1)
say3("Offset changing from %ld to %ld\n", last_offset, -offset);
#endif
last_offset = -offset;
return first_guess-offset;
}
else if (!check_before && !check_after)
return Nulline;
}
}
/* We did not find the pattern, dump out the hunk so they can handle it. */
void
abort_hunk()
{
Reg1 LINENUM i;
Reg2 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 ? " ----" : " -----");
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 '\n':
fprintf(rejfp, "%s", pfetch(i));
break;
case ' ': case '-': case '+': case '!':
fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
break;
default:
say1("Fatal internal error in abort_hunk().\n");
abort();
}
}
}
/* We found where to apply it (we hope), so do it. */
void
apply_hunk(where)
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();
where--;
while (pch_char(new) == '=' || pch_char(new) == '\n')
new++;
while (old <= lastline) {
if (pch_char(old) == '-') {
copy_till(where + old - 1);
if (R_do_defines) {
if (def_state == OUTSIDE) {
fputs(not_defined, ofp);
def_state = IN_IFNDEF;
}
else if (def_state == IN_IFDEF) {
fputs(else_defined, ofp);
def_state = IN_ELSE;
}
fputs(pfetch(old), ofp);
}
last_frozen_line++;
old++;
}
else if (new > pat_end)
break;
else if (pch_char(new) == '+') {
copy_till(where + old - 1);
if (R_do_defines) {
if (def_state == IN_IFNDEF) {
fputs(else_defined, ofp);
def_state = IN_ELSE;
}
else if (def_state == OUTSIDE) {
fputs(if_defined, ofp);
def_state = IN_IFDEF;
}
}
fputs(pfetch(new), ofp);
new++;
}
else {
if (pch_char(new) != pch_char(old)) {
say3(
"Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
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);
}
if (pch_char(new) == '!') {
copy_till(where + old - 1);
if (R_do_defines) {
fputs(not_defined, ofp);
def_state = IN_IFNDEF;
}
while (pch_char(old) == '!') {
if (R_do_defines) {
fputs(pfetch(old), ofp);
}
last_frozen_line++;
old++;
}
if (R_do_defines) {
fputs(else_defined, ofp);
def_state = IN_ELSE;
}
while (pch_char(new) == '!') {
fputs(pfetch(new), ofp);
new++;
}
if (R_do_defines) {
fputs(end_defined, ofp);
def_state = OUTSIDE;
}
}
else {
assert(pch_char(new) == ' ');
old++;
new++;
}
}
}
if (new <= pat_end && pch_char(new) == '+') {
copy_till(where + old - 1);
if (R_do_defines) {
if (def_state == OUTSIDE) {
fputs(if_defined, ofp);
def_state = IN_IFDEF;
}
else if (def_state == IN_IFNDEF) {
fputs(else_defined, ofp);
def_state = IN_ELSE;
}
}
while (new <= pat_end && pch_char(new) == '+') {
fputs(pfetch(new), ofp);
new++;
}
}
if (R_do_defines && def_state != OUTSIDE) {
fputs(end_defined, ofp);
}
}
/* Open the new file. */
void
init_output(name)
char *name;
{
ofp = fopen(name, "w");
if (ofp == Nullfp)
fatal2("patch: can't create %s.\n", name);
}
/* Open a file to put hunks we can't locate. */
void
init_reject(name)
char *name;
{
rejfp = fopen(name, "w");
if (rejfp == Nullfp)
fatal2("patch: can't create %s.\n", name);
}
/* Copy input file to output, up to wherever hunk is to be applied. */
void
copy_till(lastline)
Reg1 LINENUM lastline;
{
Reg2 LINENUM R_last_frozen_line = last_frozen_line;
if (R_last_frozen_line > lastline)
say1("patch: misordered hunks! output will be garbled.\n");
while (R_last_frozen_line < lastline) {
dump_line(++R_last_frozen_line);
}
last_frozen_line = R_last_frozen_line;
}
/* Finish copying the input file to the output file. */
void
spew_output()
{
#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;
}
/* Copy one line from input to output. */
void
dump_line(line)
LINENUM line;
{
Reg1 char *s;
Reg2 char R_newline = '\n';
/* Note: string is not null terminated. */
for (s=ifetch(line, 0); putc(*s, ofp) != R_newline; s++) ;
}
/* Does the patch pattern match at line base+offset? */
bool
patch_match(base, offset, fuzz)
LINENUM base;
LINENUM offset;
LINENUM 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++) {
if (canonicalize) {
if (!similar(ifetch(iline, (offset >= 0)),
pfetch(pline),
pch_line_len(pline) ))
return FALSE;
}
else if (strnNE(ifetch(iline, (offset >= 0)),
pfetch(pline),
pch_line_len(pline) ))
return FALSE;
}
return TRUE;
}
/* Do two lines match with canonicalized white space? */
bool
similar(a,b,len)
Reg1 char *a;
Reg2 char *b;
Reg3 int len;
{
while (len) {
if (isspace(*b)) { /* whitespace (or \n) to match? */
if (!isspace(*a)) /* no corresponding whitespace? */
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 */
}
else if (*a++ != *b++) /* match non-whitespace chars */
return FALSE;
else
len--; /* probably not necessary */
}
return TRUE; /* actually, this is not reached */
/* since there is always a \n */
}
/* Exit with cleanup. */
void
my_exit(status)
int status;
{
Unlink(TMPINNAME);
if (!toutkeep) {
Unlink(TMPOUTNAME);
}
if (!trejkeep) {
Unlink(TMPREJNAME);
}
if(pfp) {
fclose(pfp);
}
Unlink(TMPPATNAME);
cleanMachSpecific();
exit(status);
}
SHAR_EOF
if test 18746 -ne "`wc -c patch.c`"
then
echo shar: error transmitting patch.c '(should have been 18746 characters)'
fi
echo shar: extracting pch.c '(28573 characters)'
cat << \SHAR_EOF > pch.c
/* $Header: pch.c,v 2.0.1.6 87/06/04 16:18:13 lwall Exp $
*
* $Log: pch.c,v $
* Revision 2.0.1.6 87/06/04 16:18:13 lwall
* pch_swap didn't swap p_bfake and p_efake.
*
* Revision 2.0.1.5 87/01/30 22:47:42 lwall
* Improved responses to mangled patches.
*
* Revision 2.0.1.4 87/01/05 16:59:53 lwall
* New-style context diffs caused double call to free().
*
* Revision 2.0.1.3 86/11/14 10:08:33 lwall
* Fixed problem where a long pattern wouldn't grow the hunk.
* Also restored p_input_line when backtracking so error messages are right.
*
* Revision 2.0.1.2 86/11/03 17:49:52 lwall
* New-style delete triggers spurious assertion error.
*
* Revision 2.0.1.1 86/10/29 15:52:08 lwall
* Could falsely report new-style context diff.
*
* Revision 2.0 86/09/17 15:39:37 lwall
* Baseline for netwide release.
*
*/
#include "EXTERN.h"
#include "common.h"
#include "util.h"
#include "INTERN.h"
#include "pch.h"
/* Patch (diff listing) abstract type. */
static long p_filesize; /* size of the patch file */
static LINENUM p_first; /* 1st line number */
static LINENUM p_newfirst; /* 1st line number of replacement */
static LINENUM p_ptrn_lines; /* # lines in pattern */
static LINENUM p_repl_lines; /* # lines in replacement text */
static LINENUM p_end = -1; /* last line in hunk */
static LINENUM p_max; /* max allowed value of p_end */
static LINENUM p_context = 3; /* # of context lines */
static LINENUM p_input_line = 0; /* current line # from patch file */
static char **p_line = Null(char**); /* the text of the hunk */
static short *p_len = Null(short*); /* length of each line */
static char *p_char = Nullch; /* +, -, and ! */
static int hunkmax = INITHUNKMAX; /* size of above arrays to begin with */
static int p_indent; /* indent to patch */
static LINENUM p_base; /* where to intuit this time */
static LINENUM p_bline; /* line # of p_base */
static LINENUM p_start; /* where intuit found a patch */
static LINENUM p_sline; /* and the line number for it */
static LINENUM p_hunk_beg; /* line number of current hunk */
static LINENUM p_efake = -1; /* end of faked up lines--don't free */
static LINENUM p_bfake = -1; /* beg of faked up lines */
/* Prepare to look for the next patch in the patch file. */
void
re_patch()
{
p_first = Nulline;
p_newfirst = Nulline;
p_ptrn_lines = Nulline;
p_repl_lines = Nulline;
p_end = (LINENUM)-1;
p_max = Nulline;
p_indent = 0;
}
/* Open the patch file at the beginning of time. */
void
open_patch_file(filename)
char *filename;
{
if (filename == Nullch || !*filename || strEQ(filename, "-")) {
pfp = fopen(TMPPATNAME, "w");
if (pfp == Nullfp)
fatal2("patch: can't create %s.\n", TMPPATNAME);
while (fgets(buf, sizeof buf, stdin) != Nullch)
fputs(buf, pfp);
Fclose(pfp);
filename = TMPPATNAME;
}
pfp = fopen(filename, "r");
if (pfp == Nullfp)
fatal2("patch file %s not found\n", filename);
#ifdef AMIGA
if(dfindOne(&filestat, filename, 0))
fatal2("dfindOne on file %s failed\n", filename);
p_filesize = filestat.fib_Size;
#else
Fstat(fileno(pfp), &filestat);
p_filesize = filestat.st_size;
#endif
next_intuit_at(0L,1L); /* start at the beginning */
set_hunkmax();
}
/* Make sure our dynamically realloced tables are malloced to begin with. */
void
set_hunkmax()
{
#ifndef lint
if (p_line == Null(char**))
p_line = (char**) malloc((MEM)hunkmax * sizeof(char *));
if (p_len == Null(short*))
p_len = (short*) malloc((MEM)hunkmax * sizeof(short));
#endif
if (p_char == Nullch)
p_char = (char*) malloc((MEM)hunkmax * sizeof(char));
}
/* Enlarge the arrays containing the current hunk of patch. */
void
grow_hunkmax()
{
hunkmax *= 2;
/*
* Note that on most systems, only the p_line array ever gets fresh memory
* since p_len can move into p_line's old space, and p_char can move into
* p_len's old space. Not on PDP-11's however. But it doesn't matter.
*/
assert(p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch);
#ifndef lint
p_line = (char**) realloc((char*)p_line, (MEM)hunkmax * sizeof(char *));
p_len = (short*) realloc((char*)p_len, (MEM)hunkmax * sizeof(short));
p_char = (char*) realloc((char*)p_char, (MEM)hunkmax * sizeof(char));
#endif
if (p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch)
return;
if (!using_plan_a)
fatal1("patch: out of memory (grow_hunkmax)\n");
out_of_mem = TRUE; /* whatever is null will be allocated again */
/* from within plan_a(), of all places */
}
/* True if the remainder of the patch file contains a diff of some sort. */
bool
there_is_another_patch()
{
if (p_base != 0L && p_base >= p_filesize) {
if (verbose)
say1("done\n");
return FALSE;
}
if (verbose)
say1("Hmm...");
diff_type = intuit_diff_type();
if (!diff_type) {
if (p_base != 0L) {
if (verbose)
say1(" Ignoring the trailing garbage.\ndone\n");
}
else
say1(" I can't seem to find a patch in there anywhere.\n");
return FALSE;
}
if (verbose)
say3(" %sooks like %s to me...\n",
(p_base == 0L ? "L" : "The next patch l"),
diff_type == CONTEXT_DIFF ? "a context diff" :
diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
diff_type == NORMAL_DIFF ? "a normal diff" :
"an ed script" );
if (p_indent && verbose)
say3("(Patch is indented %d space%s.)\n", p_indent, p_indent==1?"":"s");
skip_to(p_start,p_sline);
while (filearg[0] == Nullch) {
if (force) {
say1("No file to patch. Skipping...\n");
filearg[0] = savestr(bestguess);
return TRUE;
}
#ifdef AMIGA
fileRequest("File to patch");
#else
ask1("File to patch: ");
#endif
if (*buf != '\n') {
if (bestguess)
free(bestguess);
bestguess = savestr(buf);
filearg[0] = fetchname(buf, 0, FALSE);
}
if (filearg[0] == Nullch) {
#ifdef AMIGA
ask1("No file found--skip this patch?");
#else
ask1("No file found--skip this patch? [n] ");
#endif
if (*buf != 'y') {
continue;
}
if (verbose)
say1("Skipping patch...\n");
filearg[0] = fetchname(bestguess, 0, TRUE);
skip_rest_of_patch = TRUE;
return TRUE;
}
}
return TRUE;
}
/* Determine what kind of diff is in the remaining part of the patch file. */
int
intuit_diff_type()
{
Reg4 long this_line = 0;
Reg5 long previous_line;
Reg6 long first_command_line = -1;
long fcl_line;
Reg7 bool last_line_was_command = FALSE;
Reg8 bool this_is_a_command = FALSE;
Reg9 bool stars_last_line = FALSE;
Reg10 bool stars_this_line = FALSE;
Reg3 int indent;
Reg1 char *s;
Reg2 char *t;
char *indtmp = Nullch;
char *oldtmp = Nullch;
char *newtmp = Nullch;
char *indname = Nullch;
char *oldname = Nullch;
char *newname = Nullch;
Reg11 int retval;
bool no_filearg = (filearg[0] == Nullch);
ok_to_create_file = FALSE;
Fseek(pfp, p_base, 0);
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 = ftell(pfp);
indent = 0;
p_input_line++;
if (fgets(buf, sizeof buf, pfp) == Nullch) {
if (first_command_line >= 0L) {
/* nothing but deletes!? */
p_start = first_command_line;
p_sline = fcl_line;
retval = ED_DIFF;
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++) {
if (*s == '\t')
indent += 8 - (indent % 8);
else
indent++;
}
for (t=s; isdigit(*t) || *t == ','; t++) ;
this_is_a_command = (isdigit(*s) &&
(*t == 'd' || *t == 'c' || *t == 'a') );
if (first_command_line < 0L && 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))
oldtmp = savestr(s+4);
else if (strnEQ(s, "--- ", 4))
newtmp = savestr(s+4);
else if (strnEQ(s, "Index:", 6))
indtmp = savestr(s+6);
else if (strnEQ(s, "Prereq:", 7)) {
for (t=s+7; isspace(*t); t++) ;
revision = savestr(t);
for (t=revision; *t && !isspace(*t); t++) ;
*t = '\0';
if (!*revision) {
free(revision);
revision = Nullch;
}
}
if ((!diff_type || diff_type == ED_DIFF) &&
first_command_line >= 0L &&
strEQ(s, ".\n") ) {
p_indent = indent;
p_start = first_command_line;
p_sline = fcl_line;
retval = ED_DIFF;
goto scan_exit;
}
stars_this_line = strnEQ(s, "********", 8);
if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
strnEQ(s, "*** ", 4)) {
if (!atol(s+4))
ok_to_create_file = TRUE;
/* if this is a new context diff the character just before */
/* the newline is a '*'. */
while (*s != '\n')
s++;
p_indent = indent;
p_start = previous_line;
p_sline = p_input_line - 1;
retval = (*(s-1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
goto scan_exit;
}
if ((!diff_type || diff_type == NORMAL_DIFF) &&
last_line_was_command &&
(strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2)) ) {
p_start = previous_line;
p_sline = p_input_line - 1;
p_indent = indent;
retval = NORMAL_DIFF;
goto scan_exit;
}
}
scan_exit:
if (no_filearg) {
if (indtmp != Nullch)
indname = fetchname(indtmp, strippath, ok_to_create_file);
if (oldtmp != Nullch)
oldname = fetchname(oldtmp, strippath, ok_to_create_file);
if (newtmp != Nullch)
newname = fetchname(newtmp, strippath, ok_to_create_file);
if (oldname && newname) {
if (strlen(oldname) < strlen(newname))
filearg[0] = savestr(oldname);
else
filearg[0] = savestr(newname);
}
else if (oldname)
filearg[0] = savestr(oldname);
else if (newname)
filearg[0] = savestr(newname);
else if (indname)
filearg[0] = savestr(indname);
}
if (bestguess) {
free(bestguess);
bestguess = Nullch;
}
if (filearg[0] != Nullch)
bestguess = savestr(filearg[0]);
else if (indtmp != Nullch)
bestguess = fetchname(indtmp, strippath, TRUE);
else {
if (oldtmp != Nullch)
oldname = fetchname(oldtmp, strippath, TRUE);
if (newtmp != Nullch)
newname = fetchname(newtmp, strippath, TRUE);
if (oldname && newname) {
if (strlen(oldname) < strlen(newname))
bestguess = savestr(oldname);
else
bestguess = savestr(newname);
}
else if (oldname)
bestguess = savestr(oldname);
else if (newname)
bestguess = savestr(newname);
}
if (indtmp != Nullch)
free(indtmp);
if (oldtmp != Nullch)
free(oldtmp);
if (newtmp != Nullch)
free(newtmp);
if (indname != Nullch)
free(indname);
if (oldname != Nullch)
free(oldname);
if (newname != Nullch)
free(newname);
return retval;
}
/* Remember where this patch ends so we know where to start up again. */
void
next_intuit_at(file_pos,file_line)
long file_pos;
long file_line;
{
p_base = file_pos;
p_bline = file_line;
}
/* Basically a verbose fseek() to the actual diff listing. */
void
skip_to(file_pos,file_line)
long file_pos;
long file_line;
{
char *ret;
assert(p_base <= file_pos);
if (verbose && p_base < file_pos) {
Fseek(pfp, p_base, 0);
say1("The text leading up to this was:\n--------------------------\n");
while (ftell(pfp) < file_pos) {
ret = fgets(buf, sizeof buf, pfp);
assert(ret != Nullch);
say2("|%s", buf);
}
say1("--------------------------\n");
}
else
Fseek(pfp, file_pos, 0);
p_input_line = file_line - 1;
}
/* True if there is more of the current diff listing to process. */
bool
another_hunk()
{
Reg1 char *s;
Reg8 char *ret;
Reg2 int context = 0;
while (p_end >= 0) {
if (p_end == p_efake)
p_end = p_bfake; /* don't free twice */
else
free(p_line[p_end]);
p_end--;
}
assert(p_end == -1);
p_efake = -1;
p_max = hunkmax; /* gets reduced when --- found */
if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
long line_beginning = ftell(pfp);
/* file pos of the current line */
LINENUM repl_beginning = 0; /* index of --- line */
Reg4 LINENUM fillcnt = 0; /* #lines of missing ptrn or repl */
Reg5 LINENUM fillsrc; /* index of first line to copy */
Reg6 LINENUM filldst; /* index of first missing line */
bool ptrn_spaces_eaten = FALSE; /* ptrn was slightly misformed */
Reg9 bool repl_could_be_missing = TRUE;
/* no + or ! lines in this hunk */
bool repl_missing = FALSE; /* we are now backtracking */
long repl_backtrack_position = 0;
/* file pos of first repl line */
LINENUM repl_patch_line; /* input line number for same */
Reg7 LINENUM ptrn_copiable = 0;
/* # of copiable lines in ptrn */
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch || strnNE(buf, "********", 8)) {
next_intuit_at(line_beginning,p_input_line);
return FALSE;
}
p_context = 100;
p_hunk_beg = p_input_line + 1;
while (p_end < p_max) {
line_beginning = ftell(pfp);
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch) {
if (p_max - p_end < 4)
Strcpy(buf, " \n"); /* assume blank lines got chopped */
else {
if (repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
goto hunk_done;
}
fatal1("Unexpected end of file in patch.\n");
}
}
p_end++;
assert(p_end < hunkmax);
p_char[p_end] = *buf;
p_line[p_end] = Nullch;
switch (*buf) {
case '*':
if (strnEQ(buf, "********", 8)) {
if (repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
goto hunk_done;
}
else
fatal2("Unexpected end of hunk at line %ld.\n",
p_input_line);
}
if (p_end != 0) {
if (repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
goto hunk_done;
}
fatal3("Unexpected *** at line %ld: %s", p_input_line, buf);
}
context = 0;
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return FALSE;
}
for (s=buf; *s && !isdigit(*s); s++) ;
if (!*s)
goto malformed;
p_first = (LINENUM) atol(s);
while (isdigit(*s)) s++;
if (*s == ',') {
for (; *s && !isdigit(*s); s++) ;
if (!*s)
goto malformed;
p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
}
else if (p_first)
p_ptrn_lines = 1;
else {
p_ptrn_lines = 0;
p_first = 1;
}
p_max = p_ptrn_lines + 6; /* we need this much at least */
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 = TRUE;
goto hunk_done;
}
fatal3("Duplicate \"---\" at line %ld--check line numbers at line %ld.\n",
p_input_line, p_hunk_beg + repl_beginning);
}
else {
fatal4("%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 = ftell(pfp);
repl_patch_line = p_input_line;
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return FALSE;
}
p_char[p_end] = '=';
for (s=buf; *s && !isdigit(*s); s++) ;
if (!*s)
goto malformed;
p_newfirst = (LINENUM) atol(s);
while (isdigit(*s)) s++;
if (*s == ',') {
for (; *s && !isdigit(*s); s++) ;
if (!*s)
goto malformed;
p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
}
else if (p_newfirst)
p_repl_lines = 1;
else {
p_repl_lines = 0;
p_newfirst = 1;
}
p_max = p_repl_lines + p_end;
if (p_max > MAXHUNKSIZE)
fatal4("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)
repl_could_be_missing = FALSE;
break;
}
goto change_line;
case '+': case '!':
repl_could_be_missing = FALSE;
change_line:
if (!isspace(buf[1]) && buf[1] != '>' && buf[1] != '<' &&
repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
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 FALSE;
}
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_DIFF) ) {
repl_missing = TRUE;
goto hunk_done;
}
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return FALSE;
}
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(buf[1]) &&
repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
goto hunk_done;
}
context++;
if (!repl_beginning)
ptrn_copiable++;
p_line[p_end] = savestr(buf+2);
if (out_of_mem) {
p_end--;
return FALSE;
}
break;
default:
if (repl_beginning && repl_could_be_missing) {
repl_missing = TRUE;
goto hunk_done;
}
goto 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;
}
hunk_done:
if (p_end >=0 && !repl_beginning)
fatal2("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]);
Fseek(pfp, repl_backtrack_position, 0);
/* redundant 'new' context lines were omitted - set */
/* up to fill them in from the old file context */
fillsrc = 1;
filldst = repl_beginning+1;
fillcnt = p_repl_lines;
p_end = p_max;
}
if (diff_type == CONTEXT_DIFF &&
(fillcnt || (p_first > 1 && ptrn_copiable > 2*p_context)) ) {
if (verbose)
say1(
"(Fascinating--this is really a new-style context diff but without the ");
say1(
"telltale\nextra asterisks on the *** line that usually indicate the new");
say1("style...)\n");
diff_type = NEW_CONTEXT_DIFF;
}
/* 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)
fatal2("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++;
#ifdef DEBUGGING
if (debug & 64)
printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
fillsrc,filldst,repl_beginning,p_end+1);
#endif
assert(fillsrc==p_end+1 || fillsrc==repl_beginning);
assert(filldst==p_end+1 || filldst==repl_beginning);
}
}
else { /* normal diff--fake it up */
char hunk_type;
Reg3 int i;
LINENUM lMin, lMax;
long line_beginning = ftell(pfp);
p_context = 0;
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch || !isdigit(*buf)) {
next_intuit_at(line_beginning,p_input_line);
return FALSE;
}
p_first = (LINENUM)atol(buf);
for (s=buf; isdigit(*s); s++) ;
if (*s == ',') {
p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
while (isdigit(*s)) s++;
}
else
p_ptrn_lines = (*s != 'a');
hunk_type = *s;
if (hunk_type == 'a')
p_first++; /* do append rather than insert */
lMin = (LINENUM)atol(++s);
for (; isdigit(*s); s++) ;
if (*s == ',')
lMax = (LINENUM)atol(++s);
else
lMax = lMin;
if (hunk_type == 'd')
lMin++;
p_end = p_ptrn_lines + 1 + lMax - lMin + 1;
if (p_end > MAXHUNKSIZE)
fatal4("Hunk too large (%ld lines) at line %ld: %s",
p_end, p_input_line, buf);
while (p_end >= hunkmax)
grow_hunkmax();
p_newfirst = lMin;
p_repl_lines = lMax - lMin + 1;
Sprintf(buf, "*** %ld,%ld\n", p_first, p_first + p_ptrn_lines - 1);
p_line[0] = savestr(buf);
if (out_of_mem) {
p_end = -1;
return FALSE;
}
p_char[0] = '*';
for (i=1; i<=p_ptrn_lines; i++) {
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch)
fatal2("Unexpected end of file in patch at line %ld.\n",
p_input_line);
if (*buf != '<')
fatal2("< 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 FALSE;
}
p_len[i] = strlen(p_line[i]);
p_char[i] = '-';
}
if (hunk_type == 'c') {
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch)
fatal2("Unexpected end of file in patch at line %ld.\n",
p_input_line);
if (*buf != '-')
fatal2("--- expected at line %ld of patch.\n", p_input_line);
}
Sprintf(buf, "--- %ld,%ld\n", lMin, lMax);
p_line[i] = savestr(buf);
if (out_of_mem) {
p_end = i-1;
return FALSE;
}
p_char[i] = '=';
for (i++; i<=p_end; i++) {
ret = pgets(buf, sizeof buf, pfp);
p_input_line++;
if (ret == Nullch)
fatal2("Unexpected end of file in patch at line %ld.\n",
p_input_line);
if (*buf != '>')
fatal2("> 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 FALSE;
}
p_len[i] = strlen(p_line[i]);
p_char[i] = '+';
}
}
if (reverse) /* backwards patch? */
if (!pch_swap())
say1("Not enough memory to swap next hunk!\n");
#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, "%3d %c %c %s", i, p_char[i], special, p_line[i]);
Fflush(stderr);
}
}
#endif
if (p_end+1 < hunkmax) /* paranoia reigns supreme... */
p_char[p_end+1] = '^'; /* add a stopper for apply_hunk */
return TRUE;
malformed:
fatal3("Malformed patch at line %ld: %s", p_input_line, buf);
/* about as informative as "Syntax error" in C */
return FALSE; /* for lint */
}
/* Input a line from the patch file, worrying about indentation. */
char *
pgets(bf,sz,fp)
char *bf;
int sz;
FILE *fp;
{
char *ret = fgets(bf, sz, fp);
Reg1 char *s;
Reg2 int indent = 0;
if (p_indent && ret != Nullch) {
for (s=buf; indent < p_indent && (*s == ' ' || *s == '\t'); s++) {
if (*s == '\t')
indent += 8 - (indent % 7);
else
indent++;
}
if (buf != s)
Strcpy(buf, s);
}
return ret;
}
/* Reverse the old and new portions of the current hunk. */
bool
pch_swap()
{
char **tp_line; /* the text of the hunk */
short *tp_len; /* length of each line */
char *tp_char; /* +, -, and ! */
Reg1 LINENUM i;
Reg2 LINENUM n;
bool blankline = FALSE;
Reg3 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(char**); /* force set_hunkmax to allocate again */
p_len = Null(short*);
p_char = Nullch;
set_hunkmax();
if (p_line == Null(char**) || p_len == Null(short*) || p_char == Nullch) {
#ifndef lint
if (p_line == Null(char**))
free((char*)p_line);
p_line = tp_line;
if (p_len == Null(short*))
free((char*)p_len);
p_len = tp_len;
#endif
if (p_char == Nullch)
free((char*)p_char);
p_char = tp_char;
return FALSE; /* 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 = TRUE;
i++;
}
if (p_efake >= 0) { /* fix non-freeable ptr range */
n = p_end - i + 1;
if (p_efake > i)
n = -n;
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++;
}
assert(p_char[0] == '=');
p_char[0] = '*';
for (s=p_line[0]; *s; s++)
if (*s == '-')
*s = '*';
/* now turn the old into the new */
assert(tp_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];
}
assert(i == p_ptrn_lines + 1);
i = p_ptrn_lines;
p_ptrn_lines = p_repl_lines;
p_repl_lines = i;
#ifndef lint
if (tp_line == Null(char**))
free((char*)tp_line);
if (tp_len == Null(short*))
free((char*)tp_len);
#endif
if (tp_char == Nullch)
free((char*)tp_char);
return TRUE;
}
/* Return the specified line position in the old file of the old context. */
LINENUM
pch_first()
{
return p_first;
}
/* Return the number of lines of old context. */
LINENUM
pch_ptrn_lines()
{
return p_ptrn_lines;
}
/* Return the probable line position in the new file of the first line. */
LINENUM
pch_newfirst()
{
return p_newfirst;
}
/* Return the number of lines in the replacement text including context. */
LINENUM
pch_repl_lines()
{
return p_repl_lines;
}
/* Return the number of lines in the whole hunk. */
LINENUM
pch_end()
{
return p_end;
}
/* Return the number of context lines before the first changed line. */
LINENUM
pch_context()
{
return p_context;
}
/* Return the length of a particular patch line. */
short
pch_line_len(line)
LINENUM line;
{
return p_len[line];
}
/* Return the control character (+, -, *, !, etc) for a patch line. */
char
pch_char(line)
LINENUM line;
{
return p_char[line];
}
/* Return a pointer to a particular patch line. */
char *
pfetch(line)
LINENUM line;
{
return p_line[line];
}
/* Return where in the patch file this hunk began, for error messages. */
LINENUM
pch_hunk_beg()
{
return p_hunk_beg;
}
#ifndef AMIGA
/* Apply an ed script by feeding ed itself. */
void
do_ed_script()
{
Reg1 char *t;
Reg2 long beginning_of_this_line;
Reg3 bool this_line_is_command = FALSE;
Reg4 FILE *pipefp;
FILE *popen();
if (!skip_rest_of_patch) {
Unlink(TMPOUTNAME);
copy_file(filearg[0], TMPOUTNAME);
if (verbose)
Sprintf(buf, "/bin/ed %s", TMPOUTNAME);
else
Sprintf(buf, "/bin/ed - %s", TMPOUTNAME);
pipefp = popen(buf, "w");
}
for (;;) {
beginning_of_this_line = ftell(pfp);
if (pgets(buf, sizeof buf, pfp) == Nullch) {
next_intuit_at(beginning_of_this_line,p_input_line);
break;
}
p_input_line++;
for (t=buf; isdigit(*t) || *t == ','; t++) ;
this_line_is_command = (isdigit(*buf) &&
(*t == 'd' || *t == 'c' || *t == 'a') );
if (this_line_is_command) {
if (!skip_rest_of_patch)
fputs(buf, pipefp);
if (*t != 'd') {
while (pgets(buf, sizeof buf, pfp) != Nullch) {
p_input_line++;
if (!skip_rest_of_patch)
fputs(buf, pipefp);
if (strEQ(buf, ".\n"))
break;
}
}
}
else {
next_intuit_at(beginning_of_this_line,p_input_line);
break;
}
}
if (skip_rest_of_patch)
return;
fprintf(pipefp, "w\n");
fprintf(pipefp, "q\n");
Fflush(pipefp);
Pclose(pipefp);
ignore_signals();
if (move_file(TMPOUTNAME, outname) < 0) {
toutkeep = TRUE;
chmod(TMPOUTNAME, filemode);
}
else
chmod(outname, filemode);
set_signals();
}
#endif
SHAR_EOF
if test 28573 -ne "`wc -c pch.c`"
then
echo shar: error transmitting pch.c '(should have been 28573 characters)'
fi
echo shar: extracting version.c '(489 characters)'
cat << \SHAR_EOF > version.c
/* $Header: version.c,v 2.0 86/09/17 15:40:11 lwall Exp $
*
* $Log: version.c,v $
* Revision 2.0 86/09/17 15:40:11 lwall
* Baseline for netwide release.
*
*/
#include "EXTERN.h"
#include "common.h"
#include "util.h"
#include "INTERN.h"
#include "patchlevel.h"
#include "version.h"
/* Print out the version number and die. */
void
version()
{
extern char rcsid[];
#ifdef lint
rcsid[0] = rcsid[0];
#else
fatal3("%s\nPatch level: %d\n", rcsid, PATCHLEVEL);
#endif
}
SHAR_EOF
if test 489 -ne "`wc -c version.c`"
then
echo shar: error transmitting version.c '(should have been 489 characters)'
fi
echo shar: extracting version.h '(185 characters)'
cat << \SHAR_EOF > version.h
/* $Header: version.h,v 2.0 86/09/17 15:40:14 lwall Exp $
*
* $Log: version.h,v $
* Revision 2.0 86/09/17 15:40:14 lwall
* Baseline for netwide release.
*
*/
void version();
SHAR_EOF
if test 185 -ne "`wc -c version.h`"
then
echo shar: error transmitting version.h '(should have been 185 characters)'
fi
# End of shell archive
exit 0