This is ../info/emacs, produced by makeinfo version 4.0 from emacs.texi.

   This is the thirteenth edition of the `GNU Emacs Manual', updated
for Emacs version 20.7.

INFO-DIR-SECTION Editors
START-INFO-DIR-ENTRY
* Emacs: (emacs).	The extensible self-documenting text editor.
END-INFO-DIR-ENTRY

   Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA  02111-1307 USA

   Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998,
1999    Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under the
terms of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the Free Software Foundation instead of in the
original English.


File: emacs,  Node: Borders X,  Next: Title X,  Prev: Window Size X,  Up: Command Arguments

Internal and External Borders
=============================

   An Emacs frame has an internal border and an external border.  The
internal border is an extra strip of the background color around all
four edges of the frame.  Emacs itself adds the internal border.  The
external border is added by the window manager outside the internal
border; it may contain various boxes you can click on to move or iconify
the window.

`-ib WIDTH'
`--internal-border=WIDTH'
     Specify WIDTH as the width of the internal border.

`-bw WIDTH'
`--border-width=WIDTH'
     Specify WIDTH as the width of the main border.

   When you specify the size of the frame, that does not count the
borders.  The frame's position is measured from the outside edge of the
external border.

   Use the `-ib N' option to specify an internal border N pixels wide.
The default is 1.  Use `-bw N' to specify the width of the external
border (though the window manager may not pay attention to what you
specify).  The default width of the external border is 2.


File: emacs,  Node: Title X,  Next: Icons X,  Prev: Borders X,  Up: Command Arguments

Frame Titles
============

   An Emacs frame may or may not have a specified title.  The frame
title, if specified, appears in window decorations and icons as the name
of the frame.  If an Emacs frame has no specified title, the default
title is the name of the executable program (if there is only one frame)
or the selected window's buffer name (if there is more than one frame).

   You can specify a title for the initial Emacs frame with a command
line option:

`-title TITLE'
`--title=TITLE'
`-T TITLE'
     Specify TITLE as the title for the initial Emacs frame.

   The `--name' option (*note Resources X::) also specifies the title
for the initial Emacs frame.


File: emacs,  Node: Icons X,  Next: Resources X,  Prev: Title X,  Up: Command Arguments

Icons
=====

   Most window managers allow the user to "iconify" a frame, removing
it from sight, and leaving a small, distinctive "icon" window in its
place.  Clicking on the icon window makes the frame itself appear again.
If you have many clients running at once, you can avoid cluttering up
the screen by iconifying most of the clients.

`-i'
`--icon-type'
     Use a picture of a gnu as the Emacs icon.

`-iconic'
`--iconic'
     Start Emacs in iconified state.

   The `-i' or `--icon-type' option tells Emacs to use an icon window
containing a picture of the GNU gnu.  If omitted, Emacs lets the window
manager choose what sort of icon to use--usually just a small rectangle
containing the frame's title.

   The `-iconic' option tells Emacs to begin running as an icon, rather
than opening a frame right away.  In this situation, the icon window
provides only indication that Emacs has started; the usual text frame
doesn't appear until you deiconify it.


File: emacs,  Node: Resources X,  Next: Lucid Resources,  Prev: Icons X,  Up: Command Arguments

X Resources
===========

   Programs running under the X Window System organize their user
options under a hierarchy of classes and resources.  You can specify
default values for these options in your X resources file, usually named
`~/.Xdefaults'.

   Each line in the file specifies a value for one option or for a
collection of related options, for one program or for several programs
(optionally even for all programs).

   Programs define named resources with particular meanings.  They also
define how to group resources into named classes.  For instance, in
Emacs, the `internalBorder' resource controls the width of the internal
border, and the `borderWidth' resource controls the width of the
external border.  Both of these resources are part of the `BorderWidth'
class.  Case distinctions are significant in these names.

   In `~/.Xdefaults', you can specify a value for a single resource on
one line, like this:

     emacs.borderWidth: 2

Or you can use a class name to specify the same value for all resources
in that class.  Here's an example:

     emacs.BorderWidth: 2

   If you specify a value for a class, it becomes the default for all
resources in that class.  You can specify values for individual
resources as well; these override the class value, for those particular
resources.  Thus, this example specifies 2 as the default width for all
borders, but overrides this value with 4 for the external border:

     emacs.Borderwidth: 2
     emacs.borderwidth: 4

   The order in which the lines appear in the file does not matter.
Also, command-line options always override the X resources file.

   The string `emacs' in the examples above is also a resource name.
It actually represents the name of the executable file that you invoke
to run Emacs.  If Emacs is installed under a different name, it looks
for resources under that name instead of `emacs'.

`-name NAME'
`--name=NAME'
     Use NAME as the resource name (and the title) for the initial
     Emacs frame.  This option does not affect subsequent frames, but
     Lisp programs can specify frame names when they create frames.

     If you don't specify this option, the default is to use the Emacs
     executable's name as the resource name.

`-xrm RESOURCE-VALUES'
`--xrm=RESOURCE-VALUES'
     Specify X resource values for this Emacs job (see below).

   For consistency, `-name' also specifies the name to use for other
resource values that do not belong to any particular frame.

   The resources that name Emacs invocations also belong to a class; its
name is `Emacs'.  If you write `Emacs' instead of `emacs', the resource
applies to all frames in all Emacs jobs, regardless of frame titles and
regardless of the name of the executable file.  Here is an example:

     Emacs.BorderWidth: 2
     Emacs.borderWidth: 4

   You can specify a string of additional resource values for Emacs to
use with the command line option `-xrm RESOURCES'.  The text RESOURCES
should have the same format that you would use inside a file of X
resources.  To include multiple resource specifications in DATA, put a
newline between them, just as you would in a file.  You can also use
`#include "FILENAME"' to include a file full of resource
specifications.  Resource values specified with `-xrm' take precedence
over all other resource specifications.

   The following table lists the resource names that designate options
for Emacs, each with the class that it belongs to:

`background' (class `Background')
     Background color name.

`bitmapIcon' (class `BitmapIcon')
     Use a bitmap icon (a picture of a gnu) if `on', let the window
     manager choose an icon if `off'.

`borderColor' (class `BorderColor')
     Color name for the external border.

`borderWidth' (class `BorderWidth')
     Width in pixels of the external border.

`cursorColor' (class `Foreground')
     Color name for text cursor (point).

`font' (class `Font')
     Font name for text (or fontset name, *note Fontsets::).

`foreground' (class `Foreground')
     Color name for text.

`geometry' (class `Geometry')
     Window size and position.  Be careful not to specify this resource
     as `emacs*geometry', because that may affect individual menus as
     well as the Emacs frame itself.

     If this resource specifies a position, that position applies only
     to the initial Emacs frame (or, in the case of a resource for a
     specific frame name, only that frame).  However, the size if
     specified here applies to all frames.

`iconName' (class `Title')
     Name to display in the icon.

`internalBorder' (class `BorderWidth')
     Width in pixels of the internal border.

`menuBar' (class `MenuBar')
     Give frames menu bars if `on'; don't have menu bars if `off'.

`minibuffer' (class `Minibuffer')
     If `none', don't make a minibuffer in this frame.  It will use a
     separate minibuffer frame instead.

`paneFont' (class `Font')
     Font name for menu pane titles, in non-toolkit versions of Emacs.

`pointerColor' (class `Foreground')
     Color of the mouse cursor.

`reverseVideo' (class `ReverseVideo')
     Switch foreground and background default colors if `on', use
     colors as specified if `off'.

`verticalScrollBars' (class `ScrollBars')
     Give frames scroll bars if `on'; don't have scroll bars if `off'.

`selectionFont' (class `Font')
     Font name for pop-up menu items, in non-toolkit versions of Emacs.
     (For toolkit versions, see *Note Lucid Resources::, also see
     *Note Motif Resources::.)

`title' (class `Title')
     Name to display in the title bar of the initial Emacs frame.

   Here are resources for controlling the appearance of particular faces
(*note Faces::):

`FACE.attributeFont'
     Font for face FACE.

`FACE.attributeForeground'
     Foreground color for face FACE.

`FACE.attributeBackground'
     Background color for face FACE.

`FACE.attributeUnderline'
     Underline flag for face FACE.  Use `on' or `true' for yes.


File: emacs,  Node: Lucid Resources,  Next: Motif Resources,  Prev: Resources X,  Up: Command Arguments

Lucid Menu X Resources
======================

   If the Emacs installed at your site was built to use the X toolkit
with the Lucid menu widgets, then the menu bar is a separate widget and
has its own resources.  The resource names contain `pane.menubar'
(following, as always, the name of the Emacs invocation or `Emacs'
which stands for all Emacs invocations).  Specify them like this:

     Emacs.pane.menubar.RESOURCE:  VALUE

For example, to specify the font `8x16' for the menu-bar items, write
this:

     Emacs.pane.menubar.font:  8x16

Resources for _non-menubar_ toolkit pop-up menus have `menu*', in like
fashion.  For example, to specify the font `8x16' for the pop-up menu
items, write this:

     Emacs.menu*.font:	8x16

For dialog boxes, use `dialog' instead of `menu':

     Emacs.dialog*.font:	8x16

Experience shows that on some systems you may need to add `shell.'
before the `pane.menubar' or `menu*'.  On some other systems, you must
not add `shell.'.

   Here is a list of the specific resources for menu bars and pop-up
menus:

`font'
     Font for menu item text.

`foreground'
     Color of the foreground.

`background'
     Color of the background.

`buttonForeground'
     In the menu bar, the color of the foreground for a selected item.

`horizontalSpacing'
     Horizontal spacing in pixels between items.  Default is 3.

`verticalSpacing'
     Vertical spacing in pixels between items.  Default is 1.

`arrowSpacing'
     Horizontal spacing between the arrow (which indicates a submenu)
     and the associated text.  Default is 10.

`shadowThickness'
     Thickness of shadow line around the widget.


File: emacs,  Node: Motif Resources,  Prev: Lucid Resources,  Up: Command Arguments

Motif Menu X Resources
======================

   If the Emacs installed at your site was built to use the X toolkit
with the Motif widgets, then the menu bar is a separate widget and has
its own resources.  The resource names contain `pane.menubar'
(following, as always, the name of the Emacs invocation or `Emacs'
which stands for all Emacs invocations).  Specify them like this:

     Emacs.pane.menubar.SUBWIDGET.RESOURCE:  VALUE

   Each individual string in the menu bar is a subwidget; the
subwidget's name is the same as the menu item string.  For example, the
word `Files' in the menu bar is part of a subwidget named
`emacs.pane.menubar.Files'.  Most likely, you want to specify the same
resources for the whole menu bar.  To do this, use `*' instead of a
specific subwidget name.  For example, to specify the font `8x16' for
the menu-bar items, write this:

     Emacs.pane.menubar.*.fontList:  8x16

This also specifies the resource value for submenus.

   Each item in a submenu in the menu bar also has its own name for X
resources; for example, the `Files' submenu has an item named `Save
Buffer'.  A resource specification for a submenu item looks like this:

     Emacs.pane.menubar.popup_*.MENU.ITEM.RESOURCE: VALUE

For example, here's how to specify the font for the `Save Buffer' item:

     Emacs.pane.menubar.popup_*.Files.Save Buffer.fontList: 8x16

For an item in a second-level submenu, such as `Check Message' under
`Spell' under `Edit', the resource fits this template:

     Emacs.pane.menubar.popup_*.popup_*.MENU.RESOURCE: VALUE

For example,

     Emacs.pane.menubar.popup_*.popup_*.Spell.Check Message: VALUE

   It's impossible to specify a resource for all the menu-bar items
without also specifying it for the submenus as well.  So if you want the
submenu items to look different from the menu bar itself, you must ask
for that in two steps.  First, specify the resource for all of them;
then, override the value for submenus alone.  Here is an example:

     Emacs.pane.menubar.*.fontList:  8x16
     Emacs.pane.menubar.popup_*.fontList: 8x16

For toolkit pop-up menus, use `menu*' instead of `pane.menubar'.  For
example, to specify the font `8x16' for the pop-up menu items, write
this:

     Emacs.menu*.fontList:  8x16

   Here is a list of the specific resources for menu bars and pop-up
menus:

`armColor'
     The color to show in an armed button.

`fontList'
     The font to use.

`marginBottom'
`marginHeight'
`marginLeft'
`marginRight'
`marginTop'
`marginWidth'
     Amount of space to leave around the item, within the border.

`borderWidth'
     The width of border around the menu item, on all sides.

`shadowThickness'
     The width of the border shadow.

`bottomShadowColor'
     The color for the border shadow, on the bottom and the right.

`topShadowColor'
     The color for the border shadow, on the top and the left.


File: emacs,  Node: Antinews,  Next: MS-DOS,  Prev: Command Arguments,  Up: Top

Emacs 19 Antinews
*****************

   For those users who live backwards in time, here is information about
downgrading to Emacs version 19.  We hope you will enjoy the greater
simplicity that results from the absence of certain Emacs 20 features.

   * The multibyte character and end-of-line conversion support have
     been eliminated entirely.  (Some users consider this a tremendous
     improvement.)  Character codes are limited to the range 0 through
     255 and files imported onto Unix-like systems may have a ^M at the
     end of each line to remind you to control MS-DOG type files.

   * Fontsets, coding systems and input methods have been eliminated as
     well.

   * The mode line normally displays the string `Emacs', in case you
     forget what editor you are using.

   * Scroll bars always appear on the right-hand side of the window.
     This clearly separates them from the text in the window.

   * The `M-x customize' feature has been replaced with a very simple
     feature, `M-x edit-options'.  This shows you _all_ the user
     options right from the start, so you don't have to hunt for the
     ones you want.  It also provides a few commands, such as `s' and
     `x', to set a user option.

   * The <DELETE> key does nothing special in Emacs 19 when you use it
     after selecting a region with the mouse.  It does exactly the same
     thing in that situation as it does at all other times: delete one
     character backwards.

   * `C-x C-w' no longer changes the major mode according to the new
     file name.  If you want to change the mode, use `M-x normal-mode'.

   * In Transient Mark mode, each window displays highlighting for the
     region as it exists in that window.

   * Outline mode doesn't use overlay properties; instead, it hides a
     line by converting the preceding newline into code 015.
     Magically, however, if you save the file, the 015 character
     appears in the file as a newline.

   * There is now a clever way you can activate the minibuffer
     recursively even if `enable-recursive-minibuffers' is `nil'.  All
     you have to do is _switch windows_ to a non-minibuffer window, and
     then use a minibuffer command.  You can pile up any number of
     minibuffer levels this way, but `M-x top-level' will get you out
     of all of them.

   * We have removed the limit on the length of minibuffer history
     lists; they now contain all the minibuffer arguments you have used
     since the beginning of the session.

   * Dynamic abbrev expansion now handles case conversion in a very
     simple and straightforward way.  If you have requested preserving
     case, it always converts the entire expansion to the case pattern
     of the abbrev that you have typed in.

   * The `compose-mail' command does not exist; `C-x m' now runs `mail'
     directly.

   * There is no way to quote a file name with special characters in it.
     What you see is what you get: if the name looks remote, it is
     remote.

   * `M-x grep-find' has been eliminated, because `grep' has never been
     lost.

   * Some Dired commands have been rearranged: two-character sequences
     have been replaced with quick single-character commands:

        * For `dired-mark-executables', type `*'.

        * For `dired-mark-directories', type `/'.

        * For `dired-mark-symlinks', type `@'.

        * For `dired-change-marks', type `c'.

        * For `dired-unmark-all-files', type `C-M-?'.

        * For `dired-unmark-all-marks', type `C-M-? <RET>'.

     But if you want to use `dired-flag-garbage-files', `&', you'll
     just have to stop living in the past.

   * In C mode, you can now specify your preferred style for block
     comments.  If you want to use the style

          /*
          blah
          blah
          */

     then you should set the variable `c-block-comments-indent-p' to
     `t'.

   * To customize faces used by Font Lock mode, use the variable
     `font-lock-face-attributes'.  See its documentation string for
     details.

   * For efficiency, Font Lock mode now uses by default the minimum
     supported level of decoration for the selected major mode.

   * If you kill a buffer, any registers holding saved positions in that
     buffer are changed to point into limbo.

   * The function `set-frame-font' has been renamed to
     `set-default-font'.

   * The variable `tex-main-file' doesn't exist.  Of course, you can
     create the variable by setting it, but that won't do anything
     special.

   * The `scroll-preserve-screen-position' variable has been eliminated;
     and so has the feature that it controls.

   * We have eliminated the functions `add-untranslated-filesystem' and
     `remove-untranslated-filesystem', and replaced them with a simpler
     function, `using-unix-filesystems'.

   * To keep up with decreasing computer memory capacity, many other
     functions and files have been eliminated in Emacs 19.  There's no
     need to mention them all here.  If you try to use one of them,
     you'll get an error message to tell you that it is undefined or
     unbound.


File: emacs,  Node: MS-DOS,  Next: Manifesto,  Prev: Antinews,  Up: Top

Emacs and MS-DOS
****************

   This section briefly describes the peculiarities of using Emacs under
the MS-DOS "operating system" (also known as "MS-DOG").  If you build
Emacs for MS-DOS, the binary will also run on Windows 3.X, Windows NT,
Windows 9X, or OS/2 as a DOS application; the information in this
chapter applies for all of those systems, if you use an Emacs that was
built for MS-DOS.

   Note that it is possible to build Emacs specifically for Windows NT
or Windows 9X.  If you do that, most of this chapter does not apply;
instead, you get behavior much closer to what is documented in the rest
of the manual, including support for long file names, multiple frames,
scroll bars, mouse menus, and subprocesses.  However, the section on
text files and binary files does still apply.  There are also two
sections at the end of this chapter which apply specifically for Windows
NT and 9X.

* Menu:

* Input: MS-DOS Input.         Keyboard and mouse usage on MS-DOS.
* Display: MS-DOS Display.     Fonts, frames and display size on MS-DOS.
* Files: MS-DOS File Names.    File name conventions on MS-DOS.
* Text and Binary::            Text files on MS-DOS use CRLF to separate lines.
* Printing: MS-DOS Printing.   How to specify the printer on MS-DOS.
* I18N: MS-DOS and MULE.       Support for internationalization on MS-DOS.
* Processes: MS-DOS Processes. Running subprocesses on MS-DOS.
* Windows Processes::          Running subprocesses on Windows.
* Windows System Menu::        Controlling what the ALT key does.


File: emacs,  Node: MS-DOS Input,  Next: MS-DOS Display,  Up: MS-DOS

Keyboard and Mouse on MS-DOS
============================

   The PC keyboard maps use the left <ALT> key as the <META> key.  You
have two choices for emulating the <SUPER> and <HYPER> keys: choose
either the right <CTRL> key or the right <ALT> key by setting the
variables `dos-hyper-key' and `dos-super-key' to 1 or 2 respectively.
If neither `dos-super-key' nor `dos-hyper-key' is 1, then by default
the right <ALT> key is also mapped to the <META> key.  However, if the
MS-DOS international keyboard support program `KEYB.COM' is installed,
Emacs will _not_ map the right <ALT> to <META>, since it is used for
accessing characters like `~' and `@' on non-US keyboard layouts; in
this case, you may only use the left <ALT> as <META> key.

   The variable `dos-keypad-mode' is a flag variable that controls what
key codes are returned by keys in the numeric keypad.  You can also
define the keypad <ENTER> key to act like `C-j', by putting the
following line into your `_emacs' file:

     ;; Make the Enter key from the Numeric keypad act as C-j.
     (define-key function-key-map [kp-enter] [?\C-j])

   The key that is called <DEL> in Emacs (because that's how it is
designated on most workstations) is known as <BS> (backspace) on a PC.
That is why the PC-specific terminal initialization remaps the <BS> key
to act as <DEL>; the <DEL> key is remapped to act as `C-d' for the same
reasons.

   Emacs built for MS-DOS recognizes `C-<BREAK>' as a quit character,
just like `C-g'.  This is because Emacs cannot detect that you have
typed `C-g' until it is ready for more input.  As a consequence, you
cannot use `C-g' to stop a running command (*note Quitting::).  By
contrast, `C-<BREAK>' _is_ detected as soon as you type it (as `C-g' is
on other systems), so it can be used to stop a running command and for
emergency escape (*note Emergency Escape::).

   Emacs on MS-DOS supports a mouse (on the default terminal only).
The mouse commands work as documented, including those that use menus
and the menu bar (*note Menu Bar::).  Scroll bars don't work in MS-DOS
Emacs.  PC mice usually have only two buttons; these act as `Mouse-1'
and `Mouse-2', but if you press both of them together, that has the
effect of `Mouse-3'.

   Emacs built for MS-DOS supports clipboard operations when it runs on
Windows.  Commands that put text on the kill ring, or yank text from the
ring, check the Windows clipboard first, just as Emacs does on X Windows
(*note Mouse Commands::).  Only the primary selection and the cut buffer
are supported by MS-DOS Emacs on Windows; the secondary selection always
appears as empty.

   Due to the way clipboard access is implemented by Windows, the
length of text you can put into the clipboard is limited by the amount
of free DOS memory that is available to Emacs.  Usually, up to 620KB of
text can be put into the clipboard, but this limit depends on the system
configuration and is lower if you run Emacs as a subprocess of another
program.  If the killed text does not fit, Emacs prints a message
saying so, and does not put the text into the clipboard.

   Null characters also cannot be put into the Windows clipboard.  If
the killed text includes null characters, Emacs does not put such text
into the clipboard, and prints in the echo area a message to that
effect.

   The variable `dos-display-scancodes', when non-`nil', directs Emacs
to display the ASCII value and the keyboard scan code of each
keystroke; this feature serves as a complement to the `view-lossage'
command, for debugging.


File: emacs,  Node: MS-DOS Display,  Next: MS-DOS File Names,  Prev: MS-DOS Input,  Up: MS-DOS

Display on MS-DOS
=================

   Display on MS-DOS cannot use font variants, like bold or italic, but
it does support multiple faces, each of which can specify a foreground
and a background color.  Therefore, you can get the full functionality
of Emacs packages that use fonts (such as `font-lock', Enriched Text
mode, and others) by defining the relevant faces to use different
colors.  Use the `list-colors-display' command (*note Frame
Parameters::) and the `list-faces-display' command (*note Faces::) to
see what colors and faces are available and what they look like.

   The section *Note MS-DOS and MULE::, later in this chapter, describes
how Emacs displays glyphs and characters which aren't supported by the
native font built into the DOS display.

   Multiple frames (*note Frames::) are supported on MS-DOS, but they
all overlap, so you only see a single frame at any given moment.  That
single visible frame occupies the entire screen.  When you run Emacs
from MS-Windows DOS box, you can make the visible frame smaller than
the full screen, but Emacs still cannot display more than a single
frame at a time.

   The `mode4350' command switches the display to 43 or 50 lines,
depending on your hardware; the `mode25' command switches to the
default 80x25 screen size.

   By default, Emacs only knows how to set screen sizes of 80 columns by
25, 28, 35, 40, 43 or 50 rows.  However, if your video adapter has
special video modes that will switch the display to other sizes, you can
have Emacs support those too.  When you ask Emacs to switch the frame to
N rows by M columns dimensions, it checks if there is a variable called
`screen-dimensions-NxM', and if so, uses its value (which must be an
integer) as the video mode to switch to.  (Emacs switches to that video
mode by calling the BIOS `Set Video Mode' function with the value of
`screen-dimensions-NxM' in the `AL' register.)  For example, suppose
your adapter will switch to 66x80 dimensions when put into video mode
85.  Then you can make Emacs support this screen size by putting the
following into your `_emacs' file:

     (setq screen-dimensions-66x80 85)

   Since Emacs on MS-DOS can only set the frame size to specific
supported dimensions, it cannot honor every possible frame resizing
request.  When an unsupported size is requested, Emacs chooses the next
larger supported size beyond the specified size.  For example, if you
ask for 36x80 frame, you will get 40x80 instead.

   The variables `screen-dimensions-NxM' are used only when they
exactly match the specified size; the search for the next larger
supported size ignores them.  In the above example, even if your VGA
supports 38x80 dimensions and you define a variable
`screen-dimensions-38x80' with a suitable value, you will still get
40x80 screen when you ask for a 36x80 frame.  If you want to get the
38x80 size in this case, you can do it by setting the variable named
`screen-dimensions-36x80' with the same video mode value as
`screen-dimensions-38x80'.

   Changing frame dimensions on MS-DOS has the effect of changing all
the other frames to the new dimensions.


File: emacs,  Node: MS-DOS File Names,  Next: Text and Binary,  Prev: MS-DOS Display,  Up: MS-DOS

File Names on MS-DOS
====================

   MS-DOS normally uses a backslash, `\', to separate name units within
a file name, instead of the slash used on other systems.  Emacs on
MS-DOS permits use of either slash or backslash, and also knows about
drive letters in file names.

   On MS-DOS, file names are case-insensitive and limited to eight
characters, plus optionally a period and three more characters.  Emacs
knows enough about these limitations to handle file names that were
meant for other operating systems.  For instance, leading dots `.' in
file names are invalid in MS-DOS, so Emacs transparently converts them
to underscores `_'; thus your default init file (*note Init File::) is
called `_emacs' on MS-DOS.  Excess characters before or after the
period are generally ignored by MS-DOS itself; thus, if you visit the
file `LongFileName.EvenLongerExtension', you will silently get
`longfile.eve', but Emacs will still display the long file name on the
mode line.  Other than that, it's up to you to specify file names which
are valid under MS-DOS; the transparent conversion as described above
only works on file names built into Emacs.

   The above restrictions on the file names on MS-DOS make it almost
impossible to construct the name of a backup file (*note Backup
Names::) without losing some of the original file name characters.  For
example, the name of a backup file for `docs.txt' is `docs.tx~' even if
single backup is used.

   If you run Emacs as a DOS application under Windows 9X, you can turn
on support for long file names.  If you do that, Emacs doesn't truncate
file names or convert them to lower case; instead, it uses the file
names that you specify, verbatim.  To enable long file name support,
set the environment variable `LFN' to `y' before starting Emacs.
Unfortunately, Windows NT doesn't allow DOS programs to access long
file names, so Emacs built for MS-DOS will only see their short 8+3
aliases.

   MS-DOS has no notion of home directory, so Emacs on MS-DOS pretends
that the directory where it is installed is the value of `HOME'
environment variable.  That is, if your Emacs binary, `emacs.exe', is
in the directory `c:/utils/emacs/bin', then Emacs acts as if `HOME'
were set to `c:/utils/emacs'.  In particular, that is where Emacs looks
for the init file `_emacs'.  With this in mind, you can use `~' in file
names as an alias for the home directory, as you would in Unix.  You
can also set `HOME' variable in the environment before starting Emacs;
its value will then override the above default behavior.

   Emacs on MS-DOS handles the directory name `/dev' specially, because
of a feature in the emulator libraries of DJGPP that pretends I/O
devices have names in that directory.  We recommend that you avoid
using an actual directory named `/dev' on any disk.


File: emacs,  Node: Text and Binary,  Next: MS-DOS Printing,  Prev: MS-DOS File Names,  Up: MS-DOS

Text Files and Binary Files
===========================

   GNU Emacs uses newline characters to separate text lines.  This is
the convention used on Unix, on which GNU Emacs was developed, and on
GNU systems since they are modeled on Unix.

   MS-DOS and MS-Windows normally use carriage-return linefeed, a
two-character sequence, to separate text lines.  (Linefeed is the same
character as newline.)  Therefore, convenient editing of typical files
with Emacs requires conversion of these end-of-line (EOL) sequences.
And that is what Emacs normally does: it converts carriage-return
linefeed into newline when reading files, and converts newline into
carriage-return linefeed when writing files.  The same mechanism that
handles conversion of international character codes does this conversion
also (*note Coding Systems::).

   One consequence of this special format-conversion of most files is
that character positions as reported by Emacs (*note Position Info::) do
not agree with the file size information known to the operating system.

   Some kinds of files should not be converted, because their contents
are not really text.  Therefore, Emacs on MS-DOS distinguishes certain
files as "binary files", and reads and writes them verbatim.  (This
distinction is not part of MS-DOS; it is made by Emacs only.)  These
include executable programs, compressed archives, etc.  Emacs uses the
file name to decide whether to treat a file as binary: the variable
`file-name-buffer-file-type-alist' defines the file-name patterns that
indicate binary files.  Note that if a file name matches one of the
patterns for binary files in `file-name-buffer-file-type-alist', Emacs
uses the `no-conversion' coding system (*note Coding Systems::) which
turns off _all_ coding-system conversions, not only the EOL conversion.

   In addition, if Emacs recognizes from a file's contents that it uses
newline rather than carriage-return linefeed as its line separator, it
does not perform conversion when reading or writing that file.  Thus,
you can read and edit files from Unix or GNU systems on MS-DOS with no
special effort, and they will be left with their Unix-style EOLs.

   You can visit a file and specify whether to treat a file as text or
binary using the commands `find-file-text' and `find-file-binary'.
End-of-line conversion is part of the general coding system conversion
mechanism, so another way to control whether to treat a file as text or
binary is with the commands for specifying a coding system (*note
Specify Coding::).  For example, `C-x <RET> c undecided-unix <RET> C-x
C-f foobar.txt' visits the file `foobar.txt' without converting the
EOLs.

   The mode line indicates whether end-of-line translation was used for
the current buffer.  Normally a colon appears after the coding system
letter near the beginning of the mode line.  If MS-DOS end-of-line
translation is in use for the buffer, this character changes to a
backslash.

   When you use NFS or Samba to access file systems that reside on
computers using Unix or GNU systems, Emacs should not perform
end-of-line translation on any files in these file systems-not even
when you create a new file.  To request this, designate these file
systems as "untranslated" file systems by calling the function
`add-untranslated-filesystem'.  It takes one argument: the file system
name, including a drive letter and optionally a directory.  For example,

     (add-untranslated-filesystem "Z:")

designates drive Z as an untranslated file system, and

     (add-untranslated-filesystem "Z:\\foo")

designates directory `\foo' on drive Z as an untranslated file system.

   Most often you would use `add-untranslated-filesystem' in your
`_emacs' file, or in `site-start.el' so that all the users at your site
get the benefit of it.

   To countermand the effect of `add-untranslated-filesystem', use the
function `remove-untranslated-filesystem'.  This function takes one
argument, which should be a string just like the one that was used
previously with `add-untranslated-filesystem'.


File: emacs,  Node: MS-DOS Printing,  Next: MS-DOS and MULE,  Prev: Text and Binary,  Up: MS-DOS

Printing and MS-DOS
===================

   Printing commands, such as `lpr-buffer' (*note Hardcopy::) and
`ps-print-buffer' (*note Postscript::) can work in MS-DOS and
MS-Windows by sending the output to one of the printer ports, if a
Unix-style `lpr' program is unavailable.  This behaviour is controlled
by the same variables that control printing with `lpr' on Unix (*note
Hardcopy::, *note Postscript Variables::), but the defaults for these
variables on MS-DOS and MS-Windows are not the same as the defaults on
Unix.

   If you want to use your local printer, printing on it in the usual
DOS manner, then set the Lisp variable `lpr-command' to `""' (its
default value) and `printer-name' to the name of the printer port--for
example, `"PRN"', the usual local printer port (that's the default), or
`"LPT2"', or `"COM1"' for a serial printer.  You can also set
`printer-name' to a file name, in which case "printed" output is
actually appended to that file.  If you set `printer-name' to `"NUL"',
printed output is silently discarded (sent to the system null device).

   On MS-Windows, when the Windows network software is installed, you
can also use a printer shared by another machine by setting
`printer-name' to the UNC share name for that printer-for example,
`"//joes_pc/hp4si"'.  (It doesn't matter whether you use forward
slashes or backslashes here.)  To find out the names of shared printers,
run the command `net view' at a DOS command prompt to obtain a list of
servers, and `net view SERVER-NAME' to see the names of printers (and
directories) shared by that server.

   If you set `printer-name' to a file name, it's best to use an
absolute file name.  Emacs changes the working directory according to
the default directory of the current buffer, so if the file name in
`printer-name' is relative, you will end up with several such files,
each one in the directory of the buffer from which the printing was
done.

   The commands `print-buffer' and `print-region' call the `pr'
program, or use special switches to the `lpr' program, to produce
headers on each printed page.  MS-DOS and MS-Windows don't normally
have these programs, so by default, the variable `lpr-headers-switches'
is set so that the requests to print page headers are silently ignored.
Thus, `print-buffer' and `print-region' produce the same output as
`lpr-buffer' and `lpr-region', respectively.  If you do have a suitable
`pr' program (for example, from GNU Textutils), set
`lpr-headers-switches' to `nil'; Emacs will then call `pr' to produce
the page headers, and print the resulting output as specified by
`printer-name'.

   Finally, if you do have an `lpr' work-alike, you can set the
variable `lpr-command' to `"lpr"'.  Then Emacs will use `lpr' for
printing, as on other systems.  (If the name of the program isn't
`lpr', set `lpr-command' to specify where to find it.)  The variable
`lpr-switches' has its standard meaning when `lpr-command' is not `""'.
If the variable `printer-name' has a string value, it is used as the
value for the `-P' option to `lpr', as on Unix.

   A parallel set of variables, `ps-lpr-command', `ps-lpr-switches',
and `ps-printer-name' (*note Postscript Variables::), defines how
PostScript files should be printed.  These variables are used in the
same way as the corresponding variables described above for
non-PostScript printing.  Thus, the value of `ps-printer-name' is used
as the name of the device (or file) to which PostScript output is sent,
just as `printer-name' is used for non-PostScript printing.  (There are
two distinct sets of variables in case you have two printers attached
to two different ports, and only one of them is a PostScript printer.)

   The default value of the variable `ps-lpr-command' is `""', which
causes PostScript output to be sent to the printer port specified by
`ps-printer-name', but `ps-lpr-command' can also be set to the name of
a program which will accept PostScript files.  Thus, if you have a
non-PostScript printer, you can set this variable to the name of a
PostScript interpreter program (such as Ghostscript).  Any switches
that need to be passed to the interpreter program are specified using
`ps-lpr-switches'.  (If the value of `ps-printer-name' is a string, it
will be added to the list of switches as the value for the `-P' option.
This is probably only useful if you are using `lpr', so when using an
interpreter typically you would set `ps-printer-name' to something
other than a string so it is ignored.)

   For example, to use Ghostscript for printing on an Epson printer
connected to the `LPT2' port, put this in your `_emacs' file:

     (setq ps-printer-name t)  ; Ghostscript doesn't understand -P
     (setq ps-lpr-command "c:/gs/gs386")
     (setq ps-lpr-switches '("-q" "-dNOPAUSE"
     			"-sDEVICE=epson"
     			"-r240x72"
     			"-sOutputFile=LPT2"
     			"-Ic:/gs"))

(This assumes that Ghostscript is installed in the `"c:/gs"' directory.)

   For backwards compatibility, the value of `dos-printer'
(`dos-ps-printer'), if it has a value, overrides the value of
`printer-name' (`ps-printer-name'), on MS-DOS and MS-Windows only.


File: emacs,  Node: MS-DOS and MULE,  Next: MS-DOS Processes,  Prev: MS-DOS Printing,  Up: MS-DOS

International Support on MS-DOS
===============================

   Emacs on MS-DOS supports the same international character sets as it
does on Unix and other platforms (*note International::), including
coding systems for converting between the different character sets.
However, due to incompatibilities between MS-DOS/MS-Windows and Unix,
there are several DOS-specific aspects of this support that users should
be aware of.  This section describes these aspects.

`M-x dos-codepage-setup'
     Set up Emacs display and coding systems as appropriate for the
     current DOS codepage.

`M-x codepage-setup'
     Create a coding system for a certain DOS codepage.

   MS-DOS is designed to support one character set of 256 characters at
any given time, but gives you a variety of character sets to choose
from.  The alternative character sets are known as "DOS codepages".
Each codepage includes all 128 ASCII characters, but the other 128
characters (codes 128 through 255) vary from one codepage to another.
Each DOS codepage is identified by a 3-digit number, such as 850, 862,
etc.

   In contrast to X Windows, which lets you use several fonts at the
same time, MS-DOS doesn't allow use of several codepages in a single
session.  Instead, MS-DOS loads a single codepage at system startup,
and you must reboot MS-DOS to change it(1).  Much the same limitation
applies when you run DOS executables on other systems such as
MS-Windows.

   If you invoke Emacs on MS-DOS with the `--unibyte' option (*note
Initial Options::), Emacs does not perform any conversion of non-ASCII
characters.  Instead, it reads and writes any non-ASCII characters
verbatim, and sends their 8-bit codes to the display verbatim.  Thus,
unibyte Emacs on MS-DOS supports the current codepage, whatever it may
be, but cannot even represent any other characters.

   For multibyte operation on MS-DOS, Emacs needs to know which
characters the chosen DOS codepage can display.  So it queries the
system shortly after startup to get the chosen codepage number, and
stores the number in the variable `dos-codepage'.  Some systems return
the default value 437 for the current codepage, even though the actual
codepage is different.  (This typically happens when you use the
codepage built into the display hardware.)  You can specify a different
codepage for Emacs to use by setting the variable `dos-codepage' in
your init file.

   Multibyte Emacs supports only certain DOS codepages: those which can
display Far-Eastern scripts, like the Japanese codepage 932, and those
that encode a single ISO 8859 character set.

   The Far-Eastern codepages can directly display one of the MULE
character sets for these countries, so Emacs simply sets up to use the
appropriate terminal coding system that is supported by the codepage.
The special features described in the rest of this section mostly
pertain to codepages that encode ISO 8859 character sets.

   For the codepages which correspond to one of the ISO character sets,
Emacs knows the character set name based on the codepage number.  Emacs
automatically creates a coding system to support reading and writing
files that use the current codepage, and uses this coding system by
default.  The name of this coding system is `cpNNN', where NNN is the
codepage number.(2)

   All the `cpNNN' coding systems use the letter `D' (for "DOS") as
their mode-line mnemonic.  Since both the terminal coding system and
the default coding system for file I/O are set to the proper `cpNNN'
coding system at startup, it is normal for the mode line on MS-DOS to
begin with `-DD\-'.  *Note Mode Line::.  Far-Eastern DOS terminals do
not use the `cpNNN' coding systems, and thus their initial mode line
looks like on Unix.

   Since the codepage number also indicates which script you are using,
Emacs automatically runs `set-language-environment' to select the
language environment for that script (*note Language Environments::).

   If a buffer contains a character belonging to some other ISO 8859
character set, not the one that the chosen DOS codepage supports, Emacs
displays it using a sequence of ASCII characters.  For example, if the
current codepage doesn't have a glyph for the letter `o`' (small `o'
with a grave accent), it is displayed as `{`o}', where the braces serve
as a visual indication that this is a single character.  (This may look
awkward for some non-Latin characters, such as those from Greek or
Hebrew alphabets, but it is still readable by a person who knows the
language.)  Even though the character may occupy several columns on the
screen, it is really still just a single character, and all Emacs
commands treat it as one.

   Not all characters in DOS codepages correspond to ISO 8859
characters--some are used for other purposes, such as box-drawing
characters and other graphics.  Emacs cannot represent these characters
internally, so when you read a file that uses these characters, they are
converted into a particular character code, specified by the variable
`dos-unsupported-character-glyph'.

   Emacs supports many other characters sets aside from ISO 8859, but it
cannot display them on MS-DOS.  So if one of these multibyte characters
appears in a buffer, Emacs on MS-DOS displays them as specified by the
`dos-unsupported-character-glyph' variable; by default, this glyph is
an empty triangle.  Use the `C-u C-x =' command to display the actual
code and character set of such characters.  *Note Position Info::.

   By default, Emacs defines a coding system to support the current
codepage.  To define a coding system for some other codepage (e.g., to
visit a file written on a DOS machine in another country), use the `M-x
codepage-setup' command.  It prompts for the 3-digit code of the
codepage, with completion, then creates the coding system for the
specified codepage.  You can then use the new coding system to read and
write files, but you must specify it explicitly for the file command
when you want to use it (*note Specify Coding::).

   These coding systems are also useful for visiting a file encoded
using a DOS codepage, using Emacs running on some other operating
system.

   ---------- Footnotes ----------

   (1) Normally, one particular codepage is burnt into the display
memory, while other codepages can be installed by modifying system
configuration files, such as `CONFIG.SYS', and rebooting.

   (2) The standard Emacs coding systems for ISO 8859 are not quite
right for the purpose, because typically the DOS codepage does not
match the standard ISO character codes.  For example, the letter `c,'
(`c' with cedilla) has code 231 in the standard Latin-1 character set,
but the corresponding DOS codepage 850 uses code 135 for this glyph.


File: emacs,  Node: MS-DOS Processes,  Next: Windows Processes,  Prev: MS-DOS and MULE,  Up: MS-DOS

Subprocesses on MS-DOS
======================

   Because MS-DOS is a single-process "operating system," asynchronous
subprocesses are not available.  In particular, Shell mode and its
variants do not work.  Most Emacs features that use asynchronous
subprocesses also don't work on MS-DOS, including spelling correction
and GUD.  When in doubt, try and see; commands that don't work print an
error message saying that asynchronous processes aren't supported.

   Compilation under Emacs with `M-x compile', searching files with
`M-x grep' and displaying differences between files with `M-x diff' do
work, by running the inferior processes synchronously.  This means you
cannot do any more editing until the inferior process finishes.

   By contrast, Emacs compiled as native Windows application *does*
support asynchronous subprocesses.  *Note Windows Processes::.

   Printing commands, such as `lpr-buffer' (*note Hardcopy::) and
`ps-print-buffer' (*note Postscript::), work in MS-DOS by sending the
output to one of the printer ports.  *Note MS-DOS Printing::.

   When you run a subprocess synchronously on MS-DOS, make sure the
program terminates and does not try to read keyboard input.  If the
program does not terminate on its own, you will be unable to terminate
it, because MS-DOS provides no general way to terminate a process.
Pressing `C-c' or `C-<BREAK>' might sometimes help in these cases.

   Accessing files on other machines is not supported on MS-DOS.  Other
network-oriented commands such as sending mail, Web browsing, remote
login, etc., don't work either, unless network access is built into
MS-DOS with some network redirector.

   Dired on MS-DOS uses the `ls-lisp' package where other platforms use
the system `ls' command.  Therefore, Dired on MS-DOS supports only some
of the possible options you can mention in the `dired-listing-switches'
variable.  The options that work are `-A', `-a', `-c', `-i', `-r', `-S',
`-s', `-t', and `-u'.

