@c -*-texinfo-*-
@setfilename ../info/os
@node System Interface, Emacs Display, Processes, Top
@chapter Operating System Interface

  This chapter is about starting and getting out of Emacs, access to
values in the operating system environment, and terminal input, output
and flow control.

  @xref{Building Emacs}, for related information.  See also @ref{Emacs
Display}, for additional operating system status information which pertain
to the terminal and the screen.

@menu
* Starting Up::         Customizing Emacs start-up processing.
* Getting Out::         How exiting works (permanent or temporary).
* System Environment::  Distinguish the name and kind of system.
* Terminal Input::      Recording terminal input for debugging.
* Terminal Output::     Recording terminal output for debugging.
* Flow Control::        How to turn output flow control on or off.
* Batch Mode::          Running Emacs without terminal interaction.
@end menu

@node Starting Up, Getting Out, System Interface, System Interface
@section Starting Up Emacs

  This section describes what Emacs does when it is started, and how you
can customize these actions.

@menu
* Start-up Summary::        Sequence of actions Emacs performs at start-up.
* Init File::               Details on reading the init file (@file{.emacs}).
* Terminal-Specific::       How the terminal-specific Lisp file is read.
* Command Line Arguments::  How command line arguments are processed,
                              and how you can customize them.
@end menu

@node Start-up Summary, Init File, Starting Up,  Starting Up
@subsection Summary: Sequence of Actions at Start Up
@cindex initialization
@cindex start up of Emacs
@cindex @file{startup.el}

   The order of operations performed (in @file{startup.el}) by Emacs when
it is started up is as follows:

@enumerate
@item 
It loads @file{.emacs} unless @samp{-q} was specified on command line.
(This is not done in @samp{-batch} mode.)  @file{.emacs} is found in the
user's home directory; the @samp{-u} option can specify the user name
whose home directory should be used.

@item 
It loads @file{default.el} unless @code{inhibit-default-init} is
non-@code{nil}.  (This is not done in @samp{-batch} mode or if @samp{-q}
was specified on command line.)
@cindex @file{default.el}

@item 
It loads the terminal-specific Lisp file, if any, except when in batch
mode.

@item 
It runs @code{term-setup-hook}.

@item 
It runs @code{window-setup-hook}.

@item 
It displays copyleft and nonwarranty, plus basic use information, unless
the value of @code{inhibit-startup-message} is non-@code{nil}.

This display is also inhibited in batch mode, and if the current buffer
is not @samp{*scratch*}.

@item 
It processes any remaining command line arguments.
@end enumerate

@defopt inhibit-startup-message
  This variable inhibits the initial startup messages (the nonwarranty,
etc.).  If it is non-@code{nil}, then the messages are not printed.

  This variable exists so you can set it in your personal init file,
once you are familiar with the contents of the startup message.  Do not
set this variable in the init file of a new user, or in a way that
affects more than one user, because that would prevent new users from
receiving the information they are supposed to see.
@end defopt

@node Init File, Terminal-Specific, Start-Up Summary, Starting Up
@subsection The Init File: @file{.emacs}
@cindex init file
@cindex @file{.emacs}

  When you start Emacs, it normally attempts to load the file
@file{.emacs} from your home directory.  This file, if it exists, must
contain Lisp code.  It is called your @dfn{init file}.  The command line
switches @samp{-q} and @samp{-u} can be used to control the use of the
init file; @samp{-q} says not to load an init file, and @samp{-u} says
to load a specified user's init file instead of yours.  @xref{Entering
Emacs, , , emacs, The GNU Emacs Manual}.

@cindex default init file
  Emacs may also have a @dfn{default init file}, which is the library
named @file{default.el}.  Emacs finds the @file{default.el} file through
the standard search path for libraries (@pxref{How Programs Do
Loading}).  The Emacs distribution does not have any such file; you may
create one at your site for local customizations.  If the default init
file exists, it is loaded whenever you start Emacs, except in batch mode
or if @samp{-q} is specified.  But your own personal init file, if any,
is loaded first; if it sets @code{inhibit-default-init} to a
non-@code{nil} value, then Emacs will not load the @file{default.el}
file.

  If there is a great deal of code in your @file{.emacs} file, you
should move it into another file named @file{@var{something}.el},
byte-compile it (@pxref{Byte Compilation}), and make your @file{.emacs}
file load the other file using @code{load} (@pxref{Loading}).

  @xref{Init File Examples, , , emacs, The GNU Emacs Manual}, for
examples of how to make various commonly desired customizations in your
@file{.emacs} file.

@defopt inhibit-default-init
  This variable prevents Emacs from loading the default initialization
library file for your session of Emacs.  If its value is non-@code{nil},
then the default library is not loaded.  The default value is
@code{nil}.
@end defopt

@node Terminal-Specific, Command Line Arguments, Init File, Starting Up
@subsection Terminal-Specific Initialization
@cindex terminal-specific initialization

  Each terminal type can have its own Lisp library that Emacs will load
when run on that type of terminal.  For a terminal type named
@var{termtype}, the library is called @file{term/@var{termtype}}.  Emacs
finds the file by searching the @code{load-path} directories as it does
for other files, and trying the @samp{.elc} and @samp{.el} suffixes.
Normally, terminal-specific Lisp library is located in
@file{emacs/lisp/term}, a subdirectory of the @file{emacs/lisp}
directory in which most Emacs Lisp libraries are kept.@refill

  The library's name is constructed by concatenating the value of the
variable @code{term-file-prefix} and the terminal type.  Normally,
@code{term-file-prefix} has the value @code{"term/"}; changing this
is not recommended.

@cindex function keys
  The usual purpose of a terminal-specific library is to define the
escape sequences used by a terminal's function keys.  See the file
@file{term/vt100.el} for an example of a terminal-specific library.

  Function keys are handled by a two-level procedure.  The first level
is dependent on the specific type of terminal and maps Emacs's input
sequences to the function keys that they represent.  The second level is
independent of terminal type and is customized by users; function keys
are mapped into meanings at this level.  The terminal-specific library
handles the first level of the process and the library @file{keypad.el}
handles the second level of mapping.

@cindex termcap
  When the name of the terminal type contains a hyphen, only the part of
the name before the first hyphen is significant in choosing the library
name.  Thus, terminal types @samp{aaa-48} and @samp{aaa-30-rv} both use
the @file{term/aaa} library.  If necessary, the library can evaluate
@code{(getenv "TERM")} to find the full name of the terminal
type.@refill

  Your @file{.emacs} file can prevent the loading of the
terminal-specific library by setting @code{term-file-prefix} to
@code{nil}.  This feature is very useful when experimenting with your
own peculiar customizations.

  You can also arrange to override some of the actions of the
terminal-specific library by setting the variable
@code{term-setup-hook}.  If it is not @code{nil}, Emacs calls the value
of the variable @code{term-setup-hook} as a function of no arguments at
the end of Emacs initialization, after Emacs has already loaded both
your @file{.emacs} file and any terminal-specific libraries.  You can
use this variable to define initializations for terminals that do not
have their own libraries.@refill

@defvar term-file-prefix
@cindex @code{TERM} environment variable
  If the @code{term-file-prefix} variable is non-@code{nil}, Emacs loads
a terminal-specific initialization file as follows:

@example
(load (concat term-file-prefix (getenv "TERM")))
@end example

@noindent
You may set the @code{term-file-prefix} variable to @code{nil} in your
@file{.emacs} file if you do not wish to load the
terminal-initialization file.  To do this, put the following in
your @file{.emacs} file: @code{(setq term-file-prefix nil)}.
@end defvar

@defvar term-setup-hook 
  The value of this variable is either @code{nil} or a function to be
called by Emacs after loading your @file{.emacs} file, the default
initialization file (if any) and after loading terminal-specific Lisp
code.  The function is called with no arguments.

  You can use @code{term-setup-hook} to override the definitions made by
a terminal-specific file.
@end defvar

  See also @code{window-setup-hook} in @ref{Window Systems}.

@node Command Line Arguments,, Terminal-Specific, Starting Up
@subsection Command Line Arguments
@cindex command line arguments

  You can use command line arguments to request various actions when you
start Emacs.  Since you do not need to start Emacs more than once per
day, and will often leave your Emacs session running longer than that,
command line arguments are hardly ever used.  As a practical matter, it
is best to avoid making the habit of using them, since this habit would
encourage you to kill and restart Emacs unnecessarily often.  These
options exist for two reasons: to be compatible with other editors (for
invocation by other programs) and to enable shell scripts to run
specific Lisp programs.

@ignore
  (Note that some other editors require you to start afresh each time
you want to edit a file.  With this kind of editor, you will probably
specify the file as a command line argument.  The recommended way to
use GNU Emacs is to start it only once, just after you log in, and do
all your editing in the same Emacs process.  Each time you want to edit
a different file, you visit it with the existing Emacs, which eventually
comes to have many files in it ready for editing.  Usually you do not
kill the Emacs until you are about to log out.)
@end ignore

@defun command-line
  This function parses the command line which Emacs was called with,
processes it, loads the user's @file{.emacs} file and displays the
initial nonwarranty information, etc.
@end defun

@defvar command-line-processed
  The value of this variable is @code{t} once the command line has been
processed.

If you redump Emacs by calling @code{dump-emacs}, you must set this variable
to @code{nil} first in order to cause the new dumped Emacs to process
its new command line arguments.
@end defvar

@defvar command-switch-alist
@cindex switches on command line
@cindex options on command line
@cindex command line options
The value of this variable is an alist of user-defined command-line
options and associated handler functions.  This variable exists so you
can add elements to it.

A @dfn{command line option} is an argument on the command line of the
form:

@example
-@var{option}
@end example

The elements of the @code{command-switch-alist} look like this: 

@example
(@var{option} . @var{handler-function})
@end example

For each element, the @var{handler-function} receives the switch name as
its sole argument.

In some cases, the option is followed in the command line by an
argument.  In these cases, the @var{handler-function} can find all the
remaining command-line arguments in the variable
@code{command-line-args-left}.  (The entire list of command-line
arguments is in @code{command-line-args}.)

The command line arguments are parsed by the @code{command-line-1}
function in the @file{startup.el} file.  See also @ref{Command
Switches, , Command Line Switches and Arguments, emacs, The GNU Emacs
Manual}.
@end defvar

@defvar command-line-args
The value of this variable is the arguments passed by the shell to Emacs, as
a list of strings.
@end defvar

@node Getting Out, System Environment, Starting Up, System Interface
@section Getting out of Emacs
@cindex exiting Emacs

  There are two ways to get out of Emacs: you can kill the Emacs job,
which exits permanently, or you can suspend it, which permits you to
reenter the Emacs process later.  As a practical matter, you seldom kill
Emacs---only when you are about to log out.  Suspending is much more
common.

@menu
* Killing Emacs::        Exiting Emacs irreversibly.
* Suspending Emacs::     Exiting Emacs reversibly.
@end menu

@node Killing Emacs, Suspending Emacs, Getting Out, Getting Out
@comment  node-name,  next,  previous,  up
@subsection Killing Emacs
@cindex killing Emacs

  Killing Emacs means ending the execution of the Emacs process.
It will return to its superior process.

  All the information in the Emacs process, aside from files that have
been saved, is lost when the Emacs is killed.  Because killing Emacs
inadvertently can lose a lot of work, Emacs will query for confirmation
before actually terminating if you have buffers that need saving or
subprocesses that are running.

@defun kill-emacs &optional no-query
  This function exits the Emacs process and kills it.

  Normally, if there are modified files or if there are running
processes, @code{kill-emacs} asks the user for confirmation before
exiting.  However, if @var{no-query} is supplied and non-@code{nil},
then Emacs exits without confirmation.

  If @var{no-query} is an integer, then it is used as the exit status of
the Emacs process.  (This is useful primarily in batch operation; see
@ref{Batch Mode}.)

  If @var{no-query} is a string, its contents are stuffed into the
terminal input buffer so that the shell (or whatever program next reads
input) can read them.
@end defun

@defvar kill-emacs-hook
  The value of the @code{kill-emacs-hook} variable is either @code{nil}
or is that of a function to be called by @code{kill-emacs}.  The hook is
called before anything else is done by @code{kill-emacs}.
@end defvar

@node Suspending Emacs,  , Killing Emacs, Getting Out
@subsection Suspending Emacs
@cindex suspending Emacs

  @dfn{Suspending Emacs} means stopping Emacs temporarily and returning
control to its superior process, which is usually the shell.  This
allows you to resume editing later in the same Emacs process, with the
same buffers, the same kill ring, the same undo history, and so on.  To
resume Emacs, use the appropriate command in the parent shell---most
likely @code{fg}.

  Some operating systems do not support suspension of jobs; on these
systems, ``suspension'' actually creates a new shell temporarily as a
subprocess of Emacs.  Then you would exit the shell to return to Emacs.

  Suspension is not useful with window systems such as X Windows,
because the Emacs job may not have a parent that can resume it again,
and in any case you can give input to some other job such as a shell
merely by moving to a different window.  Therefore, suspending is not
allowed under X Windows.

@defun suspend-emacs string
  This function stops Emacs and returns to the superior process.  It
returns @code{nil}.

  If @var{string} is non-@code{nil}, its characters are sent to be read as
terminal input by Emacs's superior shell.  The characters in @var{string}
will not be echoed by the superior shell; just the results will appear.

  Before suspending, Emacs examines the symbol @code{suspend-hook}.  If
it is bound, and its value is non-@code{nil}, then the value is called
as a function of no arguments.  If the function returns non-@code{nil},
then @code{suspend-emacs} returns immediately and suspension does not
occur.

  After Emacs resumes, the symbol @code{suspend-resume-hook} is
examined.  If it is bound and non-@code{nil}, then the value is called
as a function of no arguments.

  The next redisplay after resumption will redraw the entire screen,
unless @code{no-redraw-on-reenter} is set (@pxref{Screen Attributes}).

  In the following example, note that @samp{pwd} is not echoed after
Emacs is suspended.  But it is read and executed by the shell.

@example
(suspend-emacs)
     @result{} nil

(setq suspend-hook
    (function (lambda ()
              (not (y-or-n-p "Really suspend? ")))))
     @result{} (lambda nil (not (y-or-n-p "Really suspend? ")))
(setq suspend-resume-hook
    (function (lambda () (message "Resumed!"))))
     @result{} (lambda nil (message "Resumed!"))
(suspend-emacs "pwd")
     @result{} nil
---------- Buffer: Minibuffer ----------
Really suspend? @kbd{y}

---------- Parent Shell ----------
lewis@@slug[23] % /user/lewis/manual
lewis@@slug[24] % fg

---------- Echo Area ----------
Resumed!
@end example
@end defun

@defvar suspend-hook
  The value of the @code{suspend-hook} variable, if not @code{nil}, is
called as a function with no arguments by @code{suspend-emacs} before
Emacs is actually suspended.  If the function returns non-@code{nil},
then suspension does not take place.
@end defvar

@defvar suspend-resume-hook
  The value of the @code{suspend-resume-hook} variable, if not
@code{nil}, is called as a function with no arguments after resumption
of an Emacs session that was suspended with @code{suspend-emacs}.
@end defvar

@node System Environment, Terminal Input, Getting Out, System Interface
@section Operating System Environment
@cindex operating system environment

  Emacs provides access to variables in the operating system environment
through various functions.  These variables include the name of the
system, the user's @sc{uid}, and so on.

@defvar system-type
  The value of this variable is a symbol indicating the type of
operating system Emacs is operating on.  Here is a table of the symbols
for the operating systems that Emacs can run on up to version 18.51.

@table @code
@item berkeley-unix
Berkeley BSD 4.1, 4.2, or 4.3.

@item hpux
Hewlett-Packard operating system, version 5, 6, or 7.

@item silicon-graphics-unix
Silicon Graphics Iris 3.5 or 3.6.

@item rtu
RTU 3.0, UCB universe.

@item unisoft-unix
UniSoft's UniPlus 5.0 or 5.2.

@item usg-unix-v
AT&T's System V.0, System V Release 2.0, 2.2, or 3.

@item vax-vms
VMS VMS version 4 or 5.

@item xenix
SCO Xenix 386 Release 2.2.
@end table

We do not wish to add new symbols to make finer distinctions unless it
is absolutely necessary!  In fact, it would be nice to eliminate a
couple of possibilities in the future.
@end defvar

@defun getenv var
@cindex environment variable access
  This function returns the value of the environment variable @var{var},
as a string. 

@example
(getenv "USER")
     @result{} "lewis"

lewis@@slug[10] % printenv
PATH=.:/user/lewis/bin:/usr/bin:/usr/local/bin
USER=lewis
TERM=ibmapa16
SHELL=/bin/csh
HOME=/user/lewis
@end example
@end defun

@defun user-login-name
  This function returns the name under which the user is logged in.
This is based on the effective @sc{uid}, not the real @sc{uid}.

@example
(user-login-name)
     @result{} "lewis"
@end example
@end defun

@defun user-real-login-name
  This function returns the name under which the user logged in.
This is based on the real @sc{uid}, not the effective @sc{uid}.  This
differs from @code{user-login-name} only when running with the setuid
bit. 
@end defun

@defun user-full-name
This function returns the full name of the user.

@example
(user-full-name)
     @result{} "Bil Lewis"
@end example
@end defun

@defun user-real-uid
  This function returns the real @sc{uid} of the user.

@example
(user-real-uid)
     @result{} 19
@end example
@end defun

@defun user-uid
   This function returns the effective @sc{uid} of the user.  
@end defun

@defun system-name
   This function returns the name of the machine you are running on.
@example
(system-name)
     @result{} "prep.ai.mit.edu"
@end example
@end defun

@defun current-time-string
   This function returns the current time and date as a humanly-readable
string.  The format of the string is unvarying; the number of characters
used for each part is always the same, so you can reliably use
@code{substring} to extract pieces of it.  However, it would be wise to
count the characters from the beginning of the string rather than from
the end, as additional information describing the time zone may be added
in version 19.

@example
(current-time-string)
     @result{} "Wed Oct 14 22:21:05 1987"
@end example
@end defun

@defun load-average
   This function returns the current 1 minute, 5 minute and 15 minute
load averages in a list.  The values are integers that are 100 times
the system load averages.  (The load averages indicate the number of
processes trying to run.)

@example
(load-average)
     @result{} (169 48 36)

lewis@@rocky[5] % uptime
 11:55am  up 1 day, 19:37,  3 users,  load average: 1.69, 0.48, 0.36
@end example
@end defun

@defun setprv privilege-name &optional setp getprv
  This function sets or resets a VMS privilege.  (It does not exist on
Unix.)  The first arg is the privilege name, as a string.  The second
argument, @var{setp}, is @code{t} or @code{nil}, indicating whether the
privilege is to be turned on or off.  Its default is @code{nil}.  The
function returns @code{t} if success, @code{nil} if not.

  If the third argument, @var{getprv}, is non-@code{nil}, @code{setprv}
does not change the privilege, but returns @code{t} or @code{nil}
indicating whether the privilege is currently enabled.
@end defun

@c !!! `cd' should be described in the user manual.  It is ignored here.
@ignore
@deffn Command cd directory
  This function makes @var{directory} the current buffer's default
directory.  An error is signaled if @var{directory} is not an existing
directory which is accessible by the user.

This function is intended for interactive use only.  Lisp programs
should instead use @code{(setq default-directory @var{directory})}.
In an interactive call, @var{directory} is prompted for in the
minibuffer.  

@example
(cd "/user/lewis/emacs")
     @result{} "Directory /user/lewis/emacs/"
default-directory
     @result{} "/user/lewis/emacs/"
@end example
@end deffn
@end ignore

@node Terminal Input, Terminal Output, System Environment, System Interface
@section Terminal Input

  The terminal input functions and variables keep track of or manipulate
terminal input.

  See @ref{Emacs Display}, for related functions.
@cindex terminal input

@defun recent-keys
  This function returns a string comprising the last 100 characters read
from the terminal.  These are the last 100 characters read by Emacs, no
exceptions.

@example
(recent-keys)
@result{} "erminal.  These are the last 100 characters read by Emacs, no
exceptions.

@@example
(recent-keys)^U^X^E"
@end example

@noindent
Here the string @samp{@@example} is a Texinfo command that was inserted
in the source file for the manual, and @samp{^U^X^E} are the characters
that were typed to evaluate the expression @code{(recent-keys)}.
@end defun

@deffn Command open-dribble-file  filename
@cindex dribble file
  This function opens a @dfn{dribble file} named @var{filename}.  When a
dribble file is open, Emacs copies all keyboard input characters to that
file.  (The contents of keyboard macros are not typed on the keyboard so
they are not copied to the dribble file.)

  You close the dribble file by calling this function with an argument
of @code{""}.  The function always returns @code{nil}.

  This function is normally used to record the input necessary to
trigger an Emacs bug, for the sake of a bug report.

@example
(open-dribble-file "$j/dribble")
     @result{} nil
@end example
@end deffn

  See also the @code{open-termscript} function (@pxref{Terminal Output}).

@defun set-input-mode interrupt flow quit-char
  This function sets the mode for reading keyboard input.  If
@var{interrupt} is non-null, then Emacs uses input interrupts.  If it is
@code{nil}, then it uses @sc{cbreak} mode.

  If @var{flow} is non-@code{nil}, then Emacs uses @sc{xon/xoff} (@kbd{C-q},
@kbd{C-s}) flow control for output to terminal.  This has no effect except
in @sc{cbreak} mode.  @xref{Flow Control}.

  The normal setting is system dependent.  Some systems always use
@sc{cbreak} mode regardless of what is specified.

  If @var{quit-char} is non-@code{nil}, it specifies the character to
use for quitting.  Normally this is 7, the code for @kbd{C-g}.
@xref{Quitting}.
@end defun

@defvar meta-flag
  This variable tells Emacs whether to treat the 0200 bit in keyboard
input as the @key{Meta} bit.  @code{nil} means no, and anything else
means yes.  In version 19, @code{meta-flag} will be a function instead
of a variable.
@end defvar

@defvar keyboard-translate-table
  This variable defines the translate table for keyboard input.  This
allows the user to redefine the keys on the keyboard without changing
any command bindings.  Its value must be a string or @code{nil}.

  If @code{keyboard-translate-table} is a string, then each character read
from the keyboard is looked up in this string and the character in the
string is used instead.  If the string is of length @var{n}, character codes
@var{n} and up are untranslated.

  In the example below, @code{keyboard-translate-table} is set to a
string of 128 characters.  Then the characters @kbd{C-s} and @kbd{C-\}
are swapped and the characters @kbd{C-q} and @kbd{C-^} are swapped.
After executing this function, typing @kbd{C-\} has all the usual
effects of typing @kbd{C-s}, and vice versa.  (@xref{Flow Control} for
more information on this subject.)

@cindex flow control example
@example
(defun evade-flow-control ()
  "Replace C-s with C-\ and C-q with C-^."
  (interactive)
  (let ((the-table (make-string 128 0)))
    (let ((i 0))
      (while (< i 128)
        (aset the-table i i)
        (setq i (1+ i))))

    ;; @r{Swap @kbd{C-s} and @kbd{C-\}.}
    (aset the-table ?\034 ?\^s)
    (aset the-table ?\^s ?\034)
    ;; @r{Swap @kbd{C-q} and @kbd{C-^}.}
    (aset the-table ?\036 ?\^q)
    (aset the-table ?\^q ?\036)

    (setq keyboard-translate-table the-table)))
@end example

Note that this translation is the first thing that happens after a
character is read from the terminal.  As a result, record-keeping
features such as @code{recent-keys} and @code{open-dribble-file} record
the translated characters.
@end defvar

@node Terminal Output, Flow Control, Terminal Input, System Interface
@section Terminal Output
@cindex terminal output

  The terminal output functions send or keep track of output sent from
the computer to the terminal.  The @code{baud-rate} function tells you
what Emacs thinks is the output baud rate of the terminal.

@defun baud-rate
  This function returns the output baud rate of the terminal.

@example
(baud-rate)
     @result{} 9600
@end example

  If you are running across a network, and different parts of the
network work at different baud rates, the value returned by Emacs may be
different from the value used by your local terminal.  Some network
protocols communicate the local terminal speed to the remote machine, so
that Emacs and other programs can get the proper value, but others do
not.  If the machine where Emacs is running has the wrong speed setting,
you can specify the right speed using the @code{stty} program.  However,
you will have to start Emacs afresh to make this take effect.

@strong{Note:} In version 19, @code{baud-rate} is a variable so that you
can change it conveniently within Emacs.
@end defun

@defun send-string-to-terminal string
  This function sends @var{string} to the terminal without alteration.
Control characters in @var{string} will have terminal-dependent effects.

  One use of this function is to define function keys on terminals that
have downloadable function key definitions.  For example, this is how on
certain terminals to define function key 4 to move forward four
characters (by transmitting the characters @kbd{C-u C-f} to the
computer):

@example
(send-string-to-terminal "\eF4\^U\^F")
     @result{} nil
@end example
@end defun

@deffn Command open-termscript filename
@cindex termscript file
  This function is used to open a @dfn{termscript file} that will record
all the characters sent by Emacs to the terminal.  It returns
@code{nil}.  Termscript files are useful for investigating problems
where Emacs garbles the screen, problems which are due to incorrect
termcap entries or to undesirable settings of terminal options more
often than actual Emacs bugs.  Once you are certain which characters
were actually output, you can determine reliably whether they correspond
to the termcap specifications in use.

  See also @code{open-dribble-file} in @ref{Terminal Input}.

@example
(open-termscript "../junk/termscript")
     @result{} nil
@end example
@end deffn

@node Flow Control, Batch Mode, Terminal Output, System Interface
@section Flow Control
@cindex flow control characters

  This section attempts to answer the question ``Why does Emacs choose
to use flow-control characters in its command character set?''  For a
second view on this issue, read the comments on flow control in
the @file{emacs/INSTALL} file from the distribution; for help with
termcaps and DEC terminal concentrators, see @file{emacs/etc/TERMS}.

@cindex @kbd{C-s}
@cindex @kbd{C-q}
  At one time, most terminals did not need flow control.  This meant
that the choice of @kbd{C-s} and @kbd{C-q} as command characters was
reasonable.  Emacs, for economy of keystrokes and portability, chose to
use the control characters in the @sc{ASCII} character set, and tried to
make the assignments mnemonic (thus, @kbd{C-s} for search and @kbd{C-q}
for quote).

  Later, some terminals were introduced which used these characters for
flow control.  They were not very good terminals, so Emacs maintainers
did not pay attention.  In later years, the practice became widespread
among terminals, but by this time it was usually an option.  And the
majority of users, who can turn flow control off, were unwilling to
switch to less mnemonic key bindings for the sake of flow control.

  So which usage is ``right'', Emacs's or that of some terminal and
concentrator manufacturers?  This is a rhetorical (or religious)
question; it has no simple answer.

  One reason why we are reluctant to cater to the problems caused by
@kbd{C-s} and @kbd{C-q} is that they are gratuitous.  There are other
techniques (albeit less common in practice) for flow control that
preserve transparency of the character stream.  Note also that their use
for flow control is not an official standard.  Interestingly, on the
model 33 teletype with a paper tape punch (which is very old), @kbd{C-s}
and @kbd{C-q} were sent by the computer to turn the punch on and off!

  GNU Emacs (version 18.48 and later) provides several options for
coping with terminals or front-ends that insist on using flow control
characters.  Listed in estimated order of preference, these options are
as follows:

@enumerate
@item
@cindex @sc{cbreak}
Have Emacs run in @sc{cbreak} mode with the kernel handling flow
control.  Issue @code{(set-input-mode nil t)} from @file{.emacs}.  After
doing this, it is necessary to find other keys to bind to the commands
@code{isearch-forward} and @code{quoted-insert}.  The usual nominees are
@kbd{C-^} and @kbd{C-\}.  There are two ways to get this effect:

@enumerate
@item
Use the @code{keyboard-translate-table} to cause @kbd{C-^} and
@kbd{C-\} to be received by Emacs as though @kbd{C-s} and @kbd{C-q} were
typed.  Emacs (except at its very lowest level) never knows that the
characters typed were anything but @kbd{C-s} and @kbd{C-q}, so the use
of these keys inside @code{isearch-forward} still works---typing
@kbd{C-^} while incremental searching will move the cursor to the next
match, etc.  For example:

@example
(setq keyboard-translate-table (make-string 128 0))
(let ((i 0))
  (while (< i 128)
    (aset keyboard-translate-table i i)
    (setq i (1+ i))))

  ;; @r{Swap @kbd{C-s} and @kbd{C-\}.}
  (aset the-table ?\034 ?\^s)
  (aset the-table ?\^s ?\034)
  ;; @r{Swap @kbd{C-q} and @kbd{C-^}.}
  (aset the-table ?\036 ?\^q)
  (aset the-table ?\^q ?\036)))
@end example

@item
Simply rebind the keys @kbd{C-^} and @kbd{C-\} to @code{isearch-forward}
and @code{quoted-insert}.  To use the new keys to repeat searches, it is
necessary to set @code{search-repeat-char} to @kbd{C-^} as well.
@end enumerate

@item
Don't use @sc{cbreak} mode, but cause @kbd{C-s} and @kbd{C-q} to be
bound to a null command.  The problem with this solution is that the
flow control characters were probably sent because whatever sent them is
falling behind on the characters being sent to it.  The characters that
find their way to the terminal screen will not in general be those that
are intended.  Also, it will be be necessary to find other keys to bind
to @code{isearch-forward} and @code{quoted-insert}; see the previous
alternative.

Here is a suitable null command:

@example
(defun noop ()
  "Do nothing; return nil."
  (interactive))
@end example

@item
Don't use @sc{cbreak} mode, and unset the @kbd{C-s} and @kbd{C-q} keys
with the @code{global-unset-key} function.  This is similar to the
previous alternative, except that the flow control characters will
probably cause beeps or visible bells.

Note that if the terminal is the source of the flow control characters
and kernel flow control handling is enabled, you probably will not have
to send padding characters as specified in a termcap or terminfo entry.
In this case, it may be possible to customize a termcap entry to provide
better Emacs performance on the assumption that flow control is in use.
This effect can also be simulated by announcing (with @code{stty} or its
equivalent) that the terminal is running at a very slow speed, provided
you are communicating across a network so that @code{stty} does not
actually try to change the line speed.
@end enumerate

@node Batch Mode,, Flow Control, System Interface
@section Batch Mode
@cindex batch mode
@cindex noninteractive use

  The command line option @samp{-batch} causes Emacs to run
noninteractively.  In this mode, Emacs does not read commands from the
terminal, it does not alter the terminal modes, and it does not expect
to be outputting to an erasable screen.  The idea is that you will
specify Lisp programs to run; when they are finished, Emacs should exit.
The way to specify the programs to run is with @samp{-l @var{file}},
which causes the library named @var{file} to be loaded, and @samp{-f
@var{function}}, which causes @var{function} to be called with no
arguments.

  Any Lisp program output that would normally go to the echo area,
either using @code{message} or using @code{prin1}, etc., with @code{t}
as the stream, will actually go to Emacs's standard output descriptor
when in batch mode.  Thus, Emacs behaves much like a noninteractive
application program.  (The echo area output that Emacs itself normally
generates, such as command echoing, is suppressed entirely.)

@defvar noninteractive
This variable is non-@code{nil} when Emacs is running in batch mode.
@end defvar
