Current File : //usr/local/share/zsh/5.8/help/emulate
emulate [ -lLR ] [ {zsh|sh|ksh|csh} [ flags ... ] ]
Without any argument print current emulation mode.
With single argument set up zsh options to emulate the specified
shell as much as possible. csh will never be fully emulated. If
the argument is not one of the shells listed above, zsh will be
used as a default; more precisely, the tests performed on the
argument are the same as those used to determine the emulation at
startup based on the shell name, see the section COMPATIBILITY in
zsh(1) . In addition to setting shell options, the command also
restores the pristine state of pattern enables, as if all patterns
had been enabled using enable -p.
If the emulate command occurs inside a function that has been
marked for execution tracing with functions -t then the xtrace
option will be turned on regardless of emulation mode or other
options. Note that code executed inside the function by the .,
source, or eval commands is not considered to be running directly
from the function, hence does not provoke this behaviour.
If the -R switch is given, all settable options are reset to their
default value corresponding to the specified emulation mode,
except for certain options describing the interactive environment;
otherwise, only those options likely to cause portability problems
in scripts and functions are altered. If the -L switch is given,
the options LOCAL_OPTIONS, LOCAL_PATTERNS and LOCAL_TRAPS will be
set as well, causing the effects of the emulate command and any
setopt, disable -p or enable -p, and trap commands to be local to
the immediately surrounding shell function, if any; normally these
options are turned off in all emulation modes except ksh. The -L
switch is mutually exclusive with the use of -c in flags.
If there is a single argument and the -l switch is given, the
options that would be set or unset (the latter indicated with the
prefix `no') are listed. -l can be combined with -L or -R and the
list will be modified in the appropriate way. Note the list does
not depend on the current setting of options, i.e. it includes all
options that may in principle change, not just those that would
actually change.
The flags may be any of the invocation-time flags described in the
section INVOCATION in zsh(1), except that `-o EMACS' and `-o VI'
may not be used. Flags such as `+r'/`+o RESTRICTED' may be
prohibited in some circumstances.
If -c arg appears in flags, arg is evaluated while the requested
emulation is temporarily in effect. In this case the emulation
mode and all options are restored to their previous values before
emulate returns. The -R switch may precede the name of the shell
to emulate; note this has a meaning distinct from including -R in
flags.
Use of -c enables `sticky' emulation mode for functions defined
within the evaluated expression: the emulation mode is associated
thereafter with the function so that whenever the function is
executed the emulation (respecting the -R switch, if present) and
all options are set (and pattern disables cleared) before entry to
the function, and the state is restored after exit. If the
function is called when the sticky emulation is already in effect,
either within an `emulate shell -c' expression or within another
function with the same sticky emulation, entry and exit from the
function do not cause options to be altered (except due to
standard processing such as the LOCAL_OPTIONS option). This also
applies to functions marked for autoload within the sticky
emulation; the appropriate set of options will be applied at the
point the function is loaded as well as when it is run.
For example:
emulate sh -c 'fni() { setopt cshnullglob; }
fno() { fni; }'
fno
The two functions fni and fno are defined with sticky sh
emulation. fno is then executed, causing options associated with
emulations to be set to their values in sh. fno then calls fni;
because fni is also marked for sticky sh emulation, no option
changes take place on entry to or exit from it. Hence the option
cshnullglob, turned off by sh emulation, will be turned on within
fni and remain on return to fno. On exit from fno, the emulation
mode and all options will be restored to the state they were in
before entry to the temporary emulation.
The documentation above is typically sufficient for the intended
purpose of executing code designed for other shells in a suitable
environment. More detailed rules follow.
1. The sticky emulation environment provided by `emulate shell
-c' is identical to that provided by entry to a function
marked for sticky emulation as a consequence of being
defined in such an environment. Hence, for example, the
sticky emulation is inherited by subfunctions defined
within functions with sticky emulation.
2. No change of options takes place on entry to or exit from
functions that are not marked for sticky emulation, other
than those that would normally take place, even if those
functions are called within sticky emulation.
3. No special handling is provided for functions marked for
autoload nor for functions present in wordcode created by
the zcompile command.
4. The presence or absence of the -R switch to emulate
corresponds to different sticky emulation modes, so for
example `emulate sh -c', `emulate -R sh -c' and `emulate
csh -c' are treated as three distinct sticky emulations.
5. Difference in shell options supplied in addition to the
basic emulation also mean the sticky emulations are
different, so for example `emulate zsh -c' and `emulate zsh
-o cbases -c' are treated as distinct sticky emulations.
Mini Shell