@c =============================================================
@c = $B85(B $BK](B $BLu(B: $B9b<.0l5*!wEE5$DL?.Bg3X(B
@c = $B2CI.=$@5(B: $BBgLZFXM:!wBgDM(B.$BC^GHBg3X(B = 1998/11/25
@c = 20.4$B2~D{(B: $BBgLZFXM:!wBgDM(B.$BC^GHBg3X(B = 1999/09/12
@c =============================================================
@c This is part of the Emacs manual.
@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Help, Mark, M-x, Top
@c @chapter Help
@chapter $B%X%k%W5!G=(B
@kindex Help
@c @cindex help
@cindex $B%X%k%W5!G=(B
@c @cindex self-documentation
@cindex $B%;%k%U%I%-%e%a%s%H(B
@findex help-command
@kindex C-h
@kindex F1

@c   Emacs provides extensive help features accessible through a single
@c character, @kbd{C-h}.  @kbd{C-h} is a prefix key that is used only for
@c documentation-printing commands.  The characters that you can type after
@c @kbd{C-h} are called @dfn{help options}.  One help option is @kbd{C-h};
@c that is how you ask for help about using @kbd{C-h}.  To cancel, type
@c @kbd{C-g}.  The function key @key{F1} is equivalent to @kbd{C-h}.
Emacs$B$K$O!"(B@kbd{C-h}$B$N$?$C$?(B1$BJ8;z$G8F$S=P$;$k(B
$B9bEY$J%X%k%W5!G=$,$"$j$^$9!#(B
@kbd{C-h}$B$O!"@bL@J8I=<(%3%^%s%I$N$?$a$@$1$K;H$o$l$k%W%l%U%#%C%/%9%-!<$G$9!#(B
@kbd{C-h}$B$N$"$H$KBG$DJ8;z!JNs!K$r(B
@dfn{$B%X%k%W%*%W%7%g%s(B}$B!J(Bhelp options$B!K$H8F$S$^$9!#(B
@kbd{C-h}$B$b%X%k%W%*%W%7%g%s$N(B1$B$D$G$"$C$F!"(B
@kbd{C-h}$B$N;H$$J}$rD4$Y$k$3$H$,$G$-$^$9!#(B
$BESCf$G<h$j>C$9$K$O!"(B@kbd{C-g}$B$rBG$A$^$9!#(B
$B%U%!%s%/%7%g%s%-!<(B@key{F1}$B$O!"(B@kbd{C-h}$B$HEy2A$G$9!#(B

@kindex C-h C-h
@findex help-for-help
@c   @kbd{C-h C-h} (@code{help-for-help}) displays a list of the possible
@c help options, each with a brief description.  Before you type a help
@c option, you can use @key{SPC} or @key{DEL} to scroll through the list.
@kbd{C-h C-h}$B!J(B@code{help-for-help}$B!K$O!"(B
$BMxMQ2DG=$J%X%k%W%*%W%7%g%s$N0lMw$r4JAG$J@bL@$H$H$b$KI=<($7$^$9!#(B
$B%X%k%W%*%W%7%g%s$rBG$D$^$G$O!"(B
@key{SPC}$B$d(B@key{DEL}$B$G0lMw$r%9%/%m!<%k$G$-$^$9!#(B

@c   @kbd{C-h} or @key{F1} means ``help'' in various other contexts as
@c well.  For example, in the middle of @code{query-replace}, it describes
@c the options available for how to operate on the current match.  After a
@c prefix key, it displays a list of the alternatives that can follow the
@c prefix key.  (A few prefix keys don't support @kbd{C-h}, because they
@c define other meanings for it, but they all support @key{F1}.)
@kbd{C-h}$B$d(B@key{F1}$B$O!"B>$N$5$^$6$^$J>u67$G$b!X%X%k%W!Y$r0UL#$7$^$9!#(B
$B$?$H$($P!"(B@code{query-replace}$B$N<B9TCf$K$O!"(B
$B:#0lCW$7$F$$$kJ8;zNs$KBP$7$FE,MQ2DG=$JA`:n$r@bL@$7$^$9!#(B
$B%W%l%U%#%C%/%9%-!<$KB3$1$F(B@kbd{C-h}$B$d(B@key{F1}$B$rBG$D$H!"(B
$B$=$N%W%l%U%#%C%/%9%-!<$KB3$1$k$3$H$,$G$-$k%-!<$N0lMw$rI=<($7$^$9!#(B
$B!J(B@kbd{C-h}$B$KFH<+$N0UL#$rDj5A$7$F$$$k%W%l%U%#%C%/%9%-!<$b$"$j!"(B
$B$=$N$h$&$J>l9g$K$O(B@kbd{C-h}$B$r;H$($J$$!#(B
$B$7$+$7!"(B@key{F1}$B$O$9$Y$F$N%W%l%U%#%C%/%9%-!<$G;H$($k!#!K(B

@c   Most help buffers use a special major mode, Help mode, which lets you
@c scroll conveniently with @key{SPC} and @key{DEL}.
$B$[$H$s$I$N%X%k%W%P%C%U%!$G$O!"FCJL$J%a%8%c!<%b!<%I$G$"$k(B
$B%X%k%W!J(Bhelp$B!K%b!<%I$r;H$$$^$9!#(B
$B%X%k%W!J(Bhelp$B!K%b!<%I$G$O!"(B
@key{SPC}$B$H(B@key{DEL}$B$G2hLL$r4JC1$K%9%/%m!<%k$G$-$^$9!#(B

@menu
* Help Summary::	Brief list of all Help commands.
* Key Help::		Asking what a key does in Emacs.
* Name Help::		Asking about a command, variable or function name.
* Apropos::		Asking what pertains to a given topic.
* Library Keywords::	Finding Lisp libraries by keywords (topics).
* Language Help::       Help relating to international language support.
* Help Mode::           Special features of Help mode and Help buffers.
* Misc Help::		Other help commands.
@end menu

@iftex
@node Help Summary
@end iftex
@ifinfo
@node Help Summary
@c @section Help Summary
@section $B%X%k%W$N$^$H$a(B
@end ifinfo

@c   Here is a summary of the defined help commands.
$BDj5A$5$l$F$$$k%X%k%W%3%^%s%I$r0J2<$K$^$H$a$F$*$-$^$9!#(B

@table @kbd
@item C-h a @var{regexp} @key{RET}
@c Display a list of commands whose names match @var{regexp}
@c (@code{apropos-command}).
$B@55,I=8=(B@var{regexp}$B$K0lCW$9$kL>A0$r;}$D%3%^%s%I$N0lMw$rI=<($9$k(B
$B!J(B@code{apropos-command}$B!K!#(B
@item C-h b
@c Display a table of all key bindings in effect now, in this order: minor
@c mode bindings, major mode bindings, and global bindings
@c (@code{describe-bindings}).
$B8=:_M-8z$J$9$Y$F$N%-!<%P%$%s%I$N0lMw$r!"(B
$B%^%$%J%b!<%I$N%P%$%s%G%#%s%0!"(B
$B%a%8%c!<%b!<%I$N%P%$%s%G%#%s%0!"(B
$B%0%m!<%P%k%P%$%s%G%#%s%0$N=g$KI=<($9$k(B
$B!J(B@code{describe-bindings}$B!K!#(B
@item C-h c @var{key}
@c Print the name of the command that @var{key} runs
@c (@code{describe-key-briefly}).  Here @kbd{c} stands for `character'.  For more
@c extensive information on @var{key}, use @kbd{C-h k}.
@var{key}$B$,<B9T$9$k%3%^%s%I$NL>A0$rI=<($9$k!J(B@code{describe-key-briefly}$B!K!#(B
$B$3$3$G!"(B@kbd{c}$B$O!X(Bcharacter$B!Y!JJ8;z!K$N(Bc$B$N$3$H!#(B
@var{key}$B$N$5$i$K>\$7$$>pJs$rF@$k$K$O!"(B@kbd{C-h k}$B$r;H$&!#(B
@item C-h f @var{function} @key{RET}
@c Display documentation on the Lisp function named @var{function}
@c (@code{describe-function}).  Since commands are Lisp functions,
@c a command name may be used.
Lisp$B4X?t(B@var{function}$B$N@bL@J8$rI=<($9$k(B
$B!J(B@code{describe-function}$B!K!#(B
$B%3%^%s%I$O(BLisp$B4X?t$J$N$G!"%3%^%s%IL>$b;H$($k!#(B
@item C-h h
@c Display the @file{hello} file, which shows examples of various character
@c sets.
$B$5$^$6$^$JJ8;z=89g$NNcJ8$rNc<($9$k(B@file{hello}$B%U%!%$%k$rI=<($9$k!#(B
@item C-h i
@c Run Info, the program for browsing documentation files (@code{info}).
@c The complete Emacs manual is available on-line in Info.
$B%I%-%e%a%s%H%U%!%$%k$r1\Mw$9$k%W%m%0%i%`!"(B
info$B$r5/F0$9$k!J(B@code{info}$B!K!#(B
info$B$G$O!"40A4$J(BEmacs$B%^%K%e%"%k$r%*%s%i%$%s$G8+$k$3$H$,$G$-$k!#(B
@item C-h k @var{key}
@c Display the name and documentation of the command that @var{key} runs
@c (@code{describe-key}).
@var{key}$B$,<B9T$9$k%3%^%s%I$NL>A0$H@bL@J8$rI=<($9$k(B
$B!J(B@code{describe-key}$B!K!#(B
@item C-h l
@c Display a description of the last 100 characters you typed
@c (@code{view-lossage}).
$B$3$l$^$G$KBG80$7$?:G8e$N(B100$BJ8;z$rI=<($9$k!J(B@code{view-lossage}$B!K!#(B
@item C-h m
@c Display documentation of the current major mode (@code{describe-mode}).
$B8=:_$N%a%8%c!<%b!<%I$N@bL@J8$rI=<($9$k(B
$B!J(B@code{describe-mode}$B!K!#(B
@item C-h n
@c Display documentation of Emacs changes, most recent first
@c (@code{view-emacs-news}).
Emacs$B$NJQ99E@$K4X$9$k@bL@$r:G?7$N$b$N$+$i=g$KI=<($9$k(B
$B!J(B@code{view-emacs-news}$B!K!#(B
@item C-h p
@c Find packages by topic keyword (@code{finder-by-keyword}).
$B%H%T%C%/$N%-!<%o!<%I$G!"0lCW$9$k%Q%C%1!<%8$rC5$9(B
$B!J(B@code{finder-by-keyword}$B!K!#(B
@item C-h s
@c Display current contents of the syntax table, plus an explanation of
@c what they mean (@code{describe-syntax}).  @xref{Syntax}.
$B8=:_$N9=J8%F!<%V%k$H$=$N0UL#$N@bL@$rI=<($9$k(B
$B!J(B@code{describe-syntax}$B!K!#(B
@pxref{Syntax}$B!#(B
@item C-h t
@c Enter the Emacs interactive tutorial (@code{help-with-tutorial}).
Emacs$B$NBPOC7?$N%A%e!<%H%j%"%k$KF~$k(B
$B!J(B@code{help-with-tutorial}$B!K!#(B
@item C-h v @var{var} @key{RET}
@c Display the documentation of the Lisp variable @var{var}
@c (@code{describe-variable}).
Lisp$BJQ?t(B@var{var}$B$N@bL@J8$rI=<($9$k(B
$B!J(B@code{describe-variable}$B!K!#(B
@item C-h w @var{command} @key{RET}
@c Print which keys run the command named @var{command} (@code{where-is}).
$B%3%^%s%I(B@var{command}$B$r<B9T$9$k%-!<$rI=<($9$k(B
$B!J(B@code{where-is}$B!K!#(B
@item C-h C @var{coding} @key{RET}
@c Describe coding system @var{coding}
@c (@code{describe-coding-system}).
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r@bL@$9$k(B
$B!J(B@code{describe-coding-system}$B!K!#(B
@item C-h C @key{RET}
@c Describe the coding systems currently in use.
$B8=:_;HMQCf$N%3!<%G%#%s%0%7%9%F%`$r@bL@$9$k!#(B
@item C-h I @var{method} @key{RET}
@c Describe an input method (@code{describe-input-method}).
$BF~NOJ}<0$r@bL@$9$k!J(B@code{describe-input-method}$B!K!#(B
@item C-h L @var{language-env} @key{RET}
@c Describe information on the character sets, coding systems and input
@c methods used for language environment @var{language-env}
@c (@code{describe-language-environment}).
$B8@8l4D6-(B@var{language-env}$B$K$*$$$F;H$o$l$k!"(B
$BJ8;z=89g!"%3!<%G%#%s%0%7%9%F%`!"F~NOJ}<0$r@bL@$9$k(B
$B!J(B@code{describe-language-environment}$B!K!#(B
@item C-h C-c
@c Display the copying conditions for GNU Emacs.
GNU Emacs$B$N%3%T!<%i%$%H$rI=<($9$k!#(B
@item C-h C-d
@c Display information about getting new versions of GNU Emacs.
GNU Emacs$B$N?7HG$NF~<jJ}K!$K4X$9$k>pJs$rI=<($9$k!#(B
@item C-h C-f @var{function} @key{RET}
@c Enter Info and go to the node documenting the Emacs function @var{function}
@c (@code{Info-goto-emacs-command-node}).
info$B$KF~$C$F!"(BEmacs$B$N4X?t(B@var{function}$B$r@bL@$7$F$$$k%N!<%I$K0\F0$9$k(B
$B!J(B@code{Info-goto-emacs-command-node}$B!K!#(B
@item C-h C-k @var{key}
@c Enter Info and go to the node where the key sequence @var{key} is
@c documented (@code{Info-goto-emacs-key-command-node}).
info$B$KF~$C$F!"%-!<Ns(B@var{key}$B$r@bL@$7$F$$$k%N!<%I$K0\F0$9$k(B
$B!J(B@code{Info-goto-emacs-key-command-node}$B!K!#(B
@item C-h C-p
@c Display information about the GNU Project.
GNU$B%W%m%8%'%/%H$K4X$9$k>pJs$rI=<($9$k!#(B
@item C-h @key{TAB} @var{symbol} @key{RET}
@c Display the Info documentation on symbol @var{symbol} according to the
@c programming language you are editing (@code{info-lookup-symbol}).
$BJT=8Cf$N%W%m%0%i%`8@8l$K1~$8$F!"(B
$B%7%s%\%k(B@var{symbol}$B$K4X$9$k(Binfo$B%I%-%e%a%s%H$rI=<($9$k(B
$B!J(B@code{info-lookup-symbol}$B!K!#(B
@end table

@node Key Help
@c @section Documentation for a Key
@section $B%-!<$K4X$9$k@bL@(B

@kindex C-h c
@findex describe-key-briefly
@c   The most basic @kbd{C-h} options are @kbd{C-h c}
@c (@code{describe-key-briefly}) and @w{@kbd{C-h k}} (@code{describe-key}).
@c @kbd{C-h c @var{key}} prints in the echo area the name of the command
@c that @var{key} is bound to.  For example, @kbd{C-h c C-f} prints
@c @samp{forward-char}.  Since command names are chosen to describe what
@c the commands do, this is a good way to get a very brief description of
@c what @var{key} does.
@kbd{C-h}$B$N$b$C$H$b4pK\E*$J%*%W%7%g%s$O!"(B
@kbd{C-h c}$B!J(B@code{describe-key-briefly}$B!K$H(B
@w{@kbd{C-h k}}$B!J(B@code{describe-key}$B!K$G$9!#(B
@kbd{C-h c @var{key}}$B$O!"(B
@var{key}$B$K%P%$%s%I$7$F$"$k%3%^%s%IL>$r%(%3!<NN0h$KI=<($7$^$9!#(B
$B$?$H$($P!"(B@kbd{C-h c C-f}$B$HBG$F$P(B@samp{forward-char}$B$HI=<($5$l$^$9!#(B
$B%3%^%s%IL>$O$=$N%3%^%s%I$,2?$r$9$k$+$rI=$9$h$&$KA*$s$G$"$j$^$9$+$i!"(B
$B%-!<(B@var{key}$B$,2?$r$9$k$+$r$A$g$C$HD4$Y$?$$>l9g$K!"$h$$J}K!$G$9!#(B

@kindex C-h k
@findex describe-key
@c   @kbd{C-h k @var{key}} is similar but gives more information: it
@c displays the documentation string of the command as well as its name.
@c This is too big for the echo area, so a window is used for the display.
@kbd{C-h k @var{key}}$B$bF1MM$G$9$,!"$h$jB?$/$N>pJs$rI=<($7$^$9!#(B
$B$D$^$j!"%3%^%s%I$NL>A0$@$1$G$J$/!"@bL@J8$bI=<($7$^$9!#(B
$B$=$NFbMF$O%(%3!<NN0h$KI=<($9$k$K$OB?$9$.$k$?$a!"(B
$B%&%#%s%I%&$KI=<($7$^$9!#(B

@c   @kbd{C-h c} and @kbd{C-h k} work for any sort of key sequences,
@c including function keys and mouse events.
@kbd{C-h c}$B$d(B@kbd{C-h k}$B$O!"%U%!%s%/%7%g%s%-!<$d%^%&%9%$%Y%s%H$b4^$a$?!"(B
$B$"$i$f$k%-!<Ns$KE,MQ$G$-$^$9!#(B

@node Name Help
@c @section Help by Command or Variable Name
@section $B%3%^%s%IL>$dJQ?tL>$K$h$k%X%k%WI=<((B

@kindex C-h f
@findex describe-function
@c   @kbd{C-h f} (@code{describe-function}) reads the name of a Lisp function
@c using the minibuffer, then displays that function's documentation string
@c in a window.  Since commands are Lisp functions, you can use this to get
@c the documentation of a command that you know by name.  For example,
@kbd{C-h f}$B!J(B@code{describe-function}$B!K$O!"(B
$B%_%K%P%C%U%!$G(BLisp$B4X?t$NL>A0$rFI$_<h$j!"(B
$B$=$N4X?t$N@bL@J8;zNs$r%&%#%s%I%&$KI=<($7$^$9!#(B
$B%3%^%s%I$O(BLisp$B4X?t$G$9$+$i!"(B
$BL>A0$rCN$C$F$$$k%3%^%s%I$G$"$l$P!"(B
$B$=$N@bL@J8$rF@$k$3$H$,$G$-$^$9!#(B
$B$?$H$($P!"(B

@example
C-h f auto-fill-mode @key{RET}
@end example

@noindent
@c displays the documentation of @code{auto-fill-mode}.  This is the only
@c way to get the documentation of a command that is not bound to any key
@c (one which you would normally run using @kbd{M-x}).
$B$H$9$k$H!"(B@code{auto-fill-mode}$B$N@bL@J8;zNs$rI=<($G$-$^$9!#(B
$B$I$N%-!<$K$b%P%$%s%I$7$F$$$J$$(B
$B!J$D$^$j!"DL>o(B@kbd{M-x}$B$G5/F0$9$k!K%3%^%s%I$N@bL@J8;zNs$r8+$k$K$O!"(B
$B$3$NJ}K!$7$+$"$j$^$;$s!#(B

@c   @kbd{C-h f} is also useful for Lisp functions that you are planning to
@c use in a Lisp program.  For example, if you have just written the
@c expression @code{(make-vector len)} and want to check that you are using
@c @code{make-vector} properly, type @kbd{C-h f make-vector @key{RET}}.
@c Because @kbd{C-h f} allows all function names, not just command names,
@c you may find that some of your favorite abbreviations that work in
@c @kbd{M-x} don't work in @kbd{C-h f}.  An abbreviation may be unique
@c among command names yet fail to be unique when other function names are
@c allowed.
@kbd{C-h f}$B$O$^$?!"(B
Lisp$B%W%m%0%i%`$NCf$G;H$*$&$H9M$($F$$$k(BLisp$B4X?t$KBP$7$F$bM-1W$G$9!#(B
$B$?$H$($P!"<0(B@code{(make-vector len)}$B$r=q$$$?$H$7$^$7$g$&!#(B
@code{make-vector}$B$r@5$7$/;H$C$F$$$k$+$I$&$+D4$Y$?$$$H$-$K$O!"(B
@kbd{C-h f make-vector @key{RET}}$B$HBG$A$^$9!#(B
@kbd{C-h f}$B$O!"%3%^%s%IL>$@$1$G$J$/!"$9$Y$F$N4X?tL>$KE,MQ$G$-$k$N$G!"(B
$BIaCJ(B@kbd{M-x}$B$G;H$($F$$$k>JN,7A$,(B@kbd{C-h f}$B$G$O;H$($J$$$+$b$7$l$^$;$s!#(B
$B$"$k>JN,7A$,%3%^%s%IL>$H$7$F$O0l0U$G$"$C$?$H$7$F$b!"(B
$BB>$N4X?tL>$r4^$a$F$_$k$H0l0U$G$O$J$$>l9g$b$"$j$^$9!#(B

@c   The function name for @kbd{C-h f} to describe has a default which is
@c used if you type @key{RET} leaving the minibuffer empty.  The default is
@c the function called by the innermost Lisp expression in the buffer around
@c point, @emph{provided} that is a valid, defined Lisp function name.  For
@c example, if point is located following the text @samp{(make-vector (car
@c x)}, the innermost list containing point is the one that starts with
@c @samp{(make-vector}, so the default is to describe the function
@c @code{make-vector}.
$B%_%K%P%C%U%!$G(B@key{RET}$B$@$1$rBG$C$F%_%K%P%C%U%!$,6u$N>l9g!"(B
@kbd{C-h f}$B$KM?$($i$l$k4X?tL>$K$O%G%U%)%k%HCM$,$"$j$^$9!#(B
$B%G%U%)%k%HCM$O!"%P%C%U%!Fb$N%]%$%s%H<~JU$G$b$C$H$bFbB&$N(BLisp$B<0$G(B
$B8F$S=P$5$l$k4X?t$G$9$,!"$=$l$,Dj5A$5$l$?@5$7$$(BLisp$B4X?t$NL>A0$G(B
$B$"$k>l9g$K(B@emph{$B8B$j$^$9(B}$B!#(B
$B$?$H$($P!"(B@samp{(make-vector (car x)}$B$H$$$&%F%-%9%H$ND>8e$K%]%$%s%H$,$"$k$H!"(B
$B%]%$%s%H$r4^$`$b$C$H$bFbB&$N%j%9%H$O(B@samp{(make-vector}$B$+$i;O$^$kItJ,$J$N$G!"(B
$B%G%U%)%k%H$O4X?t(B@code{make-vector}$B$G$9!#(B

@c   @kbd{C-h f} is often useful just to verify that you have the right
@c spelling for the function name.  If @kbd{C-h f} mentions a name from the
@c buffer as the default, that name must be defined as a Lisp function.  If
@c that is all you want to know, just type @kbd{C-g} to cancel the @kbd{C-h
@c f} command, then go on editing.
@kbd{C-h f}$B$O!"4X?tL>$NDV$j$,@5$7$3$H$r(B
$BC1$K3NG'$9$k$?$a$@$1$K$bLrN)$A$^$9!#(B
@kbd{C-h f}$B$,%P%C%U%!Fb$NL>A0$r%G%U%)%k%H$H$7$FI=<($9$l$P!"(B
$B$=$NL>A0$O(BLisp$B4X?t$H$7$FDj5A$5$l$F$$$k$O$:$G$9!#(B
$B$3$l$@$1$r3NG'$7$?$$$N$G$"$l$P!"(B
@kbd{C-g}$B$rBG$C$F(B@kbd{C-h f}$B%3%^%s%I$r<h$j>C$7$F!"JT=8$rB3$1$^$9!#(B

@kindex C-h w
@findex where-is
@c   @kbd{C-h w @var{command} @key{RET}} tells you what keys are bound to
@c @var{command}.  It prints a list of the keys in the echo area.  If it
@c says the command is not on any key, you must use @kbd{M-x} to run it.
@c @kbd{C-h w} runs the command @code{where-is}.
@kbd{C-h w @var{command} @key{RET}}$B$O!"(B
$B$I$N%-!<$r(B@var{command}$B$K%P%$%s%I$7$F$"$k$+$rI=<($7$^$9!#(B
$B%-!<$N0lMw$r%(%3!<NN0h$KI=<($7$^$9!#(B
$B$I$N%-!<$K$b3d$jEv$F$i$l$F$$$J$$$HI=<($5$l$?>l9g$O!"(B
$B$=$N%3%^%s%I$O(B@kbd{M-x}$B$G5/F0$9$kI,MW$,$"$j$^$9!#(B
@kbd{C-h w}$B$O%3%^%s%I(B@code{where-is}$B$r<B9T$7$^$9!#(B

@c   @kbd{C-h v} (@code{describe-variable}) is like @kbd{C-h f} but describes
@c Lisp variables instead of Lisp functions.  Its default is the Lisp symbol
@c around or before point, but only if that is the name of a known Lisp
@c variable.  @xref{Variables}.@refill
@kbd{C-h v}$B!J(B@code{describe-variable}$B!K$O(B@kbd{C-h f}$B$K;w$F$$$^$9$,!"(B
Lisp$B4X?t$G$O$J$/(BLisp$BJQ?t$r@bL@$9$kE@$,0[$J$j$^$9!#(B
$B%G%U%)%k%H$O%]%$%s%H<~JU$^$?$O%]%$%s%H$ND>A0$N(BLisp$B%7%s%\%k$G$9$,!"(B
$B4{CN$N(BLisp$BJQ?t$K8B$j$^$9!#(B
@xref{Variables}$B!#(B

@node Apropos
@c @section Apropos
@section $B%"%W%m%]%9(B

@kindex C-h a
@findex apropos-command
@c @cindex apropos
@cindex $B%"%W%m%]%9(B
@c   A more sophisticated sort of question to ask is, ``What are the
@c commands for working with files?''  To ask this question, type @kbd{C-h
@c a file @key{RET}}, which displays a list of all command names that
@c contain @samp{file}, including @code{copy-file}, @code{find-file}, and
@c so on.  With each command name appears a brief description of how to use
@c the command, and what keys you can currently invoke it with.  For
@c example, it would say that you can invoke @code{find-file} by typing
@c @kbd{C-x C-f}.  The @kbd{a} in @kbd{C-h a} stands for `Apropos';
@c @kbd{C-h a} runs the command @code{apropos-command}.  This command
@c normally checks only commands (interactive functions); if you specify a
@c prefix argument, it checks noninteractive functions as well.
$B$h$j@vN}$5$l$?<ALdJ}K!$H$7$F$O!"!X%U%!%$%k$r07$&%3%^%s%I$O!)!Y$H(B
$B$$$&$N$,$"$j$^$9!#(B
$B$3$N$h$&$K<ALd$9$k$K$O!"(B@kbd{C-h a file @key{RET}}$B$HBG$A$^$9!#(B
$B$9$k$H!"(B@code{copy-file}$B$d(B@code{find-file}$B$H$$$C$?!"(B
@samp{file}$B$rL>A0$K4^$`$9$Y$F$N%3%^%s%I$N0lMw$,I=<($5$l$^$9!#(B
$B3F%3%^%s%I$K$O!";H$$J}$N4JC1$J@bL@$d(B
$B$=$N%3%^%s%I$r5/F0$9$k%-!<$,I=<($5$l$^$9!#(B
$B$?$H$($P!"(B@code{find-file}$B$r5/F0$9$k$K$O(B@kbd{C-x C-f}$B$HBG$D!"(B
$B$H$$$C$?6q9g$G$9!#(B
@kbd{C-h a}$B$N(B@kbd{a}$B$O!V(BApropos$B!W!J!VE,@Z$J!W$N0UL#!K$rI=$7$F$$$F!"(B
@kbd{C-h a}$B$O%3%^%s%I(B@code{apropos-command}$B$r<B9T$7$^$9!#(B
$B$3$N%3%^%s%I$O!"DL>o!"%3%^%s%I!JBPOCE*$J4X?t!K$N$_$rD4$Y$^$9!#(B
$BA0CV0z?t$r;XDj$9$l$P!"HsBPOCE*$J4X?t$bD4$Y$^$9!#(B

@c   Because @kbd{C-h a} looks only for functions whose names contain the
@c string you specify, you must use ingenuity in choosing the
@c string.  If you are looking for commands for killing backwards and
@c @kbd{C-h a kill-backwards @key{RET}} doesn't reveal any, don't give up.
@c Try just @kbd{kill}, or just @kbd{backwards}, or just @kbd{back}.  Be
@c persistent.  Also note that you can use a regular expression as the
@c argument, for more flexibility (@pxref{Regexps}).
@kbd{C-h a}$B$O;XDj$7$?J8;zNs$rL>A0$K4^$`4X?t$7$+D4$Y$^$;$s$N$G!"(B
$BJ8;zNs$N;XDj$K$O9)IW$,I,MW$G$9!#(B
$B8e8~$-$KJ8;z$r%-%k$9$k%3%^%s%I$rC5$=$&$H$7$F!"(B
@kbd{C-h a kill-backwards @key{RET}}$B$G(B
$B2?$bI=<($5$l$J$/$F$b$"$-$i$a$J$$$G$/$@$5$$!#(B
@kbd{kill}$B$N$_!"$"$k$$$O(B@kbd{backwards}$B$N$_!"(B
$B$b$7$/$O(B@kbd{back}$B$N$_$r;n$7$F!"B3$1$F$/$@$5$$!#(B
$B=@Fp@-$rA}$9$?$a$K!"0z?t$H$7$F@55,I=8=$b;H$($^$9(B
$B!J(B@pxref{Regexps}$B!K!#(B

@c   Here is a set of arguments to give to @kbd{C-h a} that covers many
@c classes of Emacs commands, since there are strong conventions for naming
@c the standard Emacs commands.  By giving you a feel for the naming
@c conventions, this set should also serve to aid you in developing a
@c technique for picking @code{apropos} strings.
$B0J2<$K!"(B@kbd{C-h a}$B$K;XDj$9$k0z?t$N$&$A!"(B
Emacs$B%3%^%s%I$NB?$/$N<oN`$rLVMe$9$k$b$N$r$"$2$F$*$-$^$9!#(B
$B$H$$$&$N$O!"(BEmacs$B%3%^%s%I$NI8=`$NL?L>K!$K$O6/$$479T$,$"$k$+$i$G$9!#(B
$BL?L>K!$N479T$rM}2r$7$F$b$i$($P!"(B
$BE,@Z$J!J(B@code{apropos}$B!KJ8;zNs$r=&$$=P$95;K!$N8~>e$N<j=u$1$K$b$J$k$G$7$g$&!#(B

@quotation
@c char, line, word, sentence, paragraph, region, page, sexp, list, defun,
@c rect, buffer, frame, window, face, file, dir, register, mode, beginning, end,
@c forward, backward, next, previous, up, down, search, goto, kill, delete,
@c mark, insert, yank, fill, indent, case, change, set, what, list, find,
@c view, describe, default.
char$B!"(Bline$B!"(Bword$B!"(Bsentence$B!"(Bparagraph$B!"(Bregion$B!"(Bpage$B!"(Bsexp$B!"(Blist$B!"(Bdefun$B!"(B
rect$B!"(Bbuffer$B!"(Bframe$B!"(Bwindow$B!"(Bface$B!"(Bfile$B!"(Bdir$B!"(Bregister$B!"(Bmode$B!"(Bbeginning$B!"(Bend$B!"(B
forward$B!"(Bbackward$B!"(Bnext$B!"(Bprevious$B!"(Bup$B!"(Bdown$B!"(Bsearch$B!"(Bgoto$B!"(Bkill$B!"(Bdelete$B!"(B
mark$B!"(Binsert$B!"(Byank$B!"(Bfill$B!"(Bindent$B!"(Bcase$B!"(Bchange$B!"(Bset$B!"(Bwhat$B!"(Blist$B!"(Bfind$B!"(B
view$B!"(Bdescribe$B!"(Bdefault$B!#(B
@end quotation

@findex apropos-variable
@c   To list all user variables that match a regexp, use the command
@c @kbd{M-x apropos-variable}. This command shows only user variables and
@c customization options by default; if you specify a prefix argument, it
@c checks all variables.
$B@55,I=8=$K0lCW$9$k$9$Y$F$N%f!<%6!<JQ?t$rI=<($9$k$K$O!"(B
$B%3%^%s%I(B@kbd{M-x apropos-variable}$B$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$O!"%G%U%)%k%H$G$O!"%f!<%6!<JQ?t$H%+%9%?%^%$%:%*%W%7%g%s$@$1$r(B
$BI=<($7$^$9!#(B
$B$9$Y$F$NJQ?t$rD4$Y$k$K$O!"A0CV0z?t$r;XDj$7$^$9!#(B

@findex apropos
@c   To list all Lisp symbols that contain a match for a regexp, not just
@c the ones that are defined as commands, use the command @kbd{M-x apropos}
@c instead of @kbd{C-h a}.  This command does not check key bindings by
@c default; specify a numeric argument if you want it to check them.
$B%3%^%s%I$H$7$FDj5A$5$l$F$$$k$b$N$@$1$G$J$/!"(B
$B@55,I=8=$K0lCW$9$k$9$Y$F$N(BLisp$B%7%s%\%k$rI=<($9$k$K$O!"(B
@kbd{C-h a}$B$N$+$o$j$K(B@kbd{M-x apropos}$B$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$O!"%G%U%)%k%H$G$O!"%-!<%P%$%s%I$rD4$Y$^$;$s!#(B
$B%-!<%P%$%s%I$rD4$Y$k$K$O!"A0CV0z?t$r;XDj$7$^$9!#(B

@findex apropos-documentation
@c   The @code{apropos-documentation} command is like @code{apropos} except
@c that it searches documentation strings as well as symbol names for
@c matches for the specified regular expression.
@code{apropos-documentation}$B%3%^%s%I$O(B@code{apropos}$B$K;w$F$$$^$9$,!"(B
$B;XDj$7$?@55,I=8=$K0lCW$9$k%7%s%\%kL>$@$1$G$J$/!"(B
$B@bL@J8;zNs$bC5:w$9$kE@$,0[$J$j$^$9!#(B

@findex apropos-value
@c   The @code{apropos-value} command is like @code{apropos} except that it
@c searches symbols' values for matches for the specified regular
@c expression.  This command does not check function definitions or
@c property lists by default; specify a numeric argument if you want it to
@c check them.
@code{apropos-value}$B%3%^%s%I$O(B@code{apropos}$B$K;w$F$$$^$9$,!"(B
$B;XDj$7$?@55,I=8=$K0lCW$9$k%7%s%\%k$NCM$rC5$9E@$,0[$J$j$^$9!#(B
$B$3$N%3%^%s%I$O!"%G%U%)%k%H$G$O!"4X?tDj5A$dB0@-%j%9%H$rD4$Y$^$;$s!#(B
$B$=$l$i$bD4$Y$k$K$O!"A0CV0z?t$r;XDj$7$^$9!#(B

@vindex apropos-do-all
@c   If the variable @code{apropos-do-all} is non-@code{nil}, the commands
@c above all behave as if they had been given a prefix argument.
$BJQ?t(B@code{apropos-do-all}$B$,(B@code{nil}$B0J30$J$i$P!"(B
$B>e$K=R$Y$?%3%^%s%I$O$9$Y$F!"A0CV0z?t$r;XDj$7$?$b$N$H$7$FF0:n$7$^$9!#(B

@c   If you want more information about a function definition, variable or
@c symbol property listed in the Apropos buffer, you can click on it with
@c @kbd{Mouse-2} or move there and type @key{RET}.
$B%"%W%m%]%9!J(Bapropos$B!K%P%C%U%!$KI=<($5$l$?4X?tDj5A!"(B
$BJQ?t!"B0@-%j%9%H$K$D$$$F>\$7$/CN$j$?$$$H$-$K$O!"(B
@kbd{Mouse-2}$B%\%?%s$G%/%j%C%/$9$k$+!"(B
$B$=$N2U=j$X0\F0$7$F(B@key{RET}$B$rBG$A$^$9!#(B

@node Library Keywords
@c @section Keyword Search for Lisp Libraries
@section Lisp$B%i%$%V%i%j$KBP$9$k%-!<%o!<%IC5:w(B

@kindex C-h p
@findex finder-by-keyword
@c The @kbd{C-h p} command lets you search the standard Emacs Lisp
@c libraries by topic keywords.  Here is a partial list of keywords you can
@c use:
@kbd{C-h p}$B%3%^%s%I$G!"(B
$BI8=`(BEmacs Lisp$B%i%$%V%i%j$r%H%T%C%/$N%-!<%o!<%I$G8!:w$G$-$^$9!#(B
$BMxMQ2DG=$J%-!<%o!<%I$N0lIt$r0J2<$K<($7$^$9!#(B

@display
@c abbrev --- abbreviation handling, typing shortcuts, macros.
abbrev --- $BN,8lA`:n!"C;=LF~NO!"%^%/%m!#(B
@c bib --- support for the bibliography processor @code{bib}.
bib --- $B;29M!";2>H%W%m%;%C%5;Y1g(B@code{bib}$B!#(B
@c c --- C and C++ language support.
c --- C$B8@8l$"$k$$$O(BC++$B;Y1g!#(B
@c calendar --- calendar and time management support.
calendar --- $BF|IU$*$h$S;~4V4IM};Y1g!#(B
@c comm --- communications, networking, remote access to files.
comm --- $BDL?.!"%M%C%H%o!<%/!"%U%!%$%k$N%j%b!<%H%"%/%;%9!#(B
@c data --- support for editing files of data.
data --- $B%G!<%?%U%!%$%k$NJT=8;Y1g!#(B
@c docs --- support for Emacs documentation.
docs --- Emacs$B%I%-%e%a%s%H$K4X$9$k;Y1g!#(B
@c emulations --- emulations of other editors.
emulations --- $BB>$N%(%G%#%?$N%(%_%e%l!<%7%g%s!#(B
@c extensions --- Emacs Lisp language extensions.
extensions --- Emacs Lisp$B8@8l$N3HD%!#(B
@c faces --- support for using faces (fonts and colors; @pxref{Faces}).
faces --- $B%U%'%$%9!J%U%)%s%H$dI=<(?'!"(B@pxref{Faces}$B!K$K4X$9$k;Y1g!#(B
@c frames --- support for Emacs frames and window systems.
frames --- Emacs$B%U%l!<%`$d%&%#%s%I%&%7%9%F%`$KBP$9$k;Y1g!#(B
@c games --- games, jokes and amusements.
games --- $B%2!<%`!"%8%g!<%/!"8d3Z!#(B
@c hardware --- support for interfacing with exotic hardware.
hardware --- $B30It%O!<%I%&%'%"$H$N%$%s%?!<%U%'%$%9;Y1g!#(B
@c help --- support for on-line help systems.
help --- $B%*%s%i%$%s%X%k%W%7%9%F%`;Y1g!#(B
@c hypermedia --- support for links within text, or other media types.
hypermedia --- $B%F%-%9%H$"$k$$$OB>%a%G%#%"Fb$G$N%j%s%/;Y1g!#(B
@c i18n --- internationalization and alternate character-set support.
i18n --- $B9q:]2=!"BeBXJ8;z=89g;Y1g!#(B
@c internal --- code for Emacs internals, build process, defaults.
internal --- Emacs$BFbIt%3!<%I!"9=C[<j=g!"%G%U%)%k%H!#(B
@c languages --- specialized modes for editing programming languages.
languages --- $B%W%m%0%i%`8@8lJT=8MQ$NFC<l%b!<%I!#(B
@c lisp --- support for using Lisp (including Emacs Lisp).
lisp --- Lisp$BMxMQ;Y1g!J(BEmacs Lisp$B$b4^$`!K!#(B
@c local --- libraries local to your site.
local --- $B%5%$%H$K%m!<%+%k$J%i%$%V%i%j!#(B
@c maint --- maintenance aids for the Emacs development group.
maint --- Emacs$B3+H/%0%k!<%W8~$1$N4IM}MQ!#(B
@c mail --- modes for electronic-mail handling.
mail --- $BEE;R%a%$%kA`:nMQ$N%b!<%I!#(B
@c matching --- searching and matching.
matching --- $BC5:w!"0lCW!#(B
@c news --- support for netnews reading and posting.
news --- $B%M%C%H%K%e!<%9$N9XFI!"Ej9F;Y1g!#(B
@c non-text --- support for editing files that are not ordinary text.
non-text --- $BHs%F%-%9%H%U%!%$%kJT=8;Y1g!#(B
@c oop --- support for object-oriented programming.
oop --- $B%*%V%8%'%/%H;X8~%W%m%0%i%_%s%0;Y1g!#(B
@c outlines --- hierarchical outlining.
outlines --- $B3,AX%"%&%H%i%$%s!#(B
@c processes --- process, subshell, compilation, and job control support.
processes --- $B%W%m%;%9!"%5%V%7%'%k!"%3%s%Q%$%k!"%8%g%V@)8f;Y1g!#(B
@c terminals --- support for terminal types.
terminals --- $BC<Kv%?%$%W;Y1g!#(B
@c tex --- support for the @TeX{} formatter.
tex --- @TeX{}$B$K$h$kJ8=q@07A;Y1g!#(B
@c tools --- programming tools.
tools --- $B%W%m%0%i%_%s%0%D!<%k!#(B
@c unix --- front-ends/assistants for, or emulators of, Unix features.
unix --- UNIX$B5!G=$N%U%m%s%H%(%s%I!?%"%7%9%?%s%H$"$k$$$O%(%_%e%l!<%7%g%s!#(B
@c vms --- support code for VMS.
vms --- VMS$B;Y1g%3!<%I!#(B
@c wp --- word processing.
wp --- $B%o!<%W%m!#(B
@end display

@node Language Help
@c @section Help for International Language Support
@section $BB?8@8l;Y1g$K4X$9$k%X%k%W(B

@c   You can use the command @kbd{C-h L}
@c (@code{describe-language-environment}) to find out the support for a
@c specific language environment.  @xref{Language Environments}.  This
@c tells you which languages this language environment is useful for, and
@c lists the character sets, coding systems, and input methods that go with
@c it.  It also shows some sample text to illustrate scripts.
$B%3%^%s%I(B@kbd{C-h L}$B!J(B@code{describe-language-environment}$B!K$r;H$&$H!"(B
$BFCDj$N8@8l4D6-8~$1$K!"$I$N$h$&$J;Y1g$,$"$k$+$rGD0.$G$-$^$9!#(B
@xref{Language Environments}$B!#(B
$B$3$N%3%^%s%I$O!":#$N8@8l4D6-$,$I$N8@8l8~$1$J$N$+$r<($7!"(B
$B0l=o$K;H$o$l$kJ8;z=89g!"%3!<%G%#%s%0%7%9%F%`!"F~NOJ}<0$bI=<($7$^$9!#(B
$B$^$?!";zBN$rNc<($9$k$?$a$N%5%s%W%k%F%-%9%H$b$$$/$D$+I=<($7$^$9!#(B

@c   The command @kbd{C-h h} (@code{view-hello-file}) displays the file
@c @file{etc/HELLO}, which shows how to say ``hello'' in many languages.
$B%3%^%s%I(B@kbd{C-h h}$B!J(B@code{view-hello-file}$B!K$O!"(B
$B%U%!%$%k(B@file{etc/HELLO}$B$rI=<($7$^$9!#(B
$B$3$N%U%!%$%k$K$O!"$$$m$$$m$J9q$N8@MU$G=q$$$?!X(Bhello$B!Y$r<}$a$F$"$j$^$9!#(B

@c   The command @kbd{C-h I} (@code{describe-input-method}) describes
@c information about input methods---either a specified input method, or by
@c default the input method in use.  @xref{Input Methods}.
$B%3%^%s%I(B@kbd{C-h I}$B!J(B@code{describe-input-method}$B!K$O!"(B
$B;XDj$7$?F~NOJ}<0!"$"$k$$$O!"%G%U%)%k%H$H$7$F(B
$B:#;H$C$F$$$kF~NOJ}<0$K$D$$$F$N>pJs$rI=<($7$^$9!#(B
@xref{Input Methods}$B!#(B

@c   The command @kbd{C-h C} (@code{describe-coding-system}) describes
@c information about coding systems---either a specified coding system, or
@c the ones currently in use.  @xref{Coding Systems}.
$B%3%^%s%I(B@kbd{C-h C}$B!J(B@code{describe-coding-system}$B!K$O!"(B
$B;XDj$7$?%3!<%G%#%s%0%7%9%F%`!"$"$k$$$O!"%G%U%)%k%H$H$7$F(B
$B:#;H$C$F$$$k%3!<%G%#%s%0%7%9%F%`$K$D$$$F$N>pJs$rI=<($7$^$9!#(B
@xref{Coding Systems}$B!#(B

@node Help Mode
@c @section Help Mode Commands
@section $B%X%k%W%b!<%I$N%3%^%s%I(B

@c   Help buffers provide the commands of View mode (@pxref{Misc File
@c Ops}), plus a few special commands of their own.
$B%X%k%W%P%C%U%!$K$O!"1\Mw!J(Bview$B!K%b!<%I!J(B@pxref{Misc File Ops}$B!K$N(B
$B%3%^%s%I$K2C$($F!"FH<+$NFCJL$J%3%^%s%I$b$$$/$D$+$"$j$^$9!#(B

@table @kbd
@item @key{SPC}
@c Scroll forward.
$BA08~$-$K%9%/%m!<%k$9$k!#(B
@item @key{DEL}
@c Scroll backward.
$B8e8~$-$K%9%/%m!<%k$9$k!#(B
@item @key{RET}
@c Follow a cross reference at point.
$B%]%$%s%H0LCV$NAj8_;2>H$rC)$k!#(B
@item @key{TAB}
@c Move point forward to the next cross reference.
$B$D$.$NAj8_;2>H$X?J$`!#(B
@item S-@key{TAB}
@c Move point back to the previous cross reference.
$B$^$($NAj8_;2>H$XLa$k!#(B
@item Mouse-2
@c Follow a cross reference that you click on.
$B%/%j%C%/$7$?Aj8_;2>H$rC)$k!#(B
@end table

@c   When a command name (@pxref{M-x,, Running Commands by Name}) or
@c variable name (@pxref{Variables}) appears in the documentation, it
@c normally appears inside paired single-quotes.  You can click on the name
@c with @kbd{Mouse-2}, or move point there and type @key{RET}, to view the
@c documentation of that command or variable.  Use @kbd{C-c C-b} to retrace
@c your steps.
$B@bL@J8$K8=$l$k%3%^%s%IL>!J(B@pxref{M-x}$B!K$dJQ?tL>!J(B@pxref{Variables}$B!K$O(B
$BDL>o!"0zMQId!J(B@code{'}$B!K$G0O$^$l$F$$$^$9!#(B
$B$=$NL>A0$r(B@kbd{Mouse-2}$B$G%/%j%C%/$7$?$j!"$"$k$$$O!"(B
$B$=$3$X%]%$%s%H$r0\F0$7$F(B@key{RET}$B$rBG$D$H!"(B
$B$=$N%3%^%s%I$dJQ?t$N@bL@J8;zNs$rI=<($G$-$^$9!#(B
$B$b$H$N>l=j$KLa$k$K$O(B@kbd{C-c C-b}$B$r;H$$$^$9!#(B

@c @kindex @key{TAB} @r{(Help mode)}
@kindex @key{TAB} @r{$B!J%X%k%W%b!<%I!K(B}
@findex help-next-ref
@c @kindex S-@key{TAB} @r{(Help mode)}
@kindex S-@key{TAB} @r{$B!J%X%k%W%b!<%I!K(B}
@findex help-previous-ref
@c   There are convenient commands for moving point to cross references in
@c the help text.  @key{TAB} (@code{help-next-ref}) moves point down to the
@c next cross reference.  Use @kbd{S-@key{TAB}} to move point up to the
@c previous cross reference (@code{help-previous-ref}).
$B%X%k%W%F%-%9%HFb$NAj8_;2>H$K%]%$%s%H$r0\F0$9$kJXMx$J%3%^%s%I$,$"$j$^$9!#(B
@key{TAB}$B!J(B@code{help-next-ref}$B!K$O!"(B
$B%]%$%s%H$r$D$.$NAj8_;2>H2U=j$X?J$a$^$9!#(B
$B%]%$%s%H$r$^$($NAj8_;2>H2U=j$XLa$9$K$O(B
@kbd{S-@key{TAB}}$B!J(B@code{help-previous-ref}$B!K$r;H$$$^$9!#(B

@node Misc Help
@c @section Other Help Commands
@section $B$=$NB>$N%X%k%W%3%^%s%I(B

@kindex C-h i
@findex info
@c @cindex Info
@cindex info
@c @cindex manuals, on-line
@cindex $B%^%K%e%"%k!"%*%s%i%$%s(B
@c @cindex on-line manuals
@cindex $B%*%s%i%$%s%^%K%e%"%k(B
@c   @kbd{C-h i} (@code{info}) runs the Info program, which is used for
@c browsing through structured documentation files.  The entire Emacs manual
@c is available within Info.  Eventually all the documentation of the GNU
@c system will be available.  Type @kbd{h} after entering Info to run
@c a tutorial on using Info.
@kbd{C-h i}$B!J(B@code{info}$B!K$O(Binfo$B%W%m%0%i%`$r<B9T$7$^$9!#(B
info$B$O9=B$2=$5$l$?%I%-%e%a%s%H%U%!%$%k$r1\Mw$9$k%W%m%0%i%`$G$9!#(B
Emacs$B$N40A4$J%^%K%e%"%k$b(Binfo$B$GFI$`$3$H$,$G$-$^$9!#(B
$B>-MhE*$K$O!"(BGNU$B%7%9%F%`$N$9$Y$F$N%I%-%e%a%s%H$,FI$a$k$h$&$K$J$k$G$7$g$&!#(B
info$B$N;H$$J}$K$D$$$F$N%A%e!<%H%j%"%k$r5/F0$9$k$K$O!"(B
info$B$KF~$C$F$+$i(B@kbd{h}$B$HBG$A$^$9!#(B

@c   If you specify a numeric argument, @kbd{C-h i} prompts for the name of
@c a documentation file.  This way, you can browse a file which doesn't
@c have an entry in the top-level Info menu.  It is also handy when you
@c need to get to the documentation quickly, and you know the exact name of
@c the file.
$B?t0z?t$r;XDj$9$k$H!"(B@kbd{C-h i}$B$O%I%-%e%a%s%H%U%!%$%k$NL>A0$rJ9$$$F$-$^$9!#(B
$B$3$&$9$l$P!"%H%C%W%l%Y%k$N(Binfo$B%a%K%e!<$K5-:\$5$l$F$$$J$$(B
$B%U%!%$%k$G$b1\Mw$G$-$^$9!#(B

@kindex C-h C-f
@kindex C-h C-k
@findex Info-goto-emacs-key-command-node
@findex Info-goto-emacs-command-node
@c   There are two special help commands for accessing Emacs documentation
@c through Info.  @kbd{C-h C-f @var{function} @key{RET}} enters Info and
@c goes straight to the documentation of the Emacs function
@c @var{function}.  @kbd{C-h C-k @var{key}} enters Info and goes straight
@c to the documentation of the key @var{key}.  These two keys run the
@c commands @code{Info-goto-emacs-command-node} and
@c @code{Info-goto-emacs-key-command-node}.
info$B$r2p$7$F(BEmacs$B%I%-%e%a%s%H$r;2>H$9$k$?$a$N(B
$BFCJL$J%X%k%W%3%^%s%I$,(B2$B$D$"$j$^$9!#(B
@kbd{C-h C-f @var{function} @key{RET}}$B$O!"(B
info$B$KF~$C$F$?$@$A$K(BEmacs$B$N4X?t(B@var{function}$B$N%I%-%e%a%s%H$K0\F0$7$^$9!#(B
@kbd{C-h C-k @var{key}}$B$O!"(B
info$B$KF~$C$F$?$@$A$K%-!<(B@var{key}$B$N%I%-%e%a%s%H$K0\F0$7$^$9!#(B
$B$3$l$i(B2$B$D$N%-!<$O!"$=$l$>$l!"(B
@code{Info-goto-emacs-command-node}$B!"(B
@code{Info-goto-emacs-key-command-node}$B$r<B9T$7$^$9!#(B

@c   When editing a program, if you have an Info version of the manual for
@c the programming language, you can use the command @kbd{C-h C-i} to refer
@c to the manual documentation for a symbol (keyword, function or
@c variable).  The details of how this command works depend on the major
@c mode.
$B%W%m%0%i%`8@8l$N(Binfo$BHG$N%^%K%e%"%k$,$"$l$P!"(B
$B%W%m%0%i%`$NJT=8Cf$K%3%^%s%I(B@kbd{C-h C-i}$B$r;H$C$F!"(B
$B%^%K%e%"%k%I%-%e%a%s%H$N(B
$B%7%s%\%k!J%-!<%o!<%I!"4X?t!"JQ?t!K$K4X$9$k2U=j$r;2>H$G$-$^$9!#(B
$B%3%^%s%I$N:Y$+$$F0:n$O!"%a%8%c!<%b!<%I$K0MB8$7$^$9!#(B

@kindex C-h l
@findex view-lossage
@c   If something surprising happens, and you are not sure what commands you
@c typed, use @kbd{C-h l} (@code{view-lossage}).  @kbd{C-h l} prints the last
@c 100 command characters you typed in.  If you see commands that you don't
@c know, you can use @kbd{C-h c} to find out what they do.
$BM=4|$7$J$+$C$?$3$H$,5/$-$?$j!"(B
$BF~NO$7$?%3%^%s%I$,$o$+$i$J$/$J$C$F$7$^$C$?$H$-$O!"(B
@kbd{C-h l}$B!J(B@code{view-lossage}$B!K$r;H$C$F$/$@$5$$!#(B
@kbd{C-h l}$B$O!"$=$l$^$G$KBG80$7$?:G8e$N(B100$B8D$N%3%^%s%IJ8;z$rI=<($7$^$9!#(B
$BCN$i$J$$%3%^%s%I$,I=<($5$l$?$i!"(B@kbd{C-h c}$B$G$=$N5!G=$rCN$k$3$H$,$G$-$^$9!#(B

@kindex C-h m
@findex describe-mode
@c   Emacs has numerous major modes, each of which redefines a few keys and
@c makes a few other changes in how editing works.  @kbd{C-h m}
@c (@code{describe-mode}) prints documentation on the current major mode,
@c which normally describes all the commands that are changed in this
@c mode.
Emacs$B$K$O?tB?$/$N%a%8%c!<%b!<%I$,$"$j!"3F%a%8%c!<%b!<%I$G$O!"(B
$B$$$/$D$+$N%-!<$r:FDj5A$7!"JT=8F0:n$b>/!9JQ99$7$F$$$^$9!#(B
@kbd{C-h m}$B!J(B@code{describe-mode}$B!K$O!"(B
$B;HMQCf$N%a%8%c!<%b!<%I$K$D$$$F$N@bL@J8$rI=<($7$^$9!#(B
$B$3$l$K$O!"DL>o!"%b!<%IFb$GJQ99$7$F$"$k(B
$B$9$Y$F$N%3%^%s%I$K$D$$$F$N5-=R$,$"$j$^$9!#(B

@kindex C-h b
@findex describe-bindings
@c   @kbd{C-h b} (@code{describe-bindings}) and @kbd{C-h s}
@c (@code{describe-syntax}) present other information about the current
@c Emacs mode.  @kbd{C-h b} displays a list of all the key bindings now in
@c effect; the local bindings defined by the current minor modes first,
@c then the local bindings defined by the current major mode, and finally
@c the global bindings (@pxref{Key Bindings}).  @kbd{C-h s} displays the
@c contents of the syntax table, with explanations of each character's
@c syntax (@pxref{Syntax}).
@kbd{C-h b}$B!J(B@code{describe-bindings}$B!K$H(B
@kbd{C-h s}$B!J(B@code{describe-syntax}$B!K$O!"(B
Emacs$B$N8=:_$N%b!<%I$K4X$9$k$=$NB>$N>pJs$rM?$($F$/$l$^$9!#(B
@kbd{C-h b}$B$O!"8=:_M-8z$J$9$Y$F$N%-!<%P%$%s%I$N0lMw$rI=<($7$^$9!#(B
$B%^%$%J%b!<%I$GDj5A$5$l$F$$$k%m!<%+%k%P%$%s%G%#%s%0$+$i;O$a$F!"(B
$B8=:_$N%a%8%c!<%b!<%I$GDj5A$5$l$F$$$k%m!<%+%k%P%$%s%G%#%s%0!"(B
$B:G8e$K%0%m!<%P%k%P%$%s%G%#%s%0$rI=<($7$^$9(B
$B!J(B@pxref{Key Bindings}$B!K!#(B
@kbd{C-h s}$B$O!"3FJ8;z$N9=J8$N@bL@$rIU$1$F(B
$B9=J8%F!<%V%k$NFbMF$rI=<($7$^$9!J(B@pxref{Syntax}$B!K!#(B

@c   You can get a similar list for a particular prefix key by typing
@c @kbd{C-h} after the prefix key.  (There are a few prefix keys for which
@c this does not work---those that provide their own bindings for
@c @kbd{C-h}.  One of these is @key{ESC}, because @kbd{@key{ESC} C-h} is
@c actually @kbd{C-M-h}, which marks a defun.)
$B%W%l%U%#%C%/%9%-!<$KB3$1$F(B@kbd{C-h}$B$rBG$F$P!"(B
$BFCDj$N%W%l%U%#%C%/%9%-!<$K$D$$$FF1MM$J0lMw$rI=<($G$-$^$9!#(B
$B!J$3$NJ}K!$G$OI=<($G$-$J$$%W%l%U%#%C%/%9%-!<$bB8:_$9$k!#(B
$B$=$l$i$N%-!<$G$O!"(B@kbd{C-h}$B$KBP$7$F$OFH<+$N%P%$%s%G%#%s%0$,$"$k!#(B
@key{ESC}$B$O!"$=$N$h$&$J$b$N$N(B1$B$D!#(B
@kbd{@key{ESC} C-h}$B$O!"<B:]$K$O(B@kbd{C-M-h}$B$G$"$j!"(B
$B4X?tDj5A!J(Bdefun$B!K$r%^!<%/$9$k!#!K(B

@kindex C-h F
@findex view-emacs-FAQ
@kindex C-h n
@findex view-emacs-news
@kindex C-h C-c
@findex describe-copying
@kindex C-h C-d
@findex describe-distribution
@kindex C-h C-w
@findex describe-no-warranty
@kindex C-h C-p
@findex describe-project
@c   The other @kbd{C-h} options display various files of useful
@c information.  @kbd{C-h C-w} displays the full details on the complete
@c absence of warranty for GNU Emacs.  @kbd{C-h n} (@code{view-emacs-news})
@c displays the file @file{emacs/etc/NEWS}, which contains documentation on
@c Emacs changes arranged chronologically.  @kbd{C-h F}
@c (@code{view-emacs-FAQ}) displays the Emacs frequently-answered-questions
@c list.  @kbd{C-h t} (@code{help-with-tutorial}) displays the
@c learn-by-doing Emacs tutorial.  @kbd{C-h C-c} (@code{describe-copying})
@c displays the file @file{emacs/etc/COPYING}, which tells you the
@c conditions you must obey in distributing copies of Emacs.  @kbd{C-h C-d}
@c (@code{describe-distribution}) displays the file
@c @file{emacs/etc/DISTRIB}, which tells you how you can order a copy of
@c the latest version of Emacs.  @kbd{C-h C-p} (@code{describe-project})
@c displays general information about the GNU Project.
@kbd{C-h}$B$NB>$N%*%W%7%g%s$O!"(B
$BM-1W$J>pJs$r<}$a$?$5$^$6$^$J%U%!%$%k$rI=<($7$^$9!#(B
@kbd{C-h C-w}$B$O!"(B
GNU Emacs$B$,$^$C$?$/L5J]>Z$G$"$k$3$H$K4X$9$kA4>\:Y$rI=<($7$^$9!#(B
@kbd{C-h n}$B!J(B@code{view-emacs-news}$B!K$O!"(B
$B%U%!%$%k(B@file{emacs/etc/NEWS}$B$rI=<($7$^$9!#(B
$B$3$N%U%!%$%k$K$O!"(BEmacs$B$NJQ99$K4X$9$k5-=R$r;~4V=g$K<}$a$F$"$j$^$9!#(B
@kbd{C-h F}$B!J(B@code{view-emacs-FAQ}$B!K$O!"(B
Emacs$B$N!V$h$/$"$k<ALd=8!W$rI=<($7$^$9!#(B
@kbd{C-h t}$B!J(B@code{help-with-tutorial}$B!K$O!"(B
$B!VA`:n$7$J$,$i(BEmacs$B$r3X$V!W%A%e!<%H%j%"%k$rI=<($7$^$9!#(B
@kbd{C-h C-c}$B!J(B@code{describe-copying}$B!K$O!"(B
$B%U%!%$%k(B@file{emacs/etc/COPYING}$B$rI=<($7$^$9!#(B
$B$3$N%U%!%$%k$K$O!"(BEmacs$B$rG[I[$9$k>l9g$K=>$&$Y$->r7o$r5-=R$7$F$"$j$^$9!#(B
@kbd{C-h C-d}$B!J(B@code{describe-distribution}$B!K$O!"(B
$B%U%!%$%k(B@file{emacs/etc/DISTRIB}$B$rI=<($7$^$9!#(B
$B$3$N%U%!%$%k$K$O!"(BEmacs$B$N:G?7HG$NCmJ8J}K!$r=R$Y$F$"$j$^$9!#(B
@kbd{C-h C-p}$B!J(B@code{describe-project}$B!K$O!"(B
GNU$B%W%m%8%'%/%H$K4X$9$k0lHL>pJs$rI=<($7$^$9!#(B