man > ispell(1)

TLDR: ispell (tldr-pages)

Interactive spell checking.

  • Start an interactive session
    ispell
  • Check for typos in the specified file and interactively apply suggestions
    ispell {{path/to/file}}
  • Display version
    ispell -v
ISPELL(1)                              General Commands Manual                             ISPELL(1)

NAME
       ispell,  buildhash,  munchlist,  findaffix,  tryaffix, icombine, ijoin - Interactive spelling
       checking

SYNOPSIS
       ispell [common-flags] [-M|-N] [-Lcontext] [-V] files
       ispell [common-flags] -l
       ispell [common-flags] [-f file] [-s] [-a|-A]
       ispell [-d file] [-w chars] -c
       ispell [-d file] [-w chars] -e[e]
       ispell [-d file] -D
       ispell -v[v]

       common-flags:
              [-t] [-n] [-H] [-o] [-b] [-x] [-B] [-C] [-P] [-m] [-S] [-d file] [-p file] [-w  chars]
              [-W n] [-T type] [-kname list] [-F program]

       Helper programs:

       buildhash [-s] dict-file affix-file hash-file
       buildhash -s count affix-file

       munchlist [-l aff-file] [-c conv-file] [-T suffix]
                 [-s hash-file] [-D] [-v] [-w chars] [files]

       findaffix [-p|-s] [-f] [-c] [-m min] [-M max] [-e elim]
                 [-t tabchar] [-l low] [files]

       tryaffix [-p|-s] [-c] expanded-file affix[+addition] ...

       icombine [-T type] [-w chars] [aff-file]

       ijoin [-s|-u] join-options file1 file2

DESCRIPTION
       Ispell  is fashioned after the spell program from ITS (called ispell on Twenex systems.)  The
       most common usage is "ispell filename".  In this case, ispell will display  each  word  which
       does  not  appear  in the dictionary at the top of the screen and allow you to change it.  If
       there are "near misses" in the dictionary (words which differ by  only  a  single  letter,  a
       missing  or  extra  letter, a pair of transposed letters, or a missing space or hyphen), then
       they are also displayed on following lines.  As well as "near  misses",  ispell  may  display
       other  guesses  at ways to make the word from a known root, with each guess preceded by ques‐
       tion marks.  Finally, the line containing the word and the previous line are printed  at  the
       bottom  of  the  screen.   If  your terminal can display in reverse video, the word itself is
       highlighted.  You have the option of replacing the word completely, or choosing  one  of  the
       suggested words.  Commands are single characters as follows (case is ignored):

              R      Replace the misspelled word completely.

              Space  Accept the word this time only.

              A      Accept the word for the rest of this ispell session.

              I      Accept  the  word, capitalized as it is in the file, and update private dictio‐
                     nary.

              U      Accept the word, and add an uncapitalized (actually, all lower-case) version to
                     the private dictionary.

              0–n    Replace with one of the suggested words.

              L      Look up words in system dictionary (controlled by  the  WORDS  compilation  op‐
                     tion).

              X      Write the rest of this file, ignoring misspellings, and start next file.

              Q      Exit immediately and leave the file unchanged.

              !      Shell escape.

              ^L     Redraw screen.

              ^Z     Suspend ispell.

              ?      Give help screen.

       If  the  -M switch is specified, a one-line mini-menu at the bottom of the screen will summa‐
       rize these options.  Conversely, the -N switch may be used to suppress the  mini-menu.   (The
       minimenu  is  displayed by default if ispell was compiled with the MINIMENU option, but these
       two switches will always override the default).

       If the -L flag is given, the specified number is used as the number of lines of context to be
       shown at the bottom of the screen (The default is to calculate the amount  of  context  as  a
       certain percentage of the screen size).  The amount of context is subject to a system-imposed
       limit.

       If  the  -V  flag is given, characters that are not in the 7-bit ANSI printable character set
       will always be displayed in the style of "cat -v", even if ispell thinks that  these  charac‐
       ters are valid ISO Latin-1 on your system.  This is useful when working with older terminals.
       Without  this  switch, ispell will display 8-bit characters "as is" if they have been defined
       as string characters for the chosen file type.

       "Normal" mode, as well as the -l, -a, and -A options and interactive mode  (see  below)  also
       accepts the following "common" flags on the command line:

              -t     The input file is in TeX or LaTeX format.

              -n     The input file is in nroff/troff format.

              -H     The input file is in SGML/HTML format.  (This should really be -s, but for his‐
                     torical reasons that flag was already taken.)

              -o     The  input  file  should  be  treated as ordinary text.  (This could be used to
                     override DEFTEXFLAG.)

              -g     The input file is in Debian control file format.  Ispell will ignore everything
                     outside the Description(s).

              -b     Create a backup file by appending ".bak" to the name of the input file.

              -x     Delete the backup file after spell-checking is finished.

              -B     Report run-together words with missing blanks as spelling errors.

              -C     Consider run-together words as valid compounds.

              -P     Don't generate extra root/affix combinations.

              -m     Make possible root/affix combinations that aren't in the dictionary.

              -S     Sort the list of guesses by probable correctness.

              -d file
                     Specify an alternate dictionary file.  For example, use -d  british  to  choose
                     /usr/lib/ispell/british.{aff|hash} instead of your default ispell dictionary.

              -p file
                     Specify an alternate personal dictionary.

              -w chars
                     Specify additional characters that can be part of a word.

              -W n   Specify length of words that are always valid.

              -T type
                     Assume a given formatter type for all files.

       The  -H,  -n,  -t,  and -o options select whether ispell runs in HTML (-H), nroff/troff (-n),
       TeX/LaTeX (-t), or ordinary text (-o) input mode.  mode.  (The default mode is controlled  by
       the DEFTEXFLAG installation option, but is normally nroff/troff mode for historical reasons.)
       Unless  overridden by one of the mode-selection switches, TeX/LaTeX mode is automatically se‐
       lected if an input file has the extension ".tex", and HTML mode is automatically selected  if
       an input file has the extension ".html" or ".htm".

       In  HTML  mode, HTML tags delimited by <> signs are skipped, except that the "ALT=" construct
       is recognized if it appears with no spaces around the equals sign, and  the  text  inside  is
       spell-checked.

       In  TeX/LaTeX  mode, whenever a backslash ("\") is found, ispell will skip to the next white‐
       space or TeX/LaTeX delimiter.   Certain  commands  contain  arguments  which  should  not  be
       checked, such as labels and reference keys as are found in the \cite command, since they con‐
       tain  arbitrary,  non-word  arguments.   Spell checking is also suppressed when in math mode.
       Thus, for example, given

              \chapter {This is a Ckapter} \cite{SCH86}

       ispell will find "Ckapter" but not "SCH".  The -t option does not recognize the  TeX  comment
       character  "%",  so  comments  are also spell-checked.  It also assumes correct LaTeX syntax.
       Arguments to infrequently used commands and some optional arguments are sometimes checked un‐
       necessarily.  The bibliography will not be checked if ispell was compiled with IGNOREBIB  de‐
       fined.  Otherwise, the bibliography will be checked but the reference key will not.

       References  for the tib (if available on your system), bibliography system, that is, text be‐
       tween a ``[.'' or ``<.'' and ``.]'' or ``.>'' will always be ignored in TeX/LaTeX mode.

       The -b and -x options control whether ispell leaves a backup (.bak) file for each input file.
       The .bak file contains the pre-corrected text.  If there are file opening or writing  errors,
       the  .bak  file  may  be left for recovery purposes even with the -x option.  The default for
       this option is controlled by the DEFNOBACKUPFLAG installation option.

       The -B and -C options control how ispell handles run-together words,  such  as  "notthe"  for
       "not the".  If -B is specified, such words will be considered as errors, and ispell will list
       variations  with  an  inserted blank or hyphen as possible replacements.  If -C is specified,
       run-together words will be considered to be valid compounds, so long as both  components  are
       in  the dictionary, and each component is at least as long as a language-dependent minimum (3
       characters, by default).  This is useful for languages such as German  and  Norwegian,  where
       many  compound  words are formed by concatenation.  (Note that compounds formed from three or
       more root words will still be considered errors).  The default for this option  is  language-
       dependent; in a multi-lingual installation the default may vary depending on which dictionary
       you choose.  Warning: the -C option can cause ispell to recognize non-words and misspellings.
       Use it with caution!

       The -P and -m options control when ispell automatically generates suggested root/affix combi‐
       nations  for  possible  addition  to your personal dictionary.  (These are the entries in the
       "guess" list which are preceded by question marks.)  If -P is  specified,  such  guesses  are
       displayed only if ispell cannot generate any possibilities that match the current dictionary.
       If  -m is specified, such guesses are always displayed.  This can be useful if the dictionary
       has a limited word list, or a word list with few suffixes.  However, you  should  be  careful
       when  using  this option, as it can generate guesses that produce invalid words.  The default
       for this option is controlled by the dictionary file used.

       The -S option suppresses ispell's normal behavior of sorting the list of possible replacement
       words.  Some people may prefer this, since it somewhat enhances the probability that the cor‐
       rect word will be low-numbered.

       The -d option is used to specify an alternate hashed dictionary file, other than the default.
       If the filename does not contain a "/", the library directory for the default dictionary file
       is prefixed; thus, to use a dictionary in the local directory "-d ./xxx.hash" must  be  used.
       This  is  useful  to allow dictionaries for alternate languages.  Unlike previous versions of
       ispell, a dictionary of /dev/null is invalid, because the dictionary contains the  affix  ta‐
       ble.   If  you need an effectively empty dictionary, create a one-entry list with an unlikely
       string (e.g., "qqqqq").

       The -p option is used to specify an alternate personal dictionary file.   If  the  file  name
       does  not  begin  with "/", $HOME is prefixed.  Also, the shell variable WORDLIST may be set,
       which renames the personal dictionary in the same manner.  The  command  line  overrides  any
       WORDLIST  setting.   If neither the -p switch nor the WORDLIST environment variable is given,
       ispell will search for a personal dictionary in both the current directory and $HOME,  creat‐
       ing one in $HOME if none is found.  The preferred name is constructed by appending ".ispell_"
       to the base name of the hash file.  For example, if you use the English dictionary, your per‐
       sonal  dictionary would be named ".ispell_english".  However, if the file ".ispell_words" ex‐
       ists, it will be used as the personal dictionary regardless of the language hash file chosen.
       This feature is included primarily for backwards compatibility.

       If the -p option is not specified, ispell will look for personal  dictionaries  in  both  the
       current directory and the home directory.  If dictionaries exist in both places, they will be
       merged.   If any words are added to the personal dictionary, they will be written to the cur‐
       rent directory if a dictionary already existed in that place; otherwise they will be  written
       to the dictionary in the home directory.

       The  -w option may be used to specify characters other than alphabetics which may also appear
       in words.  For instance, -w "&" will allow "AT&T" to be picked up.  Underscores are useful in
       many technical documents.  There is an admittedly crude provision in this  option  for  8-bit
       international  characters.   Non-printing characters may be specified in the usual way by in‐
       serting a backslash followed by the octal character code; e.g., "\014" for a form feed.   Al‐
       ternatively,  if  "n" appears in the character string, the (up to) three characters following
       are a DECIMAL code 0–255, for the character.  For example, to include bells and form feeds in
       your words (an admittedly silly thing to do, but aren't most pedagogical examples):

              n007n012

       Numeric digits other than the three following "n" are simply numeric characters.  Use of  "n"
       does  not conflict with anything because actual alphabetics have no meaning - alphabetics are
       already accepted.  Ispell will typically be used with input from a file,  meaning  that  pre‐
       serving  parity  for possible 8 bit characters from the input text is OK.  If you specify the
       -l option, and actually type text from the terminal, this may create problems  if  your  stty
       settings preserve parity.

       It is not possible to use -w with certain characters.  In particular, the flag-marker charac‐
       ter  for  the  language (defined in the affix file, but usually "/") can never be made into a
       word character.

       The -W option may be used to change the length of words that ispell always accepts as  valid.
       Normally,  ispell will accept all 1-character words as valid, which is equivalent to specify‐
       ing "-W 1."  (The default for this switch is actually controlled by the MINWORD  installation
       option,  so  it  may vary at your installation.)  If you want all words to be checked against
       the dictionary, regardless of length, you might want to specify "-W 0".  On the  other  hand,
       if your document specifies a lot of three-letter acronyms, you would specify "-W 3" to accept
       all  words  of  three letters or less.  Regardless of the setting of this option, ispell will
       only generate words that are in the dictionary as suggested replacements for words; this pre‐
       vents the list from becoming too long.  Obviously, this option can be very  dangerous,  since
       short  misspellings  may be missed.  If you use this option a lot, you should probably make a
       last pass without it before you publish your document, to protect yourself against errors.

       The -T option is used to specify a default formatter type for use in generating string  char‐
       acters.   This switch overrides the default type determined from the file name.  The type ar‐
       gument may be either one of the unique names defined in the language affix file (e.g., nroff)
       or a file suffix including the dot (e.g., .tex).  If no -T option appears and no type can  be
       determined from the file name, the default string character type declared in the language af‐
       fix file will be used.

       The  -k  option  is used to enhance the behavior of certain deformatters.  The name parameter
       gives the name of a deformatter keyword set (see below), and the list parameter gives a  list
       of  one  or  more  keywords that are to be treated specially.  If list begins with a plus (+)
       sign, it is added to the existing keywords; otherwise it replaces the existing keyword  list.
       For  example,  -ktexskip1 +bibliographystyle adds "bibliographystyle" to the TeX skip-1 list,
       while -khtmlignore pre,strong replaces the HTML ignore list with  "pre"  and  "strong".   The
       lists available are:

       texskip1
              TeX/LaTeX  commands that take a single argument that should not be spell-checked, such
              as "bibliographystyle".  The default is  "end",  "vspace",  "hspace",  "cite",  "ref",
              "parbox", "label", "input", "nocite", "include", "includeonly", "documentstyle", "doc‐
              umentclass",  "usepackage",  "selectlanguage",  "pagestyle", "pagenumbering", "hyphen‐
              ation", "pageref", and "psfig", plus "bibliography" in some installations.  These key‐
              words are case-sensitive.

       texskip2
              TeX/LaTeX commands that take two arguments that should not be spell-checked,  such  as
              "setlength".   The  default is "rule", "setcounter", "addtocounter", "setlength", "ad‐
              dtolength", and "settowidth".  These keywords are case-sensitive.

       htmlignore
              HTML tags that delimit text that should not be spell-checked until  the  matching  end
              tag  is  reached.   The  default  is "code", "samp", "kbd", "pre", "listing", and "ad‐
              dress".  These keywords are case-insensitive.  (Note  that  the  content  inside  HTML
              tags, such as HREF=, is not normally checked.)

       htmlcheck
              Subfields  that  should be spell-checked even inside HTML tags.  The default is "alt",
              so that the ALT= portion of IMG tags will be spell-checked.  These keywords are  case-
              insensitive.

       All  of the above keyword lists can also be modified by environment variables whose names are
       the same as above, except in uppercase, e.g., TEXSKIP1.  The -k switch overrides (or adds to)
       the environment variables, and the environment variables override or add to the built-in  de‐
       faults.

       The  -F switch specifies an external deformatter program.  This program should read data from
       its standard input and write to its standard output.  The program must  produce  exactly  one
       character of output for each character of input, or ispell will lose synchronization and cor‐
       rupt  the  output  file.   Whitespace  characters (especially blanks, tabs, and newlines) and
       characters that should be spell-checked should be passed through unchanged.  Characters  that
       should  not  be  spell-checked  should be converted into blanks or other non-word characters.
       For example, an HTML deformatter might turn all HTML tags into blanks, and also blank out all
       text delimited by tags such as "code" or "kbd".

       The -F switch is the preferred way to deformat files for ispell, and eventually  will  become
       the only way.

       If  ispell  is  invoked without any filenames or mode switches, it enters an interactive mode
       designed to let the user check the spelling of  individual  words.   The  program  repeatedly
       prompts  on standard output with "word:" and responds with either "ok" (possibly with commen‐
       tary), "not found", or "how about" followed by a list of suggestions.

       The -l or "list" option to ispell is used to produce a list  of  misspelled  words  from  the
       standard input.

       The  -a  option is intended to be used from other programs through a pipe.  In this mode, is‐
       pell prints a one-line version identification message, and then begins reading lines  of  in‐
       put.   For  each  input  line,  a single line is written to the standard output for each word
       checked for spelling on the line.  If the word was found in the main dictionary, or your per‐
       sonal dictionary, then the line contains only a '*'.  If the word was found through affix re‐
       moval, then the line contains a '+', a space, and the root  word.   If  the  word  was  found
       through  compound  formation  (concatenation of two words, controlled by the -C option), then
       the line contains only a '-'.

       If the word is not in the dictionary, but there are near misses, then the  line  contains  an
       '&',  a space, the misspelled word, a space, the number of near misses, the number of charac‐
       ters between the beginning of the line and the beginning of the misspelled word, a colon, an‐
       other space, and a list of the near misses separated by commas  and  spaces.   Following  the
       near misses (and identified only by the count of near misses), if the word could be formed by
       adding (invalid) affixes to a known root, is a list of suggested derivations, again separated
       by  commas  and spaces.  If there are no near misses at all, the line format is the same, ex‐
       cept that the '&' is replaced by '?' (and the near-miss count is always zero).  The suggested
       derivations following the near misses are in the form:

              [prefix+] root [-prefix] [-suffix] [+suffix]

       (e.g., "re+fry-y+ies" to get "refries") where each optional pfx and sfx is a  string.   Also,
       each  near miss or guess is capitalized the same as the input word unless such capitalization
       is invalid; in the latter case each near miss is capitalized correctly according to the  dic‐
       tionary.

       Finally,  if  the  word does not appear in the dictionary, and there are no near misses, then
       the line contains a '#', a space, the misspelled word, a space, and the character offset from
       the beginning of the line.  Each sentence of text input  is  terminated  with  an  additional
       blank line, indicating that ispell has completed processing the input line.

       These output lines can be summarized as follows:

              OK:    *

              Root:  + <root>

              Compound:
                     -

              Miss:  & <original> <count> <offset>: <miss>, <miss>, ..., <guess>, ...

              Guess: ? <original> 0 <offset>: <guess>, <guess>, ...

              None:  # <original> <offset>

       For  example,  a  dummy  dictionary containing the words "fray", "Frey", "fry", and "refried"
       might produce the following response to the command "echo 'frqy refries' | ispell  -a  -m  -d
       ./test.hash":
              (#) International Ispell Version 3.0.05 (beta), 08/10/91
              & frqy 3 0: fray, Frey, fry
              & refries 1 5: refried, re+fry-y+ies

       This  mode is also suitable for interactive use when you want to figure out the spelling of a
       single word.

       The -A option works just like -a, except  that  if  a  line  begins  with  the  string  "&In‐
       clude_File&",  the rest of the line is taken as the name of a file to read for further words.
       Input returns to the original file when the include file  is  exhausted.   Inclusion  may  be
       nested  up  to  five  deep.   The key string may be changed with the environment variable IN‐
       CLUDE_STRING (the ampersands, if any, must be included).

       When in the -a mode, ispell will also accept lines of single words prefixed with any of  '*',
       '&',  '@',  '+', '-', '~', '#', '!', '%', '`', or '^'.  A line starting with '*' tells ispell
       to insert the word into the user's dictionary (similar to the I command).   A  line  starting
       with  '&' tells ispell to insert an all-lowercase version of the word into the user's dictio‐
       nary (similar to the U command).  A line starting with '@' causes ispell to accept this  word
       in  the future (similar to the A command).  A line starting with '+', followed immediately by
       tex or nroff will cause ispell to parse future input according the syntax of that  formatter.
       A  line consisting solely of a '+' will place ispell in TeX/LaTeX mode (similar to the -t op‐
       tion) and '-' returns ispell to nroff/troff mode (but these commands are obsolete).  However,
       the string character type is not changed; the '~' command must be used to do  this.   A  line
       starting with '~' causes ispell to set internal parameters (in particular, the default string
       character  type) based on the filename given in the rest of the line.  (A file suffix is suf‐
       ficient, but the period must be included.  Instead of a file name or suffix, a  unique  name,
       as  listed  in the language affix file, may be specified.)  However, the formatter parsing is
       not changed;  the '+' command must be used to change the formatter.  A line prefixed with '#'
       will cause the personal dictionary to be saved.  A line prefixed with '!' will turn on  terse
       mode (see below), and a line prefixed with '%' will return ispell to normal (non-terse) mode.
       A line prefixed with '`' will turn on verbose-correction mode (see below); this mode can only
       be disabled by turning on terse mode with '%'.

       Any  input  following the prefix characters '+', '-', '#', '!', '%', or '`' is ignored, as is
       any input following the filename on a '~' line.  To allow spell-checking of  lines  beginning
       with  these  characters,  a  line  starting  with '^' has that character removed before it is
       passed to the spell-checking code.  It is recommended  that  programmatic  interfaces  prefix
       every data line with an uparrow to protect themselves against future changes in ispell.

       To summarize these:

              *      Add to personal dictionary

              @      Accept word, but leave out of dictionary

              #      Save current personal dictionary

              ~      Set parameters based on filename

              +      Enter TeX mode

              -      Exit TeX mode

              !      Enter terse mode

              %      Exit terse mode

              `      Enter verbose-correction mode

              ^      Spell-check rest of line

       In  terse mode, ispell will not print lines beginning with '*', '+', or '-', all of which in‐
       dicate correct words.  This significantly improves running speed when the driving program  is
       going to ignore correct words anyway.

       In verbose-correction mode, ispell includes the original word immediately after the indicator
       character  in output lines beginning with '*', '+', and '-', which simplifies interaction for
       some programs.

       The -s option is only valid in conjunction with the -a or -A options, and only on BSD-derived
       systems.  If specified, ispell will stop itself with a SIGTSTP signal after each line of  in‐
       put.  It will not read more input until it receives a SIGCONT signal.  This may be useful for
       handshaking with certain text editors.

       The  -f  option  is only valid in conjunction with the -a or -A options.  If -f is specified,
       ispell will write its results to the given file, rather than to standard output.

       The -v option causes ispell to print its current version identification on the standard  out‐
       put  and exit.  If the switch is doubled, ispell will also print the options that it was com‐
       piled with.

       The -c, -e[1\n5], and -D options of ispell, are primarily intended for use by  the  munchlist
       shell  script.  The -c switch causes a list of words to be read from the standard input.  For
       each word, a list of possible root words and affixes will be written to the standard  output.
       Some  of  the root words will be invalid and must be filtered from the output by other means;
       the munchlist script does this.  As an example, the command:

              echo BOTHER | ispell -c

       produces:

              BOTHER BOTHE/R BOTH/R

       The -e switch is the reverse of -c; it expands affix flags to produce a list of  words.   For
       example, the command:

              echo BOTH/R | ispell -e

       produces:

              BOTH BOTHER

       An  optional  expansion  level  can  also be specified.  A level of 1 (-e1) is the same as -e
       alone.  A level of 2 causes the original root/affix combination to be prepended to the line:

              BOTH/R BOTH BOTHER

       A level of 3 causes multiple lines to be output, one for each generated word, with the origi‐
       nal root/affix combination followed by the word it creates:

              BOTH/R BOTH
              BOTH/R BOTHER

       A level of 4 causes a floating-point number to be appended to each of the level-3 lines, giv‐
       ing the ratio between the length of the root and the total length of all generated words  in‐
       cluding the root:

              BOTH/R BOTH 2.500000
              BOTH/R BOTHER 2.500000

       A  level of 5 causes multiple lines to be output, one for each generated word.  If the gener‐
       ated word did not use any affixes, the line is just that word.  If one or more  affixes  were
       used,  the  original  root  and the affixes actually used are printed, joined by a plus sign;
       then the generated word is printed:

              BOTH
              BOTH+R BOTHER

       Finally, the -D flag causes the affix tables from the dictionary file to be dumped  to  stan‐
       dard output.

       Ispell  is  aware  of the correct capitalizations of words in the dictionary and in your per‐
       sonal dictionary.  As well as recognizing words that must be capitalized (e.g.,  George)  and
       words  that  must be all-capitals (e.g., NASA), it can also handle words with "unusual" capi‐
       talization (e.g., "ITCorp" or "TeX").  If a word is capitalized incorrectly, the list of pos‐
       sibilities will include all acceptable capitalizations.  (More than one capitalization may be
       acceptable; for example, my dictionary lists both "ITCorp" and "ITcorp".)

       Normally, this feature will not cause you surprises, but there is one circumstance  you  need
       to  be aware of.  If you use "I" to add a word to your dictionary that is at the beginning of
       a sentence (e.g., the first word of this paragraph if "normally" were not in the dictionary),
       it will be marked as "capitalization required".  A subsequent usage of this word without cap‐
       italization (e.g., the quoted word in the previous sentence) will be considered a misspelling
       by ispell, and it will suggest the capitalized version.  You must  then  compare  the  actual
       spellings by eye, and then type "I" to add the uncapitalized variant to your personal dictio‐
       nary.  You can avoid this problem by using "U" to add the original word, rather than "I".

       The rules for capitalization are as follows:

       (1)    Any word may appear in all capitals, as in headings.

       (2)    Any  word  that is in the dictionary in all-lowercase form may appear either in lower‐
              case or capitalized (as at the beginning of a sentence).

       (3)    Any word that has "funny" capitalization (i.e., it contains both cases and there is an
              uppercase character besides the first) must appear exactly as in the  dictionary,  ex‐
              cept  as  permitted  by rule (1).  If the word is acceptable in all-lowercase, it must
              appear thus in a dictionary entry.

   buildhash
       The buildhash program builds hashed dictionary files for later use by ispell.  The  raw  word
       list (with affix flags) is given in dict-file, and the affix flags are defined by affix-file.
       The  hashed output is written to hash-file.  The formats of the two input files are described
       in ispell(5).  The -s (silent) option suppresses the usual status messages that  are  written
       to the standard error device.

   munchlist
       The munchlist shell script is used to reduce the size of dictionary files, primarily personal
       dictionary  files.   It  is also capable of combining dictionaries from various sources.  The
       given files are read (standard input if no arguments are given), reduced to a minimal set  of
       roots and affixes that will match the same list of words, and written to standard output.

       Input  for  munchlist contains of raw words (e.g from your personal dictionary files) or root
       and affix combinations (probably generated in earlier munchlist runs).  Each word or root/af‐
       fix combination must be on a separate line.

       The -D (debug) option leaves temporary files around under standard names instead of  deleting
       them,  so that the script can be debugged.  Warning: on a multiuser system, this can be a se‐
       curity hole.  To avoid possible destruction of important files, don't run the script as root,
       and set MUNCHDEBUGDIR to the name of a directory that only you can access.

       The -v (verbose) option causes progress messages to be reported to stderr so  you  won't  get
       nervous that munchlist has hung.

       If  the -s (strip) option is specified, words that are in the specified hash-file are removed
       from the word list.  This can be useful with personal dictionaries.

       The -l option can be used to specify an alternate affix-file  for  munching  dictionaries  in
       languages other than English.

       The  -c  option can be used to convert dictionaries that were built with an older affix file,
       without risk of accidentally introducing unintended affix combinations into the dictionary.

       The -T option allows dictionaries to be converted to  a  canonical  string-character  format.
       The suffix specified is looked up in the affix file (-l switch) to determine the string-char‐
       acter  format  used for the input file; the output always uses the canonical string-character
       format.  For example, a dictionary collected from TeX source  files  might  be  converted  to
       canonical format by specifying -T tex.

       The -w option is passed on to ispell.

   findaffix
       The  findaffix shell script is an aid to writers of new language descriptions in choosing af‐
       fixes.  The given dictionary files (standard input if none are given) are examined for possi‐
       ble prefixes (-p switch) or suffixes (-s switch, the default).  Each commonly-occurring affix
       is presented along with a count of the number of times it appears and an estimate of the num‐
       ber of bytes that would be saved in a dictionary hash file if it were added to  the  language
       table.  Only affixes that generate valid roots (found in the original input) are listed.

       If the "-c" option is not given, the output lines are in the following format:

              strip/add/count/bytes

       where  strip  is the string that should be stripped from a root word before adding the affix,
       add is the affix to be added, count is a count of the number of  times  that  this  strip/add
       combination  appears,  and bytes is an estimate of the number of bytes that might be saved in
       the raw dictionary file if this combination is added to the affix file.  The field  separator
       in  the  output will be the tab character specified by the -t switch;  the default is a slash
       ("/").

       If the -c ("clean output") option is given, the appearance of the  output  is  made  visually
       cleaner (but harder to post-process) by changing it to:

              -strip+add<tab>count<tab>bytes

       where  strip, add, count, and bytes are as before, and <tab> represents the ASCII tab charac‐
       ter.

       The method used to generate possible affixes will also generate  longer  affixes  which  have
       common headers or trailers.  For example, the two words "moth" and "mother" will generate not
       only  the  obvious  substitution  "+er"  but  also "-h+her" and "-th+ther" (and possibly even
       longer ones, depending on the value of min).  To prevent cluttering the output with such  af‐
       fixes,  any  affix pair that shares a common header (or, for prefixes, trailer) string longer
       than elim characters (default 1) will be suppressed.  You may want to set "elim" to  a  value
       greater  than  1  if your language has string characters; usually the need for this parameter
       will become obvious when you examine the output of your findaffix run.

       Normally, the affixes are sorted according to the estimate of bytes saved.  The -f switch may
       be used to cause the affixes to be sorted by frequency of appearance.

       To save output file space, affixes which occur fewer than 10 times are eliminated; this limit
       may be changed with the -l switch.  The -M switch specifies a maximum affix  length  (default
       8).   Affixes longer than this will not be reported.  (This saves on temporary disk space and
       makes the script run faster.)

       Affixes which generate stems shorter than 3 characters are suppressed.  (A stem is  the  word
       after the strip string has been removed, and before the add string has been added.)  This re‐
       duces  both the running time and the size of the output file.  This limit may be changed with
       the -m switch.  The minimum stem length should only be set to 1 if you have  a  lot  of  free
       time and disk space (in the range of many days and hundreds of megabytes).

       The  findaffix  script requires a non-blank field-separator character for internal use.  Nor‐
       mally, this character is a slash ("/"), but if the slash appears as a character in the  input
       word list, a different character can be specified with the -t switch.

       Ispell dictionaries should be expanded before being fed to findaffix; in addition, characters
       that are not in the English alphabet (if any) should be translated to lowercase.

   tryaffix
       The  tryaffix  shell  script  is  used to estimate the effectiveness of a proposed prefix (-p
       switch) or suffix (-s switch, the default) with a given expanded-file.  Only one affix can be
       tried with each execution of tryaffix, although multiple arguments can be  used  to  describe
       varying forms of the same affix flag (e.g., the D flag for English can add either D or ED de‐
       pending  on  whether  a trailing E is already present).  Each word in the expanded dictionary
       that ends (or begins) with the chosen suffix (or prefix) has that  suffix  (prefix)  removed;
       the  dictionary  is then searched for root words that match the stripped word.  Normally, all
       matching roots are written to standard output, but if the -c (count) flag is  given,  only  a
       statistical summary of the results is written.  The statistics given are a count of words the
       affix  potentially  applies  to and an estimate of the number of dictionary bytes that a flag
       using the affix would save.  The estimate will be high if the flag generates words  that  are
       currently  generated  by other affix flags (e.g., in English, bathers can be generated by ei‐
       ther bath/X or bather/S).

       The dictionary file, expanded-file, must already be expanded (using the -e switch of  ispell)
       and  sorted,  and  things  will  usually work best if uppercase has been folded to lower with
       'tr'.

       The affix arguments are things to be stripped from  the  dictionary  file  to  produce  trial
       roots:  for  English,  con (prefix) and ing (suffix) are examples.  The addition parts of the
       argument are letters that would have been stripped off the root before adding the affix.  For
       example, in English the affix ing normally strips e for words ending in  that  letter  (e.g.,
       like becomes liking) so we might run:

              tryaffix ing ing+e

       to cover both cases.

       All  of  the  shell  scripts  contain documentation as commentary at the beginning; sometimes
       these comments contain useful information beyond the scope of this manual page.

       It is possible to install ispell in such a way as to only support ASCII  range  text  if  de‐
       sired.

   icombine
       The  icombine program is a helper for munchlist.  It reads a list of words in dictionary for‐
       mat (roots plus flags) from the standard input, and produces a reduced list on standard  out‐
       put  which  combines common roots found on adjacent entries.  Identical roots which have dif‐
       fering flags will have their flags combined, and roots which have  differing  capitalizations
       will be combined in a way which only preserves important capitalization information.  The op‐
       tional aff-file specifies a language file which defines the character sets used and the mean‐
       ings  of  the  various  flags.   The -T switch can be used to select among alternative string
       character types by giving a dummy suffix that can be found  in  an  altstringtype  statement.
       The -w switch is identical to the same switch in ispell.

   ijoin
       The  ijoin program is a re-implementation of join(1) which handles long lines and 8-bit char‐
       acters correctly.  The -s switch specifies that the sort(1) program used to prepare the input
       to ijoin uses signed comparisons on 8-bit characters; the -u switch  specifies  that  sort(1)
       uses  unsigned comparisons.  All other options and behaviors of join(1) are duplicated as ex‐
       actly as possible based on the manual page, except that ijoin will not handle  newline  as  a
       field separator.  See the join(1) manual page for more information.

ENVIRONMENT
       DICTIONARY
              Default dictionary to use, if no -d flag is given.

       ISPELL_CHARSET
              Formatter type or character encoding to use, if none is chosen by a flag option.

       WORDLIST
              Personal dictionary file name

       INCLUDE_STRING
              Code for file inclusion under the -A option

       TMPDIR Directory used for some of munchlist's temporary files

       MUNCHDEBUGDIR
              Directory used to hold the output of munchlists' -D option.

       TEXSKIP1
              List of single-argument TeX keywords that ispell should ignore.

       TEXSKIP2
              List of two-argument TeX keywords that ispell should ignore.

       HTMLIGNORE
              List of HTML keywords that delimit text that should not be spell-checked.

       HTMLCHECK
              List of HTML fields that should always be spell-checked, even inside a tag.

FILES
       /usr/lib/ispell/default.hash
              Hashed  dictionary  (may be found in some other local directory, depending on the sys‐
              tem).

       /usr/lib/ispell/default.aff
              Affix-definition file for munchlist

       /usr/share/dict/words
              For the Lookup function.

       $HOME/.ispell_hashfile
              User's private dictionary

       .ispell_hashfile
              Directory-specific private dictionary

SEE ALSO
       egrep(1), look(1), join(1), sort(1), spell(1), sq(1), tib (if available on your system),  is‐
       pell(5), english(5)

BUGS
       Ispell should understand more troff syntax, and deal more intelligently with contractions.

       Although  small  personal  dictionaries  are sorted before they are written out, the order of
       capitalizations of the same word is somewhat random.

       When the -x flag is specified, ispell will unlink any existing .bak file.

       There are too many flags, and many of them have non-mnemonic names.

       The -e flag should accept mnemonic arguments instead of numeric ones.

       Munchlist does not deal very gracefully with dictionaries which  contain  "non-word"  charac‐
       ters.  Such characters ought to be deleted from the dictionary with a warning message.

AUTHOR
       Pace  Willisson (pace@mit-vax), 1983, based on the PDP-10 assembly version.  That version was
       written by R. E. Gorin in 1971, and later revised by W. E. Matson (1974) and W.  B.  Ackerman
       (1978).

       Collected, revised, and enhanced for the Usenet by Walt Buehring, 1987.

       Table-driven multi-lingual version by Geoff Kuenning, 1987–88.

       Large dictionaries provided by Bob Devine (vianet!devine).

       A complete list of contributors is too large to list here, but is distributed with the ispell
       sources in the file "Contributors".

VERSION
       The version of ispell described by this manual page is International Ispell Version 3.4.06 30
       Oct 2023.

                                                local                                      ISPELL(1)
ispell(1)
NAME SYNOPSIS DESCRIPTION
buildhash munchlist findaffix tryaffix icombine ijoin
ENVIRONMENT FILES SEE ALSO BUGS AUTHOR VERSION

Generated by phpman v4.9.26-5-g7740029 · Markdown · JSON · MCP Author: Che Dong Under GNU General Public License
2026-08-15 05:53 @216.73.216.208
CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)
Valid XHTML 1.0 Transitional!Valid CSS!

^_top_^