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.
