1.0 Description

License: This material may be distributed only subject to
the terms and conditions set forth in GNU General Public
License v2 or later; or, at your option, distributed under the
terms of GNU Free Documentation License version 1.2 or later
(GNU FDL).

In this page you may find both free and unfree products,
documentation, binaries and packages that could help learn to take
full advantage of Emacs. This page is part of Tiny Tools
documentation and you can use package tinytf.el to read text
version of this document. The HTML is generated from plain text
file with Perl program available at
<http://perl-text2html.sourceforge.net/>.

Paul Smith comments: ...I suggest you move to gnuserv. It is much
better than the one that comes with Emacs. Gnuclient brings up a
file in a new frame. Also it includes a "gnudoit" app which
executes arbitrary elisp on the Emacs server, allowing things like
window manager buttons that invoke Gnus or VM (or RMAIL or
whatever), etc.

ProgramminginEmacsLisp - Elisp introduction. (by
Robert J. Chassell <bob AT rattlesnake.com> lisp-intro-1.xx)
...This is an elementary introduction to programming in Emacs
Lisp for people who are not programmers, and who are not
necessarily interested in programming, but who do want to
customize or extend their computing environment.
HTML format on-line at
http://www.delorie.com/gnu/docs/emacs-lisp-intro/

NguyenThien-Thi's Emacs tutorial
http://www.glug.org/people/ttn/software/elisp-tutorial/ This
directory contains a simple elisp tutorial, presented in
several lessons. After going through the lessons, you should be
familiar enough with Emacs Lisp to read and write elisp
programs of moderate complexity, and to continue your studies
independently.

2.2 Other Lisp related documents and resources

"Paradigms of Artificial Intelligence Programming: Case Studies
in Common Lisp" by Peter Norvigis. This book is highly
recommended if you write or consider writing Emacs lisp
programs. http://www.norvig.com/paip.html A book published by
Morgan Kaufmann, Paperbound, xxviii, 946 pages.

"On LISP: Advanced Techniques for Common LISP " by Paul Graham
(Out of print) is another highly regarded book. See amazon.com
if you can buy a used copy. May still have copies, try also
<http://www.abebooks.com> and <http://www.bibliofind.com>.

[Reginald S. Perry <perry AT zso.dec.com>, XEmacs-L 1998-07-02]
Clisp is a GPLed implementation of Common Lisp. Its flavor
is that it has a CLTL1(Commom Lisp, the Language Vol. 1) feel but
they have implemented a large portion of the passed votes in CLTL2
so they are sort of ANSI. There are a couple of cool things about
Clisp. First its executable size and memory footprint is
surprisingly small for a full-blown lisp implementation....Clisp may
be a good portable solution for people who don't have access to Unix
to run CMUCL, Linux to run Allegro CL, don't have the cash to get
Commom Lisp on Windows or want to use a CL based XEmacs but is
running on OS/2 or some other system that commercial lisp vendors
wont port their wares to.

Common Lisp Hyper Spec
<http://www.lispworks.com/documentation/HyperSpec/> Harlequin
presents the Common Lisp HyperSpec (tm), an HTML document
derived (with permission from ANSI and X3) from the ANSI
Common Lisp standard (X3.226-1994). In hard copy, the ANSI
Common Lisp standard is nearly 1100 printed pages describing
nearly a thousand functions and variables in sufficient detail
to accommodate hosting of the language on a wide variety of
hardware and operating system platforms. While the paper
version remains the official standard, we think that as a
matter of practice you'll find the Common Lisp HyperSpec much
easier to navigate and use than its paper alternative.

3.1 Emacs or XEmacs future plans

There has been talk on making let to work like in modern
languages, i.e. binding variables locally(lexical scoping),
and converting to Common Lisp, possibly replacing Elisp
altogether. It's big a task and won't happen soon, but it is
on the sketch board.
<http://www.xemacs.org/Architecting-XEmacs/index.html>

Article by Denis Havlik published under mandrakeforum.com
Quotes used by permission of Denis. This article no longer exits,
due to Mndrake relabelled as Mandriva.

"First part of the speech was "why did I start GNU project" info.
Official RMS biography only says: Stallman graduated from Harvard
in 1974 with a BA in physics. During his college years, he also
worked as a staff hacker at the MIT Artificial Intelligence Lab,
learning operating system development by doing it. He wrote the
first extensible Emacs text editor there in 1975. In January 1984
he resigned from MIT to start the GNU Project. Without stating
the REASON why he left the MIT lab and started GNU project."

"When Richard M. Stallman started his programmers career, world
of programming was much different from what it looks like today:
back then, ND-agreements and shrink-wrap licenses simply didn't
exist, and sharing code was considered normal behavior. Then
someone came to idea that he can make a lot of money by NOT
sharing the source code, and started the avalanche which
ultimately led to Single-click patent and UCITA. The form in
which RMS first encountered this brave new world for the first
time was somewhat bizarre: Xerox donated a laser printer to the
MIT lab he worked in, and this printer was controlled by
proprietary software. This printer was great, but it often
jammed, and "no source" meant that they had no way of
implementing the "printer jammed" warning as they did for other
printers, used in the lab. As you can imagine, walking up and
down or camping next to printer turned out into a somewhat
annoying experience... Worse yet, some time later, Stallman
actually met a college which had source code of printer
controlling software, and refused to share it because he signed
the NDA! Instead of accepting this bizarre situation as "normal",
RMS turned around, quit the job at MIT and started the GNU
project. (the rest is a history)"

Biography of Guy Steele who designed the original Emacs
Guy is also the author of book "Common Lisp the Language, 2nd
Edition". The bio used to be located at
http://www.cs.utah.edu/dept/organick/past/GLSbio.htm and the current
location unknown, so the text has been copied here.

AboutGuyL.SteeleJr. Guy L. Steele Jr. is a
Distinguished Engineer at Sun Microsystems, Inc. He received his
A.B. in applied mathematics from Harvard College (1975), and his
S.M. and Ph.D. in computer science and artificial intelligence from
M.I.T. (1977 and 1980). He has also been an assistant professor of
computer science at Carnegie-Mellon University; a member of
technical staff at Tartan Laboratories in Pittsburgh, Pennsylvania;
and a senior scientist at Thinking Machines Corporation. He joined
Sun Microsystems in 1994.

He is author or co-author of five books: Common Lisp: The Language
(Digital Press); C: A Reference Manual (Prentice-Hall); The
Hacker's Dictionary (Harper & Row), which has been revised as The
New Hacker's Dictionary, edited by Eric Raymond with introduction
and illustrations by Guy Steele (MIT Press); The High Performance
Fortran Handbook (MIT Press); and The Java Language Specification
(Addison-Wesley).

He has published more than two dozen papers on the subject of the
Lisp language and Lisp implementation, including a series with
Gerald Jay Sussman that defined the Scheme dialect of Lisp. One of
these, "Multiprocessing Compactifying Garbage Collection," won
first place in the ACM 1975 George E. Forsythe Student Paper
Competition. Other papers published in Communications of the ACM
are "Design of a LISP-Based Microprocessor" with Gerald Jay Sussman
(November 1980) and "Data Parallel Algorithms" with W. Daniel
Hillis (December 1986). He has also published papers on other
subjects, including compilers, parallel processing, and constraint
languages. One song he composed has been published in CACM ("The
Telnet Song", April 1984).

The Association for Computing Machinery awarded him the 1988 Grace
Murray Hopper Award and named him an ACM Fellow in 1994. He was
elected a Fellow of the American Association for Artificial
Intelligence in 1990. He led the team that received a 1990 Gordon
Bell Prize honorable mention for achieving the fastest speed to
that date for a production application: 14.182 Gigaflops. He was
also awarded the 1996 ACM SIGPLAN Programming Languages Achievement
Award.

He has served on accredited standards committees X3J11 (C language)
and X3J3 (Fortran) and is currently chairman of X3J13 (Common
Lisp). He was also a member of the IEEE committee that produced the
IEEE Standard for the Scheme Programming Language, IEEE Std
1178-1990. He represents Sun Microsystems in the High Performance
Fortran Forum, which produced the High Performance Fortran
specification in May, 1993.

He has served on Ph.D. thesis committees for eight students. He has
served as program chair for the 1984 ACM Lisp Conference and for
the 15th ACM POPL conference (1988) and 23rd ACM POPL conference
(1996); he also served on program committees for 30 other
conferences. He served a five-year term on the ACM Turing Award
committee, chairing it in 1990. He served a five-year term on the
ACM Grace Murray Hopper Award committee, chairing it in 1992.

He has had chess problems published in Chess Life and Review and is
a Life Member of the United States Chess Federation. He has sung in
the bass section of the MIT Choral Society (John Oliver, conductor)
and the Masterworks Chorale (Allen Lannom, conductor) as well as in
choruses with the Pittsburgh Symphony Orchestra at Great Woods
(Michael Tilson Thomas, conductor) and with the Boston Concert
Opera (David Stockton, conductor). He has played the role of Lun
Tha in The King and I and the title role in Li'l Abner.

He designed the original EMACS command set and was the first
person to port TeX.

At Sun Microsystems he is responsible for research in language
design and implementation strategies, and architectural and
software support, and for the specification of the Java programming
language.

... GFDL'ed documentation with a GPL'ed program means that moving
stuff between the documentation and the program is possible only
for the copyright holder. This is tedious in the extreme when the
program or documentation has multiple copyright holders. Note that
there are multiple copyright holders whenever more than one person
contributes creative material of more than about 15 lines, unless
one of them is employing all the others (work-for-hire), or they
signed written, paper copyright assignments. GFDL/GPL
dual-licensing would be a good thing for that reason. --Nathanael
Nerode 2004-09-22
<http://lists.debian.org/debian-legal/2004/09/msg00451.html>

The GNU FDL is considered by Debian to be a non-free license
because of the part that contains "invariant sections" whereby you
can make a section non-changeable. See "Draft Debian Position
Statement about the GNU Free Documentation License(GFDL)" by Manoj
Srivastava
<http://people.debian.org/~srivasta/Position_Statement.html>

4.3 Emacs Jokes

4.3.1 The Word Emacs

In the early days, when memory was tight and machines slow people
got upset how much memory Emacs used. And it still uses all the
memory it can get if you use GNUS with unlimited cache setting. You
heard this a lot back then. And no wonder Emacs uses so many key
combinations, because Emacs is actually.... [this is from Gnus
manual...] What the word in reality means, is explained in the
Emacs FAQ. See also the Emacs distribution and file etc/JOKES.

With sufficient Emacs training, you will gain access to command:
M-x write-thesis RET

Err... I cannot find that in the manual... What does this command
do when invoked with a prefix argument? I am also confused about
the implementation of this command. How is the interaction
between the supervisor and student simulated in lisp? And what
function does emacs use to emulate extracting that last chapter
before the deadline from the student, and the student getting the
supervisor to actually read the damn thing. I tried an apropos
search for "thesis-blood-from-stone" but got nothing....

Without a prefix argument, it writes a master's thesis. You get a
PhD thesis when you invoke it with a prefix argument, and as far as
I recall, the quality of the resulting work can somehow be tuned by
using numeric arguments. However, to avoid flooding the libraries
on earth, I have heard that the command can only be invoked exactly
once per user.

Yes. You can imagine my dismay when I accidentally typed M-xwrite-thesisRET rather than the intended M-xwrite-the-sisRET. Perhaps when 21 is released I will get another shot. It is
simply crushing to think I may have to write a thesis the
old-fashioned way.

Don't just whine about it here! Submit a bug report with M-x
report-emacs-bug RET If you find some point of the documentation
lacking or unclear. How do you expect the Emacs documentation ever
to improve if the users are too lazy to even report the bugs and
deficits they encounter? Sheesh, kids these days, they expect
everything to be prepared for them, and have no sense of giving
back! When I was young, we didn't ask what Emacs could do for us.
We asked what we could do for Emacs. Kids of today could learn *a
lot* from that!

What does the command do if you call it programmatically?

Writes multiple theses, of course. What did you expect? Please read
tutorial (type C-ht) before bothering with such elementary
questions. Each message costs the net hundreds if not thousands of
dollars.

(Poor fellow replied...) And you there, yes, you man. Don't attempt
to answer a question when you obviously haven't a clue. Maybe you
"tested" the command, and it did as you said, but that is just an
accident. The type of thesis generated depends on 1) the previous
generated thesis1, and 2) an examination of the content of all
the files the user have opened with Emacs2. It is not like the
command is magic or anything.

Footnotes: [1] So if the previous generated thesis was a
Master Thesis, the next will default to a PhD. Thesis. [2] So use
W3 to read as many relevant online articles as possible, before
invoking the command. And don't browse for porn unless that is
what you want to graduate in.

What a stupid user interface. Maybe you elders were content with
something like that, but it is certainly not the type of thing
users would expect in the 21st century. I bow before the
enormous wisdom that must have gone into M-x write-thesis, but
we need to find a way to use it effectively.

What if I need to write multiple Master's Theses before embarking
on my first PhD? And what if I write multiple PhD theses, and
then again, a Master's Thesis to qualify for yet another PhD?
Clearly, these possibilities weren't considered at all when
designing the user interface of M-x write-thesis; you elders were
content with that simplistic default mode (and DON'T tell me that
I just need to hack a few lisp expressions to get what I want.
I'm not attempting to write a PhD about EMACS, and besides I've
got other things to do than spending hours or even days for
writing a thesis!).

When Emacs prompt you with: Thesis level (default Master):
press TAB to see a list of available choices, then type the name
of the one you prefer. You can use TAB to complete the answer
after typing a unique prefix, or (I know you young ones love this)
choose an answer by clicking the middle button while the mouse
pointer is above the answer in the Completions buffer. If you
don't have a mouse and are afraid to type, you can even switch to
the Completions buffer, move the cursor to the answer, and press
RET to select it. Isn't that amazing!

I don't see how using the prefix argument to write multiple
theses makes any sense at all. By what do these theses differ,
then? They are all based on the currently loaded buffers, no? So
am I supposed to actually READ them and find out which I like
most or what?

And what if I write multiple PhD theses, and then again, a
Master's Thesis to qualify for yet another PhD?
I suggest using the prefix argument to distinguish between a
Master's Thesis and a PhD Thesis, period. Very simple, very easy
to understand. Just a pity that this change won't make it into
Emacs 21.1 anymore, as we're already too late in the pretest.

This would make it inconsistent with self-insert-command. Or do
you propose that self-insert-command should be modified as well,
so the prefix argument changes the inserted character? I can see it
now, C-u2i inserts k, C-u-2i inserts g.
Anotherchoice: Switch to XEmacs, and you'll have it. The
code has been written since Emacs 18.62, but GNU refused to accept
it because M-xwrite-thesis won't print the standard GPL blurb
before the thesis and the assignment paper after it...

I wonder how do I choose between *roff and LaTeX as the thesis
format? Hm. [time passes] Ah, see the variable
write-thesis-format.

Just a warning, it doesn't work if you set it directly. Either call
set-thesis-format from your .emacs, or set the variable with
Customize.

[Q1] All this stuff seems to be very complicated to a beginner like
me. Anybody can send me some code to put a easily accessible menu
option to write my thesis? I don't see the point in spend time
learning new key-combos and writing things only to write my
thesis. Just two mouse clicks should be enough (or one, with the
new buttons of the GNU Emacs 21).

[Q2] I remember a neat hack floating around that allowed you to
specify the subject with a prefix argument, in case you've
browsed too much crappy sites.

Prefix argument... sigh. Not me, but the standard thesis
package has thesis-ignored-buffers, which is a regexp of buffer
names that will be ignored when writing the thesis. People,
please read the documentation before you bother poking
around so powerfull editor as Emacs. It may accidentally shut
down your local area's power grid if you press wrong key
sequences (and don't try that at home!).

In the download site, barebin has just the .exe's and a few other
files, and is only useful in conjunction with the "src" tarball.
This gives you the full source to everything, if you happen to want
that. bin is usable by itself, but doesn't include the elisp
source (that is provided by the "lisp" tarball). If you know you
want the elisp source, you can just get "fullbin", which is
basically "bin+lisp". leim is the Library of Emacs Input Methods,
which is only of interest if you want to enter non-ascii characters
in a convenient way. Emacs DOS port is (was?) maintained by Eli
Zaretskii. See "NT Emacs Installation"
<http://www.charlescurley.com/emacs.html> if the Emacs NT FAQ
is too thick to for one coming from Windows background.

5.2 Win32 XEmacs ports

There are two versions of XEmacs available for Windows platform. A
Cygwin version, which is more like the "real thing" and a native
Win32 version, also called the 'netinstall' version. The
development of native version is coordinated by a mailing list at
xemacs-nt@xemacs.org. If you are willing to contribute or want to
follow the progress, mail to xemacs-nt-request@xemacs.org to
subscribe.

[Cygwin-L 2000-07-28 Rod Whitby] XEmacs 21.1.10, 21.2.34 and
21.2.35 have all compiled out of the box for me with Cygwin 1.1.2
and the pre-release 1.1.3, using the following configure line for
Cygwin. There is one small problem with building 21.2.35 where
src/xemacs.exe is not getting the executable bit set during the
build (when dumped from temacs.exe). Just "chmod ugo+x
src/xemacs.exe", and type make again.

5.3 NTEmacs and printing

Check variables printer-name and ps-printer-name in Emacs 20.3+.
Package enscript.el has also been reported to work with
NTEmacs. Try to find it from ohio LCD. According to [Barry Roberts]
In network do this to connect your printer to win32

Cygwin is complete Unix like emulation layer for use inside Windows.
It includes almost all the familiar Unix tools that are expected by
Emacs: diff, patch, ls, telnet, ssh etc. Installation of Cygwin
happens simply running Windows installer program setup.exe where
individual packages can be selected and upgraded. See Cygwin site
for more information.

REPORTING CYGWIN PROBLEMS

It would be best if you provided as much details as possible for
the cygwin mailing list when you report problems. Here are couple
of commands that may prove handy:

5.5 Win32 terminal programs

SSH - Puttyhttp://www.chiark.greenend.org.uk/~sgtatham/putty/[Tom_Roche@ncsu.edu] Putty (the package, comprised of several
executables) provides several way to connect via SSH. The most
syntactically friendly (once configured) is 'putty', due to its
'saved session' facility.

If you start, e.g. with no options, configure a session, and save
it (e.g. as 'sehr'), one can subsequently use a happy syntax (see
second)

$ putty sehrlangname.physics.ncsu.edu
$ putty @sehr

Putty also now has many more configuration options than
formerly. Unfortunately, putty pops up a separate window, and has
no command line help of which I'm aware. (And Putty in general has
nonexistent documentation.) However: For a purely cmdline interface
(only tested with w2k cmd.exe), one can use 'plink'. I haven't used
it much: I only downloaded it for the purposes of this discussion,
but I will try to use it more. For its cmdline help, just run
'plink' with no options. (Why can't 'putty' do that?). More
usefully, one can do

$ plink -ssh username@sehrlangname.physics.ncsu.edu

and get an SSH session in the current window. Unfortunately it
seems not quite so friendly as putty; however this may be due to
the servers with which I use it--Solaris 6 boxes using Kerberos
with RSAAuthentication. Problems noted:* I encounter a minor
initial glitch. After typing my password I get the prompt

?7?[r?[999;999H?[6n

where '?' are what I believe to be escapes (the single char that
looks like '<-'). I can either wait a few seconds, or type enter,
whereupon I get the message

resize: Time out occurred

After which, all is well, except that I get the raw escapes
in my prompt. (putty handles this properly, but then, it's not
character-mode.) The saved session functionality doesn't seem to
quite work. If I do (-v for verbose)

and so on. Similarly without -v, but I get just the password
prompt. pscp supports (what I believe to be) 'normal' SCP syntax.
E.g. to copy from host to local cwd

pscp username@host.domain:/path/to/remote/filename .

Putty also has an ssh-agent, pageant, with which I've
previously had trouble (probably should retry the new code), and an
experimental SFTP client, psftp, of which I know nothing. (I.e.
even less than I know about the rest :-) In short: the Putty tools
allow me to connect to the servers I need, but only as long as I
type a password. I have never been able to get anything working
with the Kerberos servers with which I must interact that didn't
require typing a password.

SecureFx
SecureFX is entirely different from sftp. It runs the FTP protocol
over an SSH session, securing the FTP data connections by sending
them through SSH tcpip-direct channels. sftp uses an ssh.com
proprietary file-transfer protocol over an SSH subsystem channel,
talking to the sftp-server on the other side. newer versions of
SecureFX implement sftp, too. http://www.vandyke.com/

About SSH and Zone Alarm

A while ago i had posted a message saying that ssh routinely gets
disconnected on my computer. i now think i know why - the culprit
seems to be zone alarm, firewall utility. I installed ssh on my
new laptop and it never gets ssh disconnected.

It's blocking keep-alives. ssh keepalives are sent at
rather long intervals of time, but as far as I can see (I didn't
look into it too closely) once ZA has blocked one, the ssh
connection will be unusable. You should find either pop-up alerts
or logged rejections or both, depending on your ZA settings.
Configure it to allow them through instead of blocking them! For
example, the way I set things up, the destinations to which I use
ssh are in the trusted zone rather than the untrusted zone. But
presumably you could configure specific exceptions even for
destinations that are otherwise considered untrusted by ZA.
--Alan J. Flavell flavell@mail.cern.ch 2000-12-02 comp.security.ssh

MindTerm
Another nice program you can use to tunnel the CVS communication
over SSH is MindTerm. MindTerm is an SSH (currently v1.5) client
program written in 100% pure Java (non-certified). An ssh applet
which will forward X connections. They also do a java vnc client
with built in ssh encryption which is especially useful for
accessing a remote linux desktop from a windows machine with
nothing useful installed on it.
http://www.mindbright.se/mindterm/

6.0 Emacs tips

6.1 Emacs startup and load-path

All files must be put along the Emacs load-path. If you haven't
defined your private lisp directory, it's time to mkae it.

% mkdir $HOME/elisp

The content of the startup file $HOME/.emacs traditionally starts
with couple of path definitions

6.2 Loading files from .emacs

[Based on post 1997-08-22 gnu.emacs.help by Paul D. Smith] The
first thing you should always do with any .el file you download is
byte-compile it. Byte-compiling foo.el will create a file foo.elc
which will load and execute a lot faster than the uncompiled .el
file. (If you debug packages, then load the .el file instead,
because the error gives then clear backtrace)

You can byte-compile a file from within Emacs with the command
M-xbyte-compile-fileRET, or you can use this little command
(I make it an alias):

$ emacs -batch -q -f batch-byte-compile <file> [<file>...]

Note that if the package contains multiple .el files you might not
be able to do this as simply, since some of them might need others
to be compiled. However, most such packages come with a makefile to
do this for you. Next, you shouldn't use an explicit file names
like this:

(load "foo.el")

in your $HOME/.emacs, since that forces Emacs to load the uncompiled
(".el") version even if a compiled version exists. Instead, I use
this syntax:

(load "foo")

In this case, Emacs will first try to find "foo.elc" then, if that
doesn't exist, it will look for "foo.el".

(load "foo.el")

But that's not good enough yet. You really should not use commands
like load, load-file or load-library in your startup file,
instead get familiar with require command. It' similar to load
commands, but it only executes once. If the file is in emacs
already, it won't be loaded again.

(require 'foo) ;; See the provide command inside the file.

Even, that isn't good for hard core Emacs fan. Loading a package
with either way takes time. What one wants is that package only
loads when it is actually used. That's where autoload comes into
picture. The file's installation instruction should instruct to
tell you what statement to put in your .emacs. Say foo package
contains couple of user callable functions foo-1 and foo-2 that
are called from keys. You do this

Ah. No more unnecessary package loading at the emacs startup. Wait,
there is still more. Somebody has 100 autoloads in his .emacs, many
Emacs hook settings, endless count of private function definitions
to tweak all out of Emacs.., and it still takes too much time to
load all the autoload definitions from .emacs

What you need is a booster: delayed loading feature provided by
Tinyload.el. If you have read this far, then continue reading more
from the Tiny Tools package documentation page.

6.3 Many emacs startup files

When you start Emacs, the first file it loads is your $HOME/.emacs
You can put any Emacs initializing commands there, like
keybindings, color settings, package autoloads, c-mode
customizations and many other things. After a while you have added
pieces of code gradually to build up your own personal Emacs you
notice that the startup file has grown to remarkable size and
became complex. Here are some tips what you could do to arrange
your setup better.

In order to cope with very large Emacs setup the files can be
divided the setup to several files where each one deals with
specific subject: key definitions, hook settings, Emacs
default variable settings, font settings, Gnus news reader
settings, dired settings etc. By doing this, one can
conditionally load any of these startup settings and manage
the specific area. Keep files in version control, like
CVS/Subversion etc. (RCS is not that convenient) and put the
startup files in separate directory. Don't mind that CVS
repository now, if you're not familiar with it. Let's just say
that CVS is a server based version control software. With
version control, the files can be mirrored accross various
accounts. The XEmacs/Emacs/Win32 differences are separated to
their own rc files.

In the following example, we suppose that $HOME/elisp
contains all the Emacs packages and sub directory
$HOME/elisp/rc includes all the recource files (startup
files) for Emacs customisation. The emacs.el doesn't have to
necessarily contain many lines of code (for more advanced, see
*tinyload.el). By making these symbolic links, nothing is kept
in root directory:

In Windows the above commands would not work, because Windows
version of Emacs does not understand shortcuts. Just copy the
contents of $HOME/elisp/rc/emacs.el to $HOME/.emacs and so on.
The loader file emacs.el contains as few lines as possible
to load the real setup. Like this:

The real loader emacs-rc-root.el Would then load the rest of
the setup files as needed based on current host, the type of
Emacs/Xemacs and other criterias. It is not possible to
provide an example, because it will always be highly personal.
Refer to dot-emacs links mentioned previously in this document
for examples. Here are some ideas for recource files:

6.4 Editing files as ROOT

A regular user cannot C-xC-f file directly, but using
some other access method that changes the identity can. If FTP
server is enabled, the file can be edited under another
user identity:

M-x find-file /root@hostname:/etc/X11/XF86Config

Sometimes the root isn't allowed to login (as with ssh defaults),
but in RedHat it is possible to allow local root logins by
editing /etc/ftphosts. In some systems editing /etc/ftpusers
makes root access global, but that's probably bad idea because the
FTP sends passwords in clear text. You can also use Kai's package
Tramp which is intended to access remote files using rlogin,
telnet, ssh or somesuch, but it can also use su to do this. This
might do what you want:

6.5 Saving files as Unix

[Eli Zaretskii] You want the untranslated-filesystem feature. It
is explained in the section "Text Files and Binary Files" (node
name "Text and Binary") in the on-line manual, which see. This
feature allows you to tell Emacs that certain directory
hierarchies, or even an entire logical disk, require that files be
saved in Unix EOL format. You can also control this on a per-file
basis, by typing "C-x RET f undecided-unix RET" before saving the
buffer (this only needs to be done once for each buffer). But if
you routinely work with files that reside on Unix filesystems, the
untranslated-filesystem feature is IMHO much more convenient.

7.0 Byte compiling files

7.1 Compiling lisp files

Substitute DIRECTORY with the directory where you're
compiling the files; like "$HOME/elisp".

7.2 Shell alias

To make compiling files easie, a shell alias command can help.
Here "_emc" means "Emacs compile" and underscore is reserved
for all user's private commands so that they don't clash with
the ones that are there already in the system. Pay attention
to the single and double quotes, because constructing alias
command in (t)csh isn't always that intuitive. The load-path
setting included extra path from where to look for more lisp
files during compilation in case of compiling dependencies.

7.3 Dired byte compilation

8.0 Reporting bugs or improvements

8.1 Activating debug

First thing to do if you encounter an error (it is that ding tune
that you hear plus a message that appears in echo area) in Emacs,
you must turn on Emacs debug. In fact I would like to recommend
that you keep it permanently on.

8.2 Use uncompiled packages

If you get an error from some package, immediately load the
uncompiled version. The error message in byte-compiled format is
usually impossible to read by any maintainer. So do this
immediately when you encounter an error

M-xload-library package.el

Repeat the task until you get clear error to Backtrace buffer

8.3 Use package's contact function

Please report bugs of individual files with their associated contact
functions. And they are not just for bug reporting only, but any time
you want to talk with the maintainer, prefer using those contact
functions. You save him from lot of asking and guessing: this is very
important, because they automatically send valuable information about

Package name and package's version number.

The state of the variables in the package.

Emacs version and OS you're using.

Packages may have one or more reporting functions. The XXX is
package id, normally a short identifier which is in package's
functions. Like for C++ mode the id would be cc-mode. Use
the bug function, if it exists, over the other feedback
functions. If none of these functions are available, look at
the package source for Maintainer: and send message there.

XXX-submit-bug-report
XXX-submit-feedback

8.4 Requesting changes

Before you do anything, make sure you have the latest version.
Visit the download site (see source code or docs for any ULR
pointer) to be sure. Next, contact maintainer of the package
and describe the nature of a problem or suggestion with
examples. Discuss with the maintainer first before you go and
change something in the packages. If you do minor adjustments
like add new hooks, add support to a new platform, then you
can follow these steps.

MAKE ABSOLUTELY SURE THAT YOU HAVE THE LATEST VERSION.
Visit url where the latest version of the package is available.
If you don't know where you got it, see the Maintainer: or
Author: in the source file.

Make sure the file you're about to modify is in front of you,
sitting on emacs buffer. Save the file first:

% cp package.el package.el.orig

Make modifications. Save the file.

Take a difference and send gnu unified diff (-u). If you
don't have gnu diff; then use context diff (-c).

% diff -ubw package.el.orig package.el > package.el.diff

Send the package.el.diff with descriptive text of what was fixed,
what new feature was added or what bug was corrected.

9.2 Tiny Tools kit

9.3 Ttn Emacs kit

[Nguyen Thien-Thi] 1998-07. This is basically my emacs (and thus
Total Computing Experience) environment, including lots of funcs
(autoloaded), key-bindings, etc. the key binding is selective,
designed for export. (in the future, i'd like to generalize this
kind of packaging so that it is easy for anyone to publish their
library compatibly ... anyone want to help?) The subdir lisp/import
contains work by others; see file AUTHORS for attribution. if i've
made a mistake, please let me know.
http://www.glug.org/people/ttn/software/ttn-pers-elisp

10.0 Gnus

10.1 Gnus homepage

Gnus is a newsreader as well as mailreader, but not in
traditional sense. It is a hybrid, where it stamps label Mail to
anything that you point it to: mailing lists, multiple POP
accounts, multiple IMAP accounts, search engines, slashdot
articles, reading documents, digests, just about anything that can
be read and processed. It supports MIME, PGP, and PGP/MIME,
possibly S/MIME in the future.

Other popular Emacs mail user agents are VM and RMAIL. RMAIL
you probably should avoid because it uses non-standard mailbox
format called babyl. In case you need by accident hit rmail, then
use M-xunrmail and to b2m binary to conver the $HOME/RMAIL
mailbox back to unix mailbox. To move mail back to your Unix
account mailbox /var/spoo/mail/$USER, use program unmovemail.

10.2 Gnus-eyecandy.el

[Bryan Johnson] gnus-eyecandy.el allows you to gratuitously add
icons to your group buffer in a manner similar to the way that you
currently specify group highlighting, ie a Form/File alist rather
than a Form/Face alist. Like all eyecandy, it will slow down your
application, but if you don't go too crazy, it shouldn't slow
things down too much.

10.3 Gnus-bbdb.el (*)

[Brian Edmonds] Gnus functions which utilize bbdb data. Patch
some gnus internals to allow BBDB information to infect the summary
buffer. Also can be used in mail splitting.

it has a structural distinction between mailing lists and people
as entries in the BBDB. I do not think that this is quite right
because they are really entirely different kinds of media.

It does not completely seperate out mailing list stuff from normal
mail. I would like to do this.

It is not all that extensible.

So I wrote some stuff that is a bit more personalized to do it. It
follows if anyone cares....it uses procmail's foo+bar convention
for mailing lists. It is also pretty easy to add new things to
(like spam filters, which might be an addition to
csd-gnus-split-method-list).

=> csd-gnus-split.el - gnus functions which utilize bbdb data

10.4 Gnus-filterhist.el

[Bryan Johnson] 1999-12. gnus-filterhist.el creates a buffer with
a summary of the number of messages you've received per mailbox.
This summary is cleared every time you check mail. gnus-filterhist
has the concepts of current split history and session split
history. If you make gnus-filter-history-show-session-history
non-nil it will show where mail has been split this session (a
session being defined as the time since you started gnus or cleared
the session history). If you make
gnus-filter-history-show-current-split-history non-nil, it will
show you what was split the last time you checked mail. These are
independent from each other, so you can have either or both. If you
have both, the session history will show up no matter what, and the
current-split will display the message "- No Current Split -" if
there was no new mail the last time you checked. Both the session
history and the current split show up in the Filter History buffer.

10.5 Gnus-junk.el, Send UBE complaint

[Robert Bihlmeyer] What you need to do is spot the junk mail and
start gnus-junk-complain. This function will study the headers of
the current message, gather a number of admin-addresses from them,
and pop-up a mail-buffer with the proper "To:"- and
"Subject:"-headers, and a standard text. A copy of the offending
message is also appended. You can then check the constructed mail
(mainly, the "To:"-line) for sanity, apply corrections, and send
it.

10.6 Gnus-ml.el, Mailing list minor mode for gnus (*)

[2000-03-15 Gnus-L Message-ID:
<tn66uol6ni.fsf@bcv01xc7.vz.cit.alcatel.fr> by Julien Gilles] Some
weeks ago someone mentioned the RFC 2369, about "The Use of URLs
as Meta-Syntax for Core Mail List Commands and their Transport
through Message Header Fields". E.g. my group parameters for
nnml:ding

10.7 Gnus-todo.el

10.8 Deja.el, Search dejanews with nnweb

[Stephen Tse] nnweb is a nice piece of work, but is
well-known to be broken for Deja search. I personally do Deja
search daily and thus start this random hack. I separate it from
the original nnweb.el file because this file needs constant updates
to catch up with changes of www.deja.com interface.

10.9 Message-utils.el

Holger Schauer

Inserting files in a message and explicit marking it as
something somebody else has created,

Change Subject: header and add (was: <old subject>)

Strip (was: <old subject>) from Subject: headers

Add a X-No-Archieve: Yes header and a note in the body

A function for cross-post and followup-to messages.

10.10 Message-x.el, customizable completion in message headers

[Kai Grossjohan] This assigns a context-sensitive function
to the TAB key in message mode of Gnus. When in a header line, this
performs completion based on which header we're in (for example,
newsgroup name completion makes sense in the Newsgroups header
whereas mail alias expansion makes sense in the To and Cc headers).
When in the message body, this executes a different function, by
default it is indent-relative.

See also similar utility tinymail.el.

10.11 Messkeyw.el, automatic keyword support during composition

[Karl Kleinpaste] This provides a hookable mechanism by which to
have Keywords headers automatically generated based on word
frequency of the body. The goal is to make it possible to score on
Keywords provided, of course, that Keywords gets to the overview
files.

10.12 Ngn.el, insert newsgroup name into buffer using completion

[Dave Pearson] 2000-11. ngn.el provides commands for
quickly inserting a newsgroup name into a buffer.

10.13 Nnmaildir.el, one group per maildir

[Paul Jarc] 2000-06. Having only one group per maildir simplifies
things greatly in nnmaildir; .qmail files can be used to filter
messages into the appropriate places. A select method now looks
like this:

If there is only one group, it doesn't need to be put in a list.
The select method is destructively modified behind your back by
nnmaildir-open-server - I don't think this will cause problems,
will it? I think nntp.el does it too.

If you were using the old version, migration will be mildly
painful. (But it shouldn't be in the future.) First, kill (not just
unsubscribe) all your nnmaildir groups. Now, in the cur/ directory
in each of the maildirs you're using, execute this command: bash -c
'for i in *; do mv "$i" ../new/"${i%%:*}"; done' That will make all
messages appear as new again. Now set up your new select method,
fire up Gnus, and re subscribe to your groups.

10.14 Nnir.el, search mail with various search engines

[Kai Großjohann] What does it do? Well, it allows you to index your
mail using some search engine (freeWAIS-sf and Glimpse are
currently supported), then type `G G' in the Group buffer and issue
a query to the search engine. You will then get a buffer which
shows all articles matching the query, sorted by Retrieval Status
Value (score).

When looking at the retrieval result (in the Summary buffer) you
can type `G T' (aka M-x gnus-summary-nnir-goto-thread RET) on an
article. You will be teleported into the group this article came
from, showing the thread this article is part of. (See below for
restrictions.)

The Lisp installation is simple: just put this file on your
load-path, byte-compile it, and load it from $HOME/.gnus or something.
This will install a new command `G G' in your Group buffer for
searching your mail.

10.15 Nnir-grepmail.el, A grepmail plugin for nnir.el

[Nevin Kapur] This is a plugin for nnir.el to use grepmail
as its search engine. To use it, put the following in your
~/.gnus:

(require 'nnir-grepmail)
(setq nnir-search-engine 'grepmail)

If you have only one nnml and only one nnfolder backend and they
are both part of your gnus-secondary-select-methods, then that
should be it. Otherwise, you may need to customize the variables
nnir-grepmail-nnml-backend and nnir-grepmail-nnfolder-backend. The
defaults are guessed from your gnus-secondary-select-methods which
may or may not be right.

10.16 Fogey-subscribe.el

[Martin Fouts] I wanted a slightly more complex set of rules for
auto subscribing than I could get with the default functions, so
Lars suggested that I would need to write my own
gnus-subscribe-newsgroup-method which I did. In the process I
realized that one could generalize my approach to allow a great
deal of flexibility in newsgroup subscribing rules, and so, here,
after a brief test, is my trio of such methods.

10.17 Rmail-spam-filter.el

[Eli Tziperman] 2000-11. For all you rmail users that always wanted
to filter spam in rmail. You can define what spam is via custom
(menubar -> help -> customize -> specific group ->
rmail-spam-filter <enter>), where you can specify which senders,
recipients, subjects and/ or contents are considered spam (example
below), and you'll never see these again. The spam can either be
automatically saved to a spam-rmail file and deleted from your main
rmail file, or just automatically deleted. This filter works with a
regular spool mail file, as well as with pop servers. You do not
need to setup any external filter programs and the interface with
the filter is entirely via emacs's customize utility. Tested in Gnu
Emacs 20.6 and 21.0.

Showimmediatelydormants in non-nntp groups. some people
use dormant mark ? in their private mail groups as todo
and to be able to see those todo articles immediately saves
you 5x time, when you don't have to separately limit to
dormants.

Ready %uX userfunctions that you can use in the *-line-format
strings.

Group User format function: "expiry", Tell the expiry value
for the group and varaious other values.

Group User format function: "comment", Tell the group comment.

Group User format function: "tick", Tell if group has ticks.

SendUBEcomplaint to all postmasters in Received headers.
The ip addresses of postmasters are nslookup verified. You
can select either individual article or process mark multiple
articles.

10.19 Uce.el, reply to unsolicited commercial email

[Stanislav Shalunov shalunov@mccme.ru] 2000-05. Code in this file
provides semi-automatic means of replying to UCE's you might get.
It works currently only with Rmail and Gnus. If you would like to
make it work with other mail readers, Rmail-specific section is
marked below. If you want to play with code, please let me know
about your changes so I can incorporate them. I'd appreciate it.

Function uce-reply-to-uce, if called when current message in RMAIL
buffer is a UCE, will setup mail buffer in the following way: it
scans full headers of message for 1) normal return address of
sender (From, Reply-To lines); and puts these addresses into To:
header, it also puts abuse@offenders.host address there 2) mailhub
that first saw this message; and puts address of its postmaster
into To: header 3) finally, it looks at Message-Id and adds
posmaster of that host to the list of addresses. Then, we add
"Errors-To: nobody@localhost" header, so that if some of these
addresses are not actually correct, we will never see bounced mail.
Also, mail-self-blind and mail-archive-file-name take no effect:
the ideology is that we don't want to save junk or replies to junk.

10.20 Spamprod.el, generate spam complaint email

[Neil Dyke] 2000-10. Given a spam email message in Emacs,
spamprod.el generates a complaint email addressed to various
parties who are hopefully in a position to do something about
curtailing the spam. Brief backgrounder rant (can be safely
ignored): Spam is typically the product of individuals who would
choose to annoy one hundred thousand people if it enabled them to
make US$24.95 from just one of those people. Spammers are
freeloaders in the sense that they ignore the societal constraints
that for most people preclude sending an email message to massive
numbers of others. Spammers typically operate anonymously or with
throwaway pseudonymous identities, which means they have no
investment in social reputation that could be an object of direct
anti-spam pressure. However, spammers are dependent on providers of
Internet infrastructure, and are therefore vulnerable to anti-spam
social pressure placed upon the providers. Many providers do not
want to harbor or facilitate spammers, and need to be informed of
spam incidents - both to try to thwart the spammer of the
particular incident, and also to have a better sense of the
magnitude of spam incidents and whether additional proactive
anti-spam measures are called for. Venting is also good.
Legislation is sometimes appropriate, but can have really nasty
side-effects.

10.21 Vcard.el (*)

[Noah Friedman] Distributed with latest Gnus.

11.0 Mail

11.1 Getting remote mail

IMAPhttp://www.imap.org/ftp://ftp.cac.washington.edu/imap/ See IMAP vs. POP file
If you have the option, we recommend using or installing an
IMAP4rev1 server; it has the best facilities for tracking message
seen states. It also recovers from interrupted connections more
gracefully than POP3, and enables some significant performance
optimizations. --Fetchmail FAQ.

Fetchmail is a one-stop solution to the remote mail retrieval
problem for Unix machines, quite useful to anyone with an
intermittent PPP or SLIP connection to a remote mailserver. It can
collect mail using any variant of POP or IMAP and forwards via port
25 to the local SMTP listener, enabling all the normal
forwarding/filtering/aliasing mechanisms that would apply to local
mail or mail arriving via a full-time TCP/IP connection. --FAQ

Other[Alex Schroeder] I've collected code mffor .mailrc and pine
address book exports from BBDB on a page of mine at
http://www.geocities.com/kensanata/bbdb-funcs.html I think there is
a netscape-related lisp file distributed with BBDB (maybe as an
unsupported contribution?). There are various Palm Pilot interfaces
around. Maybe you should join the mailing list or take a look at
the archives.

11.3 Bbdb-pgp.el (*)

[Kevin Davidson] 1997. Use BBDB to store PGP preferences.
This file has been included in latest BBDB version.

11.4 Bbdb-mail-folders.el

For BBDB users, this code allows you to have several mail-folder by
default for a given author. Saving one mail creates automaically
the entry if none, or allows you to select which among the existing
one you want, or add a new one. Very useful when several people you
know are involved in many different projects. After a while, a
typical entry would look like this:

mail-folders: ("~/Mail/project1" "~/Mail/project2" ...)

11.5 Bbdb-expire.el, expiry and expire-proof entries for the BBDB

[nix@esperi.demon.co.uk] 2000-11. This file implements expiry of
BBDB databases, to stop them getting too fantastically bloated.
Only specific entries are retained across expiry. Each entry is
passed through each function in the bbdb-expire-expiry-functions
in turn; if any return t it is a candidate for expiry; but if any
of the functions in the bbdb-expire-preservation-functions return
t, it is not expired after all. (This scheme allows functions to
say `I don't care' as well as `expire me now' and `do not expire
me'.) One function is on bbdb-expire-expiry-functions by default;
bbdb-expire-record-old-p. Two functions are on
bbdb-expire-preservation-functions by default;
bbdb-expire-field-permanent-p and bbdb-expire-field-notes-p.
Together, these ensure that old records without a notes or a
permanent field are expired; the field-checking functions are
generated by a macro, bbdb-expire-field-foo-p. This will with
only work with the latest version of BBDB.

11.6 Blackbook.el, manage email aliases easily

[Hrvoje Niksic] Although the format of the mailrc file (that Emacs
packages use to read mail aliases from) is very simple, the
question "How do I add an alias to Emacs?" has popped up one time
too many on comp.emacs. Blackbook package will parse the
$HOME/.mailrc file, and present the aliases in a user-friendly
way, using the facilities provided by the widget library written by
Per Abrahamsen. In a way, this is similar to Pine's and Netscape's
addressbook features, hence the name.

11.7 EUDC, the Emacs Unified Directory Client (LDAP)

[Oscar Figueiredo] The Emacs Unified Directory Client (EUDC) is a
common interface to various directory services such as LDAP, CCSO
PH/QI and local BBDB. EUDC lets you query your corporate directory
server for information such as phone numbers and office locations.
It lets you also query public servers such as Four11 or BigFoot to
complete email addresses directly from the server while composing
email messages in VM, Gnus or Rmail.

11.8 Epop.el, General POP support for all MUAs

[Franklin Lee] Includes a RMAIL-like interface to managing POP3
server messages AT THE SERVER! This means you can selectively
delete messages on the server before (or after) fetching them via
epop3mail. See epop3-manage in the package.

11.9 Footnote.el (*)

With this minor mode, you can add [1] footnotes to the Email.
Package is included in XEmacs, but works fine with Emacs too.
Commands: renumber-footnotes, goto-footnote, delete-footnote,
cycle-style, back-to-message add-footnote. See commands under C-c!Note: The tar package, eg. footnote-1.09-pkg.tar.gz, contains
lot of files, but you can forget the others and copy footnote.el to
your lisp directory and use following setup:

I [hannu] took footnote package (footnote.el being 0.19) from
XEmacs 21.1 distribution, fixed few bugs, added one styleš (and
related minor features like some variables being now configurable)
and rewrote some parts for clarity (and because that style needed
more flexibility in some functions etc.) This combination may quite
well be equally or even more buggy as the version I started to fix
and extend, so before I'm going to throw my changes to
xemacs-patches for inclusion to the official version I'm offering
my current version for you to experiment with.

11.10 Fortunesig.el

[Holger.Schauer@gmx.de Holger Schauer] 1999-03.
Add a new fortune to you mail. You first generate a fortune
database with unix tool strfile then do M-x fortune. After that,
delve into automagically generating a new signature.

11.11 Feedmail.el, replacement for sendmail (*)

http://www.carpenter.org/ by Bill Carpenter, package is part of
Emacs 20.3. A replacement for parts of GNUemacs' sendmail.el.

you can get one last look at the prepped outbound message and
be prompted for confirmation

removes BCC:/RESENT-BCC: headers after getting address info

does smart filling of address headers

calls a routine to process FCC: lines and removes them

empty headers are removed

can force FROM: or SENDER: line
you can specify something other than /bin/mail for the
subprocess

you can park outgoing messages into a disk-based queue and
stimulate sending them all later (handy for laptop users);
there is also a queue for draft messages

you can generate an X-MAILER: message header

11.12 Ldbdb.el, Little Brother's Database interface

[Dave Pearson] 2000-10. lbdb.el is an emacs interface to the Little
Brother's Database. You can find out more about LBDB at
http://www.spinnaker.de/lbdb/ Two commands are provided,
lbdb and lbdb-last. lbdb lets to perform an interactive query
on the lbdb while lbdb-last allows you to recall and work with
the results of the last query you performed.

11.13 MH Mail user agent

11.14 Rmail-extras.el, support remote inboxes

[Trey Jackson] rmail-extras.el modifies the behavior of RMAIL to
allow reading mail from remote inboxes (using ange-ftp) It also
modifies the "time" package to enable raising flags for each
individual inbox that contain mail.

11.15 Signature.el

[Albrecht Kadlec] Randomly choosing quotes from a file to be used
in their sig

11.16 Tc.el, a lightweight to supercite

[Lars Clausen 1998-10] ...No, I will not make it quote with name
abbreviations like SuperCite does. That style is annoying and
unreadable, goes against the RFC's (or rather, the sons of them:),
and have generally been the most problematic thing to deal with.
Trivial-cite can handle them, but is better at 'normal' citation
marking.

11.17 TinyMail.el, email minor mode + email notification package

[Tiny Tools kit] 1996-04. Display "mister.foo@bax.site.com 6" on
the X window's frame immediately when mail arrives. And in
non-windowed emacs you see message in echo-area. Also the pending
mail count arrived so far is shown. Works currently in any Emacs
and XEmacs. This is roughly same as what reportmail.el does in
XEmacs distribution. Other features are:

Easy interface for completing field with TAB. Eg completing
Followup-To/Gcc/Newsgroups and any user defined field; like
Class or Priority

Fcc/Gcc folder can have compression extension .gz or .Z

Customizable TAB key. You can use tab for other purposees in
other headers than Cc/To where it completes email addresses.

Mail, GNUS 4/5 message, VM, MH compatible.

11.18 Unmunge.el

[Gareth Owen] 1998-06. The purpose of the package is to change ones
email address according to mail/newsgroup context, (similar to
gnus-posting-styles in later gnusen) Check also "functions to
assist in correctly setting mail addresses" by [Marty Fouts]

11.19 Vm-complain.el, send spam complaint

[Francois Ingrand] ...Automate reply and complaint message to Spam
and UCE. ...will insert a X-UCE-Spam-Reported-by: header which
you can then look for with procmail to discard complaints bouncing.
It will also insert a nice and polite string explaining why you are
fed up with all these junk mails. Last it will try to retrieve from
the original mail, hostname from which the Spam/UCE mail may have
been posted. From this it will build a recipients list based on the
variable vm-complain-recipients.

12.0 Mime

12.1 Rmime.el

[Ray Moody] 1996. RMIME provides MIME support for several Emacs
message reading packages. RMIME has been designed with RMAIL in
mind, but it has also been tested with mh-e and VM. It should work
with most other major modes as well. See also mimencode source from
ftp://thumper.bellcore.com/pub/nsb/

12.2 Extra tools for mime viewers

[maintainer] Strictly speaking these are not viewers, but some
additional tools that you can attach to your mime handling package.
Eg. I have configured TM package so that every time I "play" MS
word document it is piped through catdoc. Catdoc is word2text
filter.

Laola(perl) does a respectable job of taking MSWord files to text
...LAOLA is giving access to the raw document streams of any program
using "structured storage" technology to save its documents.
ELSER is dealing especially with these streams as they are present
in Word 6 and Word 7 documents.

13.0 WWW

13.1 Apache-mode.el

[Kevin Burton] and [Jonathan Marten] 2001-03. The list of keywords
was derived from the documentation for Apache 1.3; there may be
some errors or omissions. There are currently no local keybindings
defined, but the hooks are there in the event that anyone gets
around to adding any.

13.2 Browse-help.el, WWW context-sensitive help

[tma@netspace.net.au Tim Anderson] 2000-01. browse-help.el
provides support for context-sensitive help within Emacs. It parses
user supplied help files to build up an index of topics and their
corresponding URLs. When a topic is looked up, its help is
displayed to a browser via the browse-url package. It was written
to simplify searching through the Java and Perl documentation, and
for the most part succeeds. The parser works best on documentation
that has an index (such as allclasses-frame.html in the Java
distribution, or perlfunc.html in the Perl distribution)

13.3 Css-mode.el, Cascading style sheet handling

[Lars Garshol] This is a simple Emacs mode for editing CSS style
sheets. It adds font-locking and some basic auto-indentation
support to Emacs. It works with Emacs 19.34, but should also work
with both older and newer versions as well as XEmacs.
Have a look at: http://www.garshol.priv.no/download/xmltools/

13.4 Emacs-wiki.el, Emacs-friendly markup

[John Wiegley] See more about wiki at
http://c2.com/cgi/wiki?StartingPoints Wiki is a hypertext and a
content management system: Normal users are encouraged to enhance
the hypertext by editing and refactoring existing pages and by
adding more pages. This is made easy by requiring a certain way of
writing pages. It is not as complicated as a markup language such
as HTML. The general idea is to write plain ASCII. Word with mixed
case such as ThisOne are WikiNames – they may be a Link or they
may not. If they are, clicking them will take you to the page with
that WikiName; if they are not, clicking them will create an empty
page for you to fill out.

For more pointers to ASCII/other based WWW authoring tools, see
/t2html.html

13.5 Hbmk.el, Manage bookmarks in HTML

[Tom Breton]hbmk-add-destination-file prompts you for a
filename, which then is available as a destination for clippings.
hbmk-dispatch-region deletes the currently selected region and
pastes it to a destination which the user selects from a list.
hbmk-add-reference creates a reference at the point to a new
file. You use it when editing a file that should contain a link to
the new file. It expects the point to be in an <ol></ol>.
NOTE: You also need package tehom-4.el.

13.6 Html menus, write html page

[Heiko Muenkel] With this package it is very easy to write html
pages for the World Wide Web (WWW). It is also possible to insert
links and images by just clicking on its source and destination
(drag and drop feature). This package provides also a minor mode
(hm--html-minor-mode), which can be used together with another html
major mode, like the psgml-html mode in the XEmacs 19.15.

[Ben Tindale ben@bluesat.unsw.edu.au 2000-04] Just some quick
keybindings to make writing your jsp files a little easier. These
bindings tie in with Nelson Mindar's html-helper-mode, see
Sourceforge link.

13.8 Html-toc.el

[Rolf Naess] This package will create a table-of-contents in a
HTML-document based on <H[123]> tags. The toc will be placed
between the strings defined by toc-open and toc-close. If these
doesn't exist, it will be placed right after <body>. If no
<body>-tag exists, it will be put right before the first header.

13.9 Htmlize.el, font-lock to html converter (*), XEmacs

[Hrvoje Niksic] 1997. This package will allow you to HTML-ize your
font-lock buffers. It takes into account only the colors. A lot of
functionality could be added. To use, just go to a buffer, and
invoke M-xhtmlize-buffer and you'll be put to an HTML buffer,
which you can save.

13.10 Httpd.el, Emacs inetd webserver

[Eric Marsden] httpd.el is an HTTP server embedded in Emacs. It can
handle GET and HEAD requests; adding support for POST should not be
too difficult. Since Emacs does not provide server sockets, you
need to run this from a service such as inetd, using a line such as
the following in /etc/inetd.conf :

13.11 Iso-sgml.el

[Frederic Lepied] Edit SGML or HTML buffers with ISO 8859-1
(Latin-1) display ...elisp code for character substitutions (like
">" => ">") appropriate to send a string as "plain-text" in an
html file. The psgml package seems do not have nothing like that.

13.12 Mkhtml.el, Create HTML with links

[Drew Adams] 2000-11. Extensions to htmlize.el, by Hrvoje Niksic
(hniksic@iskon.hr). Hrvoje Niksic's htmlize.el creates HTML files
from fontified buffers, but it does not attempt to create any HTML
links. This file extends htmlize.el by trying to do that in a
couple of specific cases, interpreting mouse-face'd text in Info
and Dired buffers as links. Get htmlize.el from Niksic's web site
Somewhat related functionality is available with info2www. This
is a shell script that converts Emacs Info files on the fly to
HTML. See <http://www-flash.stanford.edu/info2www/info2www.html>

See also the makeinfo utility (Note: texi2html is now obsolete,
replaced by Makeinfo). Like mkhtml, makeinfo can convert entire
Info files to HTML. The result of converting an Info file with
makeinfo is a single HTML file. The result of converting an Info
file with mkhtml-file is an HTML file for each node in the Info
file. To produce a single HTML file with multiple Info nodes using
mkhtml, you need to first merge the nodes with the command
Info-merge-subnodes (see file info+.el). The main commands
defined here are mkhtml-any-buffer, mkhtml-dired-files and
mkhtml-file. These all try to analyze the context (Dired, Info,
merged Info) of the buffer or file(s) to determine how to create
appropriate HTML links. The most powerful of the commands here is
mkhtml-any-buffer. If you know the context, you can alternatively
use directly one of the individual commands mkhtml-dired,
mkhtml-info-buffer, mkhtml-merged-info-buffer, or
mkhtml-plain-buffer. Each of these uses the generic function
mkhtml-particular-buffer. You can also use
mkhtml-particular-buffer to create your own function for creating
HTML links in another special context.

13.13 Psgml-mode.el, HTML, XML, SGML (*)

Have a look at XAE distribution, which contains psgml,
the Saxon XSLT processor, the Docbook DTD and stylesheets, and an
HTML user's guide.

[Lennart Staflin] PSGML is a major mode for editing SGML documents.
It works with GNU Emacs 19.19 and later or with Lucid Emacs 19.9
and later. PSGML contains a simple SGML parser and can work with
any DTD. Functions provided includes menus and commands for
inserting tags with only the contextually valid tags,
identification of structural errors, editing of attribute values in
a separate window with information about types and defaults, and
structure based editing.

2000-10-27 ...The future of PSGML: It is currently not in active
development. I plan to put out one or two bug fix releases and the
move the sources to source forge (possibly after additions that has
been send to me.) I will then invite others to take an active part
in the future development of PSGML. To start this I have created
two mailing lists on source forge. A psgml-user for general
discussion and questions about PSGML and psgml-devel for discussion
about the future development of PSGML. Visit the SourceForge:
Mailing Lists for PSGML page to for subscription info. --Lennart

13.14 Psgml extension

"tehom-psgml - Psgml extensions"

[Tom Breton]tehom-psgml-index.el Generate a table-of-contents
from HTML page contents. tehom-psgml-link.el A bare-bones
hyperlink system which works with psgml. tehom-psgml.el Additions
to psgml, mostly made to make it easier to use in hbmk and
rambledocs.

13.15 Quickurl.el, insert URL at point

[Dave Pearson] This package provides a simple method of inserting
an URL based on the text at point in the current buffer. This is
part of an on-going effort to increase the information I provide
people while reducing the ammount of typing I need to do. No-doubt
there are undiscovered Emacs packages out there that do all of this
and do it better, feel free to point me to them, in the mean time
I'm having fun playing with Emacs Lisp.

13.16 TinyUrl, url finder minor mode

[Tiny Tools kit] A general URL detector minor mode. Built on top of
browse-url.el, ffap.el etc. When Emacs is idle for 2 seconds,
all urls in the line are highlighted. Urls types are various: man
pages, http, ftp, Lisp programming, Perl programming, Perl man
pages, C-code etc.. you can select different backend combinations
on the fly: Netscape, Lynx, W3...

13.17 Watson.el, query search engines

[Eric Marsden] 2000-03. watson.el is an experimental Emacs interface
to web search engines such as Altavista. Given a number of keywords
to search for, it will send the query to several search engines.
The results are then aggregated and displayed in a watson buffer.
Currently backends exist for the search engines Altavista, Google,
Yahoo!, Excite, Snap, ftpsearch, Dejanews and dmoz.org.

13.18 Web-mode.el, cvsweb

13.19 Wup.el, web page distribution

[Nguyen Thien-Thi, see kit ttn-pers-lisp] To "publish" means to
move something from the source tree to the website. To "update" is
to publish only "newer" files than the last time a wup command
was given, and to delete files on the website that are not in the
source tree. The root of the source tree must contain the elisp
file .wuprc which sets some operational variables:
wup-src-home-dir and wup-website-dir. These are strings that do
NOT end in slash. If wup-website-dir is remote, use syntax that
ange-ftp accepts: /user@host:remote/path (you will be asked for a
password). If a directory contains the file .wupfence, wup does not
update that directory or its children. This is useful for isolating
subtrees that are under development.

13.20 XAE, XML Authoring Environment

[Paul Kinnucan] 2001-01 http://xae.sunsite.dk The XML
Authoring Environment for Emacs is a free software package that
allows you to use Emacs and your system's HTML browser to create,
transform, and display XML documents. The XAE includes:

structured document editing mode (psgml) for Emacs

technical book and article DTD (Docbook)

Docbook stylesheets

XSLT processor (Saxon)

XAE and Docbook user's guides

13.21 Xml-lite.el, an indentation-engine for XML

[Mike Williams] This package provides a simple indentation engine
for XML. It is intended for use in situations where the full power
of the popular PSGML package (DTD parsing, syntax checking) is not
required. xml-indent is designed to be used in conjunction with the
default GNU Emacs sgml-mode, to provide a lightweight XML-editing
environment.

13.22 XSLT (Apache Xalan)

[Ovidiu Predescu] 2000-11. Have you ever developed XML applications
using XSLT? If so you probably felt the need of viewing the result
of applying the XSLT processor on the XML file using an XSLT sheet
you have been working on right inside your (X)Emacs, without having
to go to a terminal or to the Web browser. This minor mode allows
you to do it! The XSLT-process minor mode allows you, while you're
inside a buffer for which this minor mode is enabled, to enter a
few keystrokes that will invoke the XSLT processor of choice on the
buffer. The result is displayed in another (X)Emacs buffer, which
allows you to quickly view and inspect the results. You need to put
in your CLASSPATH xalan.jar, xerces.jar and maybe bsf.jar
bsfengines.jar, depending on the version of Xalan you're using and
whether you're using Xalan Java extensions or not. Make sure xalan1
uses a capital 'X' at the beginning, aka it should be xslt.Xalan1
not xslt.xalan1! Try doing this in jde.el bean shell
http://www.beanshell.org would be:

bsh % xslt.Xalan1.invoke("/tmp/foo.xml", "/tmp/test");

14.0 Version control

14.1 Accurev

[2001-02-01 comp.software.config-mgmt s_m_campbell@my-deja.com]
Another nice tool on the market is AccuRev/CM. We have been
piloting this tool as a replacement for VSS. Priced right, it
offers great parallel stream/branch support, nice merging features
and they also have an issue tracking software that compliments
their CM tool. Plus their development team and support team are
very responsive to address issues and they enjoy working with their
customers to make improvements to their product.

[2001-02-02 comp.software.config-mgmt Karen Lammers
klammers@grandtimber.com] It seems straight-forward, complete,
and requires little admin. Just what I'm looking for for a small
development team. I'm not completely sold yet. I have some other
products to try out first, but I wouldn't be surprised if I end up
using AccuRev. Also, in just 3 days of investigating the product,
I've sent 3 emails to AccuRev with questions and all three were
answered either first thing next morning (for one sent late in the
day) or in the very same day. Very good start to a potential
technical support relationship.

14.3 BitKeeper

Truly distributed; you don't need to have a network connection
between all of the systems, all of the time to do your job. You
can clone a copy of a repository to your laptop and have 100%
functionality while disconnected, on an airplane, at a
conference, etc. No exceptions; when we say 100%, we mean 100%,
not 99.9%.

Multi-platform. Runs on Windows NT, 2000, 98, and most of the
popular unix operating systems.

BitKeeper checksums each revision file and each delta within
the revision file. Since your data is very important, we
provide redundant checks. So far, these checks have found
multiple bad memory DIMMS (Sadly, we've found out that PC
memory is not very robust unless you get ECC memory), many NFS
corruptions, and a SPARC/Linux cache aliasing bug. All of
those errors are likely to go undetected in an RCS-based system
such as Perforce, CVS, etc. RCS has no built in integrity
checks and is made worse by a file format that prevents you
from noticing that you have bad data until you attempt to
retrieve a file.

Filerenames. BitKeeper lets users move files around and the
moves are propagated just like content changes, right down to
having a resolver for rename conflicts (I moved A->B and you
moved A->C is a conflict; if I moved A->B and you didn't move
it, the merge applies the changes automatically). This isn't a
big deal until a code reorg - then it is a huge deal. This is
one of the annoying problems with CVS and Perforce.

Changesets. BitKeeper groups changes to multiple files into a
single unit of work. You can still delve down into the
ChangeSet to see the individual changes; the detailed
information is not lost. Why do you care? Each changeset
contains enough information to reconstruct the entire tree as
of that changeset. It is as if you tagged the tree every time
you made a change. Although other tools allow tagging, the way
that they are implemented prevents people from using the
feature often since it is usually a very time consuming task on
a large tree. Our "tagging" is essentially free and takes
milliseconds for a large tree.

Lowbandwidth requirements. Because BitKeeper remembers the
state of the tree as changesets, when you synchronize any two
trees, all BitKeeper has to do is compare a summary of the
ChangeSet file. On average, that is 55 bytes per ChangeSet.
BitKeeper itself has about 2250 changesets in the course of
three years of development. That means that bk has to transfer
about 40K (we automatically gzip all transfers) to figure out
there is nothing to do. Null updates of the Linux kernel tree
take about 1.5 seconds between San Francisco and New Mexico
over 384Kbit/sec DSL.

No loss of information. Unlike third-rate tools, BitKeeper does
not lose events, nor does it ever combine two events into one.
The classic example of losing an event is a merge. For example,
if we are using CVS and I check in first, you have to do a
merge, (and it might not be pretty if 20 files were touched).
The next day you figure out that my work was really awful and
you want to separate it out from your work. In CVS, you have to
manually unmerge because CVS checked in one event where there
should have been two: (a) your work and (b) the merge work.
Since BitKeeper captures both of these events, it is easy to
remove the effects of the merge and the addition of my work
with a one-line command. You can easily get back to your
original state with just your work and you can do this weeks
later as there is no time limit.

Staging areas. The distributed nature of BitKeeper means that
you can have staging area for different groups. It is as if
each group had their own CVS server and all of those CVS
servers can talk to each other and update each other.

GUI tools. BitKeeper comes with a suite of graphical tools to
help you do your job. These tools have been described as
``kernel hacker GUIs'' by one of the Linux kernel team. What
that means is that they are not eye-candy; they actually help
you get your job done. The suite includes:

Tools include:

citool: a graphical checkin tool which has windows for the
file, list, the diffs, and a comment window. There are hot-key
bindings so that you can scroll the diffs while typing in the
comments without moving the mouse (sounds weird, it's amazingly
useful, the quality of checkin comments immediately goes up).

csettool: a graphical changeset viewer. Shows you the changeset
comments, the list of files/deltas in that changeset, and lets
you move from file to file viewing comments and diffs.
Extremely useful for code reviews. You can go from a specific
file in the csettool to sccstool and back again.

difftool: a graphical side-by-side differences viewer, color
coded for old vs. new diffs. There is also a search feature.

helptool: a graphical man page viewer with a twist: we process
all the man pages into one large searchable file.

sccstool: a graphical project and file browser. It Lets you
select any two points and see color coded context diffs and
check in comments. You can go from any revision to the
changeset which contains that revision.

fmtool: two-way file merge program. Lets you see the
differences side-by-side and pick either of them. You can edit
the resulting merge.

"cvs-commit.el" [Kevin Burton] 2001-01. cvs-commit.el is a
Emacs modification for smarter cvs-commit management. It
contains the following features. I don't think this should
conflict with current vc operation. It is possible that it is
not hooked in perfectly as I have not used in all situations.

14.6 MKS Source Integrity (WinNT)

[1998-09-18 gnu.emacs.help Message-Id: uiuilfnxf.fsf@WOLF.scala.com] ...I
put in some basic but untested support for the Unix MKS tools, and
I believe it will work but you need to change
mksrcs-local-config-name and mksrcs-global-config-name.
Obviously, since I never tested it under Unix, it may have some bug
(hopefully minor). The problems I solved in 19.33/19.34 vc.el:

Support using the rcs.rc file to find the master files. MKS
RCSDiff doesn't know the --brief option, and the vc.el package
cannot determine this on its own, so I need to manually force
it.

vc-find-binary is broken under Windows NT so we need to
manually force vc.el to choose RCS.

Under Windows NT, vc-version-other-window and ediff-revision
are broken.

Under OS/2, if you don't have an sh-compatible shell,
vc-version-other-window and ediff-revision are broken.

[2000-01-05 comp.software.config-mgmt Alex Povzner
povzner@attcanada.net] MKS SourceIntegrity is a good, reliable
and easy to use tool. However, its major weakness is that it does
not support project-level branching and merging. If this is what
you need most, you may consider a good solution for this problem
available from SiberLogic Inc called SourceTrack
(www.siberlogic.com) that makes branching and merging projects an
automatic procedure both under MKS Source Integrity and under
Microsoft SourceSafe.

14.7 Perforce P4 revision control software

[2000-11-11 http://www.perforce.com/ => licencing]FreeLicensingforOpenSourceDevelopment: Organizations
developing software that is licensed or otherwise distributed
exclusively under an Open Source license may be eligible to
obtain Perforce servers gratis. This includes upgrades but not
support. Perforce Software reserves the right to approve the Open
Source license; those fitting The Open Source Definition,
including the GNU and FreeBSD licenses, are good candidates.
Execution of a End User License Agreement for Open Source
Software Development is required. Contact us for more
information.

[Rajesh Vaidheeswarran] 2000-11. The file p4.el is a minor mode
for the P4 revision control system written by Perforce
http://www.perforce.com/ . It is not integrated into the vc.el that
exists with Emacs since I didn't know if the vc library exported
any hooks that I could use here. (Also, this library is my very
first in elisp land). Visit http://p4el.sourceforge.net/

(Robert Cowham) have produced an add-in for Perforce which does
diffs for Word documents stored in Perforce. See web site below for
more info. – rc@vaccaperna.co.uk CM Consultant and Perforce
Consulting Partner http://www.vaccaperna.co.uk/

14.7.1 Comments

[2000-01-04 comp.software.config-mgmt Gabriel Grebenar
Gabriel.Grebenar@ixos.de ] we had tested MKS Source Integrity
extensively and it seems to be a good tool for us. In the end of
our decision phase, we heard about Perforce -"a very fast,
client-server SCM tool" and we decided to throw an eye on it. We
downloaded Perforce and its documentation from www.perforce.com and
we were surprised about the distribution policy of Perforce. It's
the first "pure" internet company. You can download really
everything from their homepage. Perforce doesn't distribute it's
software on CD-ROM, nor the documentation printed on paper! Wow!

But this policy didn't say anything about its SCM tool. OK, lets
test the SCM-tool.

We installed Perforce and we were surprised again. The Perforce
server was one binary and its size was 1 MB - that's all? The
windows GUI client package was a selfextracting binary containing a
few files and its size was 2 MB?

Then we tested Perforce ...

The result: We bought many Perforce licenses. No doubt, this tool
was the fastest we had ever seen and its functionallity was
complete. Now we are running Perforce for nearly a year without any
problems (>100 users, >100000 files).

14.8 Razor

Razor is affordable, an integrated, feature-rich configuration
management system providing process management, issue/problem
tracking, version control, and release management. Workflow,
templates, rules, and controls can be customized to match your
process. See <http://www.razor.visible.com/>

14.9 RCS

RCS is easy to use local version control system. It does not
implement client/server. Warning: Native GNU RCS port uses
unix incompatible CRLF format, so you should use Cygwin RCS.
make Win32 generate the familiar file suffix, use

If you're looking for very good Explorer integrated and easy to use
win32 Graphical user interface for for standard RCS, this is your
choice. CS offers free edition of the software for personal use.
Support for GNU Emacs, Borland JBuilder/2, Symantec Visual
Cafe,éColdFusion, HomeSite, Visual SlickEdit and UltraEdit...

ComponentSoftware RCS (CS-RCS) manages document revisions. Use it
to monitor changes made in files that are accessed by standalone or
networked workstations. Based on the widely used GNU RCS, it is
fully integrated with Windows 95 and Windows NT. CS-RCS supports
multi-platform workgroups, making it the ideal solution for sites
that share common files on UNIX and Windows platforms. CS-RCS
handles all types of documents including program files, HTML
documents, MS-Word documents, pictures and drawings. CS-RCS can use
any file server or local drive to store the archive files. Network
connection to the archive repository can be LAN, corporate
wide-area network, dial-up connection and the Internet.

[Christopher Kline] 2001-05. This file implements many of the
features of VC for use with StarTeam (www.starbase.com), a source
control program.

Also take a look at Change Commander. It is an inexpensive web
based issue management/tracking system that I think fits your
needs. It provides a rich set of functions and is very easy to set
up and use. You can try it for free at
(See link at <http://www.geocities.com/xtbob/qatweb1.html>)

[2001-01-30 comp.software.config-mgmt Santiago Glikberg
santiago@netvision.net.il] I was well acquainted with StarTeam
about a year ago, and I do not remember that you coud branch tasks
(only files and change requests got branched). Also, the CR
workflow was stiff and awfull. Not mentioning the customization
capabilities (compare those to DevTrack's). I also recall that the
web interface had a very annoying bug: if you login through the
web, then you copy any page address and close your browser, you can
paste this address on a new browser and get straight to rou files
and other info, without having to log in again! A breach in
security. And of course, there was no utility to check and correct
for database integrity, which made some potential users very
nervous. But yes, the GUI is VERY good.

14.14 Visual SourceSafe

Getting the regexps just right in the variable ss-project-dirs can
be a real pain, due to the excessive number of backslash ("\")
characters that you need. For example, if your local copy of the
project $/ is in d:\VSS\, then you need to do

(setq ss-project-dirs '(("^d:\\\\VSS\\\\" . "$/")))

Note that you have to have the trailing directory delimiters after
VSS to match the separator in $/. To get around that problem, you
can use forward slashes as a delimiter in the regexp. That can
simplify things a lot. If you change ss-project-dirs, make sure
you clear the variable ss-project-dirs-cache. Short filenames can
also cause problems. If the regexps in ss-project-dirs match the
long filename but you try to get the file via the short filename,
it won't work. --Stan

[2000-01-06 comp.software.config-mgmt Alex Povzner] SourceTrack
allows you to keep different development streams in different
SourceSafe databases, branching makes the central database neither
bigger nor slower. In fact, it makes it smaller and faster since
file revisions (changes) are distributed among different stream
databases.

SourceSafe is known for lack of reliability: the bigger is the
database and the more people are working on it at the same time,
the greater is the chance it will crash. As a result, the company's
whole development will be suspended until the database is
recovered. Not in case when you have separate databases for
different project branches: not only it lowers the very probability
of a crash, it also makes it local - developers on other streams
would not be affected. Normally, the only user of the most critical
branch, the 'trunk', would be the release manager (integrator,
whatever his/her position is called). The chance that this most
critical branch crashes would be next to zero.

Branching should not be done 'at a whim'. That's why I suggest that
it should be done only when a really new development stream
emerges, which usually happens when a pilot project is launched on
top of an existing one or when a new release is delivered to
customers. How often do these things happen? Once every two weeks
at most. Remember, with SourceTrack a significant time is required
only at the moment of the initial braniching of one stream from
another. Well, branching 2500 files may take about an hour. Any
later interactions (synchronizations back and forth) between the
main stream and the newly created one will only take minutes.

<http://slashdot.org/books/00/06/10/0049251.shtml> VSS is great
evaluation-ware (better than demo-ware). After using it for half an
hour, you'll be convinced that it does everything you need. After
you've made the commitment, you'll discover otherwise.

VSS uses an extremely chatty protocol (good old DCOM), so I find
VSS unusable offsite. Latency is terrible. Over ISDN, it takes five
minutes to navigate to the proper subfolder, check out a file, and
check back in a modified version. Many at my office buy the
third-party Source Offsite: their proxy translates into a more
sensible protocol for their own client. You'll also need a
third-party client if you want to build your code on anything but
Windows(TM). We must build on NT, Linux, and Solaris, so all our
Unix synchronization was scripted by hand, to selectively update
from Samba mounted drives. In effect, we've build our own
source-control system alongside VSS.

We've found that the only safe way to synchronize a working copy of
a VSS directory is to delete the entire branch of the tree and get
a fresh copy. Otherwise, you'll never notice what files others have
deleted or what new files you've forgotten to add to the tree.
We've had the build break five days in a row for this very reason.
When I check out files, I make a mirror copy of the directory under
RCS, then use scripts to update VSS. My VSS tree is constantly
deleted and refreshed to ensure real synchronization with the rest
of the team.

The problem would be alleviated by changing "working folders"
except that working folders do not work in any rational way. You'd
like to switch between your polluted copy of a tree and a clean
copy to check that your changes are compatible with others' more
recent changes. You find that when you switch the working folder at
the root of a tree, some sub-folders (sub-directories) remain with
the old tree if files are checked out. You then discover that, by
default, the same file will check out into one working folder and
check in from another working folder. Yet time stamps and diffs
make you think you checked in from the folder you put the file into
and modified. Only when you delete and get a fresh copy of the
tree, do you discover that you checked in the wrong version. To
undo the damage, you must visit and reset every directory in the
tree. You'll never try to change working folders again. (Everyone
on the team tried it once and regretted it.)

As soon as we reach our next major milestone in August, we plan to
switch to CVS. I used Clearcase for years and would also prefer it
to VSS. --bharlan at http://billharlan.com/

My group also used VSS in the past, and we also had some major
issues with the VSS database corrupting on us. One of the major
advantages of CVS is the simple file format it uses. I've moved our
repository three times already and I've never had much of a problem
doing so. Moving to CVS also allowed us to use any OS we wanted to
for development (in Java), which was also a big plus. --selectap at
slashdot We chose CVS over VSS for stability and speed. Was on a
project that used VSS for 9 months and lost the repository 4 times.
Never heard the specific cause (could have been human error), but
don't want to risk it. On speed, VSS takes roughly twice as long as
CVS. Upside of VSS is NT integration (if you like that sort of
thing) and nicer GUI, but source safety is paramount in my mind,
with minimizing developer wait-states a close second. -bob9113 at
slashdot

14.15 Version control articles

[http://slashdot.org/books/00/06/10/0049251.shtml b asciitxt]
I'll chime in here and share my experience. I use both CVS (on
Linux and NT, 2 users) and SourceSafe (on NT, 40 users) constantly.
I've also used ClearCase (on Solaris and NT, 20 users) for two
years.

I also maintain and administer CVS (for a project a buddy and me
are working on).

ClearCase is extremely powerful, but is has its own filesystem and
is so complex, my group had many problems with it. I also found the
performance, even over a high-speed LAN, crummy. I know there are
snapshot views, but we found them problematic. ClearCase is
probably well-suited to huge legacy systems supporting multiple
concurrent releases, but it's expensive (I hear > 100,000 per year
for my company) and very difficult to administer (probably need a
person who does nothing else). Distributed development over many
cities seems unlikely.

SourceSafe is easy to use and better than most Microsoft products
(of course, they bought it rather than develop it in-house), and
even supports distributed development through an add-on called
Source OffSite. But it's not cross platform, can't be administered
remotely and is primarily GUI-driven (although I hear some things
can be done from the command line). The biggest complaints, which I
haven't seen myself yet, are that it doesn't scale well, nor does
it properly support multiple branches well - which ClearCase does.

CVS has been an absolute pleasure, and I administer it myself from
600 miles away where it is hosted on an old Pentium 200 running
Linux. The online chapters of the CVS book have been extremely
helpful. Even a newcomer like myself has been able to set it up.
Plus, with the wonderful web front-end, CVSweb, as well as TkCVS,
it's as easy to use on the client side as SourceSafe. I can't speak
to the scalability or branching management personally (although
large projects that use CVS do), I find it offers the best of both
worlds - configurability and ease-of-use.

CVS is a free low-tech version control system build upon RCS and
GNU diff. ClearCase is a expensive hightech version control
system. Both systems are pretty good at getting out of the
developers way, the most important single trait of a version
control system.

The main technical difference is that ClearCase will minimize disk
usage by providing a central server for the repository and have
each developer mount directly on server via a special purpose file
system. That way unnecessary replication of data is avoided. CVS
will simply give each developer a complete copy of the
configuration he is working on. The CVS approach has advantages as
well. It allows development to continue when the server is down, or
programmers can work at home with no or poor network connections,
and they can work at different sites. The CPU and network power of
the central server tend to become the bottleneck with ClearCase for
larger projects.

I believe the CVS approach is best. Disks are cheap. Sun apparently
agree, they have replaces their old version control system (NSE)
which were similar to ClearCase with a new system (TeamWare) more
close in spirit to CVS. Being low-tech also have advantages. CVS
stores its version information with RCS and some extra flat-text
files, so in the worst case the data is easier to recover. Other
differences are the common differences between free and commercial
software:

CVS is free, ClearCase expensive.

You can buy support from multiple sources to CVS (Signum Software
(Sweden), Cygnus (USA)), and you can fix things yourself if you
have to. With ClearCase you are less likely to need to fix
things yourself.

ClearCase comes with much better documentation.

ClearCase probably comes with more slick tools. Both have an
Emacs interface, but the CVS interface is bundled with Emacs.

Using ClearCase means betting your project on the survival of a
single company.

My recommendations

For very small projects: CVS (because it is simple)

For very large projects: CVS (because it scales well)

For a pure Sun shop with no intention of switching vendor, I'd
probably recommend TeamWare instead.

I'd recommend CVS if the people on the project are smart and
understand free software, or work is distributed. I'd recommend
ClearCase if they are dull or have problems with free software in
general.

[thread 1999-12-08 ajs@ajs.com CVS-L]

In favor of Clearcase

NOTE: The stuff about dynamic filesystem is an OPTION
not a requirement, with ClearCase 3.1+ on NT and 4.x+ on Unix you
can operate in a snapshot/sandbox fashion just like you do with
CVS.

...CVS branching is NOT cheap. Any method that must add metadata to
every file when the vast majority of that data is unused and
unneeded is not cheap. We have 10,000 elements under source control
and adding even one line to every single ,v file just because I
need to modify 3 files is obviously not cheap. In ClearCase, you
don't have to touch a single element to create a branch type. And
when you actually branch a file that branch exists in only that
element, no other element is touched. This is actually really
useful in many ways: for example, it's a very quick and simple
method to discover what files you changed: just look for the files
that have an instance of that branch.

The idea of branching only those files you need was advanced as a
solution to the problem that creating a branch in CVS requires
every single ,v file to be modified, and so is not a cheap
operation. The idea is to allow "lazy branching" where you say "any
file I modify I want on branch XYZ", but no actual branches are
created on any files until they're modified. This is what ClearCase
does and as a result, branching is a very normal, everyday
occurrence.

ClearCase comes with a wealth of features but you need to
decide which ones are useful to you and mold it into a process.
There are so many possibilities with ClearCase that it's often
money well-spent to hire someone at $65 (or more) an hour for a
while at the beginning to set things up for you. You're really
paying someone to formalize and codify an entire development
paradigm (ooh) so that your organization runs smoothly. In other
words, instead of changing the way you work to fit the SCM tool,
you structure the SCM tool to fit the way you work. That's worth
$$, IMO.ClearCase 4.0 introduces a default development process
model which might cut into the profits of some of those ClearCase
contractors, though.

Problems waiting with CVS:

Cleaning locks left when a workstation or server crashed or CVS
was interrupted by the user.

Removing working files that were checked out into the
repository and built there. (This was really bad when the
user's present working directory was inside the module they
were checking out....)

Changing permissions of files in the repository when files were
created with wrong modes or groups.

Reversing renames and moves that were done incorrectly.

Performing moves and renames (correctly).

Restoring corrupted RCS files.

Tracking down forgotten edit sessions and their associated
write locks.

Cleaning up error conditions related to having a "foo" child
directory and "foo,v" file contained in the same directory in
the repository.

Repairing erroneously moved tags.

Adding safety features like access control and setid
capability.

Some of this stuff had to do with training the engineers to stay
out of the repository, but vigilence was still required. Some of
these involved long debugging sessions to make repairs. Adding
features was sometimes complex or difficult and usually
time-consuming. (These features required changing the tool, not
using the *info hooks, which are broken when applying them to very
large numbers of files.) Some are avoidable by using certain new
modes of operation that weren't available back then. The rest were
niggling little annoyances that required frequent attention to the
tune of several hours per week.

[Paul Smith psmith@baynetworks.com] Obviously these decisions
have to be made on a case-by-case basis. I've said before, and I'll
repeat, I think comparisons between CVS and ClearCase are really
useful only insofar as they point directions in which they might
improve. I really believe they target completely different markets.
I'd not recommend ClearCase for a smaller development project, even
though I consider myself quite ClearCase proficient and I could
certainly manage it with relatively little overhead. Likewise, I'd
not recommend CVS for a development organization like the one where
I work. CVS is simply not powerful enough.

Anyone trying to train all their engineers in all this stuff is
just asking for trouble. You're thinking about it the wrong way.
ClearCase doesn't provide all this power and these advanced
features to confuse the everyday developer. They're there so that
the SCM admin folks can design and implement a complete system that
does what they want, how they want it done. Once that happens, you
train the developer's on the process you've designed. They don't
care about stuff in the Admin course, and most likely they don't
care much about most of the metadata. And the interesting parts of
the Fundamentals course can be condensed into a short intro plus
some Q&A on a web site or something. As I said, we give an hour or
so of training and a web site, and that's it. Obviously some people
"get it" better than others, but that's true of a week-long course,
too.

A good process should be a natural extension of the general work
flow of the development organization, so it shouldn't be hard to
understand or confusing. And the goal behind the advanced features
of ClearCase is to facilitate that so developers don't need to
know the gory details.

In favor of CVS

...I've found Clearcase to be very difficult to manage, and CVS
trivial. The trade-off is certainly in the branching structure.
Branching in CVS works, but it's not as graceful as in Clearcase.
Clearcase also has some nice features like their "find" command,
which can perform a UNIX-find-like operation on a revision history
tree. Very sweet. I find several things about Clearcase to be
annoying however:

It supports less system types than CVS.

It has its own filesystem type, and it's a bitch to administer
for certain configurations, so if your sysadmin and Clearcase
admin are not bestest-of-friends you may have some substantial
problems.

The per-seat licensing is a pain when you suddenly want someone
on the other side of the planet to access your repository ONCE.

The check-out, modify, check-in model is annoying. I find that
after getting over the intellectual hurdle of the way CVS does
it (it really does feel wrong), you get work done a whole lot
faster. I like not having to go around and pester someone for a
lock every 10 minutes.

I like the fact that the repository is a simple filesystem.
I've heard people talking, in this thread, about the "black
magic" required to deal directly with the CVS repository, but
at least I can see each file, and know where everything is. If
one file is corrupted (which I've never seen), I could easily
replace it from backups without taking down the whole
repository. Eggs... baskets... think about it.

CVS' remote-access model is so much more reasonable, and it
supports anonymous access, so if you need to provide access
(say on an intranet server to other random departments who need
to be able to track your code), you just give them the CVS
pserver path. I do have to say that in an environment where you
have a non-IP link (or no link) between you and another part of
the development team, Clearcase has some nice features (which I
know of, but have never tested). These features could be
emulated in CVS by using multiple modules, some of which are
maintained by the other site, but Clearcase is cleaner in this
respect.

Clearcase's hardware requirements are aggregeous. I can throw a
CVS server for a dozen users on a low-end PC or SPARC that is
also running an intranet server, DNS, samba and a printer, and
it doesn't even break a sweat. Clearcase wants dedicated, big
hardware. Dunno why.

CVS is much more suited to on-again-off-again network access
(e.g. I have a laptop that I connect to the corp. net once a
day, and otherwise am doing development on it wherever I happen
to be). Clearcase has a few ways of doing this, but none of
them is as graceful as CVS' "check out the tree, and check in
your changes whenever" model. Clearase, as mentioned above,
does a good job when you NEVER have a live connection to the
repository, but in this case, CVS does much better.

[Jan Stubbs jstubbs@microcadam.com] I have used CVS and Clearcase
at 2 different companies. At the larger company (my former
employer) we had 600 Clearcase licenses ($3000 a pop, you do the
math) and major hardware and support commitments (a manager with a
10 engineers, lots of big SPARC servers) to support it. This
compared to one server and NO support at all before we converted
from CVS. Yes, Clearcase has lots of functionality over CVS (one
not mentioned so far is the well integrated MS Visual Studio
support). But in the real world, most developers will not take the
time to figure out how to do the fancy stuff. And even the simple
stuff is VERY support intensive. Rational usually responds to a
simple problem in a couple days. You might have everyone in your
company unable to do a checkin for that long before you get an
answer. We did.

I remember a really "special" problem where the Rational GUI
checkin hourglass (some really cute spinning balls) caused all new
Dell PCs to freeze, requiring power cycling the PC. No other
application caused this problem, and we are a graphics company.
Rational was no help. A new graphics driver was the answer.
Contrast that to the open-source world where you can get an answer
for a problem in minutes through this group. And in my experience,
CVS problems are trivial compared to the CC problems we had.

Yes the CC triggers are very versatile. But my former emplorer tied
up one programmer for a year trying to implement a checkin trigger
to validate a problem database number in the checkin comment. 3
different platforms and 3 different version of PERL made it too
difficult. This could have been done with 10 lines of sh code in
the CVS commitinfo script. My former employer liked the parallel
Clearmake, it cut build time drastically. But they had to rewite
all the make files from scratch to make it work. Got a network NFS
server like Auspex or Network Appliance? Rational doesn't support
them. CVS - no problem. Performance? CVS wins again in most cases.

These factors partially explain why at this company we are
converting from CC to CVS. We especially like the speed with which
we can access our repository in Japan, compared to the complexity
and expense of CC Multisite, which costs $1500/seat and is (along
with the CC license ) 25% more in Japan.

15.0 Programming

15.1 Ascii.el

[Vinicius Latorre] 1999-12. This package provides a way to
display ASCII code on a window, that is, display in another window
an ASCII table highlighting the current character code.

15.2 C and Java code browser (Xref-Speller)

Xref-Speller is a tool extending Emacs and XEmacs (and partially
Kawa) environements by a number of source browsing and code
refactoring functions. Xref-Speller is based on full parsing and
understanding of source code while keeping good reaction time
thanks to incremental parsers. Xref-Speller's source browsing
permits you to move to a symbol definition, inspect all symbol
usages, examine only top-level or l-value usages. Powered by
automatic symbol resolution (+ overloading and virtual calls), you
just need to put the cursor on a symbol and push 'goto definition'
hot-key (See C screen shots, Java screen shots at the homepage).

Sources converted into HTML format can be browsed using
standard Internet browsers (examples).

Symbol retrieving can refresh your memory about program symbol
names.

At sharewareprices accessible for all.

15.3 C-mode-addons.el, some addon functions for c-mode

[Tijs Bakel] 2000-04. These are some simple addons we wrote
for c-mode. the original plan was to polish these routines and
then finally release them. because it was taking too much
time, i thought i'd better release them in this form.
documentation is not available. Visit #emacs at the
openprojects irc network for help. This adds two hopefully
useful, commands to cc-mode, namely c-synopsis and
c-eval-enum. c-synopsis shows you the synopsis for a given C
command in the minibuffer c-eval-enum shows you the number
associated with the current enum entry.

15.4 C-includes.el

[John Wiegley] 1999-03. This simple function prints out in a buffer
all of the files included by a C/C++ file. It's helpful sometimes
when debugging in deeply nested inclusion scenarios. Just setup
c-includes-path, and you're ready to run "M-x c-includes". With a
prefix argument, this command will ask you for a regexp, and will
print out all of the lines that match that regexp along the
inclusion path. You can then type C-c C-c in the Includes buffer
to go to that location. Finally, if the second argument to
c-includes is t, all it will do is return a list of the include
files to the caller. No messages, no buffer creation. This could be
used for deriving header dependencies, like what cc -M does.

15.6 Cc-mode with correct tab-indent

[Timothy Schaeffer] I have been able, through deliberation
and trial and error, been able to find a way to indent C and C++
code in such a way that the overall layout of the code is not
affected by the tab size. I used to do this manually in vi, but
read about CC-Mode in emacs, including its vaunted flexibility. I
immediately thought that there would be a way to configure CC-Mode
to indent the way I wanted it to. But, alas, CC-Mode uses emacs
indent-to to indent the code, based only upon a character count of
how much indentation is needed, and this either

fills it with tabs, according to the current tab-width, until it
cannot insert any more and fills the remainder with spaces, or it
just fills it with spaces. depending on whether indent-tabs-mode is
nil. The former will misalign code if tab-width is changed, and the
latter doesn't allow one to change the indentation size. In the
ideal, one should be able to change the amount of (visual) space by
which the code in a block, say, is indented, and one should be able
to align code that should begin at the same column in a way that is
not affected by tab-width. Changing the indentation (visual) space
without misaligning code can be done without modifying the file if
the tabs and spaces are inserted meticulously.

Unfortunately, CC-Mode cannot be configured to do this
automaticcaly, but this takes care of it.

15.7 Cc-tempo-electric.el

[Phillip Lord] and [Klaus Berndl] (Author) 2000-02. This package
provides support for insertion of electric characters with the
tempo package into cc-mode buffers. The current problem with tempo
is that it requires hard coding in the templates where braces, and
such forth should go, whilst cc-mode is perfectly capable of making
these decisions automatically. This package allows tempo to insert
these characters and have cc-mode behave appropriately. In practice
what this means is that instead of putting "{" into your tempo
template, you put (i ?{) (this should NOT be quoted, as tempo needs
to evaluate it!). If you have switched on the auto electric mode
within cc-mode it will now newline and reindent this "{" depending
on your indentation settings.

15.8 Cperl-mode.el (*), [X]Emacs

[Ilya Zakharevich] Major mode for editing perl files. Forget the
default perl-mode that comes with Emacs, this is much better.
Comes starndard in newest Emacs. (Ilya is one of one of the most
respected Perl core designers)

15.9 Delphi mode (*), Emacs

[Ray Blaak] 1999-03. Major mode for editing Delphi source
(Object Pascal) in Emacs. It is minimalist in that it is only
concerned with things that I actually find useful in a language
mode: indentation and coloring of keywords, comments, and string
literals. Delphi.el has been written from scratch, and is not based
on the Emacs' Pascal mode in any way. A lot of effort has been put
into getting the indentation right for Delphi constructs. It is
also fairly tolerant of syntax errors, relying as much as possible
on the indentation of the previous statement. This also makes it
faster and simpler, since there is less searching for properly
constructed beginnings.

15.10 ECB, Emacs code Browser

[Jesper Nordenberg] and [Klaus Berndl] 2001-03.ECB, Emacs Code ECB
is a source code browser that displays directories, files and
methods that can be navigated using the mouse. It is completely
written in Emacs Lisp and uses semantic to parse source files.
Currently supported languages include Java, C and Emacs Lisp
<http://sourceforge.net/projects/ecb>.

15.11 EDE, Emacs development environment

[Eric Ludlam] 1999-02. EDE (Emacs development environment) is an
Emacs lisp program which implements an environment similar to those
found in IDEs (Integrated Development Environment). While Emacs is
the premier development environment, and has lots of support for
this activity, EDE brings many divergent commands used for
debugging, and compiling and sticks them into a simple menu next to
commands used for maintaining a project file.

[2000-05-10 Paul Kinnucan paulk@mathworks.com Emacs JDE
mailing list] "Could EDE be used with JDE?" - My concern is that
it is C and makefile oriented and not easily adaptable to the
Java development model. I want something that is as easy and
intuitive to use as Visual C++'s project management system, not
something that requires you to handcraft make files. My view is
that it's okay for a development system to use makefiles
internally (as Visual C++ does) but the development system
should generate the makefiles automatically, not require the
user to do so. The development system should be able to use
makefiles created by users but it should not require users to
create makefiles. My problem with EDE at the moment is that it
does not abstract far enough away from the traditional Unix,
makefile-based development model. Essentially EDE is a thin lisp
wrapper around a makefile. You can't really create a project
without a fairly good knowledge of makefiles and makefile
terminology.

Eric Ludlam, EDE's author, is well aware of my concerns. We work
for the same company in the same building and have had many
discussions about the EDE. We have agreed to work together to try
to develop a Java project management system based on EDE. My role
would be to develop a prototype to see what, if any, additional
generic features EDE needs to accommodate Java. Eric would then
implement the additional core EDE features while I would
implement the Java specific extensions.

The ultimate goal would be to turn EDE into a true multilanguage
project management system that would allow you to create a
project with, say, a C component, a Java component, and even an
Emacs Lisp component, and then build the whole thing with a
single command. --Paul

15.12 Eiffel-mode.el

[Martin Schwenke] This is a major mode for editing and compiling
programs written in the objected-oriented language Eiffel. It has
been derived from eiffel4.el from Tower Technology Corporation

15.15 IDL Interactive Data Language (*)

IDLWAVE is an add-on mode for GNU Emacs (and XEmacs) which enables
feature-rich development and interaction with IDLŽ, the Interactive
Data Language, produced by Research Systems, Inc. It provides an
alternative to the IDLDE development environment bundled with IDL.

IDL stands for the Interactive Data Language. So these
modes are totally unrelated to the CORBA Interface Definition
Language.

15.16 Java buffi.el, compile multiple java projects

[Raphael Pierquin] buffi allows you to easily work on multiple
projects with different buildfiles at the same time. (Note : I call
a 'buildfile' any file that drive a compilation sequence, such as
Makefiles, or ant's build.xml files) It's especially useful for
Java projects where you're usually working with source code in
subdirectories with the buildfiles somewhere up the directory tree.
The idea is that you may have a dozen source files (including
buildfiles) open from different projects at the same time. If I'm
editing a file from Project A and execute 'buffi-build' (bound to
C-c c) then I probably want the buildfile from that project to be
executed. The buildfile is most likely either in the current
directory or one of its parents, and the code below will perform
that search and execute the "make" (or "ant") command in the
appropriate directory. The other case is when you execute
'buffi-build' and are NOT on a regular source file (maybe you're in
some random documentation buffer or something). In this case it
will do the best it can and execute the make on the first buildfile
buffer it can find.

15.17 Java Expert System Shell (jess-mode)

Jess-mode is a collection of Emacs Lisp files designed to
facilitate the development of Java Expert System Shell (JESS)
applications. Currently, the package consists of a major mode for
editing source and an inferior mode used to run the Jess
interpreter

M-x jdok-generate-javadoc-template or C-cj Inserts a javadoc
template above the method signature at point. before executing the
command, the point must be located at the first line of the method
declaration. if not result is uncertain.

In the following example, point is located at the beginning of the
line, before the word public (but it could be anywhere on this
line):

15.19 Java-Find.el, find and visit Java source files

[Joseph Casadonte] Emacs package that provides a way to find and
visit Java source files (indicated by a classname or filename under
point) located somewhere in the user's SOURCEPATH. There are other
packages out there that do similar things, including some things in
JDE, but I like this one. It works regardless of your mode, and
without tags. The only thing you need is a valid $SOURCEPATH.

15.20 Java-Font-Lock20.el

[Carl Manning] 1999-03 Java Syntax coloring for Gnu Emacs 20 based
on font lock. Improves robustness and correctness over the Java
font locking that comes with Emacs 20, and extends coloring for
Java1.2 features; see file for details. Includes non-garish color
schemes for both black on white and white on black, plus more basic
schemes for 16 color LCDs. Compatible with Emacs JDE.

15.21 Javahelp.el, Contextual java help

[1998-06-06 gnu.emacs.sources m2iumf4ho4.fsf@epinards.altern.org]
This is a package that adds a contextual help for the Java API
methods and classes (you know, the F1-key on most windows IDE, you
put the cursor on a method or classname, press the help key, and
the help appears for that particular keyword).

The first file is lexdfa.el, and is used to store a dictionary as a
deterministic finite-state automaton. The second is the javahelp
package itself (which relies on lexdfa for storing the
information). Because of the structure of the lexicon (stored as an
automata), the limits of structures depth need to be augmented.
Sorry for the inconvenience, I really didn't think about it when
developping the automaton (in fact it is my very first e-lisp
program). Maybe another method for storing the data would be better?

There is a newly created mailing list to make improvements to the
p4.el by having a dedicated mailing list. If you are interested in
joining that, please send body "subscribe"to
emacs-lisp-discuss-request@eng.fore.com --Rodrigo

15.22 Jcall.el, call Java from Elisp

[Helmut Eller] 2001-07. You need Java and Kawa Scheme
http://www.gnu.org/software/kawa/ this package allows you to
call Kawa (i.e. Java) from Emacs Lisp and vice versa. Emacs
Lisp objects can be passed to Java code and Java objects can
be passed to Emacs Lisp. There are two files jcall.el and
jserv.scm. Emacs Lisp objects can be passed to Java code and
Java objects can be passed to Emacs Lisp. The macros
eval-in-kawa and eval-in-emacs form the user interface:

(eval-in-kawa <form>...) sends <form>s to the kawa interpreter,
evaluates them, and returns a reference to a Java object.
(eval-in-emacs <form>...) is a kawa macro and is analog to
`eval-in-kawa'.

jde-cflow.el, abbrev mode control - disabled in comments[Philip Lord] This package automatically expands various
abbrevations into templates for the various control statements
within java. It uses tempo templates for this purpose, and is fully
customisable so that you can change the templates as you wish. or
the abbreviations if you want. The command M-x jde-cflow-customize
enters this mode.

JDOK[David Ponce 1998-10] This library helps to document Java classes
and methods. The command jdok-generate-javadoc-template
automatically inserts a javadoc block comment template above the
method, class or interface declaration at point (it assumes that
the declaration syntax is valid). The command jdok-customize (or
customize-group jdok) allows you to customize each category of
javadoc comment line (description, @version, @return, ...).

jde-hotspot.el[Philip Lord] Provides support for all of the hotspot options on
the command line. Because hotspot requires the "-classic" tag first
if it is going to be used I have to hack around with the core JDE
functions, which this file over-writes. I wrote a package
"jde-hotspot.el" a while back which hacked (and it is a hack!) JDE
to provide support for the -classic specification, and also for
turning on and off all of the various hotspot options. I'm on linux
now, and am hotspot-less so I can't guarantee that it still works.

jde-stack.el[Kevin Burton] This package provides the ability to jump
from stack traces to the relevant part of the java source. There is
one main entry point which is a mouse-1 click on the stack trace,
which will jump to the source suggested at this point. This should
also work in other buffers (for instance log files), by calling
directly the function jde-stack-show-at-point. Following this
entry point two functions jde-stack-show-next and
jde-stack-show-prev allow cycling backwards and forwards through
the stack trace. Error messages are given when the end of the stack
is reached.

15.24 Java-open.el

[Rajeev Karunakaran] 2000-07-30. Java is different from other
languages in that something like ETAGS is really not necessary to
figure out locations of files. This is because Java restricts you
to one public class per source file, and the name of the file must
be the same as the class. When this class is used in other files,
an import declaration is used. The import declaration specifies the
location of the class. All Emacs needs to do to open the Java
source file corresponding to the class name under point is to look
for the import declaration, and figure out the filename and
relative path from this declaration. Then CLASSPATH variable is
used to determine the absolute path. Java-open adds the ability to
open the source file corresponding to a Java class by placing the
cursor on the class name and pressing a key. No TAGS file or other
form of preprocessing is needed. Example of lines to be added to
your .emacs:

15.25 Java Template, jtemplate.el

[Brillant Alexandre] jtemplate is a package for emacs for
initializing easily class or interface. jtemplate uses XML
model for defining a basic structure with XML Tags.

15.26 Lazy-look.el, context-sensitive language help

[Eric Ludlam] 1999-02. Lazy look is a program which will bring up a
frame, and attempt to display context information. It is language
independent, and so far only supports emacs lisp (with the help of
eldoc) and c. For example, if the cursor is in a C buffer on a
variable name, lazy look will display the current function you are
in, the type of the variable, and any possible completions that are
available.

Note: See also tinytag.el for similar language help.

15.27 Lisp variants

acldoc.el

An emacs interface the the Franz Allegro Common Lisp documentation
tree by Larry Hunter hunter@nlm.nih.gov 1998-10

[Michael Shulman] 1999-10. Someone had mentioned mmm.el by
Gongquan Chen, an XEmacs extension allowing Multiple Major Modes in
one buffer. I looked into it, but found that it only worked for
XEmacs. "Oh, that's no problem," I thought. "I'll just change a few
things here and there and it'll work for Emacs." Well, you know how
it goes, and pretty soon I was rewriting the whole thing from
scratch, and adding new features as I went along. And now I'm about
finished. It's not a Mason mode, but rather something more general.
I've been using it with Mason as I developed it, and found it to be
very convenient: MMM Mode is a minor mode that allows multiple
major modes to coexist in a single buffer. See the documentation of
the function mmm-mode for detailed information on how to use MMM
Mode.

[Gongquan Chen 1998-12] Lisp extension that allows multiple major
modes to co-exist in a single buffer. It's a workable, yet
imperfect, solution that basically supports key bindings and
font-lock in those regions with a seconda major mode. To activate
one secondary major mode, simply add a hook to the primary major
mode's hook. For details, see defun mmm-activator.

[Gerd Neugebauer] 1994-11. Allow you to mix (for instance) html
code and c code in the same file. When entering the html areas of
the buffer you would be in html mode and when in the c areas, you
would be in c mode. Check archives for this old emacs
code.

15.33 OO-Browser

2001-05-23 There is no active CVS tree to download, only tgz kit. This project
is no longer active.

15.34 Showing tabs in buffer

15.34.1 Ascii-display.el

[Colin Walters] 2000-05. Have you ever wanted to see what ASCII
special characters are in the buffer? This might help. Currently it
only displays newlines and tabs. If I can figure out how to
consistently display returns (ASCII code 0x0D), that will be in a
future version.

15.34.2 Tab-display.el

[Kevin Burton] 2000-12. This is an attempt to handle tab display in
a way that makes things obvious when working with buffers. I
personally don't like using hard \t chars in my source files
because of width differences. You should turn font-lock-mode on
globally in order to see your tabs in color.

[2000-07-20 XEmacs-L Martin Buchholz martin@xemacs.org]
The byte-compiler knows a lot about what's good and bad in
XEmadc-land. So byte-compile the file using Emacs Lisp->Byte
Compile This File and the warnings can be very useful.

16.2 Autolisp.el, edit AutoCAD AutoLISP files

[Reini Urban] This mode will be enabled to use a patched ntemacs,
written by Steve Kemp skx@tardis.ed.ac.uk, resp. the w32ole
emodule written by myself, to be able to connect via OLE to a
running Visual Lisp for AutoCAD 2000 session.

16.3 Bm-hcmplt.el, facility to display descriptions of completions

[Yuji Minejima] 2000-03. FSF Emacs users can see the descriptions by
entering ? key. XEmacs users can see the descriptions by entering
any completion keys. Typical scenario #1 You hear that
apropos-XXX commands are very useful. So you enter `M-x
aprop<TAB>'. Emacs completes it to "apropos". you enter <TAB>.
Emacs says "Complete, but not unique". you enter ? and something
like the following displayed in a help window.

You can click an item (the middle button of your mouse), you can go
into the help window (M-v) then selete an item (RET), or you can
continue to enter in the minibuffer. See "(emacs)Completion" for
other key bindings.

16.4 Checkdoc.el (*), Emacs

[Eric Ludlam] The emacs lisp manual has a nice chapter on how to
write documentation strings. Many stylistic suggestions are fairly
deterministic and easy to check for programatically, but also easy
to forget. The main checkdoc engine will perform the stylistic
checks needed to make sure these styles are remembered.

[comment] If you're doing any lisp packages, this is a must have.
Together with lisp-mnt.el you can check you package layout for
variaous kinds of errors. Recommended, must be in every package
maker's toolbox.

16.5 Cl-array.el, CL's multi-dimensional arrays

[David Bakhash] Turn elisp almost completely into CL, at least with
respect to array manipulation. Some little issues. Since elisp and
CL will conflict on some function names, I've stuck with the cl.el
convention and defined the following: aref* length* vector*
vectorp* arrayp*

16.6 Closure.el (*), Emacs

[Peter Liljenberg] 1997-03. cl package provides closures with the
lexical-let form. I don't know what happened with closure.el (it
was renamed) with respect to FSF Emacs, but I doubt that XEmacs
needs closure.el. I'll put a newer version of closure.el at the URL
indicated above.

16.7 Crm.el, completing read multiple (*), Emacs

This code defines a function, completing-read-multiple, which
provides the ability to complete to multiple results in the
minibuffer. Each of the completed results is separated by a common
separator which the caller of the function may specify.

16.8 Eieio, subset of CLOS (Common Lisp Object System)

[Eric Ludlam] EIEIO implements a subset of CLOS (Common Lisp Object
System) which enables you to create objects, w/ singular
inheritance, and write methods. I was especially careful to try and
create an implementation that was very fast at runtime. EIEIO does
not support all of CLOS. Please check the texinfo manual for
details.

EIEIO has specialized byte compiler support, plus object browsing
functions. Because of the nature of byte compiling, EIEIO is picky
about the version of emacs you are running. It supports Emacs
19.2x+, emacs 20.x, and XEmacs 19.1x. I do not know if it works in
XEmacs 20.x as I have not tested that platform yet. Byte compiling
EIEIO is VERY IMPORTANT if performance is important. EIEIO supports
documentation generation. If you write an OO API to something, the
eieio-doc functions will write your texinfo manual for you. (Just
make sure you use the documentation features of class slots while
authoring your software.) EIEIO comes with several examples,
including a tree drawing program (which includes an emacs function
call tree browser) a bar chart program, and a generic database
access layer (which only has a PostgreSQL backend at the moment)

16.9 Elder.el, emacs lisp document writer

[Deepak Goel 2000-11] ELDER (Emacs-Lisp-Document-writER) allows you
to unite lisp with other languages. For instance, if you are
producing a MATLAB/latex document, but are frustrated with the lack
of ability of MATLAB/latex to do something, you can define a
lisp-region within your file, write your lisp-commands in there and
have fun! ELDER is particularly useful when producing
latex-documents. You may get so used to using elder that you may
group the most common functions you have defined into "elder-style"
files. The beauty of elder is that any file is a already valid
elder-file (since it likely does not contain any
elder-demarcated-lisp-regions yet) and so learning is easy. You
simply achieve more by defining elder-regions (mean: lisp-regions)
in the file. Basically, ELDER does a very simple job. It allows you
to introduce elder-regions within your document, and the text
within that region is processed as lisp commands. (Elder actually
does a lot more, but later..). ELDER thus removes all
lisp-expressions from the file and then the file is ready to be
processed by whatever the other language (MATLAB/latex/whatever)
you want to use. Elder-regions are regions demarcated by some
keywords:

([EBEG] and [EEND]) meaning elder-begin and elder-end,
respectively. This is called elder-region-A from now on. All
text found within these keywords is evaluated as
lisp-expressions. The value of the last expression (which
should ideally return a string) replaces the elder-region. In
principle, this alone is sufficient for all your needs, but
there are just a few more provisions.. - provided becauase
they make typing documents sooo much easier..

ELDER also allows you to define e-aliases. These ealiases are
more than just regular aliases.

Don't know too much lisp/elder? ELDER generates helpful
error-messages for any erorrs you make. Style-files are a list of
useful targeted elder-functions. For latex, there are 2
style-files..: article.est (lots of nifty little things) and
fundametal.est (barebones). Imagine writing your latex file as an
article, and with one switch, generating slides out of it. Or
removing/adding self-notes in a latex-document depending on whether
the document is a final draft or not.. Or printing out not just
equation-numbers, but also equation-labels along with equations
during your edit-phase, which makes "referencing" that equation 1.2
so much easier in your conclusions section---earlier you had to go
back and seasrch for that equation, and then look for the label you
defined for it.. Or auto-coloring math-environments in blue,
footnotemarks in red etc. etc.

16.10 Eldoc.el, show Emacs lisp function arglist (*), [X]Emacs

[Noah Friedman] This program was inspired by the behavior
of the "mouse documentation window" on many Lisp Machine systems;
as you type a function's symbol name as part of a sexp, it will
print the argument list for that function. Behavior is not
identical; for example, you need not actually type the function
name, you need only move point around in a sexp that calls it.
Also, if point is over a documented variable, it will print the
one-line documentation for that variable instead, to remind you of
that variable's meaning.

16.11 Elint, Emacs lisp syntax checker

[Peter Liljenberg] Now I've finished a new version of elint, an
Elisp linter. The most important improvement is that it now knows
about standard variables, and it should work not only with 19.34,
but also at least with 19.28

16.12 Ell.el, Browse the Emacs Lisp List

[Jean-Philippe Theberge] 2000-05. Emasc Lisp Lisp is available atIf Shephen
change the layout of his web page, this package may stop to work.
You may then need to upgrade this package.

16.13 Elp.el, emacs lisp profiler (*), [X]Emacs

[Barry Warsaw]. This module makes it easy to profile your lisp
functions. For easy interface to elp, see tinylisp.el in [Tiny
Tools]

16.14 Eval-expr.el, Better eval expression prompt

[Noah Friedman] 1998-07.

When reading the Lisp object interactively from the minibuffer,
the minibuffer uses the Emacs Lisp Mode syntax table. (Emacs
19.18 or later only.)

If you type an incomplete or otherwise syntactically invalid
expression (e.g. you forget a closing paren), you can fix your
mistake without having to type it all over again.

Displays the result in a buffer if it is too big to fit in the
echo area. This buffer is placed in Emacs Lisp Mode. (If you
give a prefix arg, the result is placed in the current buffer
instead of the echo area or a separate temporary buffer.)

The variables eval-expr-print-level and
eval-expr-print-length can be used to constrain the attempt
to print recursive data structures. These variables are
independent of the global print-level and print-length
variables so that eval-expression can be used more easily for
debugging.

16.15 Extre.el, extended regular expression syntax support

[Lars Ingebrigtsen] "extended regular expression syntax support".
I've now extended the regexp extender to understand most Perl
regexp elements. I've also switched from that horrible "#" escape
character to the more sensible "\" escape character. Here are some
example transformations:

16.17 Getdoc.el

16.18 Gnueval.el, fill out GNU evaluation form

[Thien-Thi Nguyen] GNU Evaluators' duties include filling out a
template to record their evaluations. But to fill out the template,
there are certain tasks that need to be done perhaps concurrently,
such as looking at source code and running the program. gnueval.el
provides two simple commands to make notes and to assemble the
final evaluation form suitable for mailing: gnueval-note and
gnueval-assemble, respectively. Additionally, current notes can
be cleared with gnueval-reset. During reset, if a gnueval-note
occurred more recently than a gnueval-assemble, you are asked
whether or not you want to continue. Lastly, this file provides
gnueval-submit, which does a gnueval-assemble, mails the
resulting buffer to the gnueval mailing list, and then (optionally)
clears the current package. There is no support for evaluating
multiple packages concurrently (and probably never will be). Even
more lastly, the command gnueval runs gnueval-note on all the
fields - this is useful for a first-pass evaluation. For
gnueval-note, you are presented with two buffers, one for
prompting text, and the other for input. When you are finished
entering input, type `C-c C-c' to finish.

16.19 Hyperspec.el, browse Common Lisp specs

See site of [Erik Naggum]

16.20 Ilisp.el, Inferior Lisp replacement

16.21 Lisp-index.el, Index Lisp files, with descriptions

[Steve Kemp] 1999-11

16.22 Lispdir.el

[Nguyen Thien-Thi] 1999-05, see ttn-pers-elisp. Enclosed is a nice
script that will generate an index of all of your lisp files,
including a description of the contents. I'm note sure how general
this will be - but it seems that most lisp files start with a line
of the form:

;;; name -- description.

If this is the case the description can be read, and it will be
added to the index.

16.23 Regexp-opt.el (*), Emacs

[Simon Marshall] Make-regexp has turned into regexp-opt which got
gobbled up by Emacs, so you don't need to look anywhere anymore. To
make efficient regexps from lists of strings. Originally written
for font-lock, from an idea from Stig's hl319.

16.24 Minibuffer-complete-cycle.el, cycle Completion buffer

[Kevin Rodgers], 1997 The minibuffer-complete command, bound by
default to TAB in the minibuffer completion keymaps, displays the
list of possible completions when no additional characters can be
completed. Subsequent invocations of this command cause the window
displaying the Completions buffer to scroll, if necessary. This
package advises the minibuffer-complete command so that
subsequent invocations instead insert each of the possible
completions in turn into the minibuffer, and highlight it in the
Completions buffer. As before, the window displaying the possible
completions is scrolled if necessary. This enhancement is enabled
or disabled by setting or unsetting the minibuffer-complete-cycle
option.

16.25 Obarray-fns.el, obarray-manipulating routines

[Noah Friedman] 1998-08-18. I had cause to write some routines for
manipulating obarrays in ome of my programs.

defun obarrayp (ob)

defun copy-obarray (ob)

defun make-local-obarray (sym)

16.26 Regress.el

[Wayne Mesard] 1997-02, enhancements by [Tom Breton] 1999-07. This
module provides support for writing and executing regression tests
for Emacs Lisp code. Nothing you couldn't do by hand. But by making
it easier, the hope is more people will do it more often.

The programmer puts one or more test suites directly in the
lisp file.

The programmer runs the tests in one of two ways: a.
Interactively, with M-x regress. b. Automatically, every time
the file is evaluated.

If there are any regressions, a report is produced detailing
the problems.

16.27 Require statement tracing

[Charles Waldman]

16.28 Run-command.el, lib for running external commands

[Peter Breton] 2000-10. A library to make running external programs
and writing program wrappers easier.It supports following. For any
of these modes, you can decide programatically whether or not the
results of the program are displayed to the user.

Running a command synchronously

Running a command synchronously on a region

Running a command asynchronously. Optionally, you can have
callbacks when the program completes

16.29 Sregex.el (*)

This package is part of Emacs.

[Bob Glickstein] 1997. Building regular exparession is not very
intuitive and when you finally get the regexp string right, it is
not obvious after 2-3 months what is was supposed to do. If you use
any complex regular expression in consider using this package to
build them more easily.It may document your code better.

16.30 Texidoc.el, have texi embedded in defvar

[John Wiegley] 1999-12. Emebbed Texinfo keeps the documentation
closer to the code, and allows the comments to serve as both.
Convert textual notations from point onward. Indent by two spaces
produces an example by three spaces produces a quotation.

16.31 Timerfunction.el

[Deepak Goel] Suppose you want emacs to run an action every
REDOSECS for as long as emacs remains idle. Think you can do it
with one call to the emacs' run-with-idle-timer? Think again.. :)
That function will perform the action exactly once every time emacs
goes idle. This function, tf-run-with-idle-timer will allow you
to keep performing an action as long as emacs remains idle.

16.32 Tmenu.el, a text based interface to the menubar

[Yuji Minejima] This package provides a text based interface to the
menubar. In order to test this as you see this file, proceed as
follows: 1: Load this package: M-x eval-buffer 2: Browse the
menubar: M-x tmenu-menubar 3: You see something like the following:
Click mouse-2 on a completion to select it. In this buffer, type
RET to select the completion near point. Possible completions are:

What's the differences between tmenu.el and tmm.el? I mainly wrote
this package to lean the differences in the menu APIs between GNU
Emacs and XEmacs, so I'm afraid there's no earth-shattering
features that tmenu.el can be proud of.

tmm.el

a standard package bundled with GNU Emacs.

is lightweight.

tmenu.el

runs on GNU Emacs and XEmacs.

allow the user to move around the menu hierarchy.

displays radio/toggle buttons.

16.33 Working.el, show progress while working

[Eric Ludlam] 1998-10. Working lets Emacs Lisp programmers easily
display working messages. These messages typically come in the form
of a percentile, or generic doodles if a maximum is unknown.
working-status-timeout if you want activity during a read/wait
loop. working-status-call-process like call-process, but uses
start-process and displays fun stuff. working-wait-for-keypress
and working-verify-sleep.

16.34 Xray.el, display internal object structures

[Vinicius Latorre] 2001-01-22. Sometimes you need to see
the internal structures to understand what is going on. This
package provides a way to display internal Emacs object structures
in a temporary buffer. xray was tested with GNU Emacs 20.6.1. So
far, there isn't any compatibility with XEmacs.

17.0 Modes

17.1 Mason-mode.el

http://www.masonhq.com/ What Is Mason? Mason is a
powerful Perl-based web site development and delivery engine. With
Mason you can embed Perl code in your HTML and construct pages from
shared, reusable components. Mason is open source. Although it can
be used from CGI or even stand-alone, it is optimally designed for
use with two other open source technologies: mod_perl and Apache.
Mason CVS access is at

[Fred Yankowski] 1999-12. I wasn't able to find an existing PHP
implementation, so I created one myself using define-derived-mode
to base it on c-mode. It works well, except for some glitches
handling shell-style ('#') comments. I have no particular
motivation to maintain a php-mode.el, so if some other PHP-mode
actually subsumes mine in functionality I might well switch over to
it. On the other hand, I'm willing to add functionality to my
php-mode.el if there's a call for it.

[2000-05-29 gnu.emacs.help Jaeyoun Chung jay@kldp.org] I've
written some elisp for this mostly to use while editing php-mode
and html-helper-mode simultaneously. You can add <?php ?> tag
extension in html-helper-mode (well, an exercise to the reader:P),
and then you can use this by binding something like `C-c i'.

17.3 Project-am.el, a project mode for emacs based on automake

[Eric Ludlam] 1998-10. This is to announce project-am.el, a project
mode for emacs based on automake. Many IDEs developed have a
concept of a "project", which is simply a file which tracks
targets, compiler flags, and other things. These "projects" then
form the basis of the compile,run,debug cycle.

We all know that Emacs is a better IDE than all those other silly
systems, but a project mode has always been absent. It's up to the
user to know how to run the compiler, and things like that.

When I first converted my GNU projects to Automake, that was when I
realized that the Makefile.am is about the smallest knowledge set
you could get to describe targets in a project. As such, this
project mode for emacs uses the automake file format as the basis
of the "ide" like environment.

This program provides a project-am-minor-mode. This is active
only for files in which a Makefile.am exists. It provides a keymap,
and menu bar item. From here, you can create new targets,
add/remove source files from targets, compile, and debug.

project-am was written and tested in Emacs 20.2. I have not tested
it on other emacses, but suspect it should work fine.

17.5 Tmmofl.el, toggles other minor modes based on font lock info

[Phillip Lord] 2000. This is a minor mode which does things
depending on the current font-lock symbol at point. This means that
you can use it to toggle for instance auto-fill-mode on when on
comments and off for the rest of the time. Its based on a more
generic form of jde-auto-abbrev.el, which I shall retire at some
time, or change to being a wrapper around tmmofl. There are two
files which are tmmofl.el which provides the core functionality,
and tmmofl-x.el which customises tmmofl for different major modes.
At the moment the latter is pretty small, but it may grow.

17.6 Smb-mode.el, editing SAMBA files

[Fraser McCrossan] 2003. A Major Mode for Emacs, to help the
editing of Samba's configuration file smb.conf It doesn't do
anything fancy, but it helps me, I hope it helps you. It's still a
work in progress, as well as being my first non-trivial Emacs Lisp
project. Comments, suggestions, and more code are welcome; email
address is at the bottom of the page.

17.7 Sawmill.el

[Dave Pearson] 1999-11. The Emacs mode for working with the
config files of sawfish. As well as providing a programming
mode (well, not so much providing as deriving) it also
includes a couple of function for interacting with a running
sawmill. I do have one small problem with this code and I
think it might be my lack of understanding of how
define-derived-mode works. The problem is that any
sawmill-mode buffer doesn't receive automatic font-locking
when global font locking is set (and font-lock-global-modes
is set to t). Also, when font-lock is turned on by hand it
doesn't do emacs-lisp "flavour" font locking despite the fact
that it derives from emacs-lisp-mode.

17.8 SML-mode.el

[Stefan monnier] SML-MODE is a major Emacs mode for editing
Standard ML. It provides syntax highlighting and automatic
indentation and comes with sml-proc which allows interaction with
an inferior SML interactive loop.

17.9 Verilog-mode.el

[from the page] ....Once you have completed the information the
verilog emacs mode will automatically be e-mailed to you. This will
also register you for automatic updates, everytime a new revision
is released.

17.10 Winmgr-mode.el, generic window manager mode

[David Konerding] (maintainer). This package is a major mode for
editing window configuration files and also defines font-lock
keywords for such files. winmgr-mode mode will automatically get
turned on if you visit a a file whose name looks like that of a
configuration file (IE, .fvwmrc, .mwmrc, .tvtwmrc, etc)

17.11 W32-help.el

[Theodore Jump] Select a C function in your program, click on it
and a help window would open with a description of the function,
its syntax, parameters passed etc.

18.0 Shell

18.1 ANSI-color.el, translate ANSI into text-properties (*)

[Alex Schroeder] 1999-11. Part of Emacs and XEmacs. This file
provides a function that takes a string or a region containing
Select Graphic Rendition (SGR) control sequences (formerly known as
ANSI escape sequences) and tries to translate these into faces.This
allows you to run ls --color=yes in shell-mode. In order to test
this, proceed as follows:

start a shell: M-x shell

load this file: M-x load-library RET ansi-color RET

activate ansi-color: M-x ansi-color-for-comint-mode-on

test ls --color=yes in the shell buffer

Note that starting your shell from within Emacs might set the
TERM environment variable. The new setting might disable the
output of SGR control sequences. Using ls --color=yes forces
ls to produce these.

[Yoann Padioleau] 2000-10. Try to colorize the buffers of emacs as
ls --color do in a terminal so if you try C-x b TAB or C-x C-f, you
will see directory in blue c source file in yellow, object file in
gray, it helps a lot to find the file you want to open.

18.3 Eshell.el, Emacs shell (*)

Included in Emacs 21

[John Wiegley] 1999-05. Basically, eshell is used just like shell
mode. Many of the keystrokes for moving around, and accessing the
history are identical. Unlike shell mode, however, eshell mode's
governing process is Emacs itself. With shell mode, an inferior
shell process is executed that communicates with Emacs via comint
mode. But eshell mode is a true, native Emacs module. No subprocess
are invoked except for those that you request in the eshell buffer.

See also [Joseph Casadonte]em-joc.el at which provides
some small additional function of eshell, the full-featured shell
written in elisp. Functions in clude a prompt replacement
(primarily replaces value of $HOME with a "~"), a "clear" function,
which clears the screen/buffer much like clear (Unix) or cls (DOS),
and a remote command, which lets you send the eshell a command from
some outside piece of lisp code.

18.4 Fshell.el

[Noah Friedman] 1998-08-18 If you give M-x fshell a prefix
arg after loading this, it will create a new shell buffer even if
one already exists. If you give it an explicit numeric prefix arg,
it will try to switch to that numbered shell buffer, or create it.
The alternative is to rename the current shell buffer and invoke
M-x shell, which is more keystrokes, especially if you decide to
name your old shell back when you're done with the newer one. rms
declined to add this functionality in emacs' shell.el, so I'm
maintaining it separately.

18.5 Mode-compile, remote compilation

[Heddy Boubaker] 1997. Provide mode-compile function as a
replacement for the use of compile command which is very dumb for
creating it's compilation command (use "make -k" by default).
mode-compile is a layer above compile; Its purpose is mainly to
build a smart compile-command for compile to execute it. This
compile-command is built according to number of parameters below.
Most of these parameters are higly customizable throught Emacs Lisp
variables (to be set in your .emacs or through Customization menu).
Running mode-compile after an universal-argument (C-u) allows
remote compilations, user is prompted for a host name to run the
compilation command on. Another function provided is
mode-compile-kill which terminate a running compilation session
launched by mode-compile.

18.6 Which.el, where is command

[Christoph Conrad] 1999-12-24. which.el is an
interactive function which takes a program name (string) as
argument and searches if it finds an executable with this name in
all paths of the variable exec-path. Almost every Unix system
(especially our beloved GNU/Linux) has this command 'on board',
some operating systems don't have. On operating systems like
Windows NT where there are several meaningful extensions (e.g.
"com", "exe") which can be a suffix of an executable you can define
a variable whose name is build from the concatenation of
"which-system-", the variable system-type and "extensions". It is
a list of extensions (strings) to append to the program name given
to the function which. If the environment variable "PATHEXT" is
available it is used instead! which-elisp is an interactive
function which takes a file name (string) as argument and searches
the files with this name and the extension ".el" in all paths of
the variable load-path.

19.0 Processes

19.1 Analog.el, monitor lists of files or command output

[Matt Hodges] 2000-10. I've written a small mode (analog) which
allows monitoring of groups of files (or output from commands). The
user just needs to specify a list of entries, so for example a
minimal setup might look like: Start the mode using M-x analog RET.
Pressing ? is the analog buffer will give help on key-bindings.

19.4 Top.el, running top(1) in emacs window

...This code sets up a buffer to handle running the "top" program
written by William LeFebvre. "top" is avaiable at
ftp.groupsys.com:/pub/top When you exit "top", the sentinel kills
the buffer. --Bill/Tom

19.5 Wget.el, wget interface for emacs

[Kevin Burton] 2000-11. This is an interface for wget. Basically it
allows you to pull down URLs and then view the output in a buffer.
This is a too to help develop/debug web applications. [maintainer]
alternatively look at Run-command.el and its wget implementation

TNT - Emacs client for AIM This is a robust client for the AOL
Instant Messenging service using the Emacs text editor as it's UI.
That's right - you can use AIM from within emacs! Check it out
just for the novelty, keep it for the convenience!

20.2 Dig.el, Domain Name System dig interface (*), Gnus

[Simon Josefsson] 2000-10. This provides an interface for "dig".
For interactive use, try M-x dig and type a hostname. Use q to
quit dig buffer. For use in elisp programs, call dig-invoke and
use dig-extract-rr to extract resource records.

20.5 Junkbust.el, configuring the Internet Junkbuster Proxy

[Neil van Dyke] 2000-11. junkbust.el adds some features to Emacs
for configuring the Internet Junkbuster Proxy(tm), aka Junkbuster,
which is a GPL'd filtering HTTP proxy from Junkbusters Corp.
<http://www.junkbuster.com/ijb.html>. The two main features
offered in this version of junkbust.el are:

Functions for adding new rules to the Junkbuster blocklist
without having to manually edit the blocklist file. The default
URL is taken from the native selection service. junkbust.el
generates a pattern from a given URL, including special-case
handling of URLs for Akamai-hosted objects. The blocklist file
is automatically checked writable from VC if necessary.

Fontifying of the Junkbuster blocklist. This is helpful in
reading the regular expression, and in distinguishing the
domain name and path parts of the rule patterns (which have
different syntax).

20.6 Lookup.el, electronic dictionaries

[Keisuke Nishida] Lookup is an integrated search interface with
electronic dictionaries for the Emacs text editor. You can use
various kinds of dictionaries, such as CD-ROM books and online
dictionaries, in an efficient and effective manner.

21.0 System administering and Linux

21.1 Apt-sources.el, Debian editing mode

[Rafael Sepulveda] APT is a package retrieval tool for Debian (a
GNU distribution, see <http://www.debian.org>); for example you
could install Emacs with following command nad APT will then
retrieve the package and install it for you:

$ apt-get install emacs21

The /etc/apt/sources.list file tells APT where to look for
packages. This mode font-locks the file and add some things
including new source lines and modifying existing source lines.

21.2 Protocols.el, reading the contents of /etc/protocols

[Dave Pearson] 2000-11. protocols.el provides a set of
functions for accessing the protocol in /etc/protocols.

The Dired that's part of EFS is an almost entirely different
program from the Dired distributed with GNU Emacs. I can't
comment on similarities or discrepancies between the two because
I use neither GNU Emacs nor its Dired. I don't know if the Dired
shipped with GNU Emacs works with EFS. I doubt it.

22.2 Filecache.el, files using a pre-loaded cache (*)

Included in latest Emacs

22.3 Fff.el, fast file finder

[Noah Friedman] 1994-03. This package provides you with a bunch of
shortcuts for visiting or inserting many different kinds of files
without having to know their full path name in the file sytem. For
example, you can quickly locate an emacs lisp library, shell
scripts in your executable path, search for TeX input files, use
the locate command (part of the GNU findutils package) to find
files anywhere on the system without a predetermined search path,
etc. You can even visit the source code for any lisp function
you've loaded from libraries or your own .emacs startup files; this
package figures out where it was loaded from and just takes you
there. Just like lisp machines used to do! There is a
well-documented set of library routines for writing your own
extensions. I've written several for scanning through system header
files, locating RFC standards documents (either locally or remotely
via transparent ftp), etc. If you'd like to look at any of these
extensions, just send me email.

22.4 Ff-paths.el, searches certain paths to find files

[Peter Galbraith] 1996-03 This code allows you to use C-x C-f
normally most of the time, except that if the requested file
doesn't exist, it is checked against a list of patterns for special
paths to search for a file of the same name.

22.5 Iman.el, man and info page completion

[Yuji Minejima] 2000-09. With this packege, short descriptions on
completions is displayed by pressing <TAB> (XEmacs only) or ?
which looks like: Click mouse-2 on a completion to select it. In
this buffer, type RET to select the completion near point.

22.6 Sure-tags.el

[Bob Glickstein] 1997. Enhances Emacs' tag-searching functions with
code that helps ensure the tags files exist and are up to date.
This file surrounds various tag-searching functions with code that

First makes sure you've selected a tags file;

Makes sure that tags file exists (and builds it if it doesn't);

Performs the requested search;

Retries the search if it fails, allowing you to first rebuild
the tags file or specify a new one

22.7 Thumbs.el, thumbnail images files

[Jean-Philippe Theberge] 2003-06. Package modifies dired-mode and
creates two new modes: thumbs-mode and thumbs-view-image-mode.
They are used for images browsing and viewing from within Emacs.
Minimal Image manipulation functions are also available via
external programs. The 'convert' program from ImageMagick
<http://www.imagemagick.org/> is required. The Esetroot program
from <http://www.eterm.org/> is optional (need by the desktop
wallpaper functionality)

22.8 Tramp.el, transparent remote accs, ssh (*)

[Kai Grossjohann] This package provides remote file editing,
similar to ange-ftp. The difference is that ange-ftp uses FTP to
transfer files between the local and the remote host, whereas
tramp.el uses a combination of rsh and rcp or other work-alike
programs, such as ssh/scp. For more detailed instructions, please
see the info file, which is included in the file tramp.tar.gz
mentioned below. See More at ftp://ftp.comlab.ox.ac.uk/tmp/Joe.Stoy/

[Gerrit Niestijl g.niestijl@rra.nl 2001-02-28] I am using
NTEmacs with Tramp succesfully using the Cygwin version of ssh and
scp. I can edit files on remote Linux servers without providing
passwords using the following syntax:
/r@scp:root@domino:/home/dbloader/load/sql/opname.sql I have
configured emacs to use Cygwin bash as its primary shell and used
ssh-keygen to generate the nessesary keys for ssh. I use cygwin
version 1.1.7-1. The openssh version that is included does not
work with NTEmancs/tramp. Instead I used another cygwin port:
ftp://ftp.franken.de/pub/win32/develop/gnuwin32/cygwin/porters/Mathur_Raju
You have to set thing up so that you can connect to the linux
machine without supplying a password. Short instructions below and
the Eamcs setup.

Create a directory $HOME/.ssh

Use ssh-keygen to generate the identity and identity.pub
files and put them in the $HOME/.ssh directory.

Setting up ssh to work without requiring any passwords: You
need a destination machine to trust the source machine. So
$HOME/.ssh/identity.pub (public key) of the source machine
needs to be appended to the list of keys in
$HOME/.ssh/authorized_keys on the destination machine. You
should be able to connect from within cygwin bash using:

[Raffael Herzog herzog@raffael.ch] 2000-03-20 gnu.emacs.help. I
was trying for hours to get Tramp to work with SSH. There are
basically two major problems with this:

SSH reads the password from a tty which Emacs does not provide.

For some strange reason, OpenSSH invokes the shell in a way
that it does not display a prompt when no tty is available
(BTW: can anyone explain that?)

My solution was the following one:

Get the source of OpenSSH, compile and install it. Afterwards,
modify the file readpass.c. Insert the line "from_stdin=1" as
the very first line of the function read_passphrase(). Like
that, SSH will prompt for a password as it does usually and
read it from stdin. Type "make" (NOT "make install") and copy
the new ssh executable to /usr/bin/ssh-stdin.

Create a one-line-script:

#!/bin/bash
exec ssh-stdin "$@" bash -i

This will invoke the patched SSH client and force a interactive
shell. I called this script ssh-tramp and put it in my PATH.

Now, the problem is, that tramp tries to invoke its own shell,
which in turn won't display any prompt neither (???). So you
have to create another one-line-script on the server:

#!/bin/bash
exec bash -i "$@"

I called it /bin/bash-interactive.

Configure tramp: For the SSH methods, set tremp-rsh-program to
"ssh-tramp" and tramp-remote-sh to "/bin/bash-interactive".

After this, tramp will work with OpenSSH. I'll send feature
requests to the responsible people. The basic idea to fix this
without patching and scripting is the following:

The client of OpenSSH should take an argument whether it is
acceptable to read the password from stdin (instead of the
hardcoded and patched alternate SSH client).

Tramp should be a bit more configurable concerning the options
to be passed to tramp-rsh-program and tramp-remote-sh. Like
that, those "scripts" could be elminated.

23.0 File Backups

23.1 Auto-save.el (*)

[Part of XEmcs][Sebastian Kremer] 1992. Combines autosaving for
ange-ftp (to a local or remote directory) with the ability to do
autosaves to a fixed directory on a local disk, in case NFS is
slow. The auto-save file used for /usr/foo/bar/baz.txt will be
AUTOSAVE/#\!usr\!foo\!bar\!baz.txt# assuming AUTOSAVE is the
non-nil value of the variable auto-save-directory. Takes care
that autosave files for non-file-buffers (e.g. mail) from two
simultaneous Emacses don't collide. Autosaves even if the current
directory is not writable. Can limit autosave names to 14
characters using a hash function, see auto-save-hash-p. See
auto-save-directory and make-auto-save-file-name and references
therein for complete documentation. M-xrecover-all-files will
effectively do recover-file on all files whose autosave file is
newer (one of the benefits of having all autosave files in the same
place).

[Part of Emacs and XEmacs] It allows version stamping and retains
the absolute path information of the file (so that like-named files
ala Makefile don't blow each other away). Apparently it's going to
be the standard implementation of this functionality in subsequent
releases of XEmacs.

23.3 Backup-subdir.el, backup files in separate directory

[Greg Klanderman] 1995-10. Allows backup files to be optionally
stored in some sub-directories, based on the value of the alist,
bkup-backup-subdirectory-info. This variable is an alist of
(FILE-REGEXP . (BACKUP-DIR OK-CREATE USE-FULL-PATH)) If the
filename to be backed up matches FILE-REGEXP, or FILE-REGEXP is t,
then BACKUP-DIR (which should end in "/") is used as the path for
its backups. Directories may begin with "/" to specify an absolute
pathname. If BACKUP-DIR does not exist and OK-CREATE is non-nil,
then it is created if possible. Otherwise the usual behavior
(backup in the same directory as the file) results. If
USE-FULL-PATH is non-nil, then the full path of the file being
backed up is prepended to the backup file name, with each "/"
replaced by a "!". This works well for absolute backup paths. If no
FILE-REGEXP matches the file name being backed up, then the usual
behavior results. The package also allows version-control to have
the value 'preserve-prefer-numbered. With this value, new files and
files which already have numeric backups get numeric backups, but
if there is a non- numeric backup already, it is preserved.

23.4 Ebackup.el, Enhanced backup operation for Emacs

[Kevin Burton] 2000-10. Basically mirrors the filesystem that I am
editing and copies all new backups into backup directory that you
specify. Default is ~/.backups Should work out of the box. All you
really need to do is add this to your lisp load path and do a
(require 'ebackup). You should also read the backups section of the
GNU Emacs manual to determine how to turn this on.

24.0 Compression and cryptography

24.1 Browse-tar.el

[Gareth Owen] 1999-02. Browse files in a tarball
memory-efficiently. This uses tar (z)tvf to browse a gzipped tar
file without opening the whole thing, in a dired-stylee. Knocked
together in a fit of pique after trying to read the xemacs source
tarball in xemacs chewed through all my swapspace one afternoon,
and as an exercise in thesis avoidance. The trade off is memory
usage vs. speed. This is very slow on large, compressed tarballs,
and each operation is slow individually, but relatively low memory
machines (like old 486s running one of the i386 unices) don't
handle these well with jka-compress and tar-mode either.
XEmacs-20.4 was a 13MB gzipped tarball and the similarly packaged
linux kernel 2.0.36 was 7MB, so the memory savings can be pretty
high too. On small files the saving/price is pretty low, and
tar-mode/jka-compress have approximately 10^13 more features, so
I'd advise you to go that way.

24.2 Crypt++

[Karl Berry] Why use this instead of jka-compr? It uses magic
numbers instead of filenames to determine the (de)compression
needed; It automatically decodes DOS and Mac text buffers, and
does the right thing when writing changed buffers (namely asks the
user); It does encryption (not that I personally have made much use
of it).

[1997-08 gnu.emacs.help] ...I would like to be able to invoke
emacs on a file of an arbitrary extension (.pgp, .asc) and have
Emacs enter a special 'mode' and try to decrypt the file using
standard PGP calls, and then at the end of the edit session,
re-encrypt the plaintext (preferably only in the buffer) and save
it back as the original .pgp/.asc format.

[John Heidemann] The crypt++.el that I had, supported only
symmetric-key encryption with pgp (pgp -c). I have modified it to
add public-key support (not as trivial [or clean] as another entry
in crypt-build-encryption-alist because public-key encryption is a
slightly different beast). See the URL.

crypt++ version 1.11 1998-03 is very limited,
because it hooks itself into find/-write-file-hooks. This means
that the lowlevel commands like write-region, loadload-fileload-library which don't run those hooks, can't
decompress files.

Jka-compr.el handles everything like clockwork and you can
forget that you use compression; the only indication you need is
the suitable extension for filenames, like ".gz" when reading or
writing to. The only bug in jka-compr is that it blindly looks
the file extension and not the magic bytes like crypt++. This is
a problem sometimes, e.g. when trying to save base64 opened gzip
file. (you can't save as ".gz" because jka-compr would gzip it
second time)

24.4 Mc-safe-sign-message.el

[Kevin Burton] 2000-11. I became tired of mc-sign signing mails that
I had already encrypted. This is just some lisp magic to only
sign if I haven't encrypted. This also caused some problems with
mailers that required passphrases to be entered twice, once on
verifying the signature and again when decrypting.

24.5 Ssl-hacks.el

ssl-find-file prompts for the file name and
passphrase and decrypts the file using ssl-program directly into
the buffer. It then installs a write-file-hook to call
ssl-write-file. ssl-write-file prompts for a passphrase and
encrypts the file using ssl-program by piping the buffer (via
call-process-region) to openSSL so that your text never gets stored
in the clear on disk. It also installs a write-file hook to itself.
Passphrases are cached associated with each buffer, and are given
as the default passphrase on subsequent writes. The only clear
exposure for passwords is the fact that I pass them on the command
line to ssl-program (they can be seen, albeit very ephemerally, by
ps on some systems), and that they may get written out to the
swapfile. If those exposures are too dangerous for your data, you
probably don't want an emacs hack; you should use the openSSL
program directly.

24.6 TinyPgp.el

#URL-HOME/emacs-tinypgp.html

NOTE: Discontinued for the time being, no future plans ahead.

TinyPgp is intended to be a 2nd generation Emacs PGP interface and
it supports all major pgp commands as a minor mode that can
be turnd on in any buffer. In adidtion to PGP 2.6.x and 5.x, TinyPgp
offers easy Remailing and anonymous account handling commands
to different servers. Interfaces directly supported are VM, RMAil, Gnus,
TM, SEMI BBDB. Platforms supportd are Unix Emacs/Unix XEmacs/NT Emacs and
NT XEmacs.

25.0 Directory

25.1 Dired-a.el, extensions to dired

[Inge Frick]1996-08.

The delete command can delete a non-empty directory by deleting
all its files and subdirectories.

The copy command can copy a directory by copying a directory
and all its files and subdirectories.

Handle archives (tar, arc, lharc, zoo etc.). This is not a
replacement for tar-mode or archive-mode but it complements
them. There are commands unpacking an entire archive,
extracting specified files (it might be better to use tar-mode
etc. for this) and get a content listing. Furthermore the copy
command is extended to copy marked files to a target that is an
archive.

View files with a method depending on file name.

Print files with a method depending on file name.

Remove carriage return at end of lines for marked files.

Toggle case for file base name (excluding the extension).

25.2 Dired-single.el, reuse the current dired buffer

[Joseph Casadonte] This package provides a way to reuse the
current dired buffer to visit another directory (rather than
creating a new buffer for the new directory). Optionally, it allows
the user to specify a name that all such buffers will have,
regardless of the directory they point to.

This feature is also built in file tinydired.el included in Tiny Tools
Kit.

25.3 Js-dired.el, lisp ls emulation for win32

[Jonas Steverud] 1998-09. The directory is represented internally
as a list of alists. Doens't rely on external programs.

25.4 Browsing ls-lR

See dired-virtual-mode in standard Emacs dired-x.el.
This is useful if you want to peruse and move around in an ls -lR
output file, for example one you got from an ftp server. With
ange-ftp, you can even dired a directory containing an ls-lR file,
visit that file and turn on virtual dired mode. But don't try to
save this file, as dired-virtual indents the listing and thus
changes the buffer.

25.5 Mc.el, Midnight commander emulation

[Kevin Burton] 2000-01. This package provides Midnight
Commander style emulation for Emacs. Midnight Commander is a UNIX
application with a User Interface similar to the old DOS program
named Norton Commander. Basically this provides the user with a
quick, two pane interface to their file system. I wanted to model
it after Midnight Commander because it is Free Software (Norton
Commander is not) and recent UNIX/Linux users will generally be
more familiar with Midnight Commander. Users of dired will be
familiar with mc because dired features are still present. All
directories are at the top of the dired buffer and are bold.
Symbolic links which are also directories are bold and italic.
Regular symbolic links are just italic. Files have no attributes.
There is another package which does not use dired. It is named
nc.el by [Ilya Zakharevich] and is It generally tries to target the
DOS equivalent Norton Commander.

25.6 Md5-dired.el, make dired sensitive to file changes

[John Wiegley] 1999-04. This mode extends dired to be sensitive to
changes within files. When you're in a directory and you want to
know when a file changes, type @u in the dired buffer. If you visit
that directory again (or revert it), and the file has changed, its
date/time string will be bolded. Use @u to update the checksum.

25.7 Dired-dd.el, Dired Drag and Drop

[Seiichi Namba]
#todo

25.8 Dired-single.el

[Joseph Casadonte] 2001-02. Emacs package that provides a way to
reuse the current dired buffer to visit another directory
(rather than creating a new buffer for the new
directory). Optionally, it allows the user to specify a name
that all such buffers will have, regardless of the directory
they point to.

25.9 Dired-sort.el, sort by date-type-size-field

Dired-sort.el date-parse.el included in [Tiny Tools]. [maintainer]
Author unknown, RCS was signed by "fad." No LCD entry in the file
mentioned. This package requires date-parse.el package too. Sort
commands available:

25.10 Dired-sort-menu.el,

[Francis Wright] Adds a sort sub-menu to the dired-mode Immediate
menu that supports the relevant GNU ls sort options, namely name,
time modified, size, extension, unsorted, time created/changed,
time accessed (not under Windows), reverse and recursive. It is
also available as a pop-up menu on shift-mouse-2 and a static
dialogue window or frame bound to C-d, which is useful for changing
several dired sort options at once. Adds key bindings to toggle
some options, and alternative functionality to mouse-2 on
meta-mouse-2 / control-shift-mouse-2. Provides a sub-menu to save
and restore dired sort configurations. Attempts to disable
menu/dialogue options that are invalid for the ls program or ftp
server being used to generate the dired buffer. The dialogue does
not require a GUI (whereas the menus do).

25.11 Dired-tar.el

Jim Blandy jimb@cyclic.com Creating and tarring files in dired
couldn't be easier than this. T on a tar file unpacks the tar
file, uncompressing it if necessary. T on a directory packs up
that directory into a gzipped tar file.

25.12 Wdired.el, rename files in dired

[Juan Garcia] wdired.el is a package that allows you
to rename files by editing directly an "dired-alike" buffer.
So, you can use C-x r t (string-rectangle), M-%
(query-replace), M-c (capitalize-word), etc to change the name
of the files in a dired buffer. All the power of emacs
commands are avaiable to renaming files! This package provides
a function that creates a buffer identical to a dired buffer,
but editable (and commands of dired mode don't work in this
buffer). Here you can edit the names of one or more files and
directories, and when you press C-c C-c, the renaming takes
effect. If you change something out of the names, or add or
remove lines, umpredictable renamings would be done. You are
warned, and remember that this software comes without any
warranty :). Help is very welcomed to do something that avoid
users shooting at therir foot, but without losing "freedom" at
editing the file names.

26.0 Drawing

26.1 Artist.el, hi-tech character based drawing package (*)

Included in Emacs 21.1

[Tomas Abrahamsson] Artist is an Emacs lisp package that allows you
to draw lines, rectangles and ellipses by using your mouse and/or
keyboard. The shapes are made up with the ascii characters |, -, /
and \.

Intersecting: When a | intersects with a -, a + is drawn,
like this:

--+-- X
| / \

Rubber-banding: When drawing lines you can interactively see
the result while holding the mouse button down and moving the
mouse. If your machine is not fast enough (a 386 is a bit too
slow, but a pentium is well enough), you can turn this feature
off. You will then see 1's and 2's which mark the 1st and 2nd
endpoint of the line you are drawing.

Arrows: After having drawn a (straight) line or a (straight)
poly-line, you can set arrows on the line-ends by typing < or
>.

Flood-filling: You can fill any area with a certain character
by flood-filling.

Cut copy and paste: You can cut, copy and paste rectangular
regions. Artist also interfaces with the rect package (this can
be turned off if it causes you any trouble) so anything you cut
in artist can be yanked with C-x r y and vice versa.

Drawing with keys: Everything you can do with the mouse, you
can also do without the mouse.

Aspect-ratio: You can set the variable artist-aspect-ratio to
reflect the height-width ratio for the font you are using.
Squares and circles are then drawn square/round. Note, that
once your ascii-file is shown with font with a different
height-width ratio, the squares won't be square and the circles
won't be round.

Shapes (see) below) lines are lines that go horinzontally,
vertically or diagonally. Plain lines go in any direction. The
shapes in the right column are accessed by holding down the
shift key while drawing.

26.2 Boxquote.el, wrapping text

[Dave Pearson] boxquote provides a set of functions for using a
text quoting style that partially boxes in the left hand side of an
area of text, such a marking style might be used to show externally
included text or example code.

----
| The default style looks like this.
`----

A number of functions are provided for quoting a region, a buffer, a
paragraph and a defun. There are also functions for quoting text while
pulling it in, either by inserting the contents of another file or by
yanking text into the current buffer.

26.3 Gnuplot.el, mouse driven GUI for gnuplot program

[Bruce Ravel] 1998-09. Gnuplot is my utility of choice for quick 'n'
dirty plotting chores. I don't love Gnuplot's command line
interface but I find mouse-driven, GUI oriented plotting tools to
be slow and unwieldy to use. My solution is to run Gnuplot from
within Emacs or XEmacs where I can edit entire scripts then send
the script to a Gnuplot process. Because it is Emacs, I have access
to a large number of useful tools to help create good scripts. Our
Gnuplot mode has the following features:

Automated completion of common words in Gnuplot and automatic
indentation

On line help using Info for Gnuplot functions and features

Interaction with Gnuplot using comint

Convenient key bindings and a pull down menu

Customizable using the custom package

Works with Emacs 19.34 and 20.2 and XEmacs 19.14 and 20.4

26.4 Rebox.el, Handling of comment boxes in various styles

[Francoise Pinard] 2001-08. For comments held within
boxes, it is painful to fill paragraphs, while stretching or
shrinking the surrounding box "by hand", as needed. This piece of
GNU Emacs LISP code eases my life on this. I find only fair, while
giving all sources for a package using such boxed comments, to also
give the means I use for nicely modifying comments.

26.6 Table.el,

This is a package that provides Emacs a table
creation/editing feature. It has some known issues in operation
under XEmacs. It also has problem in use with flyspell package.
However, I believe many will find it invaluable feature in ordinary
documentation work. Any suggestion/criticism for improvement is
welcome. It has been tested under Emacs 20.7.1, Emacs 21.0.90.1 and
XEmacs 21.1.9. M-x insert-table inserts a table at the current
point location. Suppose we have the following situation where -!-
indicates the location of point. Executing the command M-x
insert-table with 3 columns, 1 row, cell width 5 and cell height
1 produces

+-----+-----+-----+
|-!- | | |
+-----+-----+-----+

M-9 M-x widen-table-cell(C->) widens the first cell which results
as

+--------------+-----+-----+
|-!- | | |
+--------------+-----+-----+

Doing M-x widen-table-cell(C->) to middle cell and M-27 M-x
widen-table-cell(C->) to the right cell creates the next result.

27.0 Writing, reading and modifying documents

27.1 AUCTeX

[David Kastrup] AUCTeX is probably the most sophisticated
document creation environment available for writing and
creating TeX-based documents. It's probably nicest under the
upcoming Emacs 22 series, but works on Emacs 21 and XEmacs as
well. While the focus is on LaTeX, the LaTeX project's docTeX
style, Texinfo, ConTeXt, plain TeX and AMSTeX are also
supported. Versions later than 11.80 include preview-latex
<http://www.gnu.org/software/auctex/preview-latex>
functionality that allows for WYSIWYG previews of LaTeX's math
mode and other customizable fragments right in the Emacs
source buffer. AUCTeX parses source files to offer context
sensitive macro completion, language shorthands, highlighting
and other input aids, and has TeX shell functionality for
interacting with a variety of TeX engines (including Omega and
PDFTeX), previewers (using forward and reverse search where
available) and other utilities and stepping through
compilation errors easily.

27.2 Auto-capitalize.el, capitalize the first word

[Kevin Rodgers] 1998-05. In auto-capitalize minor mode, the first
word at the beginning of a sentence or a paragraph (i.e. after
sentence-end, or after paragraph-start at left-margin) is
automatically capitalized as soon as it is inserted.

27.3 Auto-correcting words

[John Wiegley] The code automatically corrects single-character
transpositions in textual input. I wrote it because character
transpositions (like "hwat" for "what") constitute 95% of my typos.
The idea is very simple. The function runs whenever an abbrev
expansion would run. If the word doesn't exist in the dictionary,
it will start transposing characters from the beginning to the end,
until it hits a valid word. If it can't find a valid word, it
leaves it alone.

27.4 Clipper.el, save strings of data for further use

[Kevin Burton] 2000-12. Clipper is a way to handle 'clips' of text
with some persistance via handles. A good example is something like
the GNU Public License. If you do a lot of Free Software work and
need to have a copy of the GPL for insertion in your source files,
you can save this text as a 'GPL' clip. When you call
clipper-insert you will be prompted for a name and when you enter
GPL this will be inserted.

27.5 Blank-mode.el, Minor mode to visualize whitespace

[Vinicius Latorre] 2000-07

27.6 Deleting text

27.6.1 General deleting utilities

Greedy Delete[Barry Warsaw] 1997-02. A mode for more hungrily deleting
whitespace. Useful in major-modes, and patterned after cc-mode's
hungry-delete minor mode. The variable gd-how-much controls how
much preceding whitespace is consumed when the delete key is hit.
For non-greedy deletion the gd-delete-function variable is
consulted.

TinyEat
Included in [Tiny Tools] kit.

Reprograms your Backspace and del keys.

Determine how much text should be eaten around current cursor
position. Eat extra spaces, extra newlines, next word next
statement, next comment ... whatever is appropriate

When you grow accustomed to this, it probably replace your old
deleting habbits.

Can also eat inside mixed case word: WordsThatAreLikeThis

27.6.2 Deleting whitespace

TinyMy
See [Tiny Tools] kit. Among other features that are packed to this
module it has some buffer utilities.

Trimtrailingwhitespaces from the buffer when file is saved.

Renaming shell or mail buffer easily to get another shell
or mail buffer.

Adding up numbers in rectangle area

Scrolling jumps to window end/beginning and does not scroll
immediately. See variable timy-:scroll-mode for more.

Stamping Docid: and Contactid: and LCD package entry fields.
when you save the buffer.

Chmod'ing buffer to w+ or w- on disk.

Gzipping or Ungzipping current file buffer.

whitespace.el[Noah Friedman] Nukes trailing whitespace from the ends of lines,
and deletes excess newlines from the ends of buffers, every time
you save. It's mode-sensitive, so for some modes it will ask you
before doing anything; in some cases it will clean up whitespace
unconditionally; and in other cases it will never do so.

27.9 Faq-mode-el, reading faqs

[Brent Burton] FAQ-mode makes reading FAQs easier by creating a
special read- only buffer that intelligently navigates the FAQ.
It's a bit like hypertext, and a bit like Emacs' View mode.
Whatever it may be like, faq-mode makes reading a FAQ's index and
locating the answer among possibly thousands of lines of text much
easier.

[maintainer]: If you're planning to write new faq or convert
existing faq, have a look at tinytf.el in [Tiny Tools] kit.

27.11 Glyph-highlight.el, display non-ascii chars

[Samuel Padgett] 2001-03. This packages highlights various
special characters with faces. The intent is to make it easy to
distinguish between ordinary characters in a buffer and the glyphs
Emacs uses when displaying control characters and octal codes and
the like.

27.12 Ietf.el, IETF Document Retrieval

[Dinesh Dutt] 2000-05. Based on a posting to this newsgroup on
doing RFC retrieval, I have put together a package to retrieve more
than just RFCs. It can retrieve Internet Drafts, BCPs and FYIs. I
do not have the original posting of the RFC code and so do not have
the original poster's name whose code I have used as the heart of
this package. If you can please contact me, I'd like to add your
name to the author list.

27.13 Longlines.el, automatically wrap long lines Some text

[Kai Grossjohann] 2000-03. Editors save text files with long lines,
and they automatically break these lines at whitespace, without
actually inserting any newline characters. When doing M-q in
Emacs, you are inserting newline characters. This file provides a
file format which automatically fills the long lines when reading a
file and unfills the lines when saving the file. There is also a
mode function, so you can do stuff like the following:

(add-to-list 'auto-mode-alist '("\\.ll\\'" . longlines-mode))

This means that all .ll files are assumed to have long lines
which will be decoded on reading an encoded on writing.

27.14 Maniac.el, fill like maniac

[Per Abrahamsen] and [Hrvoje Niksic] (Maintainer)

27.15 Mult-press.el, home, end key-magic

[Ilya Zakharevich] This package uses a variable
mult-press-cutoff-time that shows how many microseconds should
separate two keypressed before they are not considered a part of a
multipress. Set to 1 secs in sake of systems where microseconds are
not available. The only function is mult-press, that returns repeat
count of this keypress as a part of multipress. Possible usage: for
defining bindings that behave differently on the first keypress and
on the second one and others, like.

27.16 Pc-keys.el, Smart home and end keys

[Kai Grossjohann] 1998-12. Some useful bindings for Home and End
keys: Hit the key once to go to the beginning/end of a line, hit it
twice in a row to go to the beginning/end of the window, three
times in a row goes to the beiginning/end of the buffer. NB that
there is no timeout involved.

27.17 Rewrite.el, rewrite text files with regexps

27.18 RFC.el

[Kaarthik Sivakumar] RFC mode is very usefull mode to write RFC and
Internet-Draft on Emacs. You can fill, indent, or itemize paragraph
as you like. You are also able to put words to the left, center,
and right or to split to the both ends of the line. Formatting
mechanism is really cool and method to draw a protocol header frame
is neat.

27.19 Rfc-page.el

[Kaarthik Sivakumar] I wrote a set of functions that can help in
viewing rfc's narrowed to pages. Also provides a function to jump
to pages directly. This uses a particular format in RFCs, namely
the page separator (^L) and the footer. The header is not used in
this case, but each page should be separated by a ^L in the rfc
text. The footer is used to jump to pages, since footers are
usually of the form:

Moy Standards Track [Page 243]

27.20 Rfc-util.el, RFC-util interface for emacs

[Kevin Burton] 2000-10. An interface to rfc-util to download RFC's
and view them. Keeps RFCs on disk so that you can view them in the
future. You will need to install rfc-util in order to use this.

27.21 Rfcview.el, view IETF RFCs

[Neil Dyke] For historical reasons, IETF Internet RFCs are required
to be in a plain ASCII text format that's best-suited for sending
directly to a 6-lpi US-letter-size printer. This makes them
suboptimal for viewing on-screen, as you will be doing for
countless hours if you're ever doing network programming to one of
them. Fortunately, the ASCII format is usually close to what you,
the Emacs zealot, truly want – which is a format suited to more
pleasurably viewing the RFC in Emacs. The rfcview package uses
Emacs overlays to add some fontification and hide the page headers
and footers (which it replaces with one-line page number references
that look like "(p.1)", right-justified). The file is never
modified, and you can see the raw ASCII text by pressing t.

27.22 Translation.el, translation minor mode

[Christophe Deleuze] 2000-02. This is a minor mode I developped
primarily because I maintain a few french translations of Linux
HOWTOs. It allows concurrent displaying of two versions (in
different languages) of the same structured document. You can
easily manage to display what the paragraph/section/etc you're
currently editing looks like in the other language.

27.23 QA.el

[Thien-Thi Nguyen] Do you do QA? (why not?!) do you use emacs?
(that's better.) do you wish for an emacs environment for managing
spec, test case database, test runs and html reports? (ok, no need
to answer...) QA uses EDB, the Emacs Database for the test case
database and test run file. pointers to EDB in the site above.

27.24 TinyTf.el, white paper minor mode

In [Tiny Tools] kit. 1995-02 A universal "white paper" minor mode
for writing yexy with layout called TF (technical format). It can be
used to write memos, papers, big documents (Megs), faqs or anything
that is represented in text.

27.25 Templates: tempo, skeleton, expand, dmacro

ELSE - Emacs Language Sensitive Editor[Peter Milliken] 2000-02. Create templates for your own
use/language. The template concepts centers around an ASCII text
file which is easy to use and edit i.e. the definition of the if
statement in C is:

The above definition is for a "token", as defined in ELSE (see -
easy to read and modify - no esoteric knowledge of elisp required.
This means that if you wish for an if statement then just type in
'if' and then perform an 'else-expand-placeholder and you will get
the above construct. Placeholders surrounded by {}'s are mandatory
entry, those surrounded by []'s are optional. Just position into
the placeholder (using else-next/previous-placeholder) and start
typing, the "placeholder" text is auto-deleteted.

The underlying concept behind ELSE is that programming is similar
to forms entry i.e. the programming constructs are the "forms" and
the variable names etc are the data fields. A typical template
file for a language pretty much follows the EBNF for the language
and thus should offer the entire language syntax and therefore
follow the language syntax tree ie ELSE offers menu selections when
"expanding" placeholders that contain optional branches in the
language syntax (see "statement" above).

I am in the process of changing jobs at the moment, so anyone
wishing to contact me after tomorrow should try me on
peterm@zipworld.com.au

[maintainer] A nice package for easy abbrev feature handling. Eg,
when you write chars "if" + press space, it will expand the
abbrev into full C/C++ if template. I do all my lisp with this,
when I say "defu" it creates full lisp function template instantly.
Saves typing time enermously. There is also tempo.el, but there
it is not possible to define the abbrev word that expands the
template: you have to type foreach to get template for perl, but
with expand you can define shorter aliases like fe to expand to
fereach loop.

Lisp-skels.el - Skeletons for lisp coding[Tom Breton] 1999-01 This module is pretty simple: It's a bunch of
skeletons as per skeleton.el, and 1 keymap.

Dmacro.el - Dynamic Macros[Wayne Mesard] 1991-12. Dynamic Macro is a program for inserting
structured text in Emacs. In addition to straight textual
substitution (already available through Emacs' Abbrev mode) Dmacro
will insert time- and date-stamps, your name and user-id, the
current file name, a file's contents, the results of a shell
command and anything else you can think of. It can prompt the user
for strings. It can also position the cursor within the expanded
text, and indent the expansion in whatever way is appropriate to
the current major mode. Dmacro will also allow you to bind macros
to keys and automatically insert macros in new files. A development
team can use a common macro table with standardized comment block
and code macros as a way of enforcing a coding standard.

File-templates.elTakaaki.Ota@am.sony.com This package provides the template file
insertion facilities. It can be configured to make template
insertion to take place automatically whenever Emacs opens a new
file. It also provides manual insertion as well.

[Christoph Wedler] Supports writing standardized comments, updating
file names in headers, and using templates when creating a new
file. A template is a file with normal text, pre-defined "expansion
forms" like inserting (parts of) the file name, date, user name etc
(see below for more), setting point and register positions, and
"expansion forms" which are defined by elisp sexps at the end of
the template. Some examples and default templates are distributed
with this package.

Another template generator

[Peter Milliken]

defaultcontent.el

#todo: URL missing

Auto-insert-tkld.el - automatic insertion of text into new files

[Kevin Davidson] 1998-12. Note: This package seems to have been
derived from standard Emacs package autoinsert.el. Comment in the
file refer to it. The auto-insert-alist consists of dotted pairs of
( REGEXP . TYPE ) where REGEXP is a regular expression, and TYPE is
the type of file which is to be inserted into all new files
matching the regular expression with which it is paired.

27.26 Extra tools for document handling

ImageMagick <http://www.imagemagick.org/> runs on NT and
converts tons of formats to and from each other, including
postscript. ImageMagick is available for free, may be used to
support both open and proprietary applications, and may be
redistributed without fee.

28.0 Organizing content

Bc-mode.el

[Steve Burgett] Bc-mode provides commands that format right-margin
block-style comments in source code. These are comments that appear
to the right of the code, and often span several consecutive lines.
On each line, the comment is delimited by start and end delimiters,
and these are lined up with the delimiters on adjacent lines to
form a rectangular block. For example, in C:

/* If the leading char of the */
if((String[0] != '0') || /* string is '0', then the */
(tolower(String[1]) != 'x' && /* number is probably in hex */
!isdigit(String[1]))){ /* or octal; that is, unless */
iRes = sscanf(String, "%ld", &Temp); /* the number is just zero. */

This package supports any language that has a conventional comment
syntax, such as C/C++, Lisp, Shell, etc. It presently knows 22
languages and new ones are easily added.

28.1 Bookmark-menu.el, setup a menu of bookmarks

[Max Anderson] 2001-07. This package maintains a menu
of bookmarks directly in the menu bar. I was getting tired of
having to enter the Search/Bookmarks menu and then choose a
bookmark from a popup-menu. I found it peculiar that I could
not find anything like this for Emacs and its
bookmarks/registers, so I created this. The code is highly
inspired by recentf.el for the management of the menu.

28.2 Desire.el, Emacs startup file organir

[Martin Schwenke] 2000-05. Desire is a versatile configuration
package for Emacs. It is meant for users whose Emacs configuration
has become so complex that it appears to be unmanageable. It
enables you to write and load the configuration for individual
Emacs package in pieces. You can use it to setup some autoloads for
a package when you start Emacs and then do extra configuration
after the package has loaded. This speeds up your Emacs startup
without compromising your ability to do complicated things. The
extra pieces of configuration are all done conditionally, depending
on what other packages (or fake packages) you have configured.
Weighing in at only 245 lines, it is quite small. It is based on
eval-after-load. It is almost the opposite of the Emacs
customization stuff: no user friendly interface, just power.

28.3 Ee.el, categorizing information manager for Emacs

[Juri Linkov] Ee is the categorizing information manager for Emacs.
It works by collecting information from different sources and
converting information to a relational or associative database. It
uses the fields of database table records to build the category
trees, which are displayed in the Emacs view buffer. The rules for
creating the views are also specified by similar data structures
and include the rules for building category paths, sorting records
and categories, calculating the totals of category fields,
filtering records, and printing category tree and record lines.

28.4 Esheet.el, Emacs spreadsheet

http://esheet.tripod.com/index.html Esheet is a spreadsheet
module for Xemacs. It allows you to perform standard spreadsheet
functions, such as statistics functions, large-scale data
management, etc. and also more powerful formula-based functions.
Specifically, a formula may be an ELISP program of arbitrary
complexity or a formula of more ordinary syntax.

Outline mode has no end marker which means that it is
impossible for text to follow a sub-branch.

Folding mode use the same markers for branches on all depths,
Outline mode requires that marks should be longer the further,
down in the tree you go, e.g \chap, \section', \subsection,
\subsubsection. This is needed to distinguish the next mark
at the current or higher levels from a sub-branch, a problem
caused by the lack of end-markers.

Folding mode can enter a fold, hiding everything above and
below.

Folding mode has mouse support, you can navigate through a
folded document by clicking on fold marks. (The XEmacs version
of Outline mode has mouse support.)

The Isearch facilities of Folding is capable of automatically
open folds. Under Outline, the isearch is practically useless
unless the entire document is opened prior to use.

In conclusion, Outline mode is useful when the document being
edited contains natural markers, like LaTeX. When writing code
natural markers are hard to find, except if you're happy with one
function per fold (I'm not).

28.8 Outline modes

There is outline-mode,outline-minor-mode in standard Emacs and
kotl-mode.
[Vladimir Alexiev] has written a refcard to sum up the used keys.

28.9 Outline-imenu.el

28.10 SES, Emacs spreadsheet

[Jonathan Yavner] Yes, Gnumeric is better than SES, but you
can Create and edit simple spreadsheets with a minimum of
fuss. Includes full undo/redo/autosave and Cell formulas are
straight Emacs Lisp; cell values are local variables in the
spreadsheet's file buffer. To sum the first three cells in
column B, say (+ B1 B2 B3). Intuitive keystroke commands: C-o
= insert row, M-o = insert column, etc. Other features:

Printer functions support fine control of cell appearance.
These can be just format strings. To print dollars and
cents, say "$%.2f"

"Spillover" of lengthy cell values into following blank
cells.

Completing-read for entering symbols as cell values.

Cut, copy, and paste can transfer formulas and printer
functions along with the cell values.

Mouse commands for selecting a range and inserting it into
a formula.

Import and export of tab-separated values or tab-separated
formulas.

Plaintext, easily-hacked file format.

29.0 Tracking changes

29.1 Autorevert.el (*), Emacs

[Anders Lindgren] 1997-12. Auto-revert mode automagically reverts
buffers whenever the file on disk change. It is designed only to
operate when Emacs is idle, hopefully you will not notice that it
is running (except for the fact that your buffers are reverted).

29.2 Blinking-cursor.el (*), XEmacs

Makes your corsor blink instead of beeing solid block. See also
jiggle.el by [Will Mengarini] which is is an Emacs minor mode that
jiggles the cursor in situations where it can be hard to find.
Implementing this required implementing a buffer-switch-hook; no
such hook is built in to GNU Emacs 19.34, so just having the hook
might be a sufficient reason to load the package, even if you don't
need cursor jiggling.

29.3 Change-mode.el, changes made get highlighted (*)

[Part of Eamcs][Richard Sharman] 1998-02. Here's a revised version
of change-mode. This is a minor mode in which changes made get
highlighted in a different face, so you can see what you've
changed.

It can run in active or passive mode: the highlighted changes
can be a bit obtrusive, sometimes you want to get rid of them
but not lose the information. In active mode the changes are
shown in the distinctive face. In passive mode the changes are
kept and any further changes are also recorded. Toggling
between them (which can be done by simply M-x change-mdoe)
which make the highlighted text magically appear or disappear.

You can compare the current buffer (as long as it's saved to a
file) with another file: the changes get highlighted. This is
function compare-with-file, which uses ediff to analyze the
diff output. This can be used with change-mode or independant
of it.

29.4 Csdiff.el, component software diff

29.5 Etail.el, tail -f

[Kevin Burton] 2001-07. The etail packages allows you to
watch certain log files for new output. Internally it uses 'tail
--follow' which uses the select(2) system call to pay attention to
when a file has been modified. This means that Emacs doesn't have
to do any polling to see when the file has been changed.

There are other packages that allow you to watch logfiles
(analog.el and tail.el) but they have certain disadvantages.
Analog.el puts all its output into one buffer and doesn't
automatically refresh itself (it can use an interval if you want).
Tail.el pops up a window while you are editing and can get in the
way. There are also some significant bugs which I belive will never
be fixed due to timing issues (I tried to fix them and new ones
would continually pop up due to the way Emacs is setup).

The etail package tries to solve all these problems by using the
native 'tail' command to watch for new output as soon as it arives.
It also provides a GUI display of all the tail buffers in one
central location so that you can view all your log activity in one
place.

In order to avoid taking up a lot memory over time, a timer is run
in the background to trim the head of each buffer so that only
etail-max-length is displayed. This has the advantage that if a
process generates a lot of output you can still view it.

29.6 Himark.el

[See LCD archive] himark.el provides marking of text in a buffer by
highlighting. Unlike transient-mark-mode the marking is permanent
and can be accumulated. One can mark the region, the occurances of
a regexp or a rectangle. The markings in a buffer can be removed
with himark-unset.

29.7 Hi-lock.el, highlight words (*), Emacs 21

[David Koppelman] 2000-08-03. With the p-whim-lock commands text
matching interactively entered regexp's can be highlighted. For
example, `M-x highlight-regexp RET clearly RET RET' will highlight
all occurrences of clearly using a yellow background face. New
occurrences of clearly will be highlighted as they are typed.
M-xunhighlight-regexp RET' will remove the highlighting. Any
existing face can be used for highlighting and a set of appropriate
faces is provided. The regexps can be written into the current
buffer in a form that will be recognized the next time the
corresponding file is read.

29.8 Highlight-current-line.el

[Christoph Conrad] Highlights the line the cursor is in. You can
change colors of foreground (text) and background. Highlighting is
switched on in ALL buffers including minibuffers. Default behaviour
is to set only background color, so that font-lock fontification
colors remain visible.

29.9 Hl-line.el, highlight the current line (*), Emacs

Provides a global minor mode (toggled by M-x hl-line-mode) to
highlight, in a windowing system, the line on which point is
(except in a minibuffer window) to satisfy a request for a feature
of Lesser Editors.

2000-02: problem with this package is that it is global. It would
be better to have minor mode.

29.11 Linemenu.el, highlight current line

29.12 Live-mode.el, periodically revert-file

Note: The live-find-file, from LCD launches separate "tail
-f" processes for each file, so the live-mode is much more CPU
friendly, because it only uses Emacs timers.

[Bob Glickstein] 1997. live-mode is a minor mode that works like
the "tail -f" Unix command. If the file grows (or changes in any
other way) on the disk, then the buffer copy is periodically
updated to show the new file contents. This makes live-mode ideal
for viewing such things as log files. The buffer is only updated if
there are no unsaved changes. Updating is done every
live-interval seconds using revert-buffer. This code was
inspired by live-find-file (available in the Emacs Lisp archive),
whose implementation is now obsolete.

29.13 Mic-paren.el, highlight sexps (*), Xemacs

[Mikael Sjodin] 1997-02 (author) [Klaus Berndl] (maintainer, see
LCD). mic-paren.el is an extension to the packages paren.el and
stig-paren.el for Emacs. When mic-paren is active (it is
activated when loaded) Emacs normal parenthesis matching is
deactivated. Instead parenthesis matching will be performed as soon
as the cursor is positioned at a parenthesis. The matching
parenthesis (or the entire expression between the parenthesises) is
highlighted until the cursor is moved away from the parenthesis.

Checking if matching paren is horizontally off-screen (in case
of horizontal scrolling). In that case the message is displayed
in the echo-area (analogue to vertical off-screen). In case of
horizontal off-screen closing parenthesis the displayed message
is probably wider than the frame/window. So you can only read
the whole message if you are using a package like mscroll.el
(scrolling long messages) in GNU Emacs. This new feature is
only tested in Gnu Emacs > 20.4 and not in any XEmacs!

Now full customizable, means all user-options and -faces can
now be set with the custom-feature of Emacs. On the other side
this means this version of mic-paren only works with an Emacs
which provides the custom-package!

In case of the matching paren is off-screen now the displayed
message contains the line-number of the matching paren too.
Until now this version is only tested with Gnu Emacs > 20.4 and
not with any XEmacs!

29.14 Notes-mode.el, indexing system for on-line note-taking

[John Heidemann] Notes-mode is an indexing system for on-line
note-taking. Notes-mode is composed of two parts, the visible part,
a major-mode for emacs to aid note-taking; and the invisible part,
scripts which periodically index your notes for you. Note that
notes-mode provides tools to index your notes, not to search them.
(Other existing tools such as grep, agrep, and glimpse
already allow file search.) A digression about indexing vs.
searching: Indexing in this sense means organize them according to
categories you give, while searching looks through all text for
arbitrary strings. Drawing on the World Wide Web for examples,
Yahoo is an index. In
(potentially) more familiar terms, the yellow pages (1) are an
index, while directory information (411 in the USA) is sort of a
search-engine.

29.15 Records.el

[Ashvin Goel] 2000-01. Records mode is an online journal or diary
software for emacs.Records mode is an online journal or diary
software for emacs. Records allows you to keep an index to your
personal journal. It indexes your personal journal (or diary) by
subject and date, and understands web compatible links to a variety
of other documents. Records keeps track of TODO lists, allows
combining records on a subject over time, and even provides
encryption (if you really care). This journal has infact become my
major desktop tool (instead of netscape). I write most of my
documents, small and large, as records distributed over different
days and Records does the tracking for me. If you have noticed,
Records provides an editor and a browser all in one. You can browse
your records with automatically generated Records links, and you
can also edit the contents of your records.

This software was originally inspired by John Heidemann's
notes-mode. This version enhances the original notes system by
adding several features that John hasn't had time to add. The main
addition is that indexing is done on the fly so that indexes are
current as you add or delete new records. John's notes mode updates
indexes in the background (say, daily) and I found that
inconvenient. Please send me mail if you find this software useful.

29.16 Remember.el, mode for remembering data

[John Wiegley] 1999-04 Todo lists, schedules, phone
databases... everything we use databases for is really just a way
to extend the power of our memory. To be able to remember what our
conscious mind may not currently have access to. There are many
different databases out there - and good ones - which this mode
is not trying to replace. Rather, it's how that data gets there
that's the question. Most of the time, we just want to say
"Remember so-and-so's phone number, or that I have to buy dinner
for the cats tonight." That's the FACT. How it's stored is really
the computer's problem. But at this point in time, it's most
definitely also the user's problem, and sometimes so laboriously so
that people just let data slip, rather than expend the effort to
record it. "Remember" is a mode for remembering data. It uses
whatever back-end is appropriate to record and correlate the data,
but it's main intention is to allow you to express as little
structure as possible up front. If you later want to express more
powerful relationships between your data, or state assumptions that
were at first too implicit to be recognized, you can "study" the
data later and rearrange it. But the initial "just remember this"
impulse should be as close to simply throwing the data at Emacs as
possible.

M-xremember (or M-x remember-region) will accept stuff
that you type in and place it in ~/.notes with an appropriate
Subject (that it prompts for) for indexing.

The beauty is that you can choose to save the notes as mails
(it adds an X-remember header). So point mail-sources to
~/.notes and let Gnus snarf all your notes.

Add a filter to scan for "^X-remember:" and move it to some
todo/reminder folder. I often move/copy mails from other
mail/news groups to that folder as well.

29.17 Simplemerge.el, resolving CVS conflicts (*), Emacs

[Peter Österlund] Included in Emacs 21 under name smerge-mode.

29.18 Tail.el, tail -f

[Benjamin Drieu] 2001-07. This program displays `tailed' contents
of files inside transients windows of Emacs. It is primarily meant
to keep an eye on logs within Emacs instead of using additional
terminals.

29.19 Tinymy.el, y-or-n-p autorevert by timer process

In [Tiny Tools] kit. "tinymy" is a grabbag of utilities and when
you load it, one of the things it installs is a timer process that
asks y-or-n-p question for files that have changed on disk. This
package co-operates with autorevert.el, by turning itself off if
autorevert feature already exists in Emacs.

29.20 Time - Timecard-mode.el

29.21 Time - Timeclock.el (*)

Included in Emacs.

[John Wiegley] 1999-03 Like schedule.el by me also, this simple
module only intends to be better than nothing. See the Commentary
section for usage information. This mode is for keeping track of
time intervals. You can use it for whatever purpose you like, but
the typical scenario is to keep track of how much time you spend
working on certain projects. Use timeclock-in when you start on a
project, and timeclock-out when you're done. Once you've
collected some data, you can use timeclock-workday-remaining to
see how much time is left to be worked today (assuming a typical
average of 8 hours a day), and timeclock-when-to-leave which will
calculate when you're free.

29.22 Time - Timelog.el

[Thomas Gehrlein] 2001-02. This file helps you to keep track of
what you do. It writes information into a file. Each line in this
file consists of a code letter (i or o - "i" means "in", i.e.
starting an activity, "o" means "out", i.e. finishing an activity),
a date and time stamp, and information supplied by the user.

Differences between timeclock.el and timelog.el: You don't give a
reason for logging out. Instead you specify what you've done since
you logged in. (Reason is, I want to record what I did, not why I
stopped doing it.) timelog.el doesn't keep track of how much time
there is left to work for today (or tomorrow, or the day after).
timeclock.el uses more code letters, timelog.el uses only i and o.
timeclock.el uses hh:mm:ss, timelog.el uses hh:mm

29.23 Todoo.el, editing todo files

[Daniel Lundin] 2001-03. todoo.el is a mode for editing TODO files
in an outline-mode fashion. It has similarities to Oliver Seidel's
todo-mode.el , but todoo.el has been significantly simplified to
better adhere to mine and other users' needs at the time.

29.24 Todo-mode.el (*), Emacs

You have things to do in you home, office, private life, manage
them with this nice major mode.

29.25 Worklog-mode.el, keep track of stuff you do

[Kai Grossjohann] 1998-10. This code lets you keep track of stuff
you do. It writes time-stamps and some data into a file, formatted
for easy parsing. The format of the file is as follows: Each entry
starts in the beginning of a line with a date and time of the
format YYYY-MM-DD HH:MM (24 h clock). Then comes whitespace and the
entry itself. The entry may be continued on the next line,
continuation lines begin with whitespace.

29.26 X-symbol (*), XEmacs

[Christoph Wedler] The main purpose of package x-symbol is to
provide some WYSIWYGness in an area where it greatly enhance the
readability of your LaTeX or HTML source: using "real" characters
for "tokens" like \oplus or &#8482;. It also provides input methods
for these characters, both for the beginner and the expert (some
users regard this as the main reason to use package x-symbol).
WYSIWYG super- and subscripts and images/figures are also supported

30.0 Buffers

30.1 A day with buffers

Emacs users have always been interested in the most econimic and
the easiest way of managing their increasing count of buffers. You
start Emacs with the default scratch buffer, and start your daily
routines: feeding Emacs buffer after another, change X resource
files, sysadm files, user profiles, C++/Java/Perl project files,
compose mail, read news, telnet to several sites, run external
commands in Emacs windows (top, traceroute, nslookup, ping). Whups,
the favorite buffer is now buried on top of pile of other "maybe
not that significasnt buffers at the moment".

You could try killing unwanted buffers from M-xlist-buffers
but they keep coming back like boomerang: "that itsy bitsy
Completion buffer is back again", "I just killed lot om tmp-xxx
buffers and now they are back again...".

Word of advice: while the extra buffers may bother you at start,
like a stain in your white suit, you don't notice it soon if you
change your suit to blue. So, stop worrying about how many buffers
are there and seek utilities that let you navigate among those
buffer: to select right buffer for vieving, or listing all your C++
files. Btw, Emacs performs better if you don't constantly kill
temporary buffers. If some package creates a temporary buffer,
leave it there, because the application usually creates it again if
it doesn't exist. This creation of new buffers burns time a bit.

In the past many people have written various buffer swithing
utilities; pick ones that serves you best. My personal
recommendations are:

iswitchb.el[Included in recent Emacs 20.x] or older version
iswitch-buffer.el This is the fastest and most convenient way
to switch to your favorate buffer under pile of all other
buffers: Included in recent Emacs versions. There are lot of
options to restrict buffer search: case sensitive, regexp,
temporary buffer matching, or excluding buffers.

For X environment: msb.el[included in Emacs] Putting lot of
files into categories and selecting file from a popups.
This may not be an optimal buffer selection tool if you arrange
all your 50 C++ files under same menum which gets very looong.

tinyhotlist.el to keep hotlist (10-20) of permanent files
that you access 70% of your time.

recent-files.el[included in XEmacs] Going back to just
visited files

Rolling buffer by buffer in your current window: ...I don't
recommend anything, there are so many. Choose the one that
looks handiest to you.

To switch to next window (uncluding frames), use this code instead
of the default C-xo binding. The definteractive is defined
in Tiny Tools Kit file tinylibm.el

30.2 Popup menu based buffer selection utilities

recent-files.el[Jorgen Nickelsen] and frederic.mienville@aigf.sncf.fr> Frederic
Mienville. See your XEmacs installation, doesn't work for Emacs. In
Emacs 21, there is package recentf.el by [David ponce].

filemenu.el[Will Mengarini] 1997-07. This package lets you set up one or more
menus of names of files you visit frequently, so you can select
from that menu. A mouse is supported but not required. The menus
are stored in text files; they can have several columns of file
names, & can apply different default directories to different
groups of lines in the same file. File names that contain spaces,
such as occur on Macs & on Windows {95,NT}, are supported.

tinyhotlist.el
In [Tiny Tools] kit since 1995-03.

Provides X popup where you can add/remove current buffer. Kinda
'most important work file list' In non-windowed system, you get
completion menu instead of X-popup.

You can keep any persistent files in hotlist: even ange-ftp
files.

hotlist can be saved and read on startup.

This is not "last visited files" list, but persistent list of
files. When you select item from hotlist the file is displayed
if it is in Emacs, or loaded (by using ange-ftp if necessary)
if it didn't.

30.3 Typing buffer name in echo area

Ido[Kim Storm] 2000-04. Since I discovered Stephen Eglen's excellent
iswitchb package, I just couldn't live without it, but once being
addicted to switching buffers with a minimum of keystrokes, I soon
found that opening files in the old-fashioned way was just too slow
- so I decided to write a package which could open files with the
same speed and ease as iswitchb could switch buffers. ido.el is my
"interactively do" package which provides replacements for the
switch-to-buffer and find-file functions (and the various versions
of these functions) for switching between buffers and opening files
with an absolute minimum of keystrokes. The ido.el package borrows
heavily from Stephen Eglen's iswitchb.el package (both in concepts
and code), and provides the same functionality for switching
buffers while expanding the functionality to cover opening files as
well.

As you type in a substring, the list of buffers or files currently
matching the substring are displayed as you type. The list is
ordered so that the most recent buffers or files visited come at
the start of the list. The buffer or file at the start of the list
will be the one visited when you press return. By typing more of
the substring, the list is narrowed down so that gradually the
buffer or file you want will be at the top of the list.
Alternatively, you can use the right and left arrow keys (or C-s
and C-r) to rotate buffer or file names in the list until the one
you want is at the top of the list. Completion is also available so
that you can see what is common to all of the matching buffers or
files as you type.

Iswitch[Stephen Eglen] As you type in a substring, the list of buffers
currently matching the substring are displayed as you type. The
list is ordered so that the most recent buffers visited come at the
start of the list. The buffer at the start of the list will be the
one visited when you press return. By typing more of the substring,
the list is narrowed down so that gradually the buffer you want
will be at the top of the list. Alternatively, you can use C-s an
C-r to rotate buffer names in the list until the one you want is at
the top of the list. Completion is also available so that you can
see what is common to all of the matching buffers as you type.

[maintainer] 'Switch between buffers using substrings', that says
almost all. you just hit "RM" or just "R" in C-xb to switch to
RMAIL buffer. Lot of options, like toggling case sentitivity when
you search for buffer name. There is also older version,
iswitch-buffer.el which is faster, but the interface is somewhat
non-intuitive, because you're not actually in minibuffer (Be
prepared to press C-g multiple times)

swbuff.el[Joseph Casadonte] swbuff-advice.el Emacs package that provides
advice for several swbuff functions to allow the use of more
than one set of regexp filters. Also now includes the ability
to specify inclusive filters, in addition to the normal
exclusionary ones.

...I'm a long-time fan of iswitch and its successor iswitchb (by
Stephen Eglen stephene@cogs.susx.ac.uk). I hate having to type
the whole buffer name, or the beginning of the buffer name. I hate
having to press the shift key when selecting a buffer (e.g., in
order to type the "*" in "*scratch*"). But the existing packages
have never done exactly what I want.

I tend to have lots of buffers with long buffer names, so
listing the completions in the minibuffer is all-but-useless.

One buffer name is often a substring of another buffer name
(e.g., "INBOX" and "INBOX Summary"). This often causes me and
my stupid fingers to select the wrong buffer.

I missed being able to use Control-y and minibuffer history.

The alternatives are - to varying degrees - too case-sensitive.

They don't do the Right Thing with spaces in buffer names

There was something else that bugs me, but I forget what it is.

30.4 Buffer utilities

bs.el, menu for selecting and displaying buffers[Olaf Sylvester] The package bs will union the advantages of EMACS
function list-buffers and electric-buffer-list.

cycling navagation: goes to top of bufferlist if you are on
last line and press down. goes to end of bufferlist if you are
on first line and press up.

[Eric Crampton] 2000-04. This minor mode allows you to toggle a
window's "dedicated" flag. When a window is "dedicated", Emacs will
not select files into that window. This can be quite handy since
many commands will use another window to show results (e.g.,
compilation mode, starting info, etc.) A dedicated window won't be
used for such a purpose. Dedicated buffers will have "D" shown in
the mode line.

keep-buffers.el - Attempt to prevent named buffers from deletion.[Steve Kemp] 2000-01. This package allows you to protect buffers,
based upon their names, from deletion.

(keep-buffers-protect-buffer "*scratch*")

ibs.el[Olaf Sylvester] 2000-12. This Emacs package provides a minor mode
for buffer cycling; more exact: key C-TAB switches between Emacs
buffers like MS-Windows IDEs between frames. C-TAB starts buffer
cycling. Every other key terminates cycling and sets the current
buffer at the top of Emacs buffer list. The buffer we started
buffer cycling won't be buried !!! You can configure the keys for
cycling. Therefore set global ibs-cycling-key before loading
ibs.el. You can define which buffers will be used for buffer
cycling. Set global ibs-cycle-buffer-function to a function which
returns a buffer list. The default is buffer-list, which returns
all buffers in recently order. If package bs is loaded the cycling
list of this package will be used.

ibuffer.el[Colin Walters] 2000-06. Biggest improvement is the addition of the
concept of "limiting". Suppose you're working on a big project, and
you only want to see emacs-lisp-mode buffers. You can use '# m
emacs-lisp-mode RET' to do this. Limits can even be combined; if
you want to see only buffers whole filename contains "gnus", of
size > 2000 characters, then '# f gnus RET # > 2000 RET' should do
the trick. A bit more documentation about this is available by
typing 'h' in an Ibuffer.

30.5 Rolling buffers in same window

Listed in the order of creation; when wheel was invented and then
rolled over hill of years....

yic-buffer.el
Young-il Choo choo@cs.yale.edu 1990-08 This is very simple
module, couple of keystroke definitions and 20 lines of lisp. No
special features.

tinybuffer.el
See [Tiny Tools] kit. Got this idea after seeing
yic-buffer.el. See also ticb-:ignore-regexp which defines Buffers
to ignore when changing to another

C-, previous buffer (Think this as < back)
C-. Next buffer (Think this as > fwd)
A-. sort order on/off (Think this as > sorted)

C-< iswitch mode, select buffer with RET, move with <,> and <.>
This mode is special, it shows the buffer name in echo area while
you go backward and forward.

This is useful if you have many buffers and just want to skip 2-5
buffers fast. Eg. if the buffers are font-lock conrolled, swithing
to them with the C-, and C-, keys would be slow due to
fontification which happens every time you ,switch over a buffer.
The command prompt looks like following. The mode name is shown
only if buffer has no associated file name [mode name has been left
out so that full path fits there]

cycle-buffer.el[Vladimir Alexiev] 1996-06. Cycle-buffer is yet another way of
selecting buffers. Instead of prompting you for a buffer name,
cycle-buffer switches to the most recently used buffer, and
repeated invocations of cycle-buffer-forward switch to less
recently visited buffers. If you accidentally overshoot, calling
cycle-buffer-backward goes back. You should issue consecutive cycle
command pretty quickly: if there is some intervening command
between two cycling commands, or if a settable timeout expires, the
cycling is reset and the next cycle-buffer will get you to the last
buffer.

I find this to be the fastest buffer-switching mechanism; it's like
C-x b <return> w/out the return, but it's not limited to the most
recently accessed buffer. Plus you never have to remember buffer
names; you just keep cycling until you recognize the buffer you're
searching for. The buffer ring is shown in the echo area centered
around the current buffer; if you see the name of the buffer you
are looking for a few positions away from the center, you can give
an argument to cycle-buffer to get directly to it. Positive
arguments move to the right, negative arguments to the left.
In addition to cycling forward and backward, there are two versions
of the command provided: normal and "permissive". The permissive
version allows (as per factory settings) buffers of the form
bufname, while the normal version does not.

See cycle-buffer-filter = A list of forms that determine if a
buffer is considered for switching to. All forms should return
non-nil for a buffer to be eligible. The forms are evaluated in the
buffer in question, so they can check its buffer-local variables
(eg major-mode)

See cycle-buffer-filter-extra = List of forms that are
evaluated in addition to cycle-buffer-filter for the non-permissive
versions of the cycle-buffer commands.

pc-bufsw.el[Igor Boukanov] 1998-03. This is an implementation of quick switch
for Emacs buffer that is similar to one that is widely used on PC.
The main idea here is that a user chooses two keys (most often
C-tab and S-C-tab) that switch between buffers according to most or
least recently order. After the final choice is made the last
selected buffer becomes most recently used one.
pc-bufsw::quite-time = automaticaly terminate buffer switch mode.
If there is no input during quite-time seconds

30.6 Window selecting utilities

change-windows-intuitively.elproff@iq.org (See dejanews)
[Julian Assange] 1998-10. Move around (x)emacs windows intuitively
e.g take me to the window to the immediate left/right/top/bottem of
the current one.

30.7 Demax.el, Delete too narrow windows

[Anders Lindgren] 1999-04. Normally, when I work, I switch between
full screen Emacs (displaying two side-by-side windows) and a small
frame by using the plain maximize and de-maximize window manager
feature. Each time I did this I had to rearrange the windows since
two windows in a small frame will make them too narrow... So,
eventually, I grew tired of this and wrote this package to make
Emacs handle this for me. It is implemented as a global minor mode
and can be configuratable using Customize.

31.0 Desktop

31.1 Overview of to state change packages

[Exerpted from session.el by Christoph Wedler] Packages which
maintain an alist (FILENAME . PLACES), set by kill-buffer, used by
find-file [method which is used by this package]:

31.2 Desktop.el and extensions to it

Save arbitrary buffer-local variables, such as the mark ring
and state, to the desktop file

Specify regexps for additional file-visiting buffers, such as
tags and other automatically-loaded data files, to omit from
the desktop

Via a separate interface function, kill immediately any
file-visiting buffers which will not be saved to the desktop

desktop-kde-recent.el[Michel Schinz] 2001-03. Each time the desktop is saved (usually
when you exit Emacs), an entry for the desktop is added to KDE's
Recent Document menu. Notice that you can also create a directory
to store only Emacs desktop entries, reference it in
desktop-kde-recent-dir and have a Quick Browser in your KDE panel
showing the contents of that directory. That way you have a nice
menu to start Emacs on your various projects.

desk-phase.el[Juergen Erhard] 1997-02. This is a little extension for desktop.el
(included in the Emacs distribution since... way back when). If
installed, it automatically 'phases out' buffers that are left
untouched for specified period of time... which, at this time, is
just a certain number of sessions. It's not really that great...
but I didn't find anything of this kind in the LCD, and I use it
constantly (which isn't to say much, because you install it and
then forget about it). Works with GNU Emacs 20.

One important note: This is only tested on Emacs 19.28+ (I think).
It certainly works on 19.34 (which I am using at this time). It is
NOT guaranteed to work on any other than GNU Emacs... so, no XEmacs
(though I don't know any reason it shouldn't work there... uses no
esoterics...)

31.3 Grabbox.el, project bookmarks

Keep a bookmark file for often used files and text snippets
The bookmark file is divided into sections. The section name
is put in square brackets (e.g. [Emacs stuff]) The command
grabbox-section-menu enables you to navigate through the
sections via completion An entry in the grabbox-file can have
one of the following formats

31.4 Protbuf.el, protect buffers from accidental killing

Note: Emacs has underdocumented file emacs-lock.el,
which you can use to protect buffers from being killed. Function
toggle-emacs-lock will lock/unlock current buffer against
killing.

[Noah Friedman] The commands defined in this package allow you to
create buffers which cannot be killed accidentally. You can mark
`precious' buffers, then gleefully kill all the rest of your
buffers in the buffer menu. There are two minor modes defined. The
first mode protects a buffer only so long as a process is still
associated with it. You can use this to keep from killing your
shell buffer until you exit the shell process first. The second
mode unconditionally prevents a buffer from being killed. Turning
off the minor mode makes the buffer killable again.

31.5 Session.el

[Christoph Wedler] If you're looking for the n-th package which
saves some variables and buffer places between Emacs sessions,
you'll find it after the signature on separate logical pages (there
are also some comment lines about related packages). This version
only works with XEmacs-19.13+. if I know how to express the
following functions in Emacs (i.e. if s.o. sends the answer to me),
version 1.2 of this package will also work with Emacs-19.33+.

31.6 TinyDesk.el, simple file and dir information saver

In [Tiny Tools] Kit.

Works with any Emacs/XEmacs/NT Emacs/NT XEmacs release.

Simple desktop: only filenames and directories are read/saved.
Unlike the other desktop savers, this one can also UNLOAD files
from Emacs. You just tell it to remove 'these files listed in
state file state.XXX', and those files will be removed from
your Emacs buffers. You can collect 'projects' and switch
between them easily: after project1, It can can be unload and
load project3 instead.

Parse any file that includes filenames and comments

If there were any invalid entries in the state file,
the state file contents is shown to user and the entries which
had problems are marked.

State file editing (tid-mode):

- load single file on the line
- clear face properties from buffer, so that they don't
disturb your view.
- parse files for loading.
- Show files that cannot be loaded.

In regular intervals save the state of Emacs (files loaded)
If Emacs crashes you can recover the previous session.
See function tid-auto-save for more. Similar functionality
is in new Emacs releases, but this package was originally
written fo 19.28

CRASH RECOVERY: If Emacs crashes, or you have to kill it with
-HUP if it hung, there is one autosaved state file which
lists all opened files in your emacs. When you boot up again,
you need to reload the existing files AND recover any autosaved
files. The best way to get your Emacs back where it was, is
that you load the state file for editing: M-xtid-edit-state-file And from the StateFileEdit mode hit
command tid-find-file-whole-buffer and
tid-recover-file-whole-buffer. You'll be up again with your
latest files.

31.7 Windows.el

[Hirose Yuuji] This package provides the `named(numbered) frame'
that can be selected directly with their name. With revive.el,
all frames' displaying buffers, window configurations, specified
buffer-local/global variables, and window size can be saved and
restored. So you can bring your editing environments accross the
time and space! It'll be much more confortable by setting up your X
Window System's window manager to work fine with windows.el. See
the manual section [For frame users] in the program.

32.0 Screen and window

32.1 Escreen.el, mimic sun's screen(1)

[Noah Friedman]. Noah has given very little explanation about
this utility in the package documentation, so unless you know what
good the package can do you may miss it very easily. The "screens"
mean that your window configuration is saved to screen slot X. Do
you know famous SUN-OS screen(1) command that lets you run multiple
sessions in one terminal window? That should ring your bell then.
Advice - Get it for non-windowed emacs - it puts your emacs into
"session screens" where you can alternate very easily: jump to
screen 1,2,3 or go forward screens, backward screens. I also
recommend that you add entry to your fdb.el so that you don't get
tired of the error messages when trying to go to non-existing
screen. Here is one setup to get you started, HP-UX kbd specifix
bindings

32.2 Follow-mouse.el

[Kevin Rodgers] 2000-04. By default, a window within an Emacs frame
must be selected by typing `C-x o' (other-window) or by clicking
mouse-1 on the mode line or the buffer itself (mouse-set-point);
this corresponds to a "click to type" window manager policy.
follow-mouse.el implements a "focus follows mouse" window manager
policy, so that a window is selected when the mouse moves over it.

Similar feature available for Emacs and XEmacs in Tiny Tools Kit
tinymy.el

32.3 Resize-help-window.el

[Emilio lopes] 1998-09. This library provides automatic vertical
resizing of windows displaying help buffers subject to a maximal
user defined height. To toggle the resizing of help windows use
`M-x help-window-resize-mode'.

32.4 Screen-lines.el, minor mode

[Yuji Minejima] This package provides "Screen Lines" minor mode. In
this minor mode, the following standard commands move point in
terms of screen lines, as opposed to text lines.

`beginning-of-line'
`end-of-line'
`next-line'
`previous-line'

Screen lines are defined by the way the text appears
horizontally on the screen, whereas text lines are defined in terms
of newline characters as line delimiters. Screen Lines minor mode
should be handy when you edit a file with long lines.

32.5 Screenline.el

[Josh Buhl] 2000-09. This packages provides sl-screen-line-mode,
a minor mode. When activated, editing is performed in terms of
screen lines, i.e. independent of line-wrapping. Screen line mode
is buffer local. A natural use is for editing DOS-text in which
paragraphs are one single wrapped line of text, a new-line
character signalling a new paragraph. Another natural use is `all
the time', if, like me, you find it annoying trying to get to the
middle of a long line, or disconcerting when the cursor jumps down
three lines after you've only pushed the down arrow once.
sl-screen-line-mode rebinds the standard keys C-n, C-p, C-a, C-e,
C-k, up, and down. Functions provided are:

This code (except for sl-kill-screen-line, which is still a hack)
is integrated with the code for the corresponding standard
functions in simple.el, so that if the sl- prefix is everywhere
removed, you can use the code as a drop-in replacement for the
corresponding functions in simple.el, making them
screen-line-mode aware. You could then drop the
minor-mode-map-alist, which rebinds the keys. This is important for
compatibility (and for me, if I ever even want to hope to get it
integrated into the emacs source tree.

Note: due to internal problems in the primitive function
vertical-motion of Emacs 21.1 - 21.3, this package may not
work correctly. The problems are expected to be fixed in
upcoming Emacs versions.

32.6 Winner.el, restore old window configurations

[1998-03 gnu.emacs.sources Ivar Rummelhoff ivarr@ifi.uio.no]
Here comes the new version of winner.el that will be distributed
with Emacs20.3. It is very much improved since the last version
(distributed with Emacs20.2), and now it should work with Emacs19
and XEmacs, too; provided that you are not using an obsolete
version of custom. Comments are welcome! (I have removed the
buffer switching function winner-switch, since any such function
can now be used without disturbing winner-mode too much.)

Winner mode is a global minor mode that records the changes in the
window configuration (i.e. how the frames are partitioned into
windows) so that the changes can be "undone" using the command
winner-undo. By default this one is bound to the key sequence
ctrl-x left. If you change your mind (while undoing), you can press
ctrl-x right (calling winner-redo). Even though it uses some
features of Emacs20.3, winner.el should also work with Emacs19.34
and XEmacs20, provided that the installed version of custom is not
obsolete.

32.7 Winring.el, Window configuration rings (*), Emacs 20.4

[Barry Warsaw] This package provides lightweight support for
circular rings of window configurations. A window configuration is
the layout of windows and associated buffers within a frame. You
can easily push a new window configuration on the ring and create a
new window layout, then cycle through the layouts in either
direction. You can also delete configurations from the ring (except
the last one of course!). Window configurations are named, and you
can jump to and delete named configurations. Display of the current
window configuration name is only supported in currently unreleased
beta versions of Emacs and XEmacs (see below). Window configuration
rings are frame specific. That is, each frame has it's own ring
which can be cycled through independently of other frames. This is
the way I like it.

33.0 Mouse

33.1 Mouse-copy.el

33.2 Mouse-extra.el, one-click text copy and move

#todo: Emacs?

[John Heidemann] Provides one-click text copy and move. Rather than
the standard stroke-out-a-region (down-mouse-1, up-mouse-1)
followed by a yank (down-mouse-2, up-mouse-2 or C-y), you can now
stroke out a region and have it automatically pasted at the current
point. You can also move text just as easily. Although the
difference may not sound like much, it does make mousing text
around a lot easier, IMHO.

Now that you're doing things with the mouse, doesn't that scroll
bar seem far away when you want to scroll? I also overload mouse-2
to do `throw' scrolling. You click and drag. The distance you
move from your original click turns into a scroll amount. The
scroll amount is scaled exponentially to make both large moves and
short adjustments easy. What this boils down to is that you can
easily scroll around the buffer without much mouse movement.
Finally, clicks which aren't drags are passed off to the old
mouse-2 binding, so old mouse-2 operations (find-file in
dired-mode, yanking in most other modes) still work.

Third, we provide an alternative way to scroll, `drag' scrolling.
You can click on a character and then drag it around, scrolling the
buffer with you. The character always stays under the mouse.
Compared to throw-scrolling, this approach provides direct
manipulation (nice) but requires more mouse movement (unfortunate).
It is offered as an alternative for those who prefer it.

33.3 Strokes.el, mouse stroke commands (*), XEmacs

[David Bakhash] This utility which allows the user to control
XEmacs by simply moving the mouse in a certain pattern which he/she
trained XEmacs to understand as meaning something. For example, if
you wanted to train XEmacs to scroll vertically by simply dragging
the mouse vertically, then you might define a stroke which is a
vertical drag from top-to-bottom to scroll-up

33.4 Xt-mouse.el, mouse support for non-windowed emacs (*), [X]Emacs

[Per Abrahamsen] If you telnet to remote site through Xterm and you
run emacs there, then you must have this package. It allows you to
use mouse, while the emacs in remote site is in non-windowed mode.

34.0 Amusement

34.1 Ascii animation

34.2 Comics.el, read www.comics.com

[Jay Belanger] 2000-10. This will display (using w3-fetch) certain
comic strips. Use M-xread-comic to read the most currently
available strip, you will be prompted for a strip, and can (should)
use tab completion. With a numeric argument n, M-x read-comic will
find the comic from n days before the most current. To add more
comics to the list, add an entry to comics-list, as described in
the documentation string. By default, there will be a Read Comics
submenu in the Tools menu, this can be turned off by setting
comics-use-menu to nil.

35.0 Music

35.1 Cddb.el, CD DataBase interface

[William Perry] 1998-10. See also workbone, emacs interface to
workbone (the audio CD player) and volume (volume control), which
both work under GNU/Linux. The goal is to play audio CDs without
switching to a shell buffer.

35.2 Cda.el, interface to CD players

[Matt Hodges] 2000-12. Package to control command line CD players.
Just run the cdi-start command, which will pop up a cdi buffer
with the status of the CD (eg Playing) and track/artist
information. Various functions are bound to keys in the cdi
buffer, eg ">" is bound to cdi-next-track - use ? or C-h b to find
all the bindings.

35.3 Cdrw.el, frontend to various commandline CDROM

[Tony Sideris] 2001-01-23 This file is a frontend to various CDROM
burning utilities such as cdrecord, mpg123, and mkisofs (in the
future). It is basically just some extensions to dired. Currently
only support for burning MP3 files to audio CDs is supported, I
haven't gotten to data CD creation yet... this is mainly because
data CD creation from the command- line is trivial and has always
worked fine for me without a front-end, but I will probably
implement it in the future for the hell of it...

Calculate the playing time (in minutes) of the selected
(marked) MP3 files in the dired buffer.

Burn the selected MP3 without intermediate files.

Save/Restore file-lists (playlists if you will).

35.4 Mp3-tools.el A simple Linux MP3 Tag Editor

[Steve Kemp] This is a small function that I've been working on for
a little while now. It allows you to edit the ID3 tags inside
MP3's.

35.5 Mp3player.el, Interface to mpg123 and winamp

[Jean-Philippe Theberge] 2000-11. Some codes and Ideas borrowed from mpg123
by HIROSE Yuuji and mp3-tools.el by Steve Kemp
Many Thanks to you Yuuji and Steve.

35.6 Workbone.el, CD player for program workbone

[Benjamin Drieu] 2000-11. You need workbone to use this
program. You also need the volume program to be able to change
volume with keystrokes. If you have a Internet connection and
cddb.pl, you will be able to have tracks titles on the mode libe
(which is cool). Workbone.el is now interfaced with CDDB_get
(cddb.pl program), but this program sometimes need to be modified
so that it runs in non-interactive mode.

36.0 Miscellaneous

36.1 After-save-commands.el, update xrdb(1) after save

For XEmacs only. This is good for things like running
newaliases(1) on "/etc/aliases", or xrdb(1) on $HOME/.Xresources,
as well as sending signals to daemons whos configuration files
you've just finished editting.

36.2 Align.el (*)

[John Wiegley] 1996-04. This mode allows you to align regions in a
context-sensitive fashion. The classic use is to align assignments.
This file is part of Emacs 21.

a = 1;
foo = 2;
blah = 4;

becomes

a = 1;
foo = 2;
blah = 4;

36.3 Apm.el, Power Management From Within (X)Emacs

36.4 Archie.el, archie server search

It provides one command, archie, that'll prompt for something
to search for. It'll connect to an archie server and then do the
search itself asynchronously so as to not lock up Emacs while
waiting for output from the server. When the result arrives, it'll
pop up a buffer with the results. Kinda like man.

36.5 Autoarg.el, easy arguent passing to commands

#todo: Part of Emacs?

[Dave Love] 1998-09. The bindings of DIGIT and C-DIGIT are swapped
and a command bound to SPC deals with a numeric prefix arg or acts
normally without such an arg. (Absent a window system, you'd
probably want to swap DIGIT and M-DIGIT.) I can't exactly commend
its use; I think it will break the normal use of SPC in Gnus
summary buffers, at least.

36.6 Auto-arg.el, passing arguents easily to commands

[Anders Lannerback] 1998-09 This is a minor mode for people who
uses numbers as prefixes more often than to insert them in text.
With this minor mode entering a number is roughly equivalent to
entering C-u <number>.

36.7 Bm-man.el, unix man page completion

[Yuji Minejima] 2000-04. Call Unix manual page & GNU Info viewer
with completion. The completions buffer can display possible
completions with or without their short descriptions.

36.8 Buffer-perm-map.el

[Dan Steinmark] Allows key bindings to be made that are local to
the current buffer only, and remain bound in that buffer through
major mode changes.

36.9 Calc.el

36.10 Calculator.el, A simple pocket calculator for Emacs

[Eli Barzilay] 1998-11 This calculator is used in the same way as
other popular calculators like xcalc or calc.exe - but using a
keyboard interface. You can use numbers, binary and unary operators
and parens. Here are some of the default keys

36.11 Color-mode.el

[Don Knuth] When using this mode you can colorize the current line
with various colors called color-@, color-a, color-b, etc., by
saying "C-c@", "C-ca", "C-cb", etc. And C-c DEL will uncolorize a
colorized line.

36.12 Color-themes.el, preview and install color themes

[Alex Schroeder] 2000-02. The main function to call is
color-package-select. That creates a buffer for selecting a package
to preview. Once in the Color Theme Selection mode use C-h m to get
more help. I (Alex Schroeder) rewrote a lot of this package. All
the good ideas are Jonadab's ideas, all the bugs are mine.

face-list.el mode might be very useful for people developing
color-themes... After calling list-faces-display you are put in a
special mode that allows you to call 'customize-face' for the face
at point with a keystroke. In order to use this for color-theme.el,
customize the faces you want without saving them for future
sessions, and then use color-theme-print to save your settings in a
color-theme (setting the stuff for future sessions would record the
face definitions in your ~/.emacs file).

36.13 Comment.el

[Noah Friedman] The default Emacs commenting has many limitations
and you're much more satisfied with Noah's package.

Default Emacs Always puts the comment-start on the left margin.

Doesn't handle nested comments.

Gets fooled more easily than font-lock: too often font-lock
shows me the comments just fine, but the comment operations
somehow decide that the comment starts and/or ends somewhere
else. Clearly the use of regexps instead of the syntax-table is
to be blamed here.

36.14 Cib.el, Complete into Buffer for Emacs

[Carsten Dominik] 1999-11 Recently I tried to implement M-TAB
completion for a case-insensitive Programming language and ran into
the following problems:

I never liked the fact that each completion messes up my window
configuration by popping up but the Completions buffer, but
not removing it after the work is done.

I wanted to run a hook after successful completion including
after when the user selects a completion with the mouse.

Mouse selection of a completion fails for case-insensitive
completion (see commentary for details).

I wanted to support both upper and lower case completion,
depending upon what a user preferred.

The code below is a one-function interface for completion in a
buffer, Sort or a completing-read for in-buffer completion. It
addresses The above issues and a few others as well. The commentary
contains Drop-in replacements for AUCTeX's TeX-complete-symbol
and for lisp-complete-symbol from lisp.el. You can evaluate these
to try out the code.

36.15 Complete-menu.el, complete items from x-popup

Originally by Alon Albert alon@milcse.rtsg.mot.com now included
in [Tiny Tools] kit. X only. Are you tired of getting
completion in separate buffer? With this package, "?" or C-tab,
displays completions in separate x-popup instead of buffer. This is
for your convience only, not essential package.

36.16 Ctypes.el, custom defined types for font lock

[Anders Lindgren] As most Emacs users know, Emacs can fontify
source code buffers using the font-lock package. Most of the
time it does a really good job. Unfortunately, the syntax of
one of the most widely spread languages, C, makes it difficult
to fontify variable declarations. This package can search
through source files hunting down typedefs. When found,
font-lock is informed and your source code will be even more
beautifully colored than before.

36.17 Dekeys, disable and enable keys without modifying keymaps

[Juanma Barranquero] 2001-03.

This package define commands dek-enable-key and
dek-disable-key (and aliases enable-key and disable-key,
if possible) to allow dynamically disabling and re-enabling
keys without the need to search and modify the right keymap.
Keys can be disabled and enabled at any time, but the
disabling only takes effect when dek-mode is active. This
option can be set through customize, or by using the function
dek-mode with a positive argument. Setting the variable to t
in .emacs before loading dekeys is also supported (though not
recommended). The disabling of keys with dekeys is neither
global nor local. It can be thought of as associating a
disable flag with a pair (key, command). Whenever a
dekeys-disabled command is invoked by the user (not from a
lisp function), it checks if that key is disabled for the
command. If so, the command is not executed. But the binding
between a key and a command depends of course of the current
keymaps. So in other words, if you disable "q" in a dired
buffer, you'll disable quit-window in dired buffers and also
in any other mode that has the same binding, but "q" will
still be a self-inserting key in text buffers, for example,
and quit-window will work if invoked from any other key.

36.18 Diminish-mode.el, modeline display help

[Will Mengarini] Minor modes each put a word on the mode line to
signify that they're active. This can cause other displays, such as
% of file that point is at, to run off the right side of the
screen. For some minor modes, such as mouse-avoidance-mode, the
display is a waste of space, since users typically set the mode in
their .emacs & never change it. For other modes, such as my
jiggle-mode, it's a waste because there's already a visual
indication of whether the mode is in effect. A diminished mode is a
minor mode that has had its mode line display diminished, usually
to nothing, although diminishing to a shorter word or a single
letter is also supported. This package implements diminished modes.

36.19 Etalk, run talk(1) in emacs buffer

[Eric Ludlam] Etalk is Unix talk running in an emacs buffer.

36.20 File-log.el, keep change information for each file.

[Frederic Lepied] These simple functions let you add log entries
for files you edit as soon as you want and then insert your log
entries in the comment buffer when you commit your changes via the
version control tools (vc or cvs). The entries are stored in files
with a .flog extension. ie. for a file called foo.bar the entries
will be in foo.bar.flog. When the commit is done the corresponding
files are deleted.

[Robert Kiesling] 2000-11. gdialog.el uses the standard widget.el
package for easier input of simple expressions, and searches all
files in the directories below the top-level search directory (the
current directory) by default. It also defaults to the use of fgrep
(grep -F) for faster searches. Typing "M-x gdialog" creates a
window that contains text entry fields where you can enter a text
search string, the name of the top-level directory, where the files
in that directory and its subdirectories are searched for the
search string, and a "Search!" button that will start the
subprocess and send the output to an Emacs shell output window. The
output window uses compile-mode, so you can use that mode's
navigation features (e.g., C-x `) to navigate through the search
results.

36.22 Igrep.el, an improved interface to grep

[Kevin Rodgers] The newest version can be found with Google at
<http://groups.google.com/groups?group=gnu.emacs.sources>. If
you ever want to grep something from bunch of directories, you
can't live without this. It runs on compilation buffer, so
normal M-xgoto-error puts you right on the file inside
emacs. Get this and forget 'grep' that is included in
Emacs. See also

36.23 Initsplit, code to split customizations into different files

[John Wiegley] 2000-01. This file allows you to split Emacs
customizations (set via M-x customize) into different files, based
on the names of the variables. It uses a regexp to match against
each face and variable name, and associates with a file that the
variable should be stored in.

36.25 Ishl.el, incremental search highlighting (*), Emacs

#todo: emacs?

[Bob Glickstein] 1997. Ishl has been approved for inclusion in an
upcoming release of Emacs, under the name isearch-lazy-highlight.
Ishl stands for "incremental search highlighting." Normally,
incremental search highlights the current match for the search
string using the "region" face. This package uses the "secondary
selection" face to highlight all the other matches, too. This makes
it easier to anticipate where the cursor will land each time you
press C-s or C-r to repeat a pending search forward or
backward.

36.26 Lprint, print to your local printer

[Ron Isaacson] lprint is a quick and easy way to print from Emacs
to the LOCAL printer. If I'm at home and I dial in by modem to my
account and run Emacs, the local printer is the one sitting on my
desk at home, connected to my home computer.

36.27 Mathlab.el

36.28 Master.el, scroll other buffer

[Alex Schroeder] 1999-02. master-mode is a minor mode which enables
you to scroll another buffer (the slave) without leaving your
current buffer (the master). It is used by sql.el, for example: The
SQL buffer is the master and the SQLi buffer commands are sent to
is the slave. This allows you to scroll the SQLi buffer containing
the output of the commands you sent it from the SQL buffer.

36.31 Narrow-stack.el, recursive narrow

36.32 Next-screen-line.el, Move logical next line even if long display

Often having to edit files with more than 80 columns, I prefer that
next-line and previous-line not jump over wrapped continuation
lines. Here is a drop-in replacement for next-line-internal that
moves the cursor by screen lines rather than newline-separated
lines. This is especially handy while editing binary files. The
functions beginning-of-line and end-of-line, bound to C-a and
C-e respectively, are also redefined to behave similarly. Nothing
is different when these functions are called non-interactively, so
other packages should not be affected. During interactive use, the
old behavior can be had by setting the variable
next-line-move-newlines to true.

36.33 Pager.el, Keep page up and down position

[Mikael Sjodin] Pager provides new scroll-commands. Emacs builtins
(scroll-down and scroll-up) sucks!! With my commands a page-up
followed by a page-down command will return the point to same place
where it was before the page-up command.

36.34 Pcomplete, context aware complete

[John Wiegley] 1999-08. This module provides a programmable
completion facility using "completion functions". Each completion
function is responsible for producing a list of possible
completions relevant to the current argument position.

36.35 Power-macros.el, assign macro to key

[Jesper Pedersen] When you have loaded this packages Emacs will,
upon comletion of macro definition, ask you which key you want to
assign this macro to and ask for a description of the macro. If
something is already bound to this key, Emacs will ask you whether
you want to override this binding. Furthermore, this package also
takes care of saving the macro to your .emacs file for later Emacs
sessions. The most notable difference to tinymacro.el is the
macro manage buffer. Which lets you move macros to other keys, move
a macro from being defined for one major-mode to another, and so
on.

36.36 Printing.el, Printing utilities.

[Vinicius Latorre] 2000-04. This package provides some printing
utilities that includes previewing/printing a PostScript file,
printing a text file and previewing/printing some major modes (like
mh-folder-mode, rmail-summary-mode, gnus-summary-mode, etc).
Printing.el was inspired on:

printing.el is prepared to run on Unix and NT systems. On Unix
system, printing depends on gs and gv utilities. On NT system,
printing.el depends on gstools (gswin32.exe and gsview32.exe). To
obtain ghostscript, ghostview and GSview see the URL
http://www.cs.wisc.edu/~ghost/.

36.37 Redo.el, Redo/undo system (*), XEmacs

[Kyle Jones] Emacs' normal undo system allows you to undo an
arbitrary number of buffer changes. These undos are recorded as
ordinary buffer changes themselves. So when you break the chain of
undos by issuing some other command, you can then undo all the
undos. The chain of recorded buffer modifications therefore grows
without bound, truncated only at garbage collection time.The
redo/undo system is different in two ways:

The undo/redo command chain is only broken by a buffer
modification. You can move around the buffer or switch buffers
and still come back and do more undos or redos.

The redo command rescinds the most recent undo without
recording the change as a new buffer change. It completely
reverses the effect of the undo, which includes making the
chain of buffer modification records shorter by one, to
counteract the effect of the undo command making the record
list longer by one.

36.38 Rpm.el, Redhat Linux package browser

[Detlev Zundel] 1998-09. This mode provides sort of a dired buffer
to interact with the rpm utility used on some Linux systems to
manage software packages. The mode starts up by displaying all
installed packages. You can then get detailed informations on a
specific package, verify, install/uninstall a package or check/list
dependencies. In the detailed information buffer you can easily
visit listed files e.g. to check readme's or other documentation
stuff. rpm-mode also hooks into dired mode, so you can easily
install a file (or tagged files) from a dired buffer.It's generally
a nice way to browse through the packages without having to
remember the syntax of rpm.

My primary intention was NOT to read .rpm files and view/edit parts
of it but to construct a front-end for rpm for GNU Emacs. It is
very useful if you want to browse the installed packages, perform
operations on them, etc. So the mode does not read raw .rpm files
but rather uses "rpm" to do all the processing. But it would of
course be nice to preview .rpm-files before the installation and
indeed Bart Schaefer has mailed an extension to arc-mode.el to me
that implements exactly that functionality. I think that arc-mode
is the natural place for an rpm-mode as an rpm-file is rather an
archive than a compressed file and Bart wrote the code already so
why not use it.

...I wrote a SQL mode for Emacs 20.3 based on comint-mode. I use it
a lot whenever I need a decent interface for Oracle's SQL*Plus.
sql-interactive-mode is used to interact with a SQL interpreter
process in the SQL buffer. The SQL buffer is created by calling
a SQL interpreter-specific entry function. Do not call sql-mode
by itself - some variables must be set by the entry function. This
sql-mode doesn't try to do what many other sql-modes can do much
better, such as Peter D. Pezaris' sql-mode or any of the many other
SQL modes available. It's only goal is to be small and simple and
to provide syntax hilighting. The following interpreters are
supported:

psql by Postgres

mysql by MySQL

solsql by Solid

SQL*Plus by Oracle

dbaccess by Informix

isql by SyBase

sql by Ingres

isql by Microsoft

SQL mode for MySql suport
Look at one sql mode by [Espen Wiborg].

PostgreSQL pg.el[Eric Marsden] 1999-03. pg.el provides a socket-level interface to
the PostgreSQL object-relational database system. It is capable of
automatic type coercions from a range of SQL types to the
equivalent Emacs Lisp type.

36.43 Sqlplus-html.el, Render SQL*Plus HTML output on-the-fly.

[Hrvoje Niksic] This package might be useful to people
who use Oracle's SQL*Plus in a shell buffer. It massages the
output of SQL*Plus to format it into nice-looking tables a la
mysql's command line client. This is feasible thanks to the
fact that SQL*Plus has an option to produce HTML output, and
that links and w3 handle HTML tables nicely. For the mode to
work, you will need a working w3 package or the links
external browser (lynx won't do because it doesn't handle
tables.) Start the sqlplus client in a comint (i.e. shell)
buffer. Then execute `M-x sqlplus-html-setup', and you should
be all set

36.44 Tablature-mode.el

Mark Rubin 1993-09 no email known
See if LCD has this, dejanews don't

Playing guitar? Want to write tab for others? This is handy
tool for it.

36.45 Vi-dot.el, repeat the preceding command

[Will Mengarini] This package defines a command that repeats the
preceding command, whatever that was. The command is called
vi-dot because the vi editor, Emacs's arch-rival among the Great
Unwashed, does that when "." is pressed in its command mode. If the
preceding command had a prefix argument, that argument is applied
to the vi-dot command, unless the vi-dot command is given a new
prefix argument, in which case it applies that new prefix argument
to the preceding command. This means a key sequence like C-u - C-x
C-t can be repeated. (It shoves the preceding line upward in the
buffer.).

37.0 Ported XEmacs or Emacs packages

37.1 Crisp.el, xemacs brief editor emulation

Currently available for Emacs 20.2+ [Url location unknown]

37.2 Pc-select.el, select region with cursor keys (*), Emacs

[Michael Staats] 1997-08-28 comp.emacs pc-select.el, which is a
part of the standard distribution of GNU emacs, now also works with
XEmacs (following a suggestion from Don Mahurin
dmahurin@dmapub.dma.org). At least as far as I tested it up to
now.

37.3 Ffap.el, find file at point (*), Emacs

Included in latest Emacs

37.4 Printing.el

[Vinicius Latorre] 2000-12. This package provides some printing
utilities that includes previewing/printing a PostScript file,
printing a text file and previewing/printing some major modes (like
mh-folder-mode, rmail-summary-mode, gnus-summary-mode, etc).
Printing.el is prepared to run on Unix and NT systems. On Unix
system, Printing.el depends on gs and gv utilities. On NT
system,Printing.el depends on gstools (gswin32.exe and
gsview32.exe). To obtain ghostscript, ghostview and GSview see the
URL <http://www.cs.wisc.edu/~ghost/>. Printing.el also depends on
ps-print and lpr GNU Emacs packages. Printing.el was inspired on:

37.5 Print - a2ps-print.el

37.6 Ps-print.el, print font lock color buffers (*)

37.7 Ps-print-interface.el

[Volker Franz] ps-print-interface.el is a graphical front end for
ps-print. If you want to print a buffer, it gives you an interface
with buttons and menus which looks roughly like below. Currently,
ps-print-interface.el is still mainly for XEmacs. However, I hope
soon to be able to include some suggestions Vinicius (the author of
printing.el) made for GNU emacs. All the options can be set or
selected easily.

37.8 Uptimes.el, Emacs uptime

[Dave Pearson] 1999-05. uptimes provides a simple system for
tracking and displaying the uptimes of your emacs sessions. Simply
loading uptimes.el from your ~/.emacs file will start the tracking
of any session.

38.0 Emulation packages

38.1 Cua.el, Windows key-bindings

[Kim Storm] CUA mode provides a complete emulatation of the
standard CUA key bindings (Motif/Windows/Mac GUI) for
selecting and manipulating the region where S-<movement>
is used to highlight & extend the region and (almost)
transparently allows you to use the C-z, C-x, C-c, and C-v
keys as you are accustomed to on systems like Windows. In
addition to the basic functionality, CUA-mode has integrated
rectangle and <register support, as well as a global mark
feature - all using C-x, C-c and C-v rather than the normal
plethora of obscure key sequences!

The following CUA keys ARE rebound:

C-z -> undo
C-v -> paste

and now for the added bonus: When the region is currently active
(and highlighted since transient-mark-mode is used), the C-x and
C-c keys will work as CUA keys. When the region is not active, C-x
and C-c works as prefix keys!

C-x -> cut
C-c -> copy

This has a few drawbacks (such as not being able to copy the region
into a register using C-x r x), but it is not too serious since
there are other ways to do most things (e.g. I use C-u C-x r x a
C-v to copy the region to register a). And in the few cases where
you make a mistake and delete the region - you just undo the
mistake (with C-z).

When the region is highlighted, TAB and S-TAB will indent the
entire region by the normal tab-width (or the given prefix
arg).

C-x C-x (exchange point and mark) no longer activates the mark
(i.e. highlights the region). I found that to be confusing
since the sequence C-x C-x (exchange once) followed by C-x C-x
(change back) would then cut the region! To activate the
region in this way, use C-u C-x C-x.

[delete] will delete (not copy) the highlighted region.

The highlighted region is automatically deleted if other text is
typed or inserted.

38.2 Fsf-mouse.el, FSF mouse emulation in XEmacs

[Jan Vroonhof] This file emulates the mouse selection behaviour of
FSF Emacs, mostly based on descriptions of it on USENET. In
particular

It copies any mouse selection to the kill ring.

It moves the context-menu to C-mouse-3.

It makes mouse-3, Adjust the mouse selection if there is one.
Make selection from current point if there isn't.
Delete the region on a second click.[1]

38.3 Fsf-compat, FSF function library in XEmacs

See directory fsf-compat/ in your XEmacs installation. These packages
solve most of the incompatibities while porting from Emacs to
XEmacs. Eg timer.el vs. itimer.el

39.0 Ancient packages or included in Emacs

39.1 Browse-url.el, delegate url to www browsers (*)

[Part of X/Emacs][Denis Howe] 1995-04. This package provides
functions which read a URL (Uniform Resource Locator) from the
minibuffer, defaulting to the URL around point, and ask a
World-Wide Web browser to load it. It can also load the URL
associated with the current buffer. Different browsers use
different methods of remote control so there is one function for
each supported browser. If the chosen browser is not running, it is
started. Currently there is support for: netscape , mosaic, cci,
w3, w3-gnudoit, iximosaic, lynx-*, grail, mmm, generic.

Check also general url browser package, tinyurl.el. It
is a minor mode that you can turn on in any buffer. It's built on top
of browse-url.el.

39.2 Custom.el (*), Emacs and XEmacs

[maintainer] As a package writer, you should make it compatible with
custom; so that novice emacs users can change settings of the package
easily. Note that if your Emacs is not 20+ or XEmacs 20.3+, you're
bets served by Noah Friedman's cust-stub.el custom emulation library
by [Noah Friedman]

39.3 Fdb.el, ignore emacs error signals

[Anders Lindgren] Emacs 20.3 implemented debug-ignored-errors
which does the same thing as Anders's package. The same variable is
available in XEmacs too.

39.4 Filladapt.el, adaptive filling

Note: This is obsolete and old, Included in XEmacs. There
also was fa-extras.el which was and add-on to filladapt.el

[Kyle Jones] These functions enhance the default behavior of Emacs'
Auto Fill mode and the commands fill-paragraph,
lisp-fill-paragraph and fill-region-as-paragraph. The chief
improvement is that the beginning of a line to be filled is
examined and, based on information gathered, an appropriate value
for fill-prefix is constructed. Also the boundaries of the
current paragraph are located. This occurs only if the fill prefix
is not already non-nil. The net result of this is that blurbs of
text that are offset from left margin by asterisks, dashes, and/or
spaces, numbered examples, included text from USENET news articles,
etc. are generally filled correctly with no fuss.

39.5 Mview.el, view minor mode

Mike Williams mikew@gopher.dosli.govt.nz 1993-11. Emacs 19.30
ships with view-mode converted to minor mode, If you have older
Emacs, ftp this, so that you can enjoy the minor mode interface.

39.6 Suggbind.el, keybind command reminder

[Noah Friedman] 1994-03. Emacs 19.30 changed the behavior of
execute-extended-command (i.e. the command which lets you run other
commands by typing ``M-x foo'' so that if the variable
suggest-key-bindings is set, it prints the keybinding (if any) of
the command to help you learn shortcuts.

Emacs prior 19.35 show binding before the command execution,
which is not good.

39.7 Smtpmail.el (*)

[Part of XEmacs 19.15 and Emacs 20.x] ...way to say RMAIL, that the
outgoing Mail should be sent immediatly by the computer which is
directly connected with the internet and not with the computer on
which emacs is installed. Since it last about some minutes until
the mail RELAY is used to sent the mail further.

39.9 Term.el (*)

Term.el offers nice termcap colorings in the buffer. Eg. you
can run lynx, small and fast web browser, inside your emacs
buffer. Here is my setup how to run Lynx in my 19.28. I use
tinyurl.el to swing along the HTTP reference in mail posts

40.0 Directory listings of site-lisp

Example of mywebget.pl <http://perl-webget.sourceforge.net/>
and result of running mywebget-emacs.conf to generate
site-lisp/net hierarchy. The basic idea of the structure is:

ROOT ( /usr/share/emacs/site-lisp/ or $HOME/elisp )
common
| Files that can be used in Emacs and XEmacs,
| these files have been picked from
| gnu.emacs.sources or from mailing lists.
| Files do not have a homepage.
|
| lcd OHIO OSU Lisp code directory
| other
| programming
| win32 win32 only files
|
emacs Files that work only in EMACS
| users By person name
| packages By package name
| other Miscellaneous
|
xemacs Files that work only in XEMACS
| users By person name
| packages By package name
| other Miscellaneous
|
net Packages available from net, URL exists.
cvs-packages Packages that can be updated via CVS pserver
|
packages Packages, that consist of multiple files
|
users Individual user packages from their homepages.

Here is the structure as reported by perl program ddir.pl
Emacs ackage tinypath.el allows putting files easily under
multiple directories and auto-configures Emacs as needed if
you move/rename/delete directories.