SH-STD(1) SH-STD(1)
NAME
std, if, while, ~, no, !, apply, getlines, status, pctl, fn,
and, or, raise, rescue, hd, tl, index, split, join, pid,
parse, pctl, env - standard shell builtins module.
SYNOPSIS
load std
! command
~ value [ pattern... ]
no [ arg... ]
and command...
apply command [ arg... ]
getlines [ separators ] command
flag f [ +- ]
for var in [ arg... ] command
fn name command
if condition action [ condition action ]... [ elseaction ]
or command...
pctl flag...
raise name
rescue pattern rescueblock command
status value
subfn name command
while condition command
${hd list}
${index number list}
${pid}
${split [ separators ] arg}
${join separator list}
${tl list}
${parse arg]
${pipe ( from | to | fdnum ) command}
${env}
DESCRIPTION
Std is a loadable module for sh(1) that provides the equiva-
lent of a ``standard library'' for the shell, including a
set of control-flow constructs and some other miscellaneous
commands. In the following descriptions, if an argument is
executed, then it should be a braced block suitable for exe-
cuting by sh. A true exit status is defined to be nil; any
non-nil exit status is false. Unless otherwise stated, the
return value of a command is that of the last command that
it executed. If invalid arguments are passed to any com-
mand, a usage exception is raised, and a message printed to
stderr.
Each of the looping commands for, apply, while, and getlines
installs an exception handler for the duration of the loop
SH-STD(1) SH-STD(1)
to catch the exceptions break and continue. If a break
exception is caught, the loop is terminated; if a continue
exception is caught, the loop will continue executing as
usual. The commands are as follows:
! ! inverts the exit status of a command (non-null
is changed to null, null is changed to non-null).
~ ~ matches value against each pattern in turn,
returning true if any of them match and false oth-
erwise. The patterns are of the same form as
those accepted by the shell for filename pattern
matching except that / is not treated specially.
(see filepat(2)). Patterns must be quoted to stop
the shell from interpreting them.
no True if there are no arguments. Useful for testing
if there are any items in a list without counting
the items with $#.
and And evaluates each command in turn until one
returns false.
apply Apply evaluates command once for each arg, passing
it in the variable $1.
getlines Getlines reads lines from the standard input, exe-
cuting command for each line, setting the environ-
ment variable $line to the line read, with any
terminating character removed. If separators is
given, a line is terminated when any character in
separators is found; the default separator string
is a single newline character.
flag Either set (+), clear (-), or test (neither + or
-) the flag f, where f is a single character, one
of the command line flags to sh (see sh(1)).
fn Fn defines a new builtin command named name; when
run, this command evaluates command. The command
is stored in the environment variable fn-name; any
variables of this form found when when std is
loaded will be defined in this way. If command is
not given, then the builtin will be removed.
subfn Subfn is similar to fn except that it defines a
new substitution builtin name. When name is
invoked, it creates a new local variable result
and executes command. The value of $result when
command has terminated is the value yielded by the
substitution builtin name. Command is stored in
and restored from the environment in a similar way
SH-STD(1) SH-STD(1)
to fn, except that sfn-name is used as the name of
the environment variable.
if If executes condition; if it returns true, then
action is executed, otherwise each of the next
condition-action pairs is evaluated in the same
way; if no condition is satisfied, then elseaction
will be executed, if present.
for For is similar to apply; it runs command once for
each arg, but it performs a local assignment of
arg to var each time.
or Or evaluates each command in turn until one
returns true.
pctl Pctl is an interface to the Inferno system call
sys-pctl(2); each argument specifies one bit in
the bitmask passed to that function. The possible
flags are newfd, forkfd, newns, forkns, newpgrp
and nodevs. See sys-pctl(2) for details of the
meaning of these flags. Pctl returns true.
raise Raise raises the exception name; name will be
truncated if it is longer than that allowed by
raise (128 bytes in utf(6) representation). Con-
trol will be transferred to the innermost rescue
block in the same process that matches name. If
there is no rescue block in place, the current
process will exit, yielding name as its exit sta-
tus. If no name is given, the exception named in
$exception is raised; if this is null, a bad raise
context exception is raised. The default command
prompt catches all exceptions.
rescue Rescue executes command with an exception handler
installed for the duration of the call. It will
catch all exceptions with a name matching pattern,
where pattern is of the same form accepted by
Limbo's exception handling statement. Specifi-
cally, the pattern is a string that matches liter-
ally, except that a trailing `*' character will
match any sequence of characters. If an exception
is caught, rescue executes rescueblock, setting
$exception to the name of the exception raised.
status returns its first argument word as its exit sta-
tus, or nil if none is given.
while While repeatedly executes condition and then
action until condition does not return true.
SH-STD(1) SH-STD(1)
${env} Env yields a list of the names of all currently
set non-nil environment variables.
${hd} Hd yields the first of its arguments, or nil if
there are no arguments.
${index} Index yields the n'th element in its argument
list, indexed from 1. N must be a decimal inte-
ger.
${join} Join yields a single element which is the concate-
nation of all the elements in list separated by
separator. If there are no elements in list, it
yields an empty string. The shell operator $"var
is exactly equivalent to ${join ' ' $var}.
${parse} Parse parses arg according to the usual syntax
rules, raising a parse error exception if it
fails. Arg must be a well-formed command block
surrounded by braces. Parse yields a functionally
equivalent version of arg.
${pid} Pid yields the process id of the current process.
${pipe} Pipe runs command asynchronously, with one of its
file descriptors connected to a bidirectional
pipe. The first argument to pipe determines which
file descriptor is connected: if the argument is
from, its standard output is connected; if the
argument is to, its standard input is connected;
otherwise file descriptor fdnum is connected.
Pipe yields the name of a file that can be opened
to access the other end of the pipe. Note that
this command is now deprecated in favour of the
<{} redirection operator built in to the shell.
${split} Split splits arg into list elements at every point
where one or more characters in separators appear.
If separators is not given, the value of $ifs is
used.
${tl} Tl yields all but the first of its arguments, or
nil if there are no arguments.
Syntactic considerations
It is worth being aware of a few pitfalls that await the
user of some of these commands. Unlike other shells, the
syntax of sh does not include the syntax of the control flow
commands, so it is important to be aware of the rules that
govern the gathering of the arguments for a command. In
particular, the following code, written to print a message a
filename ends in .b will not work: it will always print
SH-STD(1) SH-STD(1)
``file is Limbo source''.
and
{~ $filename '*.b'}
{echo file is Limbo source}
This is because newlines separate shell commands, so the
above code first invokes and with no arguments, and then
each of the braced block commands on each subsequent line.
It is usual to use round brackets in order to group together
arguments on separate lines, e.g.
and (
{~ $filename '*.b'}
{echo file is Limbo source}
)
This has the originally intended meaning.
FILES
/tmp/pipe.*d Temporary placeholder directory for named
pipes.
/tmp/pipes/* Mount point for named pipes.
SOURCE
/appl/cmd/sh/std.b
SEE ALSO
sh(1), sh-expr(1), sh-tk(1)