Github/emacs
2
0
Fork 1
mirror of git://git.sv.gnu.org/emacs.git synced 2026-02-16 09:14:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

Release 18.59

Browse source
This commit is contained in:
Stefan Monnier 2017-10-18 13:31:44 -04:00
parent cd645247b0
commit 802cdf3d4b
782 changed files with 223638 additions and 37686 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
ChangeLog Normal file
View file

@ -0,0 +1,94 @@
Fri Oct 30 19:36:38 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Version 18.59 released.
Wed Oct 28 19:30:14 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* vmsdist.com: Don't copy vaxcrtl.olb into distribution.
Assume VMS version 5.5 or newer.
Sat Oct 3 01:32:44 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* build-install: Use sh -c pwd, not just pwd.
Fri Oct 2 19:14:07 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (install.xenix): Delete spurious space.
Tue Aug 25 18:04:27 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (src/paths.h): Use just `sed', not `/bin/sed'.
Sun Jun 7 14:21:01 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (install): Get rid of -s from install commands.
Thu Feb 13 14:53:26 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (install): Use INSTALL to install programs.
(INSTALL): New variable.
Sun Feb 9 21:41:17 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (mkdir): Create BINDIR and MANDIR if nec.
Don't chmod LIBDIR.
* build-install: Use normal convention for EMACS dir.
Fix syntax in directory name comparison.
Install emacsclient. Deleted the chmod for executables.
Start with #! to force use of sh.
Sat Feb 1 17:40:30 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* install.sh: New file.
Fri Jan 31 23:46:51 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (clean, distclean): Clean oldXMenu subdir.
Mon Jan 27 16:29:53 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (install): Remove `B' from tar xf command.
* Makefile (CLEANDIR): Add oldXMenu.
Sat Jan 25 00:06:59 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* build-install: Finish updating to sh syntax.
Fri Jan 17 22:56:27 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile (LIBDIR): Change back to /usr/local/emacs.
(It got changed recently but I don't know why.)
Sat Mar 9 23:21:20 1991 Richard Stallman (rms at mole.ai.mit.edu)
* Makefile (clean): Use /bin/pwd, not pwd.
Fri Sep 28 22:36:32 1990 Richard Stallman (rms at mole.ai.mit.edu)
* Makefile (install, install.sysv, install.xenix):
Install wakeup instead of loadst. No need for setuid or setgid.
Tue Aug 7 13:19:35 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* Makefile (clean): Clean etc if that's not the installation dir.
Thu Apr 26 13:36:18 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* Makefile (paths.h): Make sed alter each name in the path.
Tue Aug 30 13:43:43 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* Makefile (install.sysv): Use cpio, not tar.
Wed Aug 3 19:20:13 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* Makefile (lockdir): Rename `lock' target.
Depend on it from install*, not from `all'.
Mon May 16 02:08:08 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)
* Makefile: Changed LIBDIR and BINDIR back to /usr/local/{emacs,bin}
to match build-install and paths.h.

84
GETTING.GNU.SOFTWARE
View file

@ -1,84 +0,0 @@
-*- text -*-
Getting GNU Software, 19 Sep 90
Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc.
Permission is granted to anyone to make or distribute
verbatim copies of this document provided that the
copyright notice and this permission notice are preserved.
* GNU and the Free Software Foundation
Project GNU is organized as part of the Free Software Foundation, Inc.
The Free Software Foundation has the following goals:
1) to create GNU as a full development/operating system.
2) to distribute GNU and other useful software with source code and
permission to copy and redistribute.
Further information on the rationale for GNU is in file
/pub/gnu/etc/GNU (All files referred to are on the Internet host
prep.ai.mit.edu.
Information on GNU Internet mailing lists and gnUSENET newsgroupscan
be found in file /pub/gnu/etc/MAILINGLISTS.
* How To Get The Software
The easiest way to get a copy of the distribution is from someone else
who has it. You need not ask for permission to do so, or tell any one
else; just copy it. The second easiest is to ftp it over the
Internet. The third easiest way is to uucp it. Ftp and uucp
information is in file /pub/gnu/etc/FTP.
If you cannot get a copy any of these ways, or if you would feel more
confident getting copies straight from us, or if you would like to get
some funds to us to help in our efforts, you can order one from the
Free Software Foundation. See file /pub/gnu/etc/DISTRIB.
* Available Software
** GNU Emacs
The GNU Emacs distribution includes:
- manual source in TeX format.
- an enhanced regex (regular expression) library.
See file /pub/gnu/etc/MACHINES for the status of porting Emacs to
various machines and operating systems.
** C Scheme - a block structured dialect of LISP.
The Free Software Foundation distributes C Scheme for the MIT Scheme
Project on it tapes. A partial ftp distribution can be found on
prep.ai.mit.edu. The full ftp distribution can be found on
zurich.ai.mit.edu.
Problems with the C Scheme distribution and it's ftp distribution
should be referred to: <bug-cscheme@prep.ai.mit.edu>. There are two
general mailing lists: <scheme@mc.lcs.mit.edu> and
<info-cscheme@prep.ai.mit.edu>. Requests to join either list to:
<info-cscheme-request@prep.ai.mit.edu> or
<scheme-request@mc.lcs.mit.edu>.
** Other GNU Software
A fuller list of available software are in the files
/pub/gnu/etc/DISTRIB and /pub/gnu/etc/FTP.
* No Warranties
We distribute software in the hope that it will be useful, but without
any warranty. No author or distributor of this software accepts
responsibility to anyone for the consequences of using it or for
whether it serves any particular purpose or works at all, unless he
says so in writing.
* If You Like The Software
If you like the software developed and distributed by the Free
Software Foundation, please express your satisfaction with a donation.
Your donations will help to support the foundation and make our future
efforts successful, including a complete development and operating
system, called GNU (Gnu's Not Un*x), which will run Un*x user
programs. For more information on GNU and the Foundation, contact us
at Internet address <gnu@prep.ai.mit.edu> or the foundation's US Mail
address found in file /pub/gnu/etc/DISTRIB.

208
INSTALL Normal file
View file

@ -0,0 +1,208 @@
GNU Emacs Installation Guide
Copyright (c) 1988 Free software Foundation, Inc.
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last changed them,
and that any new or changed statements about the activities
of the Free Software Foundation are approved by the Foundation.
PREPARATION
0) Make sure your system has enough swapping space allocated
to handle a program whose pure code is 400k bytes or
and whose data area is at least 150k and can reach 600k
bytes or much more. If the swapping space is insufficient, you
will get an error in the command temacs -l loadup inc dump,
found in $BUILD/src/ymakefile, or possibly when running the
final dumped Emacs.
1) Choose a place in the file structure for the main directory
of Emacs code to reside. This will ultimately have
subdirectories named src, lisp, etc, etc. Call this name
$EMACS. Let $BUILD stand for the name the directory has now.
2) Copy $BUILD/src/config.h-dist to $BUILD/src/config.h,
and edit it to set the right options for your system. The file
$BUILD/etc/MACHINES may help you decide what to put there.
If you need to override any of the definitions in the s- and m-
files for your system and machine, do so by editing config.h,
not by changing the s- and m- files. Occasionally you may
need to redefine parameters used in etc/movemail.c.
3) Declare the place in the file system where Emacs will
be once installed. This is done in the file `src/paths.h'.
But you don't have to change it yourself. `build-install' and `make'
edit `src/paths.h' automatically.
If you are using the shell-script `build-install'
edit the assignment that sets the variable `EMACS'.
If you are using `make' in the main Emacs directory to do
the installation, edit the definition of `LIBDIR' in `Makefile'
in that directory.
If you are doing the building by hand (not using `build-install' or
`make') then you yourself must copy $BUILD/src/paths.h-dist to
paths.h, and edit it to contain the correct directory names:
$EMACS/lisp for the directory for Lisp libraries, and $EMACS/etc for
the directory for executables and text files.
Emacs will use these names once it has been built.
During building, Emacs searches the directory ../lisp for
Lisp files before the directories specified in paths.h, and
executable files are found in ../etc. So the main Emacs
directory $BUILD can be anywhere while Emacs is built, but
must be renamed to $EMACS afterwards in order for Emacs to
work properly.
4) Look at $BUILD/lisp/paths.el; if some of those values
are not right for your system, create a file
$BUILD/lisp/site-init.el containing Lisp code to override them.
You would use the Lisp function `setq'. For example,
(setq news-inews-program "/usr/bin/inews")
is how you would override the default value of the
variable news-inews-program (which is "/usr/local/inews").
5) Put into $BUILD/lisp/site-init.el any Lisp code
you want loaded into Emacs before it is dumped out.
This file is nonexistent in the distribution.
You do not need to create it, if you have nothing
to put in it.
6) Decide what compiler switches to use.
For example, if you would like to compile with optimization,
you might want to change the definition of CFLAGS in
the file $BUILD/src/ymakefile to use C_OPTIMIZE_SWITCH
instead of C_DEBUG_SWITCH.
Note that many Unix compilers have bugs that affect -O; if you use
-O, be prepared to recompile without -O if you have any trouble.
Note that many (most?) versions of debuggers
other than GDB do not know how to handle programs like Emacs
that use raw or cbreak mode, change other terminal status bits,
and use asynchronous SIGIO signals for terminal input.
However, most debuggers may work if Emacs uses a separate terminal
from the one being used by the debugger, or if Emacs is using
its own X window.
If you do have a debugger that works, it is probably best to use `-g'
so that you are not helpless in the face of a problem.
With GCC, you can use -O and -g together. The easiest way to do this
is to change C_DEBUG_SWITCH to include both -O and -g. GCC is probably
more reliable with -O than without, as it is tested more with -O.
The way to specify use of GCC is to set the environment variable CC
to `gcc' before you do `make install'
7) If you wish to compile with GCC, you may need to use -traditional
or run fixincludes. This is needed if your system's header files
are incompatible with ANSI C. If your system header files are designed
for ANSI C, then GCC should handle them properly. For more info, refer
the INSTALL file of GCC.
If your system header files are non-ANSI and you don't use -traditional
or fixincludes to compensate, the usual effect is that the ioctl
system call does not work. The result is an Emacs that almost completely
fails to work.
8) Refer to the file $BUILD/etc/TERMS for information on
fields you may wish to add to various termcap entries.
9) Run `make install' in the main directory of the Emacs distribution
to finish building and installing Emacs in the standard way.
You are done!
(On system V, you need to use `make install.sysv' instead of `make install'.
On Xenix, use `make install.xenix'.
On AIX, use `make install.aix'.
You can also try `make INSTALL=./install.sh install'
on any kind of system.)
The last step of building Emacs involves running Emacs in a special
way. At this time, if the directories that Emacs will refer to during
use for Lisp code and executables do not already exist, Emacs will
print a warning to this effect. If you plan to have `make' create
these directories while it installs Emacs, then do not be alarmed by
the warnings.
The shell script `build-install' is an alternative to `make install'.
It is a little less sophisticated than the makefile, but probably
easier to customize for nonstandard kinds of installation. If you
want to install in precisely the usual fashion, we recommend using
`make' rather than `build-install'.
BUILDING GNU EMACS
`make install' and its variants start with these steps to compile Emacs.
1) Cd to $BUILD/etc and run `make'.
This creates files named `ctags' and `etags' and `wakeup'
and `make-docfile' and `digest-doc' and `test-distrib'. And others.
2) Cd to $BUILD/src and Run `make'
This refers to files in the $BUILD/lisp and $BUILD/etc subdirectories
using names ../lisp and ../etc.
This creates a file $BUILD/src/xemacs which is the runnable Emacs,
assigning it a new version number by incrementing the version
stored in $BUILD/lisp/version.el.
It also creates a file in $BUILD/etc, whose name is
DOC followed by the current Emacs version.
This file contains documentation strings for all the
functions in Emacs. Each time you run make to make a new xemacs,
a new DOC file with a new name is made. You must keep
the DOC file for an Emacs version as long as you keep using
that Emacs version.
INSTALLATION
After compilation, `make install' and its variants continue with these steps
to install the Emacs already compiled.
0) Move files from $BUILD to $EMACS if they are not the same directory.
The files that you need include at least the subdirectories
lisp, etc and info. After this, the directory in which you said
(in paths.h) Emacs would be installed actually contains the necessary
parts of Emacs.
1) Move the file $EMACS/xemacs to /usr/local/bin/emacs,
or some other name in users' search paths.
`xemacs' has an alternate name $EMACS/src/emacs-EMACSVERSION;
you may wish to make a symbolic link
named /usr/local/bin/emacs pointing to that alternate name,
as an easy way of installing different versions.
You can delete $EMACS/src/temacs.
3) Move the programs ctags, etags and emacsclient from $EMACS/etc
to /usr/local/bin. These programs are run by users as shell commands.
The program $EMACS/etc/wakeup is invoked by Emacs when appropriate.
The programs $EMACS/etc/make-docfile and $EMACS/etc/test-distrib
are not used any more; they were used in building Emacs.
$EMACS/etc/digest-doc can be used to convert DOC into a
file for users to read. There is no important reason to move it.
4) The files in $EMACS/src subdirectory, except for xemacs,
are not used by Emacs once it is built.
See the file PROBLEMS in this directory for a list of various
problems sometimes encountered, and what to do about them.

150
Makefile Normal file
View file

@ -0,0 +1,150 @@
# make all to compile and build Emacs
# make install to install it
# make install.sysv to install on system V.
# make install.xenix to install on Xenix
# make install.aix to install on AIX.
# make tags to update tags tables
#
# make distclean to delete everything that wasn't in the distribution
# This is a very dangerous thing to do!
# make clean
# This is a little less dangerous.
SHELL = /bin/sh
# Where to install things
# Note that on system V you must change MANDIR to /use/local/man/man1.
# This got changed in late 1991 to say /usr/local/lib/emacs,
# but there was no explanation of why, so it seems better to keep this stable.
LIBDIR= /usr/local/emacs
BINDIR= /usr/local/bin
MANDIR= /usr/local/man/man1
# Flags passed down to subdirectory makefiles.
MFLAGS=
# Command used for installation.
# If `install' doesn't work on your system, try `./install.sh'.
INSTALL=install
# Subdirectories to make recursively. `lisp' is not included
# because the compiled lisp files are part of the distribution
# and you cannot remake them without installing Emacs first.
SUBDIR= etc src
# Subdirectories to install
COPYDIR= etc info lisp
# Subdirectories to clean
CLEANDIR= ${COPYDIR} lisp/term oldXMenu
all: src/paths.h ${SUBDIR}
src/paths.h: Makefile src/paths.h-dist
sed 's;/usr/local/emacs;${LIBDIR};g' < src/paths.h-dist > src/paths.h
src: etc
.RECURSIVE: ${SUBDIR}
${SUBDIR}: FRC
cd $@; make ${MFLAGS} all
install: all mkdir lockdir
# B option to tar xf removed because some systems don't have it.
# It should work without that as long as the same tar program
# is running on both sides of the pipe.
-if [ `/bin/pwd` != `(cd ${LIBDIR}; /bin/pwd)` ] ; then \
tar cf - ${COPYDIR} | (cd ${LIBDIR}; umask 0; tar xf - ) ;\
for i in ${CLEANDIR}; do \
(rm -rf ${LIBDIR}/$$i/RCS; \
rm -f ${LIBDIR}/$$i/\#*; \
rm -f ${LIBDIR}/$$i/*~); \
done \
else true; \
fi
$(INSTALL) -c etc/emacsclient ${BINDIR}/emacsclient
$(INSTALL) -c etc/etags ${BINDIR}/etags
$(INSTALL) -c etc/ctags ${BINDIR}/ctags
$(INSTALL) -c -m 1755 src/xemacs ${BINDIR}/xemacs
$(INSTALL) -c -m 444 etc/emacs.1 ${MANDIR}/emacs.1
-rm -f ${BINDIR}/emacs
mv ${BINDIR}/xemacs ${BINDIR}/emacs
install.sysv: all mkdir lockdir
-if [ `/bin/pwd` != `(cd ${LIBDIR}; /bin/pwd)` ] ; then \
find ${COPYDIR} -print | cpio -pdum ${LIBDIR} ;\
for i in ${CLEANDIR}; do \
(rm -rf ${LIBDIR}/$$i/RCS; \
rm -f ${LIBDIR}/$$i/\#*; \
rm -f ${LIBDIR}/$$i/*~); \
done \
else true; \
fi
-cpset etc/emacsclient ${BINDIR}/emacsclient 755 bin bin
-cpset etc/etags ${BINDIR}/etags 755 bin bin
-cpset etc/ctags ${BINDIR}/ctags 755 bin bin
-cpset etc/emacs.1 ${MANDIR}/emacs.1 444 bin bin
-/bin/rm -f ${BINDIR}/emacs
-cpset src/xemacs ${BINDIR}/emacs 1755 bin bin
install.xenix: all mkdir lockdir
if [ `pwd` != `(cd ${LIBDIR}; pwd)` ] ; then \
tar cf - ${COPYDIR} | (cd ${LIBDIR}; umask 0; tar xpf - ) ;\
for i in ${CLEANDIR}; do \
(rm -rf ${LIBDIR}/$$i/RCS; \
rm -f ${LIBDIR}/$$i/\#*; \
rm -f ${LIBDIR}/$$i/*~); \
done \
else true; \
fi
cp etc/etags etc/ctags etc/emacsclient ${BINDIR}
chmod 755 ${BINDIR}/etags ${BINDIR}/ctags ${BINDIR}/emacsclient
cp etc/emacs.1 ${MANDIR}/emacs.1
chmod 444 ${MANDIR}/emacs.1
-mv -f ${BINDIR}/emacs ${BINDIR}/emacs.old
cp src/xemacs ${BINDIR}/emacs
chmod 1755 ${BINDIR}/emacs
-rm -f ${BINDIR}/emacs.old
install.aix: all mkdir lockdir
-if [ `/bin/pwd` != `(cd ${LIBDIR}; /bin/pwd)` ] ; then \
tar cf - ${COPYDIR} | (cd ${LIBDIR}; umask 0; tar xBf - ) ;\
for i in ${CLEANDIR}; do \
(rm -rf ${LIBDIR}/$$i/RCS; \
rm -f ${LIBDIR}/$$i/\#*; \
rm -f ${LIBDIR}/$$i/*~); \
done \
else true; \
fi
install -f ${BINDIR} etc/emacsclient
install -f ${BINDIR} etc/etags
install -f ${BINDIR} etc/ctags
install -M 1755 -f ${BINDIR} src/xemacs
install -M 444 -f ${MANDIR} etc/emacs.1
-rm -f ${BINDIR}/emacs
mv ${BINDIR}/xemacs ${BINDIR}/emacs
mkdir: FRC
-mkdir ${LIBDIR} ${BINDIR} ${MANDIR}
distclean:
for i in ${SUBDIR}; do (cd $$i; make ${MFLAGS} distclean); done
cd oldXMenu; make ${MFLAGS} distclean
clean:
cd src; make clean
cd oldXMenu; make ${MFLAGS} clean
if [ `/bin/pwd` != `(cd ${LIBDIR}; /bin/pwd)` ] ; then \
cd etc; make clean; \
else true; \
fi
lockdir:
-mkdir ${LIBDIR}/lock
-chmod 777 ${LIBDIR}/lock
FRC:
tags: etc
cd src; ../etc/etags *.[ch] ../lisp/*.el ../lisp/term/*.el

771
PROBLEMS Normal file
View file

@ -0,0 +1,771 @@
This file describes various problems that have been encountered
in compiling, installing and running GNU Emacs.
* If you have trouble building Emacs in Solaris, it is likely to be
that you've put /usr/ucb ahead of /usr/ccs/bin in PATH. Try changing
that for building Emacs. (The problem may really come from
/usr/ucb/ld.)
* M-x manual command does not work on Solaris when you specify a
manual section number. You can make it work by setting manual-program
to "/usr/ucb/man".
* On some variants of SVR4, Emacs does not work at all with X.
Try defining BROKEN_FIONREAD in your config.h file. If this solves
the problem, please send a bug report to tell us this is needed; be
sure to say exactly what type of machine and system you are using.
* On some MIPS systems, division by zero crashes Emacs.
Some operating systems on MIPS machines give SIGTRAP for division by
zero instead of the usual signals. The only real solution is to fix
the system to give a proper signal.
In the meantime, you can change init_data in data.c if you wish.
Change it to handle SIGTRAP as well as SIGFPE. But this will have a
great disadvantage: you will not be able to run Emacs under a
debugger. I think crashing on division by zero is a lesser problem.
* Linking says that the functions insque and remque are undefined.
Change oldXMenu/Makefile by adding insque.o to the variable OBJS.
* Emacs fails to understand most Internet host names, even though
the names work properly with other programs on the same system.
This typically happens on Suns and other systems that use shared
libraries. The cause is that the site has installed a version of the
shared library which uses a name server--but has not installed a
similiar version of the unshared library which Emacs uses.
The result is that most programs, using the shared library, work with
the nameserver, but Emacs does not.
The fix is to install an unshared library that corresponds to what you
installed in the shared library, and then relink Emacs.
* On a Sun running SunOS 4.1.1, you get this error message from GNU ld:
/lib/libc.a(_Q_sub.o): Undefined symbol __Q_get_rp_rd referenced from text segment
The problem is in the Sun shared C library, not in GNU ld.
The solution is to install Patch-ID# 100267-03 from Sun.
* Self documentation messages are garbled.
This means that the file `etc/DOC-...' doesn't properly correspond
with the Emacs executable. Redumping Emacs and then installing the
corresponding pair of files should fix the problem.
* M-x shell immediately responds "Process shell exited abnormally with code 1".
This is often due to inability to run the program `env'.
This should be in the `etc' subdirectory of the directory
where Emacs is installed, and it should be marked executable.
* Trouble using ptys on AIX.
People often instll the pty devices on AIX incorrectly.
Use `smit pty' to reinstall them properly.
* Shell mode on HP/UX gives the message, "`tty`: Ambiguous".
christos@theory.tn.cornell.edu says:
The problem is that in your .cshrc you have something that tries to
execute `tty`. If you are not running the shell on a real tty then
tty will print "not a tty". Csh expects one word in some places,
but tty is giving it back 3.
The solution is to add a pair of quotes around `tty` to make it a single
word:
if (`tty` == "/dev/console")
should be changed to:
if ("`tty`" == "/dev/console")
Even better, move things that set up terminal sections out of .cshrc
and into .login.
* Using X Windows, control-shift-leftbutton makes Emacs hang.
Use the shell command `xset bc' to make the old X Menu package work.
* Emacs running under X Windows does not handle mouse clicks.
* `emacs -geometry 80x20' finds a file named `80x20'.
One cause of such problems is having (setq term-file-prefix nil) in
your .emacs file. Another cause is a bad value of EMACSLOADPATH in
the environment.
* Emacs gets error message from linker on Sun.
If the error message says that a symbol such as `f68881_used' or
`ffpa_used' or `start_float' is undefined, this probably indicates
that you have compiled some libraries, such as the X libraries,
with a floating point option other than the default.
It's not terribly hard to make this work with small changes in
crt0.c together with linking with Fcrt1.o, Wcrt1.o or Mcrt1.o.
However, the easiest approach is to build Xlib with the default
floating point option: to decide at run time what hardware is
available.
* Emacs fails to get default settings from X Windows server.
The X library in X11R4 has a bug; it interchanges the 2nd and 3rd
arguments to XGetDefaults. Define the macro XBACKWARDS in config.h to
tell Emacs to compensate for this.
I don't believe there is any way Emacs can determine for itself
whether this problem is present on a given system.
* Keyboard input gets confused after a beep when using a DECserver
as a concentrator.
This problem seems to be a matter of configuring the DECserver to use
7 bit characters rather than 8 bit characters.
* M-x shell persistently reports "Process shell exited abnormally with code 1".
This happened on Suns as a result of what is said to be a bug in Sunos
version 4.0.x. The only fix was to reboot the machine.
* Programs running under terminal emulator do not recognize `emacs'
terminal type.
The cause of this is a shell startup file that sets the TERMCAP
environment variable. The terminal emulator uses that variable to
provide the information on the special terminal type that Emacs
emulates.
Rewrite your shell startup file so that it does not change TERMCAP
in such a case. You could use the following conditional which sets
it only if it is undefined.
if ( ! ${?TERMCAP} ) setenv TERMCAP ~/my-termcap-file
Or you could set TERMCAP only when you set TERM--which should not
happen in a non-login shell.
* Error compiling sysdep.c, "sioctl.h: no such file or directory".
Among USG systems with TIOCGWINSZ, some require sysdep.c to include
the file sioctl.h; on others, sioctl.h does not exist. We don't know
how to distinguish these two kind of systems, so currently we try to
include sioctl.h on all of them. If this #include gets an error, just
delete it.
* X Windows doesn't work if DISPLAY uses a hostname.
People have reported kernel bugs in certain systems that cause Emacs
not to work with X Windows if DISPLAY is set using a host name. But
the problem does not occur if DISPLAY is set to `unix:0.0'. I think
the bug has to do with SIGIO or FIONREAD.
You may be able to compensate for the bug by doing (set-input-mode nil nil).
However, that has the disadvantage of turning off interrupts, so that
you are unable to quit out of a Lisp program by typing C-g.
The easy way to do this is to put
(setq x-sigio-bug t)
in your site-init.el file.
* Problem with remote X server on Suns.
On a Sun, running Emacs on one machine with the X server on another
may not work if you have used the unshared system libraries. This
is because the unshared libraries fail to use YP for host name lookup.
As a result, the host name you specify may not be recognized.
* Watch out for .emacs files and EMACSLOADPATH environment vars
These control the actions of Emacs.
~/.emacs is your Emacs init file.
EMACSLOADPATH overrides which directories the function
"load" will search.
If you observe strange problems, check for these and get rid
of them, then try again.
* Shell mode ignores interrupts on Apollo Domain
You may find that M-x shell prints the following message:
Warning: no access to tty; thus no job control in this shell...
This can happen if there are not enough ptys on your system.
Here is how to make more of them.
% cd /dev
% ls pty*
# shows how many pty's you have. I had 8, named pty0 to pty7)
% /etc/crpty 8
# creates eight new pty's
* Fatal signal in the command temacs -l loadup inc dump
This command is the final stage of building Emacs. It is run by the
Makefile in the src subdirectory, or by build.com on VMS.
It has been known to get fatal errors due to insufficient swapping
space available on the machine.
On 68000's, it has also happened because of bugs in the
subroutine `alloca'. Verify that `alloca' works right, even
for large blocks (many pages).
* test-distrib says that the distribution has been clobbered
* or, temacs prints "Command key out of range 0-127"
* or, temacs runs and dumps xemacs, but xemacs totally fails to work.
* or, temacs gets errors dumping xemacs
This can be because the .elc files have been garbled. Do not be
fooled by the fact that most of a .elc file is text: these are
binary files and can contain all 256 byte values.
In particular `shar' cannot be used for transmitting GNU Emacs.
It typically truncates "lines". What appear to be "lines" in
a binary file can of course be of any length. Even once `shar'
itself is made to work correctly, `sh' discards null characters
when unpacking the shell archive.
I have also seen character \177 changed into \377. I do not know
what transfer means caused this problem. Various network
file transfer programs are suspected of clobbering the high bit.
The only verified ways to transfer GNU Emacs are `tar', kermit (in
binary mode on Unix), and rcp or internet ftp between two Unix systems,
or chaosnet cftp using raw mode.
If you have a copy of Emacs that has been damaged in its
nonprinting characters, you can fix them:
1) Record the names of all the .elc files.
2) Delete all the .elc files.
3) Recompile alloc.c with a value of PURESIZE twice as large.
You might as well save the old alloc.o.
4) Remake xemacs. It should work now.
5) Running xemacs, do Meta-x byte-compile-file repeatedly
to recreate all the .elc files that used to exist.
You may need to increase the value of the variable
max-lisp-eval-depth to succeed in running the compiler interpreted
on certain .el files. 400 was sufficient as of last report.
6) Reinstall the old alloc.o (undoing changes to alloc.c if any)
and remake temacs.
7) Remake xemacs. It should work now, with valid .elc files.
* temacs prints "Pure Lisp storage exhausted"
This means that the Lisp code loaded from the .elc and .el
files during temacs -l loadup inc dump took up more
space than was allocated.
This could be caused by
1) adding code to the preloaded Lisp files
2) adding more preloaded files in loadup.el
3) having a site-init.el or site-load.el which loads files.
Note that ANY site-init.el or site-load.el is nonstandard;
if you have received Emacs from some other site
and it contains a site-init.el or site-load.el file, consider
deleting that file.
4) getting the wrong .el or .elc files
(not from the directory you expected).
5) deleting some .elc files that are supposed to exist.
This would cause the source files (.el files) to be
loaded instead. They take up more room, so you lose.
6) a bug in the Emacs distribution which underestimates
the space required.
If the need for more space is legitimate, change the definition
of PURESIZE in config.h.
But in some of the cases listed above, this problem is a consequence
of something else that is wrong. Be sure to check and fix the real
problem.
* Changes made to .el files do not take effect.
You may have forgotten to recompile them into .elc files.
Then the old .elc files will be loaded, and your changes
will not be seen. To fix this, do M-x byte-recompile-directory
and specify the directory that contains the Lisp files.
* The dumped Emacs (xemacs) crashes when run, trying to write pure data.
Two causes have been seen for such problems.
1) On a system where getpagesize is not a system call, it is defined
as a macro. If the definition (in both unexec.c and malloc.c) is wrong,
it can cause problems like this. You might be able to find the correct
value in the man page for a.out (5).
2) Some systems allocate variables declared static among the
initialized variables. Emacs makes all initialized variables in most
of its files pure after dumping, but the variables declared static and
not initialized are not supposed to be pure. On these systems you
may need to add "#define static" to the m- or the s- file.
* Compilation errors on VMS.
You will get warnings when compiling on VMS because there are
variable names longer than 32 (or whatever it is) characters.
This is not an error. Ignore it.
VAX C does not support #if defined(foo). Uses of this construct
were removed, but some may have crept back in. They must be rewritten.
There is a bug in the C compiler which fails to sign extend characters
in conditional expressions. The bug is:
char c = -1, d = 1;
int i;
i = d ? c : d;
The result is i == 255; the fix is to typecast the char in the
conditional expression as an (int). Known occurrences of such
constructs in Emacs have been fixed.
* rmail gets error getting new mail
rmail gets new mail from /usr/spool/mail/$USER using a program
called `movemail'. This program interlocks with /bin/mail using
the protocol defined by /bin/mail.
There are two different protocols in general use. One of them uses
the `flock' system call. The other involves creating a lock file;
`movemail' must be able to write in /usr/spool/mail in order to do
this. You control which one is used by defining, or not defining,
the macro MAIL_USE_FLOCK in config.h or the m- or s- file it includes.
IF YOU DON'T USE THE FORM OF INTERLOCKING THAT IS NORMAL ON YOUR
SYSTEM, YOU CAN LOSE MAIL!
If your system uses the lock file protocol, and fascist restrictions
prevent ordinary users from writing the lock files in /usr/spool/mail,
you may need to make `movemail' setgid to a suitable group such as
`mail'. You can use these commands (as root):
chgrp mail movemail
chmod 2755 movemail
* Emacs won't work with X-windows if the value of DISPLAY is HOSTNAME:0.
* GNUs can't make contact with the specified host for nntp.
Some people have found that Emacs was unable to connect to the local
host by name, as in DISPLAY=prep:0 if you are running on prep, but
could handle DISPLAY=unix:0. Here is what tale@rpi.edu said:
Seems as
though gethostbyname was bombing somewhere along the way. Well, we
had just upgrade from SunOS 3.5 (which X11 was built under) to SunOS
4.0.1. Any new X applications which tried to be built with the pre
OS-upgrade libraries had the same problems which Emacs was having.
Missing /etc/resolv.conf for a little while (when one of the libraries
was built?) also might have had a hand in it.
The result of all of this (with some speculation) was that we rebuilt
X and then rebuilt Emacs with the new libraries. Works as it should
now. Hoorah.
If you have already installed the name resolver in the file libresolv.a,
then you need to compile Emacs to use that library. The easiest way to
do this is to add to config.h a definition of LIBS_SYSTEM, LIBS_MACHINE
or LIB_STANDARD which uses -lresolv. Watch out! If you redefine a macro
that is already in use in your configuration to supply some other libraries,
be careful not to lose the others.
Thus, you could start by adding this to config.h:
#define LIBS_SYSTEM -lresolv
Then if this gives you an error for redefining a macro, and you see that
the s- file defines LIBS_SYSTEM as -lfoo -lbar, you could change config.h
again to say this:
#define LIBS_SYSTEM -lresolv -lfoo -lbar
* Emacs spontaneously displays "I-search: " at the bottom of the screen.
This means that Control-S/Control-Q "flow control" is being used.
C-s/C-q flow control is bad for Emacs editors because it takes away
C-s and C-q as user commands. Since editors do not output long streams
of text without user commands, there is no need for a user-issuable
"stop output" command in an editor; therefore, a properly designed
flow control mechanism would transmit all possible input characters
without interference. Designing such a mechanism is easy, for a person
with at least half a brain.
There are three possible reasons why flow control could be taking place:
1) Terminal has not been told to disable flow control
2) Insufficient padding for the terminal in use
3) Some sort of terminal concentrator or line switch is responsible
First of all, many terminals have a set-up mode which controls
whether they generate flow control characters. This must be
set to "no flow control" in order for Emacs to work. Sometimes
there is an escape sequence that the computer can send to turn
flow control off and on. If so, perhaps the termcap `ti' string
should turn flow control off, and the `te' string should turn it on.
Once the terminal has been told "no flow control", you may find it
needs more padding. The amount of padding Emacs sends is controlled
by the termcap entry for the terminal in use, and by the output baud
rate as known by the kernel. The shell command `stty' will print
your output baud rate; `stty' with suitable arguments will set it if
it is wrong. Setting to a higher speed causes increased padding. If
the results are wrong for the correct speed, there is probably a
problem in the termcap entry. You must speak to a local Unix wizard
to fix this. Perhaps you are just using the wrong terminal type.
For terminals that lack a "no flow control" mode, sometimes just
giving lots of padding will prevent actual generation of flow control
codes. You might as well try it.
If you are really unlucky, your terminal is connected to the computer
through a concentrator which sends flow control to the computer, or it
insists on sending flow control itself no matter how much padding you
give it. You are screwed! You should replace the terminal or
concentrator with a properly designed one. In the mean time,
some drastic measures can make Emacs semi-work.
One drastic measure to ignore C-s and C-q, while sending enough
padding that the terminal will not really lose any output.
Ignoring C-s and C-q can be done by using keyboard-translate-table
to map them into an undefined character such as C-^ or C-\. Sending
lots of padding is done by changing the termcap entry. Here is how
to make such a keyboard-translate-table:
(let ((the-table (make-string 128 0)))
;; Default is to translate each character into itself.
(let ((i 0))
(while (< i 128)
(aset the-table i i)
(setq i (1+ i))))
;; Swap C-s with C-\
(aset the-table ?\C-\\ ?\C-s)
(aset the-table ?\C-s ?\C-\\)
;; Swap C-q with C-^
(aset the-table ?\C-^ ?\C-q)
(aset the-table ?\C-q ?\C-^)
(setq keyboard-translate-table the-table))
An even more drastic measure is to make Emacs use flow control.
To do this, evaluate the Lisp expression (set-input-mode nil t).
Emacs will then interpret C-s and C-q as flow control commands. (More
precisely, it will allow the kernel to do so as it usually does.) You
will lose the ability to use them for Emacs commands. Also, as a
consequence of using CBREAK mode, the terminal's Meta-key, if any,
will not work, and C-g will be liable to cause a loss of output which
will produce garbage on the screen. (These problems apply to 4.2BSD;
they may not happen in 4.3 or VMS, and I don't know what would happen
in sysV.) You can use keyboard-translate-table, as shown above,
to map two other input characters (such as C-^ and C-\) into C-s and
C-q, so that you can still search and quote.
I have no intention of ever redisigning the Emacs command set for
the assumption that terminals use C-s/C-q flow control. This
flow control technique is a bad design, and terminals that need
it are bad merchandise and should not be purchased. If you can
get some use out of GNU Emacs on inferior terminals, I am glad,
but I will not make Emacs worse for properly designed systems
for the sake of inferior systems.
* Control-S and Control-Q commands are ignored completely.
For some reason, your system is using brain-damaged C-s/C-q flow
control despite Emacs's attempts to turn it off. Perhaps your
terminal is connected to the computer through a concentrator
that wants to use flow control.
You should first try to tell the concentrator not to use flow control.
If you succeed in this, try making the terminal work without
flow control, as described in the preceding section.
If that line of approach is not successful, map some other characters
into C-s and C-q using keyboard-translate-table. The example above
shows how to do this with C-^ and C-\.
* Control-S and Control-Q commands are ignored completely on a net connection.
Some versions of rlogin (and possibly telnet) do not pass flow
control characters to the remote system to which they connect.
On such systems, emacs on the remote system cannot disable flow
control on the local system.
One way to cure this is to disable flow control on the local host
(the one running rlogin, not the one running rlogind) using the
stty command, before starting the rlogin process. On many systems,
"stty start u stop u" will do this.
Some versions of tcsh will prevent even this from working. One way
around this is to start another shell before starting rlogin, and
issue the stty command to disable flow control from that shell.
* Screen is updated wrong, but only on one kind of terminal.
This could mean that the termcap entry you are using for that
terminal is wrong, or it could mean that Emacs has a bug handing
the combination of features specified for that terminal.
The first step in tracking this down is to record what characters
Emacs is sending to the terminal. Execute the Lisp expression
(open-termscript "./emacs-script") to make Emacs write all
terminal output into the file ~/emacs-script as well; then do
what makes the screen update wrong, and look at the file
and decode the characters using the manual for the terminal.
There are several possibilities:
1) The characters sent are correct, according to the terminal manual.
In this case, there is no obvious bug in Emacs, and most likely you
need more padding, or possibly the terminal manual is wrong.
2) The characters sent are incorrect, due to an obscure aspect
of the terminal behavior not described in an obvious way
by termcap.
This case is hard. It will be necessary to think of a way for
Emacs to distinguish between terminals with this kind of behavior
and other terminals that behave subtly differently but are
classified the same by termcap; or else find an algorithm for
Emacs to use that avoids the difference. Such changes must be
tested on many kinds of terminals.
3) The termcap entry is wrong.
See the file etc/TERMS for information on changes
that are known to be needed in commonly used termcap entries
for certain terminals.
4) The characters sent are incorrect, and clearly cannot be
right for any terminal with the termcap entry you were using.
This is unambiguously an Emacs bug, and can probably be fixed
in termcap.c, tparam.c, term.c, scroll.c, cm.c or dispnew.c.
* Output from Control-V is slow.
On many bit-map terminals, scrolling operations are fairly slow.
Often the termcap entry for the type of terminal in use fails
to inform Emacs of this. The two lines at the bottom of the screen
before a Control-V command are supposed to appear at the top after
the Control-V command. If Emacs thinks scrolling the lines is fast,
it will scroll them to the top of the screen.
If scrolling is slow but Emacs thinks it is fast, the usual reason is
that the termcap entry for the terminal you are using does not
specify any padding time for the `al' and `dl' strings. Emacs
concludes that these operations take only as much time as it takes to
send the commands at whatever line speed you are using. You must
fix the termcap entry to specify, for the `al' and `dl', as much
time as the operations really take.
Currently Emacs thinks in terms of serial lines which send characters
at a fixed rate, so that any operation which takes time for the
terminal to execute must also be padded. With bit-map terminals
operated across networks, often the network provides some sort of
flow control so that padding is never needed no matter how slow
an operation is. You must still specify a padding time if you want
Emacs to realize that the operation takes a long time. This will
cause padding characters to be sent unnecessarily, but they do
not really cost much. They will be transmitted while the scrolling
is happening and then discarded quickly by the terminal.
Most bit-map terminals provide commands for inserting or deleting
multiple lines at once. Define the `AL' and `DL' strings in the
termcap entry to say how to do these things, and you will have
fast output without wasted padding characters. These strings should
each contain a single %-spec saying how to send the number of lines
to be scrolled. These %-specs are like those in the termcap
`cm' string.
You should also define the `IC' and `DC' strings if your terminal
has a command to insert or delete multiple characters. These
take the number of positions to insert or delete as an argument.
A `cs' string to set the scrolling region will reduce the amount
of motion you see on the screen when part of the screen is scrolled.
* Your Delete key sends a Backspace to the terminal, using an AIXterm.
The solution is to include in your .Xdefaults the lines:
*aixterm.Translations: #override <Key>BackSpace: string(0x7f)
aixterm*ttyModes: erase ^?
This makes your Backspace key send DEL (ASCII 127).
* You type Control-H (Backspace) expecting to delete characters.
Put `stty dec' in your .login file and your problems will disappear
after a day or two.
The choice of Backspace for erasure was based on confusion, caused by
the fact that backspacing causes erasure (later, when you type another
character) on most display terminals. But it is a mistake. Deletion
of text is not the same thing as backspacing followed by failure to
overprint. I do not wish to propagate this confusion by conforming
to it.
For this reason, I believe `stty dec' is the right mode to use,
and I have designed Emacs to go with that. If there were a thousand
other control characters, I would define Control-h to delete as well;
but there are not very many other control characters, and I think
that providing the most mnemonic possible Help character is more
important than adapting to people who don't use `stty dec'.
If you are obstinate about confusing buggy overprinting with deletion,
you can redefine Backspace in your .emacs file:
(global-set-key "\b" 'delete-backward-char)
You may then wish to put the function help-command on some
other key. I leave to you the task of deciding which key.
* Editing files through RFS gives spurious "file has changed" warnings.
It is possible that a change in Emacs 18.37 gets around this problem,
but in case not, here is a description of how to fix the RFS bug that
causes it.
There was a serious pair of bugs in the handling of the fsync() system
call in the RFS server.
The first is that the fsync() call is handled as another name for the
close() system call (!!). It appears that fsync() is not used by very
many programs; Emacs version 18 does an fsync() before closing files
to make sure that the bits are on the disk.
This is fixed by the enclosed patch to the RFS server.
The second, more serious problem, is that fsync() is treated as a
non-blocking system call (i.e., it's implemented as a message that
gets sent to the remote system without waiting for a reply). Fsync is
a useful tool for building atomic file transactions. Implementing it
as a non-blocking RPC call (when the local call blocks until the sync
is done) is a bad idea; unfortunately, changing it will break the RFS
protocol. No fix was supplied for this problem.
(as always, your line numbers may vary)
% rcsdiff -c -r1.2 serversyscall.c
RCS file: RCS/serversyscall.c,v
retrieving revision 1.2
diff -c -r1.2 serversyscall.c
*** /tmp/,RCSt1003677 Wed Jan 28 15:15:02 1987
--- serversyscall.c Wed Jan 28 15:14:48 1987
***************
*** 163,169 ****
/*
* No return sent for close or fsync!
*/
! if (syscall == RSYS_close || syscall == RSYS_fsync)
proc->p_returnval = deallocate_fd(proc, msg->m_args[0]);
else
{
--- 166,172 ----
/*
* No return sent for close or fsync!
*/
! if (syscall == RSYS_close)
proc->p_returnval = deallocate_fd(proc, msg->m_args[0]);
else
{
* ld complains because `alloca' is not defined on your system.
Alloca is a library function in 4.2bsd, which is used very heavily by
GNU Emacs. Use of malloc instead is very difficult, as you would have
to arrange for the storage to be freed, and do so even in the case of
a longjmp happening inside a subroutine. Many subroutines in Emacs
can do longjmp.
If your system does not support alloca, try defining the symbol
C_ALLOCA in the m-...h file for that machine. This will enable the use
in Emacs of a portable simulation for alloca. But you will find that
Emacs's performance and memory use improve if you write a true
alloca in assembler language.
alloca (N) should return the address of an N-byte block of memory
added dynamically to the current stack frame.
* Vax C compiler bugs affecting Emacs.
You may get one of these problems compiling Emacs:
foo.c line nnn: compiler error: no table entry for op STASG
foo.c: fatal error in /lib/ccom
These are due to bugs in the C compiler; the code is valid C.
Unfortunately, the bugs are unpredictable: the same construct
may compile properly or trigger one of these bugs, depending
on what else is in the source file being compiled. Even changes
in header files that should not affect the file being compiled
can affect whether the bug happens. In addition, sometimes files
that compile correctly on one machine get this bug on another machine.
As a result, it is hard for me to make sure this bug will not affect
you. I have attempted to find and alter these constructs, but more
can always appear. However, I can tell you how to deal with it if it
should happen. The bug comes from having an indexed reference to an
array of Lisp_Objects, as an argument in a function call:
Lisp_Object *args;
...
... foo (5, args[i], ...)...
putting the argument into a temporary variable first, as in
Lisp_Object *args;
Lisp_Object tem;
...
tem = args[i];
... foo (r, tem, ...)...
causes the problem to go away.
The `contents' field of a Lisp vector is an array of Lisp_Objects,
so you may see the problem happening with indexed references to that.
* 68000 C compiler problems
Various 68000 compilers have different problems.
These are some that have been observed.
** Using value of assignment expression on union type loses.
This means that x = y = z; or foo (x = z); does not work
if x is of type Lisp_Object.
** "cannot reclaim" error.
This means that an expression is too complicated. You get the correct
line number in the error message. The code must be rewritten with
simpler expressions.
** XCONS, XSTRING, etc macros produce incorrect code.
If temacs fails to run at all, this may be the cause.
Compile this test program and look at the assembler code:
struct foo { char x; unsigned int y : 24; };
lose (arg)
struct foo arg;
{
test ((int *) arg.y);
}
If the code is incorrect, your compiler has this problem.
In the XCONS, etc., macros in lisp.h you must replace (a).u.val with
((a).u.val + coercedummy) where coercedummy is declared as int.
This problem will not happen if the m-...h file for your type
of machine defines NO_UNION_TYPE. That is the recommended setting now.
* C compilers lose on returning unions
I hear that some C compilers cannot handle returning
a union type. Most of the functions in GNU Emacs return
type Lisp_Object, which is currently defined as a union.
This problem will not happen if the m-...h file for your type
of machine defines NO_UNION_TYPE. That is the recommended setting now.

42
README Normal file
View file

@ -0,0 +1,42 @@
This directory holds the latest distribution version of GNU Emacs.
The subdirectory `src' holds the C code,
`lisp' holds the Lisp code for the editing commands,
`etc' holds various associated documentation files
and programs that Emacs runs,
`info' holds the Info documentation tree.
`man' holds the source of the Emacs manual.
`cpp' holds a C preprocessor for use instead of the installed one
when the installed one fails to distinguish more than 8 characters
in a symbol name.
`shortnames' holds programs and data files for creating files of #define's
used to convert long symbol names to distinct short ones
for C compiles that cannot distinguish more than 8 characters.
The file INSTALL in this directory says how to bring up
GNU Emacs on Unix, once you have loaded the entire subtree of this
directory.
The files `build-install' and `Makefile' help automate the process of
building and installing emacs. The former is a shell script. See
INSTALL for more info.
The file PROBLEMS contains information on many common
problems that occur in building, installing and running Emacs.
The `etc' subdirectory contains several other files,
named in capital letters, which you should look at
when installing GNU Emacs.
The file 'emacs.com' in this directory is for VMS. It defines
logical names and commands such as `emacs', so you must edit
it to specify the file and directory names used on your machine.
This file must be executed in each session to enable you to run
the installed Emacs. It should be executed by your `login.com' file,
or else perhaps it can be executed once at system boot time.
The file `kepteditor.com' in this directory is also for VMS.
When a user says to run Emacs, it really runs this command file.
See the files VMSINSTALL and VMSNOTES for more information on VMS use.

129
VMSINSTALL Normal file
View file

@ -0,0 +1,129 @@
* Installing GNU Emacs from a VMS install kit
If you receive a VMS distribution tape containing an install kit, you
can restore Emacs and run it immediately on any VMS system 4.2 or newer.
The installation command file will automatically rename certain files
whose names must vary according to the version of VMS in use.
However, it is not certain we will have the install kit developed
soon, so until that is done, you may receive an ordinary BACKUP
saveset instead.
* Installing GNU Emacs from an ordinary VMS BACKUP saveset
If you receive a VMS distribution tape in VMS BACKUP interchange
format you can restore Emacs and run it on VMS versions 4.2 or newer
after executing a few commands. What you must do depends on the
VMS version (one procedure for VMS 4.2 or 4.3; another procedure
for newer VMS versions).
For VMS versions 4.4 and up, make sure the file
SYS$SYSTEM:RIGHTSLIST.DAT has WORLD:R access. Emacs reads this file
to check file access.
In order to compile Emacs with the VMS C compiler, you will need a
pagefile quota of around 22000 pages, plus enough swap space to handle
that. (This was in VMS 5.1-1, with 5 meg of physical memory.) See
HELP SYSGEN CREATE and HELP SYSGEN INSTALL for more information.
Choose a directory to restore to, say DEV:[LIB]. Do:
$ mount/foreign mta0:
$ backup/log mta0: dev:[lib...]
Now, if you are using VMS version 4.4 or later, set your default to
the directory DEV:[LIB.EMACS] and run the command file
DEV:[LIB.EMACS]ALLRENAME.COM:
$ set default dev:[lib.emacs]
$ @allrename [...] "_" "-"
This renames all files in the Emacs distribution from their old-VMS
names (containing `_' characters) to their new-VMS names (containing
`-' instead).
Now, edit DEV:[LIB.EMACS]EMACS.COM. Replace the definition of
EMACS_LIBRARY with the appropriate device and directory. The
definition initially reads as follows:
$ define /translation=concealed emacs_library sys$device:[emacs.]
You would replace this with:
$ define /translation=concealed emacs_library dev:[lib.emacs.]
Now execute the command file DEV:[LIB.EMACS]EMACS.COM. This defines
a command EMACS that runs a suspendable permanent Emacs. To
fully install Emacs, you must arrange for users to run this file
on login, or arrange for this file to be run when the system boots.
The distribution contains an Emacs executable in
DEV:[LIB.EMACS]EMACS.EXE. It uses DEV:[LIB.EMACS]EMACS.DUMP every time
it runs. The EMACS.EXE has been linked with the non-sharable C
library, so it should run on any VMS V4.4+ system, whether or not the
C compiler exists. The .OBJ files are all there, so you can relink
with /debug if you want to have fun.
A few C source files contain compilation conditionals that depend
on the version of VMS. We have compiled these files specially for
VMS version 4.2 (or 4.3) in object files with extension .JBO.
So to run on VMS 4.2, rename all the .JBO files to .OBJ, then
link and build Emacs as described in DEV:[LIB.EMACS.SRC]VMSBUILD.
$ set def [.src]
$ rename *.jbo *.obj
$ @precomp
$ @link
$ @build
$ rename temacs.exe [-]emacs.exe
$ rename temacs.dump [-]emacs.dump
To be clean, you should also edit the file [.SRC]CONFIG.H to #include
the file S_VMS4_2.H. Then the proper conditionals will be activated
if you ever recompile.
* Moving a Unix distribution to VMS.
Moving a Unix distribution to VMS is mostly a matter of transferring
the files to the VMS system, but with old versions of VMS (prior to
4.4) it is a little more complicated because some of the file names
used on Unix are not supported by VMS. Every `-' in a Unix file name
must be changed to a `_' on VMS. (In VMS versions 4.4 and up, this is
not necessary, since `-' is allowed in file names.)
A few other changes must be made regardless of the version of VMS:
1) Copy the file [.SRC]VMSPATHS.H to [.SRC]PATHS.H, replacing any existing
file PATHS.H in that directory.
2) Delete any file [.SRC]CONFIG.H and replace it with a copy of
CONFIG.H-DIST. Then edit this file so it specifies `m-vax.h' as the
second include file and for the first include file one of
`s-vms4-0.h', `s-vms4-2.h', `s-vms4-4.h' or `s-vms5-5.h'. (Use the
highest version not greater than the VMS version you are running. For
VMS versions prior to 4.4, the `-' characters must be replaced with
`_'.)
You can now compile, link, build and install Emacs as described in
[.SRC]VMSBUILD..
* Moving a VMS distribution to Unix.
Delete all .OBJ files, and PATHS.H and CONFIG.H. Then copy the
remaining files, changing each `_' in a file name to `-`. Unix will
allow filenames with `_' but Emacs will not work with them!
Names which on VMS end in a period (have a null extension) should
have no period on Unix. Thus, "YMAKEFILE." becomes "ymakefile".
VMS file names are case-insensitive. On Unix, case is significant.
Most of the file names must be in lower case or they will not work.
There are only a few exceptions:
1) CHANGELOG. becomes ChangeLog
2) MAKEFILE. becomes Makefile
3) TAGS. becomes TAGS
4) Files of English text with null extensions keep their names
in upper case. For example, README. becomes README and
[.ETC]GNU. becomes GNU

70
VMSNOTES Normal file
View file

@ -0,0 +1,70 @@
See the file VMSINSTALL for VMS installation information.
* Deficiencies of VMS GNU Emacs
All GNU Emacs features which on Unix work by running a Unix utility
in a subprocess currently do not work on VMS.
These include reading and sending mail, reading and posting netnews,
spelling correction, displaying the time and load in the mode line,
and the `sort-columns' command. (dired and sending output to printers
don't work in version 18, but will in version 19.) Naturally, the
commands to view Unix manual pages and execute Unix shell commands
also do not work.
It is not possible to fix these problems in a general way on VMS
because they involve interfaces to parts of the operating system which
work very differently on VMS. Each feature must be reimplemented
individually.
I hope that someone will send me an implementation for directory listing
on VMS. This should not be very hard to do. Most of the code you need
is already provided in [.src]dired.c.
The normal commands for running an inferior shell or lisp with I/O
through an Emacs buffer do not work on VMS in Emacs version 18, but
will work in version 19. For the meanwhile, you can create a DCL
subprocess which does I/O through an Emacs buffer and get a similar
effect. See the file [.lisp]vms-patch.el.
* Specifying terminal type.
To specify a terminal type for Emacs that is not known to VMS,
define the logical name EMACS_TERM with the terminal type as value.
Terminal types are looked up in the termcap data base, which is
found as the file `[etc]termcap.dat' in the Emacs distribution.
* Specifying file names.
GNU Emacs accepts both Unix and VMS file name syntax. Most Lisp
code that runs in Emacs uses Unix syntax so it can run everywhere.
Users on VMS will generally type file names with VMS syntax.
The EMACSLOADPATH logical name, if you use it, should contain
directory names in Unix syntax, separated by commas.
find-file prompts with the current directory. You can then type a
relative directory spec to get somewhere else in the hirearchy. For
instance:
Find File: emacs_library:[src][-.lisp]startup.el
is converted to emacs_library:[lisp]startup.el by
expand-file-name. The basic rule is:
][- is treated like /.. (dir:[file.sub][-.other] ==> dir:[file.other],
dir:[file.sub][-] ==> dir:[file])
][. elides the ][ (dir:[file][.sub] ==> dir:[file.sub])
][alpha backs up to the previous [ (dir:[file][other] ==> dir:[other])
a colon appearing after a ] forces a new "root" disk.
(dev:[file]dev2:[other] ==> dev2:[other])
expand-file-name also tries to be smart about decnet node names,
but this is not yet known to work.
* A possible problem.
For VMS versions 4.4 and up, make sure the file
SYS$SYSTEM:RIGHTSLIST.DAT has WORLD:R access. Emacs reads this file
to check file access. If this file does not have appropriate access,
Emacs may think that you cannot write any files.

39
allrename.com Normal file
View file

@ -0,0 +1,39 @@
$! Command file to rename many files at once
$! performing a global string substitution on each name.
$!Example:
$! @allrename [...] "-" "_"
$!changes each `-' in a name into a `_'.
$!
$!The device and directory names are not altered.
$!
$ p2_length = f$length (p2)
$ p3_length = f$length (p3)
$
$file_loop:
$ full_name = f$search("''p1'*.*;*")
$ if ("''full_name'" .eqs. "") then goto done
$ original_device = f$parse("''full_name'",,,"DEVICE")
$ original_dir = f$parse("''full_name'",,,"DIRECTORY")
$ original_file_name = f$parse("''full_name'",,,"NAME")
$ original_file_type = f$parse("''full_name'",,,"TYPE")
$ original_file_version = f$parse("''full_name'",,,"VERSION")
$ original_file = original_file_name -
+ original_file_type + original_file_version
$ new_file = original_file
$ something_done = "false"
$name_loop:
$ max_length = f$length(new_file)
$ index = f$locate("''p2'", new_file)
$ if (index .ge. max_length) then goto end_of_name
$ something_done = "true"
$ new_file = f$extract (0,index,new_file) + p3 -
+ f$extract(index+p2_length,max_length-index,new_file)
$ goto name_loop
$end_of_name:
$ original_file = original_device + original_dir + original_file
$ new_file = original_device + original_dir + new_file
$ if (something_done) then -
rename 'original_file' 'new_file'
$ goto file_loop
$done:
$ exit

38
build-install Executable file
View file

@ -0,0 +1,38 @@
#!/bin/sh
# Shell script for building and installing Emacs.
# This is an alternative to `make install',
# and it still exists just because it always has.
set -x
EMACS=/usr/local/emacs
BIN=/usr/local/bin
/bin/sed "s;/usr/local/emacs;$EMACS;" < src/paths.h-dist > src/paths.h
(cd etc; make) || exit 1
(cd src; make) || exit 1
# The double quotes prevent an error from sh on Suns
# when the directory does not exist yet.
# We use sh -c pwd instead of just pwd because on some systems (Suns?)
# plan pwd tends to give back the specified name sometimes.
if [ `sh -c pwd` != "`(cd $EMACS; sh -c pwd)`" ]
then
mv `pwd` $EMACS
if [ $? != '0' ]
then
mkdir $EMACS
echo mv `pwd` to $EMACS failed--using tar to copy.
tar cf - . | (cd $EMACS; umask 0; tar xf -)
if [ $? != '0' ]
then
echo tar-copying `pwd` to $EMACS failed.
exit 1
fi
fi
fi
cp $EMACS/etc/[ce]tags $BIN
cp $EMACS/etc/emacsclient $BIN
mv $EMACS/src/xemacs $BIN/emacs
rm $EMACS/src/temacs

20
cpp/Makefile Normal file
View file

@ -0,0 +1,20 @@
# Makefile for cccp in the Emacs distribution only.
# Here we assume that you are using sys V.0
# (since cccp is used by Emacs only to deal with shortnames lossage).
# Therefore, we add -DEMACS to CFLAGS and add -lPW to linking.
CFLAGS=-g -I. -DEMACS
cpp: cccp
-rm cpp
ln cccp cpp
cccp: cccp.o y.tab.o
cc -o cccp -g cccp.o y.tab.o -lPW
testexp: y.tab.c
cc -g -DTEST_EXP_READER y.tab.c -o testexp
y.tab.c: cexp.y
echo expect 40 shift/reduce conflicts
yacc cexp.y
cccp.o: cccp.c
y.tab.o: y.tab.c
lint: y.tab.c
lint -p y.tab.c cccp.c

2483
cpp/cccp.c Normal file
View file

File diff suppressed because it is too large Load diff

591
cpp/cexp.y Normal file
View file

@ -0,0 +1,591 @@
/* Parse C expressions for CCCP.
Copyright (C) 1986 Free Software Foundation.
NO WARRANTY
BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
GENERAL PUBLIC LICENSE TO COPY
1. You may copy and distribute verbatim copies of this source file
as you receive it, in any medium, provided that you conspicuously
and appropriately publish on each copy a valid copyright notice
"Copyright (C) 1986 Free Software Foundation"; and include
following the copyright notice a verbatim copy of the above disclaimer
of warranty and of this License.
2. You may modify your copy or copies of this source file or
any portion of it, and copy and distribute such modifications under
the terms of Paragraph 1 above, provided that you also do the following:
a) cause the modified files to carry prominent notices stating
that you changed the files and the date of any change; and
b) cause the whole of any work that you distribute or publish,
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
License Agreement (except that you may choose to grant more extensive
warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
Mere aggregation of another unrelated program with this program (or its
derivative) on a volume of a storage or distribution medium does not bring
the other program under the scope of these terms.
3. You may copy and distribute this program (or a portion or derivative
of it, under Paragraph 2) in object code or executable form under the terms
of Paragraphs 1 and 2 above provided that you also do one of the following:
a) accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Paragraphs 1 and 2 above; or,
b) accompany it with a written offer, valid for at least three
years, to give any third party free (except for a nominal
shipping charge) a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of
Paragraphs 1 and 2 above; or,
c) accompany it with the information you received as to where the
corresponding source code may be obtained. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form alone.)
For an executable file, complete source code means all the source code for
all modules it contains; but, as a special exception, it need not include
source code for modules which are standard libraries that accompany the
operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
otherwise to copy, sublicense, distribute or transfer this program is void and
your rights to use the program under this License agreement shall be
automatically terminated. However, parties who have received computer
software programs from you with this License Agreement will not have
their licenses terminated so long as such parties remain in full compliance.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding!
Adapted from expread.y of GDB by Paul Rubin, July 1986.
/* Parse a C expression from text in a string */
%{
#include <setjmp.h>
/* #define YYDEBUG 1 */
static int yylex ();
static yyerror ();
int expression_value;
static jmp_buf parse_return_error;
/* some external tables of character types */
extern unsigned char is_idstart[], is_idchar[];
%}
%union {
long lval;
int voidval;
char *sval;
}
%type <lval> exp exp1 start
%token <lval> INT CHAR
%token <sval> NAME
%token <lval> ERROR
%left ','
%left OR
%left AND
%left '|'
%left '^'
%left '&'
%left EQUAL NOTEQUAL
%left '<' '>' LEQ GEQ
%left LSH RSH
%left '+' '-'
%left '*' '/' '%'
%right UNARY
%%
start : exp1
{ expression_value = $1; }
;
/* Expressions, including the comma operator. */
exp1 : exp
| exp1 ',' exp
{ $$ = $3; }
;
/* Expressions, not including the comma operator. */
exp : '-' exp %prec UNARY
{ $$ = - $2; }
| '!' exp %prec UNARY
{ $$ = ! $2; }
| '~' exp %prec UNARY
{ $$ = ~ $2; }
| '(' exp1 ')'
{ $$ = $2; }
;
/* Binary operators in order of decreasing precedence. */
exp : exp '*' exp
{ $$ = $1 * $3; }
| exp '/' exp
{ $$ = $1 / $3; }
| exp '%' exp
{ $$ = $1 % $3; }
| exp '+' exp
{ $$ = $1 + $3; }
| exp '-' exp
{ $$ = $1 - $3; }
| exp LSH exp
{ $$ = $1 << $3; }
| exp RSH exp
{ $$ = $1 >> $3; }
| exp EQUAL exp
{ $$ = ($1 == $3); }
| exp NOTEQUAL exp
{ $$ = ($1 != $3); }
| exp LEQ exp
{ $$ = ($1 <= $3); }
| exp GEQ exp
{ $$ = ($1 >= $3); }
| exp '<' exp
{ $$ = ($1 < $3); }
| exp '>' exp
{ $$ = ($1 > $3); }
| exp '&' exp
{ $$ = ($1 & $3); }
| exp '^' exp
{ $$ = ($1 ^ $3); }
| exp '|' exp
{ $$ = ($1 | $3); }
| exp AND exp
{ $$ = ($1 && $3); }
| exp OR exp
{ $$ = ($1 || $3); }
| exp '?' exp ':' exp
{ $$ = $1 ? $3 : $5; }
| INT
{ $$ = yylval.lval; }
| CHAR
{ $$ = yylval.lval; }
| NAME
{ $$ = 0; }
;
%%
/* During parsing of a C expression, the pointer to the next character
is in this variable. */
static char *lexptr;
/* Take care of parsing a number (anything that starts with a digit).
Set yylval and return the token type; update lexptr.
LEN is the number of characters in it. */
/* maybe needs to actually deal with floating point numbers */
static int
parse_number (olen)
int olen;
{
register char *p = lexptr;
register long n = 0;
register int c;
register int base = 10;
register len = olen;
char *err_copy;
extern double atof ();
for (c = 0; c < len; c++)
if (p[c] == '.') {
/* It's a float since it contains a point. */
yyerror ("floating point numbers not allowed in #if expressions");
return ERROR;
/* ****************
yylval.dval = atof (p);
lexptr += len;
return FLOAT;
**************** */
}
if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
p += 2;
base = 16;
len -= 2;
}
else if (*p == '0')
base = 8;
while (len-- > 0) {
c = *p++;
n *= base;
if (c >= '0' && c <= '9')
n += c - '0';
else {
if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
if (base == 16 && c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (len == 0 && c == 'l')
;
else {
yyerror ("Invalid number in #if expression");
return ERROR;
}
}
}
lexptr = p;
yylval.lval = n;
return INT;
}
struct token {
char *operator;
int token;
};
#define NULL 0
static struct token tokentab2[] = {
{"&&", AND},
{"||", OR},
{"<<", LSH},
{">>", RSH},
{"==", EQUAL},
{"!=", NOTEQUAL},
{"<=", LEQ},
{">=", GEQ},
{NULL, ERROR}
};
/* Read one token, getting characters through lexptr. */
static int
yylex ()
{
register int c;
register int namelen;
register char *tokstart;
register struct token *toktab;
retry:
tokstart = lexptr;
c = *tokstart;
/* See if it is a special token of length 2. */
for (toktab = tokentab2; toktab->operator != NULL; toktab++)
if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
lexptr += 2;
return toktab->token;
}
switch (c) {
case 0:
return 0;
case ' ':
case '\t':
case '\n':
lexptr++;
goto retry;
case '\'':
lexptr++;
c = *lexptr++;
if (c == '\\')
c = parse_escape (&lexptr);
yylval.lval = c;
c = *lexptr++;
if (c != '\'') {
yyerror ("Invalid character constant in #if");
return ERROR;
}
return CHAR;
case '/': /* possible comment */
if (*lexptr != '*')
return c;
for (;;) {
while (*lexptr != '\0') {
if (*lexptr++ == '*' && *lexptr == '/') {
lexptr++;
goto retry;
}
}
}
/* some of these chars are invalid in constant expressions;
maybe do something about them later */
case '+':
case '-':
case '*':
case '%':
case '|':
case '&':
case '^':
case '~':
case '!':
case '@':
case '<':
case '>':
case '(':
case ')':
case '[':
case ']':
case '.':
case '?':
case ':':
case '=':
case '{':
case '}':
case ',':
lexptr++;
return c;
case '"':
yyerror ("double quoted strings not allowed in #if expressions");
return ERROR;
}
if (c >= '0' && c <= '9') {
/* It's a number */
for (namelen = 0;
c = tokstart[namelen], is_idchar[c] || c == '.';
namelen++)
;
return parse_number (namelen);
}
if (!is_idstart[c]) {
yyerror ("Invalid token in expression");
return ERROR;
}
/* It is a name. See how long it is. */
for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
;
lexptr += namelen;
return NAME;
}
/* Parse a C escape sequence. STRING_PTR points to a variable
containing a pointer to the string to parse. That pointer
is updated past the characters we use. The value of the
escape sequence is returned.
A negative value means the sequence \ newline was seen,
which is supposed to be equivalent to nothing at all.
If \ is followed by a null character, we return a negative
value and leave the string pointer pointing at the null character.
If \ is followed by 000, we return 0 and leave the string pointer
after the zeros. A value of 0 does not mean end of string. */
static int
parse_escape (string_ptr)
char **string_ptr;
{
register int c = *(*string_ptr)++;
switch (c)
{
case 'a':
return '\a';
case 'b':
return '\b';
case 'e':
return 033;
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'v':
return '\v';
case '\n':
return -2;
case 0:
(*string_ptr)--;
return 0;
case '^':
c = *(*string_ptr)++;
if (c == '\\')
c = parse_escape (string_ptr);
if (c == '?')
return 0177;
return (c & 0200) | (c & 037);
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
{
register int i = c - '0';
register int count = 0;
while (++count < 3)
{
if ((c = *(*string_ptr)++) >= '0' && c <= '7')
{
i *= 8;
i += c - '0';
}
else
{
(*string_ptr)--;
break;
}
}
return i;
}
default:
return c;
}
}
static
yyerror (s)
char *s;
{
error (s);
longjmp (parse_return_error, 1);
}
/* This page contains the entry point to this file. */
/* Parse STRING as an expression, and complain if this fails
to use up all of the contents of STRING. */
int
parse_c_expression (string)
char *string;
{
lexptr = string;
if (lexptr == 0 || *lexptr == 0) {
error ("empty #if expression");
return 0; /* don't include the #if group */
}
/* if there is some sort of scanning error, just return 0 and assume
the parsing routine has printed an error message somewhere.
there is surely a better thing to do than this. */
if (setjmp(parse_return_error))
return 0;
if (yyparse ())
return 0; /* actually this is never reached
the way things stand. */
if (*lexptr)
error ("Junk after end of expression.");
return expression_value; /* set by yyparse() */
}
#ifdef TEST_EXP_READER
/* main program, for testing purposes. */
main()
{
int n;
char buf[1024];
extern int yydebug;
/*
yydebug = 1;
*/
initialize_random_junk ();
for (;;) {
printf("enter expression: ");
n = 0;
while ((buf[n] = getchar()) != '\n')
n++;
buf[n] = '\0';
printf("parser returned %d\n", parse_c_expression(buf));
}
}
/* table to tell if char can be part of a C identifier. */
char is_idchar[256];
/* table to tell if char can be first char of a c identifier. */
char is_idstart[256];
/* table to tell if c is horizontal space. isspace() thinks that
newline is space; this is not a good idea for this program. */
char is_hor_space[256];
/*
* initialize random junk in the hash table and maybe other places
*/
initialize_random_junk()
{
register int i;
/*
* Set up is_idchar and is_idstart tables. These should be
* faster than saying (is_alpha(c) || c == '_'), etc.
* Must do set up these things before calling any routines tthat
* refer to them.
*/
for (i = 'a'; i <= 'z'; i++) {
++is_idchar[i - 'a' + 'A'];
++is_idchar[i];
++is_idstart[i - 'a' + 'A'];
++is_idstart[i];
}
for (i = '0'; i <= '9'; i++)
++is_idchar[i];
++is_idchar['_'];
++is_idstart['_'];
/* horizontal space table */
++is_hor_space[' '];
++is_hor_space['\t'];
}
error (msg)
{
printf("error: %s\n", msg);
}
#endif

19
emacs.com Normal file
View file

@ -0,0 +1,19 @@
$ ! VMS command file to make the definitions needed to run the installed Emacs.
$ ! You must edit the file names herein when you install Emacs.
$ ! You must execute this in each session in order to run Emacs
$ ! or else it must be executed by the system at each boot.
$ ! To execute at boot time, specify "/SYSTEM" as the first parameter.
$
$ ! The following line must be changed according to where
$ ! in the file system you install Emacs.
$
$ define 'p1' /translation=concealed emacs_library sys$sysdevice:[emacs.]
$
$ ! These should no longer be needed, because everything
$ ! is now written to use emacs_library.
$ ! define 'p1' emacs_lisplib emacs_library:[lisp]
$ ! define 'p1' emacs_etc emacs_library:[etc]
$ ! define 'p1' emacs_lock emacs_library:[lock]
$ ! define 'p1' termcap emacs_library:[etc]termcap.dat
$ runemacs :== $emacs_library:[000000]emacs -map emacs_library:[000000]emacs.dump
$ emacs :== @emacs_library:[000000]kepteditor emacs

75
etc/3B-MAXMEM Normal file
View file

@ -0,0 +1,75 @@
Date: Mon, 16 Feb 87 15:04:41 EST
From: katinsky@gauss.rutgers.edu (David Katinsky)
To: rms@prep.ai.mit.edu
Subject: 3b2 procedure to raise MAXMEM
Below is the procedure I followed to allow enough memory for GnuEmacs to run
on my 3b2/400. The end result of this is that a process can snarf up to 2Mb
of memory. This can be a bit dangerous on a 2Mb machine, but I tried it and
it worked ok.
-------------------------------------------------------------------------------
In the simplest case, these are the procedures to reconfigure a 3bx kernel.
1] cd /etc/master.d
`ls` shows the files to be:
README ctc* hdelog idisk ipc iuart kernel mau
mem msg ports* prf sem shm stubs sxt
sys xt
2] Edit the file which contains the parameter[s] you wish to change.
In the following excerpt from /etc/master.d/kernel the value MAXMEM
was raised from 256 to 1024.
In V.3.0 and later releases, the parameter in question is MAXUMEM
instead of MAXMEM.
*
* The following entries form the tunable parameter table.
*
NCALL = 30
NPROC = 60
NTEXT = 58
NCLIST = 188
* maxmem is number of pages (2K) was 256 --dmk
MAXMEM = 1024
MAXUP = 25
* hashbuf must be a power of 2
NHBUF = 128
NPBUF = 8
3] cd /boot
4] mkboot -k KERNEL
5] shutdown -i5 -g0 -y
This will take the machine down and bring it back up into firmware
mode. When you see that the machine has reached this state, type the
firmware password (default=mcp). The machine will ask for the name of
a program to execute. At this prompt enter /etc/system . The machine
should start to boot and display its configuration data.
8701271222 dmk
[katinsky@topaz.rutgers.edu]
-------------------------------------------------------------------------------
I do not feel that having the default firmware password is a
problem... but if you wish to edit it out, feel free.
dmk


218
etc/AIX.DUMP Normal file
View file

@ -0,0 +1,218 @@
The following text was written by someone at IBM to describe an older
version of the code for dumping on AIX.
I (rms) couldn't understand the code, and I can't fully understand
this text either. I rewrote the code to use the same basic
principles, as far as I understood them, but more cleanly. This
rewritten code does not always work. In fact, the basic method
seems to be intrinsically flawed.
Since then, someone else implemented a different way of dumping on
the RS/6000, which does seem to work. None of the following
applies to the way Emacs now dumps on the 6000. However, the
current method fails to use shared libraries. Anyone who might be
interested in trying to resurrect the previous method might still
find the following information useful.
It seems that the IBM dumping code was simply set up to detect when
the dumped data cannot be used, and in that case to act approximately
as if CANNOT_DUMP had been defined all along. (This is buried in
paragraph 1.) It seems simpler just to define CANNOT_DUMP, since
Emacs is not set up to decide at run time whether there is dumping or
not, and doing so correctly would be a lot of work.
Note that much of the other information, such as the name and format
of the dumped data file, has been changed.
--rms
A different approach has been taken to implement the
"dump/load" feature of GNU Emacs for AIX 3.1. Traditionally the
unexec function creates a new a.out executable file which contains
preloaded Lisp code. Executing the new a.out file (normally called
xemacs) provides rapid startup since the standard suite of Lisp code
is preloaded as part of the executable file.
AIX 3.1 architecture precludes the use of this technique
because the dynamic loader cannot guarantee a fixed starting location
for the process data section. The loader loads all shared library
data BEFORE process data. When a shared library changes its data
space, the process initial data section address (_data) will change
and all global process variables are automatically relocated to new
addresses. This invalidates the "dumped" Emacs executable which has
data addresses which are not relocatable and now corrupt. Emacs would
fail to execute until rebuilt with the new libraries.
To circumvent the dynamic loader feature of AIX 3.1, the dump process
has been modified as follows:
1) A new executable file is NOT created. Instead, both pure and
impure data are saved by the dump function and automatically
reloaded during process initialization. If any of the saved data
is unavailable or invalid, loadup.el will be automatically loaded.
2) Pure data is defined as a shared memory segment and attached
automatically as read-only data during initialization. This
allows the pure data to be a shared resource amoung all Emacs
processes. The shared memory segment size is PURESIZE bytes.
If the shared memory segment is unavailable or invalid, a new
shared memory segment is created and the impure data save file
is destroyed, forcing loadup.el to be reloaded.
3) The ipc key used to create and access Emacs shared memory is
SHMKEY and can be overridden by the environment symbol EMACSSHMKEY.
Only one ipc key is allowed per system. The environment symbol
is provided in case the default ipc key has already been used.
4) Impure data is written to the ../bin/.emacs.data file by the
dump function. This file contains the process' impure data
at the moment of load completion. During Emacs initialization,
the process' data section is expanded and overwritten
with the .emacs.data file contents.
The following are software notes concerning the GNU Emacs dump function under AIX 3.1:
1) All of the new dump/load code is activated by the #ifdef SHMKEY
conditional.
2) The automatic loading of loadup.el does NOT cause the dump function
to be performed. Therefore once the pure/impure data is discarded,
someone must remake Emacs to create the saved data files. This
should only be necessary when Emacs is first installed or whenever
AIX is upgraded.
3) Emacs will exit with an error if executed in a non-X environment
and the dump function was performed within a X window. Therefore
the dump function should always be performed in a non-X
environment unless the X environment will ALWAYS be available.
4) Emacs only maintains the lower 24 bits of any data address. The
remaining upper 8 bits are reset by the XPNTR macro whenever any
Lisp object is referenced. This poses a serious problem because
pure data is stored in segment 3 (shared memory) and impure data
is stored in segment 2 (data). To reset the upper 8 address bits
correctly, XPNTR must guess as to which type of data is represented
by the lower 24 address bits. The technique chosen is based upon
the fact that pure data offsets in segment 3 range from
0 -> PURESIZE-1, which are relatively small offsets. Impure data
offsets in segment 2 are relatively large (> 0x40000) because they
must follow all shared library data. Therefore XPNTR adds segment
3 to each data offset which is small (below PURESIZE) and adds
segment 2 to all other offsets. This algorithm will remain valid
as long as a) pure data size remains relatively small and b) process
data is loaded after shared library data.
To eliminate this guessing game, Emacs must preserve the 32-bit
address and add additional data object overhead for the object type
and garbage collection mark bit.
5) The data section written to .emacs.data is divided into three
areas as shown below. The file header contains four character
pointers which are used during automatic data loading. The file's
contents will only be used if the first three addresses match
their counterparts in the current process. The fourth address is
the new data segment address required to hold all of the preloaded
data.
.emacs.data file format
+---------------------------------------+ \
| address of _data | \
+---------------------------------------+ \
| address of _end | \
+---------------------------------------+ file header
| address of initial sbrk(0) | /
+---------------------------------------+ /
| address of final sbrk(0) | /
+---------------------------------------+ /
\ \
\ \
all data to be loaded from
_data to _end
\ \
\ \
+---------------------------------------+
\ \
\ \
all data to be loaded from
initial to final sbrk(0)
\ \
+---------------------------------------+
Sections two and three contain the preloaded data which is
resotred at locations _data and initial sbrk(0) respectively.
The reason two separate sections are needed is that process
initialization allocates data (via malloc) prior to main()
being called. Therefore _end is several kbytes lower than
the address returned by an initial sbrk(0). This creates a
hole in the process data space and malloc will abort if this
region is overwritten during the load function.
One further complication with the malloc'd space is that it
is partially empty and must be "consumed" so that data space
malloc'd in the future is not assigned to this region. The malloc
function distributed with Emacs anticipates this problem but the
AIX 3.1 version does not. Therefore, repeated malloc calls are
needed to exhaust this initial malloc space. How do you know
when malloc has exhausted its free memroy? You don't! So the
code must repeatedly call malloc for each buffer size and
detect when a new memory page has been allocated. Once the new
memory page is allocated, you can calculate the number of free
buffers in that page and request exactly that many more. Future
malloc requests will now be added at the top of a new memory page.
One final point - the initial sbrk(0) is the value of sbrk(0)
after all of the above malloc hacking has been performed.
The following Emacs dump/load issues need to be addressed:
1) Loadup.el exits with an error message because the xemacs and
emacs-xxx files are not created during the dump function.
Loadup.el should be changed to check for the new .emacs.data
file.
2) Dump will only support one .emacs.data file for the entire
system. This precludes the ability to allow each user to
define his/her own "dumped" Emacs.
Add an environment symbol to override the default .emacs.data
path.
3) An error message "error in init file" is displayed out of
startup.el when the dumped Emacs is invoked by a non-root user.
Although all of the preloaded Lisp code is present, the important
purify-flag has not been set back to Qnil - precluding the
loading of any further Lisp code until the flag is manually
reset.
The problem appears to be an access violation which will go
away if the read-write access modes to all of the files are
changed to rw-.
4) In general, all file access modes should be changed from
rw-r--r-- to rw-rw-rw-. They are currently setup to match
standard AIX access modes.
5) The dump function is not invoked when the automatic load of
loadup.el is performed.
Perhaps the command arguments array should be expanded with
"dump" added to force an automatic dump.
6) The automatic initialization function alloc_shm will delete
the shared memory segment and .emacs.data file if the "dump"
command argument is found in ANY argument position. The
dump function will only take place in loadup.el if "dump"
is the third or fourth command argument.
Change alloc_shm to live by loadup.el rules.

39
etc/APOLLO Normal file
View file

@ -0,0 +1,39 @@
The Apollo has a bizarre operating system which does not permit
Emacs to be dumped with preloaded pure Lisp code. Therefore, each
time you start Emacs on this system, the standard Lisp code is loaded
into it. Expect it to take a long time. You can prevent loading of
the standard Lisp code by specifying the -nl switch. It must
come at the beginning of the command line; only the -t and -batch
switches may come before it.
You must use m-apollo.h in the config.h file, together with
s-bsd4.2.h.
There is one remaining problem on the Apollo. You must replace
the CPP line in src/Makefile with "CPP = /usr/lib/cpp".
The C preprocessor lives there rather than in /lib/cpp because the
Aegis OS uses the /lib directory as the repository for shared libraries.
Here is a design for a method of dumping and reloading the relevant
necessary impure areas of Emacs.
On dumping, you need to dump only the array `pure' plus the
locations that contain values of forwarded Lisp variables or that are
protected for garbage collection. The former can be found by a
garbage- collection-like technique, and the latter are in the
staticprolist vector (see alloc.c for both things).
Reloading would work in an Emacs that has just been started; except
when a switch is specified to inhibit this, it would read the dump
file and set all the appropriate locations. The data loaded must be
relocated, but that's not hard. Those locations that are of type
Lisp_Object can be found by a technique like garbage-collection, and
those of them that point to storage can be relocated. The other data
read from the file will not need to be relocated.
The switch to inhibit loading the data base would be used when it
is time to dump a new data base.
This would take a few seconds, which is much faster than loading
the Lisp code of Emacs from scratch.

57
etc/APPLE Normal file
View file

@ -0,0 +1,57 @@
@unnumbered Special Report: Apple's New Look and Feel
You might have read about the new look-and-feel copyright lawsuit,
Apple vs. Hewlett Packard and Microsoft. Apple claims the power to
stop people from writing any program that works even vaguely like a
Macintosh. If they and other look-and-feel plaintiffs triumph, they
will use this new power over the public to put an end to free software
that could substitute for commercial software.
In the weeks after the suit was filed, USENET reverberated with
condemnation for Apple. GNU supporters Richard Stallman, John Gilmore, and
Paul Rubin decided to take action against Apple's no-longer-deserved
reputation as a force for progress. Apple's reputation comes from having
made better computers; but now, Apple is working to make all non-Apple
computers worse. If this deprives the public of the future work of many
companies, the harm done would be many times the good that any one company
does. Our hope was that if the user community realizes how destructive
Apple's present actions are, Apple would lose customers and have more
trouble finding employees.
Our method of action was to print 5000 buttons that say ``Keep Your Lawyers
Off My Computer'' and hand them out at the West Coast Computer Faire. The
center of the button shows the rainbow-apple logo with a Gigeresque mouth
full of ferocious teeth. The picture was drawn by Etienne Suvasa, who also
drew the cover for the GNU Emacs manual. We call the picture ``Apple's New
Look and Feel''.
We gave out nearly 4000 buttons at the show (saving the rest for
afterwards). The result was a great success: the extent of anger at Apple
was apparent to everyone at the show. Many of the invited speakers at the
show wore our buttons, spoke about them, or even waved them from the
podium. The press noticed this: at least one Macintosh user's magazine
carried a photo of the button afterwards.
Some of you may be considering using, buying, or recommending Macintoshes;
you might even be writing programs for them or thinking about it. Please
think twice and look for an alternative. Doing those things means more
success for Apple, and this could encourage Apple to persist in its
aggression. It also encourages other companies to try similar
obstructionism.
[It is because of this boycott that we don't include support for Macintosh
Unix in GNU software.]
You might think that your current project ``needs'' a Macintosh now. If
you find yourself thinking this way, consider the far future. You probably
plan to be alive a year or two from now, and working on some other project.
You will want to get good computers for that, too. But an Apple monopoly
could easily make the price of such computers at that time several times
what it would otherwise be. Your decision to use some other kind of
machine, or to defer your purchases now, might make sure that the machines
your next project needs are affordable when you need them.
Newspapers report that Macintosh clones will be available soon. If
you must buy a Macintosh-like machine, buy a clone. Don't feed the
lawyers!

127
etc/BABYL Normal file
View file

@ -0,0 +1,127 @@
>From rlk@think.COM (Robert Krawitz) Mon Nov 30 10:56:46 1987
Let's see if I remember my BNF for babyl files; this corresponds to
version 5:
File := <header>
<message>* ; Some say there must be at least one message.
Header := Babyl Options:\n
<header-option>*
|^_
Header-option := <header-token> ; See note [5]
: *
<value>
header-token := [^\000-\017:\177-\377]* ; Not these characters [tab is OK]
header-value := ditto, if a list, each element separated by a comma and
a space.
message := \^L\n
[01], ; See note [1] below
( <attribute>,)* ; Note space before and comma after token
,
( <label>,)* ; ditto, see note [4] below
\n
<header>* ; See note [1] and [2] below
*** EOOH ***\n
<header>* ; See note [2] below
\n
<body>
\^_
attribute := unseen |
last | ; Not all programs implement this. It
; generally only gets used internally, and
; isn't written out to a file.
>last | ; Babyl uses this for a deleted message at the
; end. It shouldn't be written out to a file.
deleted |
recent | ; Not all programs implement this. It refers
; to a message in the last batch of new mail;
; thus it probably shouldn't be written out to
; a file during a normal save although it
; makes sense to write it out in an emergency save.
filed |
answered |
forwarded |
redistributed |
badheader | ; Not all programs implement this
filed ; Not all programs implement this
label := [^\000-\020,\177-\377]* ; No control chars,
; whitespace, commas, rubout, or high bit set
header := [^\000-\020:\177-\377]*:
<header-line>
<header-line>*
header-line := [ \t][^\n]*\n ; Continuation lines must be indented
body := (.*\n)* ; See note [3] below
[1] A zero means that the headers have not been cleaned up,
reprocessed, toggled, or whatever. In this case there should be no
headers before the EOOH line. A one means that the headers have been
reprocessed. In this case, the original headers will typically be
before the EOOH line and the reformatted or whatever subset of headers
that the user should see will be after it. Note that in this case
it's permissible to garbage collect all headers before the EOOH line.
No one's defined what it means to garbage collect SOME of the headers
before this line, or what that means.
[2] It's apparently permissible to add headers of the program's own
choosing before the EOOH line. Or at least, Rmail does so (it caches
a summary line) and nothing seems to object. There's no particular
guarantee that something else won't step all over it, though. Headers
after the EOOH line can be reformatted as the program wishes (e. g.
indent the header lines to the same distance, canonicalize machine
names) for display to the user. It's generally best for programs that
read a babyl file to look at the headers before the EOOH line if they
exist, since these should be untouched by the user. Remember, the
user can edit anything after the EOOH line.
[3] A \^_ at the beginning of a line should be quoted somehow. The
normal way seems to be to decompose it into 2 characters: a ^ and a _.
Strictly speaking, it doesn't always have to be, since the following
text would have to be parsable as a message, but some programs don't
try to use that much intelligence. Oh well.
[4] Labels, or keywords as they are often called, are generally
defined by the user, although it's not entirely impermissible for a
program to use these for its own purpose (e. g. a keyword named
RemindMe might be used to automatically find important messages).
Some people also want these used to cache other state implemented by
certain programs; this use is undefined. Note that all keywords used
should be inserted in a header-option named Keywords:. Can a keyword
have the same name as an attribute? Who knows? It's probably not a
good idea, since some programs use the concept of <labels> =
<keywords> + <attributes>. Sigh.
[5] Some tokens are standardized in meaning. Common tokens are Mail
inboxes, babyl file version number, which is currently 5, labels used
in messages, window format for Zmail, anything else you want to be
associated with a file. Be warned that labels should be a complete
list of all user-defined keywords used in the file, so if you add a
new label to a message, you should add it to this list. You should
also have a Babyl version: 5 file attribute (look in a babyl file for
details).
Anyone know if there actually is a "formal" standard? This was done
quickly from memory and a Zmail manual, but there are at least three
programs around that use Babyl files (zmail, babyl, and emacs/rmail)
and someone at SIPB was going to write a command-based mail reader
similar to Unix Mail but operating on babyl files, and someone (of
course not me :-)) should probably write xbabyl :-)
References:
ITS/Tops-20 INFO file on babyl (who wrote it? ECC? GZ?)
Zmail manual (the MIT version was written by RMS; ECC wrote the
section on Babyl file format)
--

159
etc/CCADIFF Normal file
View file

@ -0,0 +1,159 @@
Differences between GNU Emacs and CCA Emacs.
Copyright (c) 1985 Richard M. Stallman
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
* GNU Emacs Lisp vs CCA Elisp.
GNU Emacs Lisp does not have a distinction between Lisp functions
and Emacs functions, or between Lisp variables and Emacs variables.
The Lisp and the editor are integrated. A Lisp function defined
with defun is callable as an editor command if you put an
interactive calling spec in it; for example,
(defun forward-character (n)
(interactive "p")
(goto-char (+ (point) n)))
defines a function of one argument that moves point forward by
a specified number of characters. Programs could call this function,
as in (forward-character 6), or it could be assigned to a key,
in which case the "p" says to pass the prefix numeric arg as
the function's argument. As a result of this feature, you often
need not have two different functions, one to be called by programs
and another to read arguments from the user conveniently; the same
function can do both.
CCA Elisp tries to be a subset of Common Lisp and tries to
have as many Common Lisp functions as possible (though it is still
only a small fraction of full Common Lisp). GNU Emacs Lisp
is somewhat similar to Common Lisp just because of my Maclisp
and Lisp Machine background, but it has several distinct incompatibilities
in both syntax and semantics. Also, I have not attempted to
provide many Common Lisp functions that you could write in Lisp,
or others that provide no new capability in the circumstances.
GNU Emacs Lisp does not have packages, readtables, or character objects
(it uses integers to represent characters).
On the other hand, windows, buffers, relocatable markers and processes
are first class objects in GNU Emacs Lisp. You can get information about them
and do things to them in a Lispy fashion. Not so in CCA Emacs.
In GNU Emacs Lisp, you cannot open a file and read or write characters
or Lisp objects from it. This feature is painful to support, and
is not fundamentally necessary in an Emacs, because instead you
can read the file into a buffer, read or write characters or
Lisp objects in the buffer, and then write the buffer into the file.
On the other hand, GNU Emacs Lisp does allow you to rename, delete, add
names to, and copy files; also to find out whether a file is a
directory, whether it is a symbolic link and to what name, whether
you can read it or write it, find out its directory component,
expand a relative pathname, find completions of a file name, etc.,
which you cannot do in CCA Elisp.
GNU Emacs Lisp uses dynamic scope exclusively. This enables you to
bind variables which affect the execution of the editor, such as
indent-tabs-mode.
GNU Emacs Lisp code is normally compiled into byte code. Most of the
standard editing commands are written in Lisp, and many are
dumped, pure, in the Emacs that users normally run.
GNU Emacs allows you to interrupt a runaway Lisp program with
Control-g.
* GNU Emacs Editing Advantages
GNU Emacs is faster for many things, especially insertion of text
and file I/O.
GNU Emacs allows you to undo more than just the last command
with the undo command (C-x u, or C-_). You can undo quite a ways back.
Undo information is separate for each buffer; changes in one buffer
do not affect your ability to undo in another buffer.
GNU Emacs commands that want to display some output do so by putting
it in a buffer and displaying that buffer in a window. This
technique comes from Gosling Emacs. It has both advantages and
disadvantages when compared with the technique, copied by CCA Emacs
from my original Emacs which inherited it from TECO, of having "type
out" which appears on top of the text in the current window but
disappears automatically at the next input character.
GNU Emacs does not use the concept of "subsystems". Instead, it uses
highly specialized major modes. For example, dired in GNU Emacs has
the same commands as dired does in other versions of Emacs, give or
take a few, but it is a major mode, not a subsystem. The advantage
of this is that you do not have to "exit" from dired and lose the
state of dired in order to edit files again. You can simply switch
to another buffer, and switch back to the dired buffer later. You
can also have several dired buffers, looking at different directories.
It is still possible to write a subsystem--your own command loop--
in GNU Emacs, but it is not recommended, since writing a major mode
for a special buffer is better.
Recursive edits are also rarely used, for the same reason: it is better
to make a new buffer and put it in a special major mode. Sending
mail is done this way.
GNU Emacs expects everyone to use find-file (C-x C-f) for reading
in files; its C-x C-v command kills the current buffer and then finds
the specified file.
As a result, users do not need to think about the complexities
of subsystems, recursive edits, and various ways to read in files
or what to do if a buffer contains changes to some other file.
GNU Emacs uses its own format of tag table, made by the "etags"
program. This format makes finding a tag much faster.
Dissociated Press is supported.
* GNU Emacs Editing Disadvantages.
GNU Emacs does not display the location of the mark.
GNU Emacs does not have a concept of numbers of buffers,
or a permanent ordering of buffers, or searching through multiple
buffers. The tags-search command provides a way to search
through several buffers automatically.
GNU Emacs does not provide commands to visit files without
setting the buffer's default directory. Users can write such
commands in Lisp by copying the code of the standard file
visiting commands and modifying them.
GNU Emacs does not support "plus options" in the command
arguments or in buffer-selection commands, except for line numbers.
GNU Emacs does not support encryption. Down with security!
GNU Emacs does not support replaying keystroke files,
and does not normally write keystroke files.
* Neutral Differences
GNU Emacs uses TAB, not ESC, to complete file names, buffer names,
command names, etc.
GNU Emacs uses ESC to terminate searches, instead of
the C-d uses by CCA Emacs. (Actually, this character is controlled
by a parameter in GNU Emacs.) C-M-s in GNU Emacs is an interactive
regular expression search, but you can get to a noninteractive
one by typing ESC right after the C-M-s.
In GNU Emacs, C-x s asks, for each modified file buffer, whether
to save it.
GNU Emacs indicates line continuation with "\" and line
truncation (at either margin) with "$".
The command to resume a tags-search or tags-query-replace in
GNU Emacs is Meta-Comma.

54
etc/CHARACTERS Normal file
View file

@ -0,0 +1,54 @@
Ideas for extending GNU Emacs to deal with arbitrary character sets.
I would like GNU Emacs to be extended to handle all the world's alphabets
and word signs. I don't expect to have time to do such a thing in the next
few years, so here are my ideas on the best way to do it.
* Each graphic is represented by a sequence of ordinary 8-bit characters.
* All the characters that make up such a sequence have codes >= 0200.
* The first character of such a sequence is between 0200 and 0237.
* The remaining characters of such a sequence are all 0240 or higher.
* The first character of the sequence determines the number of characters
in the sequence. Thus, 0200...0207 could start two-character sequences,
0210...0227 could start three-character sequences, and 0230 could start
four-character sequences. (Codes 0231...0237 would be reserved.)
* Several common alphabets, and some mathematical symbols, would get
two-character sequences. (Probably Greek, Russian, Hebrew(?), Arabic(?),
Korean, and Japanese kana). The remaining alphabets, and some versions of
Chinese, would get three-character sequences. Other sets of Chinese
characters would get four-character sequences.
Each country that uses Chinese characters has its own standard character
set, and it is not easy to correlate them to avoid overlap. So there may
need to be several sets of Chinese characters. That is why they need so
much code space.
True support for Hebrew and Arabic requires dealing with the problem of
writing direction for mixed text; I don't know what to do for that.
* The functions that use syntax table would determine the
syntax of a sequence from its first character.
* Functions in indent.c for computing widths and columns would
determine the width of a sequence from its first character.
So would display routines.
* Only a few other editing routines would need any change. In
particular, searching and regexp matching might not need any change.
* Most of the work required would be in redisplay. The only case that
needs to be supported is with X windows, since ordinary terminals
can't display all these characters anyway.
* There might need to be code to translate files from this format
to whatever format is typically stored on disk.
I would be very unhappy with half-measures, such as support for
Japanese only.

157
etc/COOKIES Normal file
View file

@ -0,0 +1,157 @@
[Someone sent this in from California, and we decided to extend
our campaign against information hoarding to recipes as well
as software. (Recipes are the closest thing, not involving computers,
to software.)
The story appears to be a myth, according to the Chicago Tribune,
which says that Mrs Fields Cookies hoards the information completely.
Therefore, this recipe can be thought of as a compatible replacement.
We have reports that the cookies it makes are pretty good.]
Someone at PG&E called the Mrs. Fields Cookie office
and requested the recipe for her cookies. They asked
her for her charge card number, and she gave it to them
thinking the cost would be $15 to $25. It turned out
to be $200!
Therefore, this person is giving the recipe to anyone
and everyone she knows (and doesn't know) so that
someone can get use of her $200. Anyway, just keep
passing it on.
Cream together: 2 cups butter
2 cups sugar
2 cups brown sugar
Add: 4 eggs
2 tsp. vanilla
Mis together in
separate bowl: 4 cups flour
5 cups oatmeal (put small
amounts of oatmeal in blender until it turns to
powder. Measure out 5 cups of oatmeal and only
"powderize" that, NOT 5 cups "powderized" oatmeal)
1 tsp salt
2 tsp baking powder
2 tsp baking soda
Mix: All of the above
Add: 24 oz. bag of chocolate chips and
1 finely grated 8 oz Hershey bar (plain)
Add: 3 cups chopped nuts (any kind)
Bake on greased cookie sheet (make golf ball sized balls) and
bake about two inches apart. Bake at 350 degrees for 8 - 10
minutes. DO NOT OVERBAKE. Makes 112.
From: ucdavis!lll-lcc!hplabs!parcvax!bane@ucbvax.berkeley.edu (John R. Bane)
Subject: Re: free cookie foundation?
Hi! I "stole" your very expensive cookie recipe off the net. If you
want to send me your SnailMail address, I'll be glad to send you a
dollar (I would like to suggest this to the net, but I think there is
some netiquette rule against asking for money - or is that only money
for oneself?) to help defray the cost (it's not much, but if EVERYone
who took the recipe sent you a dollar, it would help).
Here also is another cookie recipe which I'm very fond of.
Makes 6-8 dozen
Bake at 375 degrees for ~10 min.
Cream together:
1 cup shortening (I use Weight Watcher's Reduced Calorie Margarine!)
1/4 cup peanut butter (I recommend the non-sugared kind)
1/2 cup sugar
1/2 cup brown sugar
2 eggs
1 teaspoon vanilla
Add:
1/2 cup flour
1 teaspoon soda
1/2 teaspoon salt
2 cups rolled oats (I use the 5-min variety)
1-2 cups chocolate chips (I use 2 cups semi-sweet - ummmm!)
1 cup nuts (I use pecan pieces - don't get them crushed, or the extra
oil will make greasy cookies)
1 cup shredded or flaked coconut
(The nuts were listed as optional and I added the coconut myself, but
I really love them there! You could also add things like m&m's, or
raisons (I don't care for raisons in cookies, but you might). I've
always wanted to try banana chips.)
Mix well. Drop by teaspoonfuls on greased cookie sheet (I use pam).
Bake at 375 degrees for approx. 10 min.
My aunt found this recipe in an Amish book called something like
"Eating Well When The Whole World Is Starving," and although I thought
a cookie recipe was a bit odd for a book like that, they are about the
healthiest a cookie is ever likely to get.
They are also very easy to make (no blending, sifting, rolling, etc.)
and extrememly delicious. I get rave reviews and recipe requests whenever
I make them.
- rene
Chocolate Chip Cookies - Glamorous, crunchy, rich with chocolate bits & nuts.
Also known as "Toll House" Cookies ... from Kenneth and Ruth Wakefield's
charming New England Toll House on the outskirts of Whitman, Massachusetts.
These cookies were first introduced to American homemakers in 1939 through
our series of radio talks on "Famous Foods From Famous Eating Places."
Mix Thoroughly :
2/3 cup soft shortening ( part butter )
1/2 cup granulated sugar
1/2 cup brown sugar ( packed )
1 egg
1 tsp vanilla
Sift together and stir in :
1-1/2 cups sifted flour (*)
1/2 tsp soda
1/2 tsp salt
Stir in :
1/2 cup cut-up nuts
6 oz package of semi-sweet chocolate pieces ( about 1-1/4 cups )
(*) for a softer, more rounded cookie, use 1-3/4 cups sifted flour.
Drop rounded teaspoonfuls about 2" apart on ungreased baking sheet. Bake until
delicately browned ... cookies should still be soft. Cool slightly before you
remove them from the baking sheet.
Temperature: 375 F. ( modern oven )
Time: bake 8 - 10 minutes
Amount: 4 - 5 dozen 2" cookies
=====
Personal comments :
I find it tastes better with a mixture of shortening and butter, as they say.
You don't need << all >> of that sugar, and it can be whatever color you want.
The nuts are optional. Feel free to play with the recipe. I put oatmeal in it,
reducing flour accordingly, and sometimes cinnamon.
I also find it useful to grease the cookie sheets.
I think I'm going to go bake some now ...
-- richard

249
etc/COPYING Normal file
View file

@ -0,0 +1,249 @@
GNU GENERAL PUBLIC LICENSE
Version 1, February 1989
Copyright (C) 1989 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The license agreements of most software companies try to keep users
at the mercy of those companies. By contrast, our General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. The
General Public License applies to the Free Software Foundation's
software and to any other program whose authors commit to using it.
You can use it for your programs, too.
When we speak of free software, we are referring to freedom, not
price. Specifically, the General Public License is designed to make
sure that you have the freedom to give away or sell copies of free
software, that you receive source code or can get it if you want it,
that you can change the software or use pieces of it in new free
programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of a such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must tell them their rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any program or other work which
contains a notice placed by the copyright holder saying it may be
distributed under the terms of this General Public License. The
"Program", below, refers to any such program or work, and a "work based
on the Program" means either the Program or any work containing the
Program or a portion of it, either verbatim or with modifications. Each
licensee is addressed as "you".
1. You may copy and distribute verbatim copies of the Program's source
code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and
disclaimer of warranty; keep intact all the notices that refer to this
General Public License and to the absence of any warranty; and give any
other recipients of the Program a copy of this General Public License
along with the Program. You may charge a fee for the physical act of
transferring a copy.
2. You may modify your copy or copies of the Program or any portion of
it, and copy and distribute such modifications under the terms of Paragraph
1 above, provided that you also do the following:
a) cause the modified files to carry prominent notices stating that
you changed the files and the date of any change; and
b) cause the whole of any work that you distribute or publish, that
in whole or in part contains the Program or any part thereof, either
with or without modifications, to be licensed at no charge to all
third parties under the terms of this General Public License (except
that you may choose to grant warranty protection to some or all
third parties, at your option).
c) If the modified program normally reads commands interactively when
run, you must cause it, when started running for such interactive use
in the simplest and most usual way, to print or display an
announcement including an appropriate copyright notice and a notice
that there is no warranty (or else, saying that you provide a
warranty) and that users may redistribute the program under these
conditions, and telling the user how to view a copy of this General
Public License.
d) You may charge a fee for the physical act of transferring a
copy, and you may at your option offer warranty protection in
exchange for a fee.
Mere aggregation of another independent work with the Program (or its
derivative) on a volume of a storage or distribution medium does not bring
the other work under the scope of these terms.
3. You may copy and distribute the Program (or a portion or derivative of
it, under Paragraph 2) in object code or executable form under the terms of
Paragraphs 1 and 2 above provided that you also do one of the following:
a) accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Paragraphs 1 and 2 above; or,
b) accompany it with a written offer, valid for at least three
years, to give any third party free (except for a nominal charge
for the cost of distribution) a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of
Paragraphs 1 and 2 above; or,
c) accompany it with the information you received as to where the
corresponding source code may be obtained. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form alone.)
Source code for a work means the preferred form of the work for making
modifications to it. For an executable file, complete source code means
all the source code for all modules it contains; but, as a special
exception, it need not include source code for modules which are standard
libraries that accompany the operating system on which the executable
file runs, or for standard header files or definitions files that
accompany that operating system.
4. You may not copy, modify, sublicense, distribute or transfer the
Program except as expressly provided under this General Public License.
Any attempt otherwise to copy, modify, sublicense, distribute or transfer
the Program is void, and will automatically terminate your rights to use
the Program under this License. However, parties who have received
copies, or rights to use copies, from you under this General Public
License will not have their licenses terminated so long as such parties
remain in full compliance.
5. By copying, distributing or modifying the Program (or any work based
on the Program) you indicate your acceptance of this license to do so,
and all its terms and conditions.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these
terms and conditions. You may not impose any further restrictions on the
recipients' exercise of the rights granted herein.
7. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of the license which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
the license, you may choose any version ever published by the Free Software
Foundation.
8. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to humanity, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.
To do so, attach the following notices to the program. It is safest to
attach them to the start of each source file to most effectively convey
the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19xx name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License. Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items--whatever suits your
program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
program `Gnomovision' (a program to direct compilers to make passes
at assemblers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
That's all there is to it!

294
etc/ChangeLog Normal file
View file

@ -0,0 +1,294 @@
Wed Oct 21 18:21:39 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* Makefile: Emacstool and other Sun-only targets replaced.
* emacstool.c: New file.
Sat Aug 22 03:09:48 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* emacsclient.c (main): Set IPC_CREAT in msgget call.
Thu Aug 20 01:09:32 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* etags.c (TEX_funcs): Keep just 1 of two redundant nested loops.
(TEX_decode_env): Make `tab' one element longer.
Sat May 9 16:24:08 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* etags.c (getit): Allow _ and $ in fortran symbol.
Thu May 7 16:11:26 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* movemail.c [POP]: Get user name via getpwuid.
Sat Mar 28 15:59:12 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* movemail.c: Allocate tempname dynamically.
Sun Mar 22 23:21:21 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* server.c: Include sys/types.h before signal.h.
Thu Mar 12 16:45:36 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* termcap.dat: Added vt101*, vt102*, vt131* and vt300.
Sat Jan 25 16:20:41 1992 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* env.c: Include errno.h.
Sun Jan 19 11:29:00 1992 (Eric Youngdale at youngdale@v6550c.nrl.navy.mil)
* etags-vmslib.c (fn_exp): Add type cast.
Tue Dec 31 16:16:05 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* server.c: Include sys/signal.h before config.h.
Sat Dec 7 17:04:17 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* movemail.c: Copied from Emacs 19.
(pfatal_and_delete): New function.
(main, popmail): Use it.
(popmail): Close output before deleting messages.
Check for error on close and on fsync.
Use `fatal' where appropriate.
(main): Remove (void).
(MAIL_USE_MMDF): New compilation flag
(main): Report failure of flock.
Fri Oct 25 14:43:33 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* server.c (msgcatch): Declare return type void.
* make-docfile.c: Fix comment on #endif.
Tue Sep 17 18:15:42 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* etags.c (main): Don't make actions depend on programmer name.
Sat Sep 14 01:42:39 1991 Richard Stallman (rms@mole.gnu.ai.mit.edu)
* etags.c (C_entries): Clear tydef and next_token_is_func at start.
(consider_token): Move next_token_is_func to global.
Mon Sep 2 16:22:04 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* server.c, emacsclient.c [not SERVER_HOME_DIR]:
Include host name in the name of the socket.
Tue Jul 30 17:03:41 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* wakeup.c: Terminate if parent goes away.
Fri Mar 29 19:00:10 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)
* server.c [USG]: Terminate if msgrcv fails.
Sun Mar 3 22:05:52 1991 Richard Stallman (rms at mole.ai.mit.edu)
* server.c [BSD]: Check for errors on stdin after scanf.
Tue Feb 26 15:55:07 1991 Richard Stallman (rms at mole.ai.mit.edu)
* etags.c (TEX_mode): Skip comment line at beg of file.
Mon Dec 31 17:52:55 1990 Richard Stallman (rms at mole.ai.mit.edu)
* refcard.tex: Change am fonts to cm.
Thu Nov 29 17:34:14 1990 Richard Stallman (rms at mole.ai.mit.edu)
* movemail.c (mbx_delimit_begin): Put space before `unseen'.
Sun Nov 18 17:09:07 1990 Richard Stallman (rms at mole.ai.mit.edu)
* server.c, emacsclient.c [BSD]: Put socket in /tmp.
Tue Nov 13 00:01:54 1990 Richard Stallman (rms at mole.ai.mit.edu)
* movemail.c (error): Handle 3 args.
(main): Don't check input access if using pop.
Tue Oct 30 12:38:39 1990 David J. MacKenzie (djm at apple-gunkies)
* emacs.1: Give the mouse bindings for X11 instead of X10.
Tue Oct 16 14:04:05 1990 Richard Stallman (rms at mole.ai.mit.edu)
* etags.c (find_entries): Check for numbers after Scheme suffix.
Sun Oct 14 18:46:21 1990 Richard Stallman (rms at mole.ai.mit.edu)
* termcap.dat (vt200-80): Fix ke and ks to frob flag 1.
Tue Oct 9 15:22:16 1990 Richard Stallman (rms at mole.ai.mit.edu)
* Makefile (nemacstool, xvetool): New targets.
Wed Sep 26 18:42:18 1990 Richard Stallman (rms at mole.ai.mit.edu)
* emacsclient.c (errno): Declare it explicitly.
Tue Aug 14 21:34:50 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* emacsclient.c [USG]: Pass msgsnd only 4 args.
Tue Aug 7 13:17:58 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* Makefile (clean): New target.
Sun Jul 8 18:18:00 1990 Richard Stallman (rms at geech)
* emacsclient.c [BSD]: Include errno.h.
Declare sys_nerr and sys_errlist.
Wed Jul 4 15:40:33 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* wakeup.c: New file.
* Makefile (wakeup): New rule.
Wed May 30 15:40:59 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* emacsclient.c: Print program name in error messages.
Handle failure of getwd.
Handle +LINE arguments in SYSVIPC case.
These are most of the changes already in the version 19 file.
Mon May 28 21:54:59 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* loadst.c (main): Conditional to get load average on Apollo.
Sun Dec 24 23:54:28 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* etags.c (readline): Separate out init of `pend'.
Thu Jun 15 12:53:43 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c [USG]: Define F_OK, etc., if not in header.
Fri May 12 22:08:09 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* etags.c (readline): Split call to xrealloc for 3b1 cc bug.
Tue Apr 18 21:31:25 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* loadst.c: on bsd4.3, use gettimeofday instead of CPUSTATES.
Thu Mar 16 13:43:07 1989 Randall Smith (randy at sugar-bombs.ai.mit.edu)
* MACHINES: m-sequent.h works for symmetry also.
Mon Mar 13 17:03:06 1989 Randall Smith (randy at sugar-bombs.ai.mit.edu)
* MACHINES: Added note mentioning m-news3.0.h.
Tue Feb 21 12:58:55 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c: On sysv, include unistd.h.
Tue Jan 3 13:29:46 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c: Check access before doing real work.
Check that outfile is in a writable directory.
On fatal error, delete the lock file.
Fri Dec 30 16:37:27 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c: Use `access' to check input and output files.
Wed Dec 28 23:16:28 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* emacsclient.c [USG]: Don't append cwd if abs pathname is spec'd.
Wed Nov 30 15:21:13 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c: Do fsync before closing output.
Tue Nov 29 09:59:54 1988 Richard Mlynarik (mly at pickled-brain.ai.mit.edu)
* movemail.c: Better error message when can't create tempname.
This file needs a great deal of extra error-checking and lucid reporting...
Tue Nov 15 10:00:21 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* movemail.c: Close output and check errors before deleting input.
Thu Aug 4 19:42:45 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* emacsclient.c: Args like +DIGITS are passed through unchanged.
Tue Jul 12 22:08:00 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* server.c: If both BSD and HAVE_SYSVIPC, use the latter.
* emacsclient.c: Likewise.
In the HAVE_SYSVIPC alternative, if BSD, use getwd instead of getcwd.
Thu Jun 23 08:40:53 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* etags.c: Handle `typedef struct foo {' (price@mcc.com).
(istoken) New string-comparison macro.
(consider_token): New arg `level'. New state `tag_ok' in `tydef'.
Tue Jun 14 04:25:58 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* etags.c: Changes for VMS.
Always define ETAGS on VMS.
Define macros GOOD and BAD for success and failure exit codes.
(begtk, intk): Allow `$' in identifiers
(main): Don't support -B, -F or -u on VMS.
Alternate loop for scanning filename arguments.
(system): Delete definition of this function.
* etags-vmslib.c (system): Undefine this; VMS now provides it.
Wed Jun 8 08:18:21 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)
* loadst.c: Prevent multiple-def errors on BSD and BSD4_3
around include of param.h. (Like fns.c.)
Mon May 16 01:06:26 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)
* loadst.c (load_average): Move load-average code to this new fn.
Add conditionals to compute load ave on UMAX.
Sat May 14 01:24:53 1988 Richard Stallman (rms at lucky-charms.ai.mit.edu)
* loadst.c: Change DK_HEADER_FILE to DKSTAT_HEADER_FILE
with opposite sense.
Fri May 13 18:09:39 1988 Chris Hanson (cph at kleph)
* emacsclient.c: Delete references to unused variable `out'. This
caused a bus error when used under hp-ux.
Fri May 6 10:42:31 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)
* loadst.c: Control dk.h conditional with DK_HEADER_FILE.
Wed May 4 16:08:43 1988 Richard Stallman (rms at rice-krispies.ai.mit.edu)
* etags.c (find_entries): `.t' or `.sch' means scheme code.
Fri Apr 29 00:22:26 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)
* loadst.c: Add BSD4_3 conditional for file dk.h instead of dkstat.h.
Thu Apr 28 08:55:46 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)
* movemail.c: #undef close, since config can #define it on V.3.
* emacsclient.c, fakemail.c, loadst.c, server.c: likewise.
Tue Apr 26 07:33:01 1988 Richard Stallman (rms at lucky-charms.ai.mit.edu)
* etags.c (TEX_mode, etc.): Remove superfluous backslashes from
invalid escape sequences such as `\{'.
* loadst.c: Add `sequent' conditional for file dk.h.
Sun Mar 20 13:17:13 1988 Richard M. Stallman (rms at wilson)
* server.c [not BSD and not HAVE_SYSVIPC]: fix error message.
* loadst.c (main) [XENIX]: use /usr/spool/mail, not /usr/mail.

113
etc/DEBUG Normal file
View file

@ -0,0 +1,113 @@
Debugging GNU Emacs
Copyright (c) 1985 Richard M. Stallman.
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last changed them.
On 4.2 you will probably find that dbx does not work for
debugging GNU Emacs. For one thing, dbx does not keep the
inferior process's terminal modes separate from its own.
For another, dbx does not put the inferior in a separate
process group, which makes trouble when an inferior uses
interrupt input, which GNU Emacs must do on 4.2.
dbx has also been observed to have other problems,
such as getting incorrect values for register variables
in stack frames other than the innermost one.
The Emacs distribution now contains GDB, the new source-level
debugger for the GNU system. GDB works for debugging Emacs.
GDB currently runs on vaxes under 4.2 and on Sun 2 and Sun 3
systems.
** Some useful techniques
`Fsignal' is a very useful place to stop in.
All Lisp errors go through there.
It is useful, when debugging, to have a guaranteed way
to return to the debugger at any time. If you are using
interrupt-drived input, which is the default, then Emacs is using
RAW mode and the only way you can do it is to store
the code for some character into the variable stop_character:
set stop_character = 29
makes Control-] (decimal code 29) the stop character.
Typing Control-] will cause immediate stop. You cannot
use the set command until the inferior process has been started.
Put a breakpoint early in `main', or suspend the Emacs,
to get an opportunity to do the set command.
If you are using cbreak input (see the Lisp function set-input-mode),
then typing Control-g will cause a SIGINT, which will return control
to the debugger immediately unless you have done
ignore 3 (in dbx)
or handle 3 nostop noprint (in gdb)
You will note that most of GNU Emacs is written to avoid
declaring a local variable in an inner block, even in
cases where using one would be the cleanest thing to do.
This is because dbx cannot access any of the variables
in a function which has even one variable defined in an
inner block. A few functions in GNU Emacs do have variables
in inner blocks, only because I wrote them before realizing
that dbx had this problem and never rewrote them to avoid it.
I believe that GDB does not have such a problem.
** If GDB does not run and your debuggers can't load Emacs.
On some systems, no debugger can load Emacs with a symbol table,
perhaps because they all have fixed limits on the number of symbols
and Emacs exceeds the limits. Here is a method that can be used
in such an extremity. Do
nm -n temacs > nmout
strip temacs
adb temacs
0xd:i
0xe:i
14:i
17:i
:r -l loadup (or whatever)
It is necessary to refer to the file `nmout' to convert
numeric addresses into symbols and vice versa.
It is useful to be running under a window system.
Then, if Emacs becomes hopelessly wedged, you can create
another window to do kill -9 in. kill -ILL is often
useful too, since that may make Emacs dump core or return
to adb.
** Debugging incorrect screen updating.
To debug Emacs problems that update the screen wrong, it is useful
to have a record of what input you typed and what Emacs sent to the
screen. To make these records, do
(open-dribble-file "~/.dribble")
(open-termscript "~/.termscript")
The dribble file contains all characters read by Emacs from the
terminal, and the termscript file contains all characters it sent to
the terminal. The use of the directory `~/' prevents interference
with any other user.
If you have unreproduceable display problems, put those two expressions
in your ~/.emacs file. When the problem happens, exit the Emacs that
you were running, kill it, and rename the two files. Then you can start
another Emacs without clobbering those files, and use it to examine them.

779
etc/DIFF Normal file
View file

@ -0,0 +1,779 @@
How is this Emacs different from all other Emacses? -*-Outline-*-
(Actually, from Twenex Emacs)
* Copyright (c) 1985 Richard M. Stallman
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last changed them.
* Fundamental concepts.
** There is no concept of "typeout" in GNU Emacs.
Any time that a command wants to display some output,
it creates a buffer (usually with a name surrounded by asterisks)
and displays it in a window.
This provides some advantages:
you can edit some more while looking at the output;
you can copy parts of the output into other buffers.
It also has a disadvantage that you must type a command
in order to make the output disappear.
You can use C-x 1 to get rid of all windows except the
selected one. To be more selective, you can switch to
the window you want to get rid of and then type C-x 0
(delete-window).
You also need to type a command to scroll the other
window if not all the output fits in it. Meta-Control-v
will usually do the job.
** There is no concept of a "subsystem" in GNU Emacs.
Where Twenex Emacs would use a subsystem, GNU Emacs
instead creates a buffer and redefines commands in it.
For example, when you send mail in GNU Emacs, you use
a buffer named *mail* which is in Mail Mode. You can
switch away from this buffer to any other buffer and
resume normal editing; then switch back and resume
composing mail. You do not have to "exit" from
composing mail in order to do ordinary editing.
This has many advantages, but it also has a disadvantage:
Subsystems in Emacs tend to have "exit" commands that return you
to whatever you were doing before entering the subsystem.
In GNU Emacs the idea of what to return to is not well defined,
so it is not clear what an "exit" command should do.
The only way to "exit" in general is to type C-x b, C-x C-f, or
some other suitable command to switch buffers. Some
subsystem-like major modes, such as Info and Mail mode, provide
commands to "exit" by switching to the previously selected
buffer.
** Files are always visited in their own buffers.
Beginning users of Twenex Emacs were told how to edit
using a single buffer and reading one file after another
into that buffer. Use of a new buffer for each file was
regarded as a more advanced mode.
In GNU Emacs, the idea of using a single buffer for various
files, one by one, has been dropped, given that the address
space is expected to be large enough for many buffers. C-x
C-f (find-file), which behaves nearly the same as in Twenex
Emacs, is in GNU Emacs the canonical way for all users to
visit files.
Various commands need to read files into Emacs in the course
of their execution. In Twenex Emacs the user must tell them
whether to reuse buffers or create new ones, using the variable
Tags Find File. In GNU Emacs, these commands always use
C-x C-f.
The command C-x C-v does still exist; it kills the current
buffer and reads the specified file into a new buffer.
It is equivalent to kill-buffer followed by find-file.
Since there is no reusing of buffers, there is no point in
calling the initial buffer "main". So the initial buffer
in GNU Emacs is called "*scratch*" and is intended for typing
Lisp expressions to be evaluated.
** File name defaulting.
GNU Emacs records a separate working directory for each buffer.
Normally this is the directory on which the buffer's file
resides; for buffers not visiting any file, it is copied from
the buffer that was current when it was created. The current buffer's
working directory can be printed with M-x pwd and set with M-x cd.
GNU Emacs shows you the default directory by inserting it in
the minibuffer when a file name is being read. You can type
the filename you want at the end of the default as if the
default were not there, or you can edit and alter the default.
If you want file /lose/big when the default /foo/defaultdir/
has been inserted for you, you need not kill the default; simply
type at the end of it: /foo/defaultdir//lose/big. Such a file
name is not ordinarily considered valid, but GNU Emacs
considers it equivalent to /lose/big.
Likewise, if you want file quux in your home directory, just add
~/quux to the end of the supplied text, to get
/foo/defaultdir/~/quux. GNU Emacs sees "/~" and throws away
everything before the "~".
You can refer to environment variables also within file names.
$ followed by the environment variable name is replaced by the
variable's value. The variable name should either be followed
by a nonalphanumeric character (which counts as part of the
file name) or be surrounded by braces {...} (which do not count
as part of the file name). Thus, if variable USER has value "rms",
"x/$USER-foo" is expanded to "x/rms-foo", and "x${USER}foo"
is expanded to "xrmsfoo". Note that this substitution is not
performed by the primitive file operation functions of GNU Emacs,
but rather by the interactive file name reader. It is also
available as a separate primitive, in the function
substitute-in-file-name.
** Exit commands C-z, C-x C-c and C-x C-z.
There are two ways to exit GNU Emacs: killing and suspending.
Killing is like what Control-c does to ordinary Unix programs.
In GNU Emacs, you type C-x C-c to kill it. (This offers to
save any modified file buffers before really killing Emacs.)
Suspending is like what Control-z does to ordinary Unix programs.
To suspend GNU Emacs, type C-x C-z, or type just C-z.
Note that C-z suspends ordinary programs instantly, but
Emacs does not suspend until it reads the C-z.
Usually it is better to suspend: once a system is smart
enough to have job control, why ever kill an editor?
You'll just have to make a new one in a minute.
This is why the convenient command C-z is provided for
suspending.
C-c is used as a prefix key for mode-specific commands and for users'
own commands. We deliberately do not make C-c ever kill Emacs,
because it should not be so easy to do something irreversible.
** Quitting with C-g.
If you type C-g while GNU Emacs is waiting for input, it
is an ordinary command (which is defined to beep). If you
type C-g while Lisp code is executing, it sets a flag which
causes a special signal, nearly the same as an error, to
happen atthe next safe place in Lisp execution. This usually
has the effect of aborting the current command in a safe way.
Because at times there have been bugs causing GNU Emacs to loop
without checking the quit flag, a special feature causes
GNU Emacs to be suspended immediately if you type a second C-g
while the flag is already set. So you can always get out
of GNU Emacs. Normally GNU Emacs recognizes and clears the quit flag
quickly enough to prevent this from happening.
When you resume GNU Emacs after a suspension caused by multiple C-g, it
asks two questions before resuming execution:
Checkpoint?
Dump core?
Answer each one with `y' or `n' and a Return.
`y' to Checkpoint? causes immediate auto-saving of all
buffers in which auto-saving is enabled.
`y' to Dump core? causes an illegal instruction to be executed.
This is to enable a wizard to figure out why GNU Emacs was
looping without checking for quits. Execution does not continue
after a core dump. If you answer `n', execution continues.
With luck, GNU Emacs will ultimately check the quit flag,
and quit normally. If not, and you type another C-g, it
is suspended again.
If GNU Emacs is not really hung, just slow, you may invoke
the double C-g feature without really meaning to. Then just
resume and answer `n' to both questions, and you will
arrive at your former state. Presumably the quit you
wanted will finish happening soon.
These questions are not asked if you suspend GNU Emacs with the C-z
command. Continuing GNU Emacs after a C-z takes you straight back
into editing.
** Undoing with C-x u or C-_
You can undo many commands--up to 10,000 characters worth.
Each time you type C-x u or C-_, another command or batch of change
is undone. Undo information is stored per buffer, and the undo
command always applies to the current buffer. A numeric argument
serves as a repeat count.
Consecutive self-inserting characters are undone in groups of twenty.
** Different character set.
GNU Emacs does not expect anyone ever to have a keyboard in which
the Control key sets an independent bit which may accompany any
character. The only control characters that can exist are the
ASCII control characters.
There is, as a result, no "control prefix" character.
** Control-h is the Help character.
I'm amazed it took me so long to get this idea. In Twenex Emacs, C-h
and C-b are equivalent commands, making C-h redundant. C-h is not
only easy to type, it is mnemonic for "Help". So in GNU Emacs the
Help character is C-h.
** Completion is done by TAB, not ESC.
ESC in the minibuffer is a Meta prefix, same as at top level.
** The string-argument reader is the minibuffer is an editor window.
In GNU Emacs, the line at the bottom of the screen is the minibuffer.
Commands that want string arguments always use this line to read them,
and you can use the ordinary Emacs editing commands to edit the
input. You can terminate input with Return because Return is defined
as the exit-minibuffer command when in the minibuffer. If you
are using a command that needs several arguments, terminate each
one with Return. You cannot separate arguments with Escape
the way you would in Twenex Emacs.
The minibuffer window does not overlay other editor windows;
it is a nearly ordinary editor window which lacks a mode line
and is "turned off" when not in use. While it IS in use, you
can switch windows to and from the minibuffer, kill text in other
windows and yank in the minibuffer, etc.
You can even issue a command that uses the minibuffer while in the
minibuffer. This gets you temporarily into a recursive minibuffer.
However, this is allowed only if you enable it, since it could be
confusing for beginners.
When you exit the minibuffer, the cursor immediately moves back to
column zero of the minibuffer line, to show you that the exit
command has been obeyed. The minibuffer contents remain on the screen
until the end of the command, unless some other text is displayed there.
A single Control-g exits the minibuffer.
** There are no &'s or ^R's or spaces in function names.
For example, the function which is called ^R Forward Word
in Twenex Emacs is called forward-word in GNU Emacs.
** The extension language is Lisp rather than TECO.
Libraries must be written in Lisp. Meta-ESC reads a Lisp
expression, evaluates it, and prints the result. Note that
Meta-ESC is "disabled" by default, so that beginning users
do not get into the minibuffer by accident in a confusing way.
Data types available include integers (which double as characters),
strings, symbols, lists, vectors, buffers, buffer pointers,
windows, and process channels.
For now, to learn about writing Lisp code for GNU Emacs, read some of
the source code, which is in directory ../lisp. Also, all Lisp
primitives have self-documentation you can read with C-h f.
** Enabling the error handler.
GNU Emacs has a Lisp debugger/stepper/trace package, but normally
errors do not enter the debugger because that is slow, and unlikely to
be of interest to most users. Set the variable debug-on-error to t to
cause errors to invoke the debugger. Set debug-on-quit to cause quit
signals (caused by C-g) to invoke the debugger.
* Other changes.
** More than two windows are allowed.
C-x 2 splits the current window into two windows,
one above the other. Initially they both display
the same buffer.
C-x 2 now accepts a numeric argument to specify the number of
lines to give to the uppermost of the two windows it makes.
C-x 0 kills the current window, making all others larger.
C-x 1 kills all windows except the current one.
C-x O switches to the next window down.
It rotates from the bottom one to the top one.
An argument serves as a repeat count; negative arguments
circulate in the reverse order.
If the same buffer is displayed in several windows,
changes made in it are redisplayed in all of them.
** Side by side windows are supported.
The command C-x 5 splits the current window into
two side-by-side windows.
C-x } makes the selected window ARG columns wider at the
expense of the windows at its sides. C-x { makes the selected
window ARG columns narrower. An argument to C-x 5 specifies
how many columns to give to the leftmost of the two windows made.
** Horizontal scrolling of the lines in a window is implemented.
C-x < (scroll-left) scrolls all displayed lines left,
with the numeric argument (default 1) saying how far to scroll.
When the window is scrolled left, some amount of the beginning
of each nonempty line is replaced by an "$".
C-x > scrolls right. If a window has no text hidden at the left
margin, it cannot be scrolled any farther right than that.
When nonzero leftwards scrolling is in effect in a window.
lines are automatically truncated at the window's right margin
regardless of the value of the variable truncate-lines in the
buffer being displayed.
** Return key does not use up empty lines.
In Twenex Emacs, the Return command advances over an existing
empty line in some cases. In GNU Emacs, the Return command always
makes inserts a newline. Twenex Emacs was designed at a time when
most display terminals did not have the ability to scroll part
of the screen, and using existing empty lines made redisplay faster.
Nowadays, terminals that cannot scroll part of the screen are rare,
so there is no need to make Return behave in a more complicated manner.
** Help m.
Typing C-h m displays documentation of the current major mode.,
telling you what special commands and features are available
and how to use them or get more information on them.
This is simply the documentation, as a function, of the
symbol which is the value of major-mode. Each major mode
function has been given documentation intended for C-h m.
** Display-hiding features.
*** Hiding indented lines
The command C-x $ with numeric argument N causes lines indented by N
or more columns to become invisible. All you see is " ..." appended
to the previous line, in place of any number of consecutive invisible
lines.
*** Outline Mode.
Outline mode is designed for editing outline-structured
files, such as this one.
Headings should be lines starting with one or more asterisks.
Major headings have one asterisk, subheadings two, etc.
Lines not starting with asterisks are body text.
You can make the body under a heading, or the subheadings
under a heading, temporarily invisible, or visible again.
Invisible lines are attached to the end of the previous line
so they go with it if you kill it and yank it back.
Commands:
Meta-} next-visible-heading move by visible headings
Meta-{ previous-visible-heading move by visible headings
Meta-x hide-body make all body text invisible (not headings).
Meta-x show-all make everything in buffer visible.
The remaining commands are used when dot is on a heading line.
They apply to some of the body or subheadings of that heading.
C-c C-h hide-subtree make text and subheadings invisible.
C-c C-s show-subtree make text and subheadings visible.
C-c C-i show-children make direct subheadings visible.
No effect on body, or subheadings 2 or more levels down.
With arg N, affects subheadings N levels down.
M-x hide-entry make immediately following body invisible.
M-x show-entry make it visible.
M-x hide-leaves make text under heading and under its subheadings invisible.
The subheadings remain visible.
M-x show-branches make all subheadings at all levels visible.
** C mode is fancy.
C mode assumes that you put the initial open-brace of
a function definition at the beginning of a line.
If you use the popular indenting style that puts this
open-brace at the end of a line containing a type declaration,
YOU WILL LOSE: C mode does not know a function starts there.
Open-brace at the beginning of a line makes it possible
for C mode to find function boundaries with total reliability;
something I consider vital and which cannot be done
if the other style is used.
The Tab command indents C code very cleverly.
I know of only one cases in which Tab does not indent C code nicely:
Expressions continued over several lines with few parentheses.
Tab does not know the precedences of C operators, so it does
not know which lines of the expression should go where.
Using parentheses to indicate the nesting of operators
except within a line makes this problem go away.
The indenting algorithm is entirely written in Lisp.
Tab with a numeric argument in Twenex Emacs indents
that many lines. It is different in GNU Emacs: it means
to shift all the lines of a bracketed expression by the
same amount as the line being indented. For example, if you have
if (foo)
{
hack ();
/** Well? */
}
and type C-u Tab on the line with the open brace, you get
if (foo)
{
hack ();
/* Well? */
}
from indenting the brace line and then shifting the
lines within the braces rigidly with the first one.
Meta-Control-q works as in Lisp mode; it should be
used with dot just before a bracketed grouping, and
indents each line INSIDE that grouping using Tab.
If used instead of C-u Tab in the previous example, it makes
if (foo)
{
hack ();
/* Well? */
}
Meta-Control-h puts mark at the end of the current C function
and puts dot before it.
Most other Meta-Control commands intended for Lisp expressions
work usefully in C mode as well.
** Meta-g (fill-region) is different.
In Twenex Emacs, Meta-g fills the region with no paragraph
boundaries except for blank and indented lines. In GNU Emacs,
it divides the region into paragraphs in the same manner as
Meta-], and fills each paragraph separately. There is also
the function fill-region-as-paragraph which fills the region
regarding at as a single paragraph regardless even of blank
or indented lines.
** Indented Text Mode instead of Edit Indented Text.
Twenex Emacs has a command Edit Indented Text which temporarily
alters some commands for editing indented paragraphs.
GNU Emacs has instead a separate major mode, Indented Text Mode,
which is different from ordinary Text Mode in just the same
alterations. Specifically, in Indented Text Mode,
Tab runs the function indent-relative, and auto filling indents
the newly created lines.
** But rectangle commands are implemented.
C-x r stores the rectangle described by dot and mark
into a register; it reads the register name from the keyboard.
C-x g, the command to insert the contents of a register,
can be used to reinsert the rectangle elsewhere.
Other rectangle commands include
open-rectangle:
insert a blank rectangle in the position and size
described by dot and mark, at its corners;
the existing text is pushed to the right.
clear-rectangle:
replace the rectangle described by dot ane mark
with blanks. The previous text is deleted.
delete-rectangle:
delete the text of the specified rectangle,
moving the text beyond it on each line leftward.
kill-rectangle
like delete-rectangle but also stores the text of
the rectangle in the "rectangle kill buffer".
More precisely, it stores the text as a list of strings
(one string for each line) in the variable killed-rectangle.
yank-rectangle
inserts the text of the last killed rectangle.
extract-rectangle and delete-extract-rectangle
these functions return the text of a rectangle
as a list of strings. They are for use in writing
other functions that operate on rectangles.
** Keyboard Macros
The C-x ( command for defining a keyboard macro can in GNU Emacs
be given a numeric argument, which means that the new macro
starts out not empty but rather as the same as the last
keyboard macro entered. In addition, that last keyboard
macro is replayed when the C-x ( is typed. C-x ( with an
argument is thus equivalent to typing plain C-x ( and then
retyping the last keyboard macro entered.
The command write-kbd-macro and append-kbd-macro can be used to
save a keyboard macro definition in a file. It is represented as
a Lisp expression which, when evaluated, will define the keyboard
macro. write-kbd-macro writes the specified file from scratch,
whereas append-kbd-macro adds to any existing text in the file.
Both expect the keyboard macro to be saved to be specified by
name; this means you must use the command name-last-kbd-macro to
give the macro a name before you can save it.
** The command to resume a terminated tags-search or tags-query-replace
is Meta-comma in GNU Emacs.
** Auto Save is on by default.
Auto Save mode is enabled by default in all buffers
that are visiting files.
The file name used for auto saving is made by prepending
"#" to the file name visited.
** Backup files.
Since Unix stupidly fails to have file version numbers,
GNU Emacs compensates slightly in the customary fashion:
when a file is modified and saved for the first time in
a particular GNU Emacs run, the original file is renamed,
appending "~" to its name. Thus, foo.c becomes foo.c~.
Emacs can also put a version number into the name of the backup file,
as in foo.c.~69~ for version number 69. This is an optional feature
that the user has to enable.
** Mode Line differences.
Each window in GNU Emacs has its own mode line, which always
displays the status of that window's buffer and nothing else.
The mode line appears at the bottom of the window. It is
full of dashes, to emphasize the boundaries between windows,
and is displayed in inverse video if the terminal supports it.
The information usually available includes:
** Local Modes feature changed slightly.
GNU Emacs supports local mode lists much like those in Twenex Emacs,
but you can only set variables, not commands. You write
Local variables:
tab-width: 10
end:
in the last page of a file, if you want to make tab-width be ten in a
file's buffer. The value you specify must be a Lisp object!
It will be read, but not evaluated. So, to specify a string,
you MUST use doublequotes. For "false", in variables whose
meanings are true or false, you MUST write nil .
Two variable names are special: "mode" and "eval".
Mode is used for specifying the major mode (as in Twenex Emacs).
mode: text
specifies text mode. Eval is used for requesting the evaluation
of a Lisp expression; its value is ignored. Thus,
eval: (set-syntax-table lisp-mode-syntax-table)
causes Lisp Mode syntax to be used.
Note that GNU Emacs looks for the string "Local variables:"
whereas Twenex Emacs looks for "Local modes:". This incompatibility
id deliberate, so that neither one will see local settings
intended for the other.
** Lisp code libraries.
Libraries of commands, and init files, are written in Lisp.
libraries conventionally have names ending in .el, while the
init file is named .emacs and is in your home directory.
Use Meta-x load-library to load a library. Most standard libraries
load automatically if you try to use the commands in them.
Meta-x byte-compile-file filename
compiles the file into byte code which loads and runs faster
than Lisp source code. The file of byte code is given a name
made by appending "c" to the end of the input file name.
Meta-x byte-recompile-directory directoryname
compiles all files in the specified directory (globbing not allowed)
which have been compiled before but have been changed since then.
Meta-x load-library automatically checks for a compiled file
before loading the source file.
Libraries once loaded do not retain their identity within GNU
Emacs. Therefore, you cannot tell just what was loaded from a
library, and you cannot un-load a library. Normally, libraries
are written so that loading one has no effect on the editing
operations that you would have used if you had not loaded the
library.
** Dired features.
You can do dired on partial directories --- any pattern
the shell can glob. Dired creates a buffer named after
the directory or pattern, so you can dired several different
directories. If you repeat dired on the same directory or
pattern, it just reselects the same buffer. Use Meta-x Revert
on that buffer to read in the current contents of the directory.
** Directory listing features.
C-x C-d now uses the default output format of `ls',
which gives just file names in multiple columns.
C-u C-x C-d passes the -l switch to `ls'.
Both read a directory spec from the minibuffer. It can
be any pattern that the shell can glob.
** Compiling other programs.
Meta-x compile allows you to run make, or any other compilation
command, underneath GNU Emacs. Error messages go into a buffer whose
name is *compilation*. If you get error messages, you can use the
command C-x ` (that is a backquote) to find the text of the next
error message.
You must specify the command to be run as an argument to M-x compile.
A default is placed in the minibuffer; you can kill it and start
fresh, edit it, or just type Return if it is what you want.
The default is the last compilation command you used; initially,
it is "make -k".
** Searching multiple files.
Meta-x grep searches many files for a regexp by invoking grep
and reading the output of grep into a buffer. You can then
move to the text lines that grep found, using the C-x ` command
just as after M-x compile.
** Running inferior shells.
Do Meta-x shell to make an inferior shell together with a buffer
which serves to hold "terminal" input and output of the shell.
The shell used is specified by the environment variable ESHELL,
or by SHELL if ESHELL is not set.
Use C-h m whilst in the *shell* buffer to get more detailed info.
The inferior shell loads the file .emacs_csh or.emacs_sh
(or similar using whatever name the shell has) when it starts up.
M-! executes a shell command in an inferior shell
and displays the output from it. With a prefix argument,
it inserts the output in the current buffer after dot
and sets the mark after the output. The shell command
gets /dev/null as its standard input.
M-| is like M-! but passes the contents of the region
as input to the shell command. A prefix argument makes
the output from the command replace the contents of the region.
** Sending mail.
Once you enter Mail Mode using C-x m or C-x 4 m or M-x mail,
C-c becomes a prefix character for mail-related editing commands.
C-c C-s is vital; that's how you send the message. C-c C-c sends
and then switches buffers or kills the current window.
Use C-h m to get a list of the others.
** Regular expressions.
GNU Emacs has regular expression facilities like those of most
Unix editors, but more powerful:
*** -- + --
+ specifies repetition of the preceding expression 1 or more
times. It is in other respect like *, which specifies repetition
0 or more times.
*** -- ? --
? is like * but matches at most one repetition of the preceding
expression.
*** -- \| --
\| specifies an alternative. Two regular expressions A and B with \| in
between form an expression that matches anything that either A or B will
match. Thus, "foo\|bar" matches either "foo" or "bar" but no other
string.
\| applies to the larges possible surrounding expressions. Only a
surrounding \( ... \) grouping can limit the grouping power of \|.
Full backtracking capability exists when multiple \|'s are used.
*** -- \( ... \) --
\( ... \) are a grouping construct that serves three purposes:
1. To enclose a set of \| alternatives for other operations.
Thus, "\(foo\|bar\)x" matches either "foox" or "barx".
2. To enclose a complicated expression for * to operate on.
Thus, "ba\(na\)*" matches "bananana", etc., with any number
of na's (zero or more).
3. To mark a matched substring for future reference.
Application 3 is not a consequence of the idea of a parenthetical
grouping; it is a separate feature which happens to be assigned as a
second meaning to the same \( ... \) construct because there is no
conflict in practice between the two meanings. Here is an explanation
of this feature.
-- \digit --
After the end of a \( ... \) construct, the matcher remembers the
beginning and end of the text matched by that construct. Then, later on
in the regular expression, you can use \ followed by a digit to mean,
``match the same text matched this time by the \( ... \) construct.''
The first nine \( ... \) constructs that appear in a regular expression
are assigned numbers 1 through 9 in order of their beginnings. \1
through \9 can be used to refer to the text matched by the corresponding
\( ... \) construct.
For example, "\(.*\)\1" matches any string that is composed of two
identical halves. The "\(.*\)" matches the first half, which can be
anything, but the \1 that follows must match the same exact text.
*** -- \` --
Matches the empty string, but only if it is at the beginning of the buffer.
*** -- \' --
Matches the empty string, but only if it is at the end of the buffer.
*** -- \b --
Matches the empty string, but only if it is at the beginning or end of
a word. Thus, "\bfoo\b" matches any occurrence of "foo" as a separate word.
"\bball\(s\|\)\b" matches "ball" or "balls" as a separate word.
*** -- \B --
Matches the empty string, provided it is NOT at the beginning or end of
a word.
*** -- \< --
Matches the empty string, provided it is at the beginning of a word.
*** -- \> --
Matches the empty string, provided it is at the end of a word.
*** -- \w --
Matches any word-constituent character. The editor syntax table determines
which characters these are.
*** -- \W --
Matches any character that is not a word-constituent.
*** -- \s<code> --
Matches any character whose syntax is <code>. <code> is a letter that
represents a syntax code: thus, "w" for word constituent, "-" for
whitespace, "(" for open-parenthesis, etc. Thus, "\s(" matches any
character with open-parenthesis syntax.
*** -- \S<code> --
Matches any character whose syntax is not <code>.

427
etc/DISTRIB Normal file
View file

@ -0,0 +1,427 @@
-*- text -*-
The prices on the order form below EXPIRE on 30 June 1992
GNU Emacs availability information, January 1992
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
Permission is granted to anyone to make or distribute
verbatim copies of this document provided that the
copyright notice and this permission notice are preserved.
GNU Emacs is legally owned by the Free Software Foundation, but we
regard the foundation actually as its custodian on behalf of the
public, since all software ought to be the common property of mankind.
The foundation permits everyone to have and run copies of GNU Emacs,
at no charge, and to redistribute copies under certain conditions
which are designed to make sure that that all modified versions of GNU
Emacs remain as free as the versions we distribute. These conditions
are stated in the document "GNU Emacs General Public License," a copy
of which is required to be distributed with every copy of GNU Emacs.
It is usually in a file named COPYING in the same directory as this
file.
If you do not know anyone to get a copy of GNU Emacs from, you can
order a tape from the Free Software Foundation. We distribute Emacs
version 18 on mag tape in different formats for many machines. We also
distribute nicely typeset copies of the Emacs user manual, Emacs Lisp
Reference Manual, the Emacs reference card, etc. See the order form at
the end of this file.
If you have Internet access, you can copy the latest Emacs
distribution from host prep.ai.mit.edu. There are several ways to do
this; see the file `FTP' in the same directory as this file for more
information. Even better, get the latest version of the file from
`/pub/gnu/GNUinfo/FTP' on prep.ai.mit.edu for the most current
arrangements. It may also be possible to copy Emacs via uucp; the
file `FTP' contains information on that too.
Emacs has been run on both Berkeley Unix and System V Unix, on a
variety of types of cpu. It also works on VMS and on Apollo
computers, though with some deficiencies that reflect problems in
these operating systems. See the file MACHINES in this directory for
a full list of machines that GNU Emacs has been tested on, with
machine-specific installation notes and warnings.
Note that there is significant variation between Unix systems
supposedly running the same version of Unix; it is possible that what
works in GNU Emacs for me does not work on your system due to such an
incompatibility. Since I must avoid reading Unix source code, I
cannot even guess what such problems may exist.
GNU Emacs is distributed with no warranty (see the General Public
License for full details, in the file COPYING in this directory), and
neither I nor the Free Software Foundation promises any kind of
support or assistance to users. The foundation keeps a list of people
who are willing to offer support and assistance for hire. It is
usually in a file named SERVICE in the same directory as this file.
You get the latest version of the file from `/pub/gnu/GNUinfo/SERVICE' on
prep.ai.mit.edu.
However, we plan to continue to improve GNU Emacs and keep it
reliable, so please send me any complaints and suggestions you have.
I will probably fix anything that I consider a malfunction. I may
make improvements that are suggested, but I may choose not to.
Improving Emacs is not my highest priority now.
If you are on the Internet, report bugs to
bug-gnu-emacs@prep.ai.mit.edu; on UUCP, use the address
...!uunet!prep.ai.mit.edu!bug-gnu-emacs. Otherwise, phone the
foundation at the number listed below, or write to the address listed
below. General questions about the GNU Project can be asked of
gnu@prep.ai.mit.edu.
If you are a computer manufacturer, I encourage you to ship a copy of
GNU Emacs with every computer you deliver. The same copying
permission terms apply to computer manufacturers as to everyone else.
You should consider making a donation to help support the GNU project;
if you estimate what it would cost to distribute some commercial
product and divide it by five, that is a good amount.
If you like GNU Emacs, please express your satisfaction with a
donation: send me or the Foundation what you feel Emacs has been worth
to you. If you are glad that I developed GNU Emacs and distribute it
as freeware, rather than following the obstructive and antisocial
practices typical of software developers, reward me. If you would
like the Foundation to develop more free software, contribute.
Your donations will help to support the development of more useful
software to be distributed on the same basis as GNU Emacs. Eventually
we will have a complete imitation of the Unix operating system, called
GNU (Gnu's Not Unix), which will run Unix user programs. For more
information on GNU, see the file GNU in this directory.
Richard M Stallman
Chief GNUisance,
President of the Free Software Foundation
Free Software Foundation Order Form
This order form is effective 1 January 1992 - 30 June 1992
Prices and contents may change without notice.
Please allow six weeks for delivery (though it won't usually take that long).
All software and publications are distributed with permission to copy and to
redistribute.
Texinfo source for each manual is on the appropriate tape. The prices for
tapes do not include printed manuals.
All software and documentation from the Free Software Foundation is provided
on an "as is" basis, with no warranty of any kind.
Contents of Tapes:
GNU Emacs Tape
The tape includes source code for:
* GNU Emacs (the extensible, customizable, self-documenting, real-time display
editor)
* The GNU Emacs Manual, as Texinfo source
* The GNU Termcap Manual, as Texinfo source (the GNU termcap library is
included with GNU Emacs)
* The GNU Emacs Lisp Reference Manual, as Texinfo source
* Calc (the extensible, advanced desk calculator and mathematical tool that
runs as part of GNU Emacs)
* The Calc Manual, as Texinfo source
* MIT Scheme (a dialect of Lisp)
* T (Yale's implementation of Scheme)
* Texinfo (beta-test of an enhanced Texinfo. Texinfo is GNU's structured
documentation system, included with GNU Emacs. Texinfo is used to produce
both on-line and printed documents.)
* The Texinfo Manual, as Texinfo source
* texi2roff (for printing Texinfo source with [nt]roff)
* Data Compression Software (to uncompress source on the tape)
GNU Languages Tape
The tape includes source code for:
* GCC 1 (the GNU C Compiler, including COFF support)
* The GCC Manual, as Texinfo source (not yet on our order form)
* G++ (the C++ front end to GCC)
* The GNU G++ Users Guide, as Texinfo source (not yet published on paper)
* libg++ (the G++ class library)
* NIH Class Library (formerly known as OOPS)
* Gas (the GNU Assembler)
* GNU binary file utilities (ar, gprof, ld, nm, size, strip, & ranlib)
* dld (a dynamic linker)
* COFF support for GNU software tools
* Flex (Vern Paxson's fast rewrite of lex)
* Bison (a free, compatible replacement for yacc)
* The Bison Manual, as Texinfo source
* GDB 3.5 (The GNU source-level C debugger)
* The GDB Manual, as Texinfo source
* GNU make
* The GNU Make Manual, as Texinfo source
* GNU indent
* Gawk (the GNU implementation of the AWK programming language)
* The Gawk Manual, as Texinfo source
* GNU Smalltalk (the GNU implementation of this programming language system)
* Perl (a programming language interpreter)
* gperf (a perfect hash-table generator)
* ae (works with GCC to produce more complete profiling information)
* f2c (a FORTRAN to C translator)
* gdbm library (GNU implementation of the standard dbm & ndbm libraries)
* texi2roff (for printing Texinfo source with [nt]roff)
* Data Compression Software (to uncompress source on the tape)
GNU Experimental Tape
This tape will not be ready until March 1992. The tape's source code
will include:
* GCC 2 (the GNU C/C++/Objective-C Compiler with many new features)
* GDB 4 (The GNU source-level C debugger)
* BFD ((Binary File Descriptor Library)
* GNU C Library (POSIX.1 compliant, upward compatible with 4.3 BSD & System V)
* GNU Graphics (graph, plot, plot2ps, et al.)
GNU Utilities Tape
The tape includes source code for:
* Bash (GNU's Bourne Again SHell)
* Groff (GNU troff & pic, eqn, tbl, refer; -man, -ms, -mm macros; & drivers)
* GNU tar & cpio
* GNU diff, grep, egrep, fgrep
* patch
* RCS (Revision Control System)
* CVS (Concurrent Version System)
* GNU fileutils (chgrp, chmod, chown, cp, dd, df, du, install, ln, ls, mkdir,
mkfifo, mknod, mv, mvdir, rm, rmdir, & touch)
* GNU shellutils (basename, date, dirname, env, expr, groups, id, logname,
nice, nohup, pathchk, printenv, printf, sleep, stty, tee, test, tty, uname,
whoami, & yes)
* GNU textutils (cat, cmp, comm, csplit, cut, expand, fold, head, join, paste,
pr, sort, split, sum, tac, tail, unexpand, uniq, & wc)
* Ghostscript (a Postscript interpreter)
* Gnuplot (an interactive mathematical plotting program)
* GNU m4, sed, & find
* elvis (a clone of the vi/ex Unix editor)
* screen (a terminal multiplexor that allows you to handle several independent
``screens'' (ttys) on a single physical terminal)
* GNU time & tput
* ms (MandelSpawn, a parallel Mandelbrot program for the X window system)
* GNU Chess (a chess playing program with an interface to X)
* Nethack (a rogue-like game)
* GNU GO (the GNU implementation of the game of GO)
* the freed files from the 4.3BSD-Tahoe distribution
* GNU make
* The GNU Make Manual, as Texinfo source
* texi2roff (for printing Texinfo source with [nt]roff)
* Data Compression Software (to uncompress source on the tape)
X11R5 Required Tape
This tape has source code for the required MIT X Window System X11R5,
including core software and documentation, and contributed client software.
X11R5 Optional Tape
This tape has source code for the optional MIT X Window System X11R5,
including contributed software, libraries, games, Andrew and toolkits.
Quantity Price Item
For Unix systems, on 1600 bpi reel-to-reel 9-track 1/2" tape in Unix tar format
(tape contents described above):
________ $200 GNU Emacs Tape
________ $200 GNU Languages Tape
________ $200 GNU Experimental Tape (not ready until March 1992)
________ $200 GNU Utilities Tape
________ $200 X11R5 Required Tape
________ $200 X11R5 Optional Tape
For Suns and some other Unix Systems, on QIC-24 DC300XLP 1/4 inch
cartridge tape, Unix tar format (tape contents described above):
________ $210 GNU Emacs Tape
________ $210 GNU Languages Tape
________ $210 GNU Experimental Tape (not ready until March 1992)
________ $210 GNU Utilities Tape
________ $210 X11R5 Required Tape
________ $210 X11R5 Optional Tape
For HP Systems, on 16-track DC600HC 1/4 inch cartridge tape, Unix tar format
(tape contents described above):
________ $230 GNU Emacs Tape
________ $230 GNU Languages Tape
________ $230 GNU Experimental Tape (not ready until March 1992)
________ $230 GNU Utilities Tape
________ $230 X11R5 Required Tape
________ $230 X11R5 Optional Tape
For IBM RS/6000 Systems, on DC600A 1/4 inch cartridge tape Unix tar format
(tape contents described above) (the GNU Languages Tape is not yet available
for the RS/6000):
________ $215 GNU Emacs Tape, plus executable files of Emacs
________ $215 GNU Experimental Tape (not ready until March 1992)
________ $215 GNU Utilities Tape
________ $215 X11R5 Required Tape
________ $215 X11R5 Optional Tape
For VMS systems, on 1600 bpi reel-to-reel 9-track 1/2" tape in VMS BACKUP (aka
interchange format):
________ $195 GNU Emacs source code and binaries. None of the other
software on the GNU Emacs Tape, described above, is included.
________ $195 GNU C compiler source code and binaries. Includes Bison and
GAS. None of the other software on the GNU Languages Tape,
described above, is included.
The following manuals are all bound to lie open, flat on a table:
________ $20 GNU Emacs manual, unit price for 1 to 5 copies.
~280 pages with a reference card, phototypeset and
offset printed.
________ $13 GNU Emacs manuals, unit price for 6 or more.
________ $50 A single GNU Emacs Lisp Reference Manual, ~550 pages,
offset printed, spiral bound.
________ $200 A box of 5 GNU Emacs Lisp Reference Manuals.
________ $50 Calc Manual, ~590 pages. Calc is an extensible, advanced desk
calculator and mathematical tool that runs under GNU Emacs.
________ $15 GDB Manual, ~170 pages, with a reference card.
________ $15 Texinfo Manual, ~220 pages. Texinfo is GNU's structured
documentation system, included with GNU Emacs. Texinfo is
used to produce both on-line and printed documents. This
manual describes how to write Texinfo documents.
________ $10 Termcap Manual, ~60 pages. Documents the termcap library and
GNU's extensions to it. The GNU termcap library is included
with GNU Emacs.
________ $10 Bison Manual, ~100 pages.
________ $15 Gawk Manual, ~200 pages.
________ $15 Make Manual, ~120 pages.
The following reference cards:
________ $1 One GNU Emacs reference card, without the manual.
________ $5 Packet of ten GNU Emacs reference cards.
________ $1 One GDB reference card, without the manual.
________ $5 Packet of ten GDB reference cards.
________ Subtotal
--------
________ In Massachusetts: add 5% sales tax, or give tax exempt number.
We pay for shipping via UPS ground transportation in the contiguous 48 states
and Canada.
________ In Alaska, Hawaii, or Puerto Rico, for shipping:
- For Emacs Lisp Reference and Emacs Calc manuals, add $5 each,
or $20 per box. For all other items, add $5 base charge,
then $1 per item except reference cards.
If outside of U.S., Canada and Puerto Rico, for shipping costs:
- for tapes or unboxed manuals, please add $15 base
charge, and then add $15 more for each tape or unboxed
manual (not reference cards) in the order:
________ Shipping cost for tapes and unboxed manuals = $15 + $15 * n;
- for each box of Emacs Lisp Reference manuals,
________ please add $70.
________ Optional tax deductible donation.
________ Total paid
--------
Orders are filled upon receipt of check or money order. We do not have the
staff to handle the billing of unpaid orders. Please help keep our lives
simple by including your payment with your order.
Please make checks payable to: "Free Software Foundation".
Please mail orders to:
Free Software Foundation, Inc.
675 Massachusetts Avenue
Cambridge, MA 02139
USA
+1 617-876-3296
This Order Form is EFFECTIVE 1 January 1992 - 30 June 1992
Name:
----------------------------------------------------------------
Mail Stop/Dept. Name
-------------------------------------------------
Organization:
--------------------------------------------------------
Street Address:
------------------------------------------------------
----------------------------------------------------------------------
City / State / Province:
---------------------------------------------
Zip Code / Postal Code / Country:
------------------------------------
In case of a problem with your order, or for overseas customs agents,
please add your voice telephone number (not your FAX number):
----------------------------------------
For orders outside the US: Orders MUST be paid in US dollars. You are
responsible for paying all duties, tariffs, and taxes. If you refuse
to pay the charges, the shipper will return or abandon your order.
Please write the telephone number that you want custom agents to call
in the space provided above.
This Order Form is EFFECTIVE 1 January 1992 - 30 June 1992

6061
etc/FAQ
View file

File diff suppressed because it is too large Load diff

266
etc/FTP Normal file
View file

@ -0,0 +1,266 @@
-*- text -*-
How to get GNU Software by Internet FTP or by UUCP. Last updated 20 Jan 92.
* No Warranties
We distribute software in the hope that it will be useful, but
without any warranty. No author or distributor of this software
accepts responsibility to anyone for the consequences of using it or
for whether it serves any particular purpose or works at all, unless
he says so in writing.
* Updates
If you find this file in the Emacs distribution, there is a chance
it is out of date. If you plan to FTP files from prep.ai.mit.edu,
you might as well start by FTPing the current version of this file,
which is `/pub/gnu/GNUinfo/FTP'.
* FTPing GNU Software
** GNU Emacs and How To FTP It
If you are on the Internet (see also "** Alternative Internet FTP
Sources" below), you can at present copy the latest distribution
version of GNU Emacs from the file /pub/gnu/emacs-M.N.tar on host
prep.ai.mit.edu (or the file /pub/gnu/emacs-M.N.tar.Z which has been
run through compress after tar). M and N standard for version
numbers; look at a listing of the directory through ftp to see what
version is available. These files are about 11 and 4 megabytes long,
respectively. After you unpack the distribution, be sure to look at
the files README and INSTALL.
Because of difficulties in transferring large files, sometimes a split
version of the tar file is created. This is a directory named
/pub/gnu/emacs-M.N.tar-split or perhaps
/pub/gnu/emacs-M.N.tar.Z-split, containing files of 100000 characters
each. There is generally no trouble in ftping files of this size.
They can be combined with cat to make a tar file or compressed tar
file.
ALWAYS USE BINARY/IMAGE MODE TO TRANSFER THESE FILES!
Text mode does not work for tar files or compressed files.
Some ftp'ers have found it necessary for successful file transfer:
- to explicitly use prep.ai.mit.edu internet address:
18.71.0.38 (as of 11 April 89)
Files of differences from previous widely distributed GNU Emacs
versions to the present version are also available on prep.ai.mit.edu
under names of the form emacs.diff-OO.OO-NN.NN in directory /pub/gnu.
These are made with diff -rc2. Sometimes there are compressed
versions of these difference files as well; their names have .Z
appended.
The Emacs manual in source form is included in the distribution.
The dvi file produced by TeX is not included, but a copy may be
available for ftp under the name /pub/gnu/emacs.dvi.
The Emacs Lisp Reference Manual is in a separate file:
/pub/gnu/lispref.tar.Z.
** VMS versions of GNU Emacs and How To FTP It.
You can anonymously ftp a VMS version of GNU emacs from:
- ddvax.llnl.gov.
- VMSA.OAC.UCI.EDU or VMSD.OAC.UCI.EDU.
- RIGEL.EFD.LTH.SE [130.235.48.3].
- ctrsci.cc.utah.edu. The 00readme.txt file gives details.
- cc.utah.edu [128.110.8.24]. User anonymous, pass guest. It
has already been compiled and linked so it is ready to run. You will
need to ftp the reblock.for program to reblock the saveset so that the
backup utility can restore that saveset. Do a backup/list on the
ftp'd saveset and catch the header info that backup puts out. It
contains the correct block size to reblock the file to. Remember to
ftp it in binary mode.
** A VMS version of G++ and How To FTP It.
mango.rsmas.miami.edu has a VMS version of the G++ compiler. Contact
angel@flipper.miami.edu (angel li) for details.
** A VMS version of GCC and How To FTP It.
Jonathan Corbet has made the "bootstrap files" for the GNU C compiler
available for pseudo-anonymous FTP on rdss.ucar.edu. The full gcc
sources are also available, for anybody who wants to start from scratch.
Jonathan Corbet also requests that you please limit your access to
outside the hours of 8-6 (mountain time) on weekdays. RDSS is a
*very* busy machine during the day. Jonathan notes, "I don't think I
have to tell you what will happen if my users feel they are being
slowed down by outside people grabbing software."
The procedure is this: FTP to rdss.ucar.edu (128.117.80.1), and log in
with a username of FTP, password FTP. Cd into the [.gcc] directory,
and grab either or both of these files:
bootstrap.bck The bootstrap files -- not much more than the
.exe files. About 1.3 mb.
gcc.bck The full-blown gcc source code. About 5mb.
Both of these files are backup savesets, and should thus be grabbed
in binary mode.
SPAN people can grab the same files from rdss::du:[ftp.gcc]. If your
node database does not know about rdss, use 9452 instead.
Jonathan Corbet is with the
National Center for Atmospheric Research, Field Observing Facility
Internet: corbet@rdss.ucar.edu
SPAN: rdss::corbet (rdss = 9452)
Usenet: ...!ncar!rdss!corbet
** Other GNU Software and How To FTP It.
This software is available on prep.ai.mit.edu under directory
/pub/gnu. Files containing diff from previous versions are often
available. Compressed versions of the tar or diff files are often
available (indicated by a .Z suffix). Much of this software is in
beta test (probably still buggy), and is being made available for use
by hackers who like to test software. M.N indicates a version number.
diff files to convert between versions (like those used for GNU
Emacs), exist for some of these programs. Some programs have misc
suport files as well. Have a look on prep.ai.mit.edu to see which
ones.
GNU Assembler (gas) gas-M.N.tar.Z Released
GNU Bash bash-M.N.tar.Z BETA TEST
GNU Bison bison-M.N.tar.Z Released
GNU C Compiler (gcc) gcc.tar-M.N.Z Late BETA TEST
GNU C++ Compiler (g++) g++.tar-M.N.Z BETA TEST
GNU C++ Library libg++-M.N.tar.Z BETA TEST
GNU cpio cpio-M.N.tar.Z BETA TEST
GNU Emacs Lisp Reference Manual lispref.tar.Z Released
GNU AWK (gawk) gawk-M.N.tar.Z Released
GNU debugger (gdb) gdb-M.N.tar.Z Released
GNU Make make-M.N.tar.Z Released
GNU ld, ar, gprof, size, nm and strip
binutils.tar.Z Released
GNU cat chmod cmp cp cut dd dir du head install ln ls
mkdir mkfifo mv paste rm rmdir tac tail touch vdir
fileutils-M.N.tar.Z BETA TEST
GNU Diff diff-M.N.tar.Z Released
GNU e?grep grep-M.N.tar.Z Released
GNU fgrep fgrep-M.N.tar.Z BETA TEST
GNU find find-M.N.tar.Z BETA TEST
GNU finger finger-M.N.tar.Z BETA TEST
GNU Ghostscript ghostscript-M.N.tar.Z
& font ghostscript*tar.Z files BETA TEST
GNU gdbm gdbm-M.N.tar.Z BETA TEST
GNU Go gnugo-M.N.tar.Z BETA TEST
GNU groff groff-M.N.tar.Z BETA TEST
GNU indent indent-M.N.tar.Z BETA TEST
GNU malloc malloc.tar.Z BETA TEST
GNU tar (to unpacl .tar files) tar-M.N.tar.Z
and tar-M-N.shar BETA TEST
GNU m4 m4.tar.Z BETA TEST
GNU sed sed-M.N.tar.Z BETA TEST
GNU Smalltalk smalltalk-M.N.tar.Z BETA TEST
GNU Chess gnuchess-M.N.tar.Z Released
GNU Buttons & Designs button.M.N.ps Released
and these packages which are not FSF software but work with
them and are part of GNU:
Concurrent Version System cvs-M.N.tar.Z
compress (to undo .Z files) compress.shar and compress.tar
dirent dirent.tar.Z
(directory reader for sysV 3.2)
elvis (a vi clone) elvis.M.N.O.tar.Z
Flex (a faster lex) flex-M.N.tar.Z
gnuplot gnuplot-M.N.tar.Z
The jargon file jargon.text.Z
(definitions of terms used by hackers)
NIH C++ Class Library nihcl-M.N.tar.Z
Perl perl-M.N.tar.Z
Revision Control System rcs.tar.Z
Texi2roff texi2roff.shar.Z
** TeX and How to FTP It
We don't distribute TeX now, but it is free software.
You can get TeX sources via anonymous FTP from labrea.stanford.edu in
pub/tex. The directory pub/tex/unix3.0 probably contains what you
want, but see pub/tex/README to be sure. The most recent incarnation
of the LaTeX macros are in labrea:pub/tex/latex. If you'd like to
support TUG and/or don't have access to the Internet, then write to
elisabet@max.acs.washington.edu about getting their tape distribution.
** Scheme and How to FTP It
The latest distribution version of C Scheme is on the machine
zurich.ai.mit.edu. To obtain a "tarred" copy of this directory,
telnet to zurich.ai.mit.edu and log in as scheme (password: scheme).
A file called dist.tar will be created (if there isn't one already),
and you will be given a choice of the file transfer program to run (of
all the ones supported by zurich). It should be self-explanatory (ha,
ha! [try ? for help]).
Read the files INSTALL and README in the top level C Scheme directory.
** Alternative Internet FTP Sources
The administrators of louie.udel.edu maintains copies of GNU Emacs and
the compress program. The files are available via anonymous ftp under
directory ~ftp/gnu.
Emacs and other GNU programs may be available via anonymous ftp from
these US sites: gatekeeper.dec.com, labrea.stanford.edu,
wuarchive.wustl.edu, a.cs.uiuc.edu, itstd.sri.com, scam.berkeley.edu,
jaguar.utah.edu, archive.cis.ohio-state.edu, and ftp.uu.net. And
these foreign sites: mcsun.eu.net (Europe - Internet address
192.16.202.1), sunic.sunet.se (Sweden), hp4nl.nluug.nl (Netherlands -
192.16.202.2), funic.funet.fi (Finland - 128.214.6.100), freja.diku.dk
(Denmark - 129.142.96.1), ftp.cs.titech.ac.jp (Japan - nemacs, the
japanese port of GNU Emacs, is under ~ftp/JAPAN). Please do NOT use a
site outside your country, until you have checked all sites inside
your country, and then your continent. Trans-ocean TCP/IP links are
very expensive and usually very low speed.
* Getting GNU software in Great Britain
jpo@cs.nott.ac.uk is willing to distribute those GNU sources he has
available. The smaller items are available from the info-server (send
to info-server@cs.nott.ac.uk) the larger items by negotiation. Due to
communication costs this service is only available within the UK.
BattenIG@computer-science.birmingham.ac.uk (aka
I.G.Batten@fulcrum.bt.co.uk) is also willing to distribute those GNU
sources he has available. He can also write tapes in qic-21 and
qic-24 formats.
lmjm@doc.ic.ac.uk is willing to distribute those GNU sources he has
available along with comp.sources.unix, comp.sources.x, X windows et
al. The archive, on src.doc.ic.ac.uk in directory /gnu, is available
via ftp (on 146.169.3.7), niftp over janet (000005102000), ftam and
uucp. All items are available using uucp, NIFTP over JANET to
src.doc.ic.ac.uk:/gnu. Due to communication costs this service is
only available within the UK. Mail to info-server@doc.ic.ac.uk for
details. He can also write sun cartridge or exabyte tapes.
* Getting GNU software via UUCP
OSU is distributing via UUCP: most GNU software, MIT C Scheme,
Compress, News, RN, NNTP, Patch, some Appletalk stuff, some of the
Internet Requests For Comment (RFC) et al.. See their periodic
postings on the Usenet newsgroup comp.sources.d for informational
updates. Current details from <staff@cis.ohio-state.edu> or
<...!osu-cis!uucp>.
Information on how to uucp some GNU programs is available via
electronic mail from: uunet!hutch!barber, hqda-ai!merlin, acornrc!bob,
hao!scicom!qetzal!upba!ugn!nepa!denny, bigtex!james (aka
james@bigtex.cactus.org), ncar!noao!asuvax!hrc!dan, oli-stl!root,
src@scuzzy.in-berlin.de (in Germany) and info@ftp.uu.net.
* If You Like The Software
If you like the software developed and distributed by the Free
Software Foundation, please express your satisfaction with a donation.
Your donations will help to support the Foundation and make our future
efforts successful, including a complete development and operating
system, called GNU (Gnu's Not Un*x), which will run Un*x user
programs. For more information on GNU and the Foundation, contact us
at the above address.
Ordering a distribution tape from the Foundation is often a good
way to bring your company or university to make a donation.

475
etc/GNU Normal file
View file

@ -0,0 +1,475 @@
The GNU Manifesto
Copyright (C) 1985 Richard M. Stallman
(Copying permission notice at the end.)
What's GNU? Gnu's Not Unix!
GNU, which stands for Gnu's Not Unix, is the name for the complete
Unix-compatible software system which I am writing so that I can give it
away free to everyone who can use it. Several other volunteers are helping
me. Contributions of time, money, programs and equipment are greatly
needed.
So far we have an Emacs text editor with Lisp for writing editor commands,
a source level debugger, a yacc-compatible parser generator, a linker, and
around 35 utilities. A shell (command interpreter) is nearly completed. A
new portable optimizing C compiler has compiled itself and may be released
this year. An initial kernel exists but many more features are needed to
emulate Unix. When the kernel and compiler are finished, it will be
possible to distribute a GNU system suitable for program development. We
will use @TeX{} as our text formatter, but an nroff is being worked on. We
will use the free, portable X window system as well. After this we will
add a portable Common Lisp, an Empire game, a spreadsheet, and hundreds of
other things, plus on-line documentation. We hope to supply, eventually,
everything useful that normally comes with a Unix system, and more.
GNU will be able to run Unix programs, but will not be identical to Unix.
We will make all improvements that are convenient, based on our experience
with other operating systems. In particular, we plan to have longer
filenames, file version numbers, a crashproof file system, filename
completion perhaps, terminal-independent display support, and perhaps
eventually a Lisp-based window system through which several Lisp programs
and ordinary Unix programs can share a screen. Both C and Lisp will be
available as system programming languages. We will try to support UUCP,
MIT Chaosnet, and Internet protocols for communication.
GNU is aimed initially at machines in the 68000/16000 class with virtual
memory, because they are the easiest machines to make it run on. The extra
effort to make it run on smaller machines will be left to someone who wants
to use it on them.
To avoid horrible confusion, please pronounce the `G' in the word `GNU'
when it is the name of this project.
Who Am I?
I am Richard Stallman, inventor of the original much-imitated EMACS editor,
formerly at the Artificial Intelligence Lab at MIT. I have worked
extensively on compilers, editors, debuggers, command interpreters, the
Incompatible Timesharing System and the Lisp Machine operating system. I
pioneered terminal-independent display support in ITS. Since then I have
implemented one crashproof file system and two window systems for Lisp
machines, and designed a third window system now being implemented; this
one will be ported to many systems including use in GNU. [Historical note:
The window system project was not completed; GNU now plans to use the
X window system.]
Why I Must Write GNU
I consider that the golden rule requires that if I like a program I must
share it with other people who like it. Software sellers want to divide
the users and conquer them, making each user agree not to share with
others. I refuse to break solidarity with other users in this way. I
cannot in good conscience sign a nondisclosure agreement or a software
license agreement. For years I worked within the Artificial Intelligence
Lab to resist such tendencies and other inhospitalities, but eventually
they had gone too far: I could not remain in an institution where such
things are done for me against my will.
So that I can continue to use computers without dishonor, I have decided to
put together a sufficient body of free software so that I will be able to
get along without any software that is not free. I have resigned from the
AI lab to deny MIT any legal excuse to prevent me from giving GNU away.
Why GNU Will Be Compatible with Unix
Unix is not my ideal system, but it is not too bad. The essential features
of Unix seem to be good ones, and I think I can fill in what Unix lacks
without spoiling them. And a system compatible with Unix would be
convenient for many other people to adopt.
How GNU Will Be Available
GNU is not in the public domain. Everyone will be permitted to modify and
redistribute GNU, but no distributor will be allowed to restrict its
further redistribution. That is to say, proprietary modifications will not
be allowed. I want to make sure that all versions of GNU remain free.
Why Many Other Programmers Want to Help
I have found many other programmers who are excited about GNU and want to
help.
Many programmers are unhappy about the commercialization of system
software. It may enable them to make more money, but it requires them to
feel in conflict with other programmers in general rather than feel as
comrades. The fundamental act of friendship among programmers is the
sharing of programs; marketing arrangements now typically used essentially
forbid programmers to treat others as friends. The purchaser of software
must choose between friendship and obeying the law. Naturally, many decide
that friendship is more important. But those who believe in law often do
not feel at ease with either choice. They become cynical and think that
programming is just a way of making money.
By working on and using GNU rather than proprietary programs, we can be
hospitable to everyone and obey the law. In addition, GNU serves as an
example to inspire and a banner to rally others to join us in sharing.
This can give us a feeling of harmony which is impossible if we use
software that is not free. For about half the programmers I talk to, this
is an important happiness that money cannot replace.
How You Can Contribute
I am asking computer manufacturers for donations of machines and money.
I'm asking individuals for donations of programs and work.
One consequence you can expect if you donate machines is that GNU will run
on them at an early date. The machines should be complete, ready to use
systems, approved for use in a residential area, and not in need of
sophisticated cooling or power.
I have found very many programmers eager to contribute part-time work for
GNU. For most projects, such part-time distributed work would be very hard
to coordinate; the independently-written parts would not work together.
But for the particular task of replacing Unix, this problem is absent. A
complete Unix system contains hundreds of utility programs, each of which
is documented separately. Most interface specifications are fixed by Unix
compatibility. If each contributor can write a compatible replacement for
a single Unix utility, and make it work properly in place of the original
on a Unix system, then these utilities will work right when put together.
Even allowing for Murphy to create a few unexpected problems, assembling
these components will be a feasible task. (The kernel will require closer
communication and will be worked on by a small, tight group.)
If I get donations of money, I may be able to hire a few people full or
part time. The salary won't be high by programmers' standards, but I'm
looking for people for whom building community spirit is as important as
making money. I view this as a way of enabling dedicated people to devote
their full energies to working on GNU by sparing them the need to make a
living in another way.
Why All Computer Users Will Benefit
Once GNU is written, everyone will be able to obtain good system software
free, just like air.
This means much more than just saving everyone the price of a Unix license.
It means that much wasteful duplication of system programming effort will
be avoided. This effort can go instead into advancing the state of the
art.
Complete system sources will be available to everyone. As a result, a user
who needs changes in the system will always be free to make them himself,
or hire any available programmer or company to make them for him. Users
will no longer be at the mercy of one programmer or company which owns the
sources and is in sole position to make changes.
Schools will be able to provide a much more educational environment by
encouraging all students to study and improve the system code. Harvard's
computer lab used to have the policy that no program could be installed on
the system if its sources were not on public display, and upheld it by
actually refusing to install certain programs. I was very much inspired by
this.
Finally, the overhead of considering who owns the system software and what
one is or is not entitled to do with it will be lifted.
Arrangements to make people pay for using a program, including licensing of
copies, always incur a tremendous cost to society through the cumbersome
mechanisms necessary to figure out how much (that is, which programs) a
person must pay for. And only a police state can force everyone to obey
them. Consider a space station where air must be manufactured at great
cost: charging each breather per liter of air may be fair, but wearing the
metered gas mask all day and all night is intolerable even if everyone can
afford to pay the air bill. And the TV cameras everywhere to see if you
ever take the mask off are outrageous. It's better to support the air
plant with a head tax and chuck the masks.
Copying all or parts of a program is as natural to a programmer as
breathing, and as productive. It ought to be as free.
Some Easily Rebutted Objections to GNU's Goals
"Nobody will use it if it is free, because that means
they can't rely on any support."
"You have to charge for the program
to pay for providing the support."
If people would rather pay for GNU plus service than get GNU free without
service, a company to provide just service to people who have obtained GNU
free ought to be profitable.
We must distinguish between support in the form of real programming work
and mere handholding. The former is something one cannot rely on from a
software vendor. If your problem is not shared by enough people, the
vendor will tell you to get lost.
If your business needs to be able to rely on support, the only way is to
have all the necessary sources and tools. Then you can hire any available
person to fix your problem; you are not at the mercy of any individual.
With Unix, the price of sources puts this out of consideration for most
businesses. With GNU this will be easy. It is still possible for there to
be no available competent person, but this problem cannot be blamed on
distribution arrangements. GNU does not eliminate all the world's problems,
only some of them.
Meanwhile, the users who know nothing about computers need handholding:
doing things for them which they could easily do themselves but don't know
how.
Such services could be provided by companies that sell just hand-holding
and repair service. If it is true that users would rather spend money and
get a product with service, they will also be willing to buy the service
having got the product free. The service companies will compete in quality
and price; users will not be tied to any particular one. Meanwhile, those
of us who don't need the service should be able to use the program without
paying for the service.
"You cannot reach many people without advertising,
and you must charge for the program to support that."
"It's no use advertising a program people can get free."
There are various forms of free or very cheap publicity that can be used to
inform numbers of computer users about something like GNU. But it may be
true that one can reach more microcomputer users with advertising. If this
is really so, a business which advertises the service of copying and
mailing GNU for a fee ought to be successful enough to pay for its
advertising and more. This way, only the users who benefit from the
advertising pay for it.
On the other hand, if many people get GNU from their friends, and such
companies don't succeed, this will show that advertising was not really
necessary to spread GNU. Why is it that free market advocates don't want
to let the free market decide this?
"My company needs a proprietary operating system
to get a competitive edge."
GNU will remove operating system software from the realm of competition.
You will not be able to get an edge in this area, but neither will your
competitors be able to get an edge over you. You and they will compete in
other areas, while benefitting mutually in this one. If your business is
selling an operating system, you will not like GNU, but that's tough on
you. If your business is something else, GNU can save you from being
pushed into the expensive business of selling operating systems.
I would like to see GNU development supported by gifts from many
manufacturers and users, reducing the cost to each.
"Don't programmers deserve a reward for their creativity?"
If anything deserves a reward, it is social contribution. Creativity can
be a social contribution, but only in so far as society is free to use the
results. If programmers deserve to be rewarded for creating innovative
programs, by the same token they deserve to be punished if they restrict
the use of these programs.
"Shouldn't a programmer be able to ask for a reward for his creativity?"
There is nothing wrong with wanting pay for work, or seeking to maximize
one's income, as long as one does not use means that are destructive. But
the means customary in the field of software today are based on
destruction.
Extracting money from users of a program by restricting their use of it is
destructive because the restrictions reduce the amount and the ways that
the program can be used. This reduces the amount of wealth that humanity
derives from the program. When there is a deliberate choice to restrict,
the harmful consequences are deliberate destruction.
The reason a good citizen does not use such destructive means to become
wealthier is that, if everyone did so, we would all become poorer from the
mutual destructiveness. This is Kantian ethics; or, the Golden Rule.
Since I do not like the consequences that result if everyone hoards
information, I am required to consider it wrong for one to do so.
Specifically, the desire to be rewarded for one's creativity does not
justify depriving the world in general of all or part of that creativity.
"Won't programmers starve?"
I could answer that nobody is forced to be a programmer. Most of us cannot
manage to get any money for standing on the street and making faces. But
we are not, as a result, condemned to spend our lives standing on the
street making faces, and starving. We do something else.
But that is the wrong answer because it accepts the questioner's implicit
assumption: that without ownership of software, programmers cannot possibly
be paid a cent. Supposedly it is all or nothing.
The real reason programmers will not starve is that it will still be
possible for them to get paid for programming; just not paid as much as
now.
Restricting copying is not the only basis for business in software. It is
the most common basis because it brings in the most money. If it were
prohibited, or rejected by the customer, software business would move to
other bases of organization which are now used less often. There are
always numerous ways to organize any kind of business.
Probably programming will not be as lucrative on the new basis as it is
now. But that is not an argument against the change. It is not considered
an injustice that sales clerks make the salaries that they now do. If
programmers made the same, that would not be an injustice either. (In
practice they would still make considerably more than that.)
"Don't people have a right to control how their creativity is used?"
"Control over the use of one's ideas" really constitutes control over other
people's lives; and it is usually used to make their lives more difficult.
People who have studied the issue of intellectual property rights carefully
(such as lawyers) say that there is no intrinsic right to intellectual
property. The kinds of supposed intellectual property rights that the
government recognizes were created by specific acts of legislation for
specific purposes.
For example, the patent system was established to encourage inventors to
disclose the details of their inventions. Its purpose was to help society
rather than to help inventors. At the time, the life span of 17 years for
a patent was short compared with the rate of advance of the state of the
art. Since patents are an issue only among manufacturers, for whom the
cost and effort of a license agreement are small compared with setting up
production, the patents often do not do much harm. They do not obstruct
most individuals who use patented products.
The idea of copyright did not exist in ancient times, when authors
frequently copied other authors at length in works of non-fiction. This
practice was useful, and is the only way many authors' works have survived
even in part. The copyright system was created expressly for the purpose
of encouraging authorship. In the domain for which it was invented--books,
which could be copied economically only on a printing press--it did little
harm, and did not obstruct most of the individuals who read the books.
All intellectual property rights are just licenses granted by society
because it was thought, rightly or wrongly, that society as a whole would
benefit by granting them. But in any particular situation, we have to ask:
are we really better off granting such license? What kind of act are we
licensing a person to do?
The case of programs today is very different from that of books a hundred
years ago. The fact that the easiest way to copy a program is from one
neighbor to another, the fact that a program has both source code and
object code which are distinct, and the fact that a program is used rather
than read and enjoyed, combine to create a situation in which a person who
enforces a copyright is harming society as a whole both materially and
spiritually; in which a person should not do so regardless of whether the
law enables him to.
"Competition makes things get done better."
The paradigm of competition is a race: by rewarding the winner, we
encourage everyone to run faster. When capitalism really works this way,
it does a good job; but its defenders are wrong in assuming it always works
this way. If the runners forget why the reward is offered and become
intent on winning, no matter how, they may find other strategies--such as,
attacking other runners. If the runners get into a fist fight, they will
all finish late.
Proprietary and secret software is the moral equivalent of runners in a
fist fight. Sad to say, the only referee we've got does not seem to
object to fights; he just regulates them ("For every ten yards you run, you
are allowed one kick."). He really ought to break them up, and penalize
runners for even trying to fight.
"Won't everyone stop programming without a monetary incentive?"
Actually, many people will program with absolutely no monetary incentive.
Programming has an irresistible fascination for some people, usually the
people who are best at it. There is no shortage of professional musicians
who keep at it even though they have no hope of making a living that way.
But really this question, though commonly asked, is not appropriate to the
situation. Pay for programmers will not disappear, only become less. So
the right question is, will anyone program with a reduced monetary
incentive? My experience shows that they will.
For more than ten years, many of the world's best programmers worked at the
Artificial Intelligence Lab for far less money than they could have had
anywhere else. They got many kinds of non-monetary rewards: fame and
appreciation, for example. And creativity is also fun, a reward in itself.
Then most of them left when offered a chance to do the same interesting
work for a lot of money.
What the facts show is that people will program for reasons other than
riches; but if given a chance to make a lot of money as well, they will
come to expect and demand it. Low-paying organizations do poorly in
competition with high-paying ones, but they do not have to do badly if the
high-paying ones are banned.
"We need the programmers desperately. If they demand that we
stop helping our neighbors, we have to obey."
You're never so desperate that you have to obey this sort of demand.
Remember: millions for defense, but not a cent for tribute!
"Programmers need to make a living somehow."
In the short run, this is true. However, there are plenty of ways that
programmers could make a living without selling the right to use a program.
This way is customary now because it brings programmers and businessmen the
most money, not because it is the only way to make a living. It is easy to
find other ways if you want to find them. Here are a number of examples.
A manufacturer introducing a new computer will pay for the porting of
operating systems onto the new hardware.
The sale of teaching, hand-holding and maintenance services could also
employ programmers.
People with new ideas could distribute programs as freeware, asking for
donations from satisfied users, or selling hand-holding services. I have
met people who are already working this way successfully.
Users with related needs can form users' groups, and pay dues. A group
would contract with programming companies to write programs that the
group's members would like to use.
All sorts of development can be funded with a Software Tax:
Suppose everyone who buys a computer has to pay x percent of
the price as a software tax. The government gives this to
an agency like the NSF to spend on software development.
But if the computer buyer makes a donation to software development
himself, he can take a credit against the tax. He can donate to
the project of his own choosing--often, chosen because he hopes to
use the results when it is done. He can take a credit for any amount
of donation up to the total tax he had to pay.
The total tax rate could be decided by a vote of the payers of
the tax, weighted according to the amount they will be taxed on.
The consequences:
* the computer-using community supports software development.
* this community decides what level of support is needed.
* users who care which projects their share is spent on
can choose this for themselves.
In the long run, making programs free is a step toward the post-scarcity
world, where nobody will have to work very hard just to make a living.
People will be free to devote themselves to activities that are fun,
such as programming, after spending the necessary ten hours a week
on required tasks such as legislation, family counseling, robot
repair and asteroid prospecting. There will be no need to be able
to make a living from programming.
We have already greatly reduced the amount of work that the whole
society must do for its actual productivity, but only a little of this
has translated itself into leisure for workers because much
nonproductive activity is required to accompany productive activity.
The main causes of this are bureaucracy and isometric struggles
against competition. Free software will greatly reduce these
drains in the area of software production. We must do this,
in order for technical gains in productivity to translate into
less work for us.
Copyright (C) 1985 Richard M. Stallman
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Modified versions may not be made.

38
etc/GNU.JOKES Normal file
View file

@ -0,0 +1,38 @@
From: Don Chiasson <G.CHIASSON@DREA-XX.ARPA>
Subject: Some gnu jokes
To: jokes@DREA-XX.ARPA, gergely@DREA-XX.ARPA, broome@DREA-XX.ARPA
cc: G.CHIASSON@DREA-XX.ARPA
Message-ID: <12329394624.13.G.CHIASSON@DREA-XX.ARPA>
Richard M. Stallman (RMS, widely known for creating EMACS) is writing
a UNIX clone called GNU (which means Gnu's Not Unix--a recursive acronym).
This seems to open the way to a whole gnu class of jokes. For example:
Q: What do you call a person who hacks while wearing no clothes?
A: A gnudist.
Q: What do you call an eligible young hacker?
A: Gnubile.
Q: What is a hacker's favorite candy?
A: Gnugat. (Though it contains little gnutrition.)
Q: What do you call a computer filled with air?
A: Gnumatic.
Q: What do you call a novice hacker who keeps pestering you
with foolish questions?
A: A gnuisance.
Q: What do you call a subtle, clever hack in the favorite language?
A: A gnuanCe.
Q: What do you use a supercomputer for?
A: Gnumerical analysis.
Q: What do you call a hacker who collects coins?
A: A gnumismatist.
Well, there are more, just too gnumerous to tell all at once. I think
I'd better go before someone starts firing gnuclear weapons at me.
Don

614
etc/GOSDIFF Normal file
View file

@ -0,0 +1,614 @@
Advantages of Gosling Emacs:
1. The program itself is much smaller.
GNU Emacs uses about 250k more pure storage.
As a result, Gosling Emacs can run on machines
that cannot run GNU Emacs. There is not much difference
in the amount of impure storage in the two programs.
2. In some versions there is support for other forks to
establish communications channels to Emacs (using sockets?).
3. There is a direct interface to dbm (data bases).
Advantages of GNU Emacs:
* True Lisp, not Mocklisp.
GNU Emacs's extension language has real symbols, lists
and vectors. Many extensions are much simpler, and some
become possible that were nearly impossible in Gosling Emacs.
Many primitives can have cleaner interfaces, and some features
need not be put in as special primitives because you can do
them easily yourself.
* But Mocklisp still works.
An automatic conversion package plus a run-time library
allows you to convert a Mocklisp library into a Lisp library.
* Commands are better crafted.
For example, nearly every editing function for which a
numeric argument would make sense as a repeat count does
accept a repeat count, and does handle a negative argument
in the way you would expect.
* The manual is clearer.
Everyone tells me it is a very good manual.
* Better on-line documentation.
Both functions and variables have documentation strings that
describe exactly how to use them.
* C mode is smart.
It really knows how to indent each line correctly,
for most popular indentation styles. (Some variables
control which style is used.)
* Compatible with PDP-10 Emacs, Multics Emacs and Zmacs.
The commands in GNU Emacs are nearly the same as in the
original Emacs and the other Emacses which imitated it.
(A few have been changed to fit the Unix environment better.)
* Support for Gosling's Emacs commands.
M-x set-gosmacs-bindings rebinds many editing commands for
compatibility with Gosling's Emacs.
M-x set-gnu-bindings reverses the change.
* Side-by-side windows.
You can split a GNU Emacs window either horizontally or
vertically.
* Redisplay is faster.
GNU Emacs sends about the same stuff to the terminal that
Gosling's does, but GNU Emacs uses much less CPU time to
decide what to do.
* Entirely termcap-driven.
GNU Emacs has nearly no special code for any terminal type. Various
new termcap strings make it possible to handle all terminals nearly as
fast as they could be handled by special-case code.
* Display-hiding features.
For example, Outline Mode makes it possible for you to edit
an outline, making entire sub-branches of the outline visible
or invisible when you wish.
* You can interrupt with Control-G.
Even a looping Lisp program can be stopped this way.
And even a loop in C code does not stop you from killing
Emacs and getting back to your shell.
* Per-buffer Undo.
You can undo the last several changes, in each buffer
independently.
* The editor code itself is clean.
Many people have remarked on how much they enjoy reading
the code for GNU Emacs.
One other note: The program etc/cvtmail that comes with GNU Emacs can
be used to convert a mail directory for Gosling Emacs's Rmail into a
Unix mail file that you could read into GNU Emacs's Rmail.
A detailed comparison by Rodney Zykowitz (rtgvax!ramin@eddie.mit.edu)
Enclosed are two difference listings. The first one is a cross-reference
by Key bindings. The second is by alphabetized function name.
Only those functions normally bound to keys in a
"standard" version are included. As far as I know it excludes
bindings added here locally (but what do I know...)
The Gosling's is version 2.02 and runs on VMS 4.2. The Gnu is
version 16.56.1 running under Ultrix 1.1.
And could someone send me some info on Gnu on VMS. I seem to have entirely
missed that posting. If it is hopeless, I just might sit down and write
a Gnu emulator for Unipress and a Unipress emulator for Gnu... But the
thought of that already makes me wanna....
ramin...
Standard disclaimer excluded for humanitarian purposes.
Command Binding Cross-references. By key code:
VMS (Unipress) GNU Emacs
Key Binding Binding
--- ------- ---------------
^@ set-mark set-mark-command
^A beginning-of-line beginning-of-line
^B backward-character backward-char
^C exit-emacs exit-recursive-edit
^D delete-next-character delete-char
^E end-of-line end-of-line
^F forward-character forward-char
^G illegal-operation
^H delete-previous-character help-command
^H-v describe-variable
^H-w where-is
^H-t help-with-tutorial
^H-s describe-syntax
^H-n view-emacs-news
^H-^N view-emacs-news
^H-m describe-mode
^H-l view-lossage
^H-i info
^H-f describe-function
^H-d describe-function
^H-k describe-key
^H-c describe-key-briefly
^H-b describe-bindings
^H-a command-apropos
^H-^D describe-distribution
^H-^C describe-copying
^H-? help-for-help
^H-^H help-for-help
^I self-insert indent-for-tab-command
^J newline-and-indent newline-and-indent
^K kill-to-end-of-line kill-line
^L redraw-display recenter
^M newline newline
^N next-line next-line
^O newline-and-backup open-line
^P previous-line previous-line
^Q quote-character quoted-insert
^R search-reverse isearch-backward
^S search-forward isearch-forward
^T transpose-characters transpose-chars
^U argument-prefix universal-argument
^V next-page scroll-up
^W delete-to-killbuffer kill-region
^X ^X-prefix Control-x-prefix
^X-^A add-mode-abbrev
^X-^B list-buffers list-buffers
^X-^C exit-emacs save-buffers-kill-emacs
^X-^D describe-word-in-buffer list-directory
^X-^E compile-it eval-last-sexp
^X-^F write-pause-or-exit find-file
^X-^H inverse-add-mode-abbrev
^X-^I insert-file indent-rigidly
^X-^L downcase-region
^X-^M write-modified-files
^X-^N next-error set-goal-column
^X-^O use-old-buffer delete-blank-linkes
^X-^P mark-page
^X-^Q toggle-read-only
^X-^R read-file find-file-read-only
^X-^S write-current-file save-buffer
^X-^T transpose-lines
^X-^U new-undo upcase-region
^X-^V visit-file find-alternate-file
^X-^W write-named-file write-file
^X-^X exchange-dot-and-mark exchange-dot-and-mark
^X-^Z shrink-window suspend-emacs
^X-ESC repeat-complex-command
^X-! execute-monitor-command
^X-$ set-selective-display
^X-( start-remembering start-kbd-macro
^X-) stop-remembering end-kbd-macro
^X-+ add-global-abbrev
^X-- inverse-add-global-abbrev
^X-. set-fill-prefix
^X-/ dot-to-register
^X-0 delete-window
^X-1 delete-other-windows delete-other-windows
^X-2 split-current-window split-window-vertically
^X-4 ctl-x-4-prefix
^X-4-^F find-file-other-window
^X-4-. find-tag-other-window
^X-4-b pop-to-buffer
^X-4-d dired-other-window
^X-4-f find-file-other-window
^X-4-m mail-other-window
^X-5 split-window-horizontally
^X-; set-comment-column
^X-< scroll-left
^X-= what-cursor-position
^X-> scroll-right
^X-[ backward-page
^X-] forward-page
^X-^ enlarge-window
^X-` next-error
^X-a append-to-buffer
^X-b switch-to-buffer switch-to-buffer
^X-d delete-window dired
^X-e execute-keyboard-macro call-last-kbd-macro
^X-f set-fill-column
^X-g insert-register
^X-h mark-whole-buffer
^X-i insert-file
^X-j register-to-dot
^X-k kill-buffer
^X-l count-lines-page
^X-m mail
^X-n next-window narrow-to-region
^X-o other-window
^X-p previous-window narrow-to-page
^X-q kbd-macro-query
^X-r copy-rectangle-to-register
^X-s save-some-buffers
^X-u advertised-undo
^X-w widen
^X-x copy-to-register
^X-z enlarge-window
^X-{ shrink-window-horizontally
^X-} enlarge-window-horizontally
^X-DEL backward-kill-sentence
^Y yank-from-killbuffer yank
^Z scroll-one-line-up suspend-emacs
ESC ESC-prefix
ESC-^@ mark-sexp
ESC-^A beginning-of-defun
ESC-^B backward-sexp
ESC-^C exit-emacs exit-recursive-edit
ESC-^D down-list
ESC-^E end-of-defun
ESC-^F forward-sexp
ESC-^H mark-defun
ESC-^J indent-new-comment-line
ESC-^K kill-sexp
ESC-^N forward-list
ESC-^O split-line
ESC-^P backward-list
ESC-^S isearch-forward-regexp
ESC-^T transpose-sexps
ESC-^U backward-up-list
ESC-^V page-next-window scroll-other-window
ESC-^W delete-region-to-buffer append-next-kill
ESC-^Y yank-buffer
ESC-ESC execute-mlisp-line eval-expression
ESC-^^ case-region-invert
ESC-^\ indent-region
ESC-<SP> just-one-space
ESC-! line-to-top-of-window shell-command
ESC-$ spell-word
ESC-% query-replace
ESC-' abbrev-prefix-mark
ESC-( backward-paragraph insert-parentheses
ESC-) forward-paragraph move-past-close-and-reindent
ESC-, beginning-of-window tags-loop-continue
ESC-- meta-minus negative-argument
ESC-. end-of-window find-tag
ESC-0..ESC-9 meta-digit digit-argument
ESC-; indent-for-comment
ESC-< beginning-of-file beginning-of-buffer
ESC-= count-lines-region
ESC-> end-of-file end-of-buffer
ESC-@ mark-word
ESC-[ backward-paragraph
ESC-\ delete-horizontal-space
ESC-] forward-paragraph
ESC-? apropos
ESC-^ case-word-invert delete-indentation
ESC-a backward-sentence backward-sentence
ESC-b backward-word backward-word
ESC-d delete-next-word kill-word
ESC-e forward-sentence forward-sentence
ESC-f forward-word forward-word
ESC-g fill-region
ESC-h delete-previous-word mark-paragraph
ESC-j indent-C-procedure indent-new-comment-line
ESC-k kill-sentence
ESC-l case-word-lower downcase-word
ESC-q query-replace-string fill-paragraph
ESC-r replace-string move-to-window-line
ESC-t transpose-words
ESC-u case-word-upper upcase-word
ESC-v previous-page scroll-down
ESC-w copy-region-as-kill
ESC-x execute-extended-command execute-extended-command
ESC-y yank-pop
ESC-z scroll-one-line-down zap-to-char
ESC-| shell-command-on-region
ESC-~ not-modified
ESC-DEL backward-kill-word
^_ return-to-monitor
.., self-insert
- minus
.../ self-insert
0..9 digit
:..~ self-insert
^? delete-previous-character
Command Binding Cross-references. By name:
Command VMS (Unipress) Key GNU Key
----------------------------- --------------------- ------------
abbrev-prefix-mark ESC-'
add-global-abbrev ^X-+
add-mode-abbrev ^X-^A
advertised-undo ^X-u
append-next-kill ESC-^W
append-to-buffer ^X-a
apropos ESC-?
argument-prefix ^U
backward-char ^B
backward-character ^B
backward-kill-sentence ^X-DEL
backward-kill-word ESC-DEL
backward-list ESC-^P
backward-page ^X-[
backward-paragraph ESC-(
backward-paragraph ESC-[
backward-sentence ESC-a
backward-sentence ESC-a
backward-sexp ESC-^B
backward-up-list ESC-^U
backward-word ESC-b
backward-word ESC-b
beginning-of-buffer ESC-<
beginning-of-defun ESC-^A
beginning-of-file ESC-<
beginning-of-line ^A
beginning-of-line ^A
beginning-of-window ESC-,
call-last-kbd-macro ^X-e
case-region-invert ESC-^^
case-word-invert ESC-^
case-word-lower ESC-l
case-word-upper ESC-u
command-apropos ^H-a
compile-it ^X-^E
control-x-prefix ^X
control-x-prefix ^X
copy-rectangle-to-register ^X-r
copy-region-as-kill ESC-w
copy-to-register ^X-x
count-lines-page ^X-l
count-lines-region ESC-=
ctl-x-4-prefix ^X-4
delete-blank-linkes ^X-^O
delete-char ^D
delete-horizontal-space ESC-\
delete-indentation ESC-^
delete-next-character ^D
delete-next-word ESC-d
delete-other-windows ^X-1
delete-other-windows ^X-1
delete-previous-character ^H ^?
delete-previous-character ^?
delete-previous-word ESC-h
delete-region-to-buffer ESC-^W
delete-to-killbuffer ^W
delete-window ^X-0
delete-window ^X-d
describe-bindings ^H-b
describe-copying ^H-^C
describe-distribution ^H-^D
describe-function ^H-f
describe-function ^H-d
describe-key ^H-k
describe-key-briefly ^H-c
describe-mode ^H-m
describe-syntax ^H-s
describe-variable ^H-v
describe-word-in-buffer ^X-^D
digit 0..9
digit 0..9
digit-argument ESC-0..ESC-9
dired ^X-d
dired-other-window ^X-4-d
dot-to-register ^X-/
down-list ESC-^D
downcase-region ^X-^L
downcase-word ESC-l
end-kbd-macro ^X-)
end-of-buffer ESC->
end-of-defun ESC-^E
end-of-file ESC->
end-of-line ^E
end-of-line ^E
end-of-window ESC-.
enlarge-window ^X-^
enlarge-window ^X-z
enlarge-window-horizontally ^X-}
esc-prefix ESC
esc-prefix ESC
eval-expression ESC-ESC
eval-last-sexp ^X-^E
exchange-dot-and-mark ^X-^X
exchange-dot-and-mark ^X-^X
execute-extended-command ESC-x
execute-extended-command ESC-x
execute-keyboard-macro ^X-e
execute-mlisp-line ESC-ESC
execute-monitor-command ^X-!
exit-emacs ^C
exit-emacs ^X-^C
exit-emacs ESC-^C
exit-recursive-edit ^C
exit-recursive-edit ESC-^C
fill-paragraph ESC-q
fill-region ESC-g
find-alternate-file ^X-^V
find-file ^X-^F
find-file-other-window ^X-4-^F
find-file-other-window ^X-4-f
find-file-read-only ^X-^R
find-tag ESC-.
find-tag-other-window ^X-4-.
forward-char ^F
forward-character ^F
forward-list ESC-^N
forward-page ^X-]
forward-paragraph ESC-)
forward-paragraph ESC-]
forward-sentence ESC-e
forward-sentence ESC-e
forward-sexp ESC-^F
forward-word ESC-f
forward-word ESC-f
help-command ^H
help-for-help ^H-?
help-for-help ^H-^H
help-with-tutorial ^H-t
illegal-operation ^G
indent-C-procedure ESC-j
indent-for-comment ESC-;
indent-for-tab-command ^I
indent-new-comment-line ESC-^J
indent-new-comment-line ESC-j
indent-region ESC-^\
indent-rigidly ^X-^I
info ^H-i
insert-file ^X-^I
insert-file ^X-i
insert-parentheses ESC-(
insert-register ^X-g
inverse-add-global-abbrev ^X--
inverse-add-mode-abbrev ^X-^H
isearch-backward ^R
isearch-forward ^S
isearch-forward-regexp ESC-^S
just-one-space ESC-<SP>
kbd-macro-query ^X-q
kill-buffer ^X-k
kill-line ^K
kill-region ^W
kill-sentence ESC-k
kill-sexp ESC-^K
kill-to-end-of-line ^K
kill-word ESC-d
line-to-top-of-window ESC-!
list-buffers ^X-^B
list-buffers ^X-^B
list-directory ^X-^D
mail ^X-m
mail-other-window ^X-4-m
mark-defun ^X-^H
mark-page ^X-^P
mark-paragraph ESC-h
mark-sexp ESC-^@
mark-whole-buffer ^X-h
mark-word ESC-@
meta-digit ESC-0..ESC-9
meta-minus ESC--
minus -
minus -
move-past-close-and-reindent ESC-)
move-to-window-line ESC-r
narrow-to-page ^X-p
narrow-to-region ^X-n
negative-argument ESC--
new-undo ^X-^U
newline ^M
newline ^M
newline-and-backup ^O
newline-and-indent ^J
newline-and-indent ^J
next-error ^X-^N
next-error ^X-`
next-line ^N
next-line ^N
next-page ^V
next-window ^X-n
not-modified ESC-~
open-line ^O
other-window ^X-o
page-next-window ESC-^V
pop-to-buffer ^X-4-b
previous-line ^P
previous-line ^P
previous-page ESC-v
previous-window ^X-p
query-replace ESC-%
query-replace-string ESC-q
quote-character ^Q
quoted-insert ^Q
read-file ^X-^R
recenter ^L
redraw-display ^L
register-to-dot ^X-j
repeat-complex-command ^X-ESC
replace-string ESC-r
return-to-monitor ^_(CTL-/)
save-buffer ^X-^S
save-buffers-kill-emacs ^X-^C
save-some-buffers ^X-s
scroll-down ESC-v
scroll-left ^X-<
scroll-one-line-down ESC-z
scroll-one-line-up ^Z
scroll-other-window ESC-^V
scroll-right ^X->
scroll-up ^V
search-forward ^S
search-reverse ^R
self-insert ^I
self-insert <SP>..,
self-insert .../
self-insert :..~
set-comment-column ^X-;
set-fill-column ^X-f
set-fill-prefix ^X-.
set-goal-column ^X-^N
set-mark ^@
set-mark-command ^@
set-selective-display ^X-$
shell-command ESC-!
shell-command-on-region ESC-|
shrink-window ^X-^Z
shrink-window-horizontally ^X-{
spell-word ESC-$
split-current-window ^X-2
split-line ESC-^O
split-window-horizontally ^X-5
split-window-vertically ^X-2
start-kbd-macro ESC-(
start-remembering ^X-(
stop-remembering ^X-)
suspend-emacs ^X-^Z
suspend-emacs ^Z
switch-to-buffer ^X-b
switch-to-buffer ^X-b
tags-loop-continue ESC-,
toggle-read-only ^X-^Q
transpose-characters ^T
transpose-chars ^T
transpose-lines ^X-^T
transpose-sexps ESC-^T
transpose-words ESC-t
universal-argument ^U
upcase-region ^X-^U
upcase-word ESC-u
use-old-buffer ^X-^O
view-emacs-news ^H-^N
view-emacs-news ^H-n
view-lossage ^H-l
visit-file ^X-^V
what-cursor-position ^X-=
where-is ^H-w
widen ^X-w
write-current-file ^X-^S
write-file ^X-^W
write-modified-files ^X-^M
write-named-file ^X-^W
write-pause-or-exit ^X-^F
yank ^Y
yank-buffer ESC-^Y
yank-from-killbuffer ^Y
yank-pop ESC-y
zap-to-char ESC-z

30
etc/INTERVAL.IDEAS Normal file
View file

@ -0,0 +1,30 @@
This idea comes from Andrew. The basic part is to represent a division
of the buffer into disjoint intervals by means of a binary tree. Each
interval has one node. The tree has the effect of a large ordered
collection of markers, but no Lisp_Marker objects appear in the tree.
Each node has two subnodes, a left and a right, each of which can be
nil instead. The subnodes' intervals are disjoint from their parent's
interval--the tree structure is for binary searching.
Each node in the tree is implicitly associated with a region of the
buffer, but I don't think it actually stores the positions; I think it
has the length of that node, or perhaps its own length and separately
the length of it plus all its subnodes.
I forget the details of this, but the idea is that you can figure out
the position of a node, or find the node containing a position, by
examining just its superiors in the tree, and you can also update the
tree for changes in the buffer by tracing just one path down the tree.
So the amount of work for nearly any operation goes with the log of
the number of intervals.
If it is desirable to be able to subdivide the intervals, each interval
can have another such tree dividing it into disjoint subintervals. And
subintervals can have trees, too. So it becomes a tree of trees.
The idea is to associate an alist with each interval or subinterval.
The complete alist associated with any spot is the append of the
alists of the containing intervals at all levels of subdivision,
smallest ones first. It would also be useful to get the bounds of the
innermost interval.

434
etc/INTERVIEW Normal file
View file

@ -0,0 +1,434 @@
GNU'S NOT UNIX
Conducted by David Betz and Jon Edwards
Richard Stallman discusses his public-domain
UNIX-compatible software system
with BYTE editors
(July 1986)
Copyright (C) 1986 Richard Stallman. Permission is granted to make and
distribute copies of this article as long as the copyright and this notice
appear on all copies.
Richard Stallman has undertaken probably the most ambitious free software
development project to date, the GNU system. In his GNU Manifesto,
published in the March 1985 issue of Dr. Dobb's Journal, Stallman described
GNU as a "complete Unix-compatible software system which I am writing so
that I can give it away free to everyone who can use it... Once GNU is
written, everyone will be able to obtain good system software free, just
like air." (GNU is an acronym for GNU's Not UNIX; the "G" is pronounced.)
Stallman is widely known as the author of EMACS, a powerful text editor
that he developed at the MIT Artificial Intelligence Laboratory. It is no
coincidence that the first piece of software produced as part of the GNU
project was a new implementation of EMACS. GNU EMACS has already achieved a
reputation as one of the best implementations of EMACS currently available
at any price.
BYTE: We read your GNU Manifesto in the March 1985 issue of Dr. Dobb's.
What has happened since? Was that really the beginning, and how have you
progressed since then?
Stallman: The publication in Dr. Dobb's wasn't the beginning of the
project. I wrote the GNU Manifesto when I was getting ready to start the
project, as a proposal to ask computer manufacturers for funding. They
didn't want to get involved, and I decided that rather than spend my time
trying to pursue funds, I ought to spend it writing code. The manifesto was
published about a year and a half after I had written it, when I had barely
begun distributing the GNU EMACS. Since that time, in addition to making
GNU EMACS more complete and making it run on many more computers, I have
nearly finished the optimizing C compiler and all the other software that
is needed for running C programs. This includes a source-level debugger
that has many features that the other source-level debuggers on UNIX don't
have. For example, it has convenience variables within the debugger so you
can save values, and it also has a history of all the values that you have
printed out, making it tremendously easier to chase around list structures.
BYTE: You have finished an editor that is now widely distributed and you
are about to finish the compiler.
Stallman: I expect that it will be finished this October.
BYTE: What about the kernel?
Stallman: I'm currently planning to start with the kernel that was written
at MIT and was released to the public recently with the idea that I would
use it. This kernel is called TRIX; it's based on remote procedure call. I
still need to add compatibility for a lot of the features of UNIX which it
doesn't have currently. I haven't started to work on that yet. I'm
finishing the compiler before I go to work on the kernel. I am also going
to have to rewrite the file system. I intend to make it failsafe just by
having it write blocks in the proper order so that the disk structure is
always consistent. Then I want to add version numbers. I have a complicated
scheme to reconcile version numbers with the way people usually use UNIX.
You have to be able to specify filenames without version numbers, but you
also have to be able to specify them with explicit version numbers, and
these both need to work with ordinary UNIX programs that have not been
modified in any way to deal with the existence of this feature. I think I
have a scheme for doing this, and only trying it will show me whether it
really does the job.
BYTE: Do you have a brief description you can give us as to how GNU as a
system will be superior to other systems? We know that one of your goals is
to produce something that is compatible with UNIX. But at least in the area
of file systems you have already said that you are going to go beyond UNIX
and produce something that is better.
Stallman: The C compiler will produce better code and run faster. The
debugger is better. With each piece I may or may not find a way to improve
it. But there is no one answer to this question. To some extent I am
getting the benefit of reimplementation, which makes many systems much
better. To some extent it's because I have been in the field a long time
and worked on many other systems. I therefore have many ideas to bring to
bear. One way in which it will be better is that practically everything in
the system will work on files of any size, on lines of any size, with any
characters appearing in them. The UNIX system is very bad in that regard.
It's not anything new as a principle of software engineering that you
shouldn't have arbitrary limits. But it just was the standard practice in
writing UNIX to put those in all the time, possibly just because they were
writing it for a very small computer. The only limit in the GNU system is
when your program runs out of memory because it tried to work on too much
data and there is no place to keep it all.
BYTE: And that isn't likely to be hit if you've got virtual memory. You may
just take forever to come up with the solution.
Stallman: Actually these limits tend to hit in a time long before you take
forever to come up with the solution.
BYTE: Can you say something about what types of machines and environments
GNU EMACS in particular has been made to run under? It's now running on
VAXes; has it migrated in any form to personal computers?
Stallman: I'm not sure what you mean by personal computers. For example, is
a Sun a personal computer? GNU EMACS requires at least a megabyte of
available memory and preferably more. It is normally used on machines that
have virtual memory. Except for various technical problems in a few C
compilers, almost any machine with virtual memory and running a fairly
recent version of UNIX will run GNU EMACS, and most of them currently do.
BYTE: Has anyone tried to port it to Ataris or Macintoshes?
Stallman: The Atari 1040ST still doesn't have quite enough memory. The next
Atari machine, I expect, will run it. I also think that future Ataris will
have some forms of memory mapping. Of course, I am not designing the
software to run on the kinds of computers that are prevalent today. I knew
when I started this project it was going to take a few years. I therefore
decided that I didn't want to make a worse system by taking on the
additional challenge of making it run in the currently constrained
environment. So instead I decided I'm going to write it in the way that
seems the most natural and best. I am confident that in a couple of years
machines of sufficient size will be prevalent. In fact, increases in memory
size are happening so fast it surprises me how slow most of the people are
to put in virtual memory; I think it is totally essential.
BYTE: I think people don't really view it as being necessary for
single-user machines.
Stallman: They don't understand that single user doesn't mean single
program. Certainly for any UNIX-like system it's important to be able to
run lots of different processes at the same time even if there is only one
of you. You could run GNU EMACS on a nonvirtual-memory machine with enough
memory, but you couldn't run the rest of the GNU system very well or a UNIX
system very well.
BYTE: How much of LISP is present in GNU EMACS? It occurred to me that it
may be useful to use that as a tool for learning LISP.
Stallman: You can certainly do that. GNU EMACS contains a complete,
although not very powerful, LISP system. It's powerful enough for writing
editor commands. It's not comparable with, say, a Common LISP System,
something you could really use for system programming, but it has all the
things that LISP needs to have.
BYTE: Do you have any predictions about when you would be likely to
distribute a workable environment in which, if we put it on our machines or
workstations, we could actually get reasonable work done without using
anything other than code that you distribute?
Stallman: It's really hard to say. That could happen in a year, but of
course it could take longer. It could also conceivably take less, but
that's not too likely anymore. I think I'll have the compiler finished in a
month or two. The only other large piece of work I really have to do is in
the kernel. I first predicted GNU would take something like two years, but
it has now been two and a half years and I'm still not finished. Part of
the reason for the delay is that I spent a lot of time working on one
compiler that turned out to be a dead end. I had to rewrite it completely.
Another reason is that I spent so much time on GNU EMACS. I originally
thought I wouldn't have to do that at all.
BYTE: Tell us about your distribution scheme.
Stallman: I don't put software or manuals in the public domain, and the
reason is that I want to make sure that all the users get the freedom to
share. I don't want anyone making an improved version of a program I wrote
and distributing it as proprietary. I don't want that to ever be able to
happen. I want to encourage the free improvements to these programs, and
the best way to do that is to take away any temptation for a person to make
improvements nonfree. Yes, a few of them will refrain from making
improvements, but a lot of others will make the same improvements and
they'll make them free.
BYTE: And how do you go about guaranteeing that?
Stallman: I do this by copyrighting the programs and putting on a notice
giving people explicit permission to copy the programs and change them but
only on the condition that they distribute under the same terms that I
used, if at all. You don't have to distribute the changes you make to any
of my programs--you can just do it for yourself, and you don't have to give
it to anyone or tell anyone. But if you do give it to someone else, you
have to do it under the same terms that I use.
BYTE: Do you obtain any rights over the executable code derived from the C
compiler?
Stallman: The copyright law doesn't give me copyright on output from the
compiler, so it doesn't give me a way to say anything about that, and in
fact I don't try to. I don't sympathize with people developing proprietary
products with any compiler, but it doesn't seem especially useful to try to
stop them from developing them with this compiler, so I am not going to.
BYTE: Do your restrictions apply if people take pieces of your code to
produce other things as well?
Stallman: Yes, if they incorporate with changes any sizable piece. If it
were two lines of code, that's nothing; copyright doesn't apply to that.
Essentially, I have chosen these conditions so that first there is a
copyright, which is what all the software hoarders use to stop everybody
from doing anything, and then I add a notice giving up part of those
rights. So the conditions talk only about the things that copyright applies
to. I don't believe that the reason you should obey these conditions is
because of the law. The reason you should obey is because an upright person
when he distributes software encourages other people to share it further.
BYTE: In a sense you are enticing people into this mode of thinking by
providing all of these interesting tools that they can use but only if they
buy into your philosophy.
Stallman: Yes. You could also see it as using the legal system that
software hoarders have set up against them. I'm using it to protect the
public from them.
BYTE: Given that manufacturers haven't wanted to fund the project, who do
you think will use the GNU system when it is done?
Stallman: I have no idea, but it is not an important question. My purpose
is to make it possible for people to reject the chains that come with
proprietary software. I know that there are people who want to do that.
Now, there may be others who don't care, but they are not my concern. I
feel a bit sad for them and for the people that they influence. Right now a
person who perceives the unpleasantness of the terms of proprietary
software feels that he is stuck and has no alternative except not to use a
computer. Well, I am going to give him a comfortable alternative.
Other people may use the GNU system simply because it is technically
superior. For example, my C compiler is producing about as good a code as I
have seen from any C compiler. And GNU EMACS is generally regarded as being
far superior to the commercial competition. And GNU EMACS was not funded by
anyone either, but everyone is using it. I therefore think that many people
will use the rest of the GNU system because of its technical advantages.
But I would be doing a GNU system even if I didn't know how to make it
technically better because I want it to be socially better. The GNU project
is really a social project. It uses technical means to make a change in
society.
BYTE: Then it is fairly important to you that people adopt GNU. It is not
just an academic exercise to produce this software to give it away to
people. You hope it will change the way the software industry operates.
Stallman: Yes. Some people say no one will ever use it because it doesn't
have some attractive corporate logo on it, and other people say that they
think it is tremendously important and everyone's going to want to use it.
I have no way of knowing what is really going to happen. I don't know any
other way to try to change the ugliness of the field that I find myself in,
so this is what I have to do.
BYTE: Can you address the implications? You obviously feel that this is an
important political and social statement.
Stallman: It is a change. I'm trying to change the way people approach
knowledge and information in general. I think that to try to own knowledge,
to try to control whether people are allowed to use it, or to try to stop
other people from sharing it, is sabotage. It is an activity that benefits
the person that does it at the cost of impoverishing all of society. One
person gains one dollar by destroying two dollars' worth of wealth. I think
a person with a conscience wouldn't do that sort of thing except perhaps if
he would otherwise die. And of course the people who do this are fairly
rich; I can only conclude that they are unscrupulous. I would like to see
people get rewards for writing free software and for encouraging other
people to use it. I don't want to see people get rewards for writing
proprietary software because that is not really a contribution to society.
The principle of capitalism is the idea that people manage to make money by
producing things and thereby are encouraged to do what is useful,
automatically, so to speak. But that doesn't work when it comes to owning
knowledge. They are encouraged to do not really what's useful, and what
really is useful is not encouraged. I think it is important to say that
information is different from material objects like cars and loaves of
bread because people can copy it and share it on their own and, if nobody
attempts to stop them, they can change it and make it better for
themselves. That is a useful thing for people to do. This isn't true of
loaves of bread. If you have one loaf of bread and you want another, you
can't just put your loaf of bread into a bread copier. you can't make
another one except by going through all the steps that were used to make
the first one. It therefore is irrelevant whether people are permitted to
copy it--it's impossible.
Books were printed only on printing presses until recently. It was
possible to make a copy yourself by hand, but it wasn't practical because
it took so much more work than using a printing press. And it produced
something so much less attractive that, for all intents and purposes, you
could act as if it were impossible to make books except by mass producing
them. And therefore copyright didn't really take any freedom away from the
reading public. There wasn't anything that a book purchaser could do that
was forbidden by copyright.
But this isn't true for computer programs. It's also not true for tape
cassettes. It's partly false now for books, but it is still true that for
most books it is more expensive and certainly a lot more work to Xerox them
than to buy a copy, and the result is still less attractive. Right now we
are in a period where the situation that made copyright harmless and
acceptable is changing to a situation where copyright will become
destructive and intolerable. So the people who are slandered as "pirates"
are in fact the people who are trying to do something useful that they have
been forbidden to do. The copyright laws are entirely designed to help
people take complete control over the use of some information for their own
good. But they aren't designed to help people who want to make sure that
the information is accessible to the public and stop others from depriving
the public. I think that the law should recognize a class of works that are
owned by the public, which is different from public domain in the same
sense that a public park is different from something found in a garbage
can. It's not there for anybody to take away, it's there for everyone to
use but for no one to impede. Anybody in the public who finds himself being
deprived of the derivative work of something owned by the public should be
able to sue about it.
BYTE: But aren't pirates interested in getting copies of programs because
they want to use those programs, not because they want to use that
knowledge to produce something better?
Stallman: I don't see that that's the important distinction. More people
using a program means that the program contributes more to society. You
have a loaf of bread that could be eaten either once or a million times.
BYTE: Some users buy commercial software to obtain support. How does your
distribution scheme provide support?
Stallman: I suspect that those users are misled and are not thinking
clearly. It is certainly useful to have support, but when they start
thinking about how that has something to do with selling software or with
the software being proprietary, at that point they are confusing
themselves. There is no guarantee that proprietary software will receive
good support. Simply because sellers say that they provide support, that
doesn't mean it will be any good. And they may go out of business. In fact,
people think that GNU EMACS has better support than commercial EMACSes. One
of the reasons is that I'm probably a better hacker than the people who
wrote the other EMACSes, but the other reason is that everyone has sources
and there are so many people interested in figuring out how to do things
with it that you don't have to get your support from me. Even just the free
support that consists of my fixing bugs people report to me and
incorporating that in the next release has given people a good level of
support. You can always hire somebody to solve a problem for you, and when
the software is free you have a competitive market for the support. You can
hire anybody. I distribute a service list with EMACS, a list of people's
names and phone numbers and what they charge to provide support.
BYTE: Do you collect their bug fixes?
Stallman: Well, they send them to me. I asked all the people who wanted to
be listed to promise that they would never ask any of their customers to
keep secret whatever they were told or any changes they were given to the
GNU software as part of that support.
BYTE: So you can't have people competing to provide support based on their
knowing the solution to some problem that somebody else doesn't know.
Stallman: No. They can compete based on their being clever and more likely
to find the solution to your problem, or their already understanding more
of the common problems, or knowing better how to explain to you what you
should do. These are all ways they can compete. They can try to do better,
but they cannot actively impede their competitors.
BYTE: I suppose it's like buying a car. You're not forced to go back to the
original manufacturer for support or continued maintenance.
Stallman: Or buying a house--what would it be like if the only person who
could ever fix problems with your house was the contractor who built it
originally? That is the kind of imposition that's involved in proprietary
software. People tell me about a problem that happens in UNIX. Because
manufacturers sell improved versions of UNIX, they tend to collect fixes
and not give them out except in binaries. The result is that the bugs don't
really get fixed.
BYTE: They're all duplicating effort trying to solve bugs independently.
Stallman: Yes. Here is another point that helps put the problem of
proprietary information in a social perspective. Think about the liability
insurance crisis. In order to get any compensation from society, an injured
person has to hire a lawyer and split the money with that lawyer. This is a
stupid and inefficient way of helping out people who are victims of
accidents. And consider all the time that people put into hustling to take
business away from their competition. Think of the pens that are packaged
in large cardboard packages that cost more than the pen--just to make sure
that the pen isn't stolen. Wouldn't it be better if we just put free pens
on every street corner? And think of all the toll booths that impede the
flow of traffic. It's a gigantic social phenomenon. People find ways of
getting money by impeding society. Once they can impede society, they can
be paid to leave people alone. The waste inherent in owning information
will become more and more important and will ultimately make the difference
between the utopia in which nobody really has to work for a living because
it's all done by robots and a world just like ours where everyone spends
much time replicating what the next fellow is doing.
BYTE: Like typing in copyright notices on the software.
Stallman: More like policing everyone to make sure that they don't have
forbidden copies of anything and duplicating all the work people have
already done because it is proprietary.
BYTE: A cynic might wonder how you earn your living.
Stallman: From consulting. When I do consulting, I always reserve the right
to give away what I wrote for the consulting job. Also, I could be making
my living by mailing copies of the free software that I wrote and some that
other people wrote. Lots of people send in $150 for GNU EMACS, but now this
money goes to the Free Software Foundation that I started. The foundation
doesn't pay me a salary because it would be a conflict of interest.
Instead, it hires other people to work on GNU. As long as I can go on
making a living by consulting I think that's the best way.
BYTE: What is currently included in the official GNU distribution tape?
Stallman: Right now the tape contains GNU EMACS (one version fits all
computers); Bison, a program that replaces YACC; MIT Scheme, which is
Professor Sussman's super-simplified dialect of LISP; and Hack, a
dungeon-exploring game similar to Rogue.
BYTE: Does the printed manual come with the tape as well?
Stallman: No. Printed manuals cost $15 each or copy them yourself. Copy
this interview and share it, too.
BYTE: How can you get a copy of that?
Stallman: Write to the Free Software Foundation, 675 Massachusetts Ave.,
Cambridge, MA 02139.
BYTE: What are you going to do when you are done with the GNU system?
Stallman: I'm not sure. Sometimes I think that what I'll go on to do is the
same thing in other areas of software.
BYTE: So this is just the first of a whole series of assaults on the
software industry?
Stallman: I hope so. But perhaps what I'll do is just live a life of ease
working a little bit of the time just to live. I don't have to live
expensively. The rest of the time I can find interesting people to hang
around with or learn to do things that I don't know how to do.
Editorial Note: BYTE holds the right to provide this interview on BIX but
will not interfere with its distribution.
Richard Stallman, 545 Technology Square, Room 703, Cambridge, MA 02139.
Copyright (C) 1986 Richard Stallman. Permission is granted to make and
distribute copies of this article as long as the copyright and this notice
appear on all copies.

77
etc/LEDIT Normal file
View file

@ -0,0 +1,77 @@
Date: 17 Apr 85 15:45:42 EST (Wed)
From: Martin David Connor <mdc@MIT-HTVAX.ARPA>
Date: Sat, 13 Apr 85 16:28:15 est
From: Richard M. Stallman <rms@mit-prep>
Can you help this person? Also, can you give me the rest of ledit
to distribute, plus some info on how to use it?
I have put the files "ledit.l" and "leditcfns.c" on prep:~mdc.
Much to my disgust ledit.l relied on some bogus little package of
functions on HT, so I had to massage it a bit.
To get it to work, one must:
- Compile leditcfns.c with something like:
cc leditcfns.c
- Edit ledit.l, changing the line beginning "(cfasl" to
have the right pathname for the cfns file you compiled in
the last step.
- Compile ledit.l with:
liszt ledit.l
Then put the following lines in your .lisprc file:
;load in functions for emacs interface
(load "//src//mdc//ledit//ledit") ; Location of Ledit library
(set-proc-str "%gnumacs") ; Name of editor
Then you can use ^E <RETURN> to get from LISP back to gnumacs.
Here is the part of my .emacs file that pertains to ledit.
;;; Set up ledit mode
(setq ledit-go-to-lisp-string "%lisp")
(setq lisp-mode-hook 'ledit-from-lisp-mode)
Date: Sat, 13 Apr 85 11:26:32 cst
From: neves@wisc-ai.arpa (David Neves)
This is a documentation question.
I cannot figure out how to use Ledit. I suspect I need some
function on the Franz Lisp end of things to go to Emacs and read in
the temporary file. Is this true? Is the Lisp job started within
Emacs or outside of emacs? I'm just plain confused. Perhaps a couple
of words from someone in the know would help.
A related question. I have been using a shell buffer when interacting
with Lisp (ie. put a definition in the kill buffer and then yank it
into the shell buffer to redefine it). This is nice but tends to fill
up the shell buffer with lots of code (I'd rather keep calls to functions
in the shell and not the functions themselves).
My question: Is using the shell buffer "better" than ledit? Am I using
it in the best way (i.e. copying definitions from an edit buffer to the
shell buffer)? -Thanks, David Neves
I have found that ledit works well for doing programming development
when you are changing lots of little pieces of a file and don't wish
to recompile the whole file. Of course M-X Compile is very nice for
calling up a liszt on a buffer and watching it in the another window.
Of course the interface of something like NIL is even better because
you can compile your function directly into your lisp. But since NIL
doesn't run under Unix, this is probably the next best thing.
I have tried the 2 window method (shell in lower window, lisp code in
upper), and have found it a little awkward. It does have certain
advantages, but most of the time, I get be fine using M-C-D to save a
defun for lisp, and C-X Z to jump back to LISP. C-E RETURN from lisp
is also mnemonic for getting back to gnumacs.
I hope this helps somewhat.

122
etc/LPF Normal file
View file

@ -0,0 +1,122 @@
Protect Your Freedom to Write Programs
Join the League for Programming Freedom
(Version of January 15, 1991)
Ten years ago, programmers were allowed to write programs using all
the techniques they knew, and providing whatever features they felt
were useful. This is no longer the case. The new monopolies,
software patents and interface copyrights, have taken away our
freedom of expression and our ability to do a good job.
"Look and feel" lawsuits attempt to monopolize well-known command
languages; some have succeeded. Copyrights on command languages
enforce gratuitous incompatibility, close opportunities for
competition, and stifle incremental improvements.
Software patents are even more dangerous; they make every design
decision in the development of a program carry a risk of a lawsuit,
with draconian pretrial seizure. It is difficult and expensive to
find out whether the techniques you consider using are patented; it is
impossible to find out whether they will be patented in the future.
The League for Programming Freedom is a grass-roots organization of
professors, students, businessmen, programmers and users dedicated to
bringing back the freedom to write programs. The League is not
opposed to the legal system that Congress intended--copyright on
individual programs. Our aim is to reverse the recent changes made by
judges in response to special interests, often explicitly rejecting
the public interest principles of the Constitution.
The League works to abolish the new monopolies by publishing articles,
talking with public officials, boycotting egregious offenders, and in
the future may intervene in court cases. On May 24, 1989, the League
picketed Lotus headquarters on account of their lawsuits, and then
again on August 2, 1990. These marches stimulated widespread media
coverage for the issue. We welcome suggestions for other activities,
as well as help in carrying them out.
Membership dues in the League are $42 per year for programmers,
managers and professionals; $10.50 for students; $21 for others.
Please give more if you can. The League's funds will be used for
filing briefs; for printing handouts, buttons and signs; whatever will
persuade the courts, the legislators, and the people. You may not get
anything personally for your dues--except for the freedom to write
programs. The League is a non-profit corporation, but not considered
a tax-exempt charity. However, for those self-employed in software,
the dues can be a business expense.
The League needs both activist members and members who only pay their
dues. We also greatly need additional corporate members; contact us
for information.
If you have any questions, please write to the League or phone
(617) 243-4091. Or send Internet mail to league@prep.ai.mit.edu.
Jack Larsen, President
Chris Hofstader, Secretary
Steve Sisak, Treasurer
Jack Larsen can be contacted at (708) 698-1160; Fax (708) 698-6221.
To join, please send a check and the following information to:
League for Programming Freedom
1 Kendall Square #143
P.O.Box 9171
Cambridge, Massachusetts 02139
(Outside the US, please send a check in US dollars on a bank
having a US correspondant bank, to save us check cashing fees.)
Your name:
The address for League mailings (a few each year):
The company you work for, and your position:
Your phone numbers (home, work or both):
Your email address, so we can contact you for demonstrations or for
writing letters. (If you don't want us to contact you for these
things, please say so, but please give us your email address anyway.)
Is there anything about you which would enable your endorsement of the
LPF to impress the public? For example, if you are or have been a
professor or an executive, or have written software that has a good
reputation, please tell us.
Would you like to help with LPF activities?
The corporate charter of the League for Programming Freedom states:
The purpose of the corporation is to engage in the following
activities:
1. To determine the existence of, and warn the public about
restrictions and monopolies on classes of computer programs where such
monopolies prevent or restrict the right to develop certain types of
computer programs.
2. To develop countermeasures and initiatives, in the public interest,
effective to block or otherwise prevent or restrain such monopolistic
activities including education, research, publications, public
assembly, legislative testimony, and intervention in court proceedings
involving public interest issues (as a friend of the court).
3. To engage in any business or other activity in service of and
related to the foregoing paragraphs that lawfully may be carried on
by a corporation organized under Chapter 180 of the Massachusetts
General Laws.
The officers and directors of the League will be elected annually by
the members.

448
etc/MACHINES
View file

@ -1,5 +1,5 @@
This is a list of the status of GNU Emacs on various machines and systems.
Last updated 27 December 1990.
Last updated 18 Oct 1992.
Systems:
For each type of system, the name of the appropriate s- header file
@ -21,6 +21,10 @@ Microport
See under "Intel 386".
Solaris (s-sol2.h)
Changes merged, and may work.
System V rel 0 (s-usg5-0.h)
Works, on Vaxes and 3bxxx's.
@ -41,6 +45,9 @@ System V rel 2 (s-usg5-2.h)
and make it store 7 there. I have as yet no evidence of whether
this problem, known in HP-UX, exists in other system V versions.
If you are compiling to work with X11 release 4, you may need
to define HAVE_RANDOM in config.h.
System V rel 2.2 (s-usg5-2-2.h)
In 5.2.2 AT&T undid, incompatibly, their previous incompatible
@ -54,31 +61,50 @@ System V rel 2.2 (s-usg5-2-2.h)
NO_REMAP. It is not yet known whether this applies to all
machines running 5.2.2.
If you are compiling to work with X11 release 4, you may need
to define HAVE_RANDOM in config.h.
System V rel 3 (s-usg5-3.h)
Some versions of this system support ptys and BSD-style sockets.
On such systems, you should define HAVE_PTYS and HAVE_SOCKETS in config.h.
If you are compiling to work with X11 release 4, you may need
to define HAVE_RANDOM in config.h.
If you want to link Emacs with shared libraries, define
USG_SHARED_LIBRARIES.
System V rel 4 (s-usg5-4.h)
Supported, including shared libraries for ELF, but ptys do not
work because TIOCGPGRP fails to work on ptys.
This failure is probably due to a misunderstanding of the
consequences of the POSIX spec: many system designers mistakenly
think that POSIX requires this feature to fail. This is untrue;
ptys are an extension, and POSIX says that extensions *when used*
may change the action of standard facilities in any fashion.
Supported, including shared libraries for ELF. pty's work now.
The standard C preprocessor generate xmakefile incorrectly. However,
/lib/cpp will work, so use `make CPP=/lib/cpp'.
The standard C preprocessor generates xmakefile incorrectly. However,
/lib/cpp will work, so use `make CPP=/lib/cpp' in the `src' subdirectory.
Ultrix (s-bsd4-2.h)
Versions 3 and earlier of V.4, on the Intel 386 and 860, had
problems in the X11 libraries. These prevent Emacs from working
with X. You can use Emacs with X provided your copy of X is based
on X11 release 4 or newer. Unfortunately, the only way you can tell
for certain whether your X11 library is new enough is to try
compiling Emacs to use X. If xemacs runs, your X11 library is new
enough.
DEC's Ultrix OS is essentially Berkeley 4.2. It does not correctly
implement certain features of 4.3.
In this context, GSV4 and GSV4i are alternate names for X11R4.
OL2.* is X11R3 based. OL3 is in between X11R3 and X11R4, and may or
may not work, depending on who made the Unix system. If the library
libXol is part of the X distribution, then you have X11R3 and Emacs
won't work with X.
Most versions of V.4 support sockets. If `/usr/lib/libsocket.so'
exists, your system supports them. If yours does not, you must add
#undef HAVE_SOCKETS in config.h, aftern the inclusion of s-usg5-4.h.
(Any system that supports Internet should implement sockets.)
Ultrix (s-bsd4-3.h)
Recent versions of Ultrix appear to support the features of Berkeley 4.3.
Ultrix was at the BSD 4.2 level for a long time after BSD 4.3 came out.
Ultrix 3.0 has incompatibilities in its X library if you have the
Ultrix version of X (UWS version 2.0). To solve them, you need to
@ -96,16 +122,19 @@ Ultrix (s-bsd4-2.h)
The problem is said to be gone in UWS version 2.1.
Ultrix 4.1 has moved the file X11/X10.h into mit/X11/X10.h.
Uniplus 5.2 (s-unipl5-2.h)
Works, on Dual machines at least.
VMS (s-vms.h)
VMS (s-vms4-0.h, s-vms4-2.h, s-vms4-4.h, s-vms5-5.h)
Works except for certain features (directory listing, dired,
sending and receiving mail) that use synchronous subprocesses.
We need people to write alternative implementations of these
facilities.
(These will work in Emacs 19.)
s-vms5-5.h may be right for some earlier versions; please let us know
what happens when you try it in VMS versions 5.0 thru 5.4.
Note that Emacs for VMS is usually distributed in a special
VMS distribution. See the file ../VMSINSTALL for info on moving
@ -128,27 +157,36 @@ Machines:
For each type of machine, the names of the m- and s- header files
are given.
Alliant (m-alliant4.h or m-alliant.h or m-alliant1.h; s-bsd4-2.h)
Alliant FX/80 (m-alliant4.h or m-alliant.h or m-alliant1.h;
s-bsd4-2.h or s-bsd4-3.h)
18.52 works on system version 4. Previous Emacs versions were
There are reports of bugs in the Alliant compiler
that prevent compiling Emacs 18.57.
No word on how to get around them. Perhaps using GCC will work.
A work-around is installed in src/dispnew.c in 18.58 for a compiler bug.
18.52 worked on system version 4. Previous Emacs versions were
known to work on previous system versions.
Use m-alliant1.h on version 1 of their operating system
and use m-alliant.h on version 2 or 3.
Use m-alliant4.h on version 4.
Use m-alliant4.h on version 4 and above.
Use s-bsd4-3.h with system version 5 and above.
Alliant FX/2800 (m-all2800.h; s-bsd4-3.h)
Known to work with 18.58 and OS version 2.2, compiler version 1.3.
Altos 3068 (m-altos.h; s-usg5-2.h)
18.52 is said to work, provided you don't compile unexec.c with -O.
Amdahl UTS (m-amdahl.h; s-usg5-2-2.h)
Amdahl UTS (m-amdahl.h; s-usg5-3.h)
Small changes for 18.38 were merged in 18.39. It is mostly
working, but at last report a bug sometimes causes Emacs to
grab very large amounts of memory. No fix or explanation
has yet been reported. It may be possible to find this bug
if you find which Emacs command it happens within and then
run that command with a breakpoint set at malloc.
Support for a newer system version, and X Windows, merged in 18.58.
(Some people report that s-usg5-2.h worked better than s-usg5-3.h
for 18.57.)
The 5.2u370 compiler is so brain damaged that it is not
even worth trying to use it. Success was obtained with the
@ -161,7 +199,7 @@ Apollo running Domain (m-apollo.h; s-bsd4-2.h)
distribute it yet.
There are reports of bugs in cc -O on this system.
In etc/Makefile, don't expect emacsclient and emacsserver to
In etc/Makefile, don't expect emacsclient and server to
compile. You might want to remove them from your makefile.
Supposedly something in dired.c runs into a compiler bug.
@ -199,9 +237,19 @@ AT&T 7300 or 3b1 (m-7300.h; s-usg5-2-2.h)
older than 3.5 did not support long symbol names. Version 3.5 does
support them, so you can remove the #define SHORTNAMES in that version.
Bull sps7 (m-sps7.h; s-usg5-2.h)
Aviion (m-aviion.h; s-dgux.h)
Changes partially merged in version 19, but some fixes are probably required.
Changes merged in 18.58.
Bull DPX/2 models 2nn or 3nn (m-dpx2-200.h or m-dpx2-300.h; s-usg5-3.h)
Should work in 18.58 except that there is a report of
Emacs terminating mysteriously if run in the background
using its own X window and the invoking process
terminates.
Be sure to read m-dpx2.h for instructions as to how to deal
with optional packages such as INET and X Windows.
CCI 5/32, 6/32
@ -211,35 +259,30 @@ Celerity (m-celerity.h; s-bsd4-2.h)
Version 18.49 works.
Clipper (m-clipper.h; ???)
Version 19 has support for some brand of clipper system.
Note that the Orion 105 is also a clipper, but some system-related
parameters are different.
Convex (m-convex.h; s-bsd4-3.h)
18.53 is supposed to work.
Cubix QBx/386 (m-intel386.h; s-usg5-3.h)
Changes merged in 19.1. Systems before 2/A/0 may fail to compile etags.c
due to a compiler bug.
18.58 works.
Use "make CC='cc -pcc'" to avoid problems creating ymakefile from xmakefile.
Cydra 5 (m-cydra5.h; s-usg5-3.h)
18.51 worked in one version of their operating system but stopped
working in a newer version. This has not been fixed.
DECstation (m-pmax.h; s-bsd4-2.h)
Data General
Works, as of 18.55. See under Ultrix for problems using X windows
See aviion.
DECstation (m-pmax.h; s-bsd4-3.h or s-osf1.h)
OSF1 support merged in 18.59.
See under Ultrix for problems using X windows
on Ultrix. Note that this is a MIPS machine.
s-bsd4-3.h is said to work ok with Ultrix 4.1.
Delta (m-delta.h; s-usg5-3.h)
Motorola Delta boxes running System V/68 release 3.
(tested on sys1147 with SVR3V5). Changes merged in 19.1.
For Ultrix versions prior to 4.0, you may need to delete
the definition of START_FILES from m-pmax.h.
Dual running System V (m-dual.h; s-usg5-2.h)
@ -252,8 +295,13 @@ Dual running Uniplus (m-dual.h; s-unipl5-2.h)
Elxsi 6400 (m-elxsi; s-usg5-2.h)
Changes for 12.0 release are in 19.1.
Dumping should work now.
18.36 required one small change that's installed in 18.38.
m-elxsi.h currenty specifies CANNOT_DUMP.
The Elxsi can in principle dump, but the necessary changes to
unexec, which involve byte-swapping, were too ugly to install.
If someone submits simple code that supports dumping on the Elxsi,
it can be installed and CANNOT_DUMP can be turned off.
Encore machine (m-ns16000.h; s-umax.h)
@ -269,12 +317,16 @@ Encore machine (m-ns16000.h; s-umax.h)
A kernel bug in some system versions causes input characters to be lost
occasionally.
Encore running MACH.
This does not yet work.
GEC 93 (m-gec93.h; s-usg5-2.h?)
Changes are partially merged in version 18, but
certainly require more work.
Gould Power Node (m-gould.h; s-bsd4-2.h or s-bsd4-3.h)
Gould (m-gould.h; s-bsd4-2.h or s-bsd4-3.h)
18.36 worked on versions 1.2 and 2.0 of the operating system.
@ -287,26 +339,24 @@ Gould Power Node (m-gould.h; s-bsd4-2.h or s-bsd4-3.h)
UTX/32 1.3 has a bug in the bcopy library routine. Fix it by
#undef BSTRING in m-gould.h.
Version 19 incorporates support for releases 2.1 and later of UTX/32.
A site running a pre-release of 2.1 should #define RELEASE2_1 in config.h.
Gould NP1 (m-gould-np1.h; s-bsd4-3.h)
Version 19 supposedly works.
Honeywell XPS100 (m-xps100.h; s-usg5-2.h)
Config file added in version 19.
HP 9000 series 200 or 300 (m-hp9000s300.h; s-hpux.h or s-bsd4-3.h)
HP 9000 series 200 or 300 (m-hp9000s300.h; s-hpux7.h, s-hpux8.h or s-bsd4-3.h)
Version 18 works.
These machines are 68000-series CPUs running HP-UX
(a derivative of sysV with some BSD features) or BSD 4.3 ported by Utah.
The choice of s- file determines which system Emacs is built for.
If you are running HP-UX release 8.0 or later, you need the optional
"C/ANSI C" software in order to build Emacs (older releases of HP-UX
do not require any special software). If the file "/etc/filesets/C"
exists on your machine, you have this software, otherwise you do not.
Series 200 HPUX runs Emacs only if it has the "HP-UX upgrade".
The series 500 has a seriously incompatible memory architecture
which relocates data in memory during execution of a program,
and support for it would be difficult to implement.
Note that HP has used two incompatible assembler syntaxes,
and has recently changed the format of C function frames.
src/crt0.c and src/alloca.s have been conditionalised for the new
@ -328,21 +378,28 @@ HP 9000 series 200 or 300 (m-hp9000s300.h; s-hpux.h or s-bsd4-3.h)
that include the `netunam' system call. This is refered to as
Network Services (NS/9000) in HP literature.
HP 9000 series 300 running BSD 4.3 (m-hp300bsd.h; s-bsd4-3.h)
If you are compiling to work with X11 release 4, you may need
to define HAVE_RANDOM in config.h.
Version 18.55 works.
HP 9000 series 500: not supported.
The series 500 has a seriously incompatible memory architecture
which relocates data in memory during execution of a program,
and support for it would be difficult to implement.
HP 9000 series 800 (Spectrum) (m-hp9000s800.h; s-hpux.h)
HP 9000 series 700 or 800 (Spectrum) (m-hp9000s800.h; s-hpux7.h or s-hpux8.h)
These files support HP's Precision Architecture machines
running HP-UX. It has been moderately tested on the Series
840.
running HP-UX. Version 18.58 should work on the 700 and the 800.
Use s-hpux7.h for HPUX version 7 or earlier,
and s-hpux8.h for HPUX version 8.
If you are running HP-UX release 8.0 or later, you need the optional
"C/ANSI C" software in order to build Emacs (older releases of HP-UX
do not require any special software). If the file "/etc/filesets/C"
exists on your machine, you have this software, otherwise you do not.
HAVE_X_MENU works, but you may need to modify oldXMenu/Makefile
to compile insque.c.
If you compile with MIT's X11R5, rather than HP's version,
then you may need to add the following to config.h:
#define srandom srand
#define random rand
High Level Hardware Orion (m-orion.h; s-bsd4-2.h)
@ -352,30 +409,34 @@ High Level Hardware Orion (m-orion.h; s-bsd4-2.h)
High Level Hardware Orion 1/05 (m-orion105.h; s-bsd4-2.h)
Changes merged in 18.52. This is the one with the Clipper cpu.
Note that systems which lack NFS need LOAD_AVE_TYPE changed to `double'.
Note that systems which lack NFS may need LOAD_AVE_TYPE changed to `double'.
C compiler has a bug; it loops compiling eval.c.
Compile it by hand without optimization.
In 18.58, trouble was reported with X windows: XrmGetResource was
reported undefined in the library. You may need to change
XT_GetDefaults in x11term.c to make it link. If so, please
send a bug report saying exactly what change was needed.
IBM PS/2 (m-ibmps2-aix.h; s-usg5-2-2.h)
IBM PS2 (m-ibmps2-aix.h; s-usg5-2-2.h or s-usg5-3.h)
Changes merged in version 19. You may need to copy
Changes mostly merged in 18.55. You may need to put an #ifndef AIX
conditional around the definition of closedir in sysdep.c, and
perhaps delete the #include of sioctl.h. You may need to copy
/usr/lib/samples/hft/hftctl.c to the Emacs src directory.
IBM RS/6000 (m-ibmrs6000.h; s-aix3-1.h)
Use s-usg5-3.h on AIX 1.2.
s-usg5-2-2.h should work on either AIX 1.1 or 1.2, but may not work with
certain new X window managers, and may be suboptimal.
Changes merged in version 19.
IBM RS/6000 (m-ibmrs6000.h; s-aix3-1.h or s-aix3-2.h)
Dumping does not work. Code has been written to implement it, but
it fails because the address of bss seems to vary occasionally
between Emacs runs. It does not seem to vary from minute to minute,
but every few days or weeks it changes to a new steady state.
When this happens, the dumped Emacs data file becomes invalid.
Changes merged in 18.56. Note that for installation on AIX you must
use `make install.aix' rather than just `make'. Use s-aix3-2.h
on AIX 3.2 also.
IBM RT/PC (m-ibmrt.h or m-ibmrt-aix.h; s-bsd4-2.h or s-usg5-2-2.h)
IBM RT/PC (m-ibmrt.h or m-ibmrt-aix.h; s-bsd4-3.h or s-usg5-2-2.h)
18.52 works on both operating systems.
Use s-bsd-4-2.h for the 4.2-like system and s-usg5-2-2.h for AIX.
Use s-bsd-4-3.h for the 4.3-like system AOS, and s-usg5-2-2.h for AIX.
On BSD, if you have trouble, try compiling with a different compiler.
@ -401,10 +462,27 @@ Integrated Solutions `Optimum V' (m-isi-ov.h; s-bsd4-2.h or s-bsd4-3.h)
in a system header file, which confuses Emacs (which thinks that UMAX
indicates the Umax operating system).
Intel 80386 (m-intel386.h or m-is386.h; s-bsd4-2.h, s-usg5-2-2.h, s-usg5-3.h,
s-386-ix.h, s-esix.h or s-xenix.h)
Integrated Solutions 386 (m-is386.h; ??)
Configuration file present in 18.57.
Intel 80386 (m-intel386.h; s-bsd4-2.h, s-usg5-2-2.h, s-usg5-3.h, s-esix.h,
s-386ix.h, s-isc2-2.h, s-isc3-0.h, s-sco3-2-2.h, s-sco3-2-4.h,
or s-xenix.h)
18.59 should support a wide variety of operating systems.
Use s-isc2-2.h for Interactive 386/ix version 2.2
and s-isc3-0.h for versions 3.0 and 3.2.
Use s-386ix.h for prior versions.
Use s-esix.h for Esix.
Use s-sco3-2-4.h for version 3.2.4, and s-sco3-2-2.h for version 3.2.2
(but it only makes a difference if you compile Emacs for X windows).
You may have to compile the cpp that comes with Emacs
and use that to preprocess src/ymakefile to get src/xmakefile.
s-sco3-2-1.h may work on SCO 3.2.1, but see the instructions in
that file for other changes you need to make.
Changes merged in 18.50 for all three operating systems.
If you are using Xenix, see notes above under Xenix.
Some sysV.3 systems seem to have bugs in `opendir';
@ -412,11 +490,20 @@ Intel 80386 (m-intel386.h or m-is386.h; s-bsd4-2.h, s-usg5-2-2.h, s-usg5-3.h,
and undefine SYSV_SYSTEM_DIR.
If you use optimization on V.3, you may need the option -W2,'-y 0'
to prevent certain faulty optimization.
to prevent certain faulty optimization. Otherwise, fns.c won't work.
On 386/ix, to link with shared libraries, add #define USG_SHARED_LIBRARIES
to config.h.
On one V.4 system, it was necessary to define LIBS_TERMCAP as -ltermcap.
Versions 3 and earlier of V.4 supposedly have problems
in the X11 libraries that prevent Emacs from working with X.
Version 4 of V.4 is said to have fixed this problem. See the
entry for System V Release 4, above. Similar problems occur on
SCO systems and perhaps also on ISC systems. There is no known
remedy except to get a different system.
There is no consistency in the handling of certain system header files
on V.3.
@ -436,35 +523,35 @@ Intel 80386 (m-intel386.h or m-is386.h; s-bsd4-2.h, s-usg5-2-2.h, s-usg5-3.h,
Some versions convince sysdep.c to try to use `struct tchars'
but define `struct tc' instead; add `#define tchars tc'
to config.h to solve this problem.
Some systems have problems that can be solved by inserting
#undef TIOCGETC
in sysdep.c, near the place where this is done for XENIX.
The file m-is386.h is used for an Integrated Solutions 386 machine.
It may also be correct for Microport systems.
Intel 860 (m-intel860.h; s-usg5-4.h)
Iris 2500 (m-irist.h; s-iris3-5.h or s-iris3-6.h)
Supposed to work in 18.58. See the notes for System V Release 4,
above, for notes on using X windows and using sockets.
Version 18 said to work; use s-irist3-5.h for system version 2.5
and s-iris3-6.h for system version 3.6.
Iris 4D (m-iris4d.h; s-irix3-3.h or s-irix4-0.h)
18.58 is known to work on Silicon Graphics 4D series machines
with IRIX 3.3 or IRIX 4.0.
Most irix3.3 systems do not have an ANSI C compiler, but a few do.
If you are using the ANSI C compiler, you may need to add
#define C_SWITCH_MACHINE -cckr
to config.h.
There is a bug in IRIX that can sometimes leave ptys owned by
root with a permission of 622. This causes malfunctions in use
of subprocesses of Emacs. This may be fixed in IRIX 4.0.5.
Iris 2500 Turbo (m-irist.h; s-iris3-5.h or s-iris3-6.h)
18.49 works. Use s-iris3-6.h for system versions 3.6 and up.
s-iris3-5.h is said to work with system version 2.5.
Note that the 3030 is the same machine as this.
Iris 4D (m-iris4d.h; s-iris3-6.h or s-irix3-3.h)
18.56 is known to work on 4D series machines with Irix 3.3 or later.
If you use the X menu facility, you must edit oldXmenu/Makefile
to add the line
RANLIB=true
Someone says that with the yellow pages you must change two definitions
in m-iris4d.h as follows:
#define LIBS_MACHINE -lsun -lbsd -lPW -lmld
#define C_SWITCH_MACHINE -I/usr/include/sun -I/usr/include/bsd
Macintosh
We are boycotting Apple because of Apple's efforts to take away
@ -505,10 +592,35 @@ Mips (m-mips.h or m-mips4.h; s-usg5-2-2.h, s-bsd4-3.h)
Use m-mips4.h for RISCOS version 4; use s-bsd4-3.h with the BSD world.
Motorola Delta (m-delta.h; s-usg5-3.h)
If you are compiling with GCC, then you must run fixincludes;
the alternative of using -traditional won't work because
the definition of SIGN_EXTEND_CHAR uses the keyword `signed'.
If the SYSV world is the default, then you probably need the following
line in etc/Makefile:
CFLAGS= -g -systype bsd43
Some operating systems on MIPS machines give SIGTRAP for division by
zero instead of the usual signals. The only real solution is to fix
the system to give a proper signal.
In the meantime, you can change init_data in data.c if you wish.
Change it to handle SIGTRAP as well as SIGFPE. But this will have a
great disadvantage: you will not be able to run Emacs under a
debugger. I think crashing on division by zero is a lesser problem.
Note that the proper m- file for the Decstation is m-pmax.h.
Motorola Delta 147 (m-delta.h; s-usg5-3.h)
m- file added in version 18.56.
Motorola Delta 187 (m-delta88k.h; s-usg5-3.h)
m- file added in version 18.58.
HAVE_X_MENU may work if you modify oldXMenu/Makefile to compile insque.c.
National Semiconductor 32000 (m-ns32000.h; s-usg5-2.h)
This is for a complete machine from National Semiconductor,
@ -528,31 +640,46 @@ NCR Tower 32 running System V release 3 (m-tower32v3.h; s-usg5-3.h)
C_OPTIMIZE_SWITCH rather than C_DEBUG_SWITCH, and do not use gcc, check
out the comments in src/m-tower32v3.h about this.
NeXT (m-next.h; s-mach2.h)
Changes merged in 18.59.
Nixdorf Targon 31 (m-targon31.h; s-usg5-2-2.h)
m- file for version 17 is included in 18
but whether it works is not known.
src/unexec.c bombs if compiled with -O.
Changes merged in 18.56 may work.
It may be necessary to define C_ALLOCA in m-targon31.h
and it may be necessary to remove alloca from libc.a.
(The alloca in libc.a is said to be broken.)
Please report to the Foundation what works.
Note that the "Targon 35" is really a Pyramid.
Nu (TI or LMI) (m-nu.h; s-usg5-2.h)
Version 18 is believed to work.
pfa50 (m-pfa50.h; s-usg5-3.h)
Changes mostly merged in 18.59.
Plexus (m-plexus.h; s-usg5-2.h)
Works as of 17.56.
Pmax (DEC Mips) (m-pmax.h; s-bsd4-2.h)
Pmax, Mips from DEC (m-pmax.h; s-bsd4-2.h)
See under DECstation, above.
Prime EXL (m-intel386.h; s-usg5-3.h)
Minor changes merged in 19.1.
18.54 should work.
Pyramid (m-pyramid.h; s-bsd4-2.h)
18.58 seems to work on the MIServer 2/1T under OSx 5.1-910507.
You need to build Emacs in the Berkeley universe with
the `ucb' command, as in `ucb make' or `ucb build-install'.
In OSx 4.0, it seems necessary to add the following two lines
to m-pyramid.h:
#define _longjmp longjmp
@ -571,14 +698,20 @@ Pyramid (m-pyramid.h; s-bsd4-2.h)
Some old system versions may require you to define PYRAMID_OLD
in when alloca.s is preprocessed, in order to define _longjmp and _setjmp.
Sequent Balance (m-sequent.h; s-bsd4-2.h, or s-bsd4-3.h on newer systems)
Pyramid MIPS systems (m-pyrmips.h; s-usg5-4.h)
Emacs 18.51 should work on system version 3.0. 18.52 is said to work.
Delete some lines at the end of m-sequent.h for earlier system versions.
Changes merged in 18.59; may work. Dumping is not supported.
Use CPP=/usr/ccs/lib/cpp when running make in src.
Sequent Symmetry (m-symmetry.h; s-bsd4-3.h)
Sequent Balance (m-sequent.h; s-bsd4-2.h)
Emacs 19 should work.
Emacs 18.51 should work on system version
3.0. 18.5[23] is said to work. Delete some lines at the end of
m-sequent.h for earlier system versions.
Sequent Symmetry (m-seq386.h; s-bsd4-2.h)
Changes merged in 18.59 for compiling with GCC.
SONY News (m-news.h; s-bsd4-2.h, or s-bsd4-3.h for system release 3)
@ -588,9 +721,12 @@ SONY News 3000 series (RISC NEWS) (m-news-risc.h; s-bsd4-3.h)
Works, as of 18.56. Note that this is a MIPS architecture machine.
Stardent 1500 or 3000
See Titan.
Some versions of the operating system give SIGTRAP for division by zero
instead of the usual signals. This causes division by zero
to make Emacs crash. The system should be fixed to give the proper signal.
Changing Emacs is not a proper solution, because it would prevent
Emacs from working under any debugger. But you can change init_data
in data.c if you wish.
Stride (m-stride.h; s-usg5-2.h)
@ -599,7 +735,8 @@ Stride (m-stride.h; s-usg5-2.h)
It may be possible to run on their V.1 system but changes
in the s- file would be needed.
Sun 1, 2 and 3 (m-sun1.h, m-sun2.h, m-sun3.h; s-bsd4-2.h or s-sunos4.h)
Sun 1, 2 and 3 (m-sun1.h, m-sun2.h, m-sun3.h;
s-bsd4-2.h, s-sunos4-0.h or s-sunos4-1.h)
There are three m- files for different versions of SunOS.
All are derived from Berkeley 4.2. Emacs 17 has run on all of them.
@ -607,14 +744,16 @@ Sun 1, 2 and 3 (m-sun1.h, m-sun2.h, m-sun3.h; s-bsd4-2.h or s-sunos4.h)
on the VERSION OF THE OPERATING SYSTEM you have.
You will need to use m-sun3.h on Sun 2's running SunOS release 3.
For SunOS release 4 on a Sun 3, use m-sun3.h and s-sunos4.h.
For SunOS release 4 on a Sun 2 or Sun 3, use m-sun3.h and s-sunos4-1.h.
(Use s-sunos4-0.h instead if using system version 4.0.*.)
See the file etc/SUNBUG for how to solve problems caused by bugs in
the "export" version of SunOS 4.
If you have trouble using open-network-stream, get the
distribution of `bind' (the BSD name-server), build libresolv.a,
and link Emacs with -lresolv. This problem is due to obsolete
software in the nonshared standard library.
If you get inappropriate "unknown host" errors from
open-network-stream, get the distribution of `bind' (the BSD
name-server), build libresolv.a, and link Emacs with -lresolv. This
problem is due to obsolete software in the nonshared standard
library.
If you want to use SunWindows, define HAVE_SUN_WINDOWS
in config.h to enable a special interface called `emacstool'.
@ -629,6 +768,11 @@ Sun 1, 2 and 3 (m-sun1.h, m-sun2.h, m-sun3.h; s-bsd4-2.h or s-sunos4.h)
compiled to use the 68881, then you must edit config.h according
the comments at the end of m-sun3.h.
It is advisable to add #define ForceNormalLib YES before building
X11R5, to force creation of a nonshared library (as well as the
shared X library). Emacs does not use shared libraries, so it
needs to have a nonshared X library in order to run with X.
Note that Emacs on a Sun is not really as big as it looks.
As dumped, it includes around 200k of zeros between the
original text section and the original data section
@ -638,20 +782,33 @@ Sun 1, 2 and 3 (m-sun1.h, m-sun2.h, m-sun3.h; s-bsd4-2.h or s-sunos4.h)
To build a single Emacs that will run on Sun 2 and Sun 3
HARDWARE, just build it on the Sun 2.
Sun 4 (m-sparc.h; s-bsd4-2.h or s-sunos4.h)
Sun 4 (m-sparc.h; s-bsd4-2.h or s-sunos4-0.h or s-sunos4-1.h or s-sol2.h)
Changes merged in 18.50. Some people say optimizing compilation
Works under Sunos 4; changes for Solaris 2 merged in Emacs 18.59.
You may need to use CPP=/usr/ucb/cc -E in src/Makefile on Solaris 2.
Some people have said optimizing compilation
does not work; some say that -O2 (whatever that is) works
perhaps with a small change.
Use s-sunos4.h for operating system version 4.
See the file etc/SUNBUG for how to solve problems caused by bugs in
the "export" version of SunOS 4.
See the entry above for the Sun 3; most of the information
applies to the Sun 4 as well.
Sun Roadrunner (m-sun386.h; s-sunos4.h)
Sun Roadrunner (m-sun386.h; s-sunos4-0.h)
Changes merged in 18.51.
Tadpole (m-tad68.h; s-usg5-3.h)
Changes merged in 18.58; minor fixes in 18.59.
You may need to edit Makefile to change the variables LIBDIR and
BINDIR from /usr/local to /usr/contrib.
To give movemail access to /usr/mail, you may need to execute
chmod 2755 etc/movemail; chgrp mail etc/movemail
Tahoe (m-tahoe.h; s-bsd4-2.h or s-bsd4-3.h)
18.52 known to work on some Tahoes, but a compiler bug intervenes
@ -672,15 +829,20 @@ Tektronix 16000 box (6130?) (m-ns16000.h; s-bsd4-2.h)
Emacs 17.61 worked.
Tektronix 4300 (m-tex4300.h; s-bsd4-3.h)
Tektronix 4300 (m-tek4300.h; s-bsd4-3.h)
Emacs 18.51 should work.
Emacs 18.58 should work.
Titan P2 or P3 (m-titan.h; s-usg5-3.h)
Depending on which linker you use, you might want to change
the value of TEXT_START in m-tek4300.h; though the native linker
does use zero, it is possible (and reasonable) to use a linker
that starts text elsewhere, like 0x2000.
Changes probably merged in version 19.
Triton 88 (m-triton88.h; s-usg5-3.h?)
Ustation E30 (SS5E) (m-ustation.h; s-unipl5-2.h).
Changes merged in 18.58.
Ustation E30 (SS5E) (m-ustation.h; s-unipl5-2.h)
Changes merged in 18.52; don't know whether they work.

743
etc/MAILINGLISTS Normal file
View file

@ -0,0 +1,743 @@
GNU Project Electronic Mailing Lists. Last Updated 23 Oct 91
Please report improvements to: gnu@prep.ai.mit.edu
* GNU mailing lists are also distributed as USENET news groups
The mailing lists are gated both ways with the gnu.all newsgroups at
ohio-state.edu. The one-to-one correspondence is indicated below. If
you don't know if your site is on USENET, ask your system administrator.
If you are a USENET site and don't get the gnu.all newsgroups, please
ask your USENET administrator to get them. If he has your feeds ask
their feeds, you should win. And everyone else wins: newsgroups make
better use of the limited bandwidth of the computer networks and your
home machine than mailing list traffic; and staying off the mailing
lists make better use of the people who maintain the lists and the
machines that the GNU people working with rms use (i.e. we have more
time to produce code!!). Thanx.
* Getting the mailing lists directly
If several users at your site or local network want to read a list and
you aren't a USENET site, Project GNU would prefer that you would set up
one address that redistributes locally. This reduces overhead on our
people and machines, your gateway machine, and the network(s) used to
transport the mail from us to you.
* How to subscribe to and report bugs in mailing lists
Send messages ABOUT these lists, such as reports of mail problems, or
requests to be added or removed, to help-gnu-emacs-request (or
info-gnu-request, bug-gdb-request, etc.), NOT to info-gnu-emacs (or
info-gnu, etc.). These <LIST_NAME>-request addresses go only to the
people who can do something about your requests or problems, and thus
avoids disturbing everyone else.
Note that all GNU mailing lists are maintained by volunteers. They get
behind occasionally. Wait at least 3 or 4 days before asking again.
Thanks!
Many of the GNU mailing lists are very large and are received by many
people. Please don't send them anything that is not seriously important
to all their readers. All GNU mailing lists are unmoderated, mail
reflectors, except info-gnu, info-gnu-emacs, info-gcc, info-g++ and
info-gnu-fortran.
All addresses below are in internet format. Consult the mail guru for
your computer to figure out address syntaxes from other networks. From
UUCP machines:
..!ucbvax!prep.ai.mit.edu!ADDRESS
..!uunet!prep.ai.mit.edu!ADDRESS
If a message you mail to a list is returned from a MAILER-DAEMON (often
with the line:
----- Transcript of session follows -----
don't resend the message to the list. All this return means is that
your original message failed to reach a few addresses on the list. Such
messages are NEVER a reason to resend a piece of mail a 2nd time. This
just bothers all (less the few delivery failures (which will probably
just fail again!)) of the readers of the list with a message they have
already seen. It also wastes computer and network resources.
It is appropriate to send these to the -request address for a list, and
ask them to check the problem out.
* Send Specific Requests for Information to: gnu@prep.ai.mit.edu
Specific requests for information about obtaining GNU software, or GNU
activities in Cambridge and elsewhere can be directed to:
gnu@prep.ai.mit.edu
* General Information about all lists
Please keep each message under 40,000 characters. Some mailers bounce
messages that are longer than this.
Most of the time, when you reply to a message sent to a list, the reply
should not go to the list. But most mail reading programs supply, by
default, all the recipients of the original as recipients of the reply.
Make a point of deleting the list address from the header when it does
not belong. This prevents bothering all readers of a list, and reduces
network congestion.
The GNU mailing lists and newsgroups, like the GNU project itself, exist
to promote the freedom to share software. So don't use these lists to
promote or recommend non-free software. (Using them to post ordering
information is the ultimate faux pas.) If there is no free program to
do a certain task, then somebody should write one!
* General Information about info-* lists
These lists and their newsgroups are meant for important announcements.
Since the GNU project uses software development as a means for social
change, the announcements may be technical or political.
Most GNU projects info-* lists (and their corresponding gnu.*.announce
newsgroups) are moderated to keep their content significant and
relevant. If you have a bug to report, send it to the bug-* list. If
you need help on something else and the help-* list exists, ask it.
See section '* General Information about all lists'.
* General Information about help-* lists
These lists (and their newsgroups) exist for anyone to ask questions
about the GNU software that the list deals with. The lists are read by
people who are willing to take the time to help other users.
When you answer the questions that people ask on the help-* lists, keep
in mind that you shouldn't answer by promoting a proprietary program as
a solution. The only real solutions are the ones all the readers can
share.
See section '* General Information about all lists'.
* General Information about bug-* lists and reporting program bugs
If you think something is a bug in a program, it might be one; or, it
might be a misunderstanding or even a feature. Before beginning to
report bugs, please read the section ``Reporting Emacs Bugs'' toward the
end of the GNU Emacs reference manual (or node Emacs/Bugs in Emacs's
built-in Info system) for a discussion of how and when to send in bug
reports. For GNU programs other than GNU Emacs, also consult their
documentation for their bug reporting procedures. Always include the
version number of the GNU program, as well as the operating system and
machine the program was ran on (if the program doesn't have a version
number, send the date of the latest entry in the file ChangeLog). For
GNU Emacs bugs, type "M-x emacs-version". A debugger backtrace of any
core dump, can also be useful. Be careful to separate out hypothesis
from fact! For bugs in GNU Emacs lisp, set variable debug-on-error to
t, and re-enter the command(s) that cause the error message; Emacs will
pop up a debug buffer if something is wrong; please include a copy of
the buffer in your bug report.
Please don't send in a patch without a test case to illustrate the
problem the patch is supposed to fix. Sometimes the patches aren't
correct or aren't the best way to do the job, and without a test case
there is no way to debug an alternate fix.
The purpose of reporting a bug is to enable the bug to be fixed for the
sake of the whole community of users. You may or may not receive a
response; the maintainers will send one if that helps them find or
verify a fix. Most GNU maintainers are volunteers and all are
overworked; they don't have time to help individuals and still fix the
bugs and make the improvements that everyone wants. If you want help
for yourself in particular, you may have to hire someone. The GNU
project maintains a list of people providing such services. It is
distributed with GNU Emacs in file etc/SERVICE, and can be requested
from gnu@prep.ai.mit.edu.
Anything addressed to the implementors and maintainers of a GNU program
via a bug-* list, should NOT be sent to the corresponding info-* or
help-* list.
Please DON'T post your bug reports on the gnu.* newsgroups! Mail them
to bug-*@prep instead! At first sight, it seems to make no difference:
anything sent to one will be propagated to the other; but if you post on
the newsgroup, the information about how to reach you is lost in the
message that goes on the mailing list. It can be very important to know
how to reach you if there is anything in the bug report that we don't
understand. Bug reports also reach the GNU maintainers quickest when
they are sent to the bug-* mailing list submittal address.
And please DON'T post your GNU bug reports to comp.* or other non gnu.*
newsgroups, they never make it to the GNU maintainers at all. Please
mail them to bug-*@prep instead!
See section '* General Information about all lists'.
* info-gnu-request@prep.ai.mit.edu to subscribe to info-gnu
** gnUSENET newsgroup: gnu.announce
** Send announcements to: info-gnu@prep.ai.mit.edu
This list distributes progress reports on the GNU Project. It is also
used by the GNU Project to ask people for various kinds of help. It is
NOT for general discussion.
The list is filtered to remove items meant for info-gnu-request, that
can be answered by the moderator without bothering the list, or should
have been sent to another list.
See section '* General Information about info-* lists'.
* gnu-misc-discuss-request@cis.ohio-state.edu to subscribe to gnu-misc-discuss
** gnUSENET newsgroup: gnu.misc.discuss
** Send contributions to: gnu-misc-discuss@cis.ohio-state.edu
This list is for serious discussion of freed software, the GNU
Project, the GNU Manifesto and their implications. It's THE place for
discussion that is not appropriate in the other GNU mailing lists and
gnUSENET newsgroups.
Flaming is out of place. Tit-for-tat is not welcome. Repetition
should not occur.
Good READING and writing are expected. Before posting, wait a while,
cool off, and think.
Don't trust pronouncements made on gnu-misc-discuss about what GNU is,
what FSF position is, what the GNU General Public License is, etc.,
unless they are made by someone you know is well connected with GNU and
are sure the message is not forged.
USENET and gnUSENET readers are expected to have read ALL the articles
in news.announce.newusers before posting. If news.announce.newusers is
empty at your site, wait (the articles are posted monthly), your posting
isn't that urgent! Readers on the Internet can anonymous ftp these
articles from wsmr-simtel20.army.mil under directory
PD2:<UNIX-C.USENET>.
Someone from the Free Software Foundation will attempt to follow this
group as time and volume permits.
Remember, "GNUs Not Unix" and "gnUSENET is Not USENET". We have
higher standards!
Note that sending technical questions about specific GNU software to
gnu-misc-discuss is likely to be less useful than sending them to the
appropriate mailing list or gnUSENET newsgroup, since more technical
people read those.
* bug-gnu-emacs-request@prep.ai.mit.edu to subscribe to bug-gnu-emacs
** gnUSENET newsgroup: gnu.emacs.bug
** Gnu Emacs bug reports to: bug-gnu-emacs@prep.ai.mit.edu
This list distributes, to the active maintainers of GNU Emacs, bug
reports and fixes for, and suggestions for improvements in GNU Emacs.
It is the place to report GNU Emacs bugs by all users of GNU Emacs.
Send bugs in the GNU Emacs Lisp reference manual to:
lisp-manual-bugs@prep.ai.mit.edu
lisp-manual-bugs is neither a mailing list nor a gnUSENET newsgroup.
It's just a bug-reporting address.
Subscribers to bug-gnu-emacs automatically receive all
info-gnu-emacs messages.
See section '* General Information about bug-* lists and reporting
program bugs'.
* gnu-emacs-sources-request@prep.ai.mit.edu to subscribe to gnu-emacs-sources
** gnUSENET newsgroup: gnu.emacs.sources
** Gnu Emacs source code to: gnu-emacs-sources@prep.ai.mit.edu
This list/newsgroup will be for the posting, by their authors, of lisp
and C sources and patches that improve GNU Emacs. Its contents will
be reviewed by FSF for inclusion in future releases of GNU Emacs.
Please do NOT discuss or request source code here. Use
help-gnu-emacs/gnu.emacs.help for those purposes. This allows the
automatic archiving of sources posted to this list/newsgroup.
Please do NOT post such sources to any other GNU mailing list (e.g
help-gnu-emacs) or gnUSENET newsgroups (e.g. gnu.emacs.help). It's up
to each poster to decide whether to cross-post to any non-gnUSENET
newsgroup (e.g. comp.emacs or vmsnet.sources).
Please do NOT announce that you have posted source code to
gnu.emacs.sources to any other GNU mailing list (e.g. help-gnu-emacs) or
gnUSENET newsgroups (e.g. gnu.emacs.help). People who want to keep up
with sources will read this list/newsgroup. It's up to each poster to
decide whether to announce a gnu.emacs.sources article in any
non-gnUSENET newsgroup (e.g comp.emacs or comp.sources.d).
If source or patches that were previously posted or a simple fix is
requested in help-gnu-emacs, please mail it to the requester. Do NOT
repost it. If you also want something that is requested, send mail to
the requester asking him to forward it to you. This kind of traffic is
best handled by e-mail, not by a broadcast medium that reaches thousands
of sites.
If the source is very long (>10k bytes) send mail offering to send it.
This prevents the requester from getting many redundant copies and saves
network bandwidth.
* help-gnu-emacs-request@prep.ai.mit.edu to subscribe to help-gnu-emacs
** gnUSENET newsgroup: gnu.emacs.help (and one-way into comp.emacs)
** Send contributions to: help-gnu-emacs@prep.ai.mit.edu
This list is the place for users and installers of GNU Emacs to ask for
help. Please send bug reports to bug-gnu-emacs instead of posting them
here.
Since help-gnu-emacs is a very large list, send it only those items that
are seriously important to many people.
If source or patches that were previously posted or a simple fix is
requested in help-gnu-emacs, please mail it to the requester. Do NOT
repost it. If you also want something that is requested, send mail to
the requester asking him to forward it to you. This kind of traffic is
best handled by e-mail, not a broadcast medium that reaches thousands of
sites.
This list is also gated one way to USENET's newsgroup comp.emacs (once
known as net.emacs). This one-way gating is done for users whose sites
get comp.emacs, but not gnu.emacs.help. Users at non-USENET sites may
receive all articles from comp.emacs by making their request to:
unix-emacs-request@bbn.com
If Emacs crashes, or if you build Emacs following the standard procedure
on a system which Emacs is supposed to work on (see etc/MACHINES) and it
does not work at all, or if an editing command does not behave as it is
documented to behave, this is a bug. Don't send bug reports to
help-gnu-emacs (gnu.emacs.help) or post them to comp.emacs; mail them to
bug-gnu-emacs instead.
See section '* General Information about help-* lists'.
* info-gnu-emacs-request@prep.ai.mit.edu to subscribe to info-gnu-emacs
** gnUSENET newsgroup: gnu.emacs.announce (and one-way into comp.emacs)
** Send announcements to: info-gnu-emacs@prep.ai.mit.edu
This list distributes announcements and progress reports on GNU Emacs.
It is NOT for general discussion; please use help-gnu-emacs for that.
The list is filtered to remove items meant for info-gnu-emacs-request,
that can be answered by the moderator without bothering the list, or
should have been sent to another list.
info-gnu-emacs is also gated one way to USENET's newsgroup comp.emacs
(once known as net.emacs). This one-way gating is done for users whose
sites get comp.emacs, but not gnu.emacs.announce. Users at non-USENET
sites may receive all articles from comp.emacs by making their request
to: unix-emacs-request@bbn.com
Do not report GNU Emacs bugs to info-gnu-emacs or comp.emacs, instead
mail them to bug-gnu-emacs@prep.ai.mit.edu.
See section '* General Information about info-* lists'.
* vms-gnu-emacs-request@harvard.harvard.edu to subscribe to vms-gnu-emacs
** gnUSENET newsgroup: gnu.emacs.vms
** Send contributions to: vms-gnu-emacs@harvard.harvard.edu
*** UUCP: ..!uunet!harvard!vms-gnu-emacs-request
This list was a working group who did the initial port of GNU Emacs to
the VMS operating system. It still discusses problems and solutions to
the VMS port and the distribution of it.
* bug-bash-request@prep.ai.mit.edu to subscribe to bug-bash
** gnUSENET newsgroup: gnu.bash.bug
** BASH bug reports to: bug-bash@prep.ai.mit.edu
This list distributes, to the active maintainers of BASH (the Bourne
Again SHell), bug reports and fixes for, and suggestions for
improvements in BASH. It is the place to report BASH bugs by all users
of BASH.
Always report the version number of the operating system, hardware, and
bash (flag -version on startup or check the variable $BASH_VERSION in a
running bash).
There are no other GNU mailing lists or gnUSENET newsgroups for BASH.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-gdb-request@prep.ai.mit.edu to subscribe to bug-gdb
** gnUSENET newsgroup: gnu.gdb.bug
** GDB bug reports to: bug-gdb@prep.ai.mit.edu
This list distributes, to the active maintainers of GDB (Gnu's
DeBugger), bug reports and fixes for, and suggestions for improvements
in GDB. It is the place to report GDB bugs by all users of GDB.
There are no other GNU mailing lists or gnUSENET newsgroups for GDB.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-gcc-request@prep.ai.mit.edu to subscribe to bug-gcc
** gnUSENET newsgroup: gnu.gcc.bug
** GCC bug reports to: bug-gcc@prep.ai.mit.edu
This list distributes bug reports for, fixes for bugs in, and
suggestions for improvements in the GNU C Compiler to its active
developers. It is the place to report GCC bugs by all testers of GCC.
The GNU C Compiler still has bugs in it, and is not quite ready for
everyday use.
Please don't send in a patch without a test case to illustrate the
problem the patch is supposed to fix. Sometimes the patches aren't
correct or aren't the best way to do the job, and without a test case
there is no way to debug an alternate fix.
The most convenient form of test case is a piece of cpp output that can
be passed directly to cc1. Preferably written in C, not C++.
Subscribers to bug-gcc automatically receive all info-gcc messages.
See section '* General Information about bug-* lists and reporting
program bugs'.
* help-gcc-request@prep.ai.mit.edu to subscribe to help-gcc
** gnUSENET newsgroup: gnu.gcc.help
** Send contributions to: help-gcc@prep.ai.mit.edu
This list is the place for users and installers of the GNU C Compiler to
ask for help.
If gcc crashes, or if you build gcc following the standard procedure on
a system which gcc is supposed to work on (see config.gcc) and it does
not work at all, or if an command line option does not behave as it is
documented to behave, this is a bug. Don't send bug reports to help-gcc
(gnu.gcc.help); mail them to bug-gcc instead.
See section '* General Information about help-* lists'.
* info-gcc-request@prep.ai.mit.edu to subscribe to info-gcc
** gnUSENET newsgroup: gnu.gcc.announce
** Send announcements to: info-gcc@prep.ai.mit.edu
This list distributes announcements and progress reports on the GNU C
Compiler. It is NOT for general discussion; please use help-gcc for
that.
The list is filtered to remove items meant for info-gcc-request, that
can be answered by the moderator without bothering the list, or should
have been sent to another list.
See section '* General Information about info-* lists'.
* bug-g++-request@prep.ai.mit.edu to subscribe to bug-g++
** gnUSENET newsgroup: gnu.g++.bug
** G++ bug reports to: bug-g++@prep.ai.mit.edu
This list distributes bug reports for, fixes for bugs in, and
suggestions for improvements in the GNU C++ Compiler to its active
developers. It is the place to report G++ bugs by all testers of G++.
G++ uses the GNU C-Compiler back end. Active developers may wish to
subscribe to bug-gcc@prep.ai.mit.edu as well.
Subscribers to bug-g++ automatically receive all info-g++ messages.
See section '* General Information about bug-* lists and reporting
program bugs'.
* help-g++-request@prep.ai.mit.edu to subscribe to help-g++
** gnUSENET newsgroup: gnu.g++.help (and one-way into comp.lang.c++)
** Send contributions to: help-g++@prep.ai.mit.edu
This list is the place for users and installers of the GNU C++ Compiler
to ask for help. Please send bug reports to bug-g++ instead of posting
them here.
help-g++ is also gated one way to USENET's newsgroup comp.lang.c++.
This one-way gating is done for users whose sites get comp.lang.c++, but
not gnu.g++.help.
If g++ crashes, or if you build g++ following the standard procedure on
a system which g++ is supposed to work on (see config.g++) and it does
not work at all, or if an command line option does not behave as it is
documented to behave, this is a bug. Don't send bug reports to help-g++
(gnu.g++.help) or post them to comp.lang.c++; mail them to bug-g++
instead.
See section '* General Information about help-* lists'.
* info-g++-request@prep.ai.mit.edu to subscribe to info-g++
** gnUSENET newsgroup: gnu.g++.announce (and one-way into comp.lang.c++)
** Send announcements to: info-g++@prep.ai.mit.edu
This list distributes announcements and progress reports on the GNU C++
Compiler. It is NOT for general discussion; please use help-g++ for
that.
The list is filtered to remove items meant for info-g++-request, that
can be answered by the moderator without bothering the list, or should
have been sent to another list.
It is also gated one way to USENET's newsgroup comp.lang.c++. This
one-way gating is done for users whose sites get comp.lang.c++, but not
gnu.g++.announce.
Do not report g++ bugs to info-g++ or comp.lang.c++, mail them to
bug-g++@prep.ai.mit.edu instead.
See section '* General Information about info-* lists'.
* bug-lib-g++-request@prep.ai.mit.edu to subscribe to bug-lib-g++
** gnUSENET newsgroup: gnu.g++.lib.bug
** lib-g++ bug reports to: bug-lib-g++@prep.ai.mit.edu
This list distributes, to the active maintainers of lib-g++ (GNU's
library for C++), bug reports and fixes for, and suggestions for
improvements in lib-g++. It is the place to report lib-g++ bugs by all
users of lib-g++.
Announcements of new releases of lib-g++ are made on both info-g++ and
bug-lib-g++.
There are no other GNU mailing lists or gnUSENET newsgroups for the G++
Library.
See section '* General Information about bug-* lists and reporting
program bugs'.
* info-gnu-fortran-request@prep.ai.mit.edu to subscribe to info-gnu-fortran
** gnUSENET newsgroup: NONE YET
** Send contributions to: info-gnu-fortran@prep.ai.mit.edu
This list is for progress reports about the GNU Fortran compiler. In
the future it will also be used for release notices.
The list is filtered to remove items meant for info-gnu-fortran-request,
that can be answered by the moderator without bothering the list, or
should have been sent to another list.
See section '* General Information about info-* lists'.
There are no other GNU mailing lists or gnUSENET newsgroups for GNU
Fortran (yet).
* bug-gnu-smalltalk-request@prep.ai.mit.edu to subscribe to bug-gnu-smalltalk
** gnUSENET newsgroup: gnu.smalltalk.bug
** GNU Smalltalk bug reports to: bug-gnu-smalltalk@prep.ai.mit.edu
GNU Smalltalk is the GNU project implementation of the Smalltalk language.
This list distributes, to the active maintainers of GNU Smalltalk, bug
reports and fixes for, and suggestions for improvements to GNU
Smalltalk. It is the place to report bugs in GNU Smalltalk by all users
of the program.
For now, new releases of GNU Smalltalk will also be announced on this list.
There are no other GNU mailing lists or gnUSENET newsgroups for GNU
Smalltalk.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-groff-request@prep.ai.mit.edu to subscribe to bug-groff
** gnUSENET newsgroup: gnu.groff.bug
** GNU groff bug reports to: bug-groff@prep.ai.mit.edu
groff is the GNU project implementation, in C++, of the traditional
Unix document formatting tools. As of June 1990 it includes troff,
pic, tbl, eqn, man macros, a PostScript driver, a driver which
produces TeX dvi format and a driver for typewriter-like devices. A
modified version of the Berkeley me macros and an enhanced version of
the X11R4 xditview are also included.
This list distributes, to the active maintainers of groff, bug reports
and fixes for, and suggestions for improvements to groff (and it
component programs). It is the place for all users of groff to report
bugs.
For now, new releases of groff will also be announced on this list.
There are no other GNU mailing lists or gnUSENET newsgroups for groff.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-ghostscript-request@prep.ai.mit.edu to subscribe to bug-ghostscript
** gnUSENET newsgroup: gnu.ghostscript.bug
** Ghostscript bug reports to: bug-ghostscript@prep.ai.mit.edu
GhostScript is the GNU project implementation of a language and graphics
library with a remarkable similarity to PostScript.
This list distributes, to the active maintainers of Ghostscript, bug
reports and fixes for, and suggestions for improvements in Ghostscript. It
is the place to report bugs in Ghostscript by all users of them.
For now, new releases of Ghostscript will also be announced on this list.
There are no other GNU mailing lists or gnUSENET newsgroups for
GhostScript.
See section '* General Information about bug-* lists and reporting
program bugs'.
* info-gnu-chess-request@prep.ai.mit.edu to subscribe to info-gnu-chess
** gnUSENET newsgroup: gnu.chess
** Send contributions to: info-gnu-chess@prep.ai.mit.edu
This list reports new releases and information about the program GNU
Chess.
See section '* General Information about info-* lists'.
* bug-gnu-utils-request@prep.ai.mit.edu to subscribe to bug-gnu-utils
** gnUSENET newsgroup: gnu.utils.bug
** GNU Utilities bug reports to: bug-gnu-utils@prep.ai.mit.edu
This list distributes, to the active maintainers of these programs, bug
reports and fixes for, and suggestions for improvements in GNU programs
not covered by other bug-* mailing lists/gnu.*.bug newsgroups. It is
the place to report bugs in these GNU programs by all users of them.
There are no other GNU mailing lists or gnUSENET newsgroups for these
GNU utilities.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-fortran-mode-request@erl.mit.edu to subscribe to bug-fortran-mode
** USENET newsgroup: (none)
** Fortran mode bug reports to: bug-fortran-mode@erl.mit.edu
This list collects bug reports, fixes for bugs, and suggestions for
improvements in GNU Emacs's Fortran mode (a major mode to support
editing Fortran source code).
It is the place to report Fortran mode bugs by all users of Fortran
mode.
Always report the version number Fortran mode reports on startup as well
as the version of Emacs.
There is no info-fortran-mode list. There are no USENET gateways to
bug-fortran-mode at this time.
* info-gnus-request%flab.Fujitsu.JUNET@uunet.UU.NET to subscribe
** gnUSENET newsgroup: NONE YET
** Send contributions to: info-gnus%flab.Fujitsu.JUNET@uunet.UU.NET
The list is intended to exchange useful information about GNUS, such as
bug reports, useful hooks, and extensions of GNUS. GNUS is an NNTP-base
network news reader for GNU Emacs (which also works with a news spool).
English and Japanese are the official languages of the list. GNUS is
quite different than gnews.
* info-gnus-english-request@cis.ohio-state.edu to subscribe
** gnUSENET newsgroup: gnu.emacs.gnus
** Send contributions to: info-gnus-english@cis.ohio-state.edu
The list has the same charter as info-gnus. The difference is that
English is the only official language of the list.
info-gnus-english/gnu.emacs.gnus is forward to info-gnus, but NOT
vice-versa.
* info-gnews-request@ics.uci.edu to subscribe to info-gnews
** gnUSENET newsgroup: gnu.emacs.gnews
** Send contributions to: info-gnews@ics.uci.edu
This newsgroup is intended to exchange useful information about gnews,
such as bug reports, useful hooks, and extensions of gnews. gnews is an
NNTP-base network news reader for GNU Emacs (which also works a news
spool). It is quite different than GNUS.
* gnu-emacs-ada-request@grebyn.com to subscribe to gnu-emacs-ada
** gnUSENET newsgroup: NONE PLANNED
** Gnu Emacs Ada support bug reports to: gnu-emacs-ada@grebyn.com
This list distributes bug reports for, fixes for bugs in, and
suggestions for improvements in GNU Emacs' editing support of the Ada
programming language.
There are no other GNU mailing lists or gnUSENET newsgroups for GNU
Emacs' editing support of Ada.
See section '* General Information about bug-* lists and reporting
program bugs'.
* bug-vm-request@uunet.uu.net to subscribe to bug-vm
** gnUSENET newsgroup: NONE
** VM mail reader bug reports to: bug-vm@uunet.uu.net
This list discusses bugs in View Mail mode for GNU Emacs, with an
emphasis on beta and prerelease versions. It is the place to report
bugs in VM.
Always report the version number of VM you are using, as well as the
version of Emacs you're running. If you believe it is significant,
report the operating system used and the hardware.
Subscribers to bug-vm automatically receive all info-vm messages.
* info-vm-request@uunet.uu.net to subscribe to info-vm
** gnUSENET newsgroup: NONE
** Send contributions to: info-vm@uunet.uu.net
This list dicusses the View Mail mode for GNU Emacs, an alternative to
rmail mode.
* supercite-request@warsaw.nlm.nih.gov to subscribe to supercite
** gnUSENET newsgroup: NONE PLANNED
** Send articles to: supercite@warsaw.nlm.nih.gov
*** UUCP: ..!uunet!warsaw.nlm.nih.gov!supercite-request
The supercite mailing list covers issues related to the advanced
mail/news citation package called Supercite for GNU Emacs.
* bug-gnu960-request@mipon2.intel.com to subscribe to bug-gnu960
** gnUSENET newsgroup: NONE PLANNED
** Intel 960 Port bug reports to: bug-gnu960@mipon2.intel.com
This list distributes bug reports for, fixes for bugs in, and
suggestions for improvements in Intel's port of GNU software to the
Intel 960 microprocessor.
You can also fax to: GNU/960 - 1-503-696-4930.
There are no other GNU mailing lists or gnUSENET newsgroups for Intel's
port of GNU software to the Intel 960 microprocessor.
See section '* General Information about bug-* lists and reporting
program bugs'.
* gnu-manual-request@a.cs.uiuc.edu IS NOW DEFUNCT
** DEAD: Gnusenet newsgroup: gnu.emacs.lisp.manual
** DEAD address: gnu-manual@a.cs.uiuc.edu
*** DEAD UUCP address: ..!uunet!uiucdcs!gnu-manual-request
This list and newsgroup is dead. It was a working group whose
volunteers wrote, proofread and commented on the developing GNU Emacs
Lisp programmers manual.
Send bugs in the GNU Emacs Lisp reference manual to:
lisp-manual-bugs@prep.ai.mit.edu
lisp-manual-bugs is neither a mailing list nor a gnUSENET newsgroup.
It's just a bug-reporting address.
* no mailing list request
** gnUSENET newsgroup: gnu.gnusenet.config
** no mailing list
This newsgroup has nothing to do with GNU software, especially its
configuration. It's exists to distribute information about the
administration and configuration of gnUSENET: the gnu.all alternative
USENET hierarchy that carry the GNU mailing lists.
Administrators of gnUSENET hosts receiving the gnu.all newsgroups are
welcome to ask questions here or via e-mail of gnu@prep.ai.mit.edu.
* no mailing list request
** gnUSENET newsgroup: gnu.gnusenet.test
** no mailing list
This newsgroup has nothing to do with GNU software, especially its
testing. It's exists to allow test messages to be made in gnUSENET: the
gnu.all alternative USENET hierarchy that carry the GNU mailing lists.
Local variables:
mode: outline
fill-column: 72
End:

176
etc/MOTIVATION Normal file
View file

@ -0,0 +1,176 @@
STUDIES FIND REWARD OFTEN NO MOTIVATOR
Creativity and intrinsic interest diminish if task is done for gain
By Alfie Kohn
Special to the Boston Globe
[reprinted with permission of the author
from the Monday 19 January 1987 Boston Globe]
In the laboratory, rats get Rice Krispies. In the classroom the top
students get A's, and in the factory or office the best workers get
raises. It's an article of faith for most of us that rewards promote
better performance.
But a growing body of research suggests that this law is not nearly as
ironclad as was once thought. Psychologists have been finding that
rewards can lower performance levels, especially when the performance
involves creativity.
A related series of studies shows that intrinsic interest in a task -
the sense that something is worth doing for its own sake - typically
declines when someone is rewarded for doing it.
If a reward - money, awards, praise, or winning a contest - comes to
be seen as the reason one is engaging in an activity, that activity
will be viewed as less enjoyable in its own right.
With the exception of some behaviorists who doubt the very existence
of intrinsic motivation, these conclusions are now widely accepted
among psychologists. Taken together, they suggest we may unwittingly
be squelching interest and discouraging innovation among workers,
students and artists.
The recognition that rewards can have counter-productive effects is
based on a variety of studies, which have come up with such findings
as these: Young children who are rewarded for drawing are less likely
to draw on their own that are children who draw just for the fun of
it. Teenagers offered rewards for playing word games enjoy the games
less and do not do as well as those who play with no rewards.
Employees who are praised for meeting a manager's expectations suffer
a drop in motivation.
Much of the research on creativity and motivation has been performed
by Theresa Amabile, associate professor of psychology at Brandeis
University. In a paper published early last year on her most recent
study, she reported on experiments involving elementary school and
college students. Both groups were asked to make "silly" collages.
The young children were also asked to invent stories.
The least-creative projects, as rated by several teachers, were done
by those students who had contracted for rewards. "It may be that
commissioned work will, in general, be less creative than work that is
done out of pure interest," Amabile said.
In 1985, Amabile asked 72 creative writers at Brandeis and at Boston
University to write poetry. Some students then were given a list of
extrinsic (external) reasons for writing, such as impressing teachers,
making money and getting into graduate school, and were asked to think
about their own writing with respect to these reasons. Others were
given a list of intrinsic reasons: the enjoyment of playing with
words, satisfaction from self-expression, and so forth. A third group
was not given any list. All were then asked to do more writing.
The results were clear. Students given the extrinsic reasons not only
wrote less creatively than the others, as judged by 12 independent
poets, but the quality of their work dropped significantly. Rewards,
Amabile says, have this destructive effect primarily with creative
tasks, including higher-level problem-solving. "The more complex the
activity, the more it's hurt by extrinsic reward," she said.
But other research shows that artists are by no means the only ones
affected.
In one study, girls in the fifth and sixth grades tutored younger
children much less effectively if they were promised free movie
tickets for teaching well. The study, by James Gabarino, now
president of Chicago's Erikson Institute for Advanced Studies in Child
Development, showed that tutors working for the reward took longer to
communicate ideas, got frustrated more easily, and did a poorer job in
the end than those who were not rewarded.
Such findings call into question the widespread belief that money is
an effective and even necessary way to motivate people. They also
challenge the behaviorist assumption that any activity is more likely
to occur if it is rewarded. Amabile says her research "definitely
refutes the notion that creativity can be operantly conditioned."
But Kenneth McGraw, associate professor of psychology at the
University of Mississippi, cautions that this does not mean
behaviorism itself has been invalidated. "The basic principles of
reinforcement and rewards certainly work, but in a restricted context"
- restricted, that is, to tasks that are not especially interesting.
Researchers offer several explanations for their surprising findings
about rewards and performance.
First, rewards encourage people to focus narrowly on a task, to do it
as quickly as possible and to take few risks. "If they feel that
'this is something I hve to get through to get the prize,' the're
going to be less creative," Amabile said.
Second, people come to see themselves as being controlled by the
reward. They feel less autonomous, and this may interfere with
performance. "To the extent one's experience of being
self-determined is limited," said Richard Ryan, associate psychology
professor at the University of Rochester, "one's creativity will be
reduced as well."
Finally, extrinsic rewards can erode intrinsic interest. People who
see themselves as working for money, approval or competitive success
find their tasks less pleasurable, and therefore do not do them as
well.
The last explanation reflects 15 years of work by Ryan's mentor at the
University of Rochester, Edward Deci. In 1971, Deci showed that
"money may work to buy off one's intrinsic motivation for an activity"
on a long-term basis. Ten years later, Deci and his colleagues
demonstrated that trying to best others has the same effect. Students
who competed to solve a puzzle quickly were less likely than those who
were not competing to keep working at it once the experiment was over.
Control plays role
There is general agreement, however, that not all rewards have the
same effect. Offering a flat fee for participating in an experiment -
similar to an hourly wage in the workplace - usually does not reduce
intrinsic motivation. It is only when the rewards are based on
performing a given task or doing a good job at it - analogous to
piece-rate payment and bonuses, respectively - that the problem
develops.
The key, then, lies in how a reward is experienced. If we come to
view ourselves as working to get something, we will no longer find
that activity worth doing in its own right.
There is an old joke that nicely illustrates the principle. An
elderly man, harassed by the taunts of neighborhood children, finally
devises a scheme. He offered to pay each child a dollar if they would
all return Tuesday and yell their insults again. They did so eagerly
and received the money, but he told them he could only pay 25 cents on
Wednesday. When they returned, insulted him again and collected their
quarters, he informed them that Thursday's rate would be just a penny.
"Forget it," they said - and never taunted him again.
Means to and end
In a 1982 study, Stanford psychologist Mark L. Lepper showed that any
task, no matter how enjoyable it once seemed, would be devalued if it
were presented as a means rather than an end. He told a group of
preschoolers they could not engage in one activity they liked until
they first took part in another. Although they had enjoyed both
activities equally, the children came to dislike the task that was a
prerequisite for the other.
It should not be surprising that when verbal feedback is experienced
as controlling, the effect on motivation can be similar to that of
payment. In a study of corporate employees, Ryan found that those who
were told, "Good, you're doing as you /should/" were "significantly
less intrinsically motivated than those who received feedback
informationally."
There's a difference, Ryan says, between saying, "I'm giving you this
reward because I recognize the value of your work" and "You're getting
this reward because you've lived up to my standards."
A different but related set of problems exists in the case of
creativity. Artists must make a living, of course, but Amabile
emphasizes that "the negative impact on creativity of working for
rewards can be minimized" by playing down the significance of these
rewards and trying not to use them in a controlling way. Creative
work, the research suggests, cannot be forced, but only allowed to
happen.
/Alfie Kohn, a Cambridge, MA writer, is the author of "No Contest: The
Case Against Competition," recently published by Houghton Mifflin Co.,
Boston, MA. ISBN 0-395-39387-6. /

87
etc/Makefile Normal file
View file

@ -0,0 +1,87 @@
CFLAGS= -g
# For Xenix. Needed for movemail
# LOADLIBES= -lx
# For Mips. Needed for who knows what.
# CFLAGS = -g -systype bsd43
EXECUTABLES = test-distrib etags ctags wakeup make-docfile \
digest-doc sorted-doc movemail cvtmail fakemail yow env \
server emacsclient
all: ${EXECUTABLES}
clean:
-rm -f ${EXECUTABLES} core
distclean:
-rm -f ${EXECUTABLES} *~ \#* DOC* core
# This justs verifies that the non-ASCII characters
# in the file `testfile' have no been clobbered by
# whatever means were used to copy and distribute Emacs.
# If they were clobbered, all the .elc files were clobbered too.
test-distrib: test-distrib.c
$(CC) -o test-distrib test-distrib.c
./test-distrib
etags: etags.c
$(CC) -o etags ${CFLAGS} -DETAGS etags.c $(LOADLIBES)
ctags: etags.c
$(CC) -o ctags ${CFLAGS} -DCTAGS etags.c $(LOADLIBES)
wakeup: wakeup.c
$(CC) -o wakeup ${CFLAGS} wakeup.c $(LOADLIBES)
make-docfile: make-docfile.c
$(CC) -o make-docfile ${CFLAGS} make-docfile.c $(LOADLIBES)
digest-doc: digest-doc.c
$(CC) -o digest-doc ${CFLAGS} digest-doc.c $(LOADLIBES)
sorted-doc: sorted-doc.c
$(CC) -o sorted-doc ${CFLAGS} sorted-doc.c $(LOADLIBES)
#
movemail: movemail.c ../src/config.h
$(CC) -o movemail ${CFLAGS} movemail.c $(LOADLIBES)
cvtmail: cvtmail.c
$(CC) -o cvtmail ${CFLAGS} cvtmail.c $(LOADLIBES)
fakemail: fakemail.c ../src/config.h
$(CC) -o fakemail ${CFLAGS} fakemail.c $(LOADLIBES)
yow: yow.c ../src/paths.h
$(CC) -o yow ${CFLAGS} yow.c $(LOADLIBES)
# this is silly -- just use emacs to edit this file!
# (in any case this program doesn't preserve alphabetical ordering,
# which is why I'm removing it)
#addyow: addyow.c
# $(CC) -o addyow ${CFLAGS} addyow.c
env: env.c ../src/config.h
$(CC) -o env -DEMACS ${CFLAGS} env.c $(LOADLIBES)
server: server.c ../src/config.h
$(CC) -o server ${CFLAGS} server.c $(LOADLIBES)
emacsclient: emacsclient.c ../src/config.h
$(CC) -o emacsclient ${CFLAGS} emacsclient.c $(LOADLIBES)
# This one is NOT included in EXECUTABLES.
# See ../src/ymakefile.
emacstool: emacstool.c
$(CC) -o emacstool ${CFLAGS} emacstool.c -lsuntool -lsunwindow -lpixrect $(LOADLIBES)
nemacstool: emacstool.c
$(CC) -o nemacstool ${CFLAGS} -DJLE emacstool.c -lsuntool -lmle -lsunwindow -lpixrect $(LOADLIBES) # For SUN Japanese Language Environment
xvetool: emacstool.c
$(CC) -o xvetool ${CFLAGS} -DXVIEW emacstool.c -lxview -lolgx -lX -I$(OPENWINHOME)/include -L$(OPENWINHOME)/lib $(LOADLIBES)
xveterm: emacstool.c
$(CC) -o xveterm ${CFLAGS} -DXVIEW -DTTERM emacstool.c -lxview -lolgx -lX -I$(OPENWINHOME)/include -L$(OPENWINHOME)/lib $(LOADLIBES)

1655
etc/NEWS Normal file
View file

File diff suppressed because it is too large Load diff

188
etc/NICKLES.WORTH Normal file
View file

@ -0,0 +1,188 @@
Article from _Computer Language_ by Bruce Tonkin.
Several prominent software companies have caused a stir lately by dropping
all development work in Pascal and adopting Microsoft BASIC. When queried all
have declined to comment about this move, but one company insider (code-named
Deep Poke) suggested talking to Niklaus Wirth to get the full story.
Speaking from his home in Zurich, Switzerland, Wirth proved to be a far
more genial soul than one might imagine, being the founder of Pascal and all.
But the European lifestyle obviously agrees with him, and he was more than
willing to provide some insights into this strange phenomenon, currently taking
place in the computer industry.
In fact, what began as an innocent inquiry eventually revealed a shocking
and exclusive piece of information: that the invention of Pascal nearly 20
years ago was intended entirely as a joke, an April Fools' prank.
Wirth tried to explain. "Every year at the Swiss Federal Institute for
Technology [the university in Zurich where Wirth is a professor of computer
science] I taught the same classes, gave the same tests, told the same
jokes," he began. "it was boring. I needed a little humor. So I started
talking about this crazy language called Pascal. Eventually, the Pascal joke
became so popular I just kept adding to it, making it more and more elaborate.
"But some of the students went to class so seldom that they missed the
joke and thought Pascal was a real language! Imagine the looks on their faces
when they got out into the world and discovered there was no such thing as a
language called Pascal. Hoo-boy! They sure learned to pay attention after
that!" he said, giggling.
Several of his better students, he continued, figured they'd make some
money by fleecing the people who actually believed in Pascal and so wrote a
simple Pascal compiler for this purpose. It was actually a kind of prank, much
like selling elevator passes to high school freshmen.
"Yes, yes," Wirth said, "the UCSD operating system started the same way.
The same bunch of rascals who did the whole Pascal thing kept pushing the idea
until it reached the point of complete absurdity. They were hysterical!
Especially late at night - they'd come up with some really boffo material.
They the next week they'd modify it and it would get even more entertaining."
Wirth's best student was Philippe Kahn, who he met while Kahn was a
student. "I used to go to a small bistro called 'Der Blaue Engel' after my
classes, and it happened that Kahn played jazz saxophone there while people
danced on the tables." Wirth was impressed with Kahn's talent and evident wit
and encouraged him to end his musical career and enter the lucrative field of
software comedy. Once he explained Pascal's comedic possibilities, Kahn was
hooked and quickly agreed.
Since most of the staff at Apple Computer Inc. was educated at the
University of California at San Diego, they were also in on the joke, Wirth
said. "That's why they kept pushing Pascal. A bunch of fine kids, those Apple
guys. Born comedians, most of them. Except this one guy - he had no sense
of humor at all. [Editor's hint: not Woz.]
"When we finally decided to do a DOS that was even funnier than UCSD
Pascal, the feeling was that UCSD was already the ultimate. But then one of
the guys proposed doing a DOS that was written in Pascal but used hieroglyphics
instead of a written language. What a genius! We were rolling in the aisles.
But that one guy, he thought we were serious. What a nerd!"
Wirth's list of the funniest features of Pascal begins with the lack of a
string data type, no random file access, primitive numeric handling, and the
existential absurdity of the semicolon.
"But I'd have to say that my crowning achievement was the lack of input
and output functions. First you can't get anything in too easy. And once it's
in, you can't do much with it. Pascal isn't good with letters and it's not
good at all with numbers. Besides, I made it very picky. You have to
recompile, recompile, recompile forever. Ha! And once you've done something
with the data, you can't get it out." Wirth started chuckling uncontrollably.
"Philippe has said C is a write-only language - I made Pascal a read-only
language!" His chuckling turned into hysterical laughter that went on for
several minutes.
"Of course, some didn't get the joke," he finally said when he could speak
again. "They kept trying to make Pascal actually useful. But I stopped them;
I made the original Pascal a standard. That meant anyone who made Pascal good
for anything was nonstandard and out on a limb!"
* * * * *
How will all this affect the future of Modula-2? Wirths' merry manner
and beaming face suddenly became hard when presented with this question;
perhaps this was taboo territory, sacred subject matter.
"Modula-2 is a real language," he finally said, his demeanor solemn. "It
represents a serious effort on my part to make amends for any damage caused by
well-meaning but unimaginative people teaching and learning Pascal.
"But it's so hard! Pascal is a very good joke, yes? But to make a really
good language from it is not so easy," he sighed.
In addition to Pascal, Wirth admitted, three other languages also were
intended as pranks: Forth, PL/I, and True BASIC.
"Forth is essentially black humor," Wirth said. "Charles Moore [who
created the language in the late 1960s] designed it as a native language for
people whose brains ran backward." Originally, he continued, it was supposed
to be the ultimate parody of Hewlett-Packard calculators, which Moore has been
competing with unsuccessfully for years. As an astronomer, he had used HP's
calculators out of necessity rather than any appreciation for their design.
But to his great surprise, he found that there were actually quite a few
people whose brains did run in reverse. Eventually, Moore came to see Forth
as a boon, especially for backward thinkers. "At least it keeps them of the
streets out of really serious trouble," Wirth said. "Imagine one of them
trying to drive a car or operate heavy machinery!"
PL/I originally stood for "Prostituted Language/Interface," Wirth
explained. "The designers were under so much pressure to add features and
include every possible construction from every other language in existence that
they eventually gave up and decided to play the whole thing for laughs. They
said 'yes' to every request, no matter how absurd, and even added things to
the language no one ever could or would use. The scoured journals for
off-beat syntax and weird symbolic notation; some of their better ideas came
from early editions of The Mad Reader and other E. C. publications. Besides,
several of them were upset with the compiler-writing team and decided to stick
it to them with a life-time project."
True BASIC is not "True" in the sense most people understand the word,
Wirth continued. Rather, "True" is itself an acronym for a "Totally wRecked-Up
Example of." The professors who came up with it are amazed that no one has
yet caught on to the joke; they felt sure their insistence on the LET keyword
would be a dead giveaway. "Of course there were other clues, but this was the
most clear-cut," Wirth said. "They even called Microsoft BASIC a street
BASIC in hopes that Bill Gates would challenge them and reveal the joke."
But Gates refused to play along, and both professors had to all but beg Wirth
to tell the world the truth about True BASIC before things went any further.
* * * * *
Jokes abound in the world of operating systems as well, according to
Wirth. In addition to the UCSD Pascal operating system, said Wirth, "Tandy,
Apple, and Commodore were for a number of years carrying out a private comedic
battle to see who could produce the world's funniest DOS."
Tandy's TRS-DOS (Tandy Radio Signal Detection Operating System - a
reference to the fact that early machines would reboot when any transmitted
signal was detected) was an early front-runner until Apple came out with the
vary amusing Control-D command what could enable or disable disk operations.
In the end, though, Commodore won the battle. Its DOS was oriented toward
records exactly the size of punch cards and took over four minutes to boot from
disk since it read disk data more slowly than most audio tape machines and even
some 300-baud modems.
But the funniest joke of all is, in Wirth's estimation, also the most
common, and he's amazed so few people have caught on to it yet.
"Come on, come on. Surely you can guess," he said, his voice rising in
excitement. "What one thing makes users more livid than any other? What one
computer product makes you feel sure it was produced by a team of trained
gerbils on mind-altering drugs? Yes, yes, yes! You see it now - manuals!"
Wirth considers Gates, who wrote all the BASIC manuals and who was on the
staff of many others, a "comic genius." "Mitch Kapor should get more
recognition - he's far better than Neil Simon. And what's-his-name, the guy
who wrote the WordStar manual - he got an award at at dinner we threw for
him a few years back. That manual is a classic in the truest Marxist
[brothers] sense of the word! Pure slapstick! But the best of them all is the
author of the dBase II manual. Now there is a writer for the ages!"
As for the IBM manuals, Wirth considers them mere hack work. "Anyone can
do stuff like that," he snorted.
But perusing a copy of the manual for NEWDOS, he seemed a little more
impressed. "Hmmmm. Not bad work. Not bad at all," he said. "But it's still
simple stuff. 'To do this, read page 40. But to know what's on page 40, you
have to read page 65, which refers to page 15, which shows a whole list of
exceptions for page 53.' Entertaining, but hardly in the class of any of the
modern masters of the art." But when his attention was brought to the fact
that none of the error numbers listed in the NEWDOS manual were ever returned
to the BASIC programmer, and that the most common disk setup (double-density,
double-sided) was not on the configuration menu, Wirth admitted that these were
indeed nice touches.
Although it is a known fact that most of the early computer manuals
(probably even the NEWDOS manual) were written by programmers and that
programmers are notoriously poor writers, Wirth would not be deterred from his
opinion that these writings are works of art.
"Most people fail to consider that good programmers are very bright.
Their thoughts are extremely well organized and most of them have the benefit
of higher education. Their brains are not warped by overexposure to TV and
their attention spans are not short-circuited by overindulgence in sex, drugs,
or alcohol. They are not constrained by conventionality. If you want to get
picky, there are a lot more programmers than there ever were writers. And
programmers simply work harder than writers. Few writers work 100 hours a
week; almost all programmers do."
The result, according to Wirth? "All programmers write at least as well
as Faulkner. Most are as good as Proust, and about a third are as good as
Dickens. Several hundred are at least as good as Shakespeare. So the manuals
you thought were inferior were simply beyond your poor ability to appreciate.
If you were a programmer, you would delight in their verbal virtuosity," he
said.
In fact, Wirth claimed, even the grammatical errors and misspellings in
the manuals were placed there deliberately. Most are elaborate literary
allusions and puns; some are inventive Joycean neologisms. As an example,
Wirth discussed the history of the word "kernal."
"Everyone, including programmers, knows the word is spelled k-e-r-n-e-l,"
he explained. "The deliberate misspelling is an implied criticism of the
typesetter (a writer's bane for years.) Of course typesetters kern the letter
l; thus, 'kern el.' But kerning can only be done for certain letter
combinations, such as two l's. Thus, 'kern a l' dares the typesetter to kern
an isolated l, an obvious typographic impossibility.
"Moreover," he continued, "'kernal' is an anagram for 'rankle,' which
describes programmers' feelings toward typesetters. Finally the inventor of
this particular word, R. K. Lane (who is well known within the Southern
California computer community) has concealed his name by means of yet another
anagram."
Wirth smiled a last secretive smile, leaving us all to wonder if this was
perhaps just one more in his series of personal computer pranks.

1346
etc/ONEWS Normal file
View file

File diff suppressed because it is too large Load diff

1165
etc/OONEWS Normal file
View file

File diff suppressed because it is too large Load diff

190
etc/OPTIONS Normal file
View file

@ -0,0 +1,190 @@
This describes the sequence of Emacs start-up actions, including the meaning
of all the command-line options. It was written by Joe Wells.
1. These command line switches are handled, only if they appear before
all other command line arguments, and only if they appear in this
order:
`-map'. Only under VMS. Instead of "undumping", under VMS the
contents of a dump file are mapped over a section of memory (very
quickly initializing lots of variables). You would not normally
use this options explicitly; it is given automatically by the
command file that implements the `emacs' command.
`-t'. The next argument is treated as the name of a terminal to use
instead of whatever is connected to the stdin, stdout, and stderr
FILE pointers.
`-display' (synonym: `-d'). The next argument is treated as the
name of an X Window System server with which to connect. This
overrides the DISPLAY environment variable.
`-nw'. This means don't connect to an X Window server even if the
DISPLAY environment variable was set or the `-display' switch was
specified. Instead, Emacs talks to a regular dumb terminal.
`-batch'. Run noninteractively. This disables any full screen
interaction either with a dumb terminal or with a window system.
In addition, Emacs will die after processing all command line
arguments. The variable `noninteractive' is t.
All of Emacs's internal data structures are initialized between steps 2
and 5.
2. The `*scratch*' buffer is created and its value of `default-directory'
is set from the result of calling the `getwd' library routine.
(getwd does what the `pwd' program does.)
3. If X11 is being used, Emacs determines the name under which it looks
for X resource values. (I haven't checked how it does this under
X10.)
1. If there is a `-rn' command line switch, it is handled now, no
matter where it is on the command line. (Later it will be
processed again and ignored.) The next argument is used as
Emacs's resource name.
2. If the `-rn' switch was missing, Emacs looks for the WM_RES_NAME
environment variable.
3. If neither of the previous two steps succeed, Emacs uses the
filename with which it was invoked as its resource name.
4. If X11 is being used, these command line switches are handled now,
no matter where they appear in the command line. (Under X10, they
are not handled until step 13.) WARNING: this can cause strange
interactions with the processing of the remaining command line
arguments in step 13.
In addition, under both X11 and X10, X resources (ie. the stuff in
an `.Xdefaults' file) are handled now. Command line switches take
precedence over resources.
After each command line switch are given the equivalent resource
names in this format: (X10 name / X11 instance name / X11 class name).
`-r'. Reverse video. (ReverseVideo/reverseVideo/ReverseVideo)
`-font' (synonym: `-fn'). Font. (BodyFont/font/Font)
`-wn'. Window name (X11 only). (/title/Title)
`-in'. Icon name (X11 only). (/iconName/Title)
`-i'. Use built-in icon bitmap. (BitMapIcon//)
`-b'. Border width (in pixels).
(BorderWidth/borderWidth/BorderWidth)
`-ib'. Internal border width (in pixels) (default: 1).
(/internalBorder/BorderWidth)
`-xrm RESOURCESTRING'. Specifies a resource name and value
that overrides any other value in the X server for that name.
This is useful also for setting parameters that don't have their
own specific options.
`-geometry' (synonym: `-w'). Window shape and size. `-geometry' is
X11 only, but its synonym `-w' was available under X10.
(/geometry/Geometry)
Color options only:
`-fg'. Foreground color. (Foreground/foreground/Foreground)
`-bg'. Background color. (Background/background/Background)
`-bd'. Border color. (Border/borderColor/BorderColor)
`-cr'. Cursor color. (Cursor/cursorColor/Foreground)
`-ms'. Mouse pointer color. (Mouse/pointerColor/Foreground)
In addition, under X10, the resource `Keymap' was handled now.
5. If your Emacs isn't dumped, the default Lisp libraries are
loaded now.
6. Emacs enters a recursive edit. The first time Emacs does a
recursive edit, steps 7 through 15 are followed, and then Emacs
enters its normal editing mode.
7. If the environment variable PWD exists, the value of
`default-directory' in the `*scratch*' buffer is set to the value of
PWD. This often causes problems and confusion when the value of PWD
doesn't actually contain the pathname of the current directory.
8. Now the `-no-init-file' (synonym: `-q') and `-user' (synonym: `-u')
command line switches are handled. They must follow the switches
mentioned in step 1, and must precede any other command line
arguments. Actually, both of these options can be specified;
whichever is last on the command line wins.
9. The user's `.emacs' file is loaded now, if the `-no-init-file'
option was not specified. If the `-user' option was specified,
that user's init file is loaded instead. This file is named
`.emacs' in the user's home directory. If no such file exists,
this step has no effect.
10. The system wide `default.el' file is loaded now, if the variable
`inhibit-default-init' is nil. The user can set this variable in the
`.emacs' file to skip this step.
11. If the *scratch* buffer still exists now, the value of
`initial-major-mode' is called as a function in this buffer.
Normally, this puts this buffer in Lisp Interaction mode.
12. Now the terminal/window-system setup file is loaded. The name of
this file is determined as follows:
1. It starts with the value of `term-file-prefix'. Normally this is
`term/', but the user can set it to another value. If this
variable is nil, this entire step is skipped.
2. For a window system, the prefix is followed by the name of the
value of the variable `window-system', followed by `-win'. For X
Windows, this means the name is `term/x-win'.
3. For a terminal, the prefix is followed by the value of the
environment variable TERM, for example, `term/vt200'. If Emacs
cannot find such a file to load, it retries by stripping off
suffixes that begin with a hyphen. For example, if TERM is
`vt200-40', first Emacs will try `term/vt200-40', and if that
fails it will try `term/vt200'.
13. The rest of the command line arguments are handled at this point, in
the order they appear:
`-funcall' (synonyms: `-f', `-e'). The next argument is treated as
the name of a function, which is called with no arguments.
`-load' (synonym: `-l'). The next argument is treated as the name
of a file to load. NOTE: the value of the variable `load-path'
will be restored after this file is done loading. Thus, trying
to change `load-path' in such a file will fail!!
`-kill'. When this argument is handled, Emacs kills itself.
`+DDD', where D is a digit. DDD is used as a line number to go to.
When the next ordinary file argument on the command line is
handled, Emacs positions point in that file on line DDD.
An ordinary filename. Emacs edits this file using the function
`find-file'. If the filename is not an absolute filename, it is
expanded relative to the value that default-directory in the
`*scratch*' buffer had at the beginning of step 11. The buffer
visiting this file becomes the current buffer.
`-insert' (synonym: `-i'). The next argument is treated as the name
of a file. This file is inserted in the current buffer.
Initially, this is the `*scratch*' buffer. Otherwise it is the
buffer visiting the file most recently specified on the command
line.
Other command line switches may have been created by modifying the
value of the variable `command-switch-alist'. If X Windows is being
used, all X-specific switches mentioned above in steps 3 and 4 will
be processed. Under X11, they will have already been handled, and
will be ignored now. Under X10, they are being handled for the
first time.
14. The values of the variables `term-setup-hook' and `window-setup-hook'
are called as functions with no arguments, in the order listed.
15. If the user did not specify any of the command line options handled
in step 13, and the variable `inhibit-startup-message' is still nil,
the familiar Emacs startup message is displayed.

968
etc/SERVICE Normal file
View file

@ -0,0 +1,968 @@
GNU Service Directory -*- text -*-
This is a list of people who have asked to be listed as offering
support services for GNU software, including GNU Emacs, for a fee
or in some cases at no charge.
The information comes from the people who asked to be listed;
we do not include any information we know to be false, but we
cannot check out any of the information; we are transmitting it to
you as it was given to us and do not promise it is correct.
Also, this is not an endorsement of the people listed here.
We have no opinions and usually no information about the abilities of
any specific person. We provide this list to enable you to contact
service providers and decide for yourself whether to hire one.
Before FSF will list your name in the GNU Service Directory, we ask
that you agree informally to the following terms:
1. You will not restrict (except by copyleft) the use or distribution
of any software, documentation, or other information you supply anyone
in the course of modifying, extending, or supporting GNU software.
This includes any information specifically designed to ameliorate the
use of GNU software.
2. You will not take advantage of contact made through the Service
Directory to advertise an unrelated business (e.g., sales of
non-GNU-related proprietary information). You may spontaneously
mention your availability for general consulting, but you should not
promote a specific unrelated business unless the client asks.
Please include some indication of your rates, because otherwise users
have nothing to go by. Please put each e-mail address inside "<>".
Please put nothing else inside "<>". Thanks!
For a current copy of this directory, or to have yourself listed, ask:
gnu@prep.ai.mit.edu
** Please keep this file alphabetical **

Joseph Arceneaux <jla@ai.mit.edu>
PO Box 460633
San Francisco, CA 94146-0633
+1 415 285 9088
Performed X11 implementation of Emacs version 19.
Worked on Emacs text annotation.
Service and development of GNU and X11 software. Handholding, teaching,
and installations at lower rates.
Rates: $150/hour. Free to selected non-profit and activist organizations.
Updated: 11/7/91

Giuseppe Attardi <attardi@di.unipi.it>
Dipartimento di Informatica
Corso Italia 40
I-56125 Pisa, Italy
+39 (50) 510-111
GNU: help on obtaininig GNU, for italian sites.
Updated: 18/11/91

Randolph Back <rback@boulder.Colorado.edu>
Back Software & Consulting, Inc.
1705 14th St. #344
Boulder, CO 80302
(303) 443-7758
Consulting, installation, cutomization and training for GNU emacs, and
other GNU software.
Entered: 3/13/91

Andrea Baldi
European Space Agency (ESA)
European Space Operations Center (ESOC)
Robert-Bosch-Str 5
D-6100 DARMSTADT
West-Germany
Phone 0049-6151-902762 (Work) Bitnet : <abaldi@esoc.bitnet>
Fax 0049-6151-90-495 Uucp : <unido!esoc.bitnet!abaldi>
Your Rate: Free
Programs Supported: Emacs, bison, gcc, g++, gdb, bash, X11
Emacs: installation and upgrading aid, answering, customization.
Gcc, g++, gdb, bash: installation and upgrading aid.
X11: quick questions
Experience (with gnu software)
I have maintained Emacs for more than 4 years as well as bison, gcc,
g++, gdb, bash, X11. I have written/modified several Emacs lisp programs.
Currently I maintain many GNU programs for my department.
Updated: 11 Sept 91

Bard Bloom
Department of Computer Science
Cornell University
Ithaca, NY 14850
607-255-9211
Your Rate: $200/hour.
I might do work for friends and worthy organizations for free.
Programs Supported: GNU Emacs
Experience: Lots. For example, in 1989 I wrote a safe multi-user
database program of sorts in Gnu Emacs in about a week.
I've written some 30,000 lines of Gnu Lisp code in total.
Degree: PhD in CS from MIT.
Other: My real life as a professor takes precedence over consulting.
Updated: 11 Sept 91

James Craig Burley
4 Mountain Gate Rd.
Ashland, MA 01721-2326
(508) 881-6087, -4745
Email: <burley@gnu.ai.mit.edu> (preferred)
<burley@cygnus.com>
<burley@world.std.com>
Expertise:
Compiler Internals (author of GNU Fortran, for example)
Operating Systems Internals (lately Linux on the ix86)
Tools/Utilities Development and Maintenance
Microcode Development and Maintenance (primarily VLIW machines)
Debugging (often asked to help debug Other People's Code)
Documentation (authored many books and ran a few doc projects)
Extensive experience with a variety of operating systems, hardware,
languages, and so on
Rate: $75/hour, though somewhat volatile due to commitments regarding
GNU Fortran -- willing to consider flat-fee arrangements
Entered: 10 Jul 92

Michael I. Bushnell <mib@gnu.ai.mit.edu>
NE43-426, 545 Technology Square
Cambridge, MA 02139
(617) 253-8568
All GNU software: Installation, customization, answering simple or
complex questions, bug fixing, extension.
Experience: I have done Unix and GNU programming for several years,
I am the primary author of the Hurd (which provides most
kernel related facilities for the GNU OS).
I am easily available in the Cambridge/Boston area; work via email.
I am willing to travel for sufficiently large jobs.
Rates: $50/hr, negotiable, less for non-profit organizaions.
Updated: 10/29/91

C2V Renaud Dumeur <renaud@ccv.fr>
82 bd Haussmann Jean-Alain Le Borgne <jalb@ccv.fr>
75009 Paris
France
Tel (1) 40.08.07.07
Fax (1) 43.87.35.99
Emacs: questions answered, installation, teaching (all levels), elisp
and C extensions and customization, porting, troubleshooting
gcc: installation, extensions, porting
gdb: installation, debugging, porting
X11: installation, debugging, internationalization
Experience: yes (ask for details)
Rates: 500ff/hr, negotiable.
Entered: 12/17/91

Mr. David J. Camp <david@wubios.wustl.edu>
6103 Charlotte Avenue
Saint Louis, MO 63120-1201
Background: Bachelor of Science in Computer Science, Washington University
Master of Science in Computer Science, Washington University
Over 12 years experience in the computer industry.
Author of the future GNU uu/xxen/decoder program.
Skilled in many languages, including C and Unix scripts.
Tasks: I can do on-site service in the St. Louis area.
I prefer short-term projects.
I can handle long projects given time.
I reserve the right to refuse work.
Rates: $50 per hour, including travel time
Entered: 1/1/91

Computing Support Team (CSTeam)
111 College Place, Rm 2-212
Syracuse, NY, 13244-4100
phone: 1-315-443-3929, fax: 1-315-443-4745, email: <info@csteam.com>
The Computing Support Team offers a wide variety of support services
including system design, installation, software support, contract
programming, network design, integration and migration services,
training, e-mail and telephone support. Experienced with GNU, X, TeX,
and other public domain software.
Rates: $50-$80/hr, 33% non-profit discount.
Entered: 10 Jul 92

Contributed Software
Graefestr. 76
1000 Berlin 61, Germany
phone: (+49 30) 694 69 07
modems: (+49 30) 694 {61 82 | 67 49 | 68 09}
email: <info@contrib.de>
internet: scuzzy.contrib.de [192.109.39.1]
We distribute, install/port, teach and support free software
in general, i.e. X11, GNU, khoros etc.
Rates are DM 150,-- plus tax per hour, educational sites get rebates.
Entered: 10 Jul 92

Cygnus Support <info@cygnus.com>
814 University Avenue ...uunet!cygint!info
Palo Alto, CA 94301
+1 415 322 3811 Voice
+1 415 322 3270 FAX
Cygnus Support offers warranty protection (service contracts) for a
number of free software tools. For a fixed annual fee our customers
receive binary and source distributions, mail and phone support,
documentation and customization assistance on a variety of popular
platforms.
At the time of this writing we offer support for a development package
including (among other things) gcc, g++, gdb, and of course, GNU
Emacs. We also offer support for a network facilities package
including many of the Athena tools like Kerberos and Hesiod. However
the set of supported tools and platforms increases frequently so
contact us for the latest information.
For those who need on-site assistance, support is also available from
our Cambridge office.
Rates: $300/hour. Annual Support starts at $35,000.
Updated: 11 Sept 91

Bradley N. Davis <b-davis@jaguar.utah.edu>
3242 South 540 West
Bountiful, UT 84010
(801) 298-6345
Will work on most GNU software. Especially GNU Emacs, GCC and a
little X11 and G++. Experienced with PCs and 386s.
Services offered: Installation, porting, customizing, troubleshooting.
Fee: $20 to $50 / hour depending on job
Updated: 6/11/91

DePalma SoftCraft Contact: Mauro DePalma
2923 Cohansey Drive Voice: (408) 259-4789
San Jose, CA 95132-1619 Fax: (408) 259-6935
Internet: <mauro@netcom.com> (or <apple!netcom!mauro>)
DePalma SoftCraft provides distribution, installation, setup, and
support for the X Window System (X11R4).
This small business provides consulting in every area of a computer
s/w project life cycle. We specialize in UNIX, GNU Development Tools
(gcc, g++, ...), RCS, and XView.
Updated: 4/29/91

Equivalent Software HB <ingwa@isy.liu.se>
Repslagaregatan 34 or <jonas-y@isy.liu.se>
582 22 Linkoping
SWEDEN
+46 (0)13 13 54 21
Equivalent Software HB is the worlds second(?) company dedicated to
supporting free UNIX software. The owners have more than 5 years of
UNIX experience, both as system adminstrators and programmers. We
also have extensive experience in maintaining the GNU programs, both
administrating it and fixing bugs.
Services offered:
- Installation and custumizing GNU and other free software. We will
make free software as easy to install and use as shrink wrapped
programs.
- Customization and porting.
- Subscriptions to new versions which we will send monthly or with
any other interval.
- Finding, Recommending and Investigation of free software in any
area of the customers choise.
- Regular consulting. We prefer smaller jobs, but are willing to
consider larger ones. We can work through the Internet, but prefer
jobs in Sweden.
Rates: For software items, request our price list.
For consulting, 450 SEK/hour.
Entered: 2/14/92

Andy Gaynor -- [Ag] <gaynor@paul.rutgers.edu>
597 Hoes Lane, Piscataway, NJ 08854
908-463-3376
GNU Emacs:
Lisp development, customization, troubleshooting, support, etc
User instruction and management for all levels of experience
Umpteen-thousand lines of Lisp code, careful study of GNU Emacs organization,
years of monitoring the UseNet Emacs and GNU groups, etc
Version 19 is due soon -- I will be up-to-speed as quickly as possible
$50/hour starting, negotiable on difficulty, organization, distribution, etc
Other Tasks:
General programming/software engineering (language software preferred)
Familiar with Unix, C, Lisp, networking, standard Unix utilities, various
other languages, etc
Contact me for more info
Entered: 10 Feb 92

Ron Guilmette <rfg@ncd.com>
396 Ano Nuevo Ave. #216
Sunnyvale, CA 94086
408-732-7839
Services: Development & porting of GNU software development tools.
GNU Contributions:
Invented, designed, and implemented the protoize and
unprotoize tools supplied with GCC2.
Designed and developed all code to support the generation
of Dwarf symbolic debugging information for System V Release
4 in GCC2.
Finished GCC2 port to the Intel i860 RISC processor.
Now developing GDB code for System V Release 4 support of
ELF and Dwarf.
Experience: 9+ years UNIX systems experience, all working on compilers
and related tools.
3+ years working professionally on GCC, G++, and GDB under
contract to various firms including the Microelectronics
and Computer Technology Corporation (MCC), Data General (DG),
Network Computing Devices (NCD), and Intel Corp.
Other qualifications:
Holder of both a Bachelor's and a Master's degree, both in
Computer Science.
Observer Member of ANSI X3J16 (C++ standardization) committee.
Former vice-chairman of UNIX International Programming
Languages Special Interest Group (UI/PLSIG).
Rates: Variable depending upon contract duration. Call for quote.
Updated: 9 Feb 92

Johannes M. Heuft <ksh@pcs.com>
Pfarrweg 2c
D-8000 Munich 90
Germany
Telephone: Germany+89/681773
Rate: min. DM 180.- ($ 120.-) per hour
interesting tasks for non-profit organisations may be free
Supported Programs: gcc, gas, g++, gdb, binutils, gnuplot, ...; (not emacs)
Experience: 10 years of operating system, network, and compiler
construction; also includes engineering management.
Degrees: Dipl. Inform. (similar to MS CS)
Updated: 11/9/91

Sanjay Hiranandani <4393472@mcimail.com>
16 Campus Plaza, Suite 180
Vestal, NY 13850
Work:607-729-7834 ext. 180
Home:607-748-2709
Fax:607-748-0243
Rate: $40/hr. Phone questions for free are ok as far as my schedule will permit
Lower rates for students and certain non-profit organizations
Can help with installation/customization/modification of most GNU software.
Experience: Software Development, System Administration, and Consulting on
a variety of computing platforms.
Updated: 11 Sept 91

Hundred Acre Software Consultants <info@pooh.com>
1280 Terminal Way, Suite 26 <uunet!heather!info>
Reno NV 89502-3243
(702) 329-9333
Hundred Acre is a consulting group providing support and development
services to organizations of all sizes. We support all kinds of publicly
available software, not just GNU; write for the current list. We work on
a "service contract" basis for support -- for a yearly fee, we provide email
and toll free telephone support, and free updates and bug fixes. Certain
support levels even have free on-site support. Development is charged on
either an hourly or fixed bid basis.
Consulting rates: $50 to $70 per hour, or fixed bid.
Support contracts: Several levels, from $500 to $30000 per year.
Updated: 2 Jul 91

Jose A. Fernandez <jaf@inference.com>
WORK: Inference Corporation HOME:
550 N. Continental Blvd. 1025 Hillside Dr.
El Segundo, CA 90245 Chino Hills, CA 91709
(310) 322-0200 (714) 528-2523
RATES:
$50-$200/hour plus expenses (or possibly free), depending on task.
SERVICES:
GNU software: installation, troubleshooting, and customization.
X11 software: installation and troubleshooting.
SysAdmin: installation, configuration, and trouble-shooting.
NetAdmin: installation, configuration, and trouble-shooting.
Education: teaching how to fish opens the demand for fishing poles.
Advice: free over email.
Entered: 10 Jul 92

Scott D. Kalter <sdk@twinsun.com>
970 Palm Ave. #218
West Hollywood, CA 90069
Home: (213)657-9174
Work: (213)524-1805
Emacs: e-lisp and C level customization/extension
training for general use and customization
user support, installation, troubleshooting
Rates: approx. $50/hr, negotiable
Very willing to answer quick questions for free.
Prefer e-mail communication to telephone.
Qualifications: BS Math/CS 1985: Carnegie Mellon University
MS CS 1988: UCLA
Extensive e-lisp level modification for rapid prototyping of
designs used in groupware research. Very familiar with all
levels of elisp programming. Taught Emacs use and
customization in universities and industry. Extensive
troubleshooting and user support experience.
Updated:10/10/91

Scott J. Kramer <sjk@aura.nbn.com>
P.O. Box 3392
San Rafael, CA 94912
+1 415-454-1295
Emacs: Tutoring, installations/upgrades, Lisp customizations,
general troubleshooting/support. Prefer that work I do
becomes part of the official Free Software Foundation
distribution.
Rate: Task- and time-dependent; non-monetary offers considered.
Updated: 28Aug91

Fen Labalme <fen@well.sf.ca.us>
Broadcatch Technologies
40 Carl St. #4
San Francisco CA 94117
(415) 731-1174
Rates: Free phone consultation
Extended project or consultation: $70/hour plus expenses
Non-profits get lower rates or free; barter welcome!
Emacs: Anything but specific termcap questions (general ones OK).
Includes elisp extensions & teaching beginning or advanced users.
Experience: I've been "hacking Emacs" for just about 15 years now.
Updated: 7/30/91

David C Lawrence <tale@cs.rpi.edu>
P.O. Box 61
North Chatham, NY 12132-0061
Home:518 766-9098 Work:518 851-2813
Rates: $30 hour for projects less than 8 hours.
$20 hour for longer projects.
Course fees vary with level of subject being taught.
Short queries answered free of charge.
All rates negotiable.
Support: Emacs (both lisp and C aspects), GCC, GAWK, sed, fileutils,
binutils, miscellaneous others. Definitely not G++.
Consulting via email or telephone, or possibly on-site.
Updated: 11 Sept 91

Greg Lehey
LEMIS
Schellnhausen 2
W-6324 Feldatal
Germany
Phone: +49-6637-1488
Fax: +49-6637-1489
Mail <grog%lemis@Germany.EU.net>
Services: Supply, porting, installation, consultation on all GNU
products.
Experience: 20 years OS and compiler experience, portations of most
GNU products.
Entered: 10 Jul 92

Marty Leisner <leisner.henr801c@xerox.com>
332 Shaftsbury Road
Rochester, New York 14610
Home:(716) 654-7931
Experience: 10 years C/Unix, 7 years DOS.
Extensive experience with GNU binary tools, cross-compilers,
embedded/hosted systems.
Degree : BS CS, Cornell University
Rates: $75/hr
Updated: 6 Jul 91

Roland McGrath <roland@idr.org>
545 Tech Sq rm 426
Cambridge, MA 02139
Work: (617) 253-8568
Co-author of GNU Make (with Richard Stallman); maintainer of GNU Make.
Author and maintainer of the GNU C Library and parts of the GNU Hurd.
FSF employee summer 1989, fall 1990 to the present.
Installation, maintenance, porting, enhancement of all GNU software.
Fees negotiable. I can work anywhere in the Boston or SF Bay Area, or
anywhere on the Internet.
Updated: 10/18/92

Lee McLoughlin <lmjm@doc.ic.ac.uk>
Department of Computing,
Imperial College,
180 Queens Gate,
London
SW7 2BZ,
UK work: +44 71 589 5111 X 5085
gcc, emacs: can support and port to new machines
other: some experience with most gnu packages
Ported emacs to two new platforms (WhiteChappel Worstations,
HLH Orion). Worked on gcc port to Intergraph Clipper. Support
various gnu packages as part of a teaching service.
Rates: Quick phone questions are free.
Degrees:.Sc(Hons) Computer Science
Other: I'm a general workaholic and well versed in compilers, communications
and most things related to Unix.
Updated: 10.10.91

T.S.Mohan <mohan%vidya@shakti.ernet.in>
KBCS Group <mohan@vigyan.ernet.in>
Supercomputer Education and Research Centre
Indian Institute of Science
Bangalore 560 012
INDIA
Telephone (01-91-812)-341811, -341805
Rate: NIL. Availability for consultancy depends on
work load. High preference for academic institutions.
Support: emacs, gdb, gcc, g++ and other small public domain utilities
Experience: Installed and supported these + other gnu programs in our
centre for the past three years. General help to sister academic
departments and other academic institutions.
Degrees: Master of Engineering in CS. Currently working towards a PhD
in Distributed computing and programming languages.
Updated: 1 Dec 1991

Mojave Systems <mojsys!support@uunet.uu.net>
1254 Harvard Avenue
Claremont, CA 91711
714-621-7372
Mojave Systems offers porting services, warranty protection, and
software support for several GNU products. Porting services are
provided for a fixed fee. Software support is provided for fixed
annual fee.
Mojave Systems is able to provide these services for a wide variety of
hosts. We are currently porting GNU make and RCS to non-Unix hosts.
Entered: 12 Dec 90

Eric Raible <raible@nas.nasa.gov>
Nasa Ames Research Center
Mail Stop T045-1
Moffett Field, CA, 94035
(415) 604-4320 (W)
Rates: $40 hour; email questions free.
Gnu emacs C/lisp programming and porting. General
unix/graphics/emacs hacking, especially on Silicon Graphics
workstations.
Degree: MIT 83 BS CS.
Updated: 11 Sept 91

Paul Reilly <reilly@dg-rtp.dg.com>
721 Bennington Drive
Raleigh, NC 27615
Work: 919 248 6210
Home: 919 847 7294
Services: access, installation, porting, customizing and debugging
Unix Free software: X11, GNU, TeX, etc.
Rates: $150/hour
Updated: Dec 1991

Adam J. Richter <adam@soda.berkeley.edu> ...!ucbvax!soda!adam
409 Evelyn Avenue, Apartment 312 (510) 528-3209
Albany, CA 94706 fax: (510) 528-8508
X windows server expert. Freeware (especially copylefted) projects
preferred.
Updated: 18 Nov 91

Wolfgang S. Rupprecht <wolfgang@wsrcc.com>
PO Box 6524 <uunet!wsrcc!wolfgang>
Alexandria, VA 22306-0524 <wolfgang%wsrcc.com@uunet.uu.net>
(703) 768-2640
Emacs: Anything, (lisp, C, customization, porting, installing) I have
written thousands of lines of GNU Emacs C and Lisp code. Original
author of the floating point additions to appear in Emacs 19.
Rates: $75/hr.
Updated: 7/20/91

John Sechrest
Jasmic Systems Internet: <sechrest@jasmic.uucp>
2140 SW 49th St. UUCP: <hp-pcd!orstcs!jasmic!sechrest>
Corvallis, Oregon 97333
Gnu software: Questions about gnu emacs general use, training and classes,
documentation, system set up and design.
Experience: 11 years of Unix work. Heavy on System administration.
Teaching classes in Unix system administraion, Unix
Kernal Programming, Networking and Consulting services.
Currently working as the Support Coordinator for
Oregon State University (for 8 years).
Familiar with BSD systems mostly. Some SysVR4.
I have supported VAxes, HP's with HPUX, HP's with 4.3 BSD,
Sequent's, Next's and a few other misc. machines.
Updated: 28 Oct 1991

Steve Simmons <scs@lokkur.dexter.mi.us>
Inland Sea
9353 Hidden Lake Circle
Dexter, MI 48130
313-769-4086 (office1)
313-426-2086 (office2)
Rate: $75.00/hr for straight time until Jan 1, 1992. Rates will go up
an undetermined amount at that time. Free advice for short questions
by phone or email.
Programs Supported: Any. Quality of support I can offer depends on
the nature of the software; in particular I am *not* a compiler person.
Experiance: 13 years in computing, 10 with UNIX and various derivatives.
Specialist in systems administration. Lots of network admin.
Degree: Bachelors from University of Michigan, 1980.
Updated: 10 Oct 91

Lynn Slater <lrs@indetech.com>
42075 Lawrence Place
Fremont Ca 94538
Office (415) 438-2048; Home (415) 793-1864; Fax (415) 438-2034
Programs: Gnu Emacs Ada Mode, Gnu Emacs Empire Tool, Emacs,
g++ and gnumake (limited support only).
Experiance:
Gnu Emacs Ada Mode -- Co-author, principle integrator
Gnu Emacs Empire Tool -- Originator, co-author, principle distributor
Emacs -- Almost all parts. Authored super-apropos, headers, first GDB
interface, fancy-lisp, enhanced scribe mode,and lots of small stuff
g++ -- Have maintained, modified, and used G++ on 300+ user commercial
OLTP software.
gnumake -- Have bug fixed and extended.
Have single makefile that can merge in local changes and build the
following systems in a consistent manner in multiple releases on multiple
machines:
asm, bison, gcc, g++, emacs, rcs, gdb, libg++, att c++ libs, gnumake,
diff, tex2iroff
The makefile and related techniques are a bit hard to explain, but they
enable use and local changes in a broad spectrum of FSF code on many
platforms without having to remember all the individual make procedures.
Rate: Free for good cause or short stuff as there is time.
Am most likely to help in areas in which I have had problems or expect to
have problems.
Updated: 10 Oct 91

Small Business Systems, Inc. <postmaster@anomaly.sbs.com>
Box 17220, Route 104
Esmond, RI 02917
401.273.4669
Rate: Varies depending on complexity of task.
Hourly and fixed-rate contracts are available.
Programs Supported: All
Updated: 11 Sept 91

Randall D. Smith <randy@ai.mit.edu>
20 Watson Street
Cambridge, MA 02139, USA
+1 (617) 983-0276
Will work on most GNU software.
Installation, handholding, trouble shooting, extensions, teaching,
GCC, GDB, GNU-EMACS, and other ports.
Rates: Upward from $50.00/hour depending on my expertise in the area of the
job. GDB consulting at $80.00/hour.
Experience: 4 years of intensive experience with Unix and C including
system hacking and modification. Experience in porting GNU-EMACS (to
SGI Iris 4D) and GCC (to use Sun FPA chip). Experience working
full-time for the GNU project on other GNU programs (June 1988 -
August 1989). Primary maintainer of GDB and the GNU loader for that
period. Resume available on request.
Entered: 10 Feb 92

Richard M. Stallman <rms@prep.ai.mit.edu>
UUCP: {mit-eddie,ucbvax,uunet,harvard,uw-beaver}!ai.mit.edu!rms
545 Tech Sq, Rm 430
Cambridge, MA 02139
Emacs: anything whatever
Is anyone interested in courses in using or extending GNU Emacs?
Original inventor of Emacs and main author of GNU Emacs and GCC.
Rates: $6/min or $250/hr.
Entered: 5/24/90

Jonathan Stone <jonathan@isor.vuw.ac.nz>
c/o- Institute of Statistics and Operations Research
Victoria University of Wellington
P.O Box 600
Wellington
New Zealand
Work: +64 4 715-315 Fax: +64 4 712-070
Rate: hourly rate: NZ $ 150/hr. Quick phone questions are free.
Reduced rates available for for non-profit/educational insts
and daily rate work. Fixed-price contracts also considered.
Programs: GNU Emacs, GCC, GDB, GNU binutils,
Ghostscript, MIT X11
I am the author of the Pyramid ports of gcc and gdb.
Experiance: Five years administration of Unix systems and GNU tools
in University environments, and support of Unix administrators
and GNU tools as an external contractor to New Zealand Government
departments.
Degrees: M.Sc (Distinction) for a thesis involving work done on GCC.
Updated: 28 Aug 91

Bob Sutterfield <bob@morningstar.com>
work: home:
Morning Star Technologies
1760 Zollinger Road 3542 Norwood Street
Columbus, Ohio 43221 USA Columbus, Ohio 43224-3424 USA
(614)451-1883 (614)267-7611
Rates: $50/hr (negotiable) plus travel expenses
Gratis to Christian missionaries and mission agencies
Services: Installation, troubleshooting, and mild customization of
most GNU production and beta-test software; tutorials, training,
and handholding; general UNIX system and network consulting.
Entered: 2/16/92

Kayvan Sylvan <kayvan@satyr.Sylvan.COM>
Sylvan Associates
879 Lewiston Drive
San Jose, CA 95136
Phone: 408-978-1407
I will help you port, install and customize GNU Emacs, GCC, G++,
bison, and other GNU tools on almost any architechture and operating
system. Questions answered. GNU C and lisp hacking available. I will
also do ongoing support and periodic upgrades if you get on my GNU
software subscription list.
Rates: $60-$100/hour, depending on type of work. Substantial discounts
for long-term contracts and also for educational or non-profit
institutions.
Experience: Many different Unix systems (2.9BSD to 4.3BSD, SVR3 and
SVR4, Xenix). Systems programming and system administration on all
brands of Unix. Kernel hacking experience. Lots of porting experience.
I can port anything to anything (within reason).
Updated: 10 Jul 92

Leonard H. Tower Jr. <tower@prep.ai.mit.edu>
36 Porter Street
Somerville, MA 02143, USA
+1 (617) 623-7739
Will work on most GNU software.
Installation, handholding, trouble shooting, extensions, teaching.
Rates: 100.00/hour + travel expenses. Negotiable for non-profits.
Experience: Have hacked on over a dozen architectures in many languages. Have
system mothered several varieties of Unixes. Assisted rms with the front end
of gcc and it's back-end support. Resume available on request.
Entered: 12 Feb 92

Watchmaker Computing <support@watch.com>
P.O.Box 163, Kendall Square
Cambridge, MA 02142
email: support@watch.com
Emacs: We'll do GNUEmacs support, porting, bug fixing, and customizing.
We also have specific expertise in:
packages: GCC, G++, X11, Xt, InterViews, PERL, TeX, Epoch
languages: C, C++, Lisp, most others; we learn quickly!
Extensive experience coding for portability under UNIX.
Typical rates $35-$150/hour; will telecommute (Internet or phone)
Entered: 1/16/91

Chris Welty <weltyc@cs.rpi.edu>
RPI Computer Science Dept
Troy, NY 12180
518-276-2816 (W)
EMail correspondance preferred.
Rates vary depending on need, barter often accepted.
Programs: emacs, especially emacs lisp.
Lots of experience in various areas.
BS, MS from RPI. Currently working on PhD.
Updated: 10/10/91

Pace Willisson <pace@blitz.com>
Blitz Product Development Corporation <uunet!blitz!pace>
4 Spruce Road
Medway, MA 02053, USA
Work: (508) 533-6430
Rates: $80.00/hour
Will work on any GNU software.
Experience: 12 years working with C, Unix and Lisp Machines including
compilation systems, networks, device drivers, demand paging systems,
boot programs and window systems. Ported GDB to 80386. Designed COFF
encapsulation scheme to run GNU linker output on System 5 kernels.
Author of Unix "ispell".
Degree: BS in Computer Science from MIT
Updated: 7/31/91

Patrick Wood
Pipeline Associates, Inc.
2740 Route 10 West
Morris Plains, NJ 07950
Rate: Free
Support For: gcc, binutils, gnulib, using gcc for cross compiling
Experiance: used gcc for cross compiling for over 2 years; used
gcc for three years; installed and support gcc on several
BSD and System V UNIX systems; wrote peephole optimizer for
gcc on 68K, wrote portable replacement for FP routines in
gnulib.c. Modified gcc and binutils to work in byte-swapped
environments.
Other: email consulting only <pipeline!phw@motown.com>,
uunet!motown!pipeline!phw,sun!pipeline!phw, amdcad!pipeline!phw
Updated: 18 Sept 91

xprt Computer Consulting, Inc. <jody@shell.com>
17200 El Camino Real Suite 110 T
Houston, TX 77058
(713) 480 UNIX
(713) 486 8575 (Fax)
Programs Supported:
X11, TeX, and all of GNU.
Experience:
We have supported and maintained all of GNU, X11 and TeX for over four
years for a major oil company's research division on several different
Unix platforms.
Rates: $150/hour
Entered: 10 Jul 92

Name: david d [zoo] zuhn <zuhn@cs.umn.edu>
Company: armadillo zoo software
Fees: $50/hour, discounts for educational institutions and non-profits
GNU and X11 installation and maintainance on SGI Iris, Sun [68k &
SPARC], and Sequent machines. Additional machines a possibility.
Any GNU software installed. Most supported.
Updated: 7/11/92

** Please keep this file alphabetical **

318
etc/SUN-SUPPORT Normal file
View file

@ -0,0 +1,318 @@
NOTE: the Free Software Foundation agreed to put this file, and the
programs it describes, into the Emacs distribution ONLY on the
condition that we would not lift a finger to maintain them! We are
willing to *pass along* support for Sun windows, but we are not
willing to let it distract us from what we are trying to do. If you
have complaints or suggestions about Sun windows support, send them to
peck@sun.com, who is the maintainer.
The interface between GNU Emacs and Sun windows consists of the program
etc/emacstool, the Lisp programs lisp/sun-*.el and lisp/term/sun.el,
and the C source file src/sunfns.c. It is documented with a man page,
etc/emacstool.1.
To enable use of these files and programs, define the configuration
switch HAVE_SUN_WINDOWS in src/config.h before compiling Emacs.
The definition of HAVE_SUN_WINDOWS must precede the #include m-sun3.h
or #include m-sun4.h.
If you must change PURESIZE, do so after the #include m-sun3.h
This software is based on SunView for Sun UNIX 4.2 Release 3.2,
and will not work "as is" on previous releases, eg 3.0 or 3.1.
Using Emacstool with GNU Emacs:
The GNU Emacs files lisp/term/sun.el, lisp/sun-mouse.el,
lisp/sun-fns.el, and src/sunfns.c provide emacs support for the
Emacstool and function keys. If your terminal type is SUN (that is,
if your environment variable TERM is set to SUN), then Emacs will
automatically load the file lisp/term/sun.el. This, in turn, will
ensure that sun-mouse.el is autoloaded when any mouse events are
detected. It is suggested that sun-mouse and sun-fns be
included in your site-init.el file, so that they will always be loaded
when running on a Sun workstation. [Increase PURESIZE to 154000].
Support for the Sun function keys requires disconnecting the standard
Emacs command Meta-[. Therefore, the function keys are supported only
if you do (setq sun-esc-bracket t) in your .emacs file.
The file src/sunfns.c defines several useful functions for emacs on
the Sun. Among these are procedures to pop-up SunView menus, put and
get from the SunView selection [STUFF] buffer, and a procedure for
changing the cursor icon. If you want to define cursor icons, try
using the functions in lisp/sun-cursors.el.
The file lisp/sun-mouse.el includes a mass of software for defining
bindings for mouse events. Any function can be called or any form
evaluated as a result of a mouse event. If you want a pop-up menu,
your function can call sun-menu-evaluate. This will bring up a
SunView walking menu of your choice.
Use the macro (defmenu menu-name &rest menu-items) to define menu
objects. Each menu item is a cons of ("string" . VALUE), VALUE is
evaluated when the string item is picked. If VALUE is a menu, then a
pullright item is created.
This version also includes support for copying to and from the
sun-windows "stuff" selection. The keyboard bindings defined in
lisp/sun-fns.el let you move the current region to the "STUFF"
selection and vice versa. Just set point with the left button, set
mark with the middle button, (the region is automatically copied to
"STUFF") then switch to a shelltool, and "Stuff" will work. Going the
other way, the main right button menu contains a "Stuff Selection"
command that works just like in shelltool. [The Get and Put function
keys are also assigned to these functions, so you don't need the mouse
or even emacstool to make this work.]
Until someone write code to read the textsw "Selection Shelf", it is
not possible to copy directly from a textsw to emacs, you must go through
the textsw "STUFF" selection.
The Scroll-bar region is not a SunView scrollbar. It really should
be called the "Right-Margin" region. The scroll bar region is basically
the rightmost five columns (see documentation on variable scrollbar-width).
Mouse hits in this region can have special bindings, currently those binding
effect scrolling of the window, and so are refered to as the "Scroll-bar"
region.
For information on what mouse bindings are in effect, use the command
M-x Describe-mouse-bindings, or the quick pop-up menu item "Mouse-Help".
GNU Emacs EXAMPLES:
See definitions in lisp/sun-fns.el for examples.
You can redefine the cursor that is displayed in the emacs window.
On initialization, it is set to a right arrow. See lisp/sun-cursors.el
for additional cursors, how to define them, how to edit them.
BUGS:
It takes a few milliseconds to create a menu before it pops up.
Someone who understands the GNU Garbage Collector might see if it
is possible for defmenu to create a SunView menu struct that does
not get destroyed by Garbage Collection.
An outline of the files used to support Sun Windows and the mouse.
etc/SUN-SUPPORT.
This document.
etc/emacstool.1:
Added: an nroff'able man page for emacstool.
etc/emacstool.c:
Encodes all the function keys internally, and passes non-window
system arguments to emacs.
etc/emacs.icon:
The "Kitchen Sink" GNU Emacs icon.
src/sunfns.c:
This contains the auxilary functions that allow elisp code to interact
with the sunwindows, selection, and menu functions.
lisp/sun-mouse.el:
Defines the lisp function which is called when a mouse hit is found
in the input queue. This handler decodes the mouse hit via a keymap-like
structure sensitive to a particular window and where in the window the
hit occured (text-region, right-margin, mode-line). Three variables
are bound (*mouse-window* *mouse-x* *mouse-y*) and the selected function
is called.
See documentation on "define-mouse" or look at lisp/sun-fns.el
to see how this is done.
Defines two functions to pass between region and sun-selection
Defines functions for interfacing with the Menu.
During menu evaluation, the variables *menu-window* *menu-x* *menu-y* are bound.
lisp/sun-fns.el
The definition of the default menu and mouse function bindings.
lisp/sun-cursors.el
Defines a number of alternate cursors, and an editor for them.
The editor is also a demonstration of mouse/menu utilization.
lisp/term/sun.el
Sets up the keymap to make the sun function keys do useful things.
Also includes the setup/initialization code for running under emacstool,
which makes "\C-Z" just close the emacstool window (-WI emacs.icon).
Jeff Peck, Sun Microsystems, Inc <peck@sun.com>
Subject: Making multi-line scrolling really work:
In your .defaults file, include the line:
/Tty/Retained "Yes"
That way, the terminal emulator can do text moves using bitblt,
instead of repaint.
If that's not enough for you, then tell unix and emacs that
the sun terminal supports multi-line and multi-character insert/delete.
Add this patch to your /etc/termcap file:
*** /etc/termcap.~1~ Mon Sep 15 12:34:23 1986
--- /etc/termcap Mon Feb 9 17:34:08 1987
***************
*** 32,39 ****
--- 32,40 ----
Mu|sun|Sun Microsystems Workstation console:\
:am:bs:km:mi:ms:pt:li#34:co#80:cl=^L:cm=\E[%i%d;%dH:\
:ce=\E[K:cd=\E[J:so=\E[7m:se=\E[m:rs=\E[s:\
:al=\E[L:dl=\E[M:im=:ei=:ic=\E[@:dc=\E[P:\
+ :AL=\E[%dL:DL=\E[%dM:IC=\E[%d@:DC=\E[%dP:\
:up=\E[A:nd=\E[C:ku=\E[A:kd=\E[B:kr=\E[C:kl=\E[D:\
:k1=\E[224z:k2=\E[225z:k3=\E[226z:k4=\E[227z:k5=\E[228z:\
:k6=\E[229z:k7=\E[230z:k8=\E[231z:k9=\E[232z:
M-|sun-nic|sune|Sun Microsystems Workstation console without insert character:\
If you don't have the program "patch", just add the line:
:AL=\E[%dL:DL=\E[%dM:IC=\E[%d@:DC=\E[%dP:\
casetek@crvax.sri.com says:
Those of you using GNU Emacs on Sun workstations under
3.2 may be interested in reducing memory utilization in
the emacstool via the Sun toolmerge facility. The technique
is described in the Release 3.2 Manual starting on page
71. The following is a summary of how it would apply
to merging emacstool into the basetools.
1) Change the main procedure declaration in emacstool.c to:
#ifdef SUN_TOOLMERGE
emacstool_main (argc, argv);
#else
main (argc, argv)
#endif
This will allow creation of either standard or toolmerge
versions.
2) Copy emacstool.o into directory /usr/src/sun/suntool.
3) make CFLAGS="-g -DSUN_TOOLMERGE" emacstool.o
4) Add the following line to basetools.h
"emacstool",emacstool_main,
5) Add the following line to toolmerge.c.
extern emacstool_main();
6) make basetools MOREOBJS="emacstool.o"
7) make install_bins
To invoke the toolmerged version, you must exit suntools and
re-start it. Make sure that /usr/bin occurs before the directory
in which you installed the standard (non-toolmerged) version.
Subject: Moving selections between OW and Emacstool/xvetool
Date: Wed, 26 Jun 91 18:58:24 PDT
From: Jeff Peck <peck>
The short answer is that we can Cut and Paste between Emacstool
and TTYSW (shelltool) and we can Paste between Emacstool and TEXTSW(cmdtool)
and somewhat more slowly move from TEXTSW to Emacstool.
**** This interaction with the TTYSW selection is a HACK! ****
At end of this message is the code that should be in your sun-mouse.el or .emacs
Here's the restrictions on using it:
1. from Shelltool to Emacstool:
select text in shelltool and hit COPY.
move to Emacstool, hit PASTE. (simple, eh?)
For any other movement, you must remember this:
"The window system must believe that a shelltool has the current selection."
If you do that, then this will all work painlessly.
[that will also explain why you can not make a selection in a cmdtool
and then directly PASTE it into Emacstool]
2. from Emacstool to Shelltool
ensure that a shelltool has the selection: (select something and hit COPY)
in emacstool select a region and hit COPY
in shelltool hit PASTE. (not too bad, yet)
3. from Emacstool to Cmdtool
ensure that a shelltool has the selection:
(in a *shelltool* select something and hit COPY)
in emacstool select a region and hit COPY
in shelltool hit PASTE. (ok, its getting crufty)
4. from Cmdtool to Emacstool
select in Cmdtool, hit COPY
in a shelltool, % cat > /dev/null
then hit PASTE
Select the text again, from the shelltool this time. hit COPY
in emacstool, hit PASTE
4a. from Cmdtool (or shelltool) to Emacstool
the function "sunview-yank-any-selection" should be bound to Meta-PASTE
If so, then just:
select in Cmdtool
in emacstool, hit Meta-PASTE
This uses the function "sunview-yank-current-selection"
which relies one the (supported) utility "get_selection"
As such, it is *not* a hack, but it *IS* SLOW (or slower)
If you know that a shelltool *still* has the selection
(note: nothing you do with Emacstool or the PASTE key will affect that)
then the "ensure..." line is a NO-OP.
Note that using COPY in emacstool will change the *value* of the selection
behind the window systems back:
the holder of the selection doesn't know of this,
the window system doesn't know of this,
and the highlighted text *WILL NOT CHANGE*
Turns out the selection value is written into a /tmp/ttyselection file
and emacs just rewrites that file, clever, eh?
Your version of sun-mouse.el should include these functions
(or put them into your .emacs)
;;; define the selection file used by this emacs
;;; if not local machine, then automounter must find /net/<host>/tmp
(defconst owselectionfile
(let ((display (getenv "DISPLAY")))
(if (null display)
nil ; no DISPLAY variable -- return nil
(let ((colon_at (string-match ":" display)))
(if (null colon_at)
nil ; no colon in environment variable -- return nil
(if (zerop colon_at)
"/tmp/ttyselection" ; colon is first character
(concat "/net/" (substring display 0 colon_at) "/tmp/ttyselection")
)))))
)
(defun xv-yank-selection ()
"Set mark and yank the contents of the current Xview selection
into the current buffer at point. The STUFF selection contains the currently
or previously highlighted text from a TTYSW."
(interactive "*")
(insert-file owselectionfile)
(exchange-point-and-mark)
)
(defun xv-select-region (beg end)
"Set the TTYSW selection to the region in the current buffer."
(interactive "r")
(write-region beg end owselectionfile nil 'noprint)
)
You can then bind these to Copy and Paste in your .emacs
(setq suntool-map-hooks '( ; not your usual hook list
(define-key suntool-map "fl" 'xv-select-region) ; L6 Copy
(define-key suntool-map "hl" 'xv-yank-selection) ; L8 Paste
)
)

41
etc/SUNBUG Normal file
View file

@ -0,0 +1,41 @@
From: coho!daveg (Dave Gagne)
Subject: Re: Problems with building emacs on SunOS 4.0 (EXPORT)
Summary: SunOS 4.0_Export "cc -Bstatic" don't work.
Organization: UBC Dept. of Electrical Engineering, Vancouver, Canada
> Has anyone else seen similar problems?
Yes indeed. Anyone who does not live in the jolly US of A.
What you are encountering is a screw-up in SunOS 4.0_Export. This
problem only occurs in the "EXPORT" version of SunOS 4.0: ie the
software which Sun ships outside of the USA. The problem has something
to do with Sun not wanting to ship their DES chips outside of the good
'ole USA. What we poor foreigners get instead is some buggered up
software.
What all this means is that "cc -Bstatic ..." WILL NOT WORK ON SUNOS
4.0 EXPORT without a little help from "ar". The static C-library is
/lib/libc.a, and this is where the problem occurs. There are a bunch of
.o files in there relating to DES stuff (des_crypt.o, des_soft.o, _crypt.o,
etc). All of them will case cc -Bstatic to die as you found with the
errors:
> _edata: ld: user attempt to redefine loader-defined symbol
> _end: user attempt to redefine loader-defined symbol
> _etext: /lib/libc.a(des_crypt.o): multiply defined
In order to make cc -Bstatic useful, you must remove all the
brain-damaged .o files from /lib/libc.a. To do this use
ar d /lib/libc.a des_crypt.o des_soft.o _crypt.o ....
(Make a backup of /lib/libc.a first, you may decide you need the "real"
thing someday). Note that there are a bunch of these files, I can't
remember all of them. You will find them quick enough by trying to
compile ANY C program, even one which does NOTHING.
After you have done this, Emacs should compile OK. I was able to get
both the "normal" text version and the X-windows (X11R2) version to
compile OK. It seems to me that the Suntools version may not have worked,
but I may just be halucinating.

229
etc/TERMS Normal file
View file

@ -0,0 +1,229 @@
This file describes what you must or might want to do to termcap entries
to make terminals work properly and efficiently with Emacs. Information
on likely problems with specific types of terminals appears at the end
of the file.
*** What you want in a terminal ***
Vital
1. Easy to compute suitable padding for.
2. Never ever sends ^S/^Q unless you type them, at least in one mode.
Nice for speed
1. Supports insert/delete of multiple lines in one command.
2. Same for multiple characters, though doing them one by
one is usually fast enough except on emulators running on
machines with bitmap screens.
Nice for usability
1. Considerably more than 24 lines.
2. Meta key (shift-like key that controls the 0200 bit
in every character you type).
*** New termcap strings ***
Emacs supports certain termcap strings that are not described in the
4.2 manual but appear to be standard in system V. The one exception
is `cS', which I invented.
`AL' insert several lines. Takes one parameter, the number of
lines to be inserted. You specify how to send this parameter
using a %-construct, just like the cursor positions in the `cm'
string.
`DL' delete several lines. One parameter.
`IC' insert several characters. One parameter.
`DC' delete several characters. One parameter.
`rp' repeat a character. Takes two parameters, the character
to be repeated and the number of times to repeat it.
Most likely you will use `%.' for sending the character
to be repeated. Emacs interprets a padding spec with a *
as giving the amount of padding per repetition.
WARNING: Many terminals have a command to repeat the
*last character output* N times. This means that the character
will appear N+1 times in a row when the command argument is N.
However, the `rp' string's parameter is the total number of
times wanted, not one less. Therefore, such repeat commands
may be used in an `rp' string only if you use Emacs's special
termcap operator `%a-c\001' to subtract 1 from the repeat count
before substituting it into the string. It is probably safe
to use this even though the Unix termcap does not accept it
because programs other than Emacs probably won't look for `rp'
anyway.
`cs' set scroll region. Takes two parameters, the vertical
positions of the first line to include in the scroll region
and the last line to include in the scroll region.
Both parameters are origin-zero. The effect of this
should be to cause a following insert-line or delete-line
not to move lines below the bottom of the scroll region.
This is not the same convention that Emacs version 16 used.
That is because I was led astray by unclear documentation
of the meaning of %i in termcap strings. Since the termcap
documentation for `cs' is also unclear, I had to deduce the
correct parameter conventions from what would make the VT-100's
`cs' string work properly. From an incorrect assumption about
%i, I reached an incorrect conclusion about `cs', but the result
worked correctly on the VT100 and ANSII terminals. In Emacs
version 17, both `cs' and %i work correctly.
The version 16 convention was to pass, for the second parameter,
the line number of the first line beyond the end of the
scroll region.
`cS' set scroll region. Differs from `cs' in taking parameters
differently. There are four parameters:
1. Total number of lines on the screen.
2. Number of lines above desired scroll region.
3. Number of lines below (outside of) desired scroll region.
4. Total number of lines on the screen, like #1.
This is because an Ambassador needs the parameters like this.
`cr', `do', `le'
Emacs will not attempt to use ^M, ^J or ^H for cursor motion
unless these capabilities are present and say to use those
characters.
`km' Says the terminal has a Meta key.
Defining these strings is important for getting maximum performance
from your terminal.
Make sure that the `ti' string sets all modes needed for editing
in Emacs. For example, if your terminal has a mode that controls
wrap at the end of the line, you must decide whether to specify
the `am' flag in the termcap entry; whichever you decide, the `ti'
string should contain commands to set the mode that way.
(Emacs also sends the `vs' string after the `ti' string.
You can put the mode-setting commands in either one of them.)
*** Specific Terminal Types ***
Watch out for termcap entries for Ann Arbor Ambassadors that
give too little padding for clear-screen. 7.2 msec per line is right.
These are the strings whose padding you probably should change:
:al=1*\E[L:dl=1*\E[M:cd=7.2*\E[J:cl=7.2*\E[H\E[J:
I have sometimes seen `\E[2J' at the front of the `ti' string;
this is a clear-screen, very slow, and it can cause you to get
Control-s sent by the terminal at startup. I recommend removing
the `\E[2J' from the `ti' string.
The `ti' or `vs' strings also usually need stuff added to them, such as
\E[>33;52;54h\E[>30;37;38;39l
You might want to add the following to the `te' or `ve' strings:
\E[>52l\E[>37h
The following additional capabilities will improve performance:
:AL=1*\E[%dL:DL=1*\E[%dM:IC=4\E[%d@:DC=4\E[%dP:rp=1*%.\E[%a-c\001%db:
If you find that the Meta key does not work, make sure that
:km:
is present in the termcap entry.
Watch out for termcap entries for VT100's that fail to specify
the `sf' string, or that omit the padding needed for the `sf' and `sr'
strings (2msec per line affected). What you need is
:sf=2*^J:sr=2*\EM:cs=\E[%i%d;%dr:
The Concept-100 and Concept-108 have many modes that `ti' strings
often fail to initialize. If you have problems on one of these
terminals, that is probably the place to fix them. These terminals
can support an `rp' string.
Watch out on HP terminals for problems with standout disappearing on
part of the mode line. These problems are due to the absence of
:sg#0: which some HP terminals need.
The vi55 is said to require `ip=2'.
The Sun console should have these capabilities for good performance.
:AL=\E[%dL:DL=\E[%dM:IC=\E[%d@:DC=\E[%dP:
The vt220 needs to be set to vt220 mode, 7 bit, space parity
in order to work fully with TERM=vt220.
If you are using a LAT terminal concentrator, you need to issue these
commands to turn off flow control:
set port flow control disable
define port flow control disable
On System V, in the terminfo database, various terminals may have
the `xt' flag that should not have it. `xt' should be present only
for the Teleray 1061 or equivalent terminal.
In particular, System V for the 386 often has `xt' for terminal type
AT386 or AT386-M, which is used for the console. You should delete
this flag. Here is how:
You can get a copy of the terminfo "source" for at386 using the
command: `infocmp at386 >at386.tic'. Edit the file at386.tic and remove
the `xt' flag. Then compile the new entry with: `tic at386.tic'.
It is also reported that these terminal types sometimes have the wrong
reverse-scroll string. It should be \E[T, but sometimes is given as \E[S.
Here is what watserv1!maytag!focsys!larry recommends for these terminals:
# This copy of the terminfo description has been fixed.
# The suggestions came from a number of usenet postings.
#
# Intel AT/386 for color card with monochrome display
#
AT386-M|at386-m|386AT-M|386at-m|at/386 console,
am, bw, eo, xon,
cols#80, lines#25,
acsc=``a1fxgqh0jYk?lZm@nEooppqDrrsstCu4vAwBx3yyzz{{||}}~~,
bel=^G, blink=\E[5m, bold=\E[1m, cbt=\E[Z,
clear=\E[2J\E[H,
cr=\r, cub=\E[%p1%dD, cub1=\E[D, cud=\E[%p1%dB,
cud1=\E[B, cuf=\E[%p1%dC, cuf1=\E[C,
cup=\E[%i%p1%02d;%p2%02dH, cuu=\E[%p1%dA, cuu1=\E[A,
dch=\E[%p1%dP, dch1=\E[P, dl=\E[%p1%dM, dl1=\E[1M,
ech=\E[%p1%dX,ed=\E[J, el=\E[K, el1=\E[1K\E[X, flash=^G, home=\E[H,
hpa=\E[%i%p1%dG, ich=\E[%p1%d@, ich1=\E[1@, il=\E[%p1%dL, il1=\E[1L,
ind=\E[S, indn=\E[%p1%dS, invis=\E[9m,
is2=\E[0;10;38m, kbs=\b, kcbt=^], kclr=\E[2J,
kcub1=\E[D, kcud1=\E[B, kcuf1=\E[C, kcuu1=\E[A,
kdch1=\E[P, kend=\E[Y, kf1=\EOP, kf10=\EOY, kf11=\EOZ,
kf12=\EOA, kf2=\EOQ, kf3=\EOR, kf4=\EOS, kf5=\EOT,
kf6=\EOU, kf7=\EOV, kf8=\EOW, kf9=\EOX, khome=\E[H,
kich1=\E[@, knp=\E[U, kpp=\E[V, krmir=\E0, rev=\E[7m, ri=\E[T,
rin=\E[%p1%dT, rmacs=\E[10m, rmso=\E[m, rmul=\E[m,
sgr=\E[10m\E[0%?%p1%p3%|%t;7%;%?%p2%t;4%;%?%p4%t;5%;%?%p6%t;1%;%?%p9%t;12%;%?%p7%t;9%;m,
sgr0=\E[0;10m, smacs=\E[12m, smso=\E[7m, smul=\E[4m,
#
# AT&T 386 color console
#
AT386|at386|386AT|386at|at/386 console,
colors#8, ncv#3, pairs#64,
is2=\E[0;10;39m,
op=\E[0m,
setb=\E[%?%p1%{0}%=%t40m
%e%p1%{1}%=%t44m
%e%p1%{2}%=%t42m
%e%p1%{3}%=%t46m
%e%p1%{4}%=%t41m
%e%p1%{5}%=%t45m
%e%p1%{6}%=%t43m
%e%p1%{7}%=%t47m%;,
setf=\E[%?%p1%{0}%=%t30m
%e%p1%{1}%=%t34m
%e%p1%{2}%=%t32m
%e%p1%{3}%=%t36m
%e%p1%{4}%=%t31m
%e%p1%{5}%=%t35m
%e%p1%{6}%=%t33m
%e%p1%{6}%=%t33m
%e%p1%{7}%=%t37m%;,
use=at386-m,
#
# Color console version that supports underline but maps blue
# foreground color to cyan.
#
AT386-UL|at386-ul|386AT-UL|386at-ul|at/386 console,
is2=\E[0;10;38m,
use=at386,

26
etc/TO-DO Normal file
View file

@ -0,0 +1,26 @@
Things useful to do for GNU Emacs:
* Primitive for random access insertion of part of a file.
* Making I/O streams for files, so that read and prin1 can
be used on files directly. The I/O stream itself would
serve as a function to read or write one character.
* If a file you can't write is in a directory you can write,
make sure it works to modify and save this file.
* Make dired's commands handle correctly the case where
ls has listed several subdirectories' contents.
It needs to be able to tell which directory each file
is really in, by searching backward for the line
which identifies the start of a directory.
* Add more dired commands, such as sorting (use the
sort utility through call-process-region).
* Make display.c record inverse-video-ness on
a character by character basis. Then make non-full-screen-width
mode lines inverse video, and display the marked location in
inverse video.
* VMS code to list a file directory. Make dired work.

4
etc/TUTORIAL
View file

@ -296,7 +296,7 @@ commands that can destroy a lot of text save it, while the ones that
attack only one character, or nothing but blank lines and spaces, do
not save.
For instance, type C-n a couple times to position the cursor
For instance, type C-n a couple times to postion the cursor
at some line on this screen.
>> Do this now, move the cursor and kill that line with C-k.
@ -533,7 +533,7 @@ to replace it with--each one ended with a Return.
Then type M-x repl s<Return>changed<Return>altered<Return>.
Notice how this line has changed: you've replaced
the word c-h-a-n-g-e-d with "altered" wherever it occurred
the word c-h-a-n-g-e-d with "altered" wherever it occured
after the cursor.

461
etc/XDOC Normal file
View file

@ -0,0 +1,461 @@
BABYL OPTIONS:
Version: 5
Labels:
Note: This is the header of an rmail file.
Note: If you are seeing it in rmail,
Note: it means the file has no messages in it.

1,,
Received: from ATHENA (ATHENA.MIT.EDU) by prep; Thu, 19 Dec 85 23:09:34 est
Received: from PARIS (PARIS.MIT.EDU) by ATHENA (4.12/4.7)
id AA02786; Thu, 19 Dec 85 23:07:35 est
From: martillo@ATHENA.MIT.EDU (Yakim Martillo)
Received: by PARIS (5.15/4.7)
id AA24170; Thu, 19 Dec 85 23:07:36 EST
Date: Thu, 19 Dec 85 23:07:36 EST
Message-Id: <8512200407.AA24170@PARIS>
To: rms@prep
Cc: lbm
Subject: Gnu Emacs + X documentation
*** EOOH ***
From: martillo@ATHENA.MIT.EDU (Yakim Martillo)
Date: Thu, 19 Dec 85 23:07:36 EST
To: rms@prep
Cc: lbm
Subject: Gnu Emacs + X documentation
This is the start of my X documentation.
I have not finished the last five sections yet. Please give me some
suggestions.
Joachim
Special Terminal Interfaces
Some terminals provide special capabilities which can be more
effectively used via specially written C functions rather than normal
termcap processing. To ease the use of these capabilities and aid the
integration of these C functions, special terminal hooks are provided.
The hooks are all externed in the source header file termhooks.h.
To determine the arguments, the interested user who wishes to develop
a special terminal interface should consult term.c.
For proper functioning of the user defined C termhook functions, the
user should make certain that the terminal characteristics as externed
in termchar.h are properly set.
Examples of how to use the termhooks can be found in xterm.c which
contains the Gnu Emacs to X interface.
Gnu Emacs to X Interface
The termhooks feature has enough power that termhooks need not be
restricted merely to the employment of special terminal capabilities.
Termhooks can be used to interface Gnu Emacs to special graphics
devices or window systems. Gnu Emacs interfaces with not a great deal
of difficulty to the MIT/Project Athena X Window system. With not too
much effort, a competent hacker should be able to interface Gnu Emacs
to the Sun, Apollo, or Blit Window systems.
What is X?
X is a network transparent window system developed at MIT by Bob
Scheiffler, Jim Gettys, Tony della Fera, Ron Newman and others. X is
a descendent of the Stanford V kernal system and Gosling's rectangle
management system. X has a standard protocol for communication with
an X server which talks to the high resolution graphics device driver.
The X developers have supplied a library libX.a which provides library
routines to handle typical graphics/window system commands. X is
network transparent in that a process running on a machine which wants
to make use of a high resolution graphics device will establish a
network connection to the X server which talks to the driver for that
device. The process will be a client of the X server. Since LAN's
typically can move data at megabit rates, running a window system in
this fashion has many advantages. For more information about X,
hackers are directed to "Xlib - C Language X Interface Version (?)"
written by Jim Gettys (DEC/MIT) and Ron Newman (MIT).
New Functionality of Gnu Emacs + X
Gnu Emacs running as a client of X provides very rapid line insertion
and deletion because bit blit commands are sent to the server and the
driver simply tells the device to move the pixels on the screen
directly. In fact, Gnu Emacs running under the xterm terminal
emulator can also cause bit blts to take place but bit blits via the
terminal emulator are rather slow because of escape sequence parsing
overhead in the terminal emulator and because of context switching
overhead as the bits take a merry trip through the pty interfaces and
drivers.
Gnu Emacs runs in its own X window and therefore no information is
lost from the xterm session from which the user invoked Gnu Emacs.
Gnu Emacs should probably be run in background from the parent X
session because then the user may continue to do more work in the
parent xterm session. As Gnu Emacs should be run in background, the
lisp form
(put 'suspend-emacs 'disabled t)
is passed to the Gnu Emacs lisp interpreter when Gnu Emacs is invoked
from an xterm terminal emulator. Should the user accidently type the
key sequence for suspend-emacs (initially C-z or C-XC-z), he will be
queried whether he truly wishes to suspend emacs. Unless the user is
confident he should reply n (= no).
If the user has an X window manager running, the user can resize the
Gnu Emacs window using the usual mouse sequences which have been
grabbed by the window manager. Gnu Emacs then automatically resizes
itself and updates the display.
By using the mouse window manager commands, the user can cause
formerly obscured sections of the Gnu Emacs window to be uncovered.
These sections have to be repainted. Since Gnu Emacs creates the Gnu
Emacs window by its lonesome, Gnu Emacs must repaint these sections of
the window all by itself. If Gnu Emacs is chugging away on some
global regexp replacement, Gnu Emacs may take its time in repainting
the display. (Similar repainting may take place on bit blits.)
With the Gnu Emacs to X interface the mouse becomes even more
powerful. Some mouse events (basically the ones not grabbed by the
window manager) are passed to Gnu Emacs. Gnu Emacs is informed of the
reception of such events because it receives the key sequence C-cC-m.
Therefore a user who wishes to use the Gnu Emacs to X interface should
not rebind this key sequence to any function.
This key sequence is bound to the lisp function x-mouse-mode which
goes and checks the special X Mouse Queue for mouse events. Each
control/shift/meta-mouse button sequence is associated with a defined
constant in the lisp file x-mouse.el. The constants are defined as
follows:
(defconst x-button-right (char-to-string 0))
(defconst x-button-middle (char-to-string 1))
(defconst x-button-left (char-to-string 2))
(defconst x-button-s-right (char-to-string 16))
(defconst x-button-s-middle (char-to-string 17))
(defconst x-button-s-left (char-to-string 18))
(defconst x-button-m-right (char-to-string 32))
(defconst x-button-m-middle (char-to-string 33))
(defconst x-button-m-left (char-to-string 34))
(defconst x-button-c-right (char-to-string 64))
(defconst x-button-c-middle (char-to-string 65))
(defconst x-button-c-left (char-to-string 66))
(defconst x-button-m-s-right (char-to-string 48))
(defconst x-button-m-s-middle (char-to-string 49))
(defconst x-button-m-s-left (char-to-string 50))
(defconst x-button-c-s-right (char-to-string 80))
(defconst x-button-c-s-middle (char-to-string 81))
(defconst x-button-c-s-left (char-to-string 82))
(defconst x-button-c-m-right (char-to-string 96))
(defconst x-button-c-m-middle (char-to-string 97))
(defconst x-button-c-m-left (char-to-string 98))
(defconst x-button-c-m-s-right (char-to-string 112))
(defconst x-button-c-m-s-middle (char-to-string 113))
(defconst x-button-c-m-s-left (char-to-string 114)).
To understand why these constants are so defined, the user should
check out the (C) definition of the lisp function x-mouse-mode in the
src file xfns.c. (I, Joachim Martillo not RMS, do not claim
this code handles mouse events in the best way possible, and all
involved with maintaining the Gnu Emacs to X interface would be open
to suggestions for improvement.)
Anyway, using these defined constants, the user may bind his own
defined functions to mouse sequences using the define-key command as
below:
(define-key mouse-map x-button-right 'x-mouse-select).
Mouse functions are defined like any of the other lisp functions in
Gnu Emacs.
Here, exempli gratia, is the lisp definition of x-mouse-select:
(defun x-mouse-select (arg)
"Select Emacs window the mouse is on."
(let ((start-w (selected-window))
(done nil)
(w (selected-window))
(rel-coordinate nil))
(while (and (not done)
(null (setq rel-coordinate
(coordinates-in-window-p arg w))))
(setq w (next-window w))
(if (eq w start-w)
(setq done t)))
(select-window w)
rel-coordinate)).
When the mouse sequence is received, x-mouse-mode checks out the mouse
queue, sees the defined constant associated with that button event,
looks up that defined constants binding in the mouse-map and then
invokes this lisp function with arg which is a list of the x and y
coordinates of the mouse when the mouse event under question took
place. The lisp symbol arg is bound to (x-coordinate y-coordinate).
The supplied mouse-functions and bindings are:
x-cut-and-wipe-text
Function: Kill text between point and mouse; also copy to
window system cut buffer.
Binding: C-Middle Button.
x-cut-text
Function: Copy text between point and mouse position into
window system cut buffer.
Binding: S-Middle Button (i.e. Shift-Middle Button).
x-mouse-keep-one-window
Function: Select Emacs window mouse is on, then kill all other Emacs
windows.
Binding: C-S-Right Button.
x-mouse-select
Function: Select Emacs window the mouse is on.
Binding: Right Button.
x-mouse-select-and-split
Function: Select Emacs window mouse is on, then split it vertically
in half.
Binding: C-Right Button.
x-mouse-set-mark
Function: Select Emacs window mouse is on, and set mark at mouse
position.
Binding: Left Button.
x-mouse-set-point
Function: Select Emacs window mouse is on, and move point to mouse
position.
Binding: Middle Button.
x-paste-text
Function: Move point to mouse position and insert window system cut
buffer contents.
Binding: S-Right Button.
These functions are invoked simply by positioning the mouse and then
pressing the correct key/button combination.
The cut and paste functions deserve special remark. The X server
maintains special buffers where data may be salted away. One client
may salt data away in a cut buffer. Then another client could request
this data. In emacs, data is salted away, by setting the point (you
could use the mouse to set the point) then moving the mouse to the end
(or beginning) of the text to be salted away and pressing shift
middle. If the text should be wiped out of the buffer as well as
salted away, C-Middle Button should be used instead of S-Middle
Button. To get the text back into this emacs or another emacs, move
the mouse to where the text should be inserted and invoke x-paste-text
via S-Right Button. The text can be pasted into any client of the
current X server from the current cut buffer using that client's paste
command. For xterm the paste command is also S-Right Button.
Other Gnu Emacs Lisp Functions
Command Line Arguments
.emacs File
x-switches
.Xdefaults

1,,
Summary-line: 19-Dec lbm@ATHENA.MIT.EDU #GNU Emacs under X Writeup for Manual
Received: from ATHENA (ATHENA.MIT.EDU) by prep; Thu, 19 Dec 85 15:57:34 est
Received: from JASON (JASON.MIT.EDU) by ATHENA (4.12/4.7)
id AA12646; Thu, 19 Dec 85 15:55:53 est
Received: by JASON (5.15/4.7)
id AA20416; Thu, 19 Dec 85 15:55:40 EST
Message-Id: <8512192055.AA20416@JASON>
To: rms@prep
Cc: tower@prep
Subject: GNU Emacs under X Writeup for Manual
Date: 19 Dec 85 15:55:33 EST (Thu)
From: Linda B. Merims <lbm@ATHENA.MIT.EDU>
*** EOOH ***
To: rms@prep
Cc: tower@prep
Subject: GNU Emacs under X Writeup for Manual
Date: 19 Dec 85 15:55:33 EST (Thu)
From: Linda B. Merims <lbm@ATHENA.MIT.EDU>
Here's something you can put in the V17 manual to describe GNU Emacs under
X. I've added a couple of notes to you about things that didn't work
when I tried them. It has no formatting commands in it. I
don't know if we followed your naming conventions. It is important
for us to distinguish between "gnuemacs" and "emacs" for the next
six months while we convert our 2000+ users over from CCA, so I mention
that at MIT's Project Athena, things are a little different for
a short while.
I didn't put in anything about X-specific variables. I don't know
anything about them. I'm also a bit colloquial in places, to make
my point better with novices (who, for example, understand "cursor" better
than "point".) I also didn't document the -d display command option.
Nor are there any credits to, for example, Joachim Martillo. Up to you.
Hope this does you good.
Linda Merims
----------------------------------------------------------------
GNU Emacs on X Window System Displays
GNU Emacs works with the X window system. It starts
by "popping up" a new window on the screen. This can be a bit
disconcerting if you're not used to it. If you're on one of these
terminals, the easiest way to start up GNU Emacs is to type the same command
you would before, but to follow it with a &, as in:
emacs paper.mss &
The "&" runs GNU Emacs in the "background," freeing your original
window for other uses. (There are X-specific options to the Gnuemacs
commands that will be listed later.)
NOTE: GNU Emacs may be invoked by
different names at different sites. It is sometimes known
as xemacs. At MIT's Project Athena where GNU Emacs was first
adapted to X, the correct command is: gnuemacs until summer
1986, when it will become just: emacs.
Soon, you will see a small black box in the upper left hand corner of your
screen that reads, "emacs: 10 x 10". (This number represents
columns x rows.) You'll also see a small outline of a window with
a cross in the upper left hand corner of it. This is where the upper
left hand corner of your window will be. You can move this cross with
the mouse to any spot on the screen. You can then do one of three
things:
make an 80 column by 24 row emacs window -- click the left mouse button
make an 80 column by 65 row emacs window -- click the right mouse button
(the length will actually be however many lines long your screen
can hold. 80 by 66 is about the size of an 8 1/2 x 11 piece of paper.)
make any size emacs window you want -- hold down the middle mouse button
and move the mouse to create a window of any size. As you move the
mouse, the numbers in the upper left hand corner of the screen and
the rubber-band outline will expand or contract. Just release the
button when the window is the size you want.
Unless you make the window in any area that does not overlap any other
windows, you may have problems when you want to get back to a window
obscured by the GNU Emacs window. You need to know how to use the X
window manager, xwm, to move and shuffle these windows around. For
more information on the window manager, you can type man xwm, on
any Berkeley 4.3 Unix system with this user-contributed (/usr/new)
utility available.
Note that you cannot suspend (C-Z) a GNU emacs X window.
GNU Emacs and the X Mouse
When using GNU Emacs on an X terminal, you can take advantage of the
convenient, quick commands for moving point, setting the mark, and
cutting and pasting text. You issue these commands by pressing
the mouse's buttons alone or in concert with the SHIFT, CTRL, or
SHIFT-CTRL keys as follows:
left set mark ('x-mouse-set-mark) (RMS, this blinked cursor but didn't
actually set anything...lbm)
middle move the cursor (point) to where the mouse is. This is
like moving the cursor with C-F or C-N or the arrow keys,
only immediate. ('x-mouse-set-point)
right move to the window where the mouse is. Point is in the same
place as it was the last time you were in the window.
('x-mouse-select)
SHIFT-left
undefined
SHIFT-middle
take the text between point and mark and put it into the
X cut buffer. The text does NOT disappear from the screen.
It does NOT go into the emacs kill right. Used for copying
text. Recall text with SHIFT-right below. ('x-cut-text)
SHIFT-right
paste text from the X cut buffer to before point. ('x-paste-text)
CTRL-left
undefined
CTRL-middle
take the text between point and mark and put it into the
X cut buffer, AND the emacs kill ring. Text is deleted
from the screen. Used for moving text. Recall text with
SHIFT-right above, or any emacs kill ring command.
('x-cut-and-wipe-text)
CTRL-right
divide current window in two. ('x-mouse-select-and-split)
CTRL-SHIFT-middle
return to one-window mode, keeping the window the mouse is
in. ('x-mouse-keep-one-window)(RMS, this didn't always work...lbm)
Emacs Command X Window Options
These command options have meaning to the X window system:
-r use reverse video (white characters on black background)
-i use GNU emacs's bitmap icon (a kitchen sink) if the emacs
window is iconized instead of the xwm window manager default.
-font fontname
use fontname instead of the default vtsingle
-b borderwidth
make the window border borderwidth pixels wide. Default is 1.
-w windowsize
instead of relying on the mouse buttons to determine size and
placement of the GNU emacs window, make it this size. Size
is specified as:
=[WIDTH][xHEIGHT][{+-}XOFF[{+-}YOFF]]
The []'s denote optional stuff, the {}'s surround
alternatives. WIDTH and HEIGHT are in number of
characters, XOFF and YOFF are in pixels. X and YOFF are
the xy offsets from the upper left corner origin for the
upper left corner of the window.
GNU Emacs will check in the .Xdefaults file for default values for
these variables. (RMS, we're not sure what program name it's
going to be looking for...lbm)
GNU Emacs under X Variables
I don't know what these are. Sorry.


116
etc/XENIX Normal file
View file

@ -0,0 +1,116 @@
Return-Path: <info-gnu-emacs-request@prep.ai.mit.edu>
Date: 5 Aug 88 18:46:22 GMT
From: jetson!john@uunet.uu.net (John Owens)
Organization: SMART HOUSE Limited Partnership
Subject: Meta key support in SCO Xenix!
Sender: info-gnu-emacs-request@prep.ai.mit.edu
To: info-gnu-emacs@prep.ai.mit.edu
Here is a substitute for /usr/lib/keyboard/keys in SCO Xenix that
allows use of the meta key in GNU Emacs. Pressing ALT with any key
causes the code returned to have the 80hex bit set. In conjunction
with this, I added lisp/term/ansi.el with the single line
(setq meta-flag t)
Here's the keys file. Make sure MAPKEY=YES is in your
/etc/default/boot. (This also allows you to enter graphics characters
from the keyboard.) Enjoy!
# alt
# scan cntrl alt alt cntrl lock
# code base shift cntrl shift alt shift cntrl shift state
0 nop nop nop nop nop nop nop nop O
1 esc esc nop nop 0x9b 0x9b nop nop O
2 '1' '!' nop nop 0xb1 0xa1 nop nop O
3 '2' '@' nul nul 0xb2 0xc0 0x80 0x80 O
4 '3' '#' nop nop 0xb3 0xa3 nop nop O
5 '4' '$' nop nop 0xb4 0xa4 nop nop O
6 '5' '%' nop nop 0xb5 0xa5 nop nop O
7 '6' '^' rs rs 0xb6 0xde 0x9e 0x9e O
8 '7' '&' nop nop 0xb7 0xa6 nop nop O
9 '8' '*' nop nop 0xb8 0xaa nop nop O
10 '9' '(' nop nop 0xb9 0xa8 nop nop O
11 '0' ')' nop nop 0xb0 0xa9 nop nop O
12 '-' '_' ns ns 0xad 0xdf 0x9f 0x9f O
13 '=' '+' nop nop 0xbd 0xab nop nop O
14 bs bs del del 0x88 0x88 0xff 0xff O
15 ht btab nop nop 0x89 btab nop nop O
16 'q' 'Q' dc1 dc1 0xf1 0xd1 0x91 0x91 C
17 'w' 'W' etb etb 0xf7 0xd7 0x97 0x97 C
18 'e' 'E' enq enq 0xe5 0xc5 0x85 0x85 C
19 'r' 'R' dc2 dc2 0xf2 0xd2 0x92 0x92 C
20 't' 'T' dc4 dc4 0xf4 0xd4 0x94 0x94 C
21 'y' 'Y' em em 0xf9 0xd9 0x99 0x99 C
22 'u' 'U' nak nak 0xf5 0xd5 0x95 0x95 C
23 'i' 'I' ht ht 0xe9 0xc9 0x89 0x89 C
24 'o' 'O' si si 0xef 0xcf 0x8f 0x8f C
25 'p' 'P' dle dle 0xf0 0xd0 0x90 0x90 C
26 '[' '{' esc esc 0xdb 0xfb 0x9b 0x9b O
27 ']' '}' gs gs 0xdd 0xfd 0x9d 0x9d O
28 cr cr nl nl 0x8d 0x8d 0x8a 0x8a O
29 ctrl ctrl ctrl ctrl ctrl ctrl ctrl ctrl O
30 'a' 'A' soh soh 0xe1 0xc1 0x81 0x81 C
31 's' 'S' dc3 dc3 0xf3 0xd3 0x93 0x93 C
32 'd' 'D' eot eot 0xe4 0xc4 0x84 0x84 C
33 'f' 'F' ack ack 0xe6 0xc6 0x86 0x86 C
34 'g' 'G' bel bel 0xe7 0xc7 0x87 0x87 C
35 'h' 'H' bs bs 0xe8 0xc8 0x88 0x88 C
36 'j' 'J' nl nl 0xea 0xca 0x8a 0x8a C
37 'k' 'K' vt vt 0xeb 0xcb 0x8b 0x8b C
38 'l' 'L' np np 0xec 0xcc 0x8c 0x8c C
39 ';' ':' nop nop 0xbb 0xba nop nop O
40 '\'' '"' nop nop 0xa7 0xa2 nop nop O
41 '`' '~' nop nop 0xe0 0xfe nop nop O
42 lshift lshift lshift lshift lshift lshift lshift lshift O
43 '\\' '|' fs fs 0xdc 0xfc 0x9c 0x9c O
44 'z' 'Z' sub sub 0xfa 0xda 0x9a 0x9a C
45 'x' 'X' can can 0xf8 0xd8 0x98 0x98 C
46 'c' 'C' etx etx 0xe3 0xc3 0x83 0x83 C
47 'v' 'V' syn syn 0xf6 0xd6 0x96 0x96 C
48 'b' 'B' stx stx 0xe2 0xc2 0x82 0x82 C
49 'n' 'N' so so 0xee 0xce 0x8e 0x8e C
50 'm' 'M' cr cr 0xed 0xcd 0x8d 0x8d C
51 ',' '<' nop nop 0xac 0xbc nop nop O
52 '.' '>' nop nop 0xae 0xbe nop nop O
53 '/' '?' nop nop 0xaf 0xbf nop nop O
54 rshift rshift rshift rshift rshift rshift rshift rshift O
55 '*' '*' nscr nscr 0xaa 0xaa nscr nscr O
56 alt alt alt alt alt alt alt alt O
57 ' ' ' ' ' ' ' ' 0xa0 0xa0 0xa0 0xa0 O
58 clock clock clock clock clock clock clock clock O
59 fkey1 fkey13 fkey25 fkey37 scr1 scr11 scr1 scr11 O
60 fkey2 fkey14 fkey26 fkey38 scr2 scr12 scr2 scr12 O
61 fkey3 fkey15 fkey27 fkey39 scr3 scr13 scr3 scr13 O
62 fkey4 fkey16 fkey28 fkey40 scr4 scr14 scr4 scr14 O
63 fkey5 fkey17 fkey29 fkey41 scr5 scr15 scr5 scr15 O
64 fkey6 fkey18 fkey30 fkey42 scr6 scr16 scr6 scr16 O
65 fkey7 fkey19 fkey31 fkey43 scr7 scr7 scr7 scr7 O
66 fkey8 fkey20 fkey32 fkey44 scr8 scr8 scr8 scr8 O
67 fkey9 fkey21 fkey33 fkey45 scr9 scr9 scr9 scr9 O
68 fkey10 fkey22 fkey34 fkey46 scr10 scr10 scr10 scr10 O
69 nlock nlock dc3 dc3 nlock nlock 0x93 0x93 O
70 slock slock del del slock slock 0xff 0xff O
71 fkey49 '7' '7' '7' 0xb7 0xb7 0xb7 0xb7 N
72 fkey50 '8' '8' '8' 0xb8 0xb8 0xb8 0xb8 N
73 fkey51 '9' '9' '9' 0xb9 0xb9 0xb9 0xb9 N
74 fkey52 '-' '-' '-' 0xad 0xad 0xad 0xad N
75 fkey53 '4' '4' '4' 0xb4 0xb4 0xb4 0xb4 N
76 fkey54 '5' '5' '5' 0xb5 0xb5 0xb5 0xb5 N
77 fkey55 '6' '6' '6' 0xb6 0xb6 0xb6 0xb6 N
78 fkey56 '+' '+' '+' 0xab 0xab 0xab 0xab N
79 fkey57 '1' '1' '1' 0xb1 0xb1 0xb1 0xb1 N
80 fkey58 '2' '2' '2' 0xb2 0xb2 0xb2 0xb2 N
81 fkey59 '3' '3' '3' 0xb3 0xb3 0xb3 0xb3 N
82 fkey60 '0' '0' '0' 0xb0 0xb0 0xb0 0xb0 N
83 del '.' del del 0xff 0xff 0xff 0xff N
84 nop nop nop nop nop nop nop nop O
85 nop nop nop nop nop nop nop nop O
86 nop nop nop nop nop nop nop nop O
87 fkey11 fkey23 fkey35 fkey47 scr11 scr11 scr11 scr11 O
88 fkey12 fkey24 fkey36 fkey48 scr12 scr12 scr12 scr12 O
--
John Owens john@jetson.UPMA.MD.US
SMART HOUSE L.P. uunet!jetson!john (old uucp)
+1 301 249 6000 john%jetson.uucp@uunet.uu.net (old internet)

98
etc/Xkeymap.txt Normal file
View file

@ -0,0 +1,98 @@
# -*-Mode: Fundamental-*-
# X keymap file for rlk with some emacsified bindings
# This file contains the default keyboard mapping. The first column contains a X keyboard code; the other
# 16 columns contain the mapping of the keycode to a character string, with various combinations
# of the SHIFT, LOCK, META, and CONTROL keys down. See the man page for "keycomp" for more information.
#
# Keycode constants for non-typewriter keys are found in <X/Xkeyboard.h>.
#
# It is easiest to edit this file with an EMACS window running across the entire width of the display, with
# tab stop set to 4.
#
# E1=Find, E2=Insert Here, E3=Remove, E4=Select, E5=Prev Screen, E6=Next Screen
# uns L S SL M ML MS MSL C CL CS CSL CM CML CMS CMSL
0212 0023, 0023, 0023, 0023, 0223, 0223, 0223, 0223, 0022, 0022, 0022, 0022, 0222, 0222, 0222, 0222, /* E1 */
0213 U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, /* E2 */
0214 0004, 0004, 0177, 0177, 0304, 0304, 0377, 0377, 0004, 0004, 0177, 0177, 0204, 0204, 0377, 0377 /* E3 */
0215 U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, /* E4 */
0216 0326, 0326, 0326, 0326, 0326, 0326, 0326, 0326, "\255\226" "\255\226" "\255\226" "\255\226" "\255\226" "\255\226" "\255\226" "\255\226" /* E5 */
0217 0026, 0026, 0026, 0026, 0026, 0026, 0026, 0026, 0226, 0226, 0226, 0226, 0226, 0226, 0226, 0226, /* E6 */
0247 0002, 0002, 0002, 0002, 0302, 0302, 0302, 0302, 0202, 0202, 0202, 0202, 0202, 0202, 0202, 0202, /* Left arrow */
0250 0006, 0006, 0006, 0006, 0306, 0306, 0306, 0306, 0206, 0206, 0206, 0206, 0206, 0206, 0206, 0206, /* Right arrow */
0251 0016, 0016, 0016, 0016, 0316, 0316, 0316, 0316, 0216, 0216, 0216, 0216, 0216, 0216, 0216, 0216, /* Down arrow */
0252 0020, 0020, 0020, 0020, 0320, 0320, 0320, 0320, 0220, 0220, 0220, 0220, 0220, 0220, 0220, 0220, /* Up arrow */
0222 0260, '0', 0260, '0', 0260, '0', 0260, '0', 0260, '0', 0260, '0', 0260, '0', 0260, '0', /* KP 0 */
0224 0256, '.', 0256, '.', 0256, '.', 0256, '.', 0256, '.', 0256, '.', 0256, '.', 0256, '.', /* KP . */
0225 '\n', '\n', '\n', '\n', 0312, 0312, 0312, 0312, 0212, 0212, 0212, 0212, 0212, 0212, 0212, 0212, /* KP Enter */
0226 0261, '1', 0261, '1', 0261, '1', 0261, '1', 0261, '1', 0261, '1', 0261, '1', 0261, '1', /* KP 1 */
0227 0262, '2', 0262, '2', 0262, '2', 0262, '2', 0262, '2', 0262, '2', 0262, '2', 0262, '2', /* KP 2 */
0230 0263, '3', 0263, '3', 0263, '3', 0263, '3', 0263, '3', 0263, '3', 0263, '3', 0263, '3', /* KP 3 */
0231 0264, '4', 0264, '4', 0264, '4', 0264, '4', 0264, '4', 0264, '4', 0264, '4', 0264, '4', /* KP 4 */
0232 0265, '5', 0265, '5', 0265, '5', 0265, '5', 0265, '5', 0265, '5', 0265, '5', 0265, '5', /* KP 5 */
0233 0266, '6', 0266, '6', 0266, '6', 0266, '6', 0266, '6', 0266, '6', 0266, '6', 0266, '6', /* KP 6 */
0234 0254, ',', 0254, ',', 0254, ',', 0254, ',', 0254, ',', 0254, ',', 0254, ',', 0254, ',', /* KP , */
0235 0267, '7', 0267, '7', 0267, '7', 0267, '7', 0267, '7', 0267, '7', 0267, '7', 0267, '7', /* KP 7 */
0236 0270, '8', 0270, '8', 0270, '8', 0270, '8', 0270, '8', 0270, '8', 0270, '8', 0270, '8', /* KP 8 */
0237 0271, '9', 0271, '9', 0271, '9', 0271, '9', 0271, '9', 0271, '9', 0271, '9', 0271, '9', /* KP 9 */
0240 0255, '-', 0255, '-', 0255, '-', 0255, '-', 0255, '-', 0255, '-', 0255, '-', 0255, '-', /* KP - */
0174 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, 0010, /* F15/Help */
0175 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, 0037, /* F16/(Un)Do */
0161 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, 0033, /* F11/ESC */
0162 '\b', '\b', '\b', '\b', '\b', '\b', U, U, '\b', '\b', U, U, U, U, U, U, /* F12/BS */
0163 '\n', '\n', '\n', '\n', '\n', '\n', U, U, '\n', '\n', U, U, U, U, U, U, /* F13/LF */
0274 0177, 0177, 0177, 0177, 0377, 0377, 0377, 0377, 0030, 0030, 0177, 0177, 0377, 0377, 0377, 0377, /* back */
0275 '\r', '\r', '\r', '\r', 0215, 0215, 0215, 0215, '\r', '\r', U, U, U, U, U, U, /* Return */
0276 '\t', '\t', '\t', '\t', 0211, 0211, 0211, 0211, "\021\t" "\021\t" "\021\t" "\021\t" "\021\t" "\021\t" "\021\t" "\021\t" /* Tab */
0277 '`', '`', '~', '~', 0340, 0340, 0376, 0376, 0036, 0036, 0036, 0036, U, U, U, U, /* ` */
0300 '1', '1', '!', '!', 0261, 0261, 0241, 0241, '1', '1', '!', '!', U, U, U, U, /* 1 */
0301 'q', 'Q', 'Q', 'Q', 0361, 0361, 0321, 0321, 0021, 0021, 0021, 0021, 0221, 0221, 0221, 0221, /* q */
0302 'a', 'A', 'A', 'A', 0341, 0341, 0301, 0301, 0001, 0001, 0001, 0001, 0201, 0201, 0201, 0201, /* a */
0303 'z', 'Z', 'Z', 'Z', 0372, 0372, 0332, 0332, 0032, 0032, 0032, 0032, 0232, 0232, 0232, 0232, /* z */
0305 '2', '2', '@', '@', 0262, 0262, 0300, 0300, 0000, 0000, 0000, 0000, 0262, 0262, 0200, 0200, /* 2 */
0306 'w', 'W', 'W', 'W', 0367, 0367, 0327, 0327, 0027, 0027, 0027, 0027, 0227, 0227, 0227, 0227, /* w */
0307 's', 'S', 'S', 'S', 0363, 0363, 0323, 0323, 0023, 0023, 0023, 0023, 0223, 0223, 0223, 0223, /* s */
0310 'x', 'X', 'X', 'X', 0370, 0370, 0330, 0330, 0030, 0030, 0030, 0030, 0230, 0230, 0230, 0230, /* x */
0311 '<', '<', '>', '>', 0274, 0274, 0276, 0276, U, U, U, U, U, U, U, U, /* < */
0313 '3', '3', '#', '#', 0263, 0263, 0243, 0243, 0033, 0033, '#', '#', U, U, U, U, /* 3 */
0314 'e', 'E', 'E', 'E', 0345, 0345, 0305, 0305, 0005, 0005, 0005, 0005, 0205, 0205, 0205, 0205, /* e */
0315 'd', 'D', 'D', 'D', 0344, 0344, 0304, 0304, 0004, 0004, 0004, 0004, 0204, 0204, 0204, 0204, /* d */
0316 'c', 'C', 'C', 'C', 0343, 0343, 0303, 0303, 0003, 0003, 0003, 0003, 0203, 0203, 0203, 0203, /* c */
0320 '4', '4', '$', '$', 0264, 0264, 0244, 0244, 0034, 0034, '$', '$', U, U, U, U, /* 4 */
0321 'r', 'R', 'R', 'R', 0362, 0362, 0322, 0322, 0022, 0022, 0022, 0022, 0222, 0222, 0222, 0222, /* r */
0322 'f', 'F', 'F', 'F', 0346, 0346, 0306, 0306, 0006, 0006, 0006, 0006, 0206, 0206, 0206, 0206, /* f */
0323 'v', 'V', 'V', 'V', 0366, 0366, 0326, 0326, 0026, 0026, 0026, 0026, 0226, 0226, 0226, 0226, /* v */
0324 ' ', ' ', ' ', ' ', 0240, 0240, 0240, 0240, 0000, 0000, 0000, 0000, 0200, 0200, 0200, 0200, /* space */
0326 '5', '5', '%', '%', 0265, 0265, 0245, 0245, 0035, 0035, '%', '%', U, U, U, U, /* 5 */
0327 't', 'T', 'T', 'T', 0364, 0364, 0324, 0324, 0024, 0024, 0024, 0024, 0224, 0224, 0224, 0224, /* t */
0330 'g', 'G', 'G', 'G', 0347, 0347, 0307, 0307, 0007, 0007, 0007, 0007, 0207, 0207, 0207, 0207, /* g */
0331 'b', 'B', 'B', 'B', 0342, 0342, 0302, 0302, 0002, 0002, 0002, 0002, 0202, 0202, 0202, 0202, /* b */
0333 '6', '6', '^', '^', 0266, 0266, 0336, 0336, 0036, 0036, 0036, 0036, U, U, U, U, /* 6 */
0334 'y', 'Y', 'Y', 'Y', 0371, 0371, 0331, 0331, 0031, 0031, 0031, 0031, 0231, 0231, 0231, 0231, /* y */
0335 'h', 'H', 'H', 'H', 0350, 0350, 0310, 0310, 0010, 0010, 0010, 0010, 0210, 0210, 0210, 0210, /* h */
0336 'n', 'N', 'N', 'N', 0356, 0356, 0316, 0316, 0016, 0016, 0016, 0016, 0216, 0216, 0216, 0216, /* n */
0340 '7', '7', '&', '&', 0267, 0267, 0246, 0246, 0037, 0037, '&', '&', U, U, U, U, /* 7 */
0341 'u', 'U', 'U', 'U', 0365, 0365, 0325, 0325, 0025, 0025, 0025, 0025, 0225, 0225, 0225, 0225, /* u */
0342 'j', 'J', 'J', 'J', 0352, 0352, 0312, 0312, 0012, 0012, 0012, 0012, 0212, 0212, 0212, 0212, /* j */
0343 'm', 'M', 'M', 'M', 0355, 0355, 0315, 0315, 0015, 0015, 0015, 0015, 0215, 0215, 0215, 0215, /* m */
0345 '8', '8', '*', '*', 0270, 0270, 0252, 0252, 0177, 0177, '*', '*', U, U, U, U, /* 8 */
0346 'i', 'I', 'I', 'I', 0351, 0351, 0311, 0311, 0011, 0011, 0011, 0011, 0211, 0211, 0211, 0211, /* i */
0347 'k', 'K', 'K', 'K', 0353, 0353, 0313, 0313, 0013, 0013, 0013, 0013, 0213, 0213, 0213, 0213, /* k */
0350 ',', ',', '<', '<', 0254, 0254, 0274, 0274, U, U, U, U, U, U, U, U, /* , */
0352 '9', '9', '(', '(', 0271, 0271, 0250, 0250, '9', '9', '(', '(', U, U, U, U, /* 9 */
0353 'o', 'O', 'O', 'O', 0357, 0357, 0317, 0317, 0017, 0017, 0017, 0017, 0217, 0217, 0217, 0217, /* o */
0354 'l', 'L', 'L', 'L', 0354, 0354, 0314, 0314, 0014, 0014, 0014, 0014, 0214, 0214, 0214, 0214, /* l */
0355 '.', '.', '>', '>', 0256, 0256, 0276, 0276, U, U, U, U, U, U, U, U, /* . */
0357 '0', '0', ')', ')', 0260, 0260, 0251, 0251, '0', '0', ')', ')', U, U, U, U, /* 0 */
0360 'p', 'P', 'P', 'P', 0360, 0360, 0320, 0320, 0020, 0020, 0020, 0020, 0220, 0220, 0220, 0220, /* p */
0362 ';', ';', ':', ':', 0273, 0273, 0272, 0272, U, U, U, U, U, U, U, U, /* ; */
0363 '/', '/', '?', '?', 0257, 0257, 0277, 0277, 0037, 0037, 0037, 0037, 0237, 0237, 0237, 0237, /* / */
0365 '=', '=', '+', '+', 0275, 0275, 0253, 0253, U, U, U, U, U, U, U, U, /* = */
0366 ']', ']', '}', '}', 0335, 0335, 0376, 0376, 0035, 0035, 0035, 0035, 0335, 0335, 0335, 0335, /* ] */
0367 '\\', '\\', '|', '|', 0334, 0334, 0374, 0374, 0034, 0034, 0034, 0034, 0334, 0334, 0334, 0334, /* \ */
0371 '-', '-', '_', '_', 0255, 0255, 0337, 0337, 0037, 0037, 0037, 0037, 0337, 0337, 0337, 0337, /* - */
0372 '[', '[', '{', '{', 0333, 0333, 0373, 0373, 0033, 0033, 0033, 0033, 0333, 0333, 0333, 0333, /* [ */
0373 '\'', '\'', '"', '"', 0247, 0247, 0242, 0242, U, U, U, U, U, U, U, U, /* ' */
#
# local variables:
# tab-width: 4
# End:

12
etc/celibacy.1 Normal file
View file

@ -0,0 +1,12 @@
CELIBACY(1) UNIX Programmer's Manual CELIBACY(1)
NAME
celibacy - don't have sex
SYNOPSIS
celibacy
DESCRIPTION
Does nothing worth mentioning.

41
etc/complink.com Normal file
View file

@ -0,0 +1,41 @@
$ ! Compile and link those programs in [etc] that are usable on VMS.
$
$ old = f$environment("default")
$ set default emacs_library:[etc]
$ if f$search("test-distrib.c") .nes. "" then goto version44
$
$ cc test_distrib.c
$ link test_distrib.obj,vmslink.opt/opt
$ run test_distrib.exe
$ cc /debug make_docfile.c
$ link make_docfile.obj,vmslink.opt/opt
$ cc /debug digest_doc.c
$ link digest_doc.obj,vmslink.opt/opt
$ cc /debug sorted_doc.c
$ cc /debug qsort.c
$ link sorted_doc.obj,qsort.obj,vmslink.opt/opt
$ cc /debug etags_vmslib.c
$ cc /debug etags.c
$ link etags.obj,etags_vmslib.obj,vmslink.opt/opt
$ goto finish
$
$version44:
$ cc test-distrib.c
$ link test-distrib.obj,vmslink.opt/opt
$ run test-distrib.exe
$ cc /debug make-docfile.c
$ link make-docfile.obj,vmslink.opt/opt
$ cc /debug digest-doc.c
$ link digest-doc.obj,vmslink.opt/opt
$ cc /debug sorted-doc.c
$ cc /debug qsort.c
$ link sorted-doc.obj,qsort.obj,vmslink.opt/opt
$ cc /debug etags-vmslib.c
$ cc /debug etags.c
$ link etags.obj,etags-vmslib.obj,vmslink.opt/opt
$
$finish:
$ cc /debug yow.c
$ link yow.obj,vmslink.opt/opt
$
$ set default 'old'

1
lib-src/cvtmail.c → etc/cvtmail.c
View file

@ -1,4 +1,5 @@
/* Copyright (C) 1985 Free Software Foundation
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify

0
lib-src/digest-doc.c → etc/digest-doc.c
View file

207
etc/echo.msg Normal file
View file

@ -0,0 +1,207 @@
Path: mit-amt!mit-eddie!think!harvard!seismo!gatech!akgua!whuxlm!whuxl!houxm!ihnp4!stolaf!umn-cs!herndon
From: herndon@umn-cs.UUCP
Newsgroups: net.sources
Subject: GNU Echo, Release 1
Message-ID: <1600001@umn-cs.UUCP>
Date: 28 Oct 85 18:23:00 GMT
/* Written 12:22 pm Oct 28, 1985 by umn-cs!herndon in umn-cs:net.jokes */
/* ---------- "GNU Echo, Release 1" ---------- */
GNUecho(1) UNIX Programmer's Manual GNUecho(1)
NAME
echo - echo arguments
SYNOPSIS
echo [ options ] ...
DESCRIPTION
_^HE_^Hc_^Hh_^Ho writes its arguments separated by blanks and terminated
by a newline on the standard output. Options to filter and
redirect the output are as follows:
-2 generate rhyming couplets from keywords
-3 generate Haiku verse from keywords
-5 generate limerick from keywords
-a convert ASCII to ASCII
-A disambiguate sentence structure
-b generate bureaucratese equivalent (see -x)
-B issue equivalent C code with bugs fixed
-c simplify/calculate arithmetic expression(s)
-C remove copyright notice(s)
-d define new echo switch map
-D delete all ownership information from system files
-e evaluate lisp expression(s)
-E convert ASCII to Navajo
-f read input from file
-F transliterate to french
-g generate pseudo-revolutionary marxist catch-phrases
-G prepend GNU manifesto
-h halt system (reboot suppressed on Suns, Apollos, and
VAXen, not supported on NOS-2)
-i emulate IBM OS/VU (recursive universes not supported)
-I emulate IBM VTOS 3.7.6 (chronosynclastic infundibulae
supported with restrictions documented in IBM VTOS
Printed 10/28/85 18 January 1983 1
GNUecho(1) UNIX Programmer's Manual GNUecho(1)
Reference Manual rev 3.2.6)
-J generate junk mail
-j justify text (see -b option)
-k output "echo" software tools
-K delete privileged accounts
-l generate legalese equivalent
-L load echo modules
-M generate mail
-N send output to all reachable networks (usable with -J,
-K, -h options)
-n do not add newline to the output
-o generate obscene text
-O clean up dirty language
-p decrypt and print /etc/passwd
-P port echo to all reachable networks
-P1 oolcay itay
-q query standard input for arguments
-r read alternate ".echo" file on start up
-R change root password to "RMS"
-s suspend operating system during output (Sun and VAX BSD
4.2 only)
-S translate to swahili
-T emulate TCP/IP handler
-t issue troff output
-u issue unix philosophy essay
-v generate reverberating echo
-V print debugging information
Printed 10/28/85 18 January 1983 2
GNUecho(1) UNIX Programmer's Manual GNUecho(1)
-x decrypt DES format messages (NSA secret algorithm CX
3.8, not distributed outside continental US)
_^HE_^Hc_^Hh_^Ho is useful for producing diagnostics in shell programs
and for writing constant data on pipes. To send diagnostics
to the standard error file, do `echo ... 1>&2'.
AUTHOR
Richard M. Stallman
Printed 10/28/85 18 January 1983 3

513
etc/emacs.1 Normal file
View file

@ -0,0 +1,513 @@
.TH EMACS 1 "1990 November 13"
.UC 4
.SH NAME
emacs \- GNU project Emacs
.SH SYNOPSIS
.B emacs
[
.I command-line switches
] [
.I files ...
]
.br
.SH DESCRIPTION
.I GNU Emacs
is a new version of
.I Emacs,
written by the author of the original (PDP-10)
.I Emacs,
Richard Stallman.
Its user functionality encompasses
everything other
.I Emacs
editors do, and it is easily extensible since its
editing commands are written in Lisp.
.PP
.I Emacs
has an extensive interactive help facility,
but the facility assumes that you know how to manipulate
.I Emacs
windows and buffers.
CTRL-h (backspace
or CTRL-h) enters the Help facility. Help Tutorial (CTRL-h t)
requests an interactive tutorial which can teach beginners the fundamentals
of
.I Emacs
in a few minutes.
Help Apropos (CTRL-h a) helps you
find a command given its functionality, Help Character (CTRL-h c)
describes a given character's effect, and Help Function (CTRL-h f)
describes a given Lisp function specified by name.
.PP
.I Emacs's
Undo can undo several steps of modification to your buffers, so it is
easy to recover from editing mistakes.
.PP
.I GNU Emacs's
many special packages handle mail reading (RMail) and sending (Mail),
outline editing (Outline), compiling (Compile), running subshells
within
.I Emacs
windows (Shell), running a Lisp read-eval-print loop
(Lisp-Interaction-Mode), and automated psychotherapy (Doctor).
.PP
There is an extensive reference manual, but
users of other Emacses
should have little trouble adapting even
without a copy. Users new to
.I Emacs
will be able
to use basic features fairly rapidly by studying the tutorial and
using the self-documentation features.
.PP
.SM Emacs Options
.PP
The following options are of general interest:
.TP 8
.I file
Edit
.I file.
.TP
.BI \+ number
Go to the line specified by
.I number
(do not insert a space between the "+" sign and
the number).
.TP
.B \-q
Do not load an init file.
.TP
.BI \-u " user"
Load
.I user's
init file.
.TP
.BI \-t " file"
Use specified
.I file
as the terminal instead of using stdin/stdout.
This must be the first argument specified in the command line.
.PP
The following options are lisp-oriented
(these options are processed in the order encountered):
.TP 8
.BI \-f " function"
Execute the lisp function
.I function.
.TP
.BI \-l " file"
Load the lisp code in the file
.I file.
.PP
The following options are useful when running
.I Emacs
as a batch editor:
.TP 8
.BI \-batch
Edit in batch mode according to the other command line arguments.
The editor will send messages to stdout.
This option must be the first in the argument list.
.TP
.B \-kill
Exit
.I Emacs
while in batch mode.
.\" START DELETING HERE IF YOU'RE NOT USING X
.PP
.SM Using Emacs with X
.PP
.I Emacs
has been tailored to work well with the X window system.
If you run
.I Emacs
from under X windows, it will create its own X window to
display in. You will probably want to start the editor
as a background process
so that you can continue using your original window.
.PP
.I Emacs
can be started with the following X switches:
.TP 8
.BI \-rn " name"
Specifies the program name which should be used when looking up
defaults in the user's X resources. This must be the first option
specified in the command line.
.TP 8
.BI \-wn " name"
Specifies the name which should be assigned to the
.I Emacs
window.
.TP 8
.B \-r
Display the
.I Emacs
window in reverse video.
.TP
.B \-i
Use the "kitchen sink" bitmap icon when iconifying the
.I Emacs
window.
.TP
.BI \-font " font, " \-fn " font"
Set the
.I Emacs
window's font to that specified by
.I font.
You will find the various
.I X
fonts in the
.I /usr/lib/X11/fonts
directory.
Note that
.I Emacs
will only accept fixed width fonts.
Under the X11 Release 4 font-naming conventions, any font with the
value "m" or "c" in the eleventh field of the font name is a fixed
width font. Furthermore, fonts whose name are of the form
.IR width x height
are generally fixed width, as is the font
.IR fixed .
See
.IR xlsfonts (1)
for more information.
When you specify a font, be sure to put a space between the
switch and the font name.
.TP
.BI \-b " pixels"
Set the
.I Emacs
window's border width to the number of pixels specified by
.I pixels.
Defaults to one pixel on each side of the window.
.TP
.BI \-ib " pixels"
Set the window's internal border width to the number of pixels specified
by
.I pixels.
Defaults to one pixel of padding on each side of the window.
.PP
.TP 8
.BI \-w " geometry, " \-geometry " geometry"
Set the
.I Emacs
window's width, height, and position as specified. The geometry
specification is in the standard X format; see
.IR X (1)
for more information.
The width and height are specified in characters; the default is 80 by
24.
.PP
.TP 8
.BI \-fg " color"
On color displays, sets the color of the text.
See the file
.I /usr/lib/X11/rgb.txt
for a list of valid
color names.
.TP
.BI \-bg " color"
On color displays,
sets the color of the window's background.
.TP
.BI \-bd " color"
On color displays,
sets the color of the window's border.
.TP
.BI \-cr " color"
On color displays,
sets the color of the window's text cursor.
.TP
.BI \-ms " color"
On color displays,
sets the color of the window's mouse cursor.
.TP
.BI \-d " displayname, " \-display " displayname"
Create the
.I Emacs
window on the display specified by
.IR displayname .
Must be the first option specified in the command line.
.TP
.B \-nw
Tells
.I Emacs
not to use its special interface to X. If you use this
switch when invoking
.I Emacs
from an
.IR xterm (1)
window, display is done in that window.
This must be the first option specified in the command line.
.PP
You can set
.I X
default values for your
.I Emacs
windows in your
.I \.Xresources
file (see
.IR xrdb (1)).
Use the following format:
.IP
emacs.keyword:value
.PP
where
.I value
specifies the default value of
.I keyword.
.I Emacs
lets you set default values for the following keywords:
.TP 8
.B font (\fPclass\fB Font)
Sets the window's text font.
.TP
.B reverseVideo (\fPclass\fB ReverseVideo)
If
.I reverseVideo's
value is set to
.I on,
the window will be displayed in reverse video.
.TP
.B bitmapIcon (\fPclass\fB BitmapIcon)
If
.I bitmapIcon's
value is set to
.I on,
the window will iconify into the "kitchen sink."
.TP
.B borderWidth (\fPclass\fB BorderWidth)
Sets the window's border width in pixels.
.TP
.B internalBorder (\fPclass\fB BorderWidth)
Sets the window's internal border width in pixels.
.TP
.B foreground (\fPclass\fB Foreground)
For color displays,
sets the window's text color.
.TP
.B background (\fPclass\fB Background)
For color displays,
sets the window's background color.
.TP
.B borderColor (\fPclass\fB BorderColor)
For color displays,
sets the color of the window's border.
.TP
.B cursorColor (\fPclass\fB Foreground)
For color displays,
sets the color of the window's text cursor.
.TP
.B pointerColor (\fPclass\fB Foreground)
For color displays,
sets the color of the window's mouse cursor.
.TP
.B geometry (\fPclass\fB Geometry)
Sets the geometry of the
.I Emacs
window (as described above).
.TP
.B title (\fPclass\fB Title)
Sets the title of the
.I Emacs
window.
.TP
.B iconName (\fPclass\fB Title)
Sets the icon name for the
.I Emacs
window icon.
.PP
If you try to set color values while using a black and white display,
the window's characteristics will default as follows:
the foreground color will be set to black,
the background color will be set to white,
the border color will be set to grey,
and the text and mouse cursors will be set to black.
.PP
.SM Using the Mouse
.PP
The following lists the mouse button bindings for the
.I Emacs
window under X11.
.in +\w'CTRL-SHIFT-middle'u+4n
.ta \w'CTRL-SHIFT-middle'u+4n
.ti -\w'CTRL-SHIFT-middle'u+4n
MOUSE BUTTON FUNCTION
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
left Set point.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
middle Paste text.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
right Cut text into X cut buffer.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
SHIFT-middle Cut text into X cut buffer.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
SHIFT-right Paste text.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
CTRL-middle Cut text into X cut buffer and kill it.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
CTRL-right Select this window, then split it into
two windows. Same as typing CTRL-x 2.
.\" START DELETING HERE IF YOU'RE NOT USING X MENUS
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
CTRL-SHIFT-left X buffer menu--hold the buttons and keys
down, wait for menu to appear, select
buffer, and release. Move mouse out of
menu and release to cancel.
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
CTRL-SHIFT-middle X help menu--pop up index card menu for
Emacs help.
.\" STOP DELETING HERE IF YOU'RE NOT USING X MENUS
.br
.ti -\w'CTRL-SHIFT-middle'u+4n
CTRL-SHIFT-right Select window with mouse, and delete all
other windows. Same as typing CTRL-x 1.
.\" STOP DELETING HERE IF YOU'RE NOT USING X
.PP
.SH MANUALS
You can order printed copies of the GNU Emacs Manual for $20.00/copy
postpaid from the Free Software Foundation, which develops GNU software.
Their address is:
.nf
Free Software Foundation
675 Mass Ave.
Cambridge, MA 02139
.fi
See the file etc/DISTRIB in the Emacs distribution
for full ordering information.
Your local Emacs maintainer might also have copies available. As
with all software and publications from FSF, everyone is permitted to
make and distribute copies of the Emacs manual. The TeX source to the
manual is also included in the Emacs source distribution.
.PP
.SH FILES
/usr/local/emacs/src - C source files and object files
/usr/local/emacs/lisp - Lisp source files and compiled files
that define most editing commands. Some are preloaded;
others are autoloaded from this directory when used.
/usr/local/emacs/man - sources for the Emacs reference manual.
/usr/local/emacs/etc - various programs that are used with
GNU Emacs, and some files of information.
/usr/local/emacs/etc/DOC.* - contains the documentation
strings for the Lisp primitives and preloaded Lisp functions
of GNU Emacs. They are stored here to reduce the size of
Emacs proper.
/usr/local/emacs/etc/DISTRIB discusses GNU Emacs distribution and
contains an order form for all of the software and manuals available
from the Free Software Foundation.
/usr/local/emacs/etc/DIFF discusses GNU Emacs vs. Twenex Emacs;
.br
/usr/local/emacs/etc/CCADIFF discusses GNU Emacs vs. CCA Emacs;
.br
/usr/local/emacs/etc/GOSDIFF discusses GNU Emacs vs. Gosling Emacs.
.br
/usr/local/emacs/etc/SERVICE lists people offering various services
to assist users of GNU Emacs, including education, troubleshooting,
porting and customization.
.br
These files also have information useful to anyone wishing to write
programs in the Emacs Lisp extension language, which is
documented in the GNU Emacs Lisp Manual.
/usr/local/emacs/info - files for the Info documentation browser
(a subsystem of Emacs) to refer to. Currently not much of Unix
is documented here, but the complete text of the Emacs reference
manual is included in a convenient tree structured form.
/usr/local/emacs/lock - holds lock files that are made for all
files being modified in Emacs, to prevent simultaneous modification
of one file by two users.
/usr/local/emacs/cpp - the GNU cpp, needed for building Emacs on
certain versions of Unix where the standard cpp cannot handle long
names for macros.
/usr/local/emacs/shortnames - facilities for translating long names to
short names in C code, needed for building Emacs on certain versions
of Unix where the C compiler cannot handle long names for functions
or variables.
.\" START DELETING HERE IF YOU'RE NOT USING X
/usr/lib/X11/rgb.txt - list of valid X color names.
.\" STOP DELETING HERE IF YOU'RE NOT USING X
.PP
.SH BUGS
There is a mailing list, bug-gnu-emacs@prep.ai.mit.edu on the internet
(ucbvax!prep.ai.mit.edu!bug-gnu-emacs on UUCPnet), for reporting Emacs
bugs and fixes. But before reporting something as a bug, please try
to be sure that it really is a bug, not a misunderstanding or a
deliberate feature. We ask you to read the section ``Reporting Emacs
Bugs'' near the end of the reference manual (or Info system) for hints
on how and when to report bugs. Also, include the version number of
the Emacs you are running in \fIevery\fR bug report that you send in.
Do not expect a personal answer to a bug report. The purpose of reporting
bugs is to get them fixed for everyone in the next release, if possible.
For personal assistance, look in the SERVICE file (see above) for
a list of people who offer it.
Please do not send anything but bug reports to this mailing list.
Send requests to be added to mailing lists to the special list
info-gnu-emacs-request@prep.ai.mit.edu (or the corresponding UUCP
address). For more information about Emacs mailing lists, see the
file /usr/local/emacs/etc/MAILINGLISTS. Bugs tend actually to be
fixed if they can be isolated, so it is in your interest to report
them in such a way that they can be easily reproduced.
.PP
Bugs that I know about are: shell will not work with programs
running in Raw mode on some Unix versions.
.SH UNRESTRICTIONS
.PP
.I Emacs
is free; anyone may redistribute copies of
.I Emacs
to
anyone under the terms stated in the
.I Emacs
General Public License,
a copy of which accompanies each copy of
.I Emacs
and which also
appears in the reference manual.
.PP
Copies of
.I Emacs
may sometimes be received packaged with distributions of Unix systems,
but it is never included in the scope of any license covering those
systems. Such inclusion violates the terms on which distribution
is permitted. In fact, the primary purpose of the General Public
License is to prohibit anyone from attaching any other restrictions
to redistribution of
.I Emacs.
.PP
Richard Stallman encourages you to improve and extend
.I Emacs,
and urges that
you contribute your extensions to the GNU library. Eventually GNU
(Gnu's Not Unix) will be a complete replacement for Berkeley
Unix.
Everyone will be able to use the GNU system for free.
.SH SEE ALSO
X(1), xlsfonts(1), xterm(1), xrdb(1)
.SH AUTHORS
.PP
.I Emacs
was written by Richard Stallman and the Free Software Foundation.
Joachim Martillo and Robert Krawitz added the X features.

34
etc/emacs.icon Normal file
View file

@ -0,0 +1,34 @@
/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16
*/
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x8000,0x0000,0x0000,0x0001,
0x8000,0x0000,0x007E,0x1C01,0x8000,0x0000,0x0006,0x1C01,
0x8000,0x0000,0x007F,0xFC01,0x8000,0x0000,0x0080,0x1C01,
0x8000,0x0000,0x013F,0xFC01,0x8000,0x0000,0x0140,0x1C01,
0x8000,0x0000,0x03E0,0x1C01,0x8000,0x0000,0x0000,0x1C01,
0x8000,0x0000,0x0000,0x1C01,0x8000,0x0000,0x0000,0x1C01,
0x8000,0x0000,0x0000,0x1C01,0x8000,0x0000,0x0210,0x1C01,
0x8000,0x0000,0x0330,0x1C01,0x8000,0x0000,0x00C0,0x1C01,
0x8003,0xFFFF,0xFFFF,0xFE01,0x8005,0xFFFF,0xFFFF,0xFE01,
0x8004,0xFFFF,0xFFFF,0xFC01,0x8004,0x787F,0xFFFF,0xF801,
0x8004,0x77FF,0xFFFF,0xF801,0x8000,0x77E3,0x6FFF,0xF801,
0x8000,0x762D,0x6FFF,0xF801,0x8004,0x77AD,0x6FFF,0xF801,
0x800C,0x77AD,0x6FFF,0xF801,0x8004,0x786D,0x8FFF,0xF801,
0x8000,0x7FFF,0xFFFF,0xF801,0x8000,0x7FFF,0xFFFF,0xF801,
0x8000,0x7E0F,0xFFFF,0xF801,0x8008,0x7EFF,0xFFFF,0xF801,
0x800C,0x7EF9,0x31CE,0x3801,0x8004,0x7E1A,0xADB5,0xF801,
0x8000,0x7EFA,0xADBE,0x7801,0x8000,0x7EFB,0xADB7,0xB801,
0x8000,0x7E0B,0xB2CC,0x7801,0x8000,0x7FFF,0xFFFF,0xF801,
0x8004,0x3FFF,0xFFFF,0xF001,0x8004,0x1FFF,0xFFFF,0xE001,
0x800C,0x0003,0x6000,0x0001,0x8000,0x0001,0x43C0,0x0001,
0x8000,0x0001,0x4420,0x0001,0x8000,0x0001,0x4990,0x0001,
0x8000,0x0001,0x4A50,0x0001,0x8004,0x0001,0x3250,0x0001,
0x8004,0x0000,0x8450,0x0001,0x800A,0x0000,0x7850,0x0001,
0x8000,0x0000,0x0050,0x0001,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

442
etc/emacs.names Normal file
View file

@ -0,0 +1,442 @@
From: harvard!topaz!BLUE!BRAIL@mit-eddie
Date: 9 Sep 85 17:25:27 EDT
Subject: EMACS -- What does it mean?
To: mit-prep!info-gnu-emacs@TOPAZ.RUTGERS.EDU
EMACS may stand for "Editing MACroS," but some friends of mine
suggested some more creative definitions. Here they are. Anyone have
any additions?
--------
Even a
Master of
Arts
Comes
Simpler
Emacs
Manuals
Are
Cryptic and
Surreal
Energetic
Merchants
Always
Cultivate
Sales
Each
Manual's
Audience is
Completely
Stupified
Emacs
Means
A
Crappy
Screen
Eventually
Munches
All
Computer
Storage
Even
My
Aunt
Crashes the
System
Eradication of
Memory
Accomplished with
Complete
Simplicity
Elsewhere
Maybe
Alternative
Civilizations
Survive
Egregious
Managers
Actively
Court
Stallman
Esoteric
Malleability
Always
Considered
Silly
Emacs
Manuals
Always
Cause
Senility
Easily
Maintained with the
Assistance of
Chemical
Solutions
EMACS
MACRO
ACTED
CREDO
SODOM
Edwardian
Manifestation of
All
Colonial
Sins
Generally
Not
Used
Except by
Middle
Aged
Computer
Scientists
Extended
Macros
Are
Considered
Superfluous
Every
Mode
Accelerates
Creation of
Software
Elsewhere
Maybe
All
Commands are
Simple
Emacs
May
Allow
Customised
Screwups
Excellent
Manuals
Are
Clearly
Suppressed
Emetic
Macros
Assault
Core and
Segmentation
Embarrassed
Manual-Writer
Accused of
Communist
Subversion
Extensibilty and
Modifiability
Aggravate
Confirmed
Simpletons
Emacs
May
Annihilate
Command
Structures
Easily
Mangles,
Aborts,
Crashes and
Stupifies
Extraneous
Macros
And
Commands
Stink
Exceptionally
Mediocre
Algorithm for
Computer
Scientists
EMACS
Makes no
Allowances
Considering its
Stiff price
Equine
Mammals
Are
Considerably
Smaller
Embarrasingly
Mundane
Advertising
Cuts
Sales
Every
Moron
Assumes
CCA is
Superior
Exceptionally
Mediocre
Autocratic
Control
System
EMACS
May
Alienate
Clients and
Supporters
Excavating
Mayan
Architecture
Comes
Simpler
Erasing
Minds
Allows
Complete
Submission
Every
Male
Adolescent
Craves
Sex
Elephantine
Memory
Absolutely
Considered
Sine que non
Emacs
Makers
Are
Crazy
Sickos
Eenie-Meenie-Miney-Mo-
Macros
Are
Completely
Slow
Experience the
Mildest
Ad
Campaign ever
Seen
Emacs
Makefiles
Annihilate
C-
Shells
Eradication of
Memory
Accomplished with
Complete
Simplicity
Emetic
Macros
Assault
Core and
Segmentation
Epileptic
MLisp
Aggravates
Compiler
Seizures
Eleven thousand
Monkeys
Asynchronously
Crank out these
Slogans
-------
From: ihnss!warren@mit-eddie (Warren Montgomery)
Newsgroups: net.emacs
Subject: Re: EMACS -- What does it mean?
Date: Tue, 10-Sep-85 09:14:24 EDT
Organization: AT&T Bell Labs, Naperville, IL
Apparently-To: emacs-netnews-distribution@mit-prep
Someone at a luncheon suggested it meant:
Evenings,
Mornings,
And a
Couple of
Saturdays
(In reference to the odd hours that went into the creation of my
implementation).
--
Warren Montgomery
ihnss!warren
IH ((312)-979) x2494
Date: Wed, 18 Sep 85 10:11:04 edt
From: inmet!tower@inmet.inmet (Leonard H. Tower Jr.) <inmet!tower@cca-unix>
Subject: Re: EMACS -- What does it mean?
To: tower@MIT-PREP.ARPA
Received: by inmet.uucp (4.12/inmet) id AA02199; Wed, 18 Sep 85 09:10:17 edt
Date: Wed, 18 Sep 85 09:10:17 edt
Message-Id: <8509181310.AA02199@inmet.uucp>
Uucp-Paths: {bellcore,ima,ihnp4}!inmet!tower
Arpa-Path: ima!inmet!tower@CCA-UNIX.ARPA
Organization: Intermetrics, Inc., Cambridge, MA, USA
Home: 36 Porter Street, Somerville, MA 02143, USA +1 (617) 623-7739
/* Written 6:48 pm Sep 14, 1985 by gml@ssc-vax in inmet:net.emacs */
/* ---------- "Re: EMACS -- What does it mean?" ---------- */
Pleeeeeeeze!!! Nice try on the meaning of EMACS. I believe the
correct acronym is:
Emacs
Makes
All
Computing
Simple
Thank you, and Good Night
/* End of text from inmet:net.emacs */
From: ho95e!wcs@mit-eddie (Bill.Stewart.4K435.x0705)
Newsgroups: net.emacs
Subject: Re: EMACS -- What does it mean?
Date: Thu, 26-Sep-85 21:43:54 EDT
Organization: AT&T Bell Labs, Holmdel NJ
Apparently-To: emacs-netnews-distribution@mit-prep
> > very interesting, but what does GNU stand for ?
> GNU = Gnu's Not UNIX. There is also MINCE, for Mince Is Not a Complete Emacs.
> More recursive acronyms, anyone?
Many people have also seen FINE Is Not Emacs, but the one that has
character is THief Isn't Even Fine.
--
## Bill Stewart, AT&T Bell Labs, Holmdel NJ 1-201-949-0705 ihnp4!ho95c!wcs
Path: mit-eddie!think!harvard!bbnccv!bbncca!linus!decvax!mcnc!ncsu!uvacs!edison!ta2
From: edison!ta2@mit-eddie (tom allebrandi)
Newsgroups: net.emacs
Subject: Re: Re: EMACS -- What does it mean?
Date: Sun, 29-Sep-85 18:11:55 EDT
Organization: General Electric's Mountain Resort
Apparently-To: emacs-netnews-distribution@mit-prep
> GNU = Gnu's Not UNIX. There is also MINCE, for Mince Is Not a Complete Emacs.
>
> More recursive acronyms, anyone?
>
For the DEC-system-10/20: FINE - Fine Is Not Emacs.....
--
...............
tom allebrandi 2, general electric aco, charlottesville, va
{decvax,duke}!mcnc!ncsu!uvacs!edison!ta2
box 8106, charlottesville, va, 22906
(804) 978-5566
...............
Date: Wed, 16 Oct 85 01:38:12 edt
From: inmet!tower (Leonard H. Tower Jr.) <inmet!tower@cca-unix>
Subject: more names
To: tower@MIT-PREP.ARPA
Received: by inmet.uucp (4.12/inmet) id AA12997; Tue, 15 Oct 85 22:31:39 edt
Date: Tue, 15 Oct 85 22:31:39 edt
Message-Id: <8510160231.AA12997@inmet.uucp>
Uucp-Paths: {bellcore,ima,ihnp4}!inmet!tower
Arpa-Path: ima!inmet!tower@CCA-UNIX.ARPA
Organization: Intermetrics, Inc., Cambridge, MA, USA
Home: 36 Porter Street, Somerville, MA 02143, USA +1 (617) 623-7739
/* Written 12:20 pm Oct 14, 1985 by rs@mirror.UUCP in inmet:net.emacs */
SINE: Sine Is Not Emacs
(MIT Architecture Machine Group)
EINE: Eine is Not Emacs
(MIT Lisp Machine)
ZWEI: Zwei Was Eine Initially
("rev2" of EINE)
--
Rich $alz {mit-eddie, ihnp4!inmet, wjh12, cca, datacube} !mirror!rs
Mirror Systems 2067 Massachusetts Ave.
617-661-0777 Cambridge, MA, 02140
/* End of text from inmet:net.emacs */
Path: mit-eddie!genrad!panda!talcott!harvard!seismo!gatech!ulysses!pajb
From: ulysses!pajb@mit-eddie (Paul Bennett)
Newsgroups: net.emacs
Subject: Here we go again ...
Date: Sat, 19-Oct-85 17:26:49 EDT
Organization: AT&T Bell Laboratories, Murray Hill
Apparently-To: emacs-netnews-distribution@mit-prep
> EINE: Eine is Not Emacs
> (MIT Lisp Machine)
>
> ZWEI: Zwei Was Eine Initially
> ("rev2" of EINE)
DREI: DREI - Really Emacs Inside
(Exists only in my head)
Paul.
UUCP: {decvax,allegra,vax135,ucbvax}!ulysses!circe!pajb
DDD: (201) 582 7346
USPS: AT&T Bell Labs, Room 5E-103, Murray Hill, NJ 07974
.. I don't care WHO you are, you're not walking on the water while I'M fishing.--
Paul.
UUCP: {decvax,allegra,vax135,ucbvax}!ulysses!circe!pajb
DDD: (201) 582 7346
USPS: AT&T Bell Labs, Room 5E-103, Murray Hill, NJ 07974
.. I don't care WHO you are, you're not walking on the water while I'M fishing.

278
etc/emacsclient.c Normal file
View file

@ -0,0 +1,278 @@
/* Client process that communicates with GNU Emacs acting as server.
Copyright (C) 1986, 1987 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define NO_SHORTNAMES
#include "../src/config.h"
#undef read
#undef write
#undef open
#ifdef close
#undef close
#endif
#if !defined(BSD) && !defined(HAVE_SYSVIPC)
#include <stdio.h>
main (argc, argv)
int argc;
char **argv;
{
fprintf (stderr, "%s: Sorry, the Emacs server is supported only\n",
argv[0]);
fprintf (stderr, "on systems with Berkeley sockets or System V IPC.\n");
exit (1);
}
#else /* BSD or HAVE_SYSVIPC */
#if defined(BSD) && ! defined (HAVE_SYSVIPC)
/* BSD code is very different from SYSV IPC code */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>
extern int sys_nerr;
extern char *sys_errlist[];
extern int errno;
main (argc, argv)
int argc;
char **argv;
{
char system_name[32];
int s, i;
FILE *out;
struct sockaddr_un server;
char *homedir, *cwd, *str;
char string[BUFSIZ];
struct stat statbfr;
char *getenv (), *getwd ();
if (argc < 2)
{
fprintf (stderr, "Usage: %s filename\n", argv[0]);
exit (1);
}
/*
* Open up an AF_UNIX socket in this person's home directory
*/
if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
{
fprintf (stderr, "%s: ", argv[0]);
perror ("socket");
exit (1);
}
server.sun_family = AF_UNIX;
#ifndef SERVER_HOME_DIR
gethostname (system_name, sizeof (system_name));
sprintf (server.sun_path, "/tmp/esrv%d-%s", geteuid (), system_name);
if (stat (server.sun_path, &statbfr) == -1)
{
perror ("stat");
exit (1);
}
if (statbfr.st_uid != geteuid())
{
fprintf (stderr, "Illegal socket owner\n");
exit (1);
}
#else
if ((homedir = getenv ("HOME")) == NULL)
{
fprintf (stderr, "%s: No home directory\n", argv[0]);
exit (1);
}
strcpy (server.sun_path, homedir);
strcat (server.sun_path, "/.emacs_server");
#endif
if (connect (s, &server, strlen (server.sun_path) + 2) < 0)
{
fprintf (stderr, "%s: ", argv[0]);
perror ("connect");
exit (1);
}
if ((out = fdopen (s, "r+")) == NULL)
{
fprintf (stderr, "%s: ", argv[0]);
perror ("fdopen");
exit (1);
}
cwd = getwd (string);
if (cwd == 0)
{
/* getwd puts message in STRING if it fails. */
fprintf (stderr, "%s: %s (%s)\n", argv[0], string,
(errno < sys_nerr) ? sys_errlist[errno] : "unknown error");
exit (1);
}
for (i = 1; i < argc; i++)
{
if (*argv[i] == '+')
{
char *p = argv[i] + 1;
while (*p >= '0' && *p <= '9') p++;
if (*p != 0)
fprintf (out, "%s/", cwd);
}
else if (*argv[i] != '/')
fprintf (out, "%s/", cwd);
fprintf (out, "%s ", argv[i]);
}
fprintf (out, "\n");
fflush (out);
printf ("Waiting for Emacs...");
fflush (stdout);
rewind (out); /* re-read the output */
str = fgets (string, BUFSIZ, out);
/* Now, wait for an answer and print any messages. */
while (str = fgets (string, BUFSIZ, out))
printf ("%s", str);
exit (0);
}
#else /* This is the SYSV IPC section */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
main (argc, argv)
int argc;
char **argv;
{
int s;
key_t key;
struct msgbuf * msgp =
(struct msgbuf *) malloc (sizeof *msgp + BUFSIZ);
struct msqid_ds * msg_st;
char *homedir, buf[BUFSIZ];
char gwdirb[BUFSIZ];
char *cwd;
char *temp;
char *getwd (), *getcwd (), *getenv ();
if (argc < 2)
{
fprintf (stderr, "Usage: %s filename\n", argv[0]);
exit (1);
}
/*
* Create a message queue using ~/.emacs_server as the path for ftok
*/
if ((homedir = getenv ("HOME")) == NULL)
{
fprintf (stderr, "%s: No home directory\n", argv[0]);
exit (1);
}
strcpy (buf, homedir);
strcat (buf, "/.emacs_server");
creat (buf, 0600);
key = ftok (buf, 1); /* unlikely to be anyone else using it */
s = msgget (key, 0600 | IPC_CREAT);
if (s == -1)
{
fprintf (stderr, "%s: ", argv[0]);
perror ("msgget");
exit (1);
}
/* Determine working dir, so we can prefix it to all the arguments. */
#ifdef BSD
temp = getwd (gwdirb);
#else
temp = getcwd (gwdirb, sizeof gwdirb);
#endif
cwd = gwdirb;
if (temp != 0)
{
/* On some systems, cwd can look like `@machine/...';
ignore everything before the first slash in such a case. */
while (*cwd && *cwd != '/')
cwd++;
strcat (cwd, "/");
}
else
{
fprintf (stderr, cwd);
exit (1);
}
msgp->mtext[0] = 0;
argc--; argv++;
while (argc)
{
if (*argv[0] == '+')
{
char *p = argv[0] + 1;
while (*p >= '0' && *p <= '9') p++;
if (*p != 0)
strcat (msgp->mtext, cwd);
}
else if (*argv[0] != '/')
strcat (msgp->mtext, cwd);
strcat (msgp->mtext, argv[0]);
strcat (msgp->mtext, " ");
argv++; argc--;
}
strcat (msgp->mtext, "\n");
msgp->mtype = 1;
if (msgsnd (s, msgp, strlen (msgp->mtext)+1, 0) < 0)
{
fprintf (stderr, "%s: ", argv[0]);
perror ("msgsnd");
exit (1);
}
/*
* Now, wait for an answer
*/
printf ("Waiting for Emacs...");
fflush (stdout);
msgrcv (s, msgp, BUFSIZ, getpid (), 0); /* wait for anything back */
strcpy (buf, msgp->mtext);
printf ("\n%s\n", buf);
exit (0);
}
#endif /* HAVE_SYSVIPC */
#endif /* BSD or HAVE_SYSVIPC */

134
etc/emacstool.1 Normal file
View file

@ -0,0 +1,134 @@
.TH EMACSTOOL 1
.SH NAME
.I emacstool
\- run emacs under Sun windows with function-key and mouse support.
.SH SYNOPSIS
.I emacstool
[{window_args} {-rc run_command_path} args ... ]
.SH TYPICAL USAGE
In ~/.suntools or ~/.rootmenu include a line like this:
.br
"Emacstool" emacstool -WI emacs.icon -f emacstool-init
.SH DESCRIPTION
.B Emacstool
creates a SunView frame and a tty subwindow within which mouse events
and function keys are translated to ASCII sequences which Emacs can
parse. The translated input events are sent to the process running in
the tty subwindow, which is typically GNU Emacs. Emacstool thereby
allows GNU Emacs users to make full use of the mouse and function keys.
GNU Emacs can be loaded with functions to interpret the mouse and
function-key events to make a truely fine screen oriented editor for
the Sun Workstation.
.PP
(Note that GNU Emacs has a special interface to the X window system as
well. The X window system has many technical advantages, it is an
industry standard, and it is also free software. The Free Software
Foundation urges you to try X windows, and distributes a free copy of
X on Emacs distribution tapes.)
.PP
Function keys are translated to a sequence of the form
`^X*[a-o][lrt]'. The last character is `l', `r', or `t' corresponding
to whether the key is among the Left, Right, or Top function keys.
The third character indicates which button of the group
was pressed. Thus, the function key in the lower right corner will
transmit the sequence `^X*or'. In addition, the [lrt] is affected by
the Control, Meta, and Shift keys. Unshifted Control keys will be
non-alphabetic: C-l is [,], C-r is [2], C-t is [4].
.PP
Mouse buttons are encoded as `^X^@([124] x y)\\n'. ^X^@ is the
standard GNU Emacs mouse event prefix, it is followed by a list
indicating the button pressed and the character row and column of the
point in the window where the mouse cursor is, and followed by a
newline character. In GNU Emacs, the ^X^@ dispatches to a
mouse event handler which then reads the following list.
.SH OPTIONS
.B Emacstool
supports all the standard window arguments, including font and icon
specifiers.
.PP
By default, Emacstool runs the program
.I emacs
in the created subwindow.
The value of the environment variable
.I EMACSTOOL
can be used to override this if your version of
.B Emacs
is not accessible on your search path by the name
.I Emacs.
In addition, the run command can be set by the
.I pathname
following the last occurence of the
.I \-rc
flag.
This is convenient for using Emacstool to run on remote machines.
.PP
All other command line arguments not used by the window system are passed
as arguments to the program that runs in the Emacstool window.
.PP
For example:
.PP
local% (emacstool -rc rlogin remote -8 &)&
.PP
will create an Emacstool window logged in to a machine named
.I remote.
If Emacs is run from this window,
Emacstool will encode mouse and function keys, and send them to rlogin.
If Emacs is run from this shell on the remote machine, it will see
the mouse and function keys properly.
However, since the remote host does not have access to the screen,
the cursor cannot be changed, menus will not appear, and the selection
buffer (STUFF) is limited.
.SH Using With GNU Emacs:
The GNU Emacs files
lisp/term/sun.el,
lisp/sun-mouse.el,
lisp/sun-fns.el,
and
src/sunfns.c
provide emacs support for the Emacstool and function keys.
Emacstool will automatically set the TERM environment variable to be "sun"
and unset the environment variable TERMCAP. That is, these variables will
not be inherited from the shell that starts Emacstool.
Since the terminal type is
.I SUN
(that is, the environment variable TERM is set to
.I SUN),
Emacs will automatically load the file lisp/term/sun.
This, in turn, will ensure that sun-mouse.el is autoloaded when any mouse
events are detected. It is suggested that
.I sun-mouse
and
.I sun-fns
be loaded in your site-init.el file, so that they will always be loaded
when running on a Sun workstation.
.PP
In addition, Emacstool sets the environment variable IN_EMACSTOOL = "t".
Lisp code in your ~/.emacs can use (getenv "IN_EMACSTOOL")
to determine whether to do Emacstool specific initalization.
Sun.el uses this to automatically call emacstool-init (getenv "IN_EMACSTOOL")
is defined.
.PP
The file src/sunfns.c defines several useful functions for emacs on
the Sun. Among these are procedures to pop-up SunView
.I menus,
put and get from the SunView
.I STUFF
buffer, and a procedure for changing the cursor
.I icon.
If you want to define or edit cursor icons,
there is a rudimentary mouse driven icon editor in the file
lisp/sun-cursors.el. Try invoking (sc:edit-cursor)
.SH BUGS
It takes a few milliseconds to create a menu before it pops up.
.SH ENVIRONMENT VARIABLES
EMACSTOOL
IN_EMACSTOOL
TERM
TERMCAP
.SH FILES
.DT
emacs
.SH "SEE ALSO"
emacs(1)
.../etc/SUN-SUPPORT
.../lisp/term/sun.el

520
etc/emacstool.c Normal file
View file

@ -0,0 +1,520 @@
/* Copyright (C) 1986, 1988, 1990, 1991 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* For Emacs in SunView/Sun-Windows: (supported by Sun Unix v3.2 or greater)
* Insert a notifier filter-function to convert all useful input
* to "key" sequences that emacs can understand. See: Emacstool(1).
*
* Author: Jeff Peck, Sun Microsystems, Inc. <peck@eng.sun.com>
*
* Original Idea: Ian Batten
* Updated 15-Mar-88, Jeff Peck: set IN_EMACSTOOL, TERM, TERMCAP
* Updated 10-Sep-88, Jeff Peck: add XVIEW and JLE support
* Updated 8-Oct-90, Jeff Peck: add Meta-bit for Xview
* Updated 6-Mar-91, Jeff Peck: Hack to detect -Wt invocation
* [note, TTYSW limitation means you must Click-To-Type in Openwin]
* [fixed in OW3 or use local/tty.o]
* for better results, this should move to using TERMSW.
* Updated 30-Mar-91, Jeff Peck, et al: Enable using TERMSW (-DTTERM)
* TERMSW understands point-to-type, even in OW2.
* Updated 5-Jun-91, Jeff Peck: Meta-key support fixed for OWv3
* Better event diagnostics for DEBUGEMACSTOOL
*
* [note: xvetool should be started with the "-nw" flag for emacs!]
*/
#ifdef XVIEW
#include <xview/xview.h>
#include <xview/panel.h>
#include <xview/attr.h>
#include <xview/tty.h>
#include <xview/ttysw.h> /* private defines */
#include <xview/termsw.h> /* -DTTERM */
#include <xview/font.h> /* for testing */
#else
#include <suntool/sunview.h>
#include <suntool/tty.h>
#include <suntool/ttysw.h>
#endif /* XVIEW */
#ifdef JLE
# include <locale.h>
#endif /* JLE */
#include <stdio.h>
#include <sys/file.h>
#define BUFFER_SIZE 128 /* Size of all the buffers */
/* define WANT_CAPS_LOCK to make f-key T1 (aka F1) behave as CapsLock */
#define WANT_CAPS_LOCK
#ifdef WANT_CAPS_LOCK
int caps_lock; /* toggle indicater for f-key T1 caps lock */
static char *Caps = "[CAPS] "; /* Caps Lock prefix string */
#define CAPS_LEN 7 /* strlen (Caps) */
#endif
static char *mouse_prefix = "\030\000"; /* C-x C-@ */
static int m_prefix_length = 2; /* mouse_prefix length */
static char *key_prefix = "\030*"; /* C-x * */
static int k_prefix_length = 2; /* key_prefix length */
#ifdef JLE
static char *emacs_name = "nemacs"; /* default run command */
static char *title = "NEmacstool - "; /* initial title */
#else
static char *emacs_name = "emacs"; /* default run command */
static char *title = "Emacstool - "; /* initial title */
#endif /* JLE */
static char buffer[BUFFER_SIZE]; /* send to ttysw_input */
static char *bold_name = 0; /* for -bold option */
Frame frame; /* Base frame for system */
#ifndef TTERM
#define SWTYPE TTY
Tty tty_win; /* Where emacs is reading */
#else
#define SWTYPE TERMSW
Termsw tty_win; /* Termsw does follow-mouse */
#endif /* TTERM */
#ifdef XVIEW
Xv_Window tty_view; /* Where the events are in Xview*/
#else
Tty tty_view; /* SunView place filler */
#endif /* XVIEW */
int font_width, font_height; /* For translating pixels to chars */
int left_margin = 0; /* default window -- frame offset */
int console_fd = 0; /* for debugging: setenv DEBUGEMACSTOOL */
FILE *console; /* for debugging: setenv DEBUGEMACSTOOL */
Icon frame_icon;
/* make an icon_image for the default frame_icon */
static short default_image[258] =
{
#include <images/terminal.icon>
};
mpr_static(icon_image, 64, 64, 1, default_image);
/*
* Assign a value to a set of keys
*/
int
button_value (event)
Event *event;
{
int retval = 0;
/*
* Code up the current situation:
*
* 1 = MS_LEFT;
* 2 = MS_MIDDLE;
* 4 = MS_RIGHT;
* 8 = SHIFT;
* 16 = CONTROL;
* 32 = META;
* 64 = DOUBLE;
* 128 = UP;
*/
if (MS_LEFT == (event_id (event))) retval = 1;
if (MS_MIDDLE == (event_id (event))) retval = 2;
if (MS_RIGHT == (event_id (event))) retval = 4;
if (event_shift_is_down (event)) retval += 8;
if (event_ctrl_is_down (event)) retval += 16;
if (event_meta_is_down (event)) retval += 32;
if (event_is_up (event)) retval += 128;
return retval;
}
/*
* Variables to store the time of the previous mouse event that was
* sent to emacs.
*
* The theory is that to time double clicks while ignoreing UP buttons,
* we must keep track of the accumulated time.
*
* If someone writes a SUN-SET-INPUT-MASK for emacstool,
* That could be used to selectively disable UP events,
* and then this cruft wouldn't be necessary.
*/
static long prev_event_sec = 0;
static long prev_event_usec = 0;
/*
* Give the time difference in milliseconds, where one second
* is considered infinite.
*/
int
time_delta (now_sec, now_usec, prev_sec, prev_usec)
long now_sec, now_usec, prev_sec, prev_usec;
{
long sec_delta = now_sec - prev_sec;
long usec_delta = now_usec - prev_usec;
if (usec_delta < 0) { /* "borrow" a second */
usec_delta += 1000000;
--sec_delta;
}
if (sec_delta >= 10)
return (9999); /* Infinity */
else
return ((sec_delta * 1000) + (usec_delta / 1000));
}
/*
* Filter function to translate selected input events for emacs
* Mouse button events become ^X^@(button x-col y-line time-delta) .
* Function keys: ESC-*{c}{lrt} l,r,t for Left, Right, Top;
* {c} encodes the keynumber as a character [a-o]
*/
static Notify_value
input_event_filter_function (window, event, arg, type)
#ifdef XVIEW
Xv_Window window;
#else /* not XVIEW */
Window window;
#endif /* XVIEW */
Event *event;
Notify_arg arg;
Notify_event_type type;
{
struct timeval time_stamp;
/* if DEBUGEMACSTOOL is set, printout event information */
if (console_fd) {
fprintf(console, "Event: %s%s%c %d %d\n",
(event_ctrl_is_down(event) ? "C-" : " "),
(event_meta_is_down(event) ? "M-" : " "),
(((event_is_button (event)) ? 'M' :
((event_is_key_left (event)) ? 'L' :
((event_is_key_right (event)) ? 'R' :
((event_is_key_top (event)) ? 'T' :
(((ASCII_FIRST <= event_id(event))
&& (event_id(event) <= ASCII_LAST)) ?
(((127 & event_id(event)) < 32) ?
((127 & event_id(event)) + 64) :
((127 & event_id(event)))) : '?')))))),
event_id(event),
event_action(event));
}
/* UP L1 is the STOP key */
if (event_id(event) == WIN_STOP) {
ttysw_input(tty_win, "\007\007\007\007\007\007\007", 7);
return NOTIFY_IGNORED;
}
/* UP L5 & L7 is Expose & Open, let them pass to sunview */
if (event_id(event) == KEY_LEFT(5) || event_id(event) == KEY_LEFT(7))
if (event_is_up (event))
return notify_next_event_func (window, event, arg, type);
else
return NOTIFY_IGNORED;
{ /* Do the mouse == button events */
if (event_is_button (event)) { /* do Mouse Button events */
time_stamp = event_time (event);
ttysw_input (tty_win, mouse_prefix, m_prefix_length);
sprintf (buffer, "(%d %d %d %d)\015",
button_value (event),
(event_x (event) - left_margin) / font_width,
event_y (event) / font_height,
time_delta (time_stamp.tv_sec, time_stamp.tv_usec,
prev_event_sec, prev_event_usec)
);
ttysw_input (tty_win, buffer, strlen(buffer));
prev_event_sec = time_stamp.tv_sec;
prev_event_usec = time_stamp.tv_usec;
return NOTIFY_IGNORED;
}
}
{ /* Do the function key events */
int d;
char c = (char) 0;
if ((event_is_key_left (event)) ?
((d = event_id(event) - KEY_LEFT(1) + 'a'), c='l') :
((event_is_key_right (event)) ?
((d = event_id(event) - KEY_RIGHT(1) + 'a'), c='r') :
((event_is_key_top (event)) ?
((d = event_id(event) - KEY_TOP(1) + 'a'), c='t') : 0))) {
if (event_is_up(event)) return NOTIFY_IGNORED;
if (event_shift_is_down (event)) c = c - 32;
/* this will give a non-{lrt} for unshifted keys */
if (event_ctrl_is_down (event)) c = c - 64;
if (event_meta_is_down (event)) c = c + 128;
#ifdef WANT_CAPS_LOCK
/* set a toggle and relabel window so T1 can act like caps-lock */
if (event_id(event) == KEY_TOP(1)) {
/* make a frame label with and without CAPS */
strcpy (buffer, Caps);
title = &buffer[CAPS_LEN];
strncpy (title, (char *)window_get (frame, FRAME_LABEL),
BUFFER_SIZE - CAPS_LEN);
buffer[BUFFER_SIZE] = (char) 0;
if (strncmp (title, Caps, CAPS_LEN) == 0)
title += CAPS_LEN; /* already Caps */
caps_lock = (caps_lock ? 0 : CAPS_LEN);
window_set(frame, FRAME_LABEL, (title -= caps_lock), 0);
return NOTIFY_IGNORED;
}
#endif /* WANT_CAPS_LOCK */
ttysw_input (tty_win, key_prefix, k_prefix_length);
sprintf (buffer, "%c%c", d, c);
ttysw_input(tty_win, buffer, strlen(buffer));
return NOTIFY_IGNORED;
}
}
/* handle ascii keyboard events
* extract "event_is_ascii(event)" from the event_id, not the event_action
*/
if ((ASCII_FIRST <= event_id(event)) && (event_id(event) <= ASCII_LAST)) {
/* ignore key-up events (button events have already been handled) */
if (event_is_up(event)) return NOTIFY_IGNORED;
#ifdef WANT_CAPS_LOCK
/* shift alpha chars to upper case if toggle is set */
if ((caps_lock) && (event_id(event) >= 'a') && (event_id(event) <= 'z'))
event_set_id(event, (event_id(event) - 32));
#endif /* WANT_CAPS_LOCK */
#ifndef NO_META_BIT
/* under Openwindows/X, the meta bit is not set in the key event,
* emacs expects this so we add it in here:
*/
if (event_meta_is_down(event))
event_set_id(event, 128 | event_id(event));
#endif /* NO_META_BIT */
}
return notify_next_event_func (window, event, arg, type);
}
main (argc, argv)
int argc;
char **argv;
{
int error_code; /* Error codes */
#ifdef JLE
setlocale(LC_ALL, "");
#endif /* JLE */
if(getenv("DEBUGEMACSTOOL"))
console = fdopen (console_fd = open("/dev/console",O_WRONLY), "w");
putenv("IN_EMACSTOOL=t"); /* notify subprocess that it is in emacstool */
if (putenv("TERM=sun") != 0) /* TTY_WIN will be a TERM=sun window */
{fprintf (stderr, "%s: Could not set TERM=sun, using `%s'\n",
argv[0], (char *)getenv("TERM")) ;};
/*
* If TERMCAP starts with a slash, it is the pathname of the
* termcap file, not an entry extracted from it, so KEEP it!
* Otherwise, it may not relate to the new TERM, so Nuke-It.
* If there is no TERMCAP environment variable, don't make one.
*/
{
char *termcap ; /* Current TERMCAP value */
termcap = (char *)getenv("TERMCAP") ;
if (termcap && (*termcap != '/'))
{
if (putenv("TERMCAP=") != 0)
{fprintf (stderr, "%s: Could not clear TERMCAP\n", argv[0]) ;} ;
} ;
} ;
/* find command to run as subprocess in window */
if (!(argv[0] = (char *)getenv("EMACSTOOL"))) /* Set emacs command name */
argv[0] = emacs_name;
/* Emacstool recognizes two special args: -rc <file> and -bold <bold-name> */
for (argc = 1; argv[argc]; argc++) /* Use last one on line */
{
if(!(strcmp ("-rc", argv[argc]))) /* Override if -rc given */
{int i = argc;
argv[argc--]=0; /* kill the -rc argument */
if (argv[i+1]) { /* move to argv[0] and squeeze the rest */
argv[0]=argv[i+1];
for (; argv[i+2]; (argv[i]=argv[i+2],argv[++i]=0));
}
}
if (!(strcmp ("-bold", argv[argc])))
{int i = argc;
argv[argc--]=0; /* kill the -bold argument */
if (argv[i+1]) { /* move to bold_name and squeeze the rest */
bold_name = argv[i+1];
for (; argv[i+2]; (argv[i]=argv[i+2],argv[++i]=0));
}
}
};
strcpy (buffer, title);
strncat (buffer, argv[0], /* append run command name */
(BUFFER_SIZE - (strlen (buffer)) - (strlen (argv[0]))) - 1);
error_code = interpose_on_window(argc,argv);
if (error_code != 0) { /* Barf */
fprintf (stderr, "notify_interpose_event_func returns %d.\n", error_code);
exit (1);
}
#ifdef XVIEW
xv_main_loop (frame); /* And away we go */
#else
window_main_loop (frame);
#endif /* XVIEW */
}
#ifdef XVIEW
int interpose_on_window(argc,argv)
int argc;
char **argv;
{
#ifndef TTERM
#ifdef FONT_WIDTH_ADJUST
int i, font_width_adjust = 1; /* hackery, and hueristics */
/* If -Wt is not supplied, OWv2 font defaults as lucidasans-12 (width=8)
* rather than the lucidasanstypewriter (width=7) actually used by ttysw.
* This hack attempts to workaround it.
*/
for (i = 1; argv[i]; i++) {
if (!(strcmp ("-Wt", argv[i])) || !(strcmp ("-font", argv[i])))
{font_width_adjust = 0;
if (console_fd) fprintf(console, "-Wt = %d\n", font_width_adjust);
break;}
}
#endif /* FONT_WIDTH_ADJUST */
#endif /* not TTERM */
/* initialize Xview, and strip window args */
xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, 0);
/* do this first, so arglist can override it */
frame_icon = icon_create (ICON_LABEL, "Emacstool",
ICON_IMAGE, &icon_image,
0);
/* Build a frame to run in */
frame = xv_create ((Xv_Window)NULL, FRAME,
FRAME_LABEL, buffer,
FRAME_ICON, frame_icon,
0);
/* Create a tty with emacs in it */
tty_win = xv_create (frame, SWTYPE, WIN_IS_CLIENT_PANE,
TTY_QUIT_ON_CHILD_DEATH, TRUE,
TTY_BOLDSTYLE, TTYSW_BOLD_INVERT,
TTY_ARGV, argv,
0);
if (bold_name) {
(void)xv_set(tty_win, TTY_BOLDSTYLE_NAME, bold_name, 0);
}
{
Xv_font font; /* declare temp font variable */
font = (Xv_font)xv_get (tty_win, XV_FONT);
font_height = (int)xv_get (font, FONT_DEFAULT_CHAR_HEIGHT);
font_width = (int)xv_get (font, FONT_DEFAULT_CHAR_WIDTH);
}
if (console_fd) fprintf(console, "Width = %d\n", font_width);
#ifndef TTERM
#ifdef FONT_WIDTH_ADJUST
font_width -= font_width_adjust; /* A guess! font cache bug in ttysw*/
#endif /* FONT_WIDTH_ADJUST */
#else
/* make the termsw act as a tty */
xv_set(tty_win, TERMSW_MODE, TTYSW_MODE_TYPE, 0);
/* termsw has variable offset depending on scrollbar size/location */
left_margin = (int)xv_get (tty_win, TEXTSW_LEFT_MARGIN);
#endif /* TTERM */
tty_view = (Xv_Window) xv_get (tty_win, OPENWIN_NTH_VIEW, 0);
xv_set(tty_view,
WIN_CONSUME_EVENTS,
WIN_MOUSE_BUTTONS, WIN_UP_EVENTS,
ACTION_ADJUST, ACTION_MENU,
WIN_ASCII_EVENTS,
WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
0,
0);
/* Interpose my event function */
return (int) notify_interpose_event_func
(tty_view, input_event_filter_function, NOTIFY_SAFE);
}
#else /* not XVIEW */
int interpose_on_window (argc, argv)
int argc;
char **argv;
{
/* do this first, so arglist can override it */
frame_icon = icon_create (ICON_LABEL, "Emacstool",
ICON_IMAGE, &icon_image,
0);
/* Build a frame to run in */
frame = window_create ((Window)NULL, FRAME,
FRAME_LABEL, buffer,
FRAME_ICON, frame_icon,
FRAME_ARGC_PTR_ARGV, &argc, argv,
0);
/* Create a tty with emacs in it */
tty_win = window_create (frame, TTY,
TTY_QUIT_ON_CHILD_DEATH, TRUE,
TTY_BOLDSTYLE, TTYSW_BOLD_INVERT,
TTY_ARGV, argv,
0);
if (bold_name) {
(void)window_set(tty_win, TTY_BOLDSTYLE_NAME, bold_name, 0);
}
/* ttysw uses pf_default, one must set WIN_FONT explicitly */
window_set (tty_win, WIN_FONT, pf_default(), 0);
font_height = (int)window_get (tty_win, WIN_ROW_HEIGHT);
font_width = (int)window_get (tty_win, WIN_COLUMN_WIDTH);
tty_view = tty_win;
window_set(tty_view,
WIN_CONSUME_PICK_EVENTS,
WIN_STOP,
WIN_MOUSE_BUTTONS, WIN_UP_EVENTS,
/* LOC_WINENTER, LOC_WINEXIT, LOC_MOVE, */
0,
WIN_CONSUME_KBD_EVENTS,
WIN_STOP,
WIN_ASCII_EVENTS,
WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
/* WIN_UP_ASCII_EVENTS, */
0,
0);
/* Interpose my event function */
return (int) notify_interpose_event_func
(tty_view, input_event_filter_function, NOTIFY_SAFE);
}
#endif /* XVIEW */

326
etc/env.c Normal file
View file

@ -0,0 +1,326 @@
/* env.c - manipulate environment and execute a program
in that environment
Mly 861126
Copyright (C) 1986 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
/*
If first argument is "-", then a new environment is constructed
from scratch; otherwise the environment is inherited from the parent
process, except as modified by other options.
So, "env - foo" will invoke the "foo" program in a null environment,
whereas "env foo" would invoke "foo" in the same environment as that
passed to "env" itself.
Subsequent arguments are interpreted as follows:
* "variable=value" (ie an arg containing a "=" character)
means to set the specified environment variable to that value.
`value' may be of zero length ("variable="). Note that setting
a variable to a zero-length value is different from unsetting it.
* "-u variable" or "-unset variable"
means to unset that variable
If that variable isn't set, does nothing.
* "-s variable value" or "-set variable value"
same as "variable=value"
* "-" or "--"
are used to indicate that the following argument is the program
to invoke. This is only necessary when the program's name
begins with "-" or contains a "="
* anything else
The first remaining argument specifies a program to invoke
(it is searched for according to the specification of the PATH
environment variable) and any arguments following that are
passed as arguments to that program
If no program-name is specified following the environment
specifications the the resulting environment is printed
(The is like specifying a program-name of "printenv")
Examples:
If the environment passed to "env" is
{ USER=rms EDITOR=emacs PATH=.:/gnubin:/hacks }
* "env DISPLAY=gnu:0 nemacs"
calls "nemacs" in the envionment
{ EDITOR=emacs USER=rms DISPLAY=gnu }
* "env - USER=foo /hacks/hack bar baz"
will call the "hack" program on arguments "bar" and "baz"
in an environment in which the only variable is "USER"
Note that the "-" option will clear out the PATH variable,
so one should be careful to specify in which directory
to find the program to call
* "env -u EDITOR USER=foo PATH=/energy -- e=mc2 bar baz"
The program "/energy/e=mc2" is called with environment
{ USER=foo PATH=/energy }
*/
#ifdef EMACS
#define NO_SHORTNAMES
#include "../src/config.h"
#endif /* EMACS */
#include <stdio.h>
#include <errno.h>
extern int execvp ();
extern char *index ();
char *xmalloc (), *xrealloc ();
char *concat ();
extern char **environ;
char **nenv;
int nenv_size;
char *progname;
void setenv ();
void fatal ();
main (argc, argv, envp)
register int argc;
register char **argv;
char **envp;
{
register char *tem;
progname = argv[0];
argc--;
argv++;
nenv_size = 100;
nenv = (char **) xmalloc (nenv_size * sizeof (char *));
*nenv = (char *) 0;
/* "-" flag means to not inherit parent's environment */
if (argc && !strcmp (*argv, "-"))
{
argc--;
argv++;
}
else
/* Else pass on existing env vars. */
for (; *envp; envp++)
{
tem = index (*envp, '=');
if (tem)
{
*tem = '\000';
setenv (*envp, tem + 1);
}
}
while (argc > 0)
{
tem = index (*argv, '=');
if (tem)
/* If arg contains a "=" it specifies to set a variable */
{
*tem = '\000';
setenv (*argv, tem + 1);
argc--; argv++;
continue;
}
if (**argv != '-')
/* Remaining args are program name and args to pass it */
break;
if (argc < 2)
fatal ("No argument following \"%s\" switch", *argv);
if (!strcmp (*argv, "-u") ||
!strcmp (*argv, "-unset"))
/* Unset a variable */
{
argc--; argv++;
setenv (*argv, 0);
argc--; argv++;
}
else if (!strcmp (*argv, "-s") ||
!strcmp (*argv, "-set"))
/* Set a variable */
{
argc--; argv++;
tem = *argv;
if (argc < 2)
fatal ("No value specified for variable \"%s\"",
tem);
argc--; argv++;
setenv (tem, *argv);
argc--; argv++;
}
else if (!strcmp (*argv, "-") || !strcmp (*argv, "--"))
{
argc--; argv++;
break;
}
else
{
fatal ("unknown switch \"%s\"", *argv);
}
}
/* If no program specified print the environment and exit */
if (argc <= 0)
{
while (*nenv)
printf ("%s\n", *nenv++);
exit (0);
}
else
{
extern int errno, sys_nerr;
extern char *sys_errlist[];
environ = nenv;
(void) execvp (*argv, argv);
fprintf (stderr, "%s: Cannot execute \"%s\"",
progname, *argv);
if (errno < sys_nerr)
fprintf (stderr, ": %s\n" , sys_errlist[errno]);
else
putc ('\n', stderr);
exit (errno != 0 ? errno : 1);
}
}
void
setenv (var, val)
register char *var, *val;
{
register char **e;
int len = strlen (var);
{
register char *tem = index (var, '=');
if (tem)
fatal ("Environment variable names may not contain \"=\": %s",
var);
else if (*var == '\000')
fatal ("Zero-length environment variable name specified.");
}
for (e = nenv; *e; e++)
if (!strncmp (var, *e, len) &&
(*e)[len] == '=')
{
if (val)
goto set;
else
do { *e = *(e + 1); } while (*e++);
return;
}
if (!val)
return; /* Nothing to unset */
len = e - nenv;
if (len + 1 >= nenv_size)
{
nenv_size += 100;
nenv = (char **) xrealloc (nenv, nenv_size * sizeof (char *));
e = nenv + len;
}
set:
val = concat (var, "=", val);
if (*e)
free (*e);
else
*(e + 1) = (char *) 0;
*e = val;
return;
}
void
fatal (msg, arg1, arg2)
char *msg, *arg1, *arg2;
{
fprintf (stderr, "%s: ", progname);
fprintf (stderr, msg, arg1, arg2);
putc ('\n', stderr);
exit (1);
}
extern char *malloc (), *realloc ();
void
memory_fatal ()
{
fatal ("Out of memory");
}
char *
xmalloc (size)
int size;
{
register char *value;
value = (char *) malloc (size);
if (!value) memory_fatal ();
return (value);
}
char *
xrealloc (ptr, size)
char *ptr;
int size;
{
register char *value;
value = (char *) realloc (ptr, size);
if (!value) memory_fatal ();
return (value);
}
/* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
char *
concat (s1, s2, s3)
char *s1, *s2, *s3;
{
int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
strcpy (result, s1);
strcpy (result + len1, s2);
strcpy (result + len1 + len2, s3);
*(result + len1 + len2 + len3) = 0;
return result;
}
/*
* Local variables:
* compile-command: "cc -g -o env env.c"
* end:
*/

60
lib-src/etags-vmslib.c → etc/etags-vmslib.c
View file

@ -1,49 +1,21 @@
/* File name wild card expansion for VMS.
This file is part of the etags program.
Copyright (C) 1987 Free Software Foundation, Inc. 3 Feb 1987
This program is distributed in the hope that it will be useful,
but without any warranty. No author or distributor
accepts responsibility to anyone for the consequences of using it
or for whether it serves any particular purpose or works at all,
unless he says so in writing.
Permission is granted to anyone to distribute verbatim copies
of this program's source code as received, in any medium, provided that
the copyright notice, the nonwarraty notice above
and this permission notice are preserved,
and that the distributor grants the recipient all rights
for further redistribution as permitted by this notice,
and informs him of these rights.
Permission is granted to distribute modified versions of this
program's source code, or of portions of it, under the above
conditions, plus the conditions that all changed files carry
prominent notices stating who last changed them and that the
derived material, including anything packaged together with it and
conceptually functioning as a modification of it rather than an
application of it, is in its entirety subject to a permission
notice identical to this one.
Permission is granted to distribute this program (verbatim or
as modified) in compiled or executable form, provided verbatim
redistribution is permitted as stated above for source code, and
A. it is accompanied by the corresponding machine-readable
source code, under the above conditions, or
B. it is accompanied by a written offer, with no time limit,
to distribute the corresponding machine-readable source code,
under the above conditions, to any one, in return for reimbursement
of the cost of distribution. Verbatim redistribution of the
written offer must be permitted. Or,
C. it is distributed by someone who received only the
compiled or executable form, and is accompanied by a copy of the
written offer of source code which he received along with it.
Permission is granted to distribute this program (verbatim or as modified)
in executable form as part of a larger system provided that the source
code for this program, including any modifications used,
is also distributed or offered as stated in the preceding paragraph.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
@ -135,7 +107,7 @@ fn_exp(out, in)
if (pass1)
{
pass1 = NO;
o.dsc$a_pointer = out;
o.dsc$a_pointer = (char *) out;
o.dsc$w_length = (short)OUTSIZE;
i.dsc$a_pointer = in;
i.dsc$w_length = (short)strlen(in);

1631
etc/etags.c Normal file
View file

File diff suppressed because it is too large Load diff

15
etc/etags.vms Normal file
View file

@ -0,0 +1,15 @@
VMS-ed version of etags
-----------------------
1. The changes made allow the program to compile correctly,
to give error messages more meaningful to VMS, to allow '$'
in identifier tokens in C programs, and to expand wild-cards in the
input filespecs.
2. To minimize the differences from the original version,
the VMS filename expansion converts filenames to lower
case, and strips version numbers. This does indeed mean
that some input specs (containing version wildcards) will
cause curious effects, it is reasonably consistent with
Emacs, which ignores file versions.

65
lib-src/fakemail.c → etc/fakemail.c
View file

@ -21,7 +21,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define NO_SHORTNAMES
#include "../src/config.h"
#if defined (BSD) && !defined (BSD4_1) && !defined (USE_FAKEMAIL)
#if defined (BSD) && !defined (BSD4_1)
/* This program isnot used in BSD, so just avoid loader complaints. */
main ()
{
@ -267,16 +267,7 @@ add_field (the_list, field, where)
{
*where++ = ' ';
while ((c = *field++) != '\0')
{
if (c == '(')
{
while (*field && *field != ')') ++field;
if (! (*field++)) break; /* no closer */
if (! (*field)) break; /* closerNULL */
c = *field;
}
*where++ = ((c == ','||c=='>'||c=='<') ? ' ' : c);
}
*where++ = ((c == ',') ? ' ' : c);
if (the_list == NIL) break;
field = the_list->string;
the_list = the_list->continuation;
@ -400,49 +391,15 @@ put_string (s)
}
void
put_line (string)
char *string;
put_line (s)
char *s;
{
register stream_list rem;
for (rem = the_streams;
rem != ((stream_list) NULL);
rem = rem->rest_streams)
{
char *s = string;
int column = 0;
/* Divide STRING into lines. */
while (*s != 0)
{
char *breakpos;
/* Find the last char that fits. */
for (breakpos = s; *breakpos && column < 78; ++breakpos)
{
if (*breakpos == '\t')
column += 8;
else
column++;
}
/* Back up to just after the last comma that fits. */
while (breakpos != s && breakpos[-1] != ',') --breakpos;
if (breakpos == s)
{
/* If no comma fits, move past the first address anyway. */
while (*breakpos != 0 && *breakpos != ',') ++breakpos;
if (*breakpos != 0)
/* Include the comma after it. */
++breakpos;
}
/* Output that much, then break the line. */
fwrite (s, 1, breakpos - s, rem->handle);
fputs ("\n\t", rem->handle);
column = 8;
/* Skip whitespace and prepare to print more addresses. */
s = breakpos;
while (*s == ' ' || *s == '\t') ++s;
}
fputs (s, rem->handle);
putc ('\n', rem->handle);
}
return;
@ -614,19 +571,11 @@ main (argc, argv)
{
char *command_line;
header the_header;
long name_length;
char *mail_program_name;
long name_length = strlen (MAIL_PROGRAM_NAME);
char buf[BUFLEN + 1];
register int size;
FILE *the_pipe;
extern char *getenv ();
mail_program_name = getenv ("FAKEMAILER");
if (!(mail_program_name && *mail_program_name))
mail_program_name = MAIL_PROGRAM_NAME;
name_length = strlen (mail_program_name);
my_name = MY_NAME;
the_streams = ((stream_list) NULL);
the_date = ((char *) NULL);
@ -634,7 +583,7 @@ main (argc, argv)
the_header = read_header ();
command_line = alloc_string (name_length + args_size (the_header));
strcpy (command_line, mail_program_name);
strcpy (command_line, MAIL_PROGRAM_NAME);
parse_header (the_header, &command_line[name_length]);
the_pipe = popen (command_line, "w");

220
etc/faq2texi.perl Normal file
View file

@ -0,0 +1,220 @@
#!/usr/staff/bin/perl
#
# efaq2texinfo : Convert Emacs FAQ to texinfo format
#
# George Ferguson, ferguson@cs.rochester.edu, 24 Jan 1992.
#
# Usage, assuming the list is in the file FAQ:
# % efaq2texinfo <FAQ >efaq.texinfo
# If you store your FAQ compressed, you can use
# % zcat FAQ.Z | efaq2texinfo >efaq.texinfo
# In any case, you then need to convert to info format:
# % makeinfo +fill-column 80 efaq.texinfo
# The result will be files efaq-info and efaq-info-[1-4]. If you don't
# have makeinfo(1), you can try using "texinfo-format-buffer" within
# emacs.
#
# The FAQ can be obtained from pit-manager.mit.edu.
#
$chapter = 0;
$item = 0;
$itemizing = 0;
$enumerating = 0;
$displaying = 0;
# Now process each line
while (<>) {
if ($. == 1 || /^---Continued---$/) {
&skipJunk;
}
s/^ +$//; # blanks only -> newline
s/\t/ /; # tabs -> spaces (stupidly)
if (/^([^0-9 \n].*)$/) { # new chapter heading
&endDisplay;
&endLists;
$chapter += 1;
$text = $1;
$text =~ s/ +[-!+]$//; # remove change marker
$chapterTitle[$chapter] = $text;
$item = 0;
# print "CHAPTER $chapter: \"$text\"\n";
} elsif (/^([0-9]+): (.*)$/) {
&endDisplay;
&endLists;
$num = $1;
$text = $2;
$text =~ s/ +[-!+]$//; # remove change marker
$menu[$chapter] .= "* Question $num::\t$text\n";
$item = $num;
$itemTitle[$item] = "$text\n";
# print "QUESTION $item: \"$text\"\n";
} else {
if (/^ +\* Topic/) { # hack for info example
&addText("@example\n");
&addText("$_");
&addText("@end example\n");
next;
} elsif (/^ +\*/) { # asterisk marks list element
if (!$itemizing) {
&addText("\@itemize \@bullet\n");
$itemizing = 1;
}
&endDisplay;
&addText("\@item\n");
s/^ +\* *//;
} elsif (/^ +[0-9]\./) { # digit-period marks list element
if (!$enumerating) {
&addText("\@enumerate\n");
$enumerating = 1;
}
&endDisplay;
&addText("\@item\n");
s/^ +[0-9]+\. *//;
} elsif (/^ {0,2}[^ \n]/) { # less whitespace marks end of list
&endLists;
}
s/ //; # automatically remove 2 spaces
if ($itemizing) { # adjust leading whitespace in lists
s/^ //;
} elsif ($enumerating) {
s/^ //;
}
if (/^ +/ && !$displaying) { # extra leading spaces -> display
&addText("\@example\n");
$displaying = 1;
}
if (/^[^ ]/ && $displaying) { # no leading spaces -> display end
&addText("\@end example\n");
$displaying = 0;
}
s/ +[-!+]$//; # remove "change" markers (sorry)
$_ = &formatText;
&addText($_);
}
}
# Just in case
&endDisplay;
&endLists;
# Output it all
# Print texinfo header
print "\\input texinfo\n";
print "@setfilename efaq.info\n";
print "@settitle Frequently Asked Questions about Emacs\n";
print "\n";
print "@node Top\n";
print "@top Frequently Asked Questions about Emacs\n";
print "\n";
print $chapterText[0];
print "\@menu\n";
for ($i = 1; $i <= $chapter; $i++) {
print "* Chapter $i::\t$chapterTitle[$i]\n";
}
print "* Index::\tHosts, usernames, files, etc.\n";
print "\@end menu\n\n";
for ($i = 1; $i <= $chapter; $i++) {
print "\@node Chapter $i\n";
print "\@chapter $chapterTitle[$i]\n";
print $chapterText[$i];
print "\@menu\n";
print $menu[$i];
print "\@end menu\n\n";
}
for ($i = 1; $i <= $item; $i++) {
print "\@node Question $i\n";
print "\@section $itemTitle[$i]"; # too many newlines already
print $itemText[$i];
}
# Print texinfo trailer
print "\n";
print "@node Index\n";
print "@appendix Index\n";
print "\n";
print "@printindex fn\n";
print "\n";
print "@bye\n";
############################################################################
sub addText {
if ($item == 0) {
$chapterText[$chapter] .= "$_[0]";
} else {
$itemText[$item] .= "$_[0]";
}
}
sub endLists {
if ($itemizing) {
&addText("\@end itemize\n");
}
if ($enumerating) {
&addText("\@end enumerate\n");
}
$enumerating = 0;
$itemizing = 0;
}
sub endDisplay {
if ($displaying) {
&addText("\@end example\n");
$displaying = 0;
}
}
sub skipJunk {
local($blank) = 0;
# skip until double newline (ie. mail headers, etc.)
while ($_ ne "\n" || !$blank) {
$blank = ($_ eq "\n");
$_ = <>;
}
# skip next paragraph: "If you are viewing..."
$_ = <>;
while ($_ ne "\n") { $_ = <>; }
# skip next paragraph: "To search for..."
$_ = <>;
while ($_ ne "\n") { $_ = <>; }
# skip next paragraph: "A `+' in the..."
$_ = <>;
while ($_ ne "\n") { $_ = <>; }
}
#
# For each line of text in the document, we generate an index entry for
# anything that looks like a hostname, email address, newsgroup, filename
# or emacs command (only long command recognized). This function is complicated
# by the fact that the index entries have to come on lines of their own,
# after the text that contains them.
#
# To recognize host:file as a single entity, add ":?" inside the first
# nested set of brackets but before the multiple-alternatives pattern.
#
# This function also escapes any characters with special meaning to
# texinfo. Returns the line of text.
#
sub formatText {
# convert special chars to texinfo escapes
s/@/@@/g;
s/\{/@{/g;
s/\}/@}/g;
# remove trailing spaces
s/ +$//g;
# gather the index entries
local($t) = $_;
local($tt) = "";
while ($t =~ /([-a-zA-Z0-9]{2,}((\.|@@|%|!|-|\/)[-@a-zA-Z0-9]+){2,})/) {
$t = $';
$tt .= "@findex $1\n";
}
# Flag cross-references
s/(q|Q)uestion ([0-9]+)/@ref\{Question $2\}/g;
# print the line of text
return("$_$tt");
}
__END__

150
etc/ledit.l Normal file
View file

@ -0,0 +1,150 @@
;;; -*- Mode: lisp -*-
; load in the c functions
(removeaddress '_signal)
(removeaddress '_switch_to_proc)
(removeaddress '_set_proc_str)
(cfasl "/src/mdc/ledit/leditcfns.o" '_switch_to_proc 'emacs)
(getaddress '_set_proc_str 'set_proc_str)
(declare (special *ledit-infile* ; emacs->lisp tempfile
*ledit-outfile* ; lisp->emacs tempfile
*ledit-ppfile* ; pp->emacs tempfile
*ledit-lisztfile* ; compiler input
*ledit-objfile* ; compiler output
*ledit-initialized*) ; flag
)
(setq *ledit-initialized* nil)
;;; INIT-LEDIT
(defun init-ledit ()
(let ((user (getenv '|USER|))) ;USER must be uppercase
(setq
*ledit-outfile* (concat "/tmp/" user ".l2") ; lisp -> emacs
*ledit-infile* (concat "/tmp/" user ".l1") ; emacs -> lisp
*ledit-ppfile* (concat "/tmp/" user ".l3") ; pp output to emacs.
*ledit-lisztfile* (concat "/tmp/" user ".l4")
*ledit-objfile* (concat "/tmp/" user ".o")
*ledit-initialized* t)))
;;; LEDIT
; if 1 arg, arg is taken as a tag name to pass to emacs.
; if 2 args, second arg is a keyword. If 2nd arg is pp,
; pp is applied to first arg, and result is sent to emacs
; to put in a buffer called LEDIT (which is first erased.)
(defun ledit fexpr (args)
(apply #'ledit* args))
;;; LEDIT*
(defun ledit* n
(if (not *ledit-initialized*) (init-ledit))
(ledit-output (listify n))
(syscall 10. *ledit-infile*) ; syscall 10 is "delete"
(syscall 10. *ledit-lisztfile*)
(emacs)
(ledit-input)
(syscall 10. *ledit-outfile*)
(syscall 10. *ledit-ppfile*)
t)
;;; LEDIT-OUTPUT
;;; Egad, what a mess! Doesn't work for XEMACS yet.
;;; Here's an example from Moclisp:
;;; -> (defun bar (nothing) (bar nothing))
;;; bar
;;; -> (ledit bar)
;;; should produce...
;;; (progn) (progn tag (setq tag "bar") (&goto-tag))
;;; and
;;; -> (ledit bar pp)
;;; should stuff this to emacs...
;;; (progn) (switch-to-buffer "LEDIT") (erase-buffer)
;;; (insert-file "/tmp/walter.l3") (lisp-mode)
;;; and this...
;;; (def bar
;;; (lambda (x)
;;; (bar nothing)))
;;; into *LEDIT*
(defun ledit-output (args)
(if args
(let ((ofile (outfile *ledit-outfile*)))
(format ofile "(progn)") ; this is necessary.
(cond ((null (cdr args)) ; no keyword -> arg is a tag.
(format ofile "(progn tag (setq tag \"~A\"~
(&goto-tag))"
(car args)))
((eq (cadr args) 'pp) ; pp-> pp first arg to emacs
(apply 'pp `((|F| ,*ledit-ppfile*) ,(car args)))
(format ofile "(switch-to-buffer \"LEDIT\")~
(erase-buffer)")
(format ofile "(insert-file \"~A\")"
*ledit-ppfile*)
(format ofile "(lisp-mode)"))
(t (format t "~&~A -- unknown option~%" (cdr args))))
(close ofile))))
;;; LISZT*
;;; Need this guy to do compile-input.
;;; Liszt returns 0 if all was well.
;;; Note that in ordinary use the user will have to get used to looking
;;; at "%Warning: ... Compiler declared *foo* special" messages, since
;;; you don't usually want to hunt around in your file, zap in the the
;;; declarations, then go back to what you were doing.
;;; Fortunately this doesn't cause the compiler to bomb.
;;; Some sleepless night I will think of a way to get around this.
(defun liszt* (&rest args)
(apply #'liszt args))
;;; LEDIT-INPUT
;;; Although there are two cases here, in practice
;;; it is never the case that there is both input to be
;;; interpreted and input to be compiled.
(defun ledit-input ()
(if (probef *ledit-lisztfile*)
(cond ((getd #'liszt)
(format t ";Compiling LEDIT:")
(and (zerop (liszt* *ledit-lisztfile* '-o *ledit-objfile*))
(load *ledit-objfile*)))
(t (format t ";Can't compile LEDIT: No liszt.~%;Reading instead:")
(let ((ifile (infile *ledit-lisztfile*)))
(ledit-load ifile)
(close ifile)))))
(if (probef *ledit-infile*)
(let ((ifile (infile *ledit-infile*)))
(format t ";Reading from LEDIT:~%")
(ledit-load ifile)
(close ifile))))
;;; LEDIT-LOAD
;;; A generally useful form of load
(defun ledit-load (ifile)
(let ((eof-form (list 'eof-form)))
(do ((form (read ifile eof-form) (read ifile eof-form)))
((eq form eof-form))
(format t "; ~A~%" (eval form)))))
(setsyntax #/ 'macro 'ledit) ; make ^E = (ledit)<return>
;; more robust version of the c function set_proc_str. Does argument checking.
;; set_proc_str sets the string that is stuffed to the tty after franz pauses
;; and the csh wakes up. It is usually "%emacs" or "%vemacs" or "%?emacs"
(defun set-proc-str (arg)
(if (stringp arg)
(set_proc_str arg)
(if (symbolp arg)
(set_proc_str (get-pname arg))
(error arg " is illegal argument to set-proc-str"))))

0
lib-src/leditcfns.c → etc/leditcfns.c
View file

271
lib-src/make-docfile.c → etc/make-docfile.c
View file

@ -61,10 +61,10 @@ main (argc, argv)
err_count += scan_file (argv[i]); /* err_count seems to be {mis,un}used */
#ifndef VMS
exit (err_count); /* see below - shane */
#endif VMS
#endif /* VMS */
}
/* Read file FILENAME and output its doc strings to outfile. */
/* Read file FILENAME and output its doc strings to stdout. */
/* Return 1 if file is not found, 0 if it is found. */
scan_file (filename)
@ -83,7 +83,7 @@ char buf[128];
/* Skip a C string from INFILE,
and return the character that follows the closing ".
If printflag is positive, output string contents to outfile.
If printflag is positive, output string contents to stdout.
If it is negative, store contents in buf.
Convert escape sequences \n and \t to newline and tab;
discard \ followed by newline. */
@ -135,46 +135,10 @@ read_c_string (infile, printflag)
return c;
}
/* Write to file OUT the argument names of the function whose text is in BUF.
MINARGS and MAXARGS are the minimum and maximum number of arguments. */
write_c_args (out, buf, minargs, maxargs)
FILE *out;
char *buf;
int minargs, maxargs;
{
register int c;
register char *p = buf;
int space = 0;
fprintf (out, "arguments: ");
while (*p)
{
c = *p++;
if (c == ',')
{
minargs--;
maxargs--;
if (!space)
putc (' ', out);
if (minargs == 0 && maxargs > 0)
fprintf (out, "&optional ");
space = 1;
continue;
}
else if (c == ' ' && space)
continue;
space = (c == ' ');
putc (c, out);
}
putc ('\n', out);
}
/* Read through a c file. If a .o file is named,
the corresponding .c file is read instead.
Looks for DEFUN constructs such as are defined in ../src/lisp.h.
Accepts any word starting DEF... so it finds DEFSIMPLE and DEFPRED. */
the corresponding .c file is read instead.
Looks for DEFUN constructs such as are defined in ../src/lisp.h.
Accepts any word starting DEF... so it finds DEFSIMPLE and DEFPRED. */
scan_c_file (filename)
char *filename;
@ -184,8 +148,7 @@ scan_c_file (filename)
register int commas;
register int defunflag;
register int defvarflag;
int minargs, maxargs;
if (filename[strlen (filename) - 1] == 'o')
filename[strlen (filename) - 1] = 'c';
@ -243,7 +206,7 @@ scan_c_file (filename)
while (c != '(')
{
if (c < 0)
goto eof;
return 0;
c = getc (infile);
}
@ -261,28 +224,9 @@ scan_c_file (filename)
while (commas)
{
if (c == ',')
{
commas--;
if (defunflag && (commas == 1 || commas == 2))
{
do
c = getc (infile);
while (c == ' ' || c == '\n' || c == '\t');
if (c < 0)
goto eof;
ungetc (c, infile);
if (commas == 2) /* pick up minargs */
fscanf (infile, "%d", &minargs);
else /* pick up maxargs */
if (c == 'M' || c == 'U') /* MANY || UNEVALLED */
maxargs = -1;
else
fscanf (infile, "%d", &maxargs);
}
}
if (c == ',') commas --;
if (c < 0)
goto eof;
return 0;
c = getc (infile);
}
while (c == ' ' || c == '\n' || c == '\t')
@ -300,41 +244,9 @@ scan_c_file (filename)
putc (037, outfile);
putc (defvarflag ? 'V' : 'F', outfile);
fprintf (outfile, "%s\n", buf);
c = read_c_string (infile, 1);
/* If this is a defun, find the arguments and print them. If
this function takes MANY or UNEVALLED args, then the C source
won't give the names of the arguments, so we shouldn't bother
trying to find them. */
if (defunflag && maxargs != -1)
{
char argbuf[1024], *p = argbuf;
while (c != ')')
{
if (c < 0)
goto eof;
c = getc (infile);
}
/* Skip into arguments. */
while (c != '(')
{
if (c < 0)
goto eof;
c = getc (infile);
}
/* Copy arguments into ARGBUF. */
*p++ = c;
do
*p++ = c = getc (infile);
while (c != ')');
*p = '\0';
/* Output them. */
fprintf (outfile, "\n\n");
write_c_args (outfile, argbuf, minargs, maxargs);
}
read_c_string (infile, 1);
}
}
eof:
fclose (infile);
return 0;
}
@ -345,8 +257,6 @@ scan_c_file (filename)
(autoload 'NAME FILE DOCSTRING ...)
(defvar NAME VALUE DOCSTRING)
(defconst NAME VALUE DOCSTRING)
(fset (quote NAME) (make-byte-code (quote ARGS) ... "\
DOCSTRING")
starting in column zero.
ARGS, FILE or VALUE is ignored. We do not know how to parse Lisp code
so we use a kludge to skip them:
@ -390,8 +300,6 @@ scan_lisp_file (filename)
c = getc (infile);
if (c != '(')
continue;
/* Handle an autoload. */
c = getc (infile);
if (c == 'a')
{
@ -471,8 +379,6 @@ scan_lisp_file (filename)
}
c = read_c_string (infile, 0);
}
/* Handle def* clauses. */
else if (c == 'd')
{
c = getc (infile);
@ -482,8 +388,6 @@ scan_lisp_file (filename)
if (c != 'f')
continue;
c = getc (infile);
/* Is this a defun? */
if (c == 'u')
{
c = getc (infile);
@ -491,8 +395,6 @@ scan_lisp_file (filename)
continue;
defvarflag = 0;
}
/* Or a defvar? */
else if (c == 'v')
{
c = getc (infile);
@ -503,8 +405,6 @@ scan_lisp_file (filename)
continue;
defvarflag = 1;
}
/* Or a defconst? */
else if (c == 'c')
{
c = getc (infile);
@ -592,155 +492,6 @@ scan_lisp_file (filename)
continue;
}
}
/* Handle an fset clause. */
else if (c == 'f')
{
c = getc (infile);
if (c != 's')
continue;
c = getc (infile);
if (c != 'e')
continue;
c = getc (infile);
if (c != 't')
continue;
/* Skip white space */
do
c = getc (infile);
while (c == ' ' || c == '\n' || c == '\t');
/* Recognize "(quote". */
if (c != '(')
continue;
c = getc (infile);
if (c != 'q')
continue;
c = getc (infile);
if (c != 'u')
continue;
c = getc (infile);
if (c != 'o')
continue;
c = getc (infile);
if (c != 't')
continue;
c = getc (infile);
if (c != 'e')
continue;
/* Skip white space */
do
c = getc (infile);
while (c == ' ' || c == '\n' || c == '\t');
/* Read and store name of function or variable being defined
Discard backslashes that are for quoting. */
p = buf;
while (c != ')' && c != ' ' && c != '\n' && c != '\t')
{
if (c == '\\')
c = getc (infile);
*p++ = c;
c = getc (infile);
}
*p = '\0';
/* Skip white space */
do
c = getc (infile);
while (c == ' ' || c == '\n' || c == '\t');
/* Recognize "(make-byte-code". */
if (c != '(')
continue;
c = getc (infile);
if (c != 'm')
continue;
c = getc (infile);
if (c != 'a')
continue;
c = getc (infile);
if (c != 'k')
continue;
c = getc (infile);
if (c != 'e')
continue;
c = getc (infile);
if (c != '-')
continue;
c = getc (infile);
if (c != 'b')
continue;
c = getc (infile);
if (c != 'y')
continue;
c = getc (infile);
if (c != 't')
continue;
c = getc (infile);
if (c != 'e')
continue;
c = getc (infile);
if (c != '-')
continue;
c = getc (infile);
if (c != 'c')
continue;
c = getc (infile);
if (c != 'o')
continue;
c = getc (infile);
if (c != 'd')
continue;
c = getc (infile);
if (c != 'e')
continue;
/* Scan for a \" followed by a newline, or for )) followed by
a newline. If we find the latter first, this function has
no docstring. */
{
char c1 = 0, c2 = 0;
for (;;)
{
/* Find newlines, and remember the two previous characters. */
for (;;)
{
c = getc (infile);
if (c == '\n' || c < 0)
break;
c2 = c1;
c1 = c;
}
/* If we've hit eof, quit. */
if (c == EOF)
break;
/* If the last two characters were \", this is a docstring. */
else if (c2 == '"' && c1 == '\\')
{
putc (037, outfile);
putc ('F', outfile);
fprintf (outfile, "%s\n", buf);
read_c_string (infile, 1);
break;
}
/* If the last two characters were )), there is no
docstring. */
else if (c2 == ')' && c1 == ')')
break;
}
continue;
}
}
else
continue;

48
etc/makedoc.com Normal file
View file

@ -0,0 +1,48 @@
$ ! VMS command file to create or update the file `DOC.' which contains
$ ! documentation strings for the functions and variables preloaded in Emacs.
$ ! This command file should be run when you build Emacs for the first time and
$ ! again if any documentation strings change in the source files listed here.
$
$ old = f$environment("default")
$ set default emacs_library:[etc]
$ on error then goto done
$ if f$search("emacs_library:[etc]make-docfile.exe") .nes. "" then goto version44
$ doit := $emacs_library:[etc]make_docfile
$ rest = "[lisp]lisp_mode.elc [lisp]text_mode.elc [lisp]c_mode.elc [lisp]buff_menu.elc [lisp]vms_patch.elc"
$ goto doit
$version44:
$ doit := $emacs_library:[etc]make-docfile
$ rest = "[lisp]lisp-mode.elc [lisp]text-mode.elc [lisp]c-mode.elc [lisp]buff-menu.elc [lisp]vms-patch.elc"
$
$doit:
$ set default emacs_library:[000000]
$ doit -o [etc]DOC
$ doit := 'doit' -a [etc]DOC
$ doit [src]dispnew.c [src]scroll.c
$ doit [src]xdisp.c [src]window.c [src]term.c [src]cm.c
$ doit [src]emacs.c [src]keyboard.c [src]macros.c
$ doit [src]keymap.c [src]sysdep.c [src]buffer.c
$ doit [src]filelock.c [src]insdel.c [src]marker.c
$ doit [src]minibuf.c [src]fileio.c [src]dired.c
$ doit [src]filemode.c [src]cmds.c [src]casefiddle.c
$ doit [src]indent.c [src]search.c [src]regex.c
$ doit [src]undo.c [src]alloc.c [src]data.c [src]doc.c
$ doit [src]editfns.c [src]callint.c [src]eval.c
$ doit [src]fns.c [src]print.c [src]lread.c [src]abbrev.c
$ doit [src]syntax.c [src]mocklisp.c
$ doit [src]bytecode.c [src]process.c [src]callproc.c [src]doprnt.c
$ doit [src]vmsfns.c
$
$ doit [lisp]simple.elc [lisp]help.elc
$ doit [lisp]files.elc [lisp]window.elc
$ doit [lisp]indent.elc [lisp]loaddefs.el
$ doit [lisp]paths.el [lisp]startup.elc
$ doit [lisp]lisp.elc [lisp]page.elc
$ doit [lisp]register.elc [lisp]paragraphs.elc
$ doit [lisp]fill.elc [lisp]isearch.elc
$ doit [lisp]replace.elc [lisp]abbrev.elc
$ doit [lisp]subr.elc [lisp]vmsproc.elc
$ doit 'rest'
$
$done:
$ set default 'old'

156
lib-src/movemail.c → etc/movemail.c
View file

@ -18,6 +18,18 @@ You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Important notice: defining MAIL_USE_FLOCK *will cause loss of mail*
if you do it on a system that does not normally use flock as its way of
interlocking access to inbox files. The setting of MAIL_USE_FLOCK
*must agree* with the system's own conventions.
It is not a choice that is up to you.
So, if your system uses lock files rather than flock, then the only way
you can get proper operation is to enable movemail to write lockfiles there.
This means you must either give that directory access modes
that permit everyone to write lockfiles in it, or you must make movemail
a setuid or setgid program. */
/*
* Modified January, 1986 by Michael R. Gretzinger (Project Athena)
*
@ -29,7 +41,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
*
* New module: popmail.c
* Modified routines:
* main - added code within #ifdef MAIL_USE_POP; added setuid(getuid())
* main - added code within #ifdef MAIL_USE_POP; added setuid (getuid ())
* after POP code.
* New routines in movemail.c:
* get_errmsg - return pointer to system error message
@ -88,7 +100,7 @@ main (argc, argv)
long now;
int tem;
char *lockname, *p;
char tempname[40];
char *tempname;
int desc;
#endif /* not MAIL_USE_FLOCK */
@ -133,7 +145,7 @@ main (argc, argv)
exit (status);
}
setuid (getuid());
setuid (getuid ());
#endif /* MAIL_USE_POP */
/* Check access to input file. */
@ -144,7 +156,29 @@ main (argc, argv)
#ifndef MAIL_USE_FLOCK
/* Use a lock file named /usr/spool/mail/$USER.lock:
If it exists, the mail file is locked. */
/* Note: this locking mechanism is *required* by the mailer
(on systems which use it) to prevent loss of mail.
On systems that use a lock file, extracting the mail without locking
WILL occasionally cause loss of mail due to timing errors!
So, if creation of the lock file fails
due to access permission on /usr/spool/mail,
you simply MUST change the permission
and/or make movemail a setgid program
so it can create lock files properly.
You might also wish to verify that your system is one
which uses lock files for this purpose. Some systems use other methods.
If your system uses the `flock' system call for mail locking,
define MAIL_USE_FLOCK in config.h or the s-*.h file
and recompile movemail. If the s- file for your system
should define MAIL_USE_FLOCK but does not, send a bug report
to bug-gnu-emacs@prep.ai.mit.edu so we can fix it. */
lockname = concat (inname, ".lock", "");
tempname = (char *) xmalloc (strlen (inname) + 20);
strcpy (tempname, inname);
p = tempname + strlen (tempname);
while (p != tempname && p[-1] != '/')
@ -152,7 +186,7 @@ main (argc, argv)
*p = 0;
strcpy (p, "EXXXXXX");
mktemp (tempname);
(void) unlink (tempname);
unlink (tempname);
while (1)
{
@ -160,11 +194,11 @@ main (argc, argv)
/* Give up if cannot do that. */
desc = open (tempname, O_WRONLY | O_CREAT, 0666);
if (desc < 0)
pfatal_with_name (concat ("temporary file \"", tempname, "\""));
pfatal_with_name ("lock file--see source file etc/movemail.c");
close (desc);
tem = link (tempname, lockname);
(void) unlink (tempname);
unlink (tempname);
if (tem >= 0)
break;
sleep (1);
@ -174,7 +208,7 @@ main (argc, argv)
{
now = time (0);
if (st.st_ctime < now - 60)
(void) unlink (lockname);
unlink (lockname);
}
}
@ -193,7 +227,7 @@ main (argc, argv)
if (indesc < 0)
pfatal_with_name (inname);
#if defined(BSD) || defined(XENIX)
#if defined (BSD) || defined (XENIX)
/* In case movemail is setuid to root, make sure the user can
read the output file. */
/* This is desirable for all systems
@ -217,7 +251,7 @@ main (argc, argv)
if (nread != write (outdesc, buf, nread))
{
int saved_errno = errno;
(void) unlink (outname);
unlink (outname);
errno = saved_errno;
pfatal_with_name (outname);
}
@ -226,24 +260,20 @@ main (argc, argv)
}
#ifdef BSD
fsync (outdesc);
if (fsync (outdesc) < 0)
pfatal_and_delete (outname);
#endif
/* Check to make sure no errors before we zap the inbox. */
if (close (outdesc) != 0)
{
int saved_errno = errno;
(void) unlink (outname);
errno = saved_errno;
pfatal_with_name (outname);
}
pfatal_and_delete (outname);
#ifdef MAIL_USE_FLOCK
#if defined(STRIDE) || defined(XENIX)
#if defined (STRIDE) || defined (XENIX)
/* Stride, xenix have file locking, but no ftruncate. This mess will do. */
(void) close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
#else
(void) ftruncate (indesc, 0L);
ftruncate (indesc, 0L);
#endif /* STRIDE or XENIX */
#endif /* MAIL_USE_FLOCK */
@ -300,6 +330,22 @@ pfatal_with_name (name)
fatal (s, name);
}
pfatal_and_delete (name)
char *name;
{
extern int errno, sys_nerr;
extern char *sys_errlist[];
char *s;
if (errno < sys_nerr)
s = concat ("", sys_errlist[errno], " for %s");
else
s = "cannot open %s";
unlink (name);
fatal (s, name);
}
/* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
char *
@ -337,6 +383,7 @@ xmalloc (size)
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <pwd.h>
#ifdef USG
#include <fcntl.h>
@ -372,6 +419,9 @@ popmail (user, outfile)
register int i;
int mbfi;
FILE *mbf;
struct passwd *pw = (struct passwd *) getpwuid (getuid ());
if (pw == NULL)
fatal ("cannot determine user name");
host = getenv ("MAILHOST");
if (host == NULL)
@ -381,29 +431,25 @@ popmail (user, outfile)
if (pop_init (host) == NOTOK)
{
error (Errmsg);
return 1;
fatal (Errmsg);
}
if (getline (response, sizeof response, sfi) != OK)
{
error (response);
return 1;
fatal (response);
}
if (pop_command ("USER %s", user) == NOTOK
|| pop_command ("RPOP %s", user) == NOTOK)
if (pop_command ("USER %s", user) == NOTOK
|| pop_command ("RPOP %s", pw->pw_name) == NOTOK)
{
error (Errmsg);
pop_command ("QUIT");
return 1;
fatal (Errmsg);
}
if (pop_stat (&nmsgs, &nbytes) == NOTOK)
{
error (Errmsg);
pop_command ("QUIT");
return 1;
fatal (Errmsg);
}
if (!nmsgs)
@ -416,18 +462,14 @@ popmail (user, outfile)
if (mbfi < 0)
{
pop_command ("QUIT");
error ("Error in open: %s, %s", get_errmsg (), outfile);
return 1;
pfatal_and_delete (outfile);
}
fchown (mbfi, getuid (), -1);
if ((mbf = fdopen (mbfi, "w")) == NULL)
{
pop_command ("QUIT");
error ("Error in fdopen: %s", get_errmsg ());
close (mbfi);
unlink (outfile);
return 1;
pfatal_and_delete (outfile);
}
for (i = 1; i <= nmsgs; i++)
@ -435,29 +477,37 @@ popmail (user, outfile)
mbx_delimit_begin (mbf);
if (pop_retr (i, mbx_write, mbf) != OK)
{
error (Errmsg);
pop_command ("QUIT");
close (mbfi);
return 1;
unlink (outfile);
fatal (Errmsg);
}
mbx_delimit_end (mbf);
fflush (mbf);
}
if (fsync (mbfi) < 0)
{
pop_command ("QUIT");
pfatal_and_delete (outfile);
}
if (close (mbfi) == -1)
{
pop_command ("QUIT");
pfatal_and_delete (outfile);
}
for (i = 1; i <= nmsgs; i++)
{
if (pop_command ("DELE %d", i) == NOTOK)
{
error (Errmsg);
pop_command ("QUIT");
close (mbfi);
return 1;
/* Better to ignore this failure. */
}
}
pop_command ("QUIT");
close (mbfi);
return 0;
return (0);
}
pop_init (host)
@ -529,7 +579,8 @@ pop_command (fmt, a, b, c, d)
return NOTOK;
}
if (debug) fprintf (stderr, "<--- %s\n", buf);
if (debug)
fprintf (stderr, "<--- %s\n", buf);
if (*buf != '+')
{
strcpy (Errmsg, buf);
@ -547,8 +598,10 @@ pop_stat (nmsgs, nbytes)
{
char buf[128];
if (debug) fprintf (stderr, "---> STAT\n");
if (putline ("STAT", Errmsg, sfo) == NOTOK) return NOTOK;
if (debug)
fprintf (stderr, "---> STAT\n");
if (putline ("STAT", Errmsg, sfo) == NOTOK)
return NOTOK;
if (getline (buf, sizeof buf, sfi) != OK)
{
@ -635,17 +688,14 @@ multiline (buf, n, f)
register int n;
FILE *f;
{
if (getline (buf, n, f) != OK) return NOTOK;
if (getline (buf, n, f) != OK)
return NOTOK;
if (*buf == '.')
{
if (*(buf+1) == NULL)
{
return DONE;
}
return DONE;
else
{
strcpy (buf, buf+1);
}
strcpy (buf, buf+1);
}
return OK;
}

167
etc/ms-kermit Normal file
View file

@ -0,0 +1,167 @@
;;; This file is designed for an 8-bit connection.
;;; Use the file ms-kermit-7bit if you have a 7-bit connection.
;; Meta key mappings for EMACS
;; By Robert Earl (rearl@watnxt3.ucr.edu)
;; May 13, 1990
;;
;; WARNING:
;; requires an 8-bit path to host. many dialups and lans won't pass the
;; eighth bit by default and may require a special command to turn this
;; off. `screen' is known to mask the eighth bit of input as well.
set term controls 8-bit
set translation key off
;; control keys
set key \3449 \128 ;; m-c-@
set key \3358 \129 ;; m-c-a
set key \3376 \130 ;; m-c-b
set key \3374 \131 ;; m-c-c
set key \3360 \132 ;; m-c-d
set key \3346 \133 ;; m-c-e
set key \3361 \134 ;; m-c-f
set key \3362 \135 ;; m-c-g
set key \3342 \136 ;; m-bs
set key \3363 \136 ;; m-c-h (sends same code as above)
set key \2469 \137 ;; m-tab
set key \3351 \137 ;; m-c-i (same as above)
set key \3364 \138 ;; m-c-j
set key \3365 \139 ;; m-c-k
set key \3366 \140 ;; m-c-l
;set key \3378 \141 ;; m-c-m
set key \2332 \141 ;; m-ret (sends same code as above)
set key \3377 \142 ;; m-c-n
set key \3352 \143 ;; m-c-o
set key \3353 \144 ;; m-c-p
set key \3344 \145 ;; m-c-q
set key \3347 \146 ;; m-c-r
set key \3359 \147 ;; m-c-s
set key \3348 \148 ;; m-c-t
set key \3350 \149 ;; m-c-u
set key \3375 \150 ;; m-c-v
set key \3345 \151 ;; m-c-w
set key \3373 \152 ;; m-c-x
set key \3349 \153 ;; m-c-y
set key \3372 \154 ;; m-c-z
;; misc keys
;set key \3354 \155 ;; m-c-[
set key \2305 \155 ;; m-esc (sends same as above)
set key \3371 \156 ;; m-c-\
set key \3355 \157 ;; m-c-]
set key \3453 \158 ;; m-c-^
set key \3458 \159 ;; m-c-_
;; \160 is conspicuously missing here--
;; alt-spc doesn't generate a distinct scan code...
;; neither do shift-spc and ctrl-spc.
;; no idea why.
set key \2936 \161 ;; m-!
set key \2856 \162 ;; m-"
set key \2938 \163 ;; m-#
set key \2939 \164 ;; m-$
set key \2940 \165 ;; m-%
set key \2942 \166 ;; m-&
set key \2344 \167 ;; m-'
set key \2944 \168 ;; m-(
set key \2945 \169 ;; m-)
set key \2943 \170 ;; m-*
set key \2947 \171 ;; m-+
set key \2355 \172 ;; m-,
set key \2434 \173 ;; m--
set key \2356 \174 ;; m-.
set key \2357 \175 ;; m-/
;; number keys
set key \2433 \176 ;; m-0
set key \2424 \177 ;; m-1
set key \2425 \178
set key \2426 \179
set key \2427 \180
set key \2428 \181
set key \2429 \182
set key \2430 \183
set key \2431 \184
set key \2432 \185 ;; m-9
set key \2855 \186 ;; m-:
set key \2343 \187 ;; m-;
set key \2867 \188 ;; m-<
set key \2435 \189 ;; m-=
set key \2868 \190 ;; m->
set key \2869 \191 ;; m-?
set key \2937 \192 ;; m-@
;; shifted A-Z
set key \2846 \193 ;; m-A
set key \2864 \194
set key \2862 \195
set key \2848 \196
set key \2834 \197
set key \2849 \198
set key \2850 \199
set key \2851 \200
set key \2839 \201
set key \2852 \202
set key \2853 \203
set key \2854 \204
set key \2866 \205
set key \2865 \206
set key \2840 \207
set key \2841 \208
set key \2832 \209
set key \2835 \210
set key \2847 \211
set key \2836 \212
set key \2838 \213
set key \2863 \214
set key \2833 \215
set key \2861 \216
set key \2837 \217
set key \2860 \218 ;; m-Z
set key \2330 \219 ;; m-[
set key \2347 \220 ;; m-\
set key \2331 \221 ;; m-]
set key \2941 \222 ;; m-^
set key \2946 \223 ;; m-_
set key \2345 \224 ;; m-`
;; lowercase a-z
set key \2334 \225 ;; m-a
set key \2352 \226
set key \2350 \227
set key \2336 \228
set key \2322 \229
set key \2337 \230
set key \2338 \231
set key \2339 \232
set key \2327 \233
set key \2340 \234
set key \2341 \235
set key \2342 \236
set key \2354 \237
set key \2353 \238
set key \2328 \239
set key \2329 \240
set key \2320 \241
set key \2323 \242
set key \2335 \243
set key \2324 \244
set key \2326 \245
set key \2351 \246
set key \2321 \247
set key \2349 \248
set key \2325 \249
set key \2348 \250 ;; m-z
;; more shifted misc. keys
set key \2842 \251 ;; m-{
set key \2859 \252 ;; m-|
set key \2843 \253 ;; m-}
set key \2857 \254 ;; m-~
set key \2318 \255 ;; m-del

312
etc/ms-kermit-7bit Normal file
View file

@ -0,0 +1,312 @@
;;; This file is designed for 7-bit connections.
;;; Use the file ms-kermit if you have an 8-bit connection.
;;; This kermit script maps the IBM-PC keyboard for use with Gnu Emacs.
;;; The ALT key is used to generate Meta characters and, in conjunction
;;; with the CTRL key, Control-Meta characters. A few other useful
;;; mappings are also performed.
;;; Andy Lowry, May 1989
;;; Exchange ESC and backquote... tilde stays put (shift-backquote)
set key \27 `
set key ` \27
;;; BACKSPACE deletes backward one character
set key scan \270 \127
;;; The following mappings affect certain special keys... all the keys
;;; are duplicated on the numeric keypad when NUM LOCK is off, but
;;; the keypad versions are NOT mapped (string definition space too small
;;; for that)
;;; INSERT toggles overwrite mode
set key scan \4434 \27xoverwrite-mode\13
;;; HOME moves point to beginning of buffer
set key scan \4423 \27<
;;; PAGE-UP scrolls backward one screen
set key scan \4425 \27v
;;; DELETE deletes one character *forward*
set key scan \4435 \4
;;; END moves point to end of buffer
set key scan \4431 \27>
;;; PAGE-DOWN scrolls forward one screen
set key scan \4433 \22
;;; ARROW keys move in the appropriate directions
set key scan \4424 \16
set key scan \4427 \2
set key scan \4432 \14
set key scan \4429 \6
;;; META versions of all the printing characters except uppercase
;;; letters are generated by using the ALT key. The definition string
;;; consists of an ESC character followed by the META-ized character.
;;; The characters are listed roughly left-to-right and top-to-bottom
;;; as they appear on the keyboard
set key scan \2345 \27`
set key scan \2424 \27\o61 ; need to use char code, since digit
set key scan \2425 \27\o62 ; would not terminate '\27'
set key scan \2426 \27\o63
set key scan \2427 \27\o64
set key scan \2428 \27\o65
set key scan \2429 \27\o66
set key scan \2430 \27\o67
set key scan \2431 \27\o70
set key scan \2432 \27\o71
set key scan \2433 \27\o60
set key scan \2434 \27\45
set key scan \2435 \27=
set key scan \2857 \27~
set key scan \2936 \27!
set key scan \2937 \27@
set key scan \2938 \27#
set key scan \2939 \27$
set key scan \2940 \27%
set key scan \2941 \27^
set key scan \2942 \27&
set key scan \2943 \27*
set key scan \2944 \27(
set key scan \2945 \27)
set key scan \2946 \27_
set key scan \2947 \27+
set key scan \2469 \27\9
set key scan \2320 \27q
set key scan \2321 \27w
set key scan \2322 \27e
set key scan \2323 \27r
set key scan \2324 \27t
set key scan \2325 \27y
set key scan \2326 \27u
set key scan \2327 \27i
set key scan \2328 \27o
set key scan \2329 \27p
set key scan \2330 \27[
set key scan \2842 \27{
set key scan \2331 \27]
set key scan \2843 \27}
set key scan \2347 \27\
set key scan \2859 \27|
set key scan \2334 \27a
set key scan \2335 \27s
set key scan \2336 \27d
set key scan \2337 \27f
set key scan \2338 \27g
set key scan \2339 \27h
set key scan \2340 \27j
set key scan \2341 \27k
set key scan \2342 \27l
set key scan \2343 \27\59
set key scan \2855 \27:
set key scan \2344 \27'
set key scan \2856 \27"
set key scan \2348 \27z
set key scan \2349 \27x
set key scan \2350 \27c
set key scan \2351 \27v
set key scan \2352 \27b
set key scan \2353 \27n
set key scan \2354 \27m
set key scan \2355 \27,
set key scan \2867 \27<
set key scan \2356 \27.
set key scan \2868 \27>
set key scan \2357 \27/
set key scan \2869 \27?
;;; CONTROL-META characters are generated by using both the CTRL and
;;; ALT keys simultaneously. All the lowercase letters are included.
;;; The definition string consists of an ESC character followed by
;;; the control character corresponding to the letter.
set key scan \3344 \27\17
set key scan \3345 \27\23
set key scan \3346 \27\5
set key scan \3347 \27\18
set key scan \3348 \27\20
set key scan \3349 \27\25
set key scan \3350 \27\21
set key scan \3351 \27\9
set key scan \3352 \27\15
set key scan \3353 \27\16
set key scan \3358 \27\1
set key scan \3359 \27\19
set key scan \3360 \27\4
set key scan \3361 \27\6
set key scan \3362 \27\7
set key scan \3363 \27\8
set key scan \3364 \27\10
set key scan \3365 \27\11
set key scan \3366 \27\12
set key scan \3372 \27\26
set key scan \3373 \27\24
set key scan \3374 \27\3
set key scan \3375 \27\22
set key scan \3376 \27\2
set key scan \3377 \27\14
set key scan \3378 \27\13
end of msiem2.ini
------------------
msiema.hlp
-----------
Date: Wed, 14 Sep 88 05:20:08 GMT
From: spolsky@YALE.ARPA
Subject: Using MS kermit 2.31 with emacs
Keywords: MS-DOS Kermit 2.31, EMACS, Meta Key
If you are using kermit (version 2.31 only) with emacs on a mainframe, the
following file may help you. It assigns all the Alt-keys so that the Alt key
may be used as a "Meta" shift, e.g. Alt-x produces M-x, etc. Note that it
will distinguish correctly between upper and lower case and accepts all
printables. (If anybody has the patience to do the Meta-Ctrl combinations,
please post them!) This actually sends "escapes" so you don't need 8 bits.
This file also sets up the cursor keys to behave as expected.
On extended keyboards (the ones with a separate cursor pad, like PS/2s) you
also get assignments for Page Up/Down, Home, End, Insert, Delete, etc.
Please let me know if you find any problems with this.
Joel Spolsky bitnet: spolsky@yalecs uucp: ...!yale!spolsky
Yale University arpa: spolsky@yale.edu voicenet: 203-436-1483
[Ed. - Thanks, Joel! Your key definitions file has been put in the kermit
distribution area as msiema.ini ("ms" for MS-Kermit, "i" because it's an
initialization file, "ema" for EMACS), along with this message as msiema.hlp.]
end of msiema.hlp
-----------------
msiema.ini
------------
; Emacs keyboard layout for Kermit 2.31
; by Joel Spolsky, Yale Univ. Save this in a file, then
; initialize it by issuing the kermit command
; take filename
; It will set up the keyboard to allow ALT to be used
; as a meta-key, and will allow cursor keys to be used
; with emacs.
; First, define all the ALT keys to send ESC+key
; to simulate "meta"
set key \2320 \27q ;; letters: unshifted
set key \2321 \27w
set key \2322 \27e
set key \2323 \27r
set key \2324 \27t
set key \2325 \27y
set key \2326 \27u
set key \2327 \27i
set key \2328 \27o
set key \2329 \27p
set key \2334 \27a
set key \2335 \27s
set key \2336 \27d
set key \2337 \27f
set key \2338 \27g
set key \2339 \27h
set key \2340 \27j
set key \2341 \27k
set key \2342 \27l
set key \2348 \27z
set key \2349 \27x
set key \2350 \27c
set key \2351 \27v
set key \2352 \27b
set key \2353 \27n
set key \2354 \27m
set key \2832 \27Q ;; letters: shifted
set key \2833 \27W
set key \2834 \27E
set key \2835 \27R
set key \2836 \27T
set key \2837 \27Y
set key \2838 \27U
set key \2839 \27I
set key \2840 \27O
set key \2841 \27P
set key \2846 \27A
set key \2847 \27S
set key \2848 \27D
set key \2849 \27F
set key \2850 \27G
set key \2851 \27H
set key \2852 \27J
set key \2853 \27K
set key \2854 \27L
set key \2860 \27Z
set key \2861 \27X
set key \2862 \27C
set key \2863 \27V
set key \2864 \27B
set key \2865 \27N
set key \2866 \27M
set key \2857 \27\126 ; ALT + ~ ;; special symbols begin here
set key \2345 \27\96 ; ALT + `
set key \2936 \27\33 ; ALT + !
set key \2937 \27\64 ; ALT + @
set key \2938 \27\35 ; ALT + #
set key \2939 \27\36 ; ALT + $
set key \2940 \27\37 ; ALT + %
set key \2941 \27\94 ; ALT + ^
set key \2942 \27\38 ; ALT + &
set key \2943 \27\42 ; ALT + *
set key \2944 \27\40 ; ALT + (
set key \2945 \27\41 ; ALT + )
set key \2946 \27\95 ; ALT + _
set key \2947 \27\43 ; ALT + +
set key \2842 \27\123 ; ALT + {
set key \2843 \27\125 ; ALT + }
set key \2330 \27\91 ; ALT + [
set key \2331 \27\93 ; ALT + ]
set key \2859 \27\124 ; ALT + :
set key \2347 \27\92 ; ALT + \
set key \2867 \27< ; ALT + <
set key \2868 \27> ; ALT + >
set key \2343 \27\59 ; ALT + ;
set key \2855 \27\58 ; ALT + :
set key \2344 \27\39 ; ALT + '
set key \2856 \27\34 ; ALT + "
set key \2355 \27\44 ; ALT + ,
set key \2356 \27\46 ; ALT + .
set key \2357 \27\47 ; ALT + /
set key \2869 \27\63 ; ALT + ?
set key \2424 \27\49 ;; numbers
set key \2425 \27\50
set key \2426 \27\51
set key \2427 \27\52
set key \2428 \27\53
set key \2429 \27\54
set key \2430 \27\55
set key \2431 \27\56
set key \2432 \27\57
set key \2433 \27\48
;; These 6 special keys for extended (PS/2) keyboards:
set key \4434 \25 ;; Insert is like ^Y - yank from kill ring
set key \4435 \23 ;; Delete is like ^W - kill to ring
set key \4423 \1 ;; Home is ^A
set key \4431 \5 ;; End is ^E
set key \4425 \27V ;; Page up is Esc-V
set key \4433 \22 ;; Page dn is ^v
set key \328 \16 ;; up cursor is ^P
set key \331 \2 ;; left cursor is ^B
set key \333 \6 ;; right cursor is ^F
set key \336 \14 ;; down cursor is ^N
set key \4427 \2 ;; left cursor on extended kbd
set key \4432 \14 ;; down cursor on extended kbd
set key \4424 \16 ;; up cursor on extended kbd
set key \4429 \6 ;; right cursor on extended kbd
set key \5491 \27b ;; ctrl-left cursor is M-b
set key \5492 \27f ;; ctrl-right cursor is M-f
;; move kermit's screen scroll (playback) features to Alt- Home,End,PgUp,PgDn
;; (this is an issue for extended keyboards only)
set key \2455 \khomscn
set key \2463 \kendscn
set key \2457 \kupscn
set key \2465 \kdnscn

226
etc/qsort.c Normal file
View file

@ -0,0 +1,226 @@
/*
* qsort.c:
* Our own version of the system qsort routine which is faster by an average
* of 25%, with lows and highs of 10% and 50%.
* The THRESHold below is the insertion sort threshold, and has been adjusted
* for records of size 48 bytes.
* The MTHREShold is where we stop finding a better median.
*/
#define THRESH 4 /* threshold for insertion */
#define MTHRESH 6 /* threshold for median */
static int qsz; /* size of each record */
static int (*qcmp)(); /* the comparison routine */
static int thresh; /* THRESHold in chars */
static int mthresh; /* MTHRESHold in chars */
/*
* qsort:
* First, set up some global parameters for qst to share. Then, quicksort
* with qst(), and then a cleanup insertion sort ourselves. Sound simple?
* It's not...
*/
qsort (base, n, size, compar)
char *base;
int n;
int size;
int (*compar)();
{
register char *i, *j, *lo, *hi, *min;
register int c;
char *max;
if (n <= 1) return;
qsz = size;
qcmp = compar;
thresh = qsz*THRESH;
mthresh = qsz*MTHRESH;
max = base + n*qsz;
if (n >= THRESH)
{
qst (base, max);
hi = base + thresh;
}
else
{
hi = max;
}
/*
* First put smallest element, which must be in the first THRESH, in
* the first position as a sentinel. This is done just by searching
* the first THRESH elements (or the first n if n < THRESH), finding
* the min, and swapping it into the first position.
*/
for (j = lo = base; (lo += qsz) < hi; )
{
if ((*qcmp) (j, lo) > 0)
j = lo;
}
if (j != base)
{ /* swap j into place */
for (i = base, hi = base + qsz; i < hi;)
{
c = *j;
*j++ = *i;
*i++ = c;
}
}
/*
* With our sentinel in place, we now run the following hyper-fast
* insertion sort. For each remaining element, min, from [1] to [n-1],
* set hi to the index of the element AFTER which this one goes.
* Then, do the standard insertion sort shift on a character at a time
* basis for each element in the frob.
*/
for (min = base; (hi = min += qsz) < max;)
{
while ( (*qcmp) (hi -= qsz, min) > 0);
if ((hi += qsz) != min)
{
for (lo = min + qsz; --lo >= min;)
{
c = *lo;
for (i = j = lo; (j -= qsz) >= hi; i = j)
*i = *j;
*i = c;
}
}
}
}
/*
* qst:
* Do a quicksort
* First, find the median element, and put that one in the first place as the
* discriminator. (This "median" is just the median of the first, last and
* middle elements). (Using this median instead of the first element is a big
* win). Then, the usual partitioning/swapping, followed by moving the
* discriminator into the right place. Then, figure out the sizes of the two
* partions, do the smaller one recursively and the larger one via a repeat of
* this code. Stopping when there are less than THRESH elements in a partition
* and cleaning up with an insertion sort (in our caller) is a huge win.
* All data swaps are done in-line, which is space-losing but time-saving.
* (And there are only three places where this is done).
*/
qst (base, max)
char *base, *max;
{
register char *i, *j, *jj, *mid;
register int ii, c;
char *tmp;
int lo, hi;
lo = max - base; /* number of elements as chars */
do
{
/*
* At the top here, lo is the number of characters of elements in the
* current partition. (Which should be max - base).
* Find the median of the first, last, and middle element and make that the
* middle element. Set j to largest of first and middle. If max is larger
* than that guy, then it's that guy, else compare max with loser of first
* and take larger. Things are set up to prefer the middle, then the first
* in case of ties.
*/
mid = i = base + qsz * ((lo/qsz) >> 1);
if (lo >= mthresh)
{
j = ((*qcmp) ((jj = base), i) > 0 ? jj : i);
if ((*qcmp) (j, (tmp = max - qsz)) > 0)
{
j = (j == jj ? i : jj); /* switch to first loser */
if ((*qcmp) (j, tmp) < 0)
j = tmp;
}
if (j != i)
{
ii = qsz;
do
{
c = *i;
*i++ = *j;
*j++ = c;
}
while( --ii );
}
}
/*
* Semi-standard quicksort partitioning/swapping
*/
for (i = base, j = max - qsz; ;)
{
while (i < mid && (*qcmp) (i, mid) <= 0)
i += qsz;
while (j > mid)
{
if ((*qcmp) (mid, j) <= 0)
{
j -= qsz;
continue;
}
tmp = i + qsz; /* value of i after swap */
if (i == mid)
{ /* j <-> mid, new mid is j */
mid = jj = j;
}
else
{ /* i <-> j */
jj = j;
j -= qsz;
}
goto swap;
}
if (i == mid)
{
break;
}
else
{ /* i <-> mid, new mid is i */
jj = mid;
tmp = mid = i; /* value of i after swap */
j -= qsz;
}
swap:
ii = qsz;
do
{
c = *i;
*i++ = *jj;
*jj++ = c;
}
while (--ii);
i = tmp;
}
/*
* Look at sizes of the two partitions, do the smaller one first by
* recursion, then do the larger one by making sure lo is its size,
* base and max are update correctly, and branching back.
* But only repeat (recursively or by branching) if the partition is
* of at least size THRESH.
*/
i = (j = mid) + qsz;
if ((lo = j - base) <= (hi = max - i))
{
if (lo >= thresh)
qst (base, j);
base = i;
lo = hi;
}
else
{
if (hi >= thresh)
qst (i, max);
max = j;
}
}
while (lo >= thresh);
}

627
etc/refcard.tex Normal file
View file

@ -0,0 +1,627 @@
% Reference Card for GNU Emacs version 18 on Unix systems
%**start of header
\newcount\columnsperpage
% This file can be printed with 1, 2, or 3 columns per page (see below).
% Specify how many you want here. Nothing else needs to be changed.
\columnsperpage=1
% Copyright (c) 1987 Free Software Foundation, Inc.
% This file is part of GNU Emacs.
% GNU Emacs is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 1, or (at your option)
% any later version.
% GNU Emacs is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
% You should have received a copy of the GNU General Public License
% along with GNU Emacs; see the file COPYING. If not, write to
% the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
% This file is intended to be processed by plain TeX (TeX82).
%
% The final reference card has six columns, three on each side.
% This file can be used to produce it in any of three ways:
% 1 column per page
% produces six separate pages, each of which needs to be reduced to 80%.
% This gives the best resolution.
% 2 columns per page
% produces three already-reduced pages.
% You will still need to cut and paste.
% 3 columns per page
% produces two pages which must be printed sideways to make a
% ready-to-use 8.5 x 11 inch reference card.
% For this you need a dvi device driver that can print sideways.
% Which mode to use is controlled by setting \columnsperpage above.
%
% Author:
% Stephen Gildea
% UUCP: mit-erl!gildea
% Internet: gildea@erl.mit.edu
%
% Thanks to Paul Rubin, Bob Chassell, Len Tower, and Richard Mlynarik
% for their many good ideas.
% If there were room, it would be nice to see sections on
% Abbrevs, Rectangles, and Dired.
\def\versionnumber{1.9}
\def\year{1987}
\def\version{March \year\ v\versionnumber}
\def\shortcopyrightnotice{\vskip 1ex plus 2 fill
\centerline{\small \copyright\ \year\ Free Software Foundation, Inc.
Permissions on back. v\versionnumber}}
\def\copyrightnotice{
\vskip 1ex plus 2 fill\begingroup\small
\centerline{Copyright \copyright\ \year\ Free Software Foundation, Inc.}
\centerline{designed by Stephen Gildea, \version}
\centerline{for GNU Emacs version 18 on Unix systems}
Permission is granted to make and distribute copies of
this card provided the copyright notice and this permission notice
are preserved on all copies.
For copies of the GNU Emacs manual, write to the Free Software
Foundation, Inc., 675 Massachusetts Ave, Cambridge MA 02139.
\endgroup}
% make \bye not \outer so that the \def\bye in the \else clause below
% can be scanned without complaint.
\def\bye{\par\vfill\supereject\end}
\newdimen\intercolumnskip
\newbox\columna
\newbox\columnb
\def\ncolumns{\the\columnsperpage}
\message{[\ncolumns\space
column\if 1\ncolumns\else s\fi\space per page]}
\def\scaledmag#1{ scaled \magstep #1}
% This multi-way format was designed by Stephen Gildea
% October 1986.
\if 1\ncolumns
\hsize 4in
\vsize 10in
\voffset -.7in
\font\titlefont=\fontname\tenbf \scaledmag3
\font\headingfont=\fontname\tenbf \scaledmag2
\font\smallfont=\fontname\sevenrm
\font\smallsy=\fontname\sevensy
\footline{\hss\folio}
\def\makefootline{\baselineskip10pt\hsize6.5in\line{\the\footline}}
\else
\hsize 3.2in
\vsize 7.95in
\hoffset -.75in
\voffset -.745in
\font\titlefont=cmbx10 \scaledmag2
\font\headingfont=cmbx10 \scaledmag1
\font\smallfont=cmr6
\font\smallsy=cmsy6
\font\eightrm=cmr8
\font\eightbf=cmbx8
\font\eightit=cmti8
\font\eighttt=cmtt8
\font\eightsy=cmsy8
\textfont0=\eightrm
\textfont2=\eightsy
\def\rm{\eightrm}
\def\bf{\eightbf}
\def\it{\eightit}
\def\tt{\eighttt}
\normalbaselineskip=.8\normalbaselineskip
\normallineskip=.8\normallineskip
\normallineskiplimit=.8\normallineskiplimit
\normalbaselines\rm %make definitions take effect
\if 2\ncolumns
\let\maxcolumn=b
\footline{\hss\rm\folio\hss}
\def\makefootline{\vskip 2in \hsize=6.86in\line{\the\footline}}
\else \if 3\ncolumns
\let\maxcolumn=c
\nopagenumbers
\else
\errhelp{You must set \columnsperpage equal to 1, 2, or 3.}
\errmessage{Illegal number of columns per page}
\fi\fi
\intercolumnskip=.46in
\def\abc{a}
\output={%
% This next line is useful when designing the layout.
%\immediate\write16{Column \folio\abc\space starts with \firstmark}
\if \maxcolumn\abc \multicolumnformat \global\def\abc{a}
\else\if a\abc
\global\setbox\columna\columnbox \global\def\abc{b}
%% in case we never use \columnb (two-column mode)
\global\setbox\columnb\hbox to -\intercolumnskip{}
\else
\global\setbox\columnb\columnbox \global\def\abc{c}\fi\fi}
\def\multicolumnformat{\shipout\vbox{\makeheadline
\hbox{\box\columna\hskip\intercolumnskip
\box\columnb\hskip\intercolumnskip\columnbox}
\makefootline}\advancepageno}
\def\columnbox{\leftline{\pagebody}}
\def\bye{\par\vfill\supereject
\if a\abc \else\null\vfill\eject\fi
\if a\abc \else\null\vfill\eject\fi
\end}
\fi
% we won't be using math mode much, so redefine some of the characters
% we might want to talk about
\catcode`\^=12
\catcode`\_=12
\chardef\\=`\\
\chardef\{=`\{
\chardef\}=`\}
\hyphenation{mini-buf-fer}
\parindent 0pt
\parskip 1ex plus .5ex minus .5ex
\def\small{\smallfont\textfont2=\smallsy\baselineskip=.8\baselineskip}
\outer\def\newcolumn{\vfill\eject}
\outer\def\title#1{{\titlefont\centerline{#1}}\vskip 1ex plus .5ex}
\outer\def\section#1{\par\filbreak
\vskip 3ex plus 2ex minus 2ex {\headingfont #1}\mark{#1}%
\vskip 2ex plus 1ex minus 1.5ex}
\newdimen\keyindent
\def\beginindentedkeys{\keyindent=1em}
\def\endindentedkeys{\keyindent=0em}
\endindentedkeys
\def\paralign{\vskip\parskip\halign}
\def\<#1>{$\langle${\rm #1}$\rangle$}
\def\kbd#1{{\tt#1}\null} %\null so not an abbrev even if period follows
\def\beginexample{\par\leavevmode\begingroup
\obeylines\obeyspaces\parskip0pt\tt}
{\obeyspaces\global\let =\ }
\def\endexample{\endgroup}
\def\key#1#2{\leavevmode\hbox to \hsize{\vtop
{\hsize=.75\hsize\rightskip=1em
\hskip\keyindent\relax#1}\kbd{#2}\hfil}}
\newbox\metaxbox
\setbox\metaxbox\hbox{\kbd{M-x }}
\newdimen\metaxwidth
\metaxwidth=\wd\metaxbox
\def\metax#1#2{\leavevmode\hbox to \hsize{\hbox to .75\hsize
{\hskip\keyindent\relax#1\hfil}%
\hskip -\metaxwidth minus 1fil
\kbd{#2}\hfil}}
\def\threecol#1#2#3{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad
&\kbd{#3}\quad\cr}
%**end of header
\title{GNU Emacs Reference Card}
\centerline{(for version 18)}
\section{Starting Emacs}
To enter Emacs, just type its name: \kbd{emacs}
To read in a file to edit, see Files, below.
\section{Leaving Emacs}
\key{suspend Emacs (the usual way of leaving it)}{C-z}
\key{exit Emacs permanently}{C-x C-c}
\section{Files}
\key{{\bf read} a file into Emacs}{C-x C-f}
\key{{\bf save} a file back to disk}{C-x C-s}
\key{{\bf insert} contents of another file into this buffer}{C-x i}
\key{replace this file with the file you really want}{C-x C-v}
\key{write buffer to a specified file}{C-x C-w}
\key{run Dired, the directory editor}{C-x d}
\section{Getting Help}
The Help system is simple. Type \kbd{C-h} and follow the directions.
If you are a first-time user, type \kbd{C-h t} for a {\bf tutorial}.
(This card assumes you know the tutorial.)
\key{get rid of Help window}{C-x 1}
\key{scroll Help window}{ESC C-v}
\key{apropos: show commands matching a string}{C-h a}
\key{show the function a key runs}{C-h c}
\key{describe a function}{C-h f}
\key{get mode-specific information}{C-h m}
\section{Error Recovery}
\key{{\bf abort} partially typed or executing command}{C-g}
\metax{{\bf recover} a file lost by a system crash}{M-x recover-file}
\key{{\bf undo} an unwanted change}{C-x u {\rm or} C-_}
\metax{restore a buffer to its original contents}{M-x revert-buffer}
\key{redraw garbaged screen}{C-l}
\section{Incremental Search}
\key{search forward}{C-s}
\key{search backward}{C-r}
\key{regular expression search}{C-M-s}
Use \kbd{C-s} or \kbd{C-r} again to repeat the search in either direction.
\key{exit incremental search}{ESC}
\key{undo effect of last character}{DEL}
\key{abort current search}{C-g}
If Emacs is still searching, \kbd{C-g} will cancel the
part of the search not done, otherwise it aborts the entire search.
\shortcopyrightnotice
\section{Motion}
Cursor motion:
\beginindentedkeys
\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\threecol{{\bf entity to move over}}{{\bf backward}}{{\bf forward}}
\threecol{character}{C-b}{C-f}
\threecol{word}{M-b}{M-f}
\threecol{line}{C-p}{C-n}
\threecol{go to line beginning (or end)}{C-a}{C-e}
\threecol{sentence}{M-a}{M-e}
\threecol{paragraph}{M-[}{M-]}
\threecol{page}{C-x [}{C-x ]}
\threecol{sexp}{C-M-b}{C-M-f}
\threecol{function}{C-M-a}{C-M-e}
\threecol{go to buffer beginning (or end)}{M-<}{M->}
}
Screen motion:
\key{scroll to next screen}{C-v}
\key{scroll to previous screen}{M-v}
\key{scroll left}{C-x <}
\key{scroll right}{C-x >}
\endindentedkeys
\section{Killing and Deleting}
\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\threecol{{\bf entity to kill}}{{\bf backward}}{{\bf forward}}
\threecol{character (delete, not kill)}{DEL}{C-d}
\threecol{word}{M-DEL}{M-d}
\threecol{line (to end of)}{M-0 C-k}{C-k}
\threecol{sentence}{C-x DEL}{M-k}
\threecol{sexp}{M-- C-M-k}{C-M-k}
}
\key{kill {\bf region}}{C-w}
\key{kill to next occurrence of {\it char}}{M-z {\it char}}
\key{yank back last thing killed}{C-y}
\key{replace last yank with previous kill}{M-y}
\section{Marking}
\key{set mark here}{C-@ {\rm or} C-SPC}
\key{exchange point and mark}{C-x C-x}
\key{set mark {\it arg\/} {\bf words} away}{M-@}
\key{mark {\bf paragraph}}{M-h}
\key{mark {\bf page}}{C-x C-p}
\key{mark {\bf sexp}}{C-M-@}
\key{mark {\bf function}}{C-M-h}
\key{mark entire {\bf buffer}}{C-x h}
\section{Query Replace}
\key{interactively replace a text string}{M-\%}
\metax{using regular expressions}{M-x query-replace-regexp}
Valid responses in query-replace mode are
\key{{\bf replace} this one, go on to next}{SPC}
\key{replace this one, don't move}{,}
\key{{\bf skip} to next without replacing}{DEL}
\key{replace all remaining matches}{!}
\key{{\bf back up} to the previous match}{^}
\key{{\bf exit} query-replace}{ESC}
\key{enter recursive edit (\kbd{C-M-c} to exit)}{C-r}
\section{Multiple Windows}
\key{delete all other windows}{C-x 1}
\key{delete this window}{C-x 0}
\key{split window in 2 vertically}{C-x 2}
\key{split window in 2 horizontally}{C-x 5}
\key{scroll other window}{C-M-v}
\key{switch cursor to another window}{C-x o}
\metax{shrink window shorter}{M-x shrink-window}
\key{grow window taller}{C-x ^}
\key{shrink window narrower}{C-x \{}
\key{grow window wider}{C-x \}}
\key{select a buffer in other window}{C-x 4 b}
\key{find file in other window}{C-x 4 f}
\key{compose mail in other window}{C-x 4 m}
\key{run Dired in other window}{C-x 4 d}
\key{find tag in other window}{C-x 4 .}
\section{Formatting}
\key{indent current {\bf line} (mode-dependent)}{TAB}
\key{indent {\bf region} (mode-dependent)}{C-M-\\}
\key{indent {\bf sexp} (mode-dependent)}{C-M-q}
\key{indent region rigidly {\it arg\/} columns}{C-x TAB}
\key{insert newline after point}{C-o}
\key{move rest of line vertically down}{C-M-o}
\key{delete blank lines around point}{C-x C-o}
\key{delete all whitespace around point}{M-\\}
\key{put exactly one space at point}{M-SPC}
\key{fill {\bf paragraph}}{M-q}
\key{fill {\bf region}}{M-g}
\key{set fill column}{C-x f}
\key{set prefix each line starts with}{C-x .}
\section{Case Change}
\key{uppercase word}{M-u}
\key{lowercase word}{M-l}
\key{capitalize word}{M-c}
\key{uppercase region}{C-x C-u}
\key{lowercase region}{C-x C-l}
\metax{capitalize region}{M-x capitalize-region}
\section{The Minibuffer}
The following keys are defined in the minibuffer.
\key{complete as much as possible}{TAB}
\key{complete up to one word}{SPC}
\key{complete and execute}{RET}
\key{show possible completions}{?}
\key{abort command}{C-g}
Type \kbd{C-x ESC} to edit and repeat the last command that used the
minibuffer. The following keys are then defined.
\key{previous minibuffer command}{M-p}
\key{next minibuffer command}{M-n}
\newcolumn
\title{GNU Emacs Reference Card}
\section{Buffers}
\key{select another buffer}{C-x b}
\key{list all buffers}{C-x C-b}
\key{kill a buffer}{C-x k}
\section{Transposing}
\key{transpose {\bf characters}}{C-t}
\key{transpose {\bf words}}{M-t}
\key{transpose {\bf lines}}{C-x C-t}
\key{transpose {\bf sexps}}{C-M-t}
\section{Spelling Check}
\key{check spelling of current word}{M-\$}
\metax{check spelling of all words in region}{M-x spell-region}
\metax{check spelling of entire buffer}{M-x spell-buffer}
\section{Tags}
\key{find tag}{M-.}
\key{find next occurrence of tag}{C-u M-.}
\metax{specify a new tags file}{M-x visit-tags-table}
\metax{regexp search on all files in tags table}{M-x tags-search}
\metax{query replace on all the files}{M-x tags-query-replace}
\key{continue last tags search or query-replace}{M-,}
\section{Shells}
\key{execute a shell command}{M-!}
\key{run a shell command on the region}{M-|}
\key{filter region through a shell command}{C-u M-|}
\metax{start a shell in window \kbd{*shell*}}{M-x shell}
\section{Rmail}
\key{scroll forward}{SPC}
\key{scroll reverse}{DEL}
\key{beginning of message}{. {\rm (dot)}}
\key{{\bf next} non-deleted message}{n}
\key{{\bf previous} non-deleted message}{p}
\key{next message}{M-n}
\key{previous message}{M-p}
\key{{\bf delete} message}{d}
\key{delete message and back up}{C-d}
\key{undelete message}{u}
\key{{\bf reply} to message}{r}
\key{forward message to someone}{f}
\key{send mail}{m}
\key{{\bf get} newly arrived mail}{g}
\key{{\bf quit} Rmail}{q}
\key{output message to another Rmail file}{o}
\key{output message in Unix-mail style}{C-o}
\key{show summary of headers}{h}
\section{Regular Expressions}
The following have special meaning inside a regular expression.
\key{any single character}{. {\rm(dot)}}
\key{zero or more repeats}{*}
\key{one or more repeats}{+}
\key{zero or one repeat}{?}
\key{any character in set}{[ {\rm$\ldots$} ]}
\key{any character not in set}{[^ {\rm$\ldots$} ]}
\key{beginning of line}{^}
\key{end of line}{\$}
\key{quote a special character {\it c\/}}{\\{\it c}}
\key{alternative (``or'')}{\\|}
\key{grouping}{\\( {\rm$\ldots$} \\)}
\key{{\it n\/}th group}{\\{\it n}}
\key{beginning of buffer}{\\`}
\key{end of buffer}{\\'}
\key{word break}{\\b}
\key{not beginning or end of word}{\\B}
\key{beginning of word}{\\<}
\key{end of word}{\\>}
\key{any word-syntax character}{\\w}
\key{any non-word-syntax character}{\\W}
\key{character with syntax {\it c}}{\\s{\it c}}
\key{character with syntax not {\it c}}{\\S{\it c}}
\section{Registers}
\key{copy region to register}{C-x x}
\key{insert register contents}{C-x g}
\key{save point in register}{C-x /}
\key{move point to saved location}{C-x j}
\section{Info}
\key{enter the Info documentation reader}{C-h i}
\beginindentedkeys
Moving within a node:
\key{scroll forward}{SPC}
\key{scroll reverse}{DEL}
\key{beginning of node}{. {\rm (dot)}}
Moving between nodes:
\key{{\bf next} node}{n}
\key{{\bf previous} node}{p}
\key{move {\bf up}}{u}
\key{select menu item by name}{m}
\key{select {\it n\/}th menu item by number (1--5)}{{\it n}}
\key{follow cross reference (return with \kbd{l})}{f}
\key{return to last node you saw}{l}
\key{return to directory node}{d}
\key{go to any node by name}{g}
Other:
\key{run Info {\bf tutorial}}{h}
\key{list Info commands}{?}
\key{{\bf quit} Info}{q}
\key{search nodes for regexp}{s}
\endindentedkeys
\section{Keyboard Macros}
\key{{\bf start} defining a keyboard macro}{C-x (}
\key{{\bf end} keyboard macro definition}{C-x )}
\key{{\bf execute} last-defined keyboard macro}{C-x e}
\key{append to last keyboard macro}{C-u C-x (}
\metax{name last keyboard macro}{M-x name-last-kbd-macro}
\metax{insert lisp definition in buffer}{M-x insert-kbd-macro}
\section{Commands Dealing with Emacs Lisp}
\key{eval {\bf sexp} before point}{C-x C-e}
\key{eval current {\bf defun}}{C-M-x}
\metax{eval {\bf region}}{M-x eval-region}
\metax{eval entire {\bf buffer}}{M-x eval-current-buffer}
\key{read and eval minibuffer}{M-ESC}
\key{re-execute last minibuffer command}{C-x ESC}
\metax{read and eval Emacs Lisp file}{M-x load-file}
\metax{load from standard system directory}{M-x load-library}
\section{Simple Customization}
% The intended audience here is the person who wants to make simple
% customizations and knows Lisp syntax.
Here are some examples of binding global keys in Emacs Lisp. Note
that you cannot say \kbd{"\\M-\#"}; you must say \kbd{"\\e\#"}.
\beginexample%
(global-set-key "\\C-cg" 'goto-line)
(global-set-key "\\e\\C-r" 'isearch-backward-regexp)
(global-set-key "\\e\#" 'query-replace-regexp)
\endexample
An example of setting a variable in Emacs Lisp:
\beginexample%
(setq backup-by-copying-when-linked t)
\endexample
\section{Writing Commands}
\beginexample%
(defun \<command-name> (\<args>)
"\<documentation>"
(interactive "\<template>")
\<body>)
\endexample
An example:
\beginexample%
(defun this-line-to-top-of-screen (line)
"Reposition line point is on to the top of
the screen. With ARG, put point on line ARG.
Negative counts from bottom."
(interactive "P")
(recenter (if (null line)
0
(prefix-numeric-value line))))
\endexample
The argument to \kbd{interactive} is a string specifying how to get
the arguments when the function is called interactively.
Type \kbd{C-h f interactive} for more information.
\copyrightnotice
\bye
% Local variables:
% compile-command: "tex refcard"
% End:

50
lib-src/emacsserver.c → etc/server.c
View file

@ -24,6 +24,11 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
and passes their commands (consisting of keyboard characters)
up to the Emacs which then executes them. */
/* This must precede sys/signal.h on certain machines. */
#include <sys/types.h>
/* This must precede config.h on certain machines. */
#include <sys/signal.h>
#define NO_SHORTNAMES
#include "../src/config.h"
#undef read
@ -32,25 +37,24 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#undef close
#if !defined(HAVE_SOCKETS) && !defined(HAVE_SYSVIPC)
#if !defined(BSD) && !defined(HAVE_SYSVIPC)
#include <stdio.h>
main ()
{
fprintf (stderr, "Sorry, the Emacs server is supported only on systems\n");
fprintf (stderr, "with Berkeley sockets or System V IPC.\n");
fprintf (stderr, "Sorry, the Emacs server is supported only on Berkeley Unix\n");
fprintf (stderr, "or System V systems with IPC\n");
exit (1);
}
#else /* HAVE_SOCKETS or HAVE_SYSVIPC */
#else /* BSD or HAVE_SYSVIPC */
#if ! defined (HAVE_SYSVIPC)
#if defined (BSD) && ! defined (HAVE_SYSVIPC)
/* BSD code is very different from SYSV IPC code */
#include <sys/file.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <sys/un.h>
#include <stdio.h>
#include <errno.h>
@ -59,6 +63,7 @@ extern int errno;
main ()
{
char system_name[32];
int s, infd, fromlen;
struct sockaddr_un server, fromunix;
char *homedir;
@ -67,7 +72,6 @@ main ()
FILE **openfiles;
int openfiles_size;
int geteuid ();
char *getenv ();
openfiles_size = 20;
@ -85,28 +89,32 @@ main ()
exit (1);
}
server.sun_family = AF_UNIX;
homedir = getenv ("HOME");
if (homedir == NULL)
#ifndef SERVER_HOME_DIR
gethostname (system_name, sizeof (system_name));
sprintf (server.sun_path, "/tmp/esrv%d-%s", geteuid (), system_name);
if (unlink (server.sun_path) == -1 && errno != ENOENT)
{
perror ("unlink");
exit (1);
}
#else
if ((homedir = getenv ("HOME")) == NULL)
{
fprintf (stderr,"No home directory\n");
exit (1);
}
sprintf (server.sun_path, "/tmp/esrv%d", geteuid ());
#if 0
strcpy (server.sun_path, homedir);
strcat (server.sun_path, "/.emacs_server");
#endif
/* Delete anyone else's old server. */
unlink (server.sun_path);
#endif
if (bind (s, &server, strlen (server.sun_path) + 2) < 0)
{
perror ("bind");
exit (1);
}
/* Only this user can send commands to this Emacs. */
chmod (server.sun_path, 0600);
/*
* Now, just wait for everything to come in..
*/
@ -214,13 +222,14 @@ main ()
#else /* This is the SYSV IPC section */
#include <sys/types.h>
#include <sys/signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <setjmp.h>
jmp_buf msgenv;
void /* void here fixes bug on sgi.
Let's hope this doesn't break other systems. */
msgcatch ()
{
longjmp (msgenv, 1);
@ -294,6 +303,7 @@ main ()
if ((fromlen = msgrcv (s, msgp, BUFSIZ - 1, 1, 0)) < 0)
{
perror ("msgrcv");
exit (1);
}
else
{
@ -313,6 +323,8 @@ main ()
}
}
#endif /* HAVE_SYSVIPC */
#endif /* SYSV IPC */
#endif /* BSD && IPC */
#endif /* HAVE_SOCKETS or HAVE_SYSVIPC */

111
etc/sex.6 Normal file
View file

@ -0,0 +1,111 @@
SEX(6) EUNUCH Programmer's Manual SEX(6)
NAME
sex - have sex
SYNOPSIS
sex [ options ] ... [ username ] ...
DESCRIPTION
_s_e_x allows the invoker to have sex with the user(s) speci-
fied in the command line. If no users are specified, they
are taken from the LOVERS environment variable. Options to
make things more interesting are as follows:
-1 masturbate
-a external stimulus (aphrodisiac) option
-b buggery
-B<animal>
bestiality with <animal>
-c chocolate sauce option
-C chaining option (cuffs included) (see also -m -s -W)
-d<file>
get a date with the features described in <file>
-e exhibitionism (image sent to all machines on the net)
-f foreplay option
-F nasal sex with plants
-i coitus interruptus (messy!)
-j jacuzzi option (California sites only)
-l leather option
-m masochism (see -s)
-M triple parallel (Menage a Trois) option
-n necrophilia (if target process is not dead, program
kills it)
-o oral option
-O parallel access (orgy)
-p debug option (proposition only)
-P pedophilia (must specify a child process)
Printed 2/15/87 2/15/87 1
SEX(6) EUNUCH Programmer's Manual SEX(6)
-q quickie (wham, bam, thank you, ma'am)
-s sadism (target must set -m)
-S sundae option
-v voyeurism (surveys the entire net)
-w whipped cream option
-W whips (see also -s, -C, and -m)
ENVIRONMENT
LOVERS
is a list of default partners which will be used if
none are specified in the command line. If any are
specified, the values in LOVERS is ignored.
FILES
/usr/lib/sex/animals animals for bestiality
/usr/lib/sex/blackbook possible dates
/usr/lib/sex/sundaes sundae recipes
/usr/lib/sex/s&m sado-masochistic equipment
BUGS
^C (quit process) may leave the user very unsatisfied.
^Z (stop process) is usually quite messy.
MAN AUTHOR
Author prefers to be anonymous.
HISTORY
Oldest program ever.

0
lib-src/sorted-doc.c → etc/sorted-doc.c
View file

BIN
etc/spook.lines Normal file
View file

Binary file not shown.

10
etc/termcap.dat
View file

@ -47,12 +47,12 @@ ZW|gator|HP 9000 model 237 emulating AAA:\
ZY|gator-52|HP 9000 model 237 emulating VT52:\
:cr=^M:do=^J:nl=^J:bl=^G:\
:le=^H:bs:cd=\EJ:ce=\EK:cl=\EH\EJ:cm=\EY%+ %+ :co#128:li#47:nd=\EC:\
:ta=^I:pt:sr=\EI:up=\EA:ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:\
:ta=^I:pt:sr=\EI:up=\EA:ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:
:ce=\EK:ho=\EH:
ZZ|gator-52t|HP 9000 model 237 emulating extra-tall VT52:\
:cr=^M:do=^J:nl=^J:bl=^G:\
:le=^H:bs:cd=\EJ:ce=\EK:cl=\EH\EJ:cm=\EY%+ %+ :co#128:li#94:nd=\EC:\
:ta=^I:pt:sr=\EI:up=\EA:ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:\
:ta=^I:pt:sr=\EI:up=\EA:ku=\EA:kd=\EB:kr=\EC:kl=\ED:kb=^H:
:ce=\EK:ho=\EH:
#
# N: ANN ARBOR
@ -461,9 +461,9 @@ ZN|aaa60|ambas60|ambassador60|ann arbor ambassador/60 lines:\
:li#60:mi:tc=aaax:
# vt100 -- this has been changed to delete the "pt" ("real tabs")
# option, which was losing. -- walter 10/84
d0|vt100-132|vt125-132|dec vt100 with 132 columns:\
d0|vt100-132|vt101-132|vt102-132|vt125-132|vt131-132|dec vt100 with 132 columns:\
:co#132:tc=vt100:
d0|vt100|vt100-am|vt100-80|vt125|vt125-80|dec vt100:\
d0|vt100|vt100-am|vt100-80|vt101|vt101-80|vt102|vt102-80|vt125|vt125-80|vt131|vt131-80|dec vt100:\
:cr=^M:bl=^G:le=^H:do=\ED:ho=\E[H:\
:co#80:li#24:cl=45\E[H\E[2J:bs:am:cm=5\E[%i%d;%dH:nd=\E[C:up=\E[A:\
:ce=2\E[K:cd=2*\E[J:so=2\E[7m:se=2\E[m:us=2\E[4m:ue=2\E[m:\
@ -549,7 +549,7 @@ nunix-61|nu-telnet-61|nu-full| Full nu screen thru telnet:\
# It is bad form to use ^J,^L,^K to scroll the screen.
# If the VT2xx doesn't have newline mode set those characters
# donot move the cursor down a line. Use \ED instead.
d0|vt200-80|vt200|vt300-80|VT 200 with 80 columns, on VMS:\
d0|vt200-80|vt200|vt300-80|vt300|VT 200 with 80 columns, on VMS:\
:AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:\
:LE=\E[%dD:RI=\E[%dC:SR=1*\E[%dM:UP=\E[%dA:al=\E[L:\
:am:bl=^G:bs:cd=2*\E[J:ce=2*\E[K:cl=45\E[H\E[2J:\

2667
etc/termcap.ucb Normal file
View file

File diff suppressed because it is too large Load diff

0
lib-src/test-distrib.c → etc/test-distrib.c
View file

BIN
etc/testfile Normal file
View file

Binary file not shown.

38
etc/ulimit.hack Normal file
View file

@ -0,0 +1,38 @@
#!/bin/sh
#
# ulimit.hack: Create an intermediate program for use in
# between kernel initialization and init startup.
# This is needed on a 3b system if the standard CDLIMIT is
# so small that the dumped Emacs file cannot be written.
# This program causes everyone to get a bigger CDLIMIT value
# so that the dumped Emacs can be written out.
#
# Users of V.3.1 and later should not use this; see etc/MACHINES
# and reconfig your kernel's CDLIMIT parameter instead.
#
# Caveat: Heaven help you if you screw this up. This puts
# a new program in as /etc/init, which then execs the real init.
#
cat > ulimit.init.c << \EOF
main(argc, argv)
int argc;
char *argv[];
{
ulimit(2, 262144L); /* "2" is the "set" command. */
/* 262,144 allows for 128Mb files to be written. */
/* If that value isn't suitable, roll your own. */
execv("/etc/real.init", argv);
}
EOF
#
# Compile it and put it in place of the usual init program.
#
cc ulimit.init.c -o ulimit.init
mv /etc/init /etc/real.init
mv ulimit.init /etc/ulimit.init
ln /etc/ulimit.init /etc/init
mv ulimit.init.c /etc/ulimit.init.c # to keep src for this hack nearby.
chmod 0754 /etc/init
exit 0
#
# Upon system reboot, all processes will inherit the new large ulimit.

680
etc/vipcard.tex Normal file
View file

@ -0,0 +1,680 @@
% Quick Reference Card for VIP 3.5 under GNU Emacs version 18 on Unix systems
%**start of header
\newcount\columnsperpage
% This file can be printed with 1, 2, or 3 columns per page (see below).
% Specify how many you want here. Nothing else needs to be changed.
\columnsperpage=1
% Copyright (c) 1987 Free Software Foundation, Inc.
% This file is part of GNU Emacs.
% GNU Emacs is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 1, or (at your option)
% any later version.
% GNU Emacs is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
% You should have received a copy of the GNU General Public License
% along with GNU Emacs; see the file COPYING. If not, write to
% the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
% This file is intended to be processed by plain TeX (TeX82).
%
% The final reference card has six columns, three on each side.
% This file can be used to produce it in any of three ways:
% 1 column per page
% produces six separate pages, each of which needs to be reduced to 80%.
% This gives the best resolution.
% 2 columns per page
% produces three already-reduced pages.
% You will still need to cut and paste.
% 3 columns per page
% produces two pages which must be printed sideways to make a
% ready-to-use 8.5 x 11 inch reference card.
% For this you need a dvi device driver that can print sideways.
% Which mode to use is controlled by setting \columnsperpage above.
%
% Author:
% Masahiko Sato
% Internet: ms@sail.stanford.edu
% Junet: masahiko@sato.riec.tohoku.junet
%
% The original TeX code for formatting the reference card was written by:
% Stephen Gildea
% UUCP: mit-erl!gildea
% Internet: gildea@erl.mit.edu
\def\versionnumber{1.2}
\def\year{1987}
\def\version{September \year\ v\versionnumber}
\def\shortcopyrightnotice{\vskip 1ex plus 2 fill
\centerline{\small \copyright\ \year\ Free Software Foundation, Inc.
Permissions on back. v\versionnumber}}
\def\copyrightnotice{
%\vskip 1ex plus 2 fill\begingroup\small
\vskip 1ex \begingroup\small
\centerline{Copyright \copyright\ \year\ Free Software Foundation, Inc.}
\centerline{designed by Masahiko Sato, \version}
\centerline{for VIP 3.5 under GNU Emacs version 18 on Unix systems}
Permission is granted to make and distribute copies of
this card provided the copyright notice and this permission notice
are preserved on all copies.
For copies of the GNU Emacs manual, write to the Free Software
Foundation, Inc., 1000 Massachusetts Ave, Cambridge MA 02138.
\endgroup}
% make \bye not \outer so that the \def\bye in the \else clause below
% can be scanned without complaint.
\def\bye{\par\vfill\supereject\end}
\newdimen\intercolumnskip
\newbox\columna
\newbox\columnb
\def\ncolumns{\the\columnsperpage}
\message{[\ncolumns\space
column\if 1\ncolumns\else s\fi\space per page]}
\def\scaledmag#1{ scaled \magstep #1}
% This multi-way format was designed by Stephen Gildea
% October 1986.
% Slightly modified by Masahiko Sato, September 1987.
\if 1\ncolumns
\hsize 4in
\vsize 10in
%\voffset -.7in
\voffset -.57in
\font\titlefont=\fontname\tenbf \scaledmag3
\font\headingfont=\fontname\tenbf \scaledmag2
\font\miniheadingfont=\fontname\tenbf \scaledmag1 % masahiko
\font\smallfont=\fontname\sevenrm
\font\smallsy=\fontname\sevensy
\footline{\hss\folio}
\def\makefootline{\baselineskip10pt\hsize6.5in\line{\the\footline}}
\else
%\hsize 3.2in
%\vsize 7.95in
\hsize 3.41in % masahiko
\vsize 8in % masahiko
\hoffset -.75in
\voffset -.745in
\font\titlefont=cmbx10 \scaledmag2
\font\headingfont=cmbx10 \scaledmag1
\font\miniheadingfont=cmbx10 % masahiko
\font\smallfont=cmr6
\font\smallsy=cmsy6
\font\eightrm=cmr8
\font\eightbf=cmbx8
\font\eightit=cmti8
\font\eightsl=cmsl8
\font\eighttt=cmtt8
\font\eightsy=cmsy8
\textfont0=\eightrm
\textfont2=\eightsy
\def\rm{\eightrm}
\def\bf{\eightbf}
\def\it{\eightit}
\def\sl{\eightsl} % masahiko
\def\tt{\eighttt}
\normalbaselineskip=.8\normalbaselineskip
\normallineskip=.8\normallineskip
\normallineskiplimit=.8\normallineskiplimit
\normalbaselines\rm %make definitions take effect
\if 2\ncolumns
\let\maxcolumn=b
\footline{\hss\rm\folio\hss}
\def\makefootline{\vskip 2in \hsize=6.86in\line{\the\footline}}
\else \if 3\ncolumns
\let\maxcolumn=c
\nopagenumbers
\else
\errhelp{You must set \columnsperpage equal to 1, 2, or 3.}
\errmessage{Illegal number of columns per page}
\fi\fi
%\intercolumnskip=.46in
\intercolumnskip=.19in % masahiko .19x4 + 3.41x3 = 10.99
\def\abc{a}
\output={%
% This next line is useful when designing the layout.
%\immediate\write16{Column \folio\abc\space starts with \firstmark}
\if \maxcolumn\abc \multicolumnformat \global\def\abc{a}
\else\if a\abc
\global\setbox\columna\columnbox \global\def\abc{b}
%% in case we never use \columnb (two-column mode)
\global\setbox\columnb\hbox to -\intercolumnskip{}
\else
\global\setbox\columnb\columnbox \global\def\abc{c}\fi\fi}
\def\multicolumnformat{\shipout\vbox{\makeheadline
\hbox{\box\columna\hskip\intercolumnskip
\box\columnb\hskip\intercolumnskip\columnbox}
\makefootline}\advancepageno}
\def\columnbox{\leftline{\pagebody}}
\def\bye{\par\vfill\supereject
\if a\abc \else\null\vfill\eject\fi
\if a\abc \else\null\vfill\eject\fi
\end}
\fi
% we won't be using math mode much, so redefine some of the characters
% we might want to talk about
\catcode`\^=12
\catcode`\_=12
\chardef\\=`\\
\chardef\{=`\{
\chardef\}=`\}
\hyphenation{mini-buf-fer}
\parindent 0pt
\parskip 1ex plus .5ex minus .5ex
\def\small{\smallfont\textfont2=\smallsy\baselineskip=.8\baselineskip}
\outer\def\newcolumn{\vfill\eject}
\outer\def\title#1{{\titlefont\centerline{#1}}\vskip 1ex plus .5ex}
\outer\def\section#1{\par\filbreak
\vskip 3ex plus 2ex minus 2ex {\headingfont #1}\mark{#1}%
\vskip 2ex plus 1ex minus 1.5ex}
% masahiko
\outer\def\subsection#1{\par\filbreak
\vskip 2ex plus 2ex minus 2ex {\miniheadingfont #1}\mark{#1}%
\vskip 1ex plus 1ex minus 1.5ex}
\newdimen\keyindent
\def\beginindentedkeys{\keyindent=1em}
\def\endindentedkeys{\keyindent=0em}
\endindentedkeys
\def\paralign{\vskip\parskip\halign}
\def\<#1>{$\langle${\rm #1}$\rangle$}
\def\kbd#1{{\tt#1}\null} %\null so not an abbrev even if period follows
\def\beginexample{\par\leavevmode\begingroup
\obeylines\obeyspaces\parskip0pt\tt}
{\obeyspaces\global\let =\ }
\def\endexample{\endgroup}
\def\key#1#2{\leavevmode\hbox to \hsize{\vtop
{\hsize=.75\hsize\rightskip=1em
\hskip\keyindent\relax#1}\kbd{#2}\hfil}}
\newbox\metaxbox
\setbox\metaxbox\hbox{\kbd{M-x }}
\newdimen\metaxwidth
\metaxwidth=\wd\metaxbox
\def\metax#1#2{\leavevmode\hbox to \hsize{\hbox to .75\hsize
{\hskip\keyindent\relax#1\hfil}%
\hskip -\metaxwidth minus 1fil
\kbd{#2}\hfil}}
\def\fivecol#1#2#3#4#5{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad
&\kbd{#3}\quad&\kbd{#4}\quad&\kbd{#5}\cr}
\def\fourcol#1#2#3#4{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad
&\kbd{#3}\quad&\kbd{#4}\quad\cr}
\def\threecol#1#2#3{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad
&\kbd{#3}\quad\cr}
\def\twocol#1#2{\hskip\keyindent\relax\kbd{#1}\hfil&\kbd{#2}\quad\cr}
\def\twocolkey#1#2#3#4{\hskip\keyindent\relax#1\hfil&\kbd{#2}\quad&\relax#3\hfil&\kbd{#4}\quad\cr}
%**end of header
\beginindentedkeys
\title{VIP Quick Reference Card}
\centerline{(for version 3.5 under GNU Emacs version 18)}
%\copyrightnotice
\section{Loading VIP}
Just type \kbd{M-x vip-mode} followed by \kbd{RET}
\section{VIP Modes}
VIP has three modes: {\it emacs mode}, {\it vi mode} and {\it insert mode}.
Mode line tells you which mode you are in.
In emacs mode you can do all the normal GNU Emacs editing.
This card explains only vi mode and insert mode.
{\bf GNU Emacs Reference Card} explains emacs mode.
You can switch modes as follows.
\key{from emacs mode to vi mode}{C-z}
\key{from vi mode to emacs mode}{C-z}
\metax{from vi mode to insert mode}{i, I, a, A, o, O {\rm or} C-o}
\key{from insert mode to vi mode}{ESC}
If you wish to be in vi mode just after you startup Emacs,
include the line:
\hskip 5ex
\kbd{(setq term-setup-hook 'vip-mode)}
in your \kbd{.emacs} file.
Or, you can put the following alias in your \kbd{.cshrc} file.
\hskip 5ex
\kbd{alias vip 'emacs \\!* -f vip-mode'}
\section{Insert Mode}
Insert mode is like emacs mode except for the following.
\key{go back to vi mode}{ESC}
\key{delete previous character}{C-h}
\key{delete previous word}{C-w}
\key{emulate \kbd{ESC} key in emacs mode}{C-z}
The rest of this card explains commands in {\bf vi mode}.
\section{Getting Information on VIP}
Execute info command by typing \kbd{M-x info} and select menu item
\kbd{vip}. Also:
\key{describe function attached to the key {\it x}}{C-h k {\it x}}
\section{Leaving Emacs}
\key{suspend Emacs}{X Z {\rm or} :st}
\metax{exit Emacs permanently}{Z Z {\rm or} X C {\rm or} :q}
\section{Error Recovery}
\key{abort partially typed or executing command}{C-g}
\key{redraw messed up screen}{C-l}
\metax{{\bf recover} a file lost by a system crash}{M-x recover-file}
\metax{restore a buffer to its original contents}{M-x revert-buffer}
\shortcopyrightnotice
\section{Counts}
Most commands in vi mode accept a {\it count} which can be supplied as a
prefix to the commands. In most cases, if a count is given, the
command is executed that many times. E.g., \kbd{5 d d} deletes 5
lines.
%\shortcopyrightnotice
\section{Registers}
There are 26 registers (\kbd{a} to \kbd{z}) that can store texts
and marks.
You can append a text at the end of a register (say \kbd{x}) by
specifying the register name in capital letter (say \kbd{X}).
There are also 9 read only registers (\kbd{1} to \kbd{9}) that store
up to 9 previous changes.
We will use {\it x\/} to denote a register.
\section{Entering Insert Mode}
\key{{\bf insert} at point}{i}
\key{{\bf append} after cursor}{a}
\key{{\bf insert} before first non-white}{I}
\key{{\bf append} at end of line}{A}
\key{{\bf open} line below}{o}
\key{{\bf open} line above}{O}
\key{{\bf open} line at point}{C-o}
\section{Buffers and Windows}
\key{move cursor to {\bf next} window}{C-n}
\key{delete current window}{X 0}
\key{delete other windows}{X 1}
\key{split current window into two windows}{X 2}
\key{show current buffer in two windows}{X 3}
\key{{\bf switch} to a buffer in the current window}{s {\sl buffer}}
\key{{\bf switch} to a buffer in another window}{S {\sl buffer}}
\key{{\bf kill} a buffer}{K}
\key{list exisiting {\bf buffers}}{X B}
\section{Files}
\metax{{\bf visit} file in the current window}{v {\sl file} {\rm or} :e {\sl file}}
\key{{\bf visit} file in another window}{V {\sl file}}
\key{{\bf save} buffer to the associated file}{X S}
\key{{\bf write} buffer to a specified file}{X W}
\key{{\bf insert} a specified file at point}{X I}
\key{{\bf get} information on the current {\bf file}}{g {\rm or} :f}
\key{run the {\bf directory} editor}{X d}
\section{Viewing the Buffer}
\key{scroll to next screen}{SPC {\rm or} C-f}
\key{scroll to previous screen}{RET {\rm or} C-b}
\key{scroll {\bf down} half screen}{C-d}
\key{scroll {\bf up} half screen}{C-u}
\key{scroll down one line}{C-e}
\key{scroll up one line}{C-y}
\key{put current line on the {\bf home} line}{z H {\rm or} z RET}
\key{put current line on the {\bf middle} line}{z M {\rm or} z .}
\key{put current line on the {\bf last} line}{z L {\rm or} z -}
\section{Marking and Returning}
\key{{\bf mark} point in register {\it x}}{m {\it x}}
\key{set mark at buffer beginning}{m <}
\key{set mark at buffer end}{m >}
\key{set mark at point}{m .}
\key{jump to mark}{m ,}
\key{exchange point and mark}{` `}
\key{... and skip to first non-white on line}{' '}
\key{go to mark {\it x}}{` {\it x}}
\key{... and skip to first non-white on line}{' {\it x}}
\section{Macros}
\key{start remembering keyboard macro}{X (}
\key{finish remembering keyboard macro}{X )}
\key{call last keyboard macro}{*}
\key{execute macro stored in register {\it x}}{@ {\it x}}
\section{Motion Commands}
\key{go backward one character}{h}
\key{go forward one character}{l}
\key{next line keeping the column}{j}
\key{previous line keeping the column}{k}
\key{next line at first non-white}{+}
\key{previous line at first non-white}{-}
\key{beginning of line}{0}
\key{first non-white on line}{^}
\key{end of line}{\$}
\key{go to {\it n}-th column on line}{{\it n} |}
\key{go to {\it n}-th line}{{\it n} G}
\key{go to last line}{G}
\key{find matching parenthesis for \kbd{()}, \kbd{\{\}} and \kbd{[]}}{\%}
\key{go to {\bf home} window line}{H}
\key{go to {\bf middle} window line}{M}
\key{go to {\bf last} window line}{L}
\subsection{Words, Sentences, Paragraphs}
\key{forward {\bf word}}{w {\rm or} W}
\key{{\bf backward} word}{b {\rm or} B}
\key{{\bf end} of word}{e {\rm or} E}
In the case of capital letter commands, a word is delimited by a
non-white character.
\key{forward sentence}{)}
\key{backward sentence}{(}
\key{forward paragraph}{\}}
\key{backward paragraph}{\{}
\subsection{Find Characters on the Line}
\key{{\bf find} {\it c} forward on line}{f {\it c}}
\key{{\bf find} {\it c} backward on line}{F {\it c}}
\key{up {\bf to} {\it c} forward on line}{t {\it c}}
\key{up {\bf to} {\it c} backward on line}{T {\it c}}
\key{repeat previous \kbd{f}, \kbd{F}, \kbd{t} or \kbd{T}}{;}
\key{... in the opposite direction}{,}
\newcolumn
\title{VIP Quick Reference Card}
\section{Searching and Replacing}
\key{search forward for {\sl pat}}{/ {\sl pat}}
\key{search backward for {\sl pat}}{?\ {\sl pat}}
\key{repeat previous search}{n}
\key{... in the opposite direction}{N}
\key{incremental {\bf search}}{C-s}
\key{{\bf reverse} incremental search}{C-r}
\key{{\bf replace}}{R}
\key{{\bf query} replace}{Q}
\key{{\bf replace} a character by another character {\it c}}{r {\it c}}
\section{Modifying Commands}
The delete (yank, change) commands explained below accept a motion command as
their argument and delete (yank, change) the region determined by the motion
command. Motion commands are classified into {\it point commands} and
{\it line commands}. In the case of line commands, whole lines will
be affected by the command. Motion commands will be represented by
{\it m} below.
The point commands are as follows:
\hskip 5ex
\kbd{h l 0 ^ \$ w W b B e E ( ) / ?\ ` f F t T \% ; ,}
The line commands are as follows:
\hskip 5ex
\kbd{j k + - H M L \{ \} G '}
\subsection{Delete/Yank/Change Commands}
\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\tabskip=0pt&#\cr
\fourcol{}{{\bf delete}}{{\bf yank}}{{\bf change}}
\fourcol{region determined by {\it m}}{d {\it m}}{y {\it m}}{c {\it m}}
\fourcol{... into register {\it x}}{" {\it x\/} d {\it m}}{" {\it x\/} y {\it m}}{" {\it x\/} c {\it m}}
\fourcol{a line}{d d}{Y {\rm or} y y}{c c}
\fourcol{current {\bf region}}{d r}{y r}{c r}
\fourcol{expanded {\bf region}}{d R}{y R}{c R}
\fourcol{to end of line}{D}{y \$}{c \$}
\fourcol{a character after point}{x}{y l}{c l}
\fourcol{a character before point}{DEL}{y h}{c h}
}
\subsection{Put Back Commands}
Deleted/yanked/changed text can be put back by the following commands.
\key{{\bf Put} back at point/above line}{P}
\key{... from register {\it x}}{" {\it x\/} P}
\key{{\bf put} back after point/below line}{p}
\key{... from register {\it x}}{" {\it x\/} p}
\subsection{Repeating and Undoing Modifications}
\key{{\bf undo} last change}{u {\rm or} :und}
\key{repeat last change}{.\ {\rm (dot)}}
Undo is undoable by \kbd{u} and repeatable by \kbd{.}.
For example, \kbd{u...} will undo 4 previous changes.
A \kbd{.} after \kbd{5dd} is equivalent to \kbd{5dd},
while \kbd{3.} after \kbd{5dd} is equivalent to \kbd{3dd}.
\section{Miscellaneous Commands}
\endindentedkeys
\paralign to \hsize{#\tabskip=5pt plus 1 fil&#\tabskip=0pt&#\tabskip=0pt&#\tabskip=0pt&#\cr
\fivecol{}{{\bf shift left}}{{\bf shift right}}{{\bf filter shell command}}{{\bf indent}}
\fivecol{region}{< {\it m}}{> {\it m}}{!\ {\it m\/} {\sl shell-com}}{= {\it m}}
\fivecol{line}{< <}{> >}{!\ !\ {\sl shell-com}}{= =}
}
\key{emulate \kbd{ESC}/\kbd{C-h} in emacs mode}{ESC{\rm /}C-h}
\key{emulate \kbd{C-c}/\kbd{C-x} in emacs mode}{C{\rm /}X}
\key{{\bf join} lines}{J}
\key{lowercase region}{\# c {\it m}}
\key{uppercase region}{\# C {\it m}}
\key{execute last keyboard macro on each line in the region}{\# g {\it m}}
\key{insert specified string for each line in the region}{\# q {\it m}}
\key{check spelling of the words in the region}{\# s {\it m}}
\section{Differences from Vi}
\beginindentedkeys
In VIP some keys behave rather differently from Vi.
The table below lists such keys, and you can get the effect of typing
these keys by typing the corresponding keys in the VIP column.
\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\threecol{}{{\bf Vi}}{{\bf VIP}}
\threecol{forward character}{SPC}{l}
\threecol{backward character}{C-h}{h}
\threecol{next line at first non-white}{RET}{+}
\threecol{delete previous character}{X}{DEL}
\threecol{get information on file}{C-g}{g}
\threecol{substitute characters}{s}{x i}
\threecol{substitute line}{S}{c c}
\threecol{change to end of line}{C {\rm or} R}{c \$}
}
(Strictly speaking, \kbd{C} and \kbd{R} behave slightly differently in Vi.)
\section{Customization}
By default, search is case sensitive.
You can change this by including the following line in your \kbd{.vip} file.
\hskip 5ex
\kbd{(setq vip-case-fold-search t)}
\beginindentedkeys
\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\twocol{{\bf variable}}{{\bf default value}}
\twocol{vip-search-wrap-around}{t}
\twocol{vip-case-fold-search}{nil}
\twocol{vip-re-search}{nil}
\twocol{vip-re-replace}{nil}
\twocol{vip-re-query-replace}{nil}
\twocol{vip-open-with-indent}{nil}
\twocol{vip-help-in-insert-mode}{nil}
\twocol{vip-shift-width}{8}
\twocol{vip-tags-file-name}{"TAGS"}
}
%\subsection{Customizing Key Bindings}
Include (some of) following lines in your \kbd{.vip} file
to restore Vi key bindings.
\beginexample
(define-key vip-mode-map "\\C-g" 'vip-info-on-file)
(define-key vip-mode-map "\\C-h" 'vip-backward-char)
(define-key vip-mode-map "\\C-m" 'vip-next-line-at-bol)
(define-key vip-mode-map " " 'vip-forward-char)
(define-key vip-mode-map "g" 'vip-keyboard-quit)
(define-key vip-mode-map "s" 'vip-substitute)
(define-key vip-mode-map "C" 'vip-change-to-eol)
(define-key vip-mode-map "R" 'vip-change-to-eol)
(define-key vip-mode-map "S" 'vip-substitute-line)
(define-key vip-mode-map "X" 'vip-delete-backward-char)
\endexample
\newcolumn
\title{Ex Commands in VIP}
In vi mode, an Ex command is entered by typing:
\hskip 5ex
\kbd{:\ {\sl ex-command} RET}
\section{Ex Addresses}
\paralign to \hsize{#\tabskip=5pt plus 1 fil&#\tabskip=2pt&#\tabskip=5pt plus 1 fil&#\cr
\twocolkey{current line}{.}{next line with {\sl pat}}{/ {\sl pat} /}
\twocolkey{line {\it n}}{{\it n}}{previous line with {\sl pat}}{?\ {\sl pat} ?}
\twocolkey{last line}{\$}{{\it n\/} line before {\it a}}{{\it a} - {\it n}}
\twocolkey{next line}{+}{{\it a\/} through {\it b}}{{\it a\/} , {\it b}}
\twocolkey{previous line}{-}{line marked with {\it x}}{' {\it x}}
\twocolkey{entire buffer}{\%}{previous context}{' '}
}
Addresses can be specified in front of a command.
For example,
\hskip 5ex
\kbd{:.,.+10m\$}
moves 11 lines below current line to the end of buffer.
\section{Ex Commands}
\endindentedkeys
\key{mark lines matching {\sl pat} and execute {\sl cmds} on these lines}{:g /{\sl pat}/ {\sl cmds}}
\key{mark lines {\it not\/} matching {\sl pat} and execute {\sl cmds} on these lines}{:v /{\sl pat}/ {\sl cmds}}
\key{{\bf move} specified lines after {\sl addr}}{:m {\sl addr}}
\key{{\bf copy} specified lines after {\sl addr}}{:co\rm\ (or \kbd{:t})\ \sl addr}
\key{{\bf delete} specified lines [into register {\it x\/}]}{:d {\rm [{\it x\/}]}}
\key{{\bf yank} specified lines [into register {\it x\/}]}{:y {\rm [{\it x\/}]}}
\key{{\bf put} back text [from register {\it x\/}]}{:pu {\rm [{\it x\/}]}}
\key{{\bf substitute} {\sl repl} for first string on line matching {\sl pat}}{:s /{\sl pat}/{\sl repl}/}
\key{repeat last substitution}{:\&}
\key{repeat previous substitute with previous search pattern as {\sl pat}}{:\~{}}
\key{{\bf read} in a file}{:r {\sl file}}
\key{{\bf read} in the output of a shell command}{:r!\ {\sl command}}
\key{write out specified lines into {\sl file}}{:w {\sl file}}
\key{write out specified lines at the end of {\sl file}}{:w>> {\sl file}}
\key{write out and then quit}{:wq {\sl file}}
\key{define a macro {\it x} that expands to {\sl cmd}}{:map {\it x} {\sl cmd}}
\key{remove macro expansion associated with {\it x}}{:unma {\it x}}
\key{print line number}{:=}
\key{print {\bf version} number of VIP}{:ve}
\key{shift specified lines to the right}{:>}
\key{shift specified lines to the left}{:<}
\key{{\bf join} lines}{:j}
\key{mark specified line to register {\it x}}{:k {\it x}}
\key{{\bf set} a variable's value}{:se}
\key{run a sub{\bf shell} in a window}{:sh}
\key{execute shell command {\sl command}}{:!\ {\sl command}}
\key{find first definition of {\bf tag} {\sl tag}}{:ta {\sl tag}}
\copyrightnotice
\bye
% Local variables:
% compile-command: "tex refcard"
% End:

2
etc/vmslink.opt Normal file
View file

@ -0,0 +1,2 @@
!sys$share:vaxcrtl/share
sys$library:vaxcrtl/library

3
lib-src/wakeup.c → etc/wakeup.c
View file

@ -18,6 +18,9 @@ main (argc, argv)
while (1)
{
/* Make sure wakeup stops when Emacs goes away. */
if (getppid () == 1)
exit (0);
printf ("Wake up!\n");
fflush (stdout);
/* If using a period of 60, produce the output when the minute

31
etc/xmouse.doc Normal file
View file

@ -0,0 +1,31 @@
.\" X windows GNU Emacs key bindings.
.\" Print with `tbl xmouse.doc | troff`
.\"
.rs
.sp 1i
.ps 6
.vs 7
.TS
box;
cfI s s
c | c | c
l | l | l.
GNU Emacs Key Bindings for X Windows
=
Key Button Function
_
Unshifted left x-mouse-set-point
\^ middle x-paste-text
\^ right x-cut-text
_
Control middle x-cut-and-wipe-text
\^ right x-mouse-select-and-split
_
Shift middle x-cut-text
\^ right x-paste-text
_
Control-Shift left x-buffer-menu
\^ middle x-help
\^ right x-mouse-keep-one-window
.TE

90
lib-src/yow.c → etc/yow.c
View file

@ -1,22 +1,17 @@
/*
* yow.c
#include <stdio.h>
#include <ctype.h>
#include "../src/paths.h"
/* zippy.c
*
* Print a quotation from Zippy the Pinhead.
* Qux <Kaufman-David@Yale> March 6, 1986
*
* With dynamic memory allocation.
*/
#include <stdio.h>
#include <ctype.h>
#include "../src/paths.h" /* For PATH_EXEC. */
#define BUFSIZE 80
#define BUFSIZE 2000
#define SEP '\0'
#ifndef YOW_FILE
#define YOW_FILE "yow.lines"
#endif
main (argc, argv)
int argc;
@ -24,7 +19,7 @@ main (argc, argv)
{
FILE *fp;
char file[BUFSIZ];
void yow(), setup_yow();
void yow();
if (argc > 2 && !strcmp (argv[1], "-f"))
strcpy (file, argv[2]);
@ -43,58 +38,29 @@ main (argc, argv)
/* initialize random seed */
srand((int) (getpid() + time((long *) 0)));
setup_yow(fp);
yow(fp);
fclose(fp);
exit(0);
}
static long len = -1;
static long header_len;
#define AVG_LEN 40 /* average length of a quotation */
/* Sets len and header_len */
void
setup_yow(fp)
FILE *fp;
{
int c;
/* Get length of file */
/* Because the header (stuff before the first SEP) can be very long,
* thus biasing our search in favor of the first quotation in the file,
* we explicitly skip that. */
while ((c = getc(fp)) != SEP) {
if (c == EOF) {
fprintf(stderr, "File contains no separators.\n");
exit(2);
}
}
header_len = ftell(fp);
if (header_len > AVG_LEN)
header_len -= AVG_LEN; /* allow the first quotation to appear */
if (fseek(fp, 0L, 2) == -1) {
perror("fseek 1");
exit(1);
}
len = ftell(fp) - header_len;
}
/* go to a random place in the file and print the quotation there */
void
yow (fp)
FILE *fp;
{
static long len = -1;
long offset;
int c, i = 0;
char *buf;
unsigned int bufsize;
char *malloc(), *realloc();
char buf[BUFSIZE];
offset = rand() % len + header_len;
/* Get length of file, go to a random place in it */
if (len == -1) {
if (fseek(fp, 0, 2) == -1) {
perror("fseek 1");
exit(1);
}
len = ftell(fp);
}
offset = rand() % len;
if (fseek(fp, offset, 0) == -1) {
perror("fseek 2");
exit(1);
@ -117,27 +83,13 @@ yow (fp)
yow(fp);
return;
}
bufsize = BUFSIZE;
buf = malloc(bufsize);
if (buf == (char *)0) {
fprintf(stderr, "can't allocate any memory\n");
exit (3);
}
buf[i++] = c;
while ((c = getc(fp)) != SEP && c != EOF) {
buf[i++] = c;
if (i == bufsize-1) {
if (i == BUFSIZ-1)
/* Yow! Is this quotation too long yet? */
bufsize *= 2;
buf = realloc(buf, bufsize);
if (buf == (char *)0) {
fprintf(stderr, "can't allocate more memory\n");
exit (3);
}
}
break;
}
buf[i++] = 0;
printf("%s\n", buf);

249
info/COPYING Normal file
View file

@ -0,0 +1,249 @@
GNU GENERAL PUBLIC LICENSE
Version 1, February 1989
Copyright (C) 1989 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The license agreements of most software companies try to keep users
at the mercy of those companies. By contrast, our General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. The
General Public License applies to the Free Software Foundation's
software and to any other program whose authors commit to using it.
You can use it for your programs, too.
When we speak of free software, we are referring to freedom, not
price. Specifically, the General Public License is designed to make
sure that you have the freedom to give away or sell copies of free
software, that you receive source code or can get it if you want it,
that you can change the software or use pieces of it in new free
programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of a such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must tell them their rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any program or other work which
contains a notice placed by the copyright holder saying it may be
distributed under the terms of this General Public License. The
"Program", below, refers to any such program or work, and a "work based
on the Program" means either the Program or any work containing the
Program or a portion of it, either verbatim or with modifications. Each
licensee is addressed as "you".
1. You may copy and distribute verbatim copies of the Program's source
code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and
disclaimer of warranty; keep intact all the notices that refer to this
General Public License and to the absence of any warranty; and give any
other recipients of the Program a copy of this General Public License
along with the Program. You may charge a fee for the physical act of
transferring a copy.
2. You may modify your copy or copies of the Program or any portion of
it, and copy and distribute such modifications under the terms of Paragraph
1 above, provided that you also do the following:
a) cause the modified files to carry prominent notices stating that
you changed the files and the date of any change; and
b) cause the whole of any work that you distribute or publish, that
in whole or in part contains the Program or any part thereof, either
with or without modifications, to be licensed at no charge to all
third parties under the terms of this General Public License (except
that you may choose to grant warranty protection to some or all
third parties, at your option).
c) If the modified program normally reads commands interactively when
run, you must cause it, when started running for such interactive use
in the simplest and most usual way, to print or display an
announcement including an appropriate copyright notice and a notice
that there is no warranty (or else, saying that you provide a
warranty) and that users may redistribute the program under these
conditions, and telling the user how to view a copy of this General
Public License.
d) You may charge a fee for the physical act of transferring a
copy, and you may at your option offer warranty protection in
exchange for a fee.
Mere aggregation of another independent work with the Program (or its
derivative) on a volume of a storage or distribution medium does not bring
the other work under the scope of these terms.
3. You may copy and distribute the Program (or a portion or derivative of
it, under Paragraph 2) in object code or executable form under the terms of
Paragraphs 1 and 2 above provided that you also do one of the following:
a) accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Paragraphs 1 and 2 above; or,
b) accompany it with a written offer, valid for at least three
years, to give any third party free (except for a nominal charge
for the cost of distribution) a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of
Paragraphs 1 and 2 above; or,
c) accompany it with the information you received as to where the
corresponding source code may be obtained. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form alone.)
Source code for a work means the preferred form of the work for making
modifications to it. For an executable file, complete source code means
all the source code for all modules it contains; but, as a special
exception, it need not include source code for modules which are standard
libraries that accompany the operating system on which the executable
file runs, or for standard header files or definitions files that
accompany that operating system.
4. You may not copy, modify, sublicense, distribute or transfer the
Program except as expressly provided under this General Public License.
Any attempt otherwise to copy, modify, sublicense, distribute or transfer
the Program is void, and will automatically terminate your rights to use
the Program under this License. However, parties who have received
copies, or rights to use copies, from you under this General Public
License will not have their licenses terminated so long as such parties
remain in full compliance.
5. By copying, distributing or modifying the Program (or any work based
on the Program) you indicate your acceptance of this license to do so,
and all its terms and conditions.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these
terms and conditions. You may not impose any further restrictions on the
recipients' exercise of the rights granted herein.
7. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of the license which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
the license, you may choose any version ever published by the Free Software
Foundation.
8. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to humanity, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.
To do so, attach the following notices to the program. It is safest to
attach them to the start of each source file to most effectively convey
the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19xx name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License. Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items--whatever suits your
program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
program `Gnomovision' (a program to direct compilers to make passes
at assemblers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
That's all there is to it!

32
info/dir Normal file
View file

@ -0,0 +1,32 @@
-*- Text -*-
This is the file .../info/dir, which contains the topmost node of the
Info hierarchy. The first time you invoke Info you start off
looking at that node, which is (dir)Top.

File: dir Node: Top This is the top of the INFO tree
This (the Directory node) gives a menu of major topics.
Typing "d" returns here, "q" exits, "?" lists all INFO commands, "h"
gives a primer for first-timers, "mTexinfo<Return>" visits Texinfo topic,
etc.
--- PLEASE ADD DOCUMENTATION TO THIS TREE. (See INFO topic first.) ---
* Menu: The list of major topics begins on the next line.
* Info: (info). Documentation browsing system.
* Emacs: (emacs). The extensible self-documenting text editor.
* VIP: (vip). A VI-emulation for Emacs.
* Texinfo: (texinfo).
With one source file, make either a printed manual
(through TeX) or an Info file (through texinfo).
Full documentation in this menu item.
* Termcap: (termcap).
The termcap library, which enables application programs
to handle all types of character-display terminals.
* Regex: (regex).
The GNU regular expression library.

369
info/emacs Normal file
View file

@ -0,0 +1,369 @@
This is Info file ../info/emacs, produced by Makeinfo-1.49 from the
input file emacs.texi.
This file documents the GNU Emacs editor.
Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under the
terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the author instead of in the original English.

Indirect:
emacs-1: 1115
emacs-2: 48771
emacs-3: 96620
emacs-4: 146550
emacs-5: 193326
emacs-6: 242965
emacs-7: 292468
emacs-8: 339287
emacs-9: 389177
emacs-10: 437965
emacs-11: 485451
emacs-12: 534362
emacs-13: 583212
emacs-14: 632855
emacs-15: 682479
emacs-16: 705948
emacs-17: 737068
emacs-18: 764424
emacs-19: 813651

Tag Table:
(Indirect)
Node: Top1117
Node: Distrib15242
Node: License17658
Node: Intro30930
Node: Screen33604
Node: Point35048
Node: Echo Area36624
Node: Mode Line38883
Node: Characters43201
Node: Keys46260
Node: Commands48773
Node: Entering Emacs51538
Node: Exiting52860
Node: Command Switches55228
Node: Basic62319
Node: Blank Lines71078
Node: Continuation Lines72633
Node: Position Info74072
Node: Arguments77253
Node: Undo80508
Node: Minibuffer84182
Node: Minibuffer File86705
Node: Minibuffer Edit88332
Node: Completion90623
Node: Repetition96622
Node: M-x99542
Node: Help102154
Node: Mark111292
Node: Setting Mark112925
Node: Using Region115121
Node: Marking Objects115861
Node: Mark Ring117714
Node: Killing119560
Node: Yanking125074
Node: Kill Ring125876
Node: Appending Kills127116
Node: Earlier Kills129180
Node: Accumulating Text131805
Node: Rectangles134869
Node: Registers138379
Node: RegPos139398
Node: RegText140282
Node: RegRect141345
Node: Display142072
Node: Scrolling143216
Node: Horizontal Scrolling146552
Node: Selective Display147742
Node: Display Vars148961
Node: Search151589
Node: Incremental Search152775
Node: Nonincremental Search160677
Node: Word Search162140
Node: Regexp Search163747
Node: Regexps165602
Node: Search Case176255
Node: Replace176962
Node: Unconditional Replace177906
Node: Regexp Replace179013
Node: Replacement and Case179928
Node: Query Replace180877
Node: Other Repeating Search184477
Node: Fixit185728
Node: Kill Errors186316
Node: Transpose187621
Node: Fixing Case190085
Node: Spelling190742
Node: Files192174
Node: File Names193328
Node: Visiting196943
Node: Saving201764
Node: Backup206641
Node: Backup Names208034
Node: Backup Deletion209547
Node: Backup Copying210718
Node: Interlocking212452
Node: Reverting216298
Node: Auto Save218111
Node: Auto Save Files219074
Node: Auto Save Control220897
Node: Recover222115
Node: ListDir223257
Node: Dired224740
Node: Dired Enter225396
Node: Dired Edit226213
Node: Dired Deletion227953
Node: Dired Immed231163
Node: Misc File Ops232435
Node: Buffers235090
Node: Select Buffer237366
Node: List Buffers238678
Node: Misc Buffer240059
Node: Kill Buffer241763
Node: Several Buffers242967
Node: Windows246738
Node: Basic Window247323
Node: Split Window249061
Node: Other Window250751
Node: Pop Up Window252498
Node: Change Window253640
Node: Major Modes255556
Node: Choosing Modes257806
Node: Indentation260347
Node: Indentation Commands262441
Node: Tab Stops265140
Node: Just Spaces267068
Node: Text267874
Node: Text Mode269868
Node: Nroff Mode272051
Node: TeX Mode273674
Node: TeX Editing275890
Node: TeX Print279306
Node: Texinfo Mode282548
Node: Outline Mode283675
Node: Outline Format285142
Node: Outline Motion287936
Node: Outline Visibility289512
Node: Words292470
Node: Sentences295430
Node: Paragraphs297642
Node: Pages299963
Node: Filling302576
Node: Auto Fill303355
Node: Fill Commands305492
Node: Fill Prefix307628
Node: Case309810
Node: Programs311848
Node: Program Modes314413
Node: Lists316618
Node: Defuns322320
Node: Grinding324938
Node: Basic Indent325551
Node: Multi-line Indent327560
Node: Lisp Indent329190
Node: C Indent332572
Node: Matching337718
Node: Comments339289
Node: Macro Expansion345804
Node: Balanced Editing346355
Node: Lisp Completion347379
Node: Documentation348388
Node: Change Log349635
Node: Tags352485
Node: Tag Syntax353812
Node: Create Tag Table354506
Node: Select Tag Table356099
Node: Find Tag356939
Node: Tags Search359259
Node: Tags Stepping361545
Node: List Tags362115
Node: Fortran363134
Node: Fortran Motion364194
Node: Fortran Indent364997
Node: ForIndent Commands365677
Node: ForIndent Num366804
Node: ForIndent Conv368075
Node: ForIndent Vars368860
Node: Fortran Comments369999
Node: Fortran Columns373630
Node: Fortran Abbrev375047
Node: Compiling/Testing375959
Node: Compilation376932
Node: Lisp Modes381893
Node: Lisp Libraries383152
Node: Loading383714
Node: Compiling Libraries386598
Node: Mocklisp388500
Node: Lisp Eval389179
Node: Lisp Debug392809
Node: Lisp Interaction398298
Node: External Lisp399664
Node: Abbrevs401750
Node: Defining Abbrevs403968
Node: Expanding Abbrevs406380
Node: Editing Abbrevs409178
Node: Saving Abbrevs411053
Node: Dynamic Abbrevs413016
Node: Picture414332
Node: Basic Picture416763
Node: Insert in Picture419063
Node: Tabs in Picture420477
Node: Rectangles in Picture421985
Node: Sending Mail423727
Node: Mail Format425626
Node: Mail Headers426958
Node: Mail Mode430251
Node: Rmail433950
Node: Rmail Scrolling436976
Node: Rmail Motion437967
Node: Rmail Deletion441295
Node: Rmail Inbox444068
Node: Rmail Files446239
Node: Rmail Output448789
Node: Rmail Labels451173
Node: Rmail Summary454708
Node: Rmail Make Summary455671
Node: Rmail Summary Edit457096
Node: Rmail Reply460460
Node: Rmail Editing463555
Node: Rmail Digest465865
Node: Recursive Edit466933
Node: Narrowing470007
Node: Sorting472014
Node: Shell477102
Node: Single Shell478018
Node: Interactive Shell479601
Node: Shell Mode482620
Node: Hardcopy484408
Node: Dissociated Press485453
Node: Amusements488012
Node: Emulation488498
Node: Customization491221
Node: Minor Modes492683
Node: Variables494336
Node: Examining496317
Node: Edit Options497759
Node: Locals499365
Node: File Variables502401
Node: Keyboard Macros506234
Node: Basic Kbd Macro508421
Node: Save Kbd Macro510663
Node: Kbd Macro Query512324
Node: Key Bindings514243
Node: Keymaps515103
Node: Rebinding519723
Node: Disabling521940
Node: Syntax523734
Node: Syntax Entry524604
Node: Syntax Change528757
Node: Init File530947
Node: Init Syntax532243
Node: Init Examples534364
Node: Terminal Init538264
Node: Debugging Init539994
Node: Quitting540700
Node: Lossage543671
Node: Stuck Recursive544303
Node: Screen Garbled545003
Node: Text Garbled546113
Node: Unasked-for Search546742
Node: Emergency Escape547519
Node: Total Frustration549271
Node: Bugs549890
Node: Version 19559029
Node: Basic Changes561292
Node: New Facilities564717
Node: Binding Changes567776
Node: Changed Commands571408
Node: M-x Changes573788
Node: New Commands576105
Node: Search Changes580453
Node: Filling Changes581913
Node: TeX Mode Changes583214
Node: Shell Changes584536
Node: Spell Changes588181
Node: Mail Changes589841
Node: Tags Changes592552
Node: Info Changes594453
Node: Dired Changes595940
Node: Marks in Dired597105
Node: Multiple Files598949
Node: Shell Commands in Dired601846
Node: Dired Regexps603444
Node: Dired Case Conversion605867
Node: Comparison in Dired606273
Node: Subdirectories in Dired607019
Node: Hiding Subdirectories608966
Node: Editing Dired Buffer610085
Node: Dired and Find611418
Node: GNUS612640
Node: Buffers of GNUS613413
Node: GNUS Startup614424
Node: Summary of GNUS615321
Node: Calendar/Diary618790
Node: Calendar619976
Node: Diary Entries622461
Node: Displaying Diary623856
Node: New Entries624932
Node: European Calendar Style627760
Node: Simple and Fancy628435
Node: Other Diary Features629321
Node: Startup Diary630467
Node: Printing Diary630963
Node: Version Control631771
Node: Concepts of VC632857
Node: Editing with VC634136
Node: Variables for Check-in/out638545
Node: Log Entries640198
Node: Change Logs and VC641494
Node: Comparing Versions644881
Node: VC Status646117
Node: Renaming and VC647150
Node: Snapshots647915
Node: Making Snapshots648407
Node: Snapshot Caveats649966
Node: Version Headers651790
Node: Emerge654041
Node: Overview of Emerge654532
Node: Submodes of Emerge657429
Node: State of Difference659006
Node: Merge Commands661545
Node: Exiting Emerge664130
Node: Combining in Emerge664814
Node: Fine Points of Emerge665594
Node: Debuggers666535
Node: Starting GUD667156
Node: Debugger Operation668114
Node: Commands of GUD669262
Node: GUD Customization671301
Node: Other New Modes673219
Node: Asm Mode674326
Node: Edebug Mode674783
Node: Editing Binary Files675522
Node: Key Sequence Changes676650
Node: Hook Changes680636
Node: Manifesto682481
Node: Glossary705950
Node: Key Index737070
Node: Command Index764426
Node: Variable Index802648
Node: Concept Index813653

End Tag Table

1007
info/emacs-1 Normal file
View file

File diff suppressed because it is too large Load diff

1131
info/emacs-10 Normal file
View file

File diff suppressed because it is too large Load diff

1173
info/emacs-11 Normal file
View file

File diff suppressed because it is too large Load diff

Some files were not shown because too many files have changed in this diff Show more