![[Erlang Systems]](min_head.gif)
The module shell implements an Erlang shell.
The shell is a user interface program
for entering expression sequences. The expressions are
evaluated and a value is returned.
A history mechanism saves previous commands and their
values, which can then be incorporated in later commands.
How many commands and results to save can be determined by the user,
either interactively, by calling shell:history/1 and
shell:results/1, or by setting the application configuration
parameters shell_history_length and
shell_saved_results for the application stdlib.
Variable bindings, and local process dictionary changes which are generated in user expressions, are preserved and the variables can be used in later commands to access their values. The bindings can also be forgotten so the variables can be re-used.
The special shell commands all have the syntax of (local) function calls. They are evaluated as normal function calls and many commands can be used in one expression sequence.
If a command (local function call) is not recognized by the
shell, an attempt is first made to find the function in the
module user_default, where customized local commands
can be placed. If found, then the function is evaluated.
Otherwise, an attempt is made to evaluate the function in the
module shell_default. The module
user_default must be explicitly loaded.
The shell also permits the user to start multiple concurrent jobs. A job can be regarded as a set of processes which can communicate with the shell.
The shell runs in two modes:
Normal mode, in which commands can be edited and expressions evaluatedJCL, in which jobs can be started, killed,
detached and connected.Only the currently connected job can 'talk' to the shell.
b()f()f(X)X.
h()history(N)N. The previous number is returned.
The default number is 20.
results(N)N. The previous number is returned.
The default number is 20.
e(N)N, if N is positive. If
it is negative, the Nth previous command is repeated
(i.e., e(-1) repeats the previous command).
v(N)N in the
current command.
help()shell_default:help().
c(File)shell_default:c(File). This compiles
and loads code in File and purges old versions of
code, if necessary. Assumes that the file and module names
are the same.
The following example is a long dialogue with the shell. Commands
starting with > are inputs to the shell. All other lines
are output from the shell. All commands in this example are explained at the end of the dialogue.
.
strider 1> erl
Erlang (BEAM) emulator version 4.9
Eshell V4.9 (abort with ^G)
1> Str = "abcd".
"abcd"
2> L = length(Str).
4
3> Descriptor = {L, list_to_atom(Str)}.
{4,abcd}
4> L.
4
5> b().
Descriptor = {4,abcd}
L = 4
Str = "abcd"
ok
6> f(L).
ok
7> b().
Descriptor = {4,abcd}
Str = "abcd"
ok
8> f(L).
ok
9> {L, _} = Descriptor.
{4,abcd}
10> L.
4
11> {P, Q, R} = Descriptor.
** exited: {{badmatch,{4,abcd}},{erl_eval,expr,3}} **
12> P.
** exited: {{unbound,'P'},{erl_eval,expr,3}} **
13> Descriptor.
{4,abcd}
14> {P, Q} = Descriptor.
{4,abcd}
15> P.
4
16> f().
ok
17> put(aa, hello).
undefined
18> get(aa).
hello
19> Y = test1:demo(1).
11
20> get().
[{aa,worked}]
21> put(aa, hello).
worked
22> Z = test1:demo(2).
** exited: {{badmatch,1},{test1,demo,[2]}} **
=ERROR REPORT==== 24-Jan-1997::07:48:46 ===
!!! Error in process <0.22.0> with exit value: {{badmatch,1}
,{test1,demo,[2]}}
23> Z.
** exited: {{unbound,'Z'},{erl_eval,expr,3}} **
24> get(aa).
hello
25> erase(), put(aa, hello).
undefined
26> spawn(test1, demo, [1]).
<0.25.0>
27> get(aa).
hello
28> io:format("hello hello\n").
hello hello
ok
29> e(28).
hello hello
ok
30> v(28).
ok
31> test1:loop(0).
Hello Number: 0
Hello Number: 1
Hello Number: 2
Hello Number: 3
User switch command
--> i
--> c
.
.
.
Hello Number: 3374
Hello Number: 3375
Hello Number: 3376
Hello Number: 3377
Hello Number: 3378
** exited: killed **
32> halt().
strider 2>
Command 1 sets the variable Str to the string
"abcd".
Command 2 sets L to the length of the string evaluating
the BIF atom_to_list.
Command 3 builds the tuple Descriptor.
Command 4 prints the value of the variable L.
Command 5 evaluates the internal shell command b(), which
is an abbreviation of "bindings". This prints
the current shell variables and their bindings. The ok at
the end is the return value of the b() function.
Command 6 f(L) evaluates the internal shell command
f(L) (abbreviation of "forget"). The value of the variable
L is removed.
Command 7 prints the new bindings.
Command 8 shows that the value of L has disappeared from
the bindings.
Command 9 performs a pattern matching operation on
Descriptor, binding a new value to L.
Command 10 prints the current value of L.
Command 11 tries to match {P, Q, R} against
Descriptor which is {4, abc}.
The match fails and none of the new variables become bound.
The printout starting with "** exited:" is not the value
of the expression (the expression had no value because its
evaluation failed), but rather a warning printed by the system
to inform the user that an error has occurred. The values of the
other variables (L, Str, etc.) are unchanged.
Commands 12 and 13 show that P is unbound because the
previous command failed, and that Descriptor has not
changed.
Commands 14 and 15 show a correct match where P and
Q are bound.
Command 16 clears all bindings.
The next few commands assume that test1:demo(X) is
defined in the following way:
demo(X) ->
put(aa, worked),
X = 1,
X + 10.
Commands 17 and 18 set and inspect the value of the item
aa in the process dictionary.
Command 19 evaluates test1:demo(1). The evaluation
succeeds and the changes made in the process dictionary become
visible to the shell. The new value of the dictionary item
aa can be seen in command 20.
Commands 21 and 22 change the value of the dictionary item
aa to hello and call test1:demo(2). Evaluation
fails and the changes made to the dictionary in
test1:demo(2), before the error occurred, are discarded.
Commands 23 and 24 show that Z was not bound and that the
dictionary item aa has retained its original value.
Commands 25, 26 and 27 show the effect of evaluating
test1:demo(1) in the background. In this case, the
expression is evaluated in a newly spawned process. Any
changes made in the process dictionary are local to the newly
spawned process and therefore not visible to the shell.
Commands 28, 29 and 30 use the history facilities of the shell.
Command 29 is e(28). This re-evaluates command
28. Command 30 is v(28). This uses the value (result) of
command 28. In the cases of a pure function (a function
with no side effects), the result is the same. For a function
with side effects, the result can be different.
For the next command, it is assumed that test1:loop(N) is
defined in the following way:
loop(N) ->
io:format("Hello Number: ~w~n", [N]),
loop(N+1).
Command 31 evaluates test1:loop(0), which puts the
system into an infinite loop. At this point the user types
Control G, which suspends output from the current process,
which is stuck in a loop, and activates JCL mode. In JCL
mode the user can start and stop jobs.
In this particular case, the i command ("interrupt") is
used to terminate the looping program, and the c command
is used to connect to the shell again. Since the process was
running in the background before we killed it, there will be
more printouts before the "** exited: killed **" message is
shown.
The halt() command exits the Erlang runtime system.
When the shell starts, it starts a single evaluator
process. This process, together with any local processes which
it spawns, is referred to as a job. Only the current job,
which is said to be connected, can perform operations
with standard IO. All other jobs, which are said to be detached, are
blocked if they attempt to use standard IO.
All jobs which do not use standard IO run in the normal way.
^G (Control G) detaches the current job and JCL mode is
activated. The JCL mode prompt is "-->". If "?" is entered at the prompt, the following help message is
displayed:
--> ?
c [nn] - connect to job
i [nn] - interrupt job
k [nn] - kill job
j - list all jobs
s - start local shell
r [node] - start remote shell
q - quit Erlang
? | h - this message
The JCL commands have the following meaning:
c [nn]<nn> or the current
job. The standard shell is resumed. Operations which use
standard IO by the current job will be interleaved with
user inputs to the shell.
i [nn]nn or the current job, but does not kill the shell
process. Accordingly, any variable bindings and the process dictionary
will be preserved and the job can be connected again.
This command can be used to interrupt an endless loop.
k [nn]nn or the current
job. All spawned processes in the job are
killed, provided they have not evaluated the
group_leader/1 BIF and are located on
the local machine. Processes spawned on remote nodes will
not be killed.
js[nn] which can be used in references.
r [node]node. This is used in
distributed Erlang to allow a shell running on one node to
control a number of applications running on a network of
nodes.
q?N = integer() Sets the number of previous commands to keep in the
history list to N. The previous number is returned.
The default number is 20.
N = integer() Sets the number of results from previous commands to keep in
the history list to N. The previous number is returned.
The default number is 20.