    This is ispell version 3.2, an interactive spelling checker.

Contents of this README file:

    What Is Ispell and Why Do I Want It?
    What's New in This Version?
    Where Can I Get Ispell?
    OK, How Do I Install It?
    Who Wrote Ispell?
    Where Do I Send Bug Reports?
    How Do I Reference Ispell in Scholarly Papers?
    Where Do I Get Dictionaries?
    How Long Does It Take to Make Dictionaries?
    Special Installation Notes for Certain Machines:
    What About Ispell for MS-DOS?

Note: this README file might not contain the latest information about
ispell.  For that information, visit the ispell Web page:

	http://fmg-www.cs.ucla.edu/geoff/ispell.html

------------------------------------------------------------------------

What Is Ispell and Why Do I Want It?

    Ispell is a fast screen-oriented spelling checker that shows you
    your errors in the context of the original file, and suggests possible
    corrections when it can figure them out.  Compared to UNIX spell, it
    is faster and much easier to use.  Ispell can also handle languages
    other than English.
    
What's New in This Version?

    Ispell 3.2 is primarily a bug-fix release, but a number of new
    features are important to users:

    -	There is a new interactive mode.  If ispell is invoked without
	arguments, it will prompt for words and suggest corrections.
    -	The emacs interface (ispell.el and ispell.texinfo) is no
	longer distributed with ispell.  Use the code that comes with
	emacs, or pick it up from:
	    ftp://kdstevens.com/pub/stevens/ispell.el.gz
	or the matching ispell.el home page:
	    http://www.kdstevens.com/~stevens/ispell-page.html
    -	There is now an HTML mode.  It is automatically selected for
	files ending in ".html", ".htm", or ".shtml".  It can also be
	chosen manually with the -H switch.
    -	There is a new general-purpose deformatter switch, -F.  This
	switch, which was suggested by Ron Guilmette, allows an
	external program to perform deformatting for ispell.  The -F
	switch opens the door to completely generalized spell checking
	with ispell.  Want to spell-check your C/C++ comments?  A
	simple deformatter filter will do the job.  See the ispell
	manual page for details.
    -	The annoying "TeX backslash bug" is now fixed correctly.
    -	TeX/LaTeX deformatting is now somewhat configurable.  Check
	out the -k switch and TEXSKIP1 in the manual page.
    -	Ispell will no longer be distributed in shar form, and new
	versions will be given as gzipped tar files rather than as
	patches.

Where Can I Get Ispell?

    If you have a Web browser, visit the ispell home page:

	http://fmg-www.cs.ucla.edu/geoff/ispell.html

    The current version of ispell is available for anonymous ftp from
    ftp.cs.ucla.edu (131.179.240.10) in the pub/ispell-3.2 directory.
    The latest version is always named "ispell-3.2.xx.tar.gz", where
    "xx" is the patch level.  There are also sometimes files named
    "README-patchxx" which contain notes specific to a given version.

    A number of ftp mirror sites also store ispell.  Check your
    favorite search engine for "ispell-3.2" to find a site near you.
    
    Ispell comes with English dictionaries.  For other languages,
    visit the ispell dictionaries Web page at:

	http://fmg-www.cs.ucla.edu/geoff/ispell-dictionaries.html

OK, How Do I Install It?

    Ispell is quite portable (thanks to many people).  If you speak
    American English and have a BSD-like system, you may be able to
    get away with simply typing "make all" to make ispell and a
    dictionary, all configured to be installed in /usr/local/*.  If
    you have a USG (System V) system (such as Linux, IRIX, or HP-UX),
    you will at least have to copy "local.h.samp" to "local.h", then
    add "#define USG" to local.h before compiling.  Be sure you have
    at least 10 MB of free space in /tmp, or set your TMPDIR
    environment variable to point somewhere with that much space.

    For more complex installations, you will have to create a fancier
    local.h file.  All customization of ispell, even for the
    Makefile, is done by creating or editing the file "local.h" to
    override the default definitions of certain variables.  The most
    common changes will be to the LANGUAGES variable (to set the
    languages; see also the Makefiles in the various language
    subdirectories), CC (to choose gcc), and BINDIR through MAN4DIR
    (to control where ispell is installed).  There are many other
    configuration parameters; see config.X for the complete list and
    further instructions.  *DO NOT* make changes to config.X or to any
    of the Makefiles.  Anything you define in "local.h" will override
    definitions in those files.

    The English-language dictionary comes in four sizes: small,
    medium, large, and extra-large.  I recommend using the medium
    dictionary unless you are very short on space.  The small and
    medium dictionaries have been hand-checked against a paper
    dictionary to improve their accuracy.  This is not true of the two
    larger ones.  The large and extra-large dictionaries contain
    less-frequently-used words, and most sites will not want to pay
    the price of storing them, especially because they may contain
    errors.  Also, a large dictionary can hide misspellings of short
    words because there is some similar word that nobody uses.  (For
    example, the crossword-puzzle favorite "ort" can hide misspellings
    of "or".)

    For each dictionary size, you can also choose to make a "plus"
    version, named by adding a plus sign to the size indication.
    These versions are created by incorporating a dictionary file of
    your own, usually /usr/dict/words.  (I can't distribute a
    dictionary based on that file because it's copyrighted.)  Making a
    plus version requires extra time and disk space, but will give you
    some computer and technical terms that aren't in the basic ispell
    word list.  However, since /usr/dict/words isn't available on many
    modern computers, the default dictionary is the "non-plus"
    version.

    After all edits, you are ready to compile ispell.  Make sure you
    have set your TMPDIR environment variable, and then type
    "make all".  This will compile all the programs, put the
    dictionaries together, and build the hash file.  If you get errors
    while compiling term.c, change the setting of "#define USG" in
    your local.h file and try again.

    If you chose a "+" version of the dictionary (the LANGUAGES macro
    in config.X), expect this first make to run for quite a while
    (usually about half an hour, but as much as 24 hours on a very
    limited machine) because of the munchlist step.  If you chose a
    non-plus version, the make will not take long.  Building a plus
    version will also take a *lot* of disk space (see the table below
    for more information), so be sure to set TMPDIR in your
    environment to point to someplace with lots of room.

    After your first make completes, you are ready to install ispell.
    The standard "make install" will install ispell, the auxiliary
    programs and scripts, the manual page, and the dictionary hash
    file, all in the directories you have chosen for them.  This
    usually has to be done as root, and on some systems you will not
    be able to redirect the output to a file.  (If you're the careful
    sort, you'll check the output of "make -n install" first to be
    sure there are no hidden surprises.)  If you don't want to install
    the dictionary-building tools, you can type "make partial-install"
    to install just the files needed to use ispell itself.

    As well as the standard "make clean" and "make realclean" targets,
    there is also a "make dictclean" target which will get rid of
    constructed dictionary files such as "english.med+".  This is a
    separate target because of the time it takes to build
    dictionaries.

    Finally, there is a directory named "addons", which contains shar
    kits for ispell helper programs that were generously written by
    other people.  These are not copyrighted or supported by the
    ispell maintainer.  Contact the original authors (listed in README
    files in the kits) for more information.

Who Wrote Ispell?

    Ispell is a very old program.  The original was written in PDP-10
    assembly in 1971, by R. E. Gorin.  The C version was written by
    Pace Willisson of MIT.  Walt Buehring of Texas Instruments added
    the emacs interface and posted it to the net.  Geoff Kuenning
    added the international support and created the current release.
    Many, many other people contributed to the current version; a
    complete list (with a much more detailed history) can be found in
    the file "Contributors".

Where Do I Send Bug Reports?

    Most ispell bug reports, except bugs related to the emacs-lisp
    interface, should be sent to "ispell-bugs@itcorp.com".  Bugs in
    the emacs interface (ispell.el) should be sent to
    "ispell-el-bugs@itcorp.com".  If you're not sure which address to
    use, send your report to "ispell-bugs@itcorp.com" and I'll sort it
    out from there.  Note that the bugs aliases are not discussion
    lists; membership is limited.

    Bugs in add-on packages (found in the "addons" subdirectory)
    should not be sent to itcorp.com.  Instead, send reports to the
    developers of those packages (see the README file for the package
    you are using).

How Do I Reference Ispell in Scholarly Papers?

    There is no published paper on ispell, so if you make use of
    ispell in a fashion that requires a reference (e.g., using the
    dictionary as a word list in a research project), you are limited
    to an Internet reference.  The full proper title is printed by
    "ispell -v": "International Ispell Version x.y.z".  Please include
    the full version number in your reference so that people can
    discover the exact variant that you used; sometimes it's
    important.  If you're feeling really nice, you can also credit me,
    Geoffrey H. Kuenning, as the author.  Usually, you should also
    include a mention of either the ispell Web page
    (http://fmg-www.cs.ucla.edu/geoff/ispell.html) or the master ftp
    site (ftp.cs.ucla.edu) so that readers of your paper can locate a
    copy if they wish.

Where Do I Get Dictionaries?

    Ispell comes with American and British dictionaries. American-style
    spellings are the default.  To get British spellings, copy the
    LANGUAGES and MASTERHASH definitions from config.X into your
    local.h, and then globally replace "american" with "british".

    For other languages, consult the file "languages/Where", which
    lists everything I know about.  You can also check the ispell
    dictionaries page:

	http://fmg-www.cs.ucla.edu/geoff/ispell-dictionaries.html

    which contains pointers to all known dictionaries.

    As a general rule, if you use a dictionary that was not intended
    for ispell, or if you combine multiple dictionaries, you should
    use munchlist to reduce the size of the dictionary.

    If you create a dictionary of your own and make it available for
    ftp, please send a notification to ispell-bugs@itcorp.com so that
    I can add your dictionary to the ftp list.

How Long Does It Take to Make Dictionaries?

    The following tables give approximate timings and peak disk usage
    for making each of the three augmented English dictionaries (the
    so-called "plus" versions).  The timings were collected on an
    unloaded 68040.  Your mileage may vary.

    Using 'EXTRADICT=/usr/dict/words':

			Time to build	Peak temp space	Final size

	english.sml+	30 minutes	7.1M		306K
	english.med+	35 minutes	8.8M		359K
	english.lrg+	60 minutes	10.7M		680K

    Using 'EXTRADICT=/usr/dict/words /usr/dict/web2':

			Time to build	Peak temp space	Final size

	english.sml+	2-1/2 hours	19.5M		2243K
	english.med+	2-1/2 hours	19.6M		2265K
	english.lrg+	3 hours		20.7M		2347K

    The peak disk usage occurs fairly early in the munching process.
    When creating english.lrg+ with /usr/dict/web2, the peak was
    reached within 30 minutes.  When web2 was omitted, the peak was
    always reached within 1/4 of the total running time of munchlist.
    Again, remember that these times will vary depending on your load
    and your machine's power.

Special Installation Notes for Certain Machines:

    Although I have tried to avoid putting in specific machine
    dependencies as a general rule, some machine-specific #defines
    will be found at the end of config.X.

    If you get lots of warnings when compiling term.c, check to be
    sure that you have correctly defined SIGNAL_TYPE in your local.h.

    Some versions of ISC Unix have TIOCGWINSZ defined even though it's
    not supported and the necessary structures are not present.  The
    solution is to add "#undef TIOCGWINSZ" in your local.h.

    Under ISC (Solaris) Unix System V.3, you may have to add includes
    of <sys/stream.h> and <sys/ptem.h> to your local.h to get around
    compilation problems in term.c.

    Some versions of SCO Unix define "struct winsize" conditionally.
    The solution is to add "#define _IBCS2" in your local.h.

    Some versions of SCO Unix define "struct winsize" in a weird
    place.  Add #includes of <sys/stream.h> and <sys/ptem.h> to your
    local.h to get around this.

    Suns running 4.1.1 also have a bug in sort which causes core dumps
    when running munchlist.  Sun users who have the System 5 option
    can work around this bug by making sure that /usr/5bin precedes
    /usr/bin in their path, so that /usr/5bin/sort is used by
    munchlist.

    It is reported that some older versions of gnu sort do not
    recognize the -T option.  (However, as of textutils 1.9 it does.)
    Define SORTTMP and MAKE_SORTTMP as the null string ("") if you use
    gnu sort, or change your path to use the manufacturer's sort
    command (but watch out for Sun's sort bug, above!).

    Some versions of gcc for the Sparc have an optimizer bug that
    causes problems for languages that use 8-bit characters.  The
    solution is to turn off optimization when compiling at least
    makedent.c, or for all of ispell.  The bug is known to exist in
    gcc 2.4.5, and is known to have been fixed in gcc 2.5.8.

    There is a report that on Solaris 2.3 for the sparc, buildhash may
    core dump.  The cure is to use "bison -y" instead of yacc.

    On SunOS 4.1.3 using Sun's SPARCompiler C2.0.1, you may have to
    select static linking (-Bstatic option in CFLAGS).

    The AIX RS6000 should use -lcurses for TERMLIB, rather than -ltermcap.

    Amiga users will need to #define fork vfork.  Other than this,
    ispell should compile using gcc on the Amiga.

    There have been reports that some BSD releases don't properly
    declare "extern int errno" in errno.h.  If you suffer from this
    problem, you'll have to add your own declaration in your local.h.

    There are known problems on Ultrix with the interaction between
    ispell and some versions of elm on Ultrix.  You may be able to fix
    this by making sure USG is undefined, or you may have to make more
    extensive changes to term.c to cause it to use the "termios"
    interface instead of the "termio" one.

    The DEC Alpha and Cray have 64-bit longs.  Make sure you define
    MASKTYPE_WIDTH as 64 for these machines.

    Some versions of the DEC Alpha compiler may compile ispell
    incorrectly.  The cure is to turn optimization off and compile
    with the -g switch.  The symptoms are segmentation faults and
    garbage characters in the ~/.ispell_english file.  If you get this
    symptom, be sure to clean out the garbage before you rerun ispell
    or recompiling won't help.

    Some versions of "uniq" on the DEC Alpha, OSF/1 2.x, generate
    garbage output if given null input, causing munchlist to loop
    forever.  This can by checked by running "uniq < /dev/null | wc
    -c", which ought print zero.  If it does not, you'll have to use
    GNU uniq (from textutils/1.11) instead, or upgrade to OSF/1 3.0
    which does not have the bug.

    DEC OSF/1 keeps the extra dictionary in a wierd place.  Set
    EXTRADICT to /usr/share/dict/words.

    HP systems will need C compiler patch PHSS_3015 to compile ispell
    correctly, bringing the revision to A.09.34 or higher.  The
    symptom of the wrong compiler is incorrect highlighting of
    misspelled words.  Gcc will also compile ispell correctly on HP
    systems.
    
    Some "internationalized" Unixes (HP, for instance) vary the
    behavior of sort(1) based on an environment variable such as LANG
    or LOCALE.  The symptom is that munchlist does not produce an
    optimal dictionary.  Munchlist tries to protect against this by
    setting LANG and LOCALE to "C", but if your system uses different
    environment variables, you may have to do this by hand.

    If you get core dumps from the sort command (reported on HP
    systems building large German dictionaries), try adding the "-y"
    flag to the appropriate invocation of sort in the Makefile or in
    munchlist.  This flag is only available on some systems.

    SGI Irix systems store /usr/dict/words in /usr/lib/dict or
    /usr/share/lib/dict.  You may have to install the normal "spell"
    and associated files from cd-rom before it will exist.  If you get
    errors compiling with Irix 4.0.5 or others, try defining __STDC__
    in local.h, to get around problems caused by the fact that the
    compiler accepts prototypes but doesn't define __STDC__.

    Some SGI Irix systems have bad utilities that cause munchlist to
    loop forever.  If you get more than 4 passes of "Creating cross
    expansions", you probably have a bad version of sed.  Install the
    GNU version of sed to cure this problem.

    Some BSDI systems have a screwy sort command that uses
    -T to specify the record (as opposed to field) delimiter.  You'll
    have to disable SORTTMP and enable MAKE_SORTTMP.  You'll also have
    to be sure that /usr/tmp has lots and lots of free space.

What About Ispell for MS-DOS?

    Although ispell is not officially supported on MS-DOS, there are a
    couple of #defines that you might find useful if you want to do
    such a thing.  Check the end of config.X.  Several people have
    reported success building DOS versions using emx/gcc.  Others have
    used the djgpp package, with bison replacing yacc.  Some places to
    look for a DOS ispell if you have an x86:

	ftp.cdrom.com:pub/os2/unix/isp3009b.zip.
	or
	ftp-os2.cdrom.com:pub/os2/2_x/unix/

    There is also a program named jspell, which is an ispell
    lookalike.  Look on ftp.tex.ac.uk, in the directory
    pub/archive/support/jspell.
