Emacs won't start anymore? See troubleshooting below.
Shells and subprocesses don't work? Using anti-virus software? See anti-virus problems below.
Using bash from Cygwin-b19? See bash below.
This document is mirrored at:
ftp.sunet.se
in Sweden
ic.uva.nl in Netherlands
More from Eli:
It might be of interest to Windows users that this version of Emacs supports long filenames (Windows 95 only) and the Windows clipboard (all versions of MS-Windows). It also supports multiple frames, but they all overlap, like when Emacs runs on a ``glass teletype'' terminal.People who would like to run Emacs on plain DOS (as opposed to Windows) will need to download and install a DPMI host at this URL:
ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2misc/csdpmi3b.zip
Hisashi Miyashita <himi@bird.scphys.kyoto-u.ac.jp> maintains MULE, multilingual Emacs. You can get distributions of MULE at ftp://ftp.tokyonet.AD.JP/pub/windows/win32/mule-win32.
There are a couple of XEmacs for Windows NT/9X porting projects. See the XEmacs FAQ entry for more info, as well as Hrvoje Niksic's XEmacs on Windows FAQ.
If you have general questions about Emacs, the best places to start looking are the Emacs manual and the standard Emacs FAQ. If you already have Emacs, you can browse the manual using Info by typing "C-h i m Emacs RET", and you can view the FAQ by typing "C-h F". Or you can browse both of them online:
Emacs 20.3.1 is the latest release of Emacs on NT and Win95/98. It contains a significant number of bug fixes and features not found in the 19.34.6 release, and is relatively stable (especially compared with the Emacs 20.2.1 release). All future development will be done under Emacs 20, and I recommend that new users download this version.
A significant change between 19.34.6 and 20 is the way in which end-of-line characters are handled. Emacs 20 has a general mechanism for detecting code systems used in files, and part of this mechanism detects end-of-line characters. I expect there to be unexpected surprises in the interaction between assumptions made by older packages and the new mechanism, so be aware.
I also highly recommend reading the help text for the function find-buffer-file-type-coding-system. Since this will be utterly impenetrable, I then suggest reading the Info pages on coding systems and end-of-line detection, and then taking a peak at f-b-f-t-c-s again.
Another very noticeable change between Emacs 19 and Emacs 20 is that all identifiers prefixed with "win32" have been changed to "w32". You should change references to these identifiers in your startup file and other lisp code to match this change.
Unfortunately, VM has not been ported to Emacs 20 yet. If you are considering whether to move to Emacs 20 and you use VM, you will probably want to stick with 19.34.6 until VM has moved forward. (Bill Carpenter <bill@carpenter.ORG> on the question of VM and Emacs 20.)
The variable c-mode-map changed to c-mode-base-map from version 19.34 to version 20.1.
Erwin Achermann <acherman@inf.ethz.ch> has graciously collected user experiences related to upgrading from 19.34.6 to 20.3.
Charles Curley <ccurley@trib.com> thoroughly reports the process he went through.
The latest end-of-line handling code in Emacs prevents command.com from being used as the interactive shell on Win95 out of the box. To use command.com as your shell, place the following in your startup file:
(setq process-coding-system-alist
'(("cmdproxy" . (raw-text-dos . raw-text-dos))))
The version of speedbar shipped with Emacs 20.3.1 has a bug preventing it from being used. If you have the JDE, you can use the version of speedbar.elc from there (either by modifying your load-path or copying it over into your lisp directory). If you don't have the JDE, the following version should work:
Some versions of sendmail give a limit when reporting the SIZE extension, and this confuses the version of smtpmail shipped with 20.3.1. The warning is completely harmless, but if it annoys you then you can apply the following patch to lisp\mail\smtpmail.el or download a patched smtpmail.el (be sure to place it in the right directory and byte compile it):
If you are having difficulty printing from Emacs 20.3.1, see Andrew's note.
If you set which-func-mode-global via customize, which-func-mode will not turn on automatically. You need to add the following to your startup file before the call to custom-set-variables:
(which-func-mode 1)
More from Cristian Ionescu-Idbohrn <cristian.ionescu-idbohrn@axis.com> on which-func-mode.
If you install the binary distribution and runemacs.exe does not run, and then you try the undump distribution or compiling from source and temacs.exe fails to dump correctly, then download the source distribution, apply this patch to src/w32heap.c, and recompile.
If AUCTeX fails with an error that the TeX output buffer is read-only, then you will want to apply this patch posted to dejanews.
igrep 2.82 needs to have the variable grep-null-device defined; add the following to your startup file:
(defvar grep-null-device null-device)
Emacs 20.3 has a bug in window-end which crops up in various places. One of them is in the lazy-lock package. If you use lazy-lock with Emacs 20.3 and are experiencing problems, try adding the following to your startup file before it loads lazy-lock:
(when (and (= emacs-major-version 20) (= emacs-minor-version 3))
(let ((emacs-minor-version 2))
(require 'lazy-lock)))
There appear to be other problems with lazy-lock as well; Jim Corwin's <corwin@matrix-one.com> experiences.
David Koppelman <koppel@ee.lsu.edu> found that the above patch does not work for him, but he does find that setting lazy-lock-defer-on-scrolling to "t" does prevent the crashes.
Richard Stallman sent out this patch that fixes the bug in the C source. If you have the source, you can apply the patch and rebuild Emacs.
Emacs is distributed in two different forms. You can get the full source distribution of Emacs, or you can get an installed distribution of Emacs with all executables precompiled.
The latest source distribution can be found in ftp.cs.washington.edu/pub/ntemacs/latest/src. It is distributed in two formats: one large gzipped tar file (emacs*.tar.gz), and a collection of smaller zip files that can be copied to 1.44 Mbyte floppies (em-src-_?.zip).
In the same directory you should also find patch files that enable you to upgrade source distributions to the latest version. These patch files are mirrors of the ones on the FSF server at ftp://ftp.gnu.ai.mit.edu/pub/gnu.
You can also browse the source online; look in ftp://ftp.cs.washington.edu/pub/ntemacs/latest/src for a directory named "emacs-<version>".
Links to precompiled versions:
I've had numerous reports from people outside North America saying that their ftp connection aborts for no apparent reason roughly a third of the way through a transfer of a full distribution. Marc Haber (s_haber@ira.uka.de) said that he suffered from the same problem, and later found that a timeout configured into his WWW proxy would cancel the transfer when the link to the US was very busy. Going around his proxy solved the problem. Andy Moreton <ajm@atml.co.uk> describes his situation when using SOCKS:
The FAQ page mentions some people have problems downloading - I may be able to shed some light on it. Our site has a reasonably secure firewall, and so all access to the outside world requires use of SOCKS based connections via a SOCKS5 server (i.e. a circuit-level gateway). When doing an FTP transfer, two connections are up - a telnet for the control connection, and the data transfer on another. As the telnet connection is idle during the file transfer, the SOCKS server disconnects it. Some FTP servers get upset by this (especially the NT FTP server), and drop the data connection if the control connection goes down.
If you do have trouble downloading the full distribution, try downloading it in the 1.44MB chunks, or try one of the mirror sites.
Mirror sites with precompiled versions:
% gunzip -c -d emacs.tar.gz | tar xvf -
(Note: Apparently the alpha version of gunzip cannot handle long file names, so you will need to rename the file to something like "emacstar.gz" before uncompressing it.)
The "-d" flag forces gunzip to decompress (its behavior depends upon the case of the name of the executable, and sometimes it doesn't recognize that it is really gunzip), and the "-c" flag tells it to pipe its output to stdout. Similarly, the "-" flag to tar tells it to read the tar file from stdin. Unpacking the distribution this way leaves the distribution in compressed form so it takes up less space.
You may see messages from tar about not being able to change the modification time on directories, and from gunzip complaining about a broken pipe. These messages are harmless and you can ignore them.
If for some reason you also want to have the tar file gunzipped, then invoke gunzip without the -c option:
% gunzip -d emacs.tar.gz
If you have the zip version, use unzip with the "-x" flag on all of the .zip files (note that you cannot use pkunzip on these files, as pkunzip will not preserve the long filenames):
% unzip -x emacs-_1.zip % (repeat for the remaining .zip files)You can find precompiled versions of all of the compression and archive utilities in ftp.cs.washington.edu/pub/ntemacs/utilities/.
WARNING: Some utilities that handle tar files can incorrectly untar the distributions when using the default settings. If you encounter problems with Emacs, see the section below on troubleshooting these problems.
Once you have unpacked a precompiled version of Emacs, it should have the following subdirectories:
bin etc info lisp lock site-lisp
If your utility failed to create the lock directory, then you can simply create it by hand (it is initially empty).
See below for information on where to place the .emacs startup file.
You should also find a file named README as a part of the distribution. Be sure to read this file for information on installing Emacs, as well as reading the section below on installing Emacs.
See the section below on troubleshooting Emacs if, after downloading a precompiled distribution and unpacking it according to the instructions above, you have trouble running Emacs.
Download and place the source distribution in a directory (say, c:\emacs). Unpack the distribution, and go to the nt subdirectory of the emacs directory that gets created in the unpacking process. Read the README and INSTALL files included with the distribution for the full details of this process.
Emacs is just like any other Win32 application compiled and linked using MSVC, and it can be debugged using Win32 debuggers like DevStudio. By default, Emacs will compile with debugging options turned on. Once compiled, you should be able to load either temacs.exe, the undumped executable, or emacs.exe, the dumped executable, into the debugger (almost always you will want to debug emacs.exe).
Before you run it in the debugger, though, you will need to have the Emacs environment variables set in your shell so that the Emacs process uses the lisp and data files of the development tree instead of an installed version of Emacs. You can either set these variables by hand, or you can use the debug.bat batch file created in the nt subdirectory and installed in the bin directory. This batch file will set the appropriate environment variables and run msdev on the emacs.exe executable installed in the bin directory.
Note that Emacs has conventions for naming built-in C identifiers corresponding to lisp functions and variables. You will, of course, need to use the C identifier names when examining variables and setting breakpoints. The C identifier versions of lisp identifiers have dashes converted to underscores, and they are prefixed with a capital letter denoting the type of lisp object that they refer to (functions use 'F', variables use 'V', etc.). For example, the C function implementing the lisp function expand-file-name is Fexpand_file_name, and the C variable corresponding to the lisp variable load-path is Vload_path.
Below are two methods for installing Emacs. If the instructions below seem a bit confusing, Charles Curley <ccurley@trib.com> has also written a tutorial on installing Emacs that you might find useful.
Let's assume that the directory in which you have unpacked Emacs is c:\emacs (note that it can be anything you want it to be; I just want to be able to refer to something concrete at this point). First, you will want to run the program bin\addpm.exe with the Emacs directory as an argument. In this example you would invoke it as:
c:\emacs\bin\addpm.exe c:\emacsInvoking addpm.exe will do two things. First, it will create a set of registry keys that tell Emacs where to find its support files (lisp, info, etc.). Second, it will create a folder containing an icon linked to runemacs.exe (a wrapper program for invoking Emacs).
Now, to run Emacs, simply click on the icon in the newly created folder or invoke runemacs.exe from a command prompt.
Alternate method:
Another alternative for running Emacs is to use the emacs.bat batch file in the bin directory (this is now the old method of invoking Emacs). Edit the emacs.bat file to change the emacs_dir environment variable to point to the Emacs installation directory and invoke the emacs.bat file to run Emacs. (If you use bash as your shell, you can use an equivalent bash script to emacs.bat.)
Note that, on Win95, you are likely to get "Out of environment space" messages when invoking the emacs.bat batch file. The problem is that the console process in which the script is executed runs out of memory in which to set the Emacs environment variables. To get around this problem, create a shortcut icon to the emacs.bat script. Then right click on the icon and select Properties. In the dialog box that pops up, select the Memory tab and then change the Environment memory allocation from "Auto" to "1024". Close the dialog box and then double click on the icon to start Emacs.
The INSTALL_DIR macro in the nt\makefile.def makefile determines where Emacs will get installed from the source distribution. If you want to install Emacs in the same directory as the source tree (say, c:\src\emacs), then simply set INSTALL_DIR appropriately:
INSTALL_DIR = c:\src\emacsIf you want to install Emacs in a different directory (say, c:\emacs), then set INSTALL_DIR to this directory:
INSTALL_DIR = c:\emacsAs compared with the installation process for the precompiled version, the installation process will automatically create a bin\emacs.bat file in the installation tree with the emacs_dir variable set appropriately.
You can run Emacs in a number of ways. If you installed Emacs using addpm, then you can run Emacs via the Start Menu using the "Programs->Gnu Emacs->Emacs" menu command. From the command line, you can use the program runemacs.exe.
If you didn't install Emacs using addpm, then you can run Emacs using the emacs.bat batch file in the Emacs bin directory. See the install section above for instructions on how to do this.
Note: Starting with version 19.34.6, Emacs is linked with setargv.obj. This gives Emacs DOS-style wildcard expansion of its command-line arguments, which should handle the common use of wildcards. To suppress expansion by setarg.obj, enclose the argument in double quotes. Embedded double-quotes will have to be escaped using a backslash.
The only thing that Emacs changes in your system is the registry (if you used addpm to install it). Emacs does not, for example, install any files in your system directory. If you don't mind the registry settings remaining in the registry, then you don't need to do anything to uninstall Emacs.
If you want to remove the registry settings, then you can use the regedt32 program to remove the Emacs registry keys. Depending upon what kind of permissions you have, the registry entries could have been installed in either HKEY_LOCAL_MACHINE\SOFTWARE\GNU\Emacs or HKEY_CURRENT_USER\SOFTWARE\GNU\Emacs.
If you feel certain that you have unpacked the distribution correctly, then you should check to make sure that the emacs_dir variable in the emacs.bat file is set correctly. If it is and you are still having trouble, make sure that it is an absolute path that includes the drive letter (or is in UNC format).
If Emacs produces an access violation when you run it, then it might be a problem with Emacs unsuccessfully interacting with other software such as HeapAgent and Starfish Internet Monitor. See the section below describing this problem and how to work around it.
If it is still not working, send me mail or send mail to the list.
The typical behavior people are encountering with this problem is that they invoke Emacs but either nothing happens or it produces an access violation, and yet they have changed nothing in their Emacs installation, and Emacs used to work fine before this point. Most likely, the problem is due to an interaction between Emacs and some new piece of software you have just installed (the most popular culprit seems to be HeapAgent). Due to the nature in which Emacs is designed and built, Emacs is fundamentally non-relocatable: it uses an initialized heap segment that needs to be mapped in at a particular virtual address at startup time before Emacs will work correctly. It appears that programs like HeapAgent install DLLs that intrude upon Emacs' virtual address space, preventing Emacs to load its initialized heap.
If you have HeapAgent, then you can work around the problem in three ways. You can download the source and recompile, as described below. Or, you can download a version that has already been precompiled to avoid conflicts with HeapAgent (compliments of Andrew Bishop <andrew.bishop@autodesk.com>). Or, you can use editbin to change the base address at which the haloader.dll dll will be loaded (this is the dll that gets loaded into every application's address space on startup):
Otherwise, the only other workaround is to recompile Emacs on your machine so that Emacs creates and initializes its heap at a virtual address that does not conflict with software such as HeapAgent. To do this, you will need to download the source, #define the macro NTHEAP_PROBE_BASE inside the procedure src\ntheap.c:allocate_heap(), and rebuild.editbin /rebase:base=0x20000000 haloader.dll
2. Starfish Internet Monitor
Apparently, Starfish Internet Monitor interferes with Emacs'
loading of the dumped heap in a manner similar to HeapAgent. See the
discussion on HeapAgent above on how to work around this.
3. Aventail AutoSOCKS
Ditto with AutoSOCKS.
A number of users have
reported that Dr. Solomon's WinGuard prevent shell-related
commands from working properly within Emacs. Turning off "Scan all
files" makes it work, though.
A similar report from
Charles Curley <ccurley@wyoming.com>.
In some situations, Emacs performance can degrade. The following
sections discuss these situations, why they come about, and what you
can do about them.
In 19.34 the menu bar is updated more often than it needs to be,
and each update can be a time consuming process. If you are using a
single frame, you will likely not notice this behavior; if you are
using a number of frames, you might notice slow redisplay performance.
Currently the only way of fixing this is to turn menu-bar-mode off
(e.g., typing "M-x menu-bar-mode", or invoking (menu-bar-mode
nil)).
For more background, see Andrew's messages on the
topic.
The use of transient mark mode can trigger the slow menu bar
update performance described above. When the mark is set in transient
mark mode, the menu bar is updated after every keystroke and command.
Again, turning off menu-bar-mode is the only way to prevent the slow
performance without recompiling Emacs with patches.
Kim Storm <storm@olicom.dk> tracked down the bug in the core
redisplay code that causes the performance problem with
transient-mark-mode enabled. See the patches
section below for his patch.
Emacs initializes the variable "system-name" with the name of your
computer upon startup. However, Emacs uses two different methods for
determining the computer name depending upon whether Winsock is loaded
by default when Emacs starts up. If Winsock is automatically loaded,
then Emacs uses gethostname, otherwise Emacs uses
GetComputerName. Alternatively, you can override all of this
by explicitly setting system-name in your startup file (also
look at user-mail-address for composing mail messages).
By default, Emacs does not automatically load Winsock because
doing so will cause Winsock to establish a connection to the network.
If you are connected to a LAN, then nothing will happen, but if you
dialup to an ISP then invoking Emacs (thereby loading Winsock) will
prompt you to unexpectedly dialup to your ISP.
You can have Emacs automatically load Winsock by defining the
environment variable PRELOAD_WINSOCK. You can set it to an
arbitrary value; Emacs just checks to see if it is defined.
Similarly, you can create a registry entry PRELOAD_WINSOCK
with the other Emacs registry entries (in
HKEY_LOCAL_MACHINE\SOFTWARE\GNU\Emacs or
HKEY_CURRENT_USER\SOFTWARE\GNU\Emacs), which will do the same thing.
The reason for this is that Emacs now has networking support built in.
When Emacs starts, the winsock DLL automatically gets loaded and tries
to resolve the fully qualified domain name for your machine under the
name "localhost". If the system doesn't have this name mapped, it
will try to query a nameserver on the internet, which is typically
some host within your ISP and subsequently prompts to connect to your
dialup service so that it can ask a name server for the domain name of
your machine. As you know, this is very unfortunate, and was not
anticipated when the networking support was added.
This problem will be fixed when 19.32 comes out, but you can work
around the problem by giving the dialup support another method for
figuring out the domain name of your machine. To do this, you need to
edit the hosts file for your system (located in %windir%\hosts on
Win95 and %windir%\system32\drivers\etc\hosts on NT) so that localhost
becomes an alias for your machine name. If your system doesn't have a
hosts file yet, you can easily create one by copying the sample hosts
file in the same directory, hosts.sam.
For example, if my machine were named
banana-fish.cs.washington.edu, then I would edit the hosts
file from:
If this doesn't work for you, there are some other options (I have not
tried these):
For networking support, you can use the external nttcp.exe program. Download
nttcp.exe and place it in your Emacs bin directory. Also download
this version of tcp.el,
byte-compile it, and place it in your lisp directory. Then add the
following to your .emacs:
This is annoying, I know, and you shouldn't have to be dealing with
this. But please bear with me for now. If it isn't there already,
prepend "start" to the last line of the .bat file (the line that
invokes the emacs.exe executable). Then create a shortcut icon to the
emacs.bat file, and edit the Properties of the shortcut (right
click on the icon). On the Program tab, select Run: to
be Minimized and make sure the Close on exit checkbox is
checked. Double click on the icon, and Emacs should start up cleanly.
Because of the way Emacs currently tries to share the clipboard
with other Windows applications, you cannot cut and paste text with
null characters embedded in it. David Biesack
<sasdjb@unx.sas.com> describes a way to get around
this, at least for cutting and pasting text just within Emacs.
I just upgraded the operating system, and Emacs no longer works.
I have received reports that, after upgrading the operating system
(e.g., from NT 3.51 to NT 4.0), an installed Emacs will start but will
not accept keyboard or mouse input. Apparantly, running addpm.exe as
described in the installation section above
fixes the problem.
I use anti-virus software. What problems can this cause?
Some anti-virus software seems to interact badly with Emacs.
Dr. Solomon's
McAfee
Why does Emacs seem to perform slowly under certain conditions?
Menu bar updates
Transient mark mode
How does Emacs determine the name of my computer?
Why does Emacs ask me to connect to my dialup service when it starts up?
For some users, when Emacs starts up it pops up the dialog for
connecting to their dialup service, or sometimes appears to hang for a
few minutes and suddenly appear.
to
127.0.0.1 localhost
The hostname should be the value of invoking (system-name) in
the Emacs *scratch* buffer, i.e., the fully qualified domain name for
your system. Note that you may also have to tell the system to look
in the hosts file as well as using DNS.
127.0.0.1 banana-fish.cs.washington.edu localhost
(load-library "tcp")
(setq tcp-program-name "nttcp")
When I run Emacs, a console window pops up. How do I make it go away?
How do I cut & paste text with null characters?
How do I change the size, position, font, and
color attributes of Emacs?
Emacs can run in two different interface modes: the Windows interface,
which allows the flexible use and mixture of fonts and colors; and the
console interface, which constrains Emacs to the limitations of
console windows. The following two sections describe how to specify
and change the size, position, font, and color attributes of Emacs in
both interface modes. Windows Interface
To customize the size of specific frames, including the initial frame, see the section on customizing frames below.
emacs -g 80x40Note that the geometry command can be combined with the position command, as described below.
(set-frame-height (selected-frame) 40)
(set-frame-width (selected-frame) 80)
To customize the position of specific frames, including the initial frame, see the section on customizing frames below.
emacs -g +10+30To combine the size with position, first specify the size and then the position. The two examples above can be combined as follows:
emacs -g 80x40+10+30Note that you can also specify position offsets from any of the corners of the screen. See the GEOMETRY SPECIFICATIONS section of the X man page for complete details on the geometry command.
(set-frame-position (selected-frame) 10 30)
Fonts in Emacs are named using the standard X Windows format for fonts. For an explanation of what each element in a font string means and how Emacs on NT uses it, see Andrew's note.
These font names are the names that can be used as arguments on the command line or in lisp functions. To see the font name corresponding to a font chosen using the font selection dialog, execute the following elisp code in the *scratch* buffer:
(insert (prin1-to-string (win32-select-font))) ; Emacs 19 (insert (prin1-to-string (w32-select-font))) ; Emacs 20To see the complete list of fonts that Emacs has access to, execute the following elisp code in the *scratch* buffer:
(insert (prin1-to-string (x-list-fonts "*")))The font support currently is a little rough around the edges. In particular, italic fonts give Emacs some problems; see below for more info about using italic fonts. Generally it performs as expected, but occasionally you might get unexpected results (e.g., Emacs didn't quite use the font you told it to use). Work is underway to fix these problems, but for now I suggest experimenting if you encounter problems.
Also, X Windows has the luxury of a set of font aliases (such as fixed) that are convenient names for referring to specific fonts. Work is underway to provide an equivalent alias mechanism under Win32 so that naming fonts does not have to be as cumbersome as it currently is.
To customize fonts for specific frames, see the section on customizing frames below.
emacs -font "-*-Courier-normal-r-*-*-13-97-*-*-c-*-*-ansi-"
To set the font of a particular face, use the set-face-font function.(set-default-font "-*-Courier-normal-r-*-*-13-97-*-*-c-*-*-ansi-")
Value Name: Emacs.FontSince the font strings are rather cumbersome, I would suggest cutting the font string into the kill-ring (which will place it in the clipboard, too) and pasting it (Ctrl-V) into the regedit dialog. (Note that you shouldn't place quotes around the font string in the registry.)
Value Type: REG_SZ
String: -*-Courier-normal-r-*-*-13-97-*-*-c-*-*-ansi-
If you have Emacs frames with specific names, you can also specify a font for that frame. For the Value Name of the entry, use the name of the frame instead of Emacs (e.g., RMAIL.Font for your RMAIL frame).
As with other windowing attributes, Emacs uses the X Windows color names for specifying colors on the command line and in elisp. One set of these names is a set of abstract color names, e.g., red, green, and blue. These names are the ones you will typically use as arguments on the command line or in elisp functions. Emacs also supports the use of numeric color names; see the COLOR NAMES section of the X man page for complete details on how to specify numeric color names and their color spaces.
To see the abstract color names that Emacs understands and the colors that they map to, use the menu command Edit->Text Properties->Display Colors, or invoke the list-colors-display function in the *scratch* buffer:
(list-colors-display)If you would like to change the mapping of color names to RGB values, or to add new color names to Emacs, then you will want to modify the alist w32-color-map (win32-color-map in Emacs 19). To make changes, you can simply cons new mappings onto the head of the alist:
(setq win32-color-map (cons '("snow" . 16448255) win32-color-map)) ; Emacs 19 (setq w32-color-map (cons '("snow" . 16448255) w32-color-map)) ; Emacs 20The number in the element is the logical OR of three values for the red, green, and blue components: (B << 16 | G << 8 | R). In the example above, red is 255, green is 250, and blue is 250. At some point there will be support for reading in files with color mappings to make this process a little easier.
To customize colors for specific frames, see the section on customizing frames below.
To customize colors for color syntax highlighting, see the section on font-lock.
emacs -fg yellow -bg black
The following elisp changes the background color to black:
(set-background-color "black")The following elisp changes the mode line foreground to firebrick:
(set-face-foreground 'modeline "firebrick")The following elisp changes the cursor color to purple:
(set-cursor-color "purple")
Emacs uses two alists to determine the default appearances of frames, default-frame-alist and initial-frame-alist. The default-frame-alist variable sets the basic defaults of all frames. Since it is a common Emacs usage to have the initial frame have slightly different properties than other frames (e.g., its position), you can use the initial-frame-alist variable to override properties in default-frame-alist specially for the initial frame. You should definitely read the help text for these variables (C-h v) for more details on the differences between them and how they interact with each other.
Below is an example of using default-frame-alist and initial-frame-alist to configure the appearances of the initial frame and all other frames (you would place this code in your startup file). With default-frame-alist, we set the top left corner of new frames to be at pixel offset +200+400, the width and height to be 80x40, the cursor to be white, the foreground to be yellow, the background to be black, and the font to be Courier 10. With initial-frame-alist, we override the top left corner of the initial frame to be at pixel offset +10+30, and inherit the remaining properties for the initial frame from default-frame-alist.
(setq default-frame-alist
'((top . 200) (left . 400)
(width . 80) (height . 40)
(cursor-color . "white")
(cursor-type . box)
(foreground-color . "yellow")
(background-color . "black")
(font . "-*-Courier-normal-r-*-*-13-97-*-*-c-*-*-ansi-")))
(setq initial-frame-alist '((top . 10) (left . 30)))
You can use the functions x-display-pixel-width and x-display-pixel-height to determine the resolution of your screen. For example:
(and window-system
(setq screen-width (x-display-pixel-width)
screen-height (x-display-pixel-height)))
Emacs currently requires that italic versions of fonts have the same width as the normal version of the font. However, most of the default fonts have italic and italic bold versions whose character widths are larger than the normal version (the only default font that appears to have viable italic and bold versions is Courier New). Because of this, Emacs by default disables the use of italic faces.
You can still enable the use of italic faces with Emacs by setting the variable w32-enable-italics (win32-enable-italics in Emacs 19) to t in your startup file:
Although this works best with Courier New, there is still one minor glitch: the italics versions are one pixel higher than the other versions, so the line spacing is increased by a pixel when italics are enabled.(setq win32-enable-italics t) ; This must be done before font settings! (Emacs 19) (setq w32-enable-italics t) ; This must be done before font settings! (Emacs 20) (set-face-font 'italic "-*-Courier New-normal-i-*-*-11-82-c-*-*-ansi-") (set-face-font 'bold-italic "-*-Courier New-bold-i-*-*-11-82-c-*-*-ansi-")
Under NT, go to the upper left hand corner and open the "-" menu of the console window. Select "Screen Size and Position...", and use the dialog to set the window to the size you want. Be sure to check the "Save Window Size and Position" checkbox so that future invocations will retain the new window size. After closing the dialog box, resize the window itself by dragging on the edges.
Under Win95, click on the properties icon in the icon toolbar at the top of the window. Go to the "Screen" tab and select the desired window size in the "Usage" panel. Click on "OK".
To reposition Emacs, click on the title bar of the console window and drag it.
Under NT, open the "-" menu. Select "Fonts...", and use the dialog to set the window font to the one you want. Be sure to check the "Save Configuration" checkbox so that your font change will be used in future invocations. Click on "OK", and the window will get resized.
. Under Win95, simply use the popup font menu in the upper left-hand corner of the window. Or click on the font icon in the icon toolbar. Or click on the properties icon in the icon toolbar and go to the "Font" tab and choose the font that you want to use.
Under the NT interface, open the "-" menu. Select "Screen Colors...", and use the dialog to choose the colors you want to use for the window. Be sure to check the "Save Configuration" checkbox so that the colors are used in future invocations. Click on "OK". Unfortunately, the colors are not immediately used, but the changes have been made. To use the new colors, simply close the window and use the icon to start Emacs again. Emacs will then come up using the colors you chose before.
I'm not exactly sure how to change the colors on a per-console-window basis under Win95.
Older versions of Windows 95 had a bug where different filenames with a particular structure would wind up with the same short filename, and hence the different filenames would point to the same file on disk. For example, "foo.mak" and "foo.mak~" will map to the same file. Early versions of Emacs suffered from this bug, but later versions (19.34.1 and above at least) work around it.
However, disabling the registry entry HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\FileSystem\NameNumericTail in Windows 95/98 (by setting it to 0) will still cause these filename conflicts. According to Microsoft, this entry should never be set to 0 for Windows 95 and 98 (see MS KnowledgeBase articles Q148594 and Q179370), but if you must have it set to 0 then you should change how backup files are created. You can do this by setting the variable backup-by-copying to t in your startup file, or by redefining the function
Your startup file can be named either _emacs or .emacs, and should be placed in your "home" directory. If you have both files in your home directory, Emacs will load the .emacs file and ignore _emacs. Also, if you have a version of Emacs older than 19.31, Emacs will only recognize _emacs as the startup file.
Your home directory is where the HOME configuration variable tells Emacs it is. As with the other Emacs configuration variables, HOME can be set in a number of ways:
If Emacs cannot find HOME set in any of the above locations, it will assume your HOME directory is "C:/".
The directory specified by HOME is also the directory substituted for tildes (~) in file names used in Emacs (so, by definition, you can always load your startup file in Emacs by doing C-x C-f "~/.emacs").
Troubleshooting: If you've set HOME to a directory using one of the above methods, and Emacs still doesn't load your startup file, the first thing you should do is check to see what Emacs thinks HOME is set to. You can do this by evaluating the following expression in the *scratch* buffer using C-x C-e:
(insert (getenv "HOME"))
Look carefully at what is printed and make sure the value is valid. For example, if the value has trailing whitespace, Emacs won't be able to find the directory. Also, be sure that the value isn't a relative drive letter (e.g., "d:" without a backslash); if it is, then HOME is going to be whatever the current directory on that drive is, which is likely not what you want to happen.
Below is a list of sample .emacs files from various people. Eventually a single sample .emacs file will be shipped with the binary distributions, but until that happens you can browse these to see what people use already.
CapsLock and Control cannot be swapped from within Emacs, and Windows does not have a convenient mechanism like xmodmap to change virtual key bindings. Instead, new keyboard layouts or device drivers can be installed, or the registry can be modified, to swap the two keys.
WARNING: If you use a new keyboard layout to switch CapsLock and Control, beware of the option to use hotkey sequences to switch keyboard layouts. This option is in Control Panel->Keyboard under the Language (Win95) or Input Locales (NT) tabs; the sequences themselves are "Left Alt+Control" and "Ctrl+Shift". If you enable one of these options, then you will likely at some point switch keyboard layouts while trying to use an Emacs key combination.
NT 4.0:
Win95: Microsoft has placed a keyboard remapping program for Win95 on their ftp site (keyremap). For more info, take a look at their Kernel Toys page.
Mark Russinovich has also written a freeware VxD that swaps CapsLock and Control under Windows 95. (I've been told that you might have to hit the real Control key once after installing the VxD to jumpstart the mapping.)
To get tab file completion in cmd.exe, use regedt32 to set the following registry entry to 0x9 (using the Edit->DWORD menu command):
HKEY_CURRENT_USER\Software\Microsoft\Command Processor\CompletionChar
It has been reported that this feature can randomly crash cmd.exe on occasion.
Microsoft distributes a utility called Xmouse, part of a package of utilities called PowerToys, that lets you change the focus handling so that the focus follows the mouse. The PowerToys package can be found at http://www.microsoft.com/windows/software/powertoy.htm.
Note that not all of these utilities written on Windows 95 work on NT; reportedly, if you are on NT 4.0 you have to use the TweakUI utility to enable follow focus. Also, if you use TweakUI, reportedly it is best to set the popup delay to 0ms for focus follow to work well with Emacs.
For more info, you can flip through a collection of email messages discussing these utilities.
2) Registry
Steve Yegge <stevey@geoworks.com> reports that there is an NT registry setting that enables mouse tracking (it's unknown whether this works on versions less than 4.0). Set the following key to 0x1:
Steve also says:HKEY_CURRENT_USER\Control Panel\Mouse\ActiveWindowTracking: 0x1
The two "bugs" I've found are:
- some applications (notably Netscape and Microsoft Developer
Studio) autoraise when they get the focus.
- the mouse doesn't move into the new window when you use
alt+TAB switching, so if a vibration bumps the mouse, you
may suddenly find yourself typing in the wrong window.
Some behaviors typically found in other Windows apps, such as deleting typed-over highlighted selections, are not configured by default in Emacs. You can, however, enable them by loading various packages. If you would like to highlight the region between the point and the mark, see the help text for transient-mark-mode; if you would like highlighted selections to be deleted when you type over them, see the help text for delete-selection-mode; if you would like to change the semantics of keypad keys such as "home" and "end", see the help text for pc-selection-mode.
Theodore Jump <tjump@spgs.com> has written a utility called EMWINMSG that enables elisp code to invoke a window operation on an Emacs frame (via the Windows API routine "ShowWindow"):
If you are used to standard Windows application keybindings, such as C-c for copy, C-v for paste, and C-x for cut, or selecting text with <shift>-movement, then you probably want to use Kim Storm's <storm@olicom.dk> CUA-mode.el.
Binu Jose Philip <binu@teil.soft.net> has written the dlgopen package to use the Windows Open File dialog box for opening files. Download dlgopen.zip, unpack, and read the top of the dlgopen.el file for directions on using the package.
Although it may at first seem like the shell is buffering the output from the program, it is actually the program that is buffering output. The C runtime typically decides how to buffer output based upon whether stdout is bound to a handle to a console window or not. If bound to a console window, output is buffered line by line; if bound to a block device, such as a file, output is buffered block by block.
In a shell buffer, stdout is a pipe handle and so is buffered in blocks. If you would like the buffering behavior of your program to behave differently, the program itself is going to have to be changed; you can use setbuf and setvbuf to manipulate the buffering semantics.
Andrew Innes is working on removing this limitation. If all goes well, it should be available in 19.35.
If you are finding that running 16-bit programs as subprocesses cause your A: drive to be accessed (hanging Emacs until a timeout occurs if no floppy is in the drive), check to see if you have McAfee Virus Shield installed. Users have found that disabling Virus Shield causes the problem to go away. Also, if you have a better fix for this problem, let me know or send mail to the list.
A followup from Bill Carpenter <bill@bubblegum.net>.
Emacs cannot guarantee that a subprocess gets killed on Win95/98, and is a difficult limitation to work around. For the forseeable future, you should always let subprocesses run to completion.
19.34.4 Previously, Ctrl-C would generate a CTRL_BREAK_EVENT (SIGQUIT) in subprocesses. Now Ctrl-C generates a CTRL_C_EVENT (SIGINT). This behavior is more accurate, but may still causes problems; see Andrew's note.
19.34.1 For applications that handle Ctrl-C and Ctrl-Break events, you might notice that typing Ctrl-C in Emacs when those applications are run as subprocesses does not trigger their Ctrl-C handlers but instead triggers the Ctrl-Break handlers. Here is what is going on. Emacs in general tries to interrupt subprocesses using Unix-style kill and SIGINT. Ideally, on Win32 the kill emulation code can translate the SIGINT into a GenerateConsoleCtrlEvent with a CTRL_C_EVENT. However, doing so does not seem to propagate the CTRL_C_EVENT to the subprocess; as far as I can tell, nothing happens. So, instead of using a CTRL_C_EVENT for SIGINT, the emulation code uses a CTRL_BREAK_EVENT, which is propagated correctly to subprocesses.
If you need to handle Ctrl-C events propagated from Emacs, you'll need to use a Ctrl-Break handler for now. Andrew describes how all of this going to be handled in the future.
If you would like to specify a different shell for Emacs to use, then you should do one of two things. You should either explicitly set the environment variable SHELL to be the shell you want to use, or, if you want to have the COMSPEC environment variable determine the shell, then you need to install Emacs using the addpm.exe program and ensure that the SHELL environment variable is not defined when you start up Emacs.
Note that sh-script.el does not recognize shell names when they have the '.exe' extension on them. If you use sh-script, you should omit the '.exe' extension when specifying the SHELL variable.
Alternatively, if you do not want to mess with the SHELL or COMSPEC variables, you can explicitly place the following in your startup file:
;; For the interactive shell (setq explicit-shell-file-name "c:/bin/tcsh.exe") ;; For subprocesses invoked via the shell (e.g., "shell -c command") (setq shell-file-name "c:/bin/tcsh.exe")
You can get a version of bash with the Cygnus tools at http://www.cygnus.com/misc/gnu-win32. To use bash with Emacs, place the following in your startup file:
Emacs 19.34
(setq win32-quote-process-args ?\")
(setq shell-command-switch "-c")
(load "comint")
(fset 'original-comint-exec-1 (symbol-function 'comint-exec-1))
(defun comint-exec-1 (name buffer command switches)
(let ((binary-process-input t)
(binary-process-output nil))
(original-comint-exec-1 name buffer command switches)))
Emacs 20
(defun my-shell-setup ()
"For bash (cygwin 18) under Emacs 20"
(setq comint-scroll-show-maximum-output 'this)
(setq comint-completion-addsuffix t)
(setq comint-process-echoes t)
(setq comint-eol-on-send t)
(setq w32-quote-process-args ?\")
(make-variable-buffer-local 'comint-completion-addsuffix))
(setq shell-mode-hook 'my-shell-setup)
(setq process-coding-system-alist (cons '("bash" . raw-text-unix)
process-coding-system-alist))
Richard M. Heiberger's <rmh@fisher.stat.temple.edu> setup for Cygnus B19.
For more configuration information with bash, take a look at Jonathan Payne's <jpayne@marimba.com> setup.
WARNING:The latest version of bash sets and uses the environment variable PID. For some as yet unknown reason, if PID is set and Emacs passes it on to bash subshells, bash croaks (Emacs can inherit the PID variable if it's started from a bash shell). If you clear the PID variable in your startup file, you should be able to continue to use bash as your subshell: (12/18/97)
(setenv "PID" nil)
For a version of ksh by David Korn, take a look at http://www.research.att.com/sw/tools/uwin. I haven't tried this shell with Emacs, but I'm guessing that it works under Emacs and that you need the following for it to work properly:
(setq win32-quote-process-args t) ; Emacs 19 (setq w32-quote-process-args t) ; Emacs 20 (setq shell-command-switch "-c")
If you find out otherwise, let me know and I'll update this section.
WARNING: People have reported that UWIN 1.5 ksh doesn't work with Emacs. I do not know why yet. If you figure out why, please send mail to the list.
(setq win32-quote-process-args t) ; Emacs 19 (setq w32-quote-process-args t) ; Emacs 20 (setq shell-command-switch "-c")
You can find tcsh at ftp://ftp.blarg.net/users/amol/tcsh. To use tcsh, place the following in your startup file:
For more configuration information with tcsh, take a look at Chris McMahan's <cmcmahan@surefirev.com> setup.(setenv "SHELL" "tcsh.exe") (setq win32-quote-process-args t) ; Emacs 19 (setq w32-quote-process-args t) ; Emacs 20 (setq shell-command-switch "-cf")
You can find zsh at ftp://ftp.blarg.net/users/amol/zsh/
Apparently the sh-script package isn't finding the shell program correctly. Peter Breton <pbreton@i-kinetics.com> says that adding a call to sh-set-shell in sh-mode-hook will fix the problem:
(add-hook 'sh-mode-hook
(defun my-sh-mode-hook-set-shell ()
;; Use whatever shell is most appropriate, it doesn't matter
;; if the actual /bin/ksh file exists on the system or not
(sh-set-shell "/bin/ksh")))
(add-hook 'comint-output-filter-functions 'shell-strip-ctrl-m nil t)
To prevent echoed commands from being printed, you can place the following in your startup file:
If shell-mode still is not stripping echoed commands, then you'll have to explicitly tell the shell to not echo commands. You can do this by setting the explicit-SHELL-args variable appropriately, where SHELL is the value of your shell environment variable (do a "M-: (getenv "SHELL")" to see what it is currently set to). Assuming that you are on NT and that your SHELL environment variable is set to cmd.exe, then placing the following in your startup file will tell cmd.exe to not echo commands:(defun my-comint-init () (setq comint-process-echoes t)) (add-hook 'comint-mode-hook 'my-comint-init)
(setq explicit-cmd.exe-args '("/q"))
Note that this variable is case sensitive; if the value of your SHELL environment variable is CMD.EXE instead, then this variable needs to be named explicit-CMD.EXE-args instead.
The character appended to directory names when completing in shell-mode is determined by the value of the variable comint-completion-addsuffix. If the value of this variable it t, then a '/' is appended to directory names. If the value of this variable is a cons pair, then the first value of the pair is appended.
In 19.34, lisp\winnt.el initializes comint-completion-addsuffix to the cons pair '("\\" . " ") using shell-mode-hook. This means that, by default, a "\" is appended to directory names during completion in shell mode. To override this behavior, you need to change the value of comint-completion-addsuffix. You can do this by resetting it in your startup file to t or by explicitly setting it to a cons pair with "/" in it:
(add-hook 'shell-mode-hook
'(lambda () (setq comint-completion-addsuffix '("/" . "")))
t)
(add-hook 'shell-mode-hook
'(lambda () (setq comint-completion-addsuffix t))
t)
In 19.35, the default will be to append "/". If Emacs detects that you are using command.com or cmd.exe, then it will it use "\" instead.
Multiple lines for each shell are given since variable names are case sensitive and shell names can be any case (so this only handles the most common situations). If you have an entirely different shell that also complains about being given the "-i" switch, you can initialize a similarly named variable to prevent the "-i" switch from being sent to the shell.(setq explicit-command.com-args nil) (setq explicit-COMMAND.COM-args nil) (setq explicit-cmd.exe-args nil) (setq explicit-CMD.EXE-args nil)
Note that, if you would like to always pass arguments to an interactive shell when it starts up, you would change the nil value in the appropriate assignment above to the list of arguments you would like to use with your shell. For example, if you would like to invoke command.com and tell it which directory its executable resides, you could place something like the following in your startup file:
;; Determine the directory containing the shell program, explicitly making ;; certain that the directory separator is a backslash when doing so. (let ((directory-sep-char ?\\)) (setq shell-directory (file-name-directory (getenv "SHELL")))) (setq explicit-command.com-args (list shell-directory)) (setq explicit-COMMAND.COM-args (list shell-directory))
The fix for this is to either prevent any arguments from being sent to the shell when it starts up (in which case command.com will use a default, and correct, value for COMSPEC), or to have the first argument be the directory in which the shell executable resides. Examples of how to do both of these are in shown in the previous subsection.
Chris Boucher <chris@sorted.org> reports that Dr. Solomon's WinGuard prevents any shell related commands from working. He found that turning off "Scan all files" makes it work, though.
I've only tested the outgoing and incoming RMAIL setups. If you find that the suggested code for any of the other incoming mail configurations is inaccurate, please let me know.
(setq user-full-name "Your full name") (setq user-mail-address "Your email address") (setq smtpmail-default-smtp-server "Domain name of machine with SMTP server") (setq smtpmail-local-domain nil) (setq send-mail-function 'smtpmail-send-it) (load-library "smtpmail")
Note that if you want to change the name of the smtp server after you've loaded smtpmail.el, you'll want to change the variable smtpmail-smtp-server.
If you are using GNUS to send mail, then you will also need:
If you are experiencing problems with sending large messages, check the value of the variable smtpmail-debug-info. If it is non-nil, you should set it to nil:(load-library "message") (setq message-send-mail-function 'smtpmail-send-it)
(setq smtpmail-debug-info nil)
If you would like to queue your outgoing mail so that you can then later send it all as a batch (e.g., when you are working disconnected on a laptop>
Feedmail comes with Emacs 20. If you're using 19.34, download the package from Bill's site, byte-compile it, and place it in your load path. You'll then need to customize it in your startup file; see Bill's setup for one example.
Fabio Somenzi <Fabio@Colorado.EDU> also sent the following as an example:
(setq send-mail-function 'feedmail-send-it) (autoload 'feedmail-send-it "feedmail") (autoload 'feedmail-run-the-queue "feedmail") (setq feedmail-buffer-eating-function 'feedmail-buffer-to-smtpmail) (setq feedmail-enable-queue t) ; optional (setq feedmail-queue-chatty nil) ; optional
Fabio also redefined the function make-auto-save-file-name to auto-save files in one local directory ($HOME/.save) and to strip out invalid characters in file names (this bug should be fixed in 19.35). Note that all files will auto-save to this directory; this allows Emacs to auto-save even when the folder files are on an inaccessible remote machine. Place the following definition of make-auto-save-file-name in your startup file to override the definition in winnt.el.
Lastly, if you would like to protect the primary folder from crashes while it is being written back to disk, then also place the following in your startup file (assuming you use VM):
(add-hook 'vm-mode-hook
'(lambda ()
(make-local-variable 'file-precious-flag)
(setq file-precious-flag t)))
(setenv "MAILHOST" "Domain name of machine with POP3 server")
(setq rmail-primary-inbox-list '("po:Your login") rmail-pop-password-required t)
(setq vm-spool-files
(list
(list "~/INBOX"
"POP3 server:110:pass:POP user name:*"
"~/INBOX.CRASH")))
Be sure to customize the POP user name field appropriately.(load-library "message") ;; For sending mail (setq message-send-mail-function 'smtpmail-send-it) ;; For reading mail (other backends can be substituted for nnml) (setq gnus-secondary-select-methods '((nnml ""))) (setq nnmail-spool-file "po:POP user name") (setq nnmail-pop-password-required t)
If you want to share your rmail folders between Unix and NT/95, you'll want to handle all your mail in binary format. This includes mail stored in folders as well as incoming mail. For mail stored in folders, you'll want to treat the directory in which you store your mail as an untranslated file system; see the section on translation below on how to do this.
For incoming mail using RMAIL, you'll need to make a small patch to rmail.el. See Don Erway's <derway@ndc.com> message describing the patch and what else he did to setup sharing between Unix and NT/95.
Mail packages often provide some way to notify you when email has arrived (a la "biff" in Unix), conveniently distracting you from getting any real work done. There are myriad ways to do this, and as people tell me them I will try to mention them here.
Franklin Lee <flee@lehman.COM> has extended the pop3 package so that you can have your mail left on the server instead of always being downloaded (it also has a biff-mode with international "barks", which can be used whether or not you download or leave your mail on the server). You'll need to download a zip archive containing a patched pop3.el and some additional elisp files:
If you unpack on Unix, be sure to use "unzip -a" to strip any carriage returns.
For instructions on how to install and configure this package so that you can leave your mail on your pop3 servers, see the instructions at the top of the epop3mail.el file.
This should potentially work with other mail packages that rely upon the pop3 elisp code. If you find that it does, or implement the glue necessary to make it work, let me know and I'll update this FAQ entry.
John Dennis <jdennis@ultranet.com> has ported Metamail, a package that allows you to receive and send MIME attachments using Emacs. For details, see John's README file:
The latest version of VM works around the problems in vm-pop, but smtpmail requires a small patch. If you are encountering similar problems, then you should modify the end of smtpmail-via-smtp in smtpmail.el as follows:
;(delete-process process)
(run-at-time 3 nil 'delete-process process))))))
To read news with Emacs, you can use the Gnus package. To invoke Gnus, type "M-x gnus" and Emacs will prompt you for a news server to connect to. For more information about using Gnus, take a look at:
For more discussion and other methods of giving Gnus a password, see a discussion on the topic.(add-hook 'nntp-server-opened-hook 'nntp-send-authinfo)
See the "What other packages work with Gnus?" question of the Gnus FAQ.
To save messages untranslated (no carriage returns), you must set the default-buffer-file-type to binary:
(setq default-buffer-file-type t)
David Finucane <finucane@myri.com> has written an elisp/Java package that makes it easy to read online newspapers through Emacs:
(Note: If you use anti-virus software, see the warnings above.)
MiKTeX is a native Win32 implementation of the TeX document processing system. The MiKTeX project page is at http://www.snafu.de/~cschenk/miktex. The project page has instructions on where to download the distribution and how to install it.
AUCTeX is a package for writing LaTeX files in Emacs. The AUCTeX project page is at http://sunsite.auc.dk/auctex, and has links for downloading the distribution and reading the manual. Lars Schmidt-Thieme <lschmidt@ix.urz.uni-heidelberg.de> has written instructions on how to use AucTex with MikTex and Emacs.
Willem Minten <Willem.Minten@esat.kuleuven.ac.be> has put together a page that has everything you need to get MiKTex, AucTeX, and Emacs working together. If you're starting from scratch, look here first.
David Finucane <finucane@myri.com> has written an elisp/Java package that uses the AltaVista translation service to translate text among a number of languages.
Jari Aalto <jari.aalto@poboxes.com> is porting PGP from Unix to NT as a package called TinyPgp for use with Emacs on NT:
Feel free to send bug reports to Jari or to the ntemacs-users list. Also, if you would like to get updates directly from Jari, let Jari know that you are using TinyPgp by sending him email.
For a close coupling of Emacs and MSVC, Christopher Payne <payneca@sagian.com> wrote a Visual Studio add-in that makes Emacs the default text editor. See his page for more info on what it can do and how it works. For information on how to customize your general development environment to use Emacs with MSVC, read Charles Curley's text below. For VisEmacs alpha executables, download this VisEmacs.zip distribution.
Written by Charles Curley with a lot of help from: David Biesack, Caleb T. Deupree, John Huxoll Gardner, Anders Lindgren, and John Yates.
This is an app note on how to use Microsoft Visual C++ with Emacs. The experiments done below were done with Emacs 19.34.1 on Windows 95, using Visual C++ 4.0 Standard Edition. Your mileage may vary.
This writeup assumes minimal knowledge of Emacs hacking on the part of the reader.
rem set up for MS C++ 4.0 call d:\msdevstd\bin\vcvars32.batUnder NT, you can set the HOME and other environment variables in the System applet of the Control Panel.
John Huxoll Gardner writes that
These environment variables can be set through the control panel. Control Panel->System->Environment tab set include to d:\msdev\include;d:\msdev\mfc\include (or whatever) set lib to d:\msdev\lib;d:\msdev\mfc\lib (or whatever) set MSDevDir to d:\msdevYou should now be able to compile from Emacs. Load a source file from a VC++ project. Type M-X compile. Replace the proposed command line with:
nmake -f MyProject.makYou will find that this defaults to a win 32 debug build. You can change it to a release build