⟦b03912c2f⟧

TextFile

@setfilename ../info/os-interface
@node Operating 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}, @pxref{Emacs Display},

@menu
* When Emacs Starts Up::        
* Getting out of Emacs::        
* Operating System Environment::        
* Terminal Input::      
* Terminal Output::     
* Flow Control::        
@end menu

@c !!! perhaps put `noninteractive' in new section, and discuss -batch too

@defvar noninteractive
@cindex batch mode
@cindex interactive sessions
   When Emacs is running in batch mode (without an interactive terminal),
then this variable is non-@code{nil}.
@end defvar

@node When Emacs Starts Up, Getting out of Emacs, Operating System Interface, Operating System Interface
@section When Emacs Starts Up

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

@enumerate

@item
Read command line switches.

@item 
Load @file{.emacs} unless @samp{-q} specified on command line.
@pindex .emacs

@item 
Load @file{default.el} unless @code{inhibit-default-init} is 
non-@code{nil}.
@pindex default.el

@item 
Load terminal specific file.

@item 
Run @code{term-setup-hook}.

@item 
Run @code{window-setup-hook}.

@item 
Display copyleft information, unless @code{inhibit-startup-message} is
non-@code{nil}.

@item 
Process remaining command line arguments.

@end enumerate

@menu
* Init File::	
* Terminal-specific Initialization::	
* Command Line Arguments::	
@end menu

@defopt inhibit-startup-message
  This global variable inhibits the initial startup messages (the non-warranty
etc.).  If it is non-@code{nil}, then the messages are not printed.  This
is for use in your personal init file, once you are familiar with the
contents of the startup message.
@end defopt

@node Init File, Terminal-specific Initialization, When Emacs Starts Up, When Emacs Starts Up
@subsection The Init File: .emacs

  When you start Emacs, it normally attempts to load the @file{.emacs}
file 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 tell Emacs whether to
load an init file.  (The @samp{-q} switch tells Emacs not to load your
init file; and the @samp{-u} switch tell Emacs to load a named user's
init file instead of yours.)  (@xref{Entering Emacs, , , emacs, The GNU
Emacs User Manual}).

  Emacs may also have a @dfn{default init file}, which is the library
named @file{default.el}.  (A Lisp library is a file containing Lisp
function definitions and other code.)  Emacs finds the @file{default.el}
file through the standard search path for libraries.  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.  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 you have a large amount 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 User Manual}, for
examples of how to make various commonly desired customizations in your
@file{.emacs} file.

@defopt inhibit-default-init
  This global 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 Initialization, Command Line Arguments, Init File, When Emacs Starts 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
find 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

@vindex term-file-prefix
  The library's name is constructed by concatenating the value of the
variable @code{term-file-prefix} and the terminal type.  

@cindex function keys
  The usual purpose of a terminal-specific library is to define the
escape sequences used by a terminal's function keys.

  Function keys are handled by a two-level process.  The first level is
dependent and 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.

  See the file @file{term/vt100.el} for an example of of a
terminal-specific library.

@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 for when you experimenting with
your own peculiar customizations; but a more elegant long-term mechanism
for handling your own customizations is to include a value for
@code{term-setup-hook} in your @file{.emacs}.

@vindex 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 set the value of the
@code{term-setup-hook} variable in your @file{.emacs} file to override
part of any of the terminal-specific libraries and to define
initializations for terminals that do not have a library.@refill

@defvar term-file-prefix
@vindex TERM
  If the @code{term-file-prefix} global variable is non-@code{nil},
Emacs loads your @file{.emacs} file and the default initialization file
and then evaluates the following expression:

@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 that of a function
that Emacs calls after loading your @file{.emacs} file, the default
initialization file (if any) and after loading terminal-specific lisp
code.  The value of @code{term-setup-hook} is called with no arguments.

  The expression in @file{startup.el} is 

@example
(and term-setup-hook (funcall term-setup-hook))
@end example
  
  To prevent the hook from being run twice, @code{term-setup-hook} is
set to @code{nil} after it is used.

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

@defvar window-setup-hook
  The value of the @code{window-setup-hook} variable is either
@code{nil} or that of a function that Emacs calls after loading your
@file{.emacs} file, the default initialization file (if any),  after
loading terminal-specific lisp code, and after calling @code{term-setup-hook}.
@code{window-setup-hook} is called with no arguments.
@end defvar

@node Command Line Arguments,  , Terminal-specific Initialization, When Emacs Starts 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 needed.  As a practical matter,
it is best to avoid them.  They exist to permit you to do several
sophisticated actions and for compatibility with other editors.

  (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.)

@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 warranty information, etc.
@end defun

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

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

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

@example
@minus{}@var{switch-string}
@end example

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

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

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

  In some cases, the command line switch is followed by an argument.  In
these cases, the command-line arguments are in the variable
@code{command-line-args}.

  The command line arguments are parsed by the @code{command-line-1}
function in the @file{startup.el} file.  Also, @pxref{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 of Emacs, Operating System Environment, When Emacs Starts Up, Operating System Interface
@section  Getting out of Emacs
@cindex quiting Emacs
@cindex exiting Emacs

  As a practical matter, in everyday use, you seldom quit Emacs---only
when you are about to log out.  The rest of the time, you will work in
Emacs or in a shell inside of Emacs.  If you do have to leave Emacs
temporarily, it is best to suspend Emacs rather than quit it.
(@xref{Suspending Emacs}.)

@menu
* Killing Emacs::	
* Suspending Emacs::	
@end menu

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

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

  All the information in the Emacs, aside from files that are 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 files that need saving or subprocesses that are
running.

@defun kill-emacs &optional no-query
  This function exits the Emacs job and kills it.  If @var{no-query} is
supplied and non-@code{nil}, then Emacs will exit directly.

  Normally, if there are modified files or if there are running
processes, Emacs will ask the user whether it should @emph{really} exit.

  If Emacs is running noninteractively and @var{no-query} is an integer,
then it returns @var{no-query} as the Unix program's exit code.

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

---------- Buffer: Minibuffer ----------
1 modified buffer exists, do you really want to exit? (yes or no) @b{yes}
Subprocesses are executing;  kill them and exit? (yes or no) @b{no}
---------- Buffer: Minibuffer ----------
@end example
@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 that Emacs calls whenever @code{kill-emacs} is
called.  The hook is called before anything else is done by
@code{kill-emacs}.
@end defvar

@node Suspending Emacs,  , Killing Emacs, Getting out of Emacs
@subsection Suspending Emacs
@cindex suspending Emacs

``Suspending Emacs'' means stopping Emacs temporarily and returning
control to its superior, which is usually the shell.  This allows you to
resume editing later in the same Emacs job, with the same files, the
same kill ring, the same undo history, and so on.  This is very convenient.
As a practical matter, you seldom need to suspend Emacs; you can do
almost all your work inside Emacs or inside a shell inside of Emacs.

@defun suspend-emacs string
@cindex suspend X Windows
  This function stops Emacs and returns to the superior process.  After
suspending Emacs, you may still resume Emacs.  (This is in contrast to
your situation after killing Emacs.)  This function does nothing if
Emacs is running under X windows.

  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 will be
called as a function of no arguments.  Emacs won't be suspended unless
this called function returns @code{nil}.

  After Emacs resumes, the symbol @code{suspend-resume-hook} will be
examined.  If it is bound and non-@code{nil}, then the value will be
called as a function of no arguments.  The next redisplay after
resumption will redraw the entire screen, unless @code{no-redraw-on
recenter} is set (@pxref{Screen Attributes}).

  @code{suspend-emacs} returns @code{nil}.

  In the example, note that @code{pwd} is not echoed by the shell
after Emacs is suspended.

@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? @b{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 is either @code{nil}, or
a function to be called (with no arguments)
before Emacs is suspended with
@code{suspend-emacs}.  Emacs won't be suspended unless the called
function returns @code{nil}.
@end defvar

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

@node Operating System Environment, Terminal Input, Getting out of Emacs, Operating 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 global 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.

@example
system-type
     @result{} berkeley-unix
@end example

@cindex Unix
@cindex VMS

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

@item hpux
Hewlet Packard release 5.0

@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 4.0, 4.2, 4.4

@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!
@end defvar

@defun getenv var
@cindex environment variables
  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{} "wheaties.ai.mit.edu"
@end example
@end defun

@defun current-time-string
   This function returns the current time, 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.

@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 intergers that are 100 times
the system load averages.  (The load averages indicate the number of
processes trying to run.)

@example
(load-average)
     @result{} (68 48 35)

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

@defvar default-directory
  The value of this buffer-local variable is the default directory
for the current buffer.  This is always a string ending with a slash
on Unix systems.

@example
default-directory
     @result{} "/user/lewis/manual/"
@end example
@end defvar

@defun setprv privilege-name &optional setp getprv
  This function sets or resets a VMS privilege.  The first arg is the
privilege name.  The second argument, @var{setp}, is @code{t} or
@code{nil}, indicating whether the privilege is to be set or reset.  Its
default is @code{nil}.  The funtion 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},
depending upon whether the privilege is already 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.  It is an error 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})}.
When called interactively, @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, Operating System Environment, Operating System Interface
@section Terminal Input

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

  Also, @pxref{Emacs Display}, for related functions.
@cindex terminal input

@defun recent-keys
  This function returns a string comprising the last 100 characters read
from 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

@end defun

@defvar last-input-char
  This global variable is set to the last terminal input character that was
typed (as part of a command or not).

  In the example below, a character is read (the character @kbd{1},
@sc{ASCII} @code{49}).  It becomes the value of @code{last-input-char}, while
@kbd{C-e} (from the @kbd{C-x C-e} command used to evaluate this expression)
remains the value of @code{last-command-char}.

@example
(progn (print (read-char))
       (print last-command-char)
       last-input-char)
     @print{} 49
     @print{} 5
     @result{} 49
@end example
@end defvar

@deffn Command open-dribble-file  filename
@cindex debug Emacs
  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.  (Inserted keyboard macros are not typed on the keyboard so they
are not copied.)  The function is normally called only interactively to
debug Emacs input.  It returns @code{nil}.  You close the dribble file
by calling this function with an argument of @code{nil}.

@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
  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.

  The normal setting is system dependent.  

  @xref{Flow Control}.
@end defun

@defvar meta-flag
  This global variable tells Emacs if it should treat the 0200 bit
in keyboard input as the @key{Meta} bit.
@end defvar

@defvar keyboard-translate-table
  This global variable defines the translate table for keyboard input.
This allows the user to redefine the keys on the keyboard without
changing any command bindings.

  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, @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-\} behaves exactly
like 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 ^S with ^\ and ^Q with ^^."
  (interactive)
  (let ((the-table (make-string 128 0)))
    (let ((i 0))
      (while (< i 128)
        (aset the-table i i)
        (setq i (1+ i))))

    ;; Swap ^S and ^\
    (aset the-table ?\034 ?\^s)
    (aset the-table ?\^s ?\034)
    ;; Swap ^Q and ^^
    (aset the-table ?\036 ?\^q)
    (aset the-table ?\^q ?\036)

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

@node Terminal Output, Flow Control, Terminal Input, Operating 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} variable tells you
what Emacs think is the output baud rate of the terminal.

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

@quotation
(@b{note:} In version 18, baud-rate is a function, but in version 19, it
is a variable.)
@end quotation

@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.  This can be a
problem with the network.
@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.

Typically, this function is used to define defining function keys on
terminals that have down-loadable function key definitions.

  The example below might define function key 4 to move forward four
characters (@kbd{C-u C-f}).

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

@deffn Command open-termscript filename
After this function is called, Emacs copies all terminal output characters
to @var{filename} as well to the terminal.  It returns @code{nil}.  This
function is normally only called interactively to debug Emacs output.

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

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

@node Flow Control,  , Terminal Output, Operating 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, please 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}.

@kindex C-s
@kindex 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, @samp{S} for search and @samp{Q} for
quote).  

  (There are other (albeit less common in practice) ways to do flow
control, not using @kbd{C-s} and @kbd{C-q}, that preserve transparency
of the character stream; these ways are not discussed here.)

  After Emacs's precedent was established, it was too hard to undo: Emacs'
use of @kbd{C-s} and @kbd{C-q} predates their use by terminals and
front-ends for flow control.  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 used for the host to turn the punch on and off!

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

  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:

@table @b
@item 1.
@cindex 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 will be
necessary to find other keys to bind to the commands
@code{isearch-forward} and @code{quoted-insert}.  The traditional nominees are
@kbd{C-^} and @kbd{C-\}.  There are two ways to get this effect:

@table @b
@item  1a.
  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.  Here's some code for this:

@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))))

  (aset keyboard-translate-table ?\^\\ ?\^s)
  (aset keyboard-translate-table ?\^^ ?\^q)
  ))
@end example

@item  1b.
  Simply rebind the keys @kbd{C-^} and @kbd{C-\} to
@code{isearch-forward} and @code{quoted-insert}.  To get continued
searches inside isearch it is also necessary to set
@code{search-repeat-char} to @kbd{C-^}, as well.
@end table

@item 2.
  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 @b{1a} and
@b{1b} above.

Here is a suitable null command:

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

@item 3.
  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 @b{2}
above, 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 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 the terminal is not directly wired to the host.
@end table
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦b03912c2f⟧ TextFile

Derivation

TextFile
