kill .SHELL, make doesn't even support it in non-parallel mode.

1 files changed, 1 insertions, 201 deletions

diff --git a/usr.bin/make/PSD.doc/tutorial.ms b/usr.bin/make/PSD.doc/tutorial.ms
index 6b6e28a0da4..1b446dce96c 100644
--- a/usr.bin/make/PSD.doc/tutorial.ms
+++ b/usr.bin/make/PSD.doc/tutorial.ms
@@ -1,4 +1,4 @@
-.\"	$OpenBSD: tutorial.ms,v 1.10 2007/02/20 08:18:47 jmc Exp $
+.\"	$OpenBSD: tutorial.ms,v 1.11 2007/09/16 10:57:03 espie Exp $
 .\"	$NetBSD: tutorial.ms,v 1.3 1996/03/06 00:15:31 christos Exp $
 .\" Copyright (c) 1988, 1989 by Adam de Boor
 .\" Copyright (c) 1989 by Berkeley Softworks
@@ -2306,15 +2306,6 @@ attribute is given to every target in the file.
 This target applies the
 .CW .MAKE
 attribute to all its sources. It does nothing if you don't give it any sources.
-.IP .SHELL \n(pw
-.Ix 0 def .SHELL
-Make is not constrained to only using the Bourne shell to execute
-the commands you put in the makefile. You can tell it some other shell
-to use with this target. Check out
-.B "A Shell is a Shell is a Shell"
-(section 4.4)
-.Rm 7 4.4
-for more information.
 .IP .SILENT \n(pw
 .Ix 0 def .SILENT target
 .Ix 0 ref .SILENT attribute
@@ -2993,197 +2984,6 @@ would wreak havoc if you tried
 .CW "make draft print" '' ``
 since you would use the same formatter for each target. As I said,
 this all gets somewhat complicated.
-.xH 2 A Shell is a Shell is a Shell
-.Rd 7
-.LP
-In normal operation, the Bourne Shell (better known as
-.CW sh '') ``
-is used to execute the commands to re-create targets. Make also allows you
-to specify a different shell for it to use when executing these
-commands. There are several things Make must know about the shell you
-wish to use. These things are specified as the sources for the
-.CW .SHELL
-.Ix 0 ref .SHELL
-.Ix 0 ref target .SHELL
-target by keyword, as follows:
-.IP "\fBpath=\fP\fIpath\fP"
-Make needs to know where the shell actually resides, so it can
-execute it. If you specify this and nothing else, Make will use the
-last component of the path and look in its table of the shells it
-knows and use the specification it finds, if any. Use this if you just
-want to use a different version of the Bourne or C Shell (yes, Make knows
-how to use the C Shell too).
-.IP "\fBname=\fP\fIname\fP"
-This is the name by which the shell is to be known. It is a single
-word and, if no other keywords are specified (other than
-.B path ),
-it is the name by which Make attempts to find a specification for
-it (as mentioned above). You can use this if you would just rather use
-the C Shell than the Bourne Shell
-.CW ".SHELL: name=csh" '' (``
-will do it).
-.IP "\fBquiet=\fP\fIecho-off command\fP"
-As mentioned before, Make actually controls whether commands are
-printed by introducing commands into the shell's input stream. This
-keyword, and the next two, control what those commands are. The
-.B quiet
-keyword is the command used to turn echoing off. Once it is turned
-off, echoing is expected to remain off until the echo-on command is given.
-.IP "\fBecho=\fP\fIecho-on command\fP"
-The command Make should give to turn echoing back on again.
-.IP "\fBfilter=\fP\fIprinted echo-off command\fP"
-Many shells will echo the echo-off command when it is given. This
-keyword tells Make in what format the shell actually prints the
-echo-off command. Wherever Make sees this string in the shell's
-output, it will delete it and any following whitespace, up to and
-including the next newline. See the example at the end of this section
-for more details.
-.IP "\fBechoFlag=\fP\fIflag to turn echoing on\fP"
-Unless a target has been marked
-.CW .SILENT ,
-Make wants to start the shell running with echoing on. To do this, it
-passes this flag to the shell as one of its arguments. If either this
-or the next flag begins with a `\-', the flags will be passed to the
-shell as separate arguments. Otherwise, the two will be concatenated
-(if they are used at the same time, of course).
-.IP "\fBerrFlag=\fP\fIflag to turn error checking on\fP"
-Likewise, unless a target is marked
-.CW .IGNORE ,
-Make wishes error-checking to be on from the very start. To this end,
-it will pass this flag to the shell as an argument. The same rules for
-an initial `\-' apply as for the
-.B echoFlag .
-.IP "\fBcheck=\fP\fIcommand to turn error checking on\fP"
-Just as for echo-control, error-control is achieved by inserting
-commands into the shell's input stream. This is the command to make
-the shell check for errors. It also serves another purpose if the
-shell doesn't have error-control as commands, but I'll get into that
-in a minute. Again, once error checking has been turned on, it is
-expected to remain on until it is turned off again.
-.IP "\fBignore=\fP\fIcommand to turn error checking off\fP"
-This is the command Make uses to turn error checking off. It has
-another use if the shell doesn't do error-control, but I'll tell you
-about that.\|.\|.\|now.
-.IP "\fBhasErrCtl=\fP\fIyes or no\fP"
-This takes a value that is either
-.B yes
-or
-.B no .
-Now you might think that the existence of the
-.B check
-and
-.B ignore
-keywords would be enough to tell Make if the shell can do
-error-control, but you'd be wrong. If
-.B hasErrCtl
-is
-.B yes ,
-Make uses the check and ignore commands in a straight-forward manner.
-If this is
-.B no ,
-however, their use is rather different. In this case, the check
-command is used as a template, in which the string
-.B %s
-is replaced by the command that's about to be executed, to produce a
-command for the shell that will echo the command to be executed. The
-ignore command is also used as a template, again with
-.B %s
-replaced by the command to be executed, to produce a command that will
-execute the command to be executed and ignore any error it returns.
-When these strings are used as templates, you must provide newline(s)
-.CW \en '') (``
-in the appropriate place(s).
-.LP
-The strings that follow these keywords may be enclosed in single or
-double quotes (the quotes will be stripped off) and may contain the
-usual C backslash-characters (\en is newline, \er is return, \eb is
-backspace, \e' escapes a single-quote inside single-quotes, \e"
-escapes a double-quote inside double-quotes). Now for an example.
-.LP
-This is actually the contents of the
-.CW <shx.mk>
-system makefile, and causes Make to use the Bourne Shell in such a
-way that each command is printed as it is executed. That is, if more
-than one command is given on a line, each will be printed separately.
-Similarly, each time the body of a loop is executed, the commands
-within that loop will be printed, etc. The specification runs like
-this:
-.DS
-#
-# This is a shell specification to have the bourne shell echo
-# the commands just before executing them, rather than when it reads
-# them. Useful if you want to see how variables are being expanded, etc.
-#
-\&.SHELL 	: path=/bin/sh \e
-	quiet="set -" \e
-	echo="set -x" \e
-	filter="+ set - " \e
-	echoFlag=x \e
-	errFlag=e \e
-	hasErrCtl=yes \e
-	check="set -e" \e
-	ignore="set +e"
-.DE
-.LP
-It tells Make the following:
-.Bp
-The shell is located in the file
-.CW /bin/sh .
-It need not tell Make that the name of the shell is
-.CW sh 
-as Make can figure that out for itself (it's the last component of
-the path).
-.Bp
-The command to stop echoing is
-.CW "set -" .
-.Bp
-The command to start echoing is
-.CW "set -x" .
-.Bp
-When the echo off command is executed, the shell will print
-.CW "+ set - " 
-(The `+' comes from using the
-.CW \-x
-flag (rather than the
-.CW \-v
-flag Make usually uses)). Make will remove all occurrences of this
-string from the output, so you don't notice extra commands you didn't
-put there.
-.Bp
-The flag the Bourne Shell will take to start echoing in this way is
-the
-.CW \-x
-flag. The Bourne Shell will only take its flag arguments concatenated
-as its first argument, so neither this nor the
-.B errFlag
-specification begins with a \-.
-.Bp
-The flag to use to turn error-checking on from the start is
-.CW \-e .
-.Bp
-The shell can turn error-checking on and off, and the commands to do
-so are
-.CW "set +e"
-and
-.CW "set -e" ,
-respectively.
-.LP
-This will cause Make to execute the two commands
-.DS
-echo "+ \fIcmd\fP"
-sh -c '\fIcmd\fP || true'
-.DE
-for each command for which errors are to be ignored. (In case you are
-wondering, the thing for
-.CW ignore
-tells the shell to execute another shell without error checking on and
-always exit 0, since the
-.B ||
-causes the
-.CW "exit 0"
-to be executed only if the first command exited non-zero, and if the
-first command exited zero, the shell will also exit zero, since that's
-the last command it executed).
 .xH 2 Compatibility
 .Ix 0 ref compatibility
 .LP