@c =============================================================
@c = $B85(B $BK](B $BLu(B: $BNkLZ1Y;R!wDEED=NBg3X(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) 1997, 1999 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node International, Major Modes, Frames, Top
@c @chapter International Character Set Support
@chapter $B9q:]2=J8;z=89g$N;H$$J}(B
@cindex MULE
@c @cindex international scripts
@c @cindex multibyte characters
@c @cindex encoding of characters
@cindex $B9q:]2=J8;z(B
@cindex $B%^%k%A%P%$%HJ8;z(B
@cindex $BJ8;z$NId9f2=(B

@c @cindex Chinese
@c @cindex Devanagari
@c @cindex Hindi
@c @cindex Marathi
@c @cindex Ethiopian
@c @cindex Greek
@cindex $BCf9q8l(B
@cindex $B%G%P%J!<%,%j!<(B
@cindex $B%R%s%G%#!<8l(B
@cindex $B%^%i%C%?8l(B
@cindex $B%(%A%*%T%"8l(B
@cindex $B%.%j%7%"8l(B
@cindex IPA
@c @cindex Japanese
@c @cindex Korean
@c @cindex Lao
@c @cindex Russian
@c @cindex Thai
@c @cindex Tibetan
@c @cindex Vietnamese
@cindex $BF|K\8l(B
@cindex $B4Z9q8l(B
@cindex $B%i%*8l(B
@cindex $B%m%7%"8l(B
@cindex $B%?%$8l(B
@cindex $B%A%Y%C%H8l(B
@cindex $B%Y%H%J%`8l(B
@c   Emacs supports a wide variety of international character sets,
@c including European variants of the Latin alphabet, as well as Chinese,
@c Devanagari (Hindi and Marathi), Ethiopian, Greek, IPA, Japanese, Korean,
@c Lao, Russian, Thai, Tibetan, and Vietnamese scripts.  These features
@c have been merged from the modified version of Emacs known as MULE (for
@c ``MULti-lingual Enhancement to GNU Emacs'')
Emacs$B$G$O9-HO0O$N9q:]2=J8;z=89g$r;H$($^$9!#(B
$B%i%F%s%"%k%U%!%Y%C%H$NJQ<o$G$"$k%h!<%m%C%Q$N8@8l$O$b$A$m$s!"Cf9q8l!"(B
$B%G%P%J!<%,%j!<!J%R%s%G%#!<8l$H%^%i%C%?8l!K!"%(%A%*%T%"8l!"%.%j%7%"8l!"(B
IPA$B!J(BInternational Phonetic Alphabet$B!"K|9qI=2;J8;z!K!"F|K\8l!"4Z9q8l!"(B
$B%i%*8l!"%m%7%"8l!"%?%$8l!"%A%Y%C%H8l!"%Y%H%J%`8l$NJ8;z$r4^$s$G$$$^$9!#(B
$B$3$l$i$N5!G=$O!"(BMULE$B!J!X(BMULti-lingual Enhancement to GNU Emacs$B!Y!K$H(B
$B$7$FCN$i$l$k(BEmacs$B$N=$@5HG$+$iJ;9g$7$^$7$?!#(B

@menu
* International Intro::     Basic concepts of multibyte characters.
* Enabling Multibyte::      Controlling whether to use multibyte characters.
* Language Environments::   Setting things up for the language you use.
* Input Methods::           Entering text characters not on your keyboard.
* Select Input Method::     Specifying your choice of input methods.
* Multibyte Conversion::    How single-byte characters convert to multibyte.
* Coding Systems::          Character set conversion when you read and
                              write files, and so on.
* Recognize Coding::        How Emacs figures out which conversion to use.
* Specify Coding::          Various ways to choose which conversion to use.
* Fontsets::                Fontsets are collections of fonts
                              that cover the whole spectrum of characters.
* Defining Fontsets::       Defining a new fontset.
* Single-Byte European Support::
                            You can pick one European character set
                            to use without multibyte characters.
@end menu

@node International Intro
@c @section Introduction to International Character Sets
@section $B9q:]2=J8;z=89g$N>R2p(B

@c   The users of these scripts have established many more-or-less standard
@c coding systems for storing files.  Emacs internally uses a single
@c multibyte character encoding, so that it can intermix characters from
@c all these scripts in a single buffer or string.  This encoding
@c represents each non-ASCII character as a sequence of bytes in the range
@c 0200 through 0377.  Emacs translates between the multibyte character
@c encoding and various other coding systems when reading and writing
@c files, when exchanging data with subprocesses, and (in some cases) in
@c the @kbd{C-q} command (@pxref{Multibyte Conversion}).
$B$3$l$i$NJ8;z$N%f!<%6!<$O!"%U%!%$%k$K3JG<$9$k$?$a$K!"(B
$B$?$/$5$s$NI8=`E*$J%3!<%G%#%s%0%7%9%F%`$r3NN)$7$F$-$^$7$?!#(B
Emacs$B$OFbItE*$K$OC10l$N%^%k%A%P%$%HJ8;zId9f2=$r;HMQ$7$F$$$k$N$G!"(B
1$B$D$N%P%C%U%!$d(B1$B$D$NJ8;zNs$NCf$K!"(B
$B$3$l$i$N$9$Y$F$NJ8;z$r:.$<9g$o$;$k$3$H$,$G$-$^$9!#(B
$B$3$NId9f2=$G$O!"Hs(BASCII$BJ8;z$r(B0200$B$+$i(B0377$B$NHO0O$N%P%$%H$N(B
$BJB$S$H$7$FI=8=$7$^$9!#(B
Emacs$B$O!"%U%!%$%k$rFI$_=q$-$9$k$H$-!"%5%V%W%m%;%9$H%G!<%?$r8r49$9$k$H$-!"(B
$B!J>l9g$K$h$C$F$O!K(B@kbd{C-q}$B%3%^%s%I$r;H$&$H$-$K!"(B
$B%^%k%A%P%$%HJ8;zId9f2=$H(B
$BB>$N$5$^$6$^$J%3!<%G%#%s%0%7%9%F%`$N$"$$$@$GJQ49$7$^$9(B
$B!J(B@pxref{Multibyte Conversion}$B!K!#(B

@kindex C-h h
@findex view-hello-file
@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.
@c This illustrates various scripts.
$B%3%^%s%I(B@kbd{C-h h}$B!J(B@code{view-hello-file}$B!K$O!"(B
$BB?$/$N8@8l$G!X(Bhello$B!Y$H=q$$$?%U%!%$%k(B@file{etc/HELLO}$B$rI=<($7$^$9!#(B
$B$3$l$O!"$5$^$6$^$J;zBN$rNc<($7$^$9!#(B

@c   Keyboards, even in the countries where these character sets are used,
@c generally don't have keys for all the characters in them.  So Emacs
@c supports various @dfn{input methods}, typically one for each script or
@c language, to make it convenient to type them.
$B$3$l$i$NJ8;z=89g$r;H$C$F$$$k9q!9$G$"$C$F$b!"(B
$B0lHL$K%-!<%\!<%I$K$O!"(B
$B$=$l$i$9$Y$F$NJ8;z$KBP$9$k%-!<$O$"$j$^$;$s!#(B
$B$G$9$+$i!"(BEmacs$B$G$O$5$^$6$^$J(B@dfn{$BF~NOJ}<0(B}$B!J(Binput methods$B!K(B
@footnote{$B!ZLuCm![(BGNU Emacs$B$r%$%s%9%H!<%k$9$k;~E@$G!"(B
$BBP1~$9$kHG$N(BLEIM$B!J(BLibrary of Emacs Input Method$B!K$N%=!<%9$r(B
GNU Emacs$B$N%=!<%9%G%#%l%/%H%j$KE83+$7$F$*$/$H!"(B
$B<+F0E*$K%$%s%9%H!<%k$5$l$k!#(B}$B$r;H$C$F!"(B
$BJXMx$KJ8;z$rBG$A9~$a$k$h$&$K$7$^$9!#(B
$BE57?E*$K$O!"(B1$B$D$N;zBN$d(B1$B$D$N8@8l$K$D$$$F(B1$B$D$NF~NOJ}<0$,$"$j$^$9!#(B

@kindex C-x RET
@c   The prefix key @kbd{C-x @key{RET}} is used for commands that pertain
@c to multibyte characters, coding systems, and input methods.
$B%W%l%U%#%C%/%9%-!<(B@kbd{C-x @key{RET}}$B$O!"(B
$B%^%k%A%P%$%HJ8;z!"%3!<%G%#%s%0%7%9%F%`!"F~NOJ}<0$K4X78$9$k%3%^%s%I$K;H$$$^$9!#(B

@node Enabling Multibyte
@c @section Enabling Multibyte Characters
@section $B%^%k%A%P%$%HJ8;z$r;HMQ2DG=$K$9$k(B

@c   You can enable or disable multibyte character support, either for
@c Emacs as a whole, or for a single buffer.  When multibyte characters are
@c disabled in a buffer, then each byte in that buffer represents a
@c character, even codes 0200 through 0377.  The old features for
@c supporting the European character sets, ISO Latin-1 and ISO Latin-2,
@c work as they did in Emacs 19 and also work for the other ISO 8859
@c character sets.
Emacs$BA4BN$d%P%C%U%!$4$H$K%^%k%A%P%$%HJ8;z$N;HMQ2D!?;HMQIT2D$r@_Dj$G$-$^$9!#(B
$B%P%C%U%!$G%^%k%A%P%$%HJ8;z$r;HMQIT2D$K$9$k$H!"(B
$B$=$N%P%C%U%!Fb$N3F%P%$%H$O(B1$B$D$NJ8;z$rI=$7$^$9!#(B
$B$?$H$(%3!<%I$,(B0200$B$+$i(B0377$B$N$"$$$@$G$"$C$F$b$=$&$G$9!#(B
$B%h!<%m%C%Q$NJ8;z=89g$G$"$k(BISO Latin-1$B$H(BISO Latin-2$B$r07$&8E$$5!G=$O!"(B
Emacs 19$B$GF0:n$7$F$$$?$h$&$KF0$-!"(B
$BB>$N(BISO 8859$BJ8;z=89g$KBP$7$F$bF0:n$7$^$9!#(B

@c   However, there is no need to turn off multibyte character support to
@c use ISO Latin; the Emacs multibyte character set includes all the
@c characters in these character sets, and Emacs can translate
@c automatically to and from the ISO codes.
$B$7$+$7!"(BISO Latin$B$r;H$&$?$a$K!"(B
$B%^%k%A%P%$%HJ8;z$r;HMQIT2D$K$9$kI,MW$O$"$j$^$;$s!#(B
Emacs$B$N%^%k%A%P%$%HJ8;z=89g$K$O$3$l$i$NJ8;z=89g$N$9$Y$F$NJ8;z$,4^$^$l!"(B
Emacs$B$O$3$l$i$N(BISO$B%3!<%I$HAj8_$K<+F0E*$KJQ49$G$-$^$9!#(B

@c   To edit a particular file in unibyte representation, visit it using
@c @code{find-file-literally}.  @xref{Visiting}.  To convert a buffer in
@c multibyte representation into a single-byte representation of the same
@c characters, the easiest way is to save the contents in a file, kill the
@c buffer, and find the file again with @code{find-file-literally}.  You
@c can also use @kbd{C-x @key{RET} c}
@c (@code{universal-coding-system-argument}) and specify @samp{raw-text} as
@c the coding system with which to find or save a file.  @xref{Specify
@c Coding}.  Finding a file as @samp{raw-text} doesn't disable format
@c conversion, uncompression and auto mode selection as
@c @code{find-file-literally} does.
$BFCDj$N%U%!%$%k$r%f%K%P%$%HI=8=$GJT=8$9$k$K$O!"(B
@code{find-file-literally}$B$r;H$C$F%U%!%$%k$rK,Ld$7$^$9!#(B
@xref{Visiting}$B!#(B
$B%^%k%A%P%$%HI=8=$N%P%C%U%!$rF1$8J8;z$N(B1$B%P%$%HI=8=$KJQ49$9$k$K$O!"(B
$B$b$C$H$b4JC1$JJ}K!$O!"FbMF$r%U%!%$%k$KJ]B8$7$F$+$i!"%P%C%U%!$r:o=|$7!"(B
@code{find-file-literally}$B$G$=$N%U%!%$%k$rK,Ld$7D>$7$^$9!#(B
@kbd{C-x @key{RET} c}$B!J(B@code{universal-coding-system-argument}$B!K$r;H$C$F!"(B
$B%U%!%$%k$rC5$7$?$jJ]B8$9$k$H$-$N%3!<%G%#%s%0%7%9%F%`$H$7$F(B
@samp{raw-text}$B$r;XDj$9$k$3$H$b$G$-$^$9!#(B
@xref{Specify Coding}$B!#(B
@samp{raw-text}$B$H$7$F%U%!%$%k$rC5$7$F$b!"(B
@code{find-file-literally}$B$N$h$&$K$O!"(B
$B=q<0JQ49!"05=L$NE83+!"%b!<%I$N<+F0A*Br$r6X;_$7$^$;$s!#(B

@vindex enable-multibyte-characters
@vindex default-enable-multibyte-characters
@c   To turn off multibyte character support by default, start Emacs with
@c the @samp{--unibyte} option (@pxref{Initial Options}), or set the
@c environment variable @samp{EMACS_UNIBYTE}.  You can also customize
@c @code{enable-multibyte-characters} or, equivalently, directly set the
@c variable @code{default-enable-multibyte-characters} in your init file to
@c have basically the same effect as @samp{--unibyte}.
$B%G%U%)%k%H$G%^%k%A%P%$%HJ8;z$r;HMQIT2D$K$9$k$K$O!"(B
@samp{--unibyte}$B%*%W%7%g%s!J(B@pxref{Initial Options}$B!K$r(B
$B;XDj$7$F(BEmacs$B$r;O$a$k$+!"$"$k$$$O!"(B
$B4D6-JQ?t(B@samp{EMACS_UNIBYTE}$B$r@_Dj$7$^$9!#(B
@samp{--unibyte}$B$HF1Ey$J8z2L$rF@$k$K$O!"(B
@code{enable-multibyte-characters}$B$r%+%9%?%^%$%:$9$k$+!"(B
$B$3$l$HEy2A$K!"=i4|2=%U%!%$%kFb$G!"(B
$BJQ?t(B@code{default-enable-multibyte-characters}$B$rD>@\@_Dj$7$^$9!#(B

@c   Multibyte strings are not created during initialization from the
@c values of environment variables, @file{/etc/passwd} entries etc.@: that
@c contain non-ASCII 8-bit characters.  However, the initialization file is
@c normally read as multibyte---like Lisp files in general---even with
@c @samp{--unibyte}.  To avoid multibyte strings being generated by
@c non-ASCII characters in it, put @samp{-*-unibyte: t;-*-} in a comment on
@c the first line.  Do the same for initialization files for packages like
@c Gnus.
$B4D6-JQ?t$NCM!"(B@file{/etc/passwd}$B$NFbMF$J$I$NHs(BASCII 8$B%S%C%HJ8;z$+$i$N(B
$B=i4|2=Cf$K$O%^%k%A%P%$%HJ8;zNs$O:n$i$l$^$;$s!#(B
$B$7$+$7!"(B@samp{--unibyte}$B$r;XDj$7$?$H$7$F$b!"(B
$B0lHL$N(BLisp$B%U%!%$%k$N$h$&$K!"=i4|2=%U%!%$%k$O!"DL>o!"(B
$B%^%k%A%P%$%H$H$7$FFI$_9~$_$^$9!#(B
$B$=$l$i$K4^$^$l$kHs(BASCII$BJ8;z$+$i%^%k%A%P%$%HJ8;zNs$,@8@.$5$l$k$N$rKI$0$K$O!"(B
1$B9TL\$NCm<a$K(B@samp{-*-unibyte: t;-*-}$B$rF~$l$F$*$-$^$9!#(B
gnus$B$J$I$N%Q%C%1!<%8$N=i4|2=%U%!%$%k$G$bF1$8$3$H$r$7$^$9!#(B

@c   The mode line indicates whether multibyte character support is enabled
@c in the current buffer.  If it is, there are two or more characters (most
@c often two dashes) before the colon near the beginning of the mode line.
@c When multibyte characters are not enabled, just one dash precedes the
@c colon.
$B%b!<%I9T$K$O!"%+%l%s%H%P%C%U%!$G%^%k%A%P%$%HJ8;z$,;HMQ2D$+$I$&$+I=<($5$l$^$9!#(B
$B;HMQ2D$J$i$P!"%b!<%I9T$N@hF,IU6a$N%3%m%s$N$^$($K(B
2$BJ8;z$+?tJ8;z!J$[$H$s$I$N>l9g%@%C%7%e(B2$B8D!K$,$"$j$^$9!#(B
$B%^%k%A%P%$%HJ8;z$,;HMQIT2D$J$i$P!"%3%m%s$N$^$($K$O%@%C%7%e$,(B1$B8D$@$1$G$9!#(B

@node Language Environments
@c @section Language Environments
@c @cindex language environments
@section $B8@8l4D6-(B
@cindex $B8@8l4D6-(B

@c   All supported character sets are supported in Emacs buffers whenever
@c multibyte characters are enabled; there is no need to select a
@c particular language in order to display its characters in an Emacs
@c buffer.  However, it is important to select a @dfn{language environment}
@c in order to set various defaults.  The language environment really
@c represents a choice of preferred script (more or less) rather than a
@c choice of language.
$B%^%k%A%P%$%HJ8;z$,;HMQ2D$N$H$-$O$$$D$G$b!"(B
$B$9$Y$F$N07$($kJ8;z=89g$r(BEmacs$B%P%C%U%!$NCf$G;H$($^$9!#(B
$B$"$k8@8l$NJ8;z$rI=<($9$k$?$a$K!"(B
Emacs$B%P%C%U%!$G$=$N8@8l$rA*Br$9$kI,MW$O$"$j$^$;$s!#(B
$B$7$+$7!"$5$^$6$^$J%G%U%)%k%H$r@_Dj$9$k$?$a$K(B@dfn{$B8@8l4D6-(B}$B$r(B
$BA*Br$7$F$*$/$3$H$O=EMW$G$9!#(B
$B8@8l4D6-$O!"8@8l$NA*Br$H$$$&$h$j!"(B
$B!JB?$+$l>/$J$+$l!K<B:]$K$O9%$_$NJ8;z$rI=$7$^$9!#(B

@c   The language environment controls which coding systems to recognize
@c when reading text (@pxref{Recognize Coding}).  This applies to files,
@c incoming mail, netnews, and any other text you read into Emacs.  It may
@c also specify the default coding system to use when you create a file.
@c Each language environment also specifies a default input method.
$B8@8l4D6-$O!"%F%-%9%H$rFI$_9~$`$H$-$K$I$N%3!<%G%#%s%0%7%9%F%`$rG'<1$9$k$+$r(B
$B@)8f$7$^$9!J(B@pxref{Recognize Coding}$B!K!#(B
$B8@8l4D6-$O!"%U%!%$%k!"E~Ce%a%$%k!"%K%e!<%9!"(B
Emacs$B$XFI$_9~$`$=$NB>$N%F%-%9%H$KE,MQ$5$l$^$9!#(B
$B8@8l4D6-$O!"%U%!%$%k$r:n@.$7$?$H$-$K;H$&%G%U%)%k%H$N(B
$B%3!<%G%#%s%0%7%9%F%`$r;XDj$9$k$3$H$b$"$j$^$9!#(B
$B3F8@8l4D6-$O!"%G%U%)%k%H$NF~NOJ}<0$b;XDj$7$^$9!#(B

@findex set-language-environment
@c   The way to select a language environment is with the command @kbd{M-x
@c set-language-environment}.  It makes no difference which buffer is
@c current when you use this command, because the effects apply globally to
@c the Emacs session.  The supported language environments include:
$B8@8l4D6-$rA*Br$9$k$K$O!"(B
$B%3%^%s%I(B@kbd{M-x set-language-environment}$B$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$r;H$C$?$H$-$K$I$N%P%C%U%!$,(B
$B%+%l%s%H%P%C%U%!$G$"$k$+$O4X78$"$j$^$;$s!#(B
$B$H$$$&$N$O!"$=$N8zNO$O!"$=$N(BEmacs$B%;%C%7%g%s$KA4BN$KE,MQ$5$l$k$+$i$G$9!#(B
$B0J2<$N8@8l4D6-$r;H$($^$9!#(B

@quotation
@c Chinese-BIG5, Chinese-CNS, Chinese-GB, Cyrillic-Alternativnyj,
@c Cyrillic-ISO, Cyrillic-KOI8, Devanagari, English, Ethiopic, Greek,
@c Hebrew, Japanese, Korean, Lao, Latin-1, Latin-2, Latin-3, Latin-4,
@c Latin-5, Thai, Tibetan, and Vietnamese.
Chinese-BIG5$B!"(BChinese-CNS$B!"(BChinese-GB$B!"(BCyrillic-Alternativnyj$B!"(B
Cyrillic-ISO$B!"(BCyrillic-KOI8$B!"(BDevanagari$B!"(BEnglish$B!"(BEthiopic$B!"(BGreek$B!"(B
Hebrew$B!"(BJapanese$B!"(BKorean$B!"(BLao$B!"(BLatin-1$B!"(BLatin-2$B!"(BLatin-3$B!"(BLatin-4$B!"(B
Latin-5$B!"(BThai$B!"(BTibetan$B!"(BVietnamese$B!#(B
@end quotation

@c   Some operating systems let you specify the language you are using by
@c setting locale environment variables.  Emacs handles one common special
@c case of this: if your locale name for character types contains the
@c string @samp{8859-@var{n}}, Emacs automatically selects the
@c corresponding language environment.
$B$$$/$D$+$N%*%Z%l!<%F%#%s%0%7%9%F%`$G$O!"(B
$B%m!<%1%k!J(Blocale$B!K4D6-JQ?t$r@_Dj$9$k$3$H$G8@8l$r;XDj$G$-$^$9!#(B
Emacs$B$O!"$3$N$h$/$"$kFCJL$J>lLL$r07$$$^$9!#(B
$BJ8;z<o$rI=$9%m!<%1%kL>$,J8;zNs(B@samp{8859-@var{n}}$B$r4^$`$J$i!"(B
Emacs$B$O<+F0E*$KBP1~$9$k8@8l4D6-$rA*Br$7$^$9!#(B

@kindex C-h L
@findex describe-language-environment
@c   To display information about the effects of a certain language
@c environment @var{lang-env}, use the command @kbd{C-h L @var{lang-env}
@c @key{RET}} (@code{describe-language-environment}).  This tells you which
@c languages this language environment is useful for, and lists the
@c character sets, coding systems, and input methods that go with it.  It
@c also shows some sample text to illustrate scripts used in this language
@c environment.  By default, this command describes the chosen language
@c environment.
$B$"$k8@8l4D6-(B@var{lang-env}$B$N8z2L$K$D$$$F$N>pJs$rI=<($9$k$K$O!"(B
$B%3%^%s%I(B@kbd{C-h L @var{lang-env} @key{RET}}
$B!J(B@code{describe-language-environment}$B!K$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$O!"$=$N8@8l4D6-$,$I$N8@8l$KLrN)$D$N$+!"(B
$B$=$N8@8l$G;H$o$l$kJ8;z=89g!"%3!<%G%#%s%0%7%9%F%`!"(B
$BF~NOJ}<0$N0lMw$rI=<($7$^$9!#(B
$B$^$?!"$=$N8@8l4D6-$G;H$o$l$kJ8;z$rNc<($9$kNcJ8$bI=<($7$^$9!#(B
$B%G%U%)%k%H$G$O!"$3$N%3%^%s%I$OA*Br$5$l$F$$$k8@8l4D6-$r5-=R$7$^$9!#(B

@vindex set-language-environment-hook
@c   You can customize any language environment with the normal hook
@c @code{set-language-environment-hook}.  The command
@c @code{set-language-environment} runs that hook after setting up the new
@c language environment.  The hook functions can test for a specific
@c language environment by checking the variable
@c @code{current-language-environment}.
$B$I$N8@8l4D6-$b%N!<%^%k%U%C%/(B@code{set-language-environment-hook}$B$G(B
$B%+%9%?%^%$%:$G$-$^$9!#(B
$B%3%^%s%I(B@code{set-language-environment}$B$O!"(B
$B?7$7$$8@8l4D6-$r@_Dj$7$?$"$H$G$3$N%U%C%/$r<B9T$7$^$9!#(B
$B%U%C%/4X?t$G$O!"JQ?t(B@code{current-language-environment}$B$r8!::$9$l$P!"(B
$B8@8l4D6-$rCN$k$3$H$,$G$-$^$9!#(B

@vindex exit-language-environment-hook
@c   Before it starts to set up the new language environment,
@c @code{set-language-environment} first runs the hook
@c @code{exit-language-environment-hook}.  This hook is useful for undoing
@c customizations that were made with @code{set-language-environment-hook}.
@c For instance, if you set up a special key binding in a specific language
@c environment using @code{set-language-environment-hook}, you should set
@c up @code{exit-language-environment-hook} to restore the normal binding
@c for that key.
@code{set-language-environment}$B$O!"?7$7$$8@8l4D6-$r@_Dj$7;O$a$k$^$($K!"(B
$B$^$:%U%C%/(B@code{exit-language-environment-hook}$B$r<B9T$7$^$9!#(B
$B$3$N%U%C%/$O!"!JD>A0$N8@8l4D6-$r@_Dj$7$?!K(B
@code{set-language-environment}$B$G;\$7$?%+%9%?%^%$%:$r$b$H$KLa$9$N$KJXMx$G$9!#(B
$B$?$H$($P!"(B@code{set-language-environment-hook}$B$r;H$C$F@_Dj$7$?(B
$BFCDj$N8@8l4D6-$GFCJL$J%-!<%P%$%s%G%#%s%0$rDj5A$7$?$H$-$K$O!"(B
$B$=$l$r$=$N%-!<$N$b$H$N%P%$%s%G%#%s%0$KLa$9$?$a$K(B
@code{exit-language-environment-hook}$B$r@_Dj$9$k$Y$-$G$9!#(B

@node Input Methods
@c @section Input Methods
@section $BF~NOJ}<0(B

@c @cindex input methods
@c   An @dfn{input method} is a kind of character conversion designed
@c specifically for interactive input.  In Emacs, typically each language
@c has its own input method; sometimes several languages which use the same
@c characters can share one input method.  A few languages support several
@c input methods.
@dfn{$BF~NOJ}<0(B}$B!J(Binput method$B!K$O!"(B
$BBPOCE*$KF~NO$9$k$?$a$KFCJL$K@_7W$5$l$?J8;zJQ49$N0l<o$G$9!#(B
Emacs$B$G$O!"E57?E*$K$O!"3F8@8l8~$1$K@lMQ$NF~NOJ}<0$,$"$j$^$9!#(B
$B$H$-$K$O!"F1$8J8;z$r;H$&$$$/$D$+$N8@8l$GF~NOJ}<0$r6&M-$7$^$9!#(B
$BJ#?t$NF~NOJ}<0$r;H$&8@8l$b>/$7$O$"$j$^$9!#(B

@c   The simplest kind of input method works by mapping ASCII letters into
@c another alphabet.  This is how the Greek and Russian input methods work.
$BF~NOJ}<0$N$b$C$H$bC1=c$J$b$N$O!"(BASCII$BJ8;z$rJL$N%"%k%U%!%Y%C%H$K(B
$BBP1~$5$;$k$3$H$GF0:n$7$^$9!#(B
$B%.%j%7%"8l$H%m%7%"8l$NF~NOJ}<0$O$3$N$h$&$KF0:n$7$^$9!#(B

@c   A more powerful technique is composition: converting sequences of
@c characters into one letter.  Many European input methods use composition
@c to produce a single non-ASCII letter from a sequence that consists of a
@c letter followed by accent characters (or vice versa).  For example, some
@c methods convert the sequence @kbd{a'} into a single accented letter.
@c These input methods have no special commands of their own; all they do
@c is compose sequences of printing characters.
$B$h$j6/NO$JJ}K!$O9g@.$G!"J8;z$NNs$r(B1$B$D$NJ8;z$KJQ49$7$^$9!#(B
$BB?$/$N%h!<%m%C%Q$NF~NOJ}<0$O!"J8;z$N$&$7$m$K%"%/%;%s%HJ8;z$,B3$/Ns(B
$B!J$"$k$$$O$=$N5U=g!K$+$i!"(B1$B$D$NHs(BASCII$BJ8;z$r@8@.$9$k9g@.$r;H$$$^$9!#(B
$B$?$H$($P!"$$$/$D$+$NF~NOJ}<0$G$O!"(B
$BJ8;z$NNs(B@kbd{a'}$B$r(B1$B$D$N%"%/%;%s%HIU$-J8;z$KJQ49$7$^$9!#(B
$B$3$l$i$NF~NOJ}<0$K$O!"$=$NJ}<0$K8GM-$NFCJL$J%3%^%s%I$O$"$j$^$;$s!#(B
$B0u;zJ8;z$NNs$r9g@.$9$k$@$1$G$9!#(B

@c   The input methods for syllabic scripts typically use mapping followed
@c by composition.  The input methods for Thai and Korean work this way.
@c First, letters are mapped into symbols for particular sounds or tone
@c marks; then, sequences of these which make up a whole syllable are
@c mapped into one syllable sign.
$B2;@aJ8;zMQ$NF~NOJ}<0$G$O!"E57?E*$K$O!"BP1~IU$1$?$"$H$G9g@.$7$^$9!#(B
$B%?%$8l$H4Z9q8l$NF~NOJ}<0$O!"$3$NJ}K!$GF0:n$7$^$9!#(B
$B$^$:!"J8;z$r2;@<5-9f$KBP1~IU$1$^$9!#(B
$B$=$7$F!"(B1$B$D$N2;@aA4BN$r9=@.$9$k$=$l$i$NNs$r(B1$B$D$N2;@a5-9f$KBP1~IU$1$^$9!#(B

@c   Chinese and Japanese require more complex methods.  In Chinese input
@c methods, first you enter the phonetic spelling of a Chinese word (in
@c input method @code{chinese-py}, among others), or a sequence of portions
@c of the character (input methods @code{chinese-4corner} and
@c @code{chinese-sw}, and others).  Since one phonetic spelling typically
@c corresponds to many different Chinese characters, you must select one of
@c the alternatives using special Emacs commands.  Keys such as @kbd{C-f},
@c @kbd{C-b}, @kbd{C-n}, @kbd{C-p}, and digits have special definitions in
@c this situation, used for selecting among the alternatives.  @key{TAB}
@c displays a buffer showing all the possibilities.
$BCf9q8l$dF|K\8l$G$O!"$h$jJ#;($JJ}K!$,I,MW$G$9!#(B
$BCf9q8l$NF~NOJ}<0$G$O!"$^$:!"Cf9q8l$NC18l$NH/2;I=5-$rF~NO$9$k(B
$B!J$H$j$o$1F~NOJ}<0(B@code{chinese-py}$B!K$+!"(B
1$BJ8;z$N3FItJ,ItJ,$NNs!J$H$j$o$1F~NOJ}<0(B@code{chinese-4corner}$B$d(B
@code{chinese-sw}$B!K$rF~NO$7$^$9!#(B
1$B$D$NH/2;I=5-$O!"IaDL!"B?$/$N0[$J$kCf9q8l$NJ8;z$KBP1~$7$F$$$k$N$G!"(B
$BFCJL$J(BEmacs$B%3%^%s%I$r;H$C$F8uJd72$+$i(B1$B$D$rA*$VI,MW$,$"$j$^$9!#(B
@kbd{C-f}$B!"(B@kbd{C-b}$B!"(B@kbd{C-n}$B!"(B@kbd{C-p}$B$H?t;z%-!<$O!"(B
$B$3$N>u67$G8uJd$rA*$V$?$a$K;H$o$l$kFCJL$JDj5A$K$J$C$F$$$^$9!#(B
@key{TAB}$B$O!"$9$Y$F$N8uJd$r%P%C%U%!$KI=<($7$^$9!#(B

@c    In Japanese input methods, first you input a whole word using
@c phonetic spelling; then, after the word is in the buffer, Emacs converts
@c it into one or more characters using a large dictionary.  One phonetic
@c spelling corresponds to many differently written Japanese words, so you
@c must select one of them; use @kbd{C-n} and @kbd{C-p} to cycle through
@c the alternatives.
$BF|K\8l$NF~NOJ}<0(B@footnote{$B!ZLuCm![8@8l4D6-$,(B@code{Japanese}$B$N$H$-$K(B
$B%G%U%)%k%H$G;HMQ$5$l$k(BLEIM$B$K4^$^$l$F$$$k$b$N!#(B
$B!V%m!<%^;z"*$R$i$,$J"*4A;z!W$HJQ49$9$k$,!"$"$^$$;H$$$d$9$/$O$J$$!#(B
WNN$B!"$+$s$J!"(BSKK$B$J$I$r;H$&$K$O!"(BEmacs$B$NG[I[$H$OJL$NHs8x<0%Q%C%A$r(B
$B<+A0$GEv$F$kI,MW$,$"$k!#(B
$B$?$@$7!"$3$l$i$rMQ$$$?>l9g!"F|K\8l$rF~NO$G$-$J$$>lLL$b$"$k$3$H$r(B
$B>5CN$7$F$*$/I,MW$,$"$k!#(B}
$B$G$O!"$^$:!"H/2;I=5-$r;H$C$F(B1$B$D$NC18lA4BN$rF~NO$7$^$9!#(B
$B$=$7$F!"C18l$,%P%C%U%!$KF~$C$?$"$H$G!"(B
Emacs$B$OBg$-$J<-=q$r;H$C$F(B1$B$D0J>e$NJ8;z$XJQ49$7$^$9!#(B
1$B$D$NH/2;I=5-$O!"$?$/$5$s$N0[$J$kF|K\8l$NC18l$KBP1~$7$F$$$k$N$G!"(B
$B$=$NCf$+$iA*$VI,MW$,$"$j$^$9!#(B
$B8uJd$r=d2s$9$k$K$O!"(B@kbd{C-n}$B$d(B@kbd{C-p}$B$r;H$$$^$9!#(B

@c   Sometimes it is useful to cut off input method processing so that the
@c characters you have just entered will not combine with subsequent
@c characters.  For example, in input method @code{latin-1-postfix}, the
@c sequence @kbd{e '} combines to form an @samp{e} with an accent.  What if
@c you want to enter them as separate characters?
$B$H$-$K$O!"F~NOJ}<0$G$N=hM}$r@Z$jN%$7$?$[$&$,JXMx$J$3$H$,$"$j$^$9!#(B
$B$=$&$9$l$P!"F~NO$7$?J8;z$O8eB3$NF~NOJ8;z$H7k9g$5$l$^$;$s!#(B
$B$?$H$($P!"F~NOJ}<0(B@code{latin-1-postfix}$B$G$O!"(B
$B%-!<Ns(B@kbd{e '}$B$O7k9g$5$l$F%"%/%;%s%HIU$-(B@samp{e}$B$K$J$j$^$9!#(B
$B$3$l$i$rJL!9$NJ8;z$H$7$FF~NO$7$?$$$H$-$O$I$&$9$k$N$G$7$g$&!)(B

@c   One way is to type the accent twice; that is a special feature for
@c entering the separate letter and accent.  For example, @kbd{e ' '} gives
@c you the two characters @samp{e'}.  Another way is to type another letter
@c after the @kbd{e}---something that won't combine with that---and
@c immediately delete it.  For example, you could type @kbd{e e @key{DEL}
@c '} to get separate @samp{e} and @samp{'}.
1$B$D$NJ}K!$O!"%"%/%;%s%H$r(B2$B2sBG$D$3$H$G$9!#(B
$B$3$l$O!"%"%k%U%!%Y%C%H$H%"%/%;%s%H$rJL!9$KF~NO$9$kFCJL$J5!G=$G$9!#(B
$B$?$H$($P!"(B@kbd{e ' '}$B$O!"(B2$B$D$NJ8;z(B@samp{e'}$B$K$J$j$^$9!#(B
$BJL$NJ}K!$O!"(B@kbd{e}$B$N$"$H$K7k9g$5$l$J$$JL$NJ8;z$rBG$C$F$+$i!"(B
$B$9$0$K$=$l$r>C$9$3$H$G$9!#(B
$B$?$H$($P!"(B @samp{e}$B$H(B@samp{'}$B$rF~NO$9$k$K$O!"(B@kbd{e e @key{DEL}'}$B$HBG$A$^$9!#(B

@c   Another method, more general but not quite as easy to type, is to use
@c @kbd{C-\ C-\} between two characters to stop them from combining.  This
@c is the command @kbd{C-\} (@code{toggle-input-method}) used twice.
$BJL$NJ}K!$O$h$j0lHLE*$G$9$,!"BG$D$N$O4JC1$G$O$"$j$^$;$s!#(B
2$B$D$NJ8;z$N$"$$$@$G(B@kbd{C-\ C-\}$B$rBG$C$F!"7k9g$r;_$a$^$9!#(B
$B$3$l$O!"%3%^%s%I(B@kbd{C-\}$B!J(B@code{toggle-input-method}$B!K$r(B2$B2s;H$C$F$$$^$9!#(B
@ifinfo
@c @xref{Select Input Method}.
@xref{Select Input Method}$B!#(B
@end ifinfo

@c   @kbd{C-\ C-\} is especially useful inside an incremental search,
@c because it stops waiting for more characters to combine, and starts
@c searching for what you have already entered.
@kbd{C-\ C-\}$B$O!"%$%s%/%j%a%s%?%k%5!<%A$NCf$G$OFC$KJXMx$G$9!#(B
$B$H$$$&$N$O!"7k9g$9$kJ8;z$rBT$D$3$H$r;_$a$F!"(B
$B$9$G$KF~NO$7$?$b$N$rC5:w$7;O$a$k$+$i$G$9!#(B

@vindex input-method-verbose-flag
@vindex input-method-highlight-flag
@c   The variables @code{input-method-highlight-flag} and
@c @code{input-method-verbose-flag} control how input methods explain what
@c is happening.  If @code{input-method-highlight-flag} is non-@code{nil},
@c the partial sequence is highlighted in the buffer.  If
@c @code{input-method-verbose-flag} is non-@code{nil}, the list of possible
@c characters to type next is displayed in the echo area (but not when you
@c are in the minibuffer).
 $BJQ?t(B@code{input-method-highlight-flag}$B$H(B
@code{input-method-verbose-flag}$B$O!"(B
$BF~NOJ}<0$K2?$,?J9TCf$+$r$I$N$h$&$KI=<($5$;$k$+$r@)8f$7$^$9!#(B
@code{input-method-highlight-flag}$B$,(B@code{nil}$B0J30$J$i$P!"(B
$B%P%C%U%!$G$O!JF~NOESCf$N!KItJ,Ns$r6/D4I=<($7$^$9!#(B
@code{input-method-verbose-flag}$B$,(B@code{nil}$B0J30$J$i$P!"(B
$B!J%_%K%P%C%U%!$NCf$G$J$1$l$P!K(B
$B$D$.$KBG80$G$-$kJ8;z$N0lMw$r%(%3!<NN0h$KI=<($7$^$9!#(B

@node Select Input Method
@c @section Selecting an Input Method
@section $BF~NOJ}<0$NA*Br(B

@table @kbd
@item C-\
@c Enable or disable use of the selected input method.
$BA*Br$5$l$F$$$kF~NOJ}<0$r%*%s!?%*%U$9$k!#(B

@item C-x @key{RET} C-\ @var{method} @key{RET}
@c Select a new input method for the current buffer.
$B%+%l%s%H%P%C%U%!$KBP$7$F?7$7$$F~NOJ}<0$rA*Br$9$k!#(B

@item C-h I @var{method} @key{RET}
@itemx C-h C-\ @var{method} @key{RET}
@findex describe-input-method
@kindex C-h I
@kindex C-h C-\
@c Describe the input method @var{method} (@code{describe-input-method}).
@c By default, it describes the current input method (if any).
@c This description should give you the full details of how to
@c use any particular input method.
$BF~NOJ}<0(B@var{method}$B$K$D$$$F@bL@$9$k!J(B@code{describe-input-method}$B!K!#(B
$B%G%U%)%k%H$G$O!"!J$"$l$P!K8=:_$NF~NOJ}<0$r@bL@$9$k!#(B
$B$3$N@bL@$G!"$"$kF~NOJ}<0$N;H$$J}$N>\:Y$,$o$+$k$O$:!#(B

@item M-x list-input-methods
@c Display a list of all the supported input methods.
$B;HMQ2DG=$J$9$Y$F$NF~NOJ}<0$N0lMw$rI=<($9$k!#(B
@end table

@findex set-input-method
@vindex current-input-method
@kindex C-x RET C-\
@c   To choose an input method for the current buffer, use @kbd{C-x
@c @key{RET} C-\} (@code{set-input-method}).  This command reads the
@c input method name with the minibuffer; the name normally starts with the
@c language environment that it is meant to be used with.  The variable
@c @code{current-input-method} records which input method is selected.
$B%+%l%s%H%P%C%U%!$KBP$9$kF~NOJ}<0$rA*$V$K$O!"(B
@kbd{C-x @key{RET} C-\}$B!J(B@code{set-input-method}$B!K$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$O!"%_%K%P%C%U%!$GF~NOJ}<0L>$rFI$_$^$9!#(B
$B$=$NL>A0$O!"DL>o!"0l=o$K;H$&$3$H$r0U?^$5$l$?8@8l4D6-$G;O$^$j$^$9!#(B
$BJQ?t(B@code{current-input-method}$B$O!"$I$NF~NOJ}<0$rA*Br$7$?$+$r5-O?$7$^$9!#(B
  
@findex toggle-input-method
@kindex C-\
@c   Input methods use various sequences of ASCII characters to stand for
@c non-ASCII characters.  Sometimes it is useful to turn off the input
@c method temporarily.  To do this, type @kbd{C-\}
@c (@code{toggle-input-method}).  To reenable the input method, type
@c @kbd{C-\} again.
$BF~NOJ}<0$O!"Hs(BASCII$BJ8;z$rF~NO$9$k$?$a$K!"$5$^$6$^$J(BASCII$BJ8;z$NNs$r;H$$$^$9!#(B
$B$H$-$K$O!"0l;~E*$KF~NOJ}<0$r%*%U$K$G$-$k$HJXMx$J$3$H$b$"$j$^$9!#(B
$B$=$&$9$k$K$O!"(B@kbd{C-\}$B!J(B@code{toggle-input-method}$B!K$HBG$A$^$9!#(B
$BF~NOJ}<0$r$U$?$?$S%*%s$K$9$k$K$O!"(B@kbd{C-\}$B$r$b$&0lEYBG$A$^$9!#(B

@c   If you type @kbd{C-\} and you have not yet selected an input method,
@c it prompts for you to specify one.  This has the same effect as using
@c @kbd{C-x @key{RET} C-\} to specify an input method.
@kbd{C-\}$B$rBG$C$?$H$-$K!"F~NOJ}<0$r$^$@A*Br$7$F$$$J$$$H!"(B
$BF~NOJ}<0$r;XDj$9$k$h$&$KJ9$$$F$-$^$9!#(B
$B$3$l$O!"F~NOJ}<0$r;XDj$9$k$?$a$K(B
@kbd{C-x @key{RET} C-\}$B$r;H$&$N$HF1$88z2L$,$"$j$^$9!#(B

@vindex default-input-method
@c   Selecting a language environment specifies a default input method for
@c use in various buffers.  When you have a default input method, you can
@c select it in the current buffer by typing @kbd{C-\}.  The variable
@c @code{default-input-method} specifies the default input method
@c (@code{nil} means there is none).
$B8@8l4D6-$rA*Br$9$k$H!"$5$^$6$^$J%P%C%U%!$G;H$&(B
$B%G%U%)%k%H$NF~NOJ}<0$r;XDj$7$^$9!#(B
$B%G%U%)%k%H$NF~NOJ}<0$r;XDj$7$F$"$l$P!"(B
@kbd{C-\}$B$HBG$F$P%+%l%s%H%P%C%U%!$G$=$l$rA*Br$G$-$^$9!#(B
$BJQ?t(B@code{default-input-method}$B$O!"%G%U%)%k%H$NF~NOJ}<0$r;XDj$7$^$9(B
$B!J(B@code{nil}$B$OF~NOJ}<0$J$7$N0UL#!K!#(B

@findex quail-set-keyboard-layout
@c   Some input methods for alphabetic scripts work by (in effect)
@c remapping the keyboard to emulate various keyboard layouts commonly used
@c for those scripts.  How to do this remapping properly depends on your
@c actual keyboard layout.  To specify which layout your keyboard has, use
@c the command @kbd{M-x quail-set-keyboard-layout}.
$B%"%k%U%!%Y%C%HJ8;z$KBP$9$k$$$/$D$+$NF~NOJ}<0$O!"(B
$B$=$NJ8;z8~$1$K0lHLE*$K;HMQ$5$l$k$5$^$6$^$J%-!<%\!<%IG[Ns$r(B
$B%(%_%e%l!<%H$9$k$h$&$K%-!<%\!<%I$r(B
$B!J<B<AE*$K!K%^%C%T%s%0$7D>$9$3$H$GF0:n$7$^$9!#(B
$B%^%C%T%s%0$7D>$9J}K!$O!"$"$J$?$N<B:]$N%-!<%\!<%IG[Ns$K0MB8$7$^$9!#(B
$B;H$C$F$$$k%-!<%\!<%IG[Ns$r;XDj$9$k$K$O!"(B
$B%3%^%s%I(B@kbd{M-x quail-set-keyboard-layout}$B$r;H$$$^$9!#(B

@findex list-input-methods
@c   To display a list of all the supported input methods, type @kbd{M-x
@c list-input-methods}.  The list gives information about each input
@c method, including the string that stands for it in the mode line.
$B;HMQ2DG=$J$9$Y$F$NF~NOJ}<0$N0lMw$rI=<($9$k$K$O!"(B
@kbd{M-x list-input-methods}$B$HBG$A$^$9!#(B
$B$3$N0lMw$K$O!"%b!<%I9T$KI=<($5$l$kF~NOJ}<0$rI=$9J8;zNs$r4^$a$F!"(B
$B3FF~NOJ}<0$K$D$$$F$N>pJs$,<($5$l$^$9!#(B

@node Multibyte Conversion
@c @section Unibyte and Multibyte Non-ASCII characters
@section $B%f%K%P%$%H$H%^%k%A%P%$%H$NHs(BASCII$BJ8;z(B

@c   When multibyte characters are enabled, character codes 0240 (octal)
@c through 0377 (octal) are not really legitimate in the buffer.  The valid
@c non-ASCII printing characters have codes that start from 0400.
$B%^%k%A%P%$%HJ8;z$,;HMQ2D$N$H$-$K$O!"(B
$BJ8;z%3!<%I(B0240$B!J(B8$B?J?t!K$+$i(B0377$B!J(B8$B?J?t!K$NJ8;z$O!"(B
$B<B:]$K$=$N$^$^$G$O%P%C%U%!Fb$KB8:_$7$^$;$s!#(B
$B@5$7$$Hs(BASCII$B0u;zJ8;z$O!"(B0400$B$+$i;O$^$k%3!<%I$K$J$j$^$9!#(B

@c   If you type a self-inserting character in the invalid range 0240
@c through 0377, Emacs assumes you intended to use one of the ISO
@c Latin-@var{n} character sets, and converts it to the Emacs code
@c representing that Latin-@var{n} character.  You select @emph{which} ISO
@c Latin character set to use through your choice of language environment
0240$B$+$i(B0377$B$NIT@5$JHO0O$N<+8JA^F~J8;z$rBG$C$?>l9g!"(B
Emacs$B$O!"(BISO Latin-@var{n}$BJ8;z=89g$N(B1$B$D$r;H$*$&$H$7$F$$$k$H2>Dj$7$F!"(B
Latin-@var{n}$B$NJ8;z$rI=$9(BEmacs$B$N%3!<%I$KJQ49$7$^$9!#(B
$B8@8l4D6-$NA*Br$r2p$7$F!"(B@emph{$B$I$N(B}ISO Latin$BJ8;z=89g$r;H$&$N$+;XDj$G$-$^$9(B
@iftex
@c (see above).
$B!J>e5-;2>H!K!#(B
@end iftex
@ifinfo
@c (@pxref{Language Environments}).
$B!J(B@pxref{Language Environments}$B!K!#(B
@end ifinfo
@c If you do not specify a choice, the default is Latin-1.
$B2?$bA*$s$G$J$$$H!"%G%U%)%k%H$O(BLatin-1$B$G$9!#(B

@c   The same thing happens when you use @kbd{C-q} to enter an octal code
@c in this range.
@kbd{C-q}$B$G$3$NHO0O$N(B8$B?J%3!<%I$rF~NO$9$k$H!"F1$8$3$H$,5/$3$j$^$9!#(B

@node Coding Systems
@c @section Coding Systems
@c @cindex coding systems
@section $B%3!<%G%#%s%0%7%9%F%`(B
@cindex $B%3!<%G%#%s%0%7%9%F%`(B

@c   Users of various languages have established many more-or-less standard
@c coding systems for representing them.  Emacs does not use these coding
@c systems internally; instead, it converts from various coding systems to
@c its own system when reading data, and converts the internal coding
@c system to other coding systems when writing data.  Conversion is
@c possible in reading or writing files, in sending or receiving from the
@c terminal, and in exchanging data with subprocesses.
$B$5$^$6$^$J8@8l$r;H$&%f!<%6!<$O!"(B
$B$=$l$i$rI=8=$9$k$?$a$NI8=`E*$J(B
$B%3!<%G%#%s%0%7%9%F%`$r?tB?$/3NN)$7$F$-$^$7$?!#(B
Emacs$B$O$3$l$i$N%3!<%G%#%s%0%7%9%F%`$rFbItE*$K$O;HMQ$7$^$;$s!#(B
$B$=$N$+$o$j!"%G!<%?$rFI$`$H$-$K$O!"(B
$B$5$^$6$^$J%3!<%G%#%s%0%7%9%F%`$+$i(BEmacs$BFH<+$N%3!<%G%#%s%0%7%9%F%`$KJQ49$7!"(B
$B%G!<%?$r=q$/$H$-$K$O!"(B
$BFbIt%3!<%G%#%s%0%7%9%F%`$+$iB>$N%3!<%G%#%s%0%7%9%F%`$KJQ49$7$^$9!#(B
$B%U%!%$%k$NFI$_=q$-!"C<Kv$H$N$d$j$H$j!"%5%V%W%m%;%9$H$N%G!<%?8r49$K$*$$$F!"(B
$BJQ49$G$-$^$9!#(B

@c   Emacs assigns a name to each coding system.  Most coding systems are
@c used for one language, and the name of the coding system starts with the
@c language name.  Some coding systems are used for several languages;
@c their names usually start with @samp{iso}.  There are also special
@c coding systems @code{no-conversion}, @code{raw-text} and
@c @code{emacs-mule} which do not convert printing characters at all.
Emacs$B$O3F%3!<%G%#%s%0%7%9%F%`$KL>A0$rIU$1$F$$$^$9!#(B
$BB?$/$N%3!<%G%#%s%0%7%9%F%`$O!"(B1$B$D$N8@8l$G;HMQ$5$l$k$N$G!"(B
$B%3!<%G%#%s%0%7%9%F%`$NL>A0$O!"8@8l$NL>A0$G;O$^$j$^$9!#(B
$B$$$/$D$+$N%3!<%G%#%s%0%7%9%F%`$O!"$$$/$D$b$N8@8l$G;HMQ$5$l$^$9!#(B
$B$=$N>l9g!"%3!<%G%#%s%0%7%9%F%`$NL>A0$O!"DL>o!"(B@samp{iso}$B$G;O$^$j$^$9!#(B
$B0u;zJ8;z$r$^$C$?$/JQ49$7$J$$FCJL$J%3!<%G%#%s%0%7%9%F%`!"(B
@code{no-conversion}$B!"(B@code{raw-text}$B!"(B@code{emacs-mule}$B$b$"$j$^$9!#(B

@c @cindex end-of-line conversion
@cindex $B9TKvJQ49(B
@c   In addition to converting various representations of non-ASCII
@c characters, a coding system can perform end-of-line conversion.  Emacs
@c handles three different conventions for how to separate lines in a file:
@c newline, carriage-return linefeed, and just carriage-return.
$BHs(BASCII$BJ8;z$N$5$^$6$^$JI=8=7A$NJQ49$K2C$($F!"(B
$B%3!<%G%#%s%0%7%9%F%`$O9TKvJQ49$b9T$$$^$9!#(B
Emacs$B$O!"%U%!%$%kFb$N9T$N6h@Z$jJ}$H$7$F!"(B
3$B$D$N0[$J$kJQ49$r07$($^$9!#(B
$B$D$^$j!"2~9T!"I|5"2~9T!"I|5"$G$9!#(B

@table @kbd
@item C-h C @var{coding} @key{RET}
@c Describe coding system @var{coding}.
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r@bL@$9$k!#(B

@item C-h C @key{RET}
@c Describe the coding systems currently in use.
$B8=:_;HMQ$7$F$$$k%3!<%G%#%s%0%7%9%F%`$r@bL@$9$k!#(B

@item M-x list-coding-systems
@c Display a list of all the supported coding systems.
$B;HMQ2DG=$J$9$Y$F$N%3!<%G%#%s%0%7%9%F%`$N0lMw$rI=<($9$k!#(B
@end table

@kindex C-h C
@findex describe-coding-system
@c   The command @kbd{C-h C} (@code{describe-coding-system}) displays
@c information about particular coding systems.  You can specify a coding
@c system name as argument; alternatively, with an empty argument, it
@c describes the coding systems currently selected for various purposes,
@c both in the current buffer and as the defaults, and the priority list
@c for recognizing coding systems (@pxref{Recognize Coding}).
$B%3%^%s%I(B@kbd{C-h C}$B!J(B@code{describe-coding-system}$B!K$O!"(B
$BFCDj$N%3!<%G%#%s%0%7%9%F%`$K$D$$$F$N>pJs$rI=<($7$^$9!#(B
$B0z?t$K%3!<%G%#%s%0%7%9%F%`L>$r;XDj$G$-$^$9!#(B
$B$"$k$$$O!"0z?t$,6u$N$H$-$K$O!"(B
$B%+%l%s%H%P%C%U%!$KBP$9$k$b$N$H%G%U%)%k%H$NN>J}$K$D$$$F!"(B
$B$5$^$6$^$JL\E*$N$?$a$KA*Br$5$l$F$$$k8=:_$N%3!<%G%#%s%0%7%9%F%`$H!"(B
$B%3!<%G%#%s%0%7%9%F%`$rG'<1$9$k$?$a$NM%@h=g0LI=$r@bL@$7$^$9!#(B
$B!J(B@pxref{Recognize Coding}$B!K!#(B

@findex list-coding-systems
@c   To display a list of all the supported coding systems, type @kbd{M-x
@c list-coding-systems}.  The list gives information about each coding
@c system, including the letter that stands for it in the mode line
@c (@pxref{Mode Line}).
$BMxMQ2DG=$J$9$Y$F$N%3!<%G%#%s%0%7%9%F%`$N0lMw$rI=<($9$k$K$O!"(B
@kbd{M-x list-coding-systems}$B$HBG$A$^$9!#(B
$B%b!<%I9T$KI=<($5$l$kJ8;z$r4^$a$F!"(B
$B3F%3!<%G%#%s%0%7%9%F%`$K$D$$$F$N>pJs$N0lMw$rI=<($7$^$9!J(B@pxref{Mode Line}$B!K!#(B

@c @cindex end-of-line conversion
@c @cindex MS-DOS end-of-line conversion
@c @cindex Macintosh end-of-line conversion
@cindex $B9TKvJQ49(B
@cindex MS-DOS$B9TKvJQ49(B
@cindex Macintosh$B9TKvJQ49(B
@c   Each of the coding systems that appear in this list---except for
@c @code{no-conversion}, which means no conversion of any kind---specifies
@c how and whether to convert printing characters, but leaves the choice of
@c end-of-line conversion to be decided based on the contents of each file.
@c For example, if the file appears to use the sequence carriage-return
@c linefeed to separate lines, DOS end-of-line conversion will be used.
$B$$$+$J$k<oN`$NJQ49$b9T$o$J$$(B@code{no-conversion}$B$r=|$$$F!"(B
$B$3$N0lMw$K8=$l$k3F%3!<%G%#%s%0%7%9%F%`$O(B
$B0u;zJ8;z$r$I$N$h$&$KJQ49$9$k!?$7$J$$$r;XDj$7$^$9!#(B
$B$7$+$7!"9TKvJQ49$O!"3F%U%!%$%k$NFbMF$K4p$E$$$F7hDj$5$l$^$9!#(B
$B$?$H$($P!"%U%!%$%k$,9T6h@Z$j$KI|5"2~9T$r;HMQ$7$F$$$k$h$&$K;W$o$l$k$H$-$K$O!"(B
$B$=$N9TKvJQ49$r;H$$$^$9!#(B

@c   Each of the listed coding systems has three variants which specify
@c exactly what to do for end-of-line conversion:
$B0lMw$N3F%3!<%G%#%s%0%7%9%F%`$K$O!"(B
$B$I$N$h$&$K9TKvJQ49$9$k$+$r@53N$K;XDj$9$k(B3$B$D$NJQ<o$,$"$j$^$9!#(B

@table @code
@item @dots{}-unix
@c Don't do any end-of-line conversion; assume the file uses
@c newline to separate lines.  (This is the convention normally used
@c on Unix and GNU systems.)
$B9TKvJQ49$r9T$o$J$$!#(B
$B%U%!%$%k$G$O!"9T6h@Z$j$K2~9T$r;HMQ$7$F$$$k$H2>Dj$9$k!#(B
$B!J$3$l$O!"(BUNIX$B$H(BGNU$B%7%9%F%`$GIaDL$K;HMQ$5$l$kJQ49!#!K(B

@item @dots{}-dos
@c Assume the file uses carriage-return linefeed to separate lines, and do
@c the appropriate conversion.  (This is the convention normally used on
@c Microsoft systems.@footnote{It is also specified for MIME `text/*'
@c bodies and in other network transport contexts.  It is different
@c from the SGML reference syntax record-start/record-end format which
@c Emacs doesn't support directly.})
$B%U%!%$%k$G$O!"9T6h@Z$j$KI|5"2~9T$r;HMQ$7$F$$$k$H2>Dj$7!"E,Ev$JJQ49$r9T$&!#(B
$B!J$3$l$O!"(BMicrosoft$B%7%9%F%`$GIaDL$K;HMQ$5$l$kJQ49!#(B
@footnote{MIME$B$N!V(Btext/*$B!W$NK\BN$d!"(B
$BB>$N%M%C%H%o!<%/E>Aw$N>lLL$G$b;XDj$5$l$k!#(B
Emacs$B$,D>@\$K$O07$($J$$(B
SGML$B$N;2>H9=J8$G$"$k(Brecord-start/record-end$B=q<0$H$O0[$J$k!#(B}$B!K(B

@item @dots{}-mac
@c Assume the file uses carriage-return to separate lines, and do the
@c appropriate conversion.  (This is the convention normally used on the
@c Macintosh system.)
$B%U%!%$%k$G$O!"9T6h@Z$j$KI|5"$r;HMQ$7$F$$$k$H2>Dj$7!"E,Ev$JJQ49$r9T$&!#(B
$B!J$3$l$O!"(BMachintosh$B%7%9%F%`$GIaDL$K;HMQ$5$l$kJQ49!#!K(B
@end table

@c   These variant coding systems are omitted from the
@c @code{list-coding-systems} display for brevity, since they are entirely
@c predictable.  For example, the coding system @code{iso-latin-1} has
@c variants @code{iso-latin-1-unix}, @code{iso-latin-1-dos} and
@c @code{iso-latin-1-mac}.
$B$3$l$i$N%3!<%G%#%s%0%7%9%F%`$NJQ<o$O!"(B
$B40A4$KM=A[$G$-$k$N$G(B@code{list-coding-systems}$B$NI=<($+$i$O(B
$B4J7i$K$9$k$?$a$K=|$+$l$F$$$^$9!#(B
$B$?$H$($P!"%3!<%G%#%s%0%7%9%F%`(B@code{iso-latin-1}$B$K$O!"(B
@code{iso-latin-1-unix}$B!"(B@code{iso-latin-1-dos}$B!"(B@code{iso-latin-1-mac}
$B$NJQ<o$,$"$j$^$9!#(B

@c   The coding system @code{raw-text} is good for a file which is mainly
@c ASCII text, but may contain byte values above 127 which are not meant to
@c encode non-ASCII characters.  With @code{raw-text}, Emacs copies those
@c byte values unchanged, and sets @code{enable-multibyte-characters} to
@c @code{nil} in the current buffer so that they will be interpreted
@c properly.  @code{raw-text} handles end-of-line conversion in the usual
@c way, based on the data encountered, and has the usual three variants to
@c specify the kind of end-of-line conversion to use.
$B%3!<%G%#%s%0%7%9%F%`(B@code{raw-text}$B$O!"(B
$B<g$K(BASCII$B%F%-%9%H$N%U%!%$%k$KE,$7$F$$$^$9$,!"(B
$B%U%!%$%k$K$O!"Hs(BASCII$BJ8;z$NId9f$r0UL#$7$J$$(B127$B$r1[$($k%P%$%HCM$,(B
$B4^$^$l$k$+$b$7$l$^$;$s!#(B
@code{raw-text}$B$G$O!"(B
Emacs$B$O!"$=$l$i$N%P%$%H$,E,@Z$K2r<a$5$l$k$h$&$KCM$rJQ99$7$J$$$G%3%T!<$7!"(B
$B%+%l%s%H%P%C%U%!$N(B
@code{enable-multibyte-characters}$B$K(B@code{nil}$B$r@_Dj$7$^$9!#(B
@code{raw-text}$B$O!"=P2q$C$?%G!<%?$K4p$E$/IaDL$NJ}K!$G9TKvJQ49$r=hM}$7!"(B
$B;HMQ$9$k9TKvJQ49$r;XDj$9$k(B3$B$D$NJQ<o$r;}$A$^$9!#(B

@c   In contrast, the coding system @code{no-conversion} specifies no
@c character code conversion at all---none for non-ASCII byte values and
@c none for end of line.  This is useful for reading or writing binary
@c files, tar files, and other files that must be examined verbatim.  It,
@c too, sets @code{enable-multibyte-characters} to @code{nil}.
$BBP>HE*$K!"%3!<%G%#%s%0%7%9%F%`(B@code{no-conversion}$B$O!"(B
$BHs(BASCII$B%P%$%HCM$H9TKv$KBP$7$F!"$$$+$J$kJ8;z%3!<%IJQ49$b;XDj$7$^$;$s!#(B
$B$3$l$O!"%P%$%J%j%U%!%$%k!"(Btar$B%U%!%$%k!"(B
$B$=$N$^$^=hM}$9$kI,MW$,$"$k$=$NB>$N%U%!%$%k$rFI$_=q$-$9$k$N$KJXMx$G$9!#(B
$B$3$l$b!"(B@code{enable-multibyte-characters}$B$K(B@code{nil}$B$r@_Dj$7$^$9!#(B

@c   The easiest way to edit a file with no conversion of any kind is with
@c the @kbd{M-x find-file-literally} command.  This uses
@c @code{no-conversion}, and also suppresses other Emacs features that
@c might convert the file contents before you see them.  @xref{Visiting}.
$B$$$+$J$k<oN`$NJQ49$b$7$J$$$G%U%!%$%k$rJT=8$9$k$b$C$H$b4JC1$JJ}K!$O!"(B
@kbd{M-x find-file-literally}$B%3%^%s%I$r;H$&$3$H$G$9!#(B
$B$3$N%3%^%s%I$O!"(B@code{no-conversion}$B$r;H$$!"(B
$B$"$J$?$,%U%!%$%k$r8+$k$^$($K%U%!%$%k$NFbMF$r(B
$BJQ49$9$k$+$b$7$l$J$$(BEmacs$B$N$=$NB>$N5!G=$rM^@)$7$^$9!#(B
@xref{Visiting}$B!#(B

@c   The coding system @code{emacs-mule} means that the file contains
@c non-ASCII characters stored with the internal Emacs encoding.  It
@c handles end-of-line conversion based on the data encountered, and has
@c the usual three variants to specify the kind of end-of-line conversion.
$B%3!<%G%#%s%0%7%9%F%`(B@code{emacs-mule}$B$O!"(B
Emacs$BFbIt$NId9f2=$N$^$^$G3JG<$5$l$?Hs(BASCII$BJ8;z$r(B
$B4^$`%U%!%$%k$G$"$k$3$H$r0UL#$7$^$9!#(B
$B$3$l$O!"=P2q$C$?%G!<%?$K4p$E$$$F9TKvJQ49$r07$$!"(B
$B9TKvJQ49$N<oN`$r;XDj$9$kDL>o$N(B3$B$D$NJQ<o$r;}$A$^$9!#(B

@node Recognize Coding
@c @section Recognizing Coding Systems
@section $B%3!<%G%#%s%0%7%9%F%`$NG'<1(B

@c   Most of the time, Emacs can recognize which coding system to use for
@c any given file---once you have specified your preferences.
$B0lEY<+J,$N9%$_$r;XDj$7$F$*$1$P!"$[$H$s$I$N>l9g!"(BEmacs$B$O!"(B
$BM?$($i$l$?%U%!%$%k$KBP$7$F$I$N%3!<%G%#%s%0%7%9%F%`$r;H$&$+G'<1$G$-$^$9!#(B 

@c   Some coding systems can be recognized or distinguished by which byte
@c sequences appear in the data.  However, there are coding systems that
@c cannot be distinguished, not even potentially.  For example, there is no
@c way to distinguish between Latin-1 and Latin-2; they use the same byte
@c values with different meanings.
$B$$$/$D$+$N%3!<%G%#%s%0%7%9%F%`$O!"(B
$B%G!<%?Fb$K$I$N$h$&$J%P%$%HNs$,8=$l$?$+$G!"G'<1$7$?$j6hJL$G$-$^$9!#(B
$B$7$+$7!"6hJL$G$-$J$$%3!<%G%#%s%0%7%9%F%`$d(B
$B$=$N2DG=@-$b$J$$%3!<%G%#%s%0%7%9%F%`$b$"$j$^$9!#(B
$B$?$H$($P!"(BLatin-1$B$H(BLatin-2$B$r6hJL$9$kJ}K!$O$"$j$^$;$s!#(B
$B$3$l$i$OF1$8%P%$%HCM$r0[$J$k0UL#$G;HMQ$7$F$$$^$9!#(B

@c   Emacs handles this situation by means of a priority list of coding
@c systems.  Whenever Emacs reads a file, if you do not specify the coding
@c system to use, Emacs checks the data against each coding system,
@c starting with the first in priority and working down the list, until it
@c finds a coding system that fits the data.  Then it converts the file
@c contents assuming that they are represented in this coding system.
Emacs$B$O!"%3!<%G%#%s%0%7%9%F%`$NM%@h=g0LI=$rMQ$$$F$3$N;vBV$r=hM}$7$^$9!#(B
$B;HMQ$9$k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$J$1$l$P!"(B
Emacs$B$O%U%!%$%k$rFI$`$H$-$O$$$D$G$b!"(B
$BM%@h=g0L$N$b$C$H$b9b$$$b$N$+$i;O$a$F=g$K2<$j$J$,$i!"(B
$B%G!<%?$K9g$&%3!<%G%#%s%0%7%9%F%`$r$_$D$1$k$^$G(B
$B3F%3!<%G%#%s%0%7%9%F%`$KBP$7$F%G!<%?$r8!::$7$^$9!#(B
$B$=$7$F!"%U%!%$%k$O$=$N%3!<%G%#%s%0%7%9%F%`$GI=8=$5$l$F$$$k$H2>Dj$7$F!"(B
$B%U%!%$%k$NFbMF$rJQ49$7$^$9!#(B

@c   The priority list of coding systems depends on the selected language
@c environment (@pxref{Language Environments}).  For example, if you use
@c French, you probably want Emacs to prefer Latin-1 to Latin-2; if you use
@c Czech, you probably want Latin-2 to be preferred.  This is one of the
@c reasons to specify a language environment.
$B%3!<%G%#%s%0%7%9%F%`$NM%@h=g0LI=$O!"A*Br$5$l$F$$$k8@8l4D6-$K0MB8$7$^$9(B
$B!J(B@pxref{Language Environments}$B!K!#(B
$B$?$H$($P!"%U%i%s%98l$r;H$&$N$J$i!"$?$V$s!"(B
Emacs$B$K$O(BLatin-2$B$h$j(BLatin-1$B$rA*$s$G$[$7$$$G$7$g$&!#(B
$B%A%'%38l$r;H$&$J$i!"$?$V$s!"(BLatin-2$B$N$[$&$,$h$$$G$7$g$&!#(B
$B$3$l$,!"8@8l4D6-$r;XDj$9$kM}M3$N(B1$B$D$G$9!#(B 

@findex prefer-coding-system
@c   However, you can alter the priority list in detail with the command
@c @kbd{M-x prefer-coding-system}.  This command reads the name of a coding
@c system from the minibuffer, and adds it to the front of the priority
@c list, so that it is preferred to all others.  If you use this command
@c several times, each use adds one element to the front of the priority
@c list.
$B$7$+$7!"%3%^%s%I(B@kbd{M-x prefer-coding-system}$B$r;H$C$F!"(B
$BM%@h=g0LI=$N>\:Y$rJQ99$G$-$^$9!#(B
$B$3$N%3%^%s%I$O%_%K%P%C%U%!$+$i%3!<%G%#%s%0%7%9%F%`$NL>A0$rFI$_!"(B
$B$=$l$rM%@h=g0LI=$N@hF,$KDI2C$7$F!"B>$N$9$Y$F$N$b$N$h$jM%@h$9$k$h$&$K$7$^$9!#(B
$B$3$N%3%^%s%I$r?t2s;H$&$H!"(B
$B;HMQ$9$k$4$H$KM%@h=g0LI=$N@hF,$K(B1$B$D$NMWAG$,DI2C$5$l$^$9!#(B

@c   If you use a coding system that specifies the end-of-line conversion
@c type, such as @code{iso-8859-1-dos}, what that means is that Emacs
@c should attempt to recognize @code{iso-8859-1} with priority, and should
@c use DOS end-of-line conversion in case it recognizes @code{iso-8859-1}.
@code{iso-8859-1-dos}$B$N$h$&$J9TKvJQ49$r;XDj$7$?%3!<%G%#%s%0%7%9%F%`$r;H$&$H!"(B
@code{iso-8859-1}$B$rM%@h$7$FG'<1$7!"$=$N>l9g$K$O(BDOS$B$N9TKvJQ49$r;H$&$3$H$r(B
Emacs$B$K;X<($9$k$3$H$K$J$j$^$9!#(B

@vindex file-coding-system-alist
@c   Sometimes a file name indicates which coding system to use for the
@c file.  The variable @code{file-coding-system-alist} specifies this
@c correspondence.  There is a special function
@c @code{modify-coding-system-alist} for adding elements to this list.  For
@c example, to read and write all @samp{.txt} files using the coding system
@c @code{china-iso-8bit}, you can execute this Lisp expression:
$B$H$-$K$O!"%U%!%$%k$KBP$7$F;HMQ$9$k%3!<%G%#%s%0%7%9%F%`$r(B
$B%U%!%$%kL>$,<($7$F$$$k$3$H$,$"$j$^$9!#(B
$BJQ?t(B@code{file-coding-system-alist}$B$O!"$3$NBP1~4X78$r;XDj$7$^$9!#(B
$B$3$N%j%9%H$KMWAG$rDI2C$9$kFCJL$J4X?t(B
@code{modify-coding-system-alist}$B$,$"$j$^$9!#(B
$B$?$H$($P!"$9$Y$F$N(B@samp{.txt}$B$NFI$_=q$-$K!"(B
$B%3!<%G%#%s%0%7%9%F%`(B@code{china-iso-8bit}$B$r;HMQ$7$?$$$J$i!"(B
$B$D$.$N(BLisp$B<0$r<B9T$7$^$9!#(B

@smallexample
(modify-coding-system-alist 'file "\\.txt\\'" 'china-iso-8bit)
@end smallexample

@noindent
@c The first argument should be @code{file}, the second argument should be
@c a regular expression that determines which files this applies to, and
@c the third argument says which coding system to use for these files.
$B;O$a$N0z?t$O(B@code{file}$B!"(B
$BBh(B2$B0z?t$O$3$l$rE,MQ$9$k%U%!%$%k$r7hDj$9$k@55,I=8=!"(B
$BBh(B3$B0z?t$O$3$l$i$N%U%!%$%k$KBP$7$F;HMQ$9$k%3!<%G%#%s%0%7%9%F%`$G$9!#(B

@vindex inhibit-eol-conversion
@c   Emacs recognizes which kind of end-of-line conversion to use based on
@c the contents of the file: if it sees only carriage-returns, or only
@c carriage-return linefeed sequences, then it chooses the end-of-line
@c conversion accordingly.  You can inhibit the automatic use of
@c end-of-line conversion by setting the variable @code{inhibit-eol-conversion}
@c to non-@code{nil}.
Emacs$B$O!"%U%!%$%k$NFbMF$K4p$E$$$F!";HMQ$9$k9TKvJQ49$N<oN`$rG'<1$7$^$9!#(B
$BI|5"$N$_!"$"$k$$$O!"I|5"2~9T$NNs$N$_$G$"$l$P!"(B
$BBP1~$9$k9TKvJQ49$rA*Br$7$^$9!#(B
$BJQ?t(B@code{inhibit-eol-conversion}$B$K(B@code{nil}$B0J30$r@_Dj$9$k$H!"(B
$B9TKvJQ49$N<+F0E*$J;HMQ$r6X;_$G$-$^$9!#(B

@vindex coding
@c   You can specify the coding system for a particular file using the
@c @samp{-*-@dots{}-*-} construct at the beginning of a file, or a local
@c variables list at the end (@pxref{File Variables}).  You do this by
@c defining a value for the ``variable'' named @code{coding}.  Emacs does
@c not really have a variable @code{coding}; instead of setting a variable,
@c it uses the specified coding system for the file.  For example,
@c @samp{-*-mode: C; coding: latin-1;-*-} specifies use of the Latin-1
@c coding system, as well as C mode.  If you specify the coding explicitly
@c in the file, that overrides @code{file-coding-system-alist}.
$B%U%!%$%k$N@hF,$N(B@samp{-*-@dots{}-*-}$B$d!"(B
$B%U%!%$%k$N:G8e$N%m!<%+%kJQ?t%j%9%H$r;H$C$F!"(B
$B8D!9$N%U%!%$%k$KBP$7$F%3!<%G%#%s%0%7%9%F%`$r;XDj$G$-$^$9(B
$B!J(B@pxref{File Variables}$B!K!#(B
$B$3$l$r9T$&$K$O!"(B@code{coding}$B$H$$$&L>A0$N!XJQ?t!Y$KCM$rDj5A$7$^$9!#(B
Emacs$B$K$O!"JQ?t(B@code{coding}$B$O<B:]$K$O$"$j$^$;$s!#(B
$BJQ?t$r@_Dj$9$k$+$o$j$K!"(B
$B%U%!%$%k$KBP$7$F;XDj$5$l$?%3!<%G%#%s%0%7%9%F%`$r;H$$$^$9!#(B
$B$?$H$($P!"(B@samp{-*-mode: C; coding: latin-1;-*-}$B$O!"(B
C$B%b!<%I$r;XDj$9$k$H$H$b$K!"(BLatin-1$B$N%3!<%G%#%s%0%7%9%F%`$N;HMQ$r;XDj$7$^$9!#(B
$B%U%!%$%k$G%3!<%G%#%s%0%7%9%F%`$rL@<(E*$K;XDj$7$?>l9g!"(B
$B$=$l$O(B@code{file-coding-system-alist}$B$KM%@h$7$^$9!#(B

@vindex auto-coding-alist
@c   The variable @code{auto-coding-alist} is the strongest way to specify
@c the coding system for certain patterns of file names; this variable even
@c overrides @samp{-*-coding:-*-} tags in the file itself.  Emacs uses this
@c feature for tar and archive files, to prevent Emacs from being confused
@c by a @samp{-*-coding:-*-} tag in a member of the archive and thinking it
@c applies to the archive file as a whole.
$BJQ?t(B@code{auto-coding-alist}$B$O!"FCDj$N%Q%?!<%s$N%U%!%$%kL>$KBP$7$F(B
$B%3!<%G%#%s%0%7%9%F%`$r;XDj$9$k$b$C$H$b6/$$J}K!$G$9!#(B
$B$3$NJQ?t$O!"%U%!%$%k<+?H$N(B@samp{-*-coding:-*-}$B$K$5$($bM%@h$7$^$9!#(B
Emacs$B$O(Btar$B%U%!%$%k$d%"!<%+%$%V%U%!%$%k$KBP$7$F$3$N5!G=$r;H$$$^$9!#(B
$B%"!<%+%$%VFb$N%U%!%$%k$NCf$K$"$k(B@samp{-*-coding:-*-}$B$G:.Mp$7$F!"(B
$B%U%!%$%kA4BN$K%3!<%G%#%s%0%7%9%F%`$rE,MQ$7$F$7$^$&$3$H$rKI$0$N$G$9!#(B

@vindex buffer-file-coding-system
@c   Once Emacs has chosen a coding system for a buffer, it stores that
@c coding system in @code{buffer-file-coding-system} and uses that coding
@c system, by default, for operations that write from this buffer into a
@c file.  This includes the commands @code{save-buffer} and
@c @code{write-region}.  If you want to write files from this buffer using
@c a different coding system, you can specify a different coding system for
@c the buffer using @code{set-buffer-file-coding-system} (@pxref{Specify
@c Coding}).
Emacs$B$,%P%C%U%!$KBP$9$k%3!<%G%#%s%0%7%9%F%`$r0lEYA*Br$9$k$H!"(B
$B$=$N%3!<%G%#%s%0%7%9%F%`$r(B@code{buffer-file-coding-system}$B$KF~$l$F$*$-!"(B
$B$3$N%P%C%U%!$+$i%U%!%$%k$K=q$/A`:n$G$O!"(B
$B%G%U%)%k%H$G$3$N%3!<%G%#%s%0%7%9%F%`$r;H$$$^$9!#(B
$B$3$l$K$O!"%3%^%s%I(B@code{save-buffer}$B$d(B@code{write-region}$B$b4^$^$l$^$9!#(B
$B0[$J$k%3!<%G%#%s%0%7%9%F%`$rMQ$$$F$3$N%P%C%U%!$+$i%U%!%$%k$K=q$-$?$$$H$-$K$O!"(B
@code{set-buffer-file-coding-system}$B$r;H$C$F!"(B
$B$=$N%P%C%U%!$KBP$7$F0[$J$k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9(B
$B!J(B@pxref{Specify Coding}$B!K!#(B

@vindex sendmail-coding-system
@c   When you send a message with Mail mode (@pxref{Sending Mail}), Emacs has
@c four different ways to determine the coding system to use for encoding
@c the message text.  It tries the buffer's own value of
@c @code{buffer-file-coding-system}, if that is non-@code{nil}.  Otherwise,
@c it uses the value of @code{sendmail-coding-system}, if that is
@c non-@code{nil}.  The third way is to use the default coding system for
@c new files, which is controlled by your choice of language environment,
@c if that is non-@code{nil}.  If all of these three values are @code{nil},
@c Emacs encodes outgoing mail using the Latin-1 coding system.
$B%a%$%k!J(Bmail$B!K%b!<%I!J(B@pxref{Sending Mail}$B!K$G%a%C%;!<%8$rAw$k$H$-!"(B
Emacs$B$K$O!"%a%C%;!<%8%F%-%9%H$NId9f2=$K;H$&%3!<%G%#%s%0%7%9%F%`$r7hDj$9$k(B
$B0[$J$kJ}K!$,(B4$B$D$"$j$^$9!#(B
$B%P%C%U%!$N(B@code{buffer-file-coding-system}$B$,(B@code{nil}$B0J30$J$i$P!"(B
$B$=$NCM$r;n$7$^$9!#(B
$B$5$b$J$1$l$P!"(B@code{sendmail-coding-system}$B$NCM$,(B@code{nil}$B0J30$J$i$P!"(B
$B$=$NCM$r;H$$$^$9!#(B
3$B$D$a$NJ}K!$O!"?7$7$$%U%!%$%k$KBP$9$k%G%U%)%k%H$N(B
$B%3!<%G%#%s%0%7%9%F%`$,(B@code{nil}$B0J30$J$i$P!"$=$l$r;H$$$^$9!#(B
$B$3$NCM$O!"8@8l4D6-$NA*Br$G@)8f$5$l$^$9!#(B
$B$3$l$i$N(B3$B$D$NCM$,$9$Y$F(B@code{nil}$B$J$i$P!"(B
Emacs$B$O!"(BLatin-1$B$N%3!<%G%#%s%0%7%9%F%`$r;HMQ$7$FAw=P%a%$%k$rId9f2=$7$^$9!#(B

@vindex rmail-decode-mime-charset
@c   When you get new mail in Rmail, each message is translated
@c automatically from the coding system it is written in---as if it were a
@c separate file.  This uses the priority list of coding systems that you
@c have specified.  If a MIME message specifies a character set, Rmail
@c obeys that specification, unless @code{rmail-decode-mime-charset} is
@c @code{nil}.
rmail$B$G?7$7$$%a%$%k$r<u$1$H$C$?$H$-!"(B
$B3F%a%C%;!<%8$,JL!9$N%U%!%$%k$G$"$k$+$N$h$&$K!"(B
$B3F%a%C%;!<%8$O<+F0E*$K$=$N%a%$%k$,=q$+$l$?%3!<%G%#%s%0%7%9%F%`$GJQ49$5$l$^$9!#(B
$B$3$l$K$O!";XDj$7$?%3!<%G%#%s%0%7%9%F%`$NM%@h=g0LI=$r;H$$$^$9!#(B
MIME$B%a%C%;!<%8$,J8;z=89g$r;XDj$9$k$H$-$K$O!"(B
@code{rmail-decode-mime-charset}$B$,(B@code{nil}$B$G$J$$8B$j!"(B
rmail$B$O$=$N;XDj$K=>$$$^$9!#(B

@vindex rmail-file-coding-system
@c   For reading and saving Rmail files themselves, Emacs uses the coding
@c system specified by the variable @code{rmail-file-coding-system}.  The
@c default value is @code{nil}, which means that Rmail files are not
@c translated (they are read and written in the Emacs internal character
@c code).
rmail$B%U%!%$%k<+?H$rFI$s$@$jJ]B8$7$?$j$9$k$H$-$K$O!"(B
Emacs$B$O!"JQ?t(B@code{rmail-file-coding-system}$B$G;XDj$5$l$?(B
$B%3!<%G%#%s%0%7%9%F%`$r;H$$$^$9!#(B
$B$=$N%G%U%)%k%HCM$O!"(B@code{nil}$B$G$9!#(B
rmail$B%U%!%$%k$OJQ49$7$J$$$H$$$&0UL#$G$9(B
$B!J(Brmail$B%U%!%$%k$O!"(BEmacs$B$NFbItJ8;z%3!<%I$GFI$_=q$-$5$l$k!#!K(B

@node Specify Coding
@c @section Specifying a Coding System
@section $B%3!<%G%#%s%0%7%9%F%`$N;XDj(B

@c   In cases where Emacs does not automatically choose the right coding
@c system, you can use these commands to specify one:
Emacs$B$,<+F0E*$K@5$7$$%3!<%G%#%s%0%7%9%F%`$rA*Br$7$J$$>l9g$K$O!"(B
$B%3!<%G%#%s%0%7%9%F%`$r;XDj$9$k$D$.$N%3%^%s%I$r;HMQ$G$-$^$9!#(B

@table @kbd
@item C-x @key{RET} f @var{coding} @key{RET}
@c Use coding system @var{coding} for the visited file
@c in the current buffer.
$B%+%l%s%H%P%C%U%!$KK,Ld$7$?%U%!%$%k$K(B
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;H$&!#(B

@item C-x @key{RET} c @var{coding} @key{RET}
@c Specify coding system @var{coding} for the immediately following
@c command.
$B$3$N%3%^%s%I$ND>8e$KB3$/%3%^%s%I$KBP$7$F(B
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;XDj$9$k!#(B

@item C-x @key{RET} k @var{coding} @key{RET}
@c Use coding system @var{coding} for keyboard input.
$B%-!<%\!<%IF~NO$KBP$7$F%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;HMQ$9$k!#(B

@item C-x @key{RET} t @var{coding} @key{RET}
@c Use coding system @var{coding} for terminal output.
$BC<Kv=PNO$KBP$7$F%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;HMQ$9$k!#(B

@item C-x @key{RET} p @var{input-coding} @key{RET} @var{output-coding} @key{RET}
@c Use coding systems @var{input-coding} and @var{output-coding} for
@c subprocess input and output in the current buffer.
$B%+%l%s%H%P%C%U%!$G$N%5%V%W%m%;%9$NF~NO$H=PNO$K(B
$B%3!<%G%#%s%0%7%9%F%`(B@var{input-coding}$B$H(B@var{output-coding}$B$r;HMQ$9$k!#(B

@item C-x @key{RET} x @var{coding} @key{RET}
@c Use coding system @var{coding} for transferring selections to and from
@c other programs through the window system.
$B%&%#%s%I%&%7%9%F%`$r2p$7$?B>$N%W%m%0%i%`$H$N%;%l%/%7%g%s$N8r49$K$O!"(B
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;HMQ$9$k!#(B

@item C-x @key{RET} X @var{coding} @key{RET}
@c Use coding system @var{coding} for transferring @emph{one}
@c selection---the next one---to or from the window system.
$B%&%#%s%I%&%7%9%F%`$G(B@emph{1$B$D(B}$B$N%;%l%/%7%g%s$N8r49$K$O!"(B
$B%3!<%G%#%s%0%7%9%F%`(B@var{coding}$B$r;HMQ$9$k!#(B
@end table

@kindex C-x RET f
@findex set-buffer-file-coding-system
@c   The command @kbd{C-x @key{RET} f} (@code{set-buffer-file-coding-system})
@c specifies the file coding system for the current buffer---in other
@c words, which coding system to use when saving or rereading the visited
@c file.  You specify which coding system using the minibuffer.  Since this
@c command applies to a file you have already visited, it affects only the
@c way the file is saved.
$B%3%^%s%I(B@kbd{C-x @key{RET} f}$B!J(B@code{set-buffer-file-coding-system}$B!K$O(B
$B%+%l%s%H%P%C%U%!$KBP$7$F%U%!%$%k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$B$$$$$+$($l$P!"K,Ld$7$?%U%!%$%k$rJ]B8$7$?$j$U$?$?$SFI$`9~$`$H$-$K(B
$B;H$&%3!<%G%#%s%0%7%9%F%`$G$9!#(B
$B%3!<%G%#%s%0%7%9%F%`$O%_%K%P%C%U%!$r;H$C$F;XDj$7$^$9!#(B
$B$3$N%3%^%s%I$O!"$9$G$KK,Ld$7$?%U%!%$%k$K:nMQ$9$k$N$G!"(B
$B%U%!%$%k$rJ]B8$9$k$H$-$K$7$+1F6A$7$^$;$s!#(B

@kindex C-x RET c
@findex universal-coding-system-argument
@c   Another way to specify the coding system for a file is when you visit
@c the file.  First use the command @kbd{C-x @key{RET} c}
@c (@code{universal-coding-system-argument}); this command uses the
@c minibuffer to read a coding system name.  After you exit the minibuffer,
@c the specified coding system is used for @emph{the immediately following
@c command}.
$B%U%!%$%k$KBP$9$k%3!<%G%#%s%0%7%9%F%`$r;XDj$9$kJL$NJ}K!$O!"(B
$B%U%!%$%k$rK,Ld$9$k$H$-$G$9!#(B
$B$^$:%3%^%s%I(B@kbd{C-x @key{RET} c}
$B!J(B@code{universal-coding-system-argument}$B!K$r;H$$$^$9!#(B
$B$3$N%3%^%s%I$O!"%_%K%P%C%U%!$r;H$C$F%3!<%G%#%s%0%7%9%F%`L>$rFI$_$^$9!#(B
$B%_%K%P%C%U%!$r=P$?$"$H!"(B
@emph{$BD>8e$N%3%^%s%I(B}$B$KBP$7$F;XDj$7$?%3!<%G%#%s%0%7%9%F%`$,;HMQ$5$l$^$9!#(B

@c   So if the immediately following command is @kbd{C-x C-f}, for example,
@c it reads the file using that coding system (and records the coding
@c system for when the file is saved).  Or if the immediately following
@c command is @kbd{C-x C-w}, it writes the file using that coding system.
@c Other file commands affected by a specified coding system include
@c @kbd{C-x C-i} and @kbd{C-x C-v}, as well as the other-window variants of
@c @kbd{C-x C-f}.
$B$G$9$+$i!"$?$H$($P!"$=$ND>8e$N%3%^%s%I$,(B@kbd{C-x C-f}$B$J$i$P!"(B
$B$=$N%3!<%G%#%s%0%7%9%F%`$r;H$C$F%U%!%$%k$rFI$_$^$9(B
$B!J$=$7$F!"%U%!%$%k$rJ]B8$9$k$H$-$N$?$a$K(B
$B$=$N%3!<%G%#%s%0%7%9%F%`$r5-O?$7$^$9!K!#(B 
$B$"$k$$$O!"$=$ND>8e$N%3%^%s%I$,(B@kbd{C-x C-w}$B$J$i$P!"(B
$B$=$N%3!<%G%#%s%0%7%9%F%`$r;H$C$F%U%!%$%k$K=q$-$^$9!#(B
$B%3!<%G%#%s%0%7%9%F%`$r;XDj$9$k$3$H$G!"1F6A$5$l$kB>$N%U%!%$%k%3%^%s%I$O!"(B
@kbd{C-x C-i}$B$H(B@kbd{C-x C-v}$B!"$*$h$S!"(B
$BJL$N%&%#%s%I%&$r;H$&(B@kbd{C-x C-f}$B$NJQ7A$G$9!#(B

@c   @kbd{C-x @key{RET} c} also affects commands that start subprocesses,
@c including @kbd{M-x shell} (@pxref{Shell}).
@kbd{C-x @key{RET} c}$B$O!"(B@kbd{M-x shell}$B!J(B@pxref{Shell}$B!K$r4^$`(B
$B%5%V%W%m%;%9$r3+;O$9$k%3%^%s%I$K$b1F6A$7$^$9!#(B

@c   However, if the immediately following command does not use the coding
@c system, then @kbd{C-x @key{RET} c} ultimately has no effect.
$B$7$+$7$J$,$i!"$=$ND>8e$N%3%^%s%I$,%3!<%G%#%s%0%7%9%F%`$r;HMQ$7$J$$$J$i!"(B
@kbd{C-x @key{RET} c}$B$O:G=*E*$K$O2?$N8z2L$b$"$j$^$;$s!#(B

@c   An easy way to visit a file with no conversion is with the @kbd{M-x
@c find-file-literally} command.  @xref{Visiting}.
$B%U%!%$%k$rJQ49$7$J$$$GK,Ld$9$k$b$C$H$b4JC1$JJ}K!$O!"(B
@kbd{M-x find-file-literally}$B%3%^%s%I$G$9!#(B
@xref{Visiting}$B!#(B

@vindex default-buffer-file-coding-system
@c   The variable @code{default-buffer-file-coding-system} specifies the
@c choice of coding system to use when you create a new file.  It applies
@c when you find a new file, and when you create a buffer and then save it
@c in a file.  Selecting a language environment typically sets this
@c variable to a good choice of default coding system for that language
@c environment.
 $BJQ?t(B@code{default-buffer-file-coding-system}$B$O!"(B
$B?7$7$$%U%!%$%k$r:n@.$9$k$H$-$N%3!<%G%#%s%0%7%9%F%`$NA*Br$r;XDj$7$^$9!#(B
$B$3$NJQ?t$O!"?75,:n@.$N%U%!%$%k$rK,Ld$9$k$H$-!"$"$k$$$O!"(B
$B%P%C%U%!$r:n@.$7$F$=$l$r%U%!%$%k$KJ]B8$9$k$H$-$KE,MQ$5$l$^$9!#(B
$B8@8l4D6-$rA*Br$9$k$H!"E57?E*$K$O!"(B
$B8@8l4D6-$KBP$7$F:GE,$N%G%U%)%k%H$N%3!<%G%#%s%0%7%9%F%`$r(B
$B$3$NJQ?t$K@_Dj$7$^$9!#(B

@kindex C-x RET t
@findex set-terminal-coding-system
@c   The command @kbd{C-x @key{RET} t} (@code{set-terminal-coding-system})
@c specifies the coding system for terminal output.  If you specify a
@c character code for terminal output, all characters output to the
@c terminal are translated into that coding system.
$B%3%^%s%I(B@kbd{C-x @key{RET} t}$B!J(B@code{set-terminal-coding-system}$B!K$O(B
$BC<Kv=PNO$KBP$9$k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$BC<Kv=PNO$N%3!<%G%#%s%0%7%9%F%`$r;XDj$9$k$H!"(B
$BC<Kv$X$N$9$Y$F$NJ8;z=PNO$O$=$N%3!<%G%#%s%0%7%9%F%`$KK]Lu$5$l$^$9!#(B

@c   This feature is useful for certain character-only terminals built to
@c support specific languages or character sets---for example, European
@c terminals that support one of the ISO Latin character sets.  You need to
@c specify the terminal coding system when using multibyte text, so that
@c Emacs knows which characters the terminal can actually handle.
$B$3$N5!G=$O!"FCDj$N8@8l$dJ8;z=89g8~$1$K:n$i$l$?$"$k<o$NJ8;zC<Kv$K$OJXMx$G$9!#(B
$B$?$H$($P!"(BISO Latin $BJ8;z=89g$N(B1$B$D$r07$($k%h!<%m%C%Q$NC<Kv$G$9!#(B 
$B%^%k%A%P%$%H%F%-%9%H$r;H$C$F$$$k$H$-$K$O!"(B
Emacs$B$,C<Kv$G<B:]$K07$($kJ8;z$rCN$k$?$a$K!"(B
$BC<Kv%3!<%G%#%s%0%7%9%F%`$r;XDj$9$kI,MW$,$"$j$^$9!#(B

@c   By default, output to the terminal is not translated at all, unless
@c Emacs can deduce the proper coding system from your terminal type.
Emacs$B$,$"$J$?$NC<Kv$N@5$7$$%3!<%G%#%s%0%7%9%F%`$r?dB,$G$-$J$$8B$j!"(B
$B%G%U%)%k%H$G$O!"C<Kv=PNO$O$^$C$?$/JQ49$7$^$;$s!#(B

@kindex C-x RET k
@findex set-keyboard-coding-system
@c   The command @kbd{C-x @key{RET} k} (@code{set-keyboard-coding-system})
@c specifies the coding system for keyboard input.  Character-code
@c translation of keyboard input is useful for terminals with keys that
@c send non-ASCII graphic characters---for example, some terminals designed
@c for ISO Latin-1 or subsets of it.
$B%3%^%s%I(B@kbd{C-x @key{RET} k}$B!J(B@code{set-keyboard-coding-system}$B!K$O(B
$B%-!<%\!<%IF~NO$KBP$9$k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$B%-!<%\!<%I$+$iF~NO$7$?J8;z%3!<%I$NJQ49$O!"(B
$BHs(BASCII$B?^7AJ8;z$rAw=P$9$k%-!<$rM-$9$kC<Kv$K$OJXMx$G$9!#(B
$B$?$H$($P!"$$$/$D$+$NC<Kv$O!"(BISO Latin-1$B$d$=$NItJ,=89g8~$1$K@_7W$5$l$F$$$^$9!#(B

@c   By default, keyboard input is not translated at all.
$B%G%U%)%k%H$G$O!"%-!<%\!<%IF~NO$O$^$C$?$/JQ49$7$^$;$s!#(B

@c   There is a similarity between using a coding system translation for
@c keyboard input, and using an input method: both define sequences of
@c keyboard input that translate into single characters.  However, input
@c methods are designed to be convenient for interactive use by humans, and
@c the sequences that are translated are typically sequences of ASCII
@c printing characters.  Coding systems typically translate sequences of
@c non-graphic characters.
$B%3!<%G%#%s%0%7%9%F%`$r;HMQ$7$F%-!<%\!<%IF~NO$rJQ49$9$k$3$H$H!"(B
$BF~NOJ}<0$N;HMQ$K$O;w$?$H$3$m$,$"$j$^$9!#(B
$B$I$A$i$b!"(B1$B$D$NJ8;z$KJQ49$9$k%-!<%\!<%IF~NONs$rDj5A$7$F$$$^$9!#(B
$B$7$+$7$J$,$i!"F~NOJ}<0$O?M$,BPOCE*$K;HMQ$9$k$N$KJXMx$J$h$&$K@_7W$5$l$F$$$F!"(B
$BJQ49$5$l$kNs$OE57?E*$K$O(BASCII$B0u;zJ8;z$NNs$G$9!#(B
$B%3!<%G%#%s%0%7%9%F%`$O!"E57?E*$K$OHs?^7AJ8;z$NNs$rJQ49$7$^$9!#(B

@kindex C-x RET x
@kindex C-x RET X
@findex set-selection-coding-system
@findex set-next-selection-coding-system
@c   The command @kbd{C-x @key{RET} x} (@code{set-selection-coding-system})
@c specifies the coding system for sending selected text to the window
@c system, and for receiving the text of selections made in other
@c applications.  This command applies to all subsequent selections, until
@c you override it by using the command again.  The command @kbd{C-x
@c @key{RET} X} (@code{set-next-selection-coding-system}) specifies the
@c coding system for the next selection made in Emacs or read by Emacs.
$B%3%^%s%I(B@kbd{C-x @key{RET} x}$B!J(B@code{set-selection-coding-system}$B!K$O!"(B
$BA*Br$5$l$?%F%-%9%H$r%&%#%s%I%&%7%9%F%`$XAw$k$H$-!"$*$h$S!"(B
$BB>$N%"%W%j%1!<%7%g%s$G:n$i$l$?%;%l%/%7%g%s$N%F%-%9%H$r<u$1<h$k$H$-$N(B
$B%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$B$3$N%3%^%s%I$O!":F@_Dj$7$J$$8B$j!"0J9_$N$9$Y$F$N%;%l%/%7%g%s$K:nMQ$7$^$9!#(B
$B%3%^%s%I(B@kbd{C-x @key{RET} X}$B!J(B@code{set-next-selection-coding-system}$B!K$O!"(B
Emacs$B$,:n$k!?FI$`$D$.$N%;%l%/%7%g%s$N%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B

@kindex C-x RET p
@findex set-buffer-process-coding-system
@c   The command @kbd{C-x @key{RET} p} (@code{set-buffer-process-coding-system})
@c specifies the coding system for input and output to a subprocess.  This
@c command applies to the current buffer; normally, each subprocess has its
@c own buffer, and thus you can use this command to specify translation to
@c and from a particular subprocess by giving the command in the
@c corresponding buffer.
$B%3%^%s%I(B@kbd{C-x @key{RET} p}$B!J(B@code{set-buffer-process-coding-system}$B!K$O!"(B
$B%5%V%W%m%;%9$NF~=PNO$KBP$9$k%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$B$3$N%3%^%s%I$O%+%l%s%H%P%C%U%!$K:nMQ$7$^$9!#(B
$BDL>o!"3F%5%V%W%m%;%9$O$=$l<+?H$N%P%C%U%!$r;}$A$^$9!#(B
$B$G$9$+$i!"3F%5%V%W%m%;%9$NF~=PNO$NJQ49$r;XDj$9$k$K$O!"(B
$BBP1~$9$k%P%C%U%!$G$3$N%3%^%s%I$r;HMQ$7$^$9!#(B

@c   By default, process input and output are not translated at all.
$B%G%U%)%k%H$G$O!"%W%m%;%9$NF~=PNO$O$^$C$?$/JQ49$7$^$;$s!#(B

@vindex file-name-coding-system
@c   The variable @code{file-name-coding-system} specifies a coding system
@c to use for encoding file names.  If you set the variable to a coding
@c system name (as a Lisp symbol or a string), Emacs encodes file names
@c using that coding system for all file operations.  This makes it
@c possible to use non-ASCII characters in file names---or, at least, those
@c non-ASCII characters which the specified coding system can encode.
$BJQ?t(B@code{file-name-coding-system}$B$O!"(B
$B%U%!%$%kL>$rId9f2=$9$k$?$a$N%3!<%G%#%s%0%7%9%F%`$r;XDj$7$^$9!#(B
$B$3$NJQ?t$K!J(BLisp$B%7%s%\%k$dJ8;zNs$G!K%3!<%G%#%s%0%7%9%F%`L>$r@_Dj$9$k$H!"(B
Emacs$B$O!"$9$Y$F$N%U%!%$%kA`:n$KBP$7$F$=$N%3!<%G%#%s%0%7%9%F%`$r(B
$B;H$C$F%U%!%$%kL>$rId9f2=$7$^$9!#(B
$B$3$l$O!"%U%!%$%kL>$KHs(BASCII$BJ8;z$r;H$&$3$H$r2DG=$K$7$F$$$^$9!#(B
$B$"$k$$$O!">/$J$/$H$b!";XDj$7$?%3!<%G%#%s%0%7%9%F%`$GId9f2=$G$-$k(B
$BHs(BASCII$BJ8;z$r;H$($k$O$:$G$9!#(B

@c   If @code{file-name-coding-system} is @code{nil}, Emacs uses a default
@c coding system determined by the selected language environment.  In the
@c default language environment, any non-ASCII characters in file names are
@c not encoded specially; they appear in the file system using the internal
@c Emacs representation.
@code{file-name-coding-system}$B$,(B@code{nil}$B$J$i$P!"(B
Emacs$B$O!"A*Br$5$l$F$$$k8@8l4D6-$G7h$^$k%G%U%)%k%H$N%3!<%G%#%s%0%7%9%F%`$r(B
$B;H$$$^$9!#(B
$B%G%U%)%k%H$N8@8l4D6-$G$O!"(B
$B%U%!%$%kL>$NCf$NHs(BASCII$BJ8;z$OFCJL$KId9f2=$7$^$;$s!#(B
Emacs$B$NFbItI=8=$G%U%!%$%k%7%9%F%`>e$K8=$l$^$9!#(B

@c   @strong{Warning:} if you change @code{file-name-coding-system} (or the
@c language environment) in the middle of an Emacs session, problems can
@c result if you have already visited files whose names were encoded using
@c the earlier coding system and cannot be encoded (or are encoded
@c differently) under the new coding system.  If you try to save one of
@c these buffers under the visited file name, saving may use the wrong file
@c name, or it may get an error.  If such a problem happens, use @kbd{C-x
@c C-w} to specify a new file name for that buffer.
@strong{$B7Y9p!'(B}@code{ }Emacs$B%;%C%7%g%s$NESCf$G(B@code{file-name-coding-system}
$B!J$d8@8l4D6-!K$rJQ99$9$k$H!"LdBj$H$J$k>l9g$,$"$j$^$9!#(B
$B$D$^$j!"$=$l$^$G$N%3!<%G%#%s%0%7%9%F%`$GId9f2=$5$l$?L>A0$N%U%!%$%k$r(B
$B$9$G$KK,Ld$7$F$$$F!"?7$7$$%3!<%G%#%s%0%7%9%F%`$G$O$=$NL>A0$r(B
$BId9f2=$G$-$J$$!J$"$k$$$O0[$J$C$FId9f2=$5$l$k!K$H$-$G$9!#(B
$B$=$N$h$&$J%P%C%U%!$rK,Ld@h%U%!%$%kL>$GJ]B8$7$h$&$H$9$k$H!"(B
$B$^$A$,$C$?L>A0$N%U%!%$%k$KJ]B8$5$l$k$+!"%(%i!<$K$J$j$^$9!#(B
$B$=$N$h$&$JLdBj$,H/@8$7$?>l9g$K$O!"(B @kbd{C-x C-w}$B$r;H$C$F!"(B
$B$=$N%P%C%U%!$K?7$7$$%U%!%$%kL>$r;XDj$7$^$9!#(B

@node Fontsets
@c @section Fontsets
@c @cindex fontsets
@section $B%U%)%s%H%;%C%H(B
@cindex $B%U%)%s%H%;%C%H(B

@c   A font for X Windows typically defines shapes for one alphabet or
@c script.  Therefore, displaying the entire range of scripts that Emacs
@c supports requires a collection of many fonts.  In Emacs, such a
@c collection is called a @dfn{fontset}.  A fontset is defined by a list of
@c fonts, each assigned to handle a range of character codes. 
X$B%&%#%s%I%&%7%9%F%`$N%U%)%s%H$O!"E57?E*$K$O!"(B
1$B$D$N%"%k%U%!%Y%C%H$dJ8;z=89g$N7A$rDj5A$7$F$$$^$9!#(B
$B$7$?$,$C$F!"(BEmacs$B$,07$($kJ8;z$NHO0OA4BN$rI=<($9$k$K$O!"(B
$B$?$/$5$s$N%U%)%s%H$r=8$a$?$b$N$,I,MW$G$9!#(B
Emacs$B$G$O!"$=$&$$$C$?%U%)%s%H$r=8$a$?$b$N$r(B
@dfn{$B%U%)%s%H%;%C%H(B}$B!J(Bfontset$B!K$H8F$S$^$9!#(B
$B%U%)%s%H%;%C%H$O!"$"$kJ8;z%3!<%IHO0O$r07$&%U%)%s%H$N%j%9%H$GDj5A$5$l$^$9!#(B

@c   Each fontset has a name, like a font.  The available X fonts are
@c defined by the X server; fontsets, however, are defined within Emacs
@c itself.  Once you have defined a fontset, you can use it within Emacs by
@c specifying its name, anywhere that you could use a single font.  Of
@c course, Emacs fontsets can use only the fonts that the X server
@c supports; if certain characters appear on the screen as hollow boxes,
@c this means that the fontset in use for them has no font for those
@c characters.
$B3F%U%)%s%H%;%C%H$K$O!"%U%)%s%H$HF1MM$KL>A0$,$"$j$^$9!#(B
$B;HMQ2DG=$J(BX$B$N%U%)%s%H$O!"(BX$B%5!<%P!<$,Dj5A$7$^$9!#(B
$B$7$+$7!"%U%)%s%H%;%C%H$O(BEmacs$B$NCf$GDj5A$5$l$^$9!#(B
$B$$$C$?$s%U%)%s%H%;%C%H$rDj5A$9$l$P!"%U%)%s%H$r;H$($k>lLL$G$O$I$3$G$b!"(B
$B$=$NL>A0$r;XDj$7$F(BEmacs$BFb$N%U%)%s%H%;%C%H$r;HMQ$G$-$^$9!#(B
$B$b$A$m$s!"(BEmacs$B$N%U%)%s%H%;%C%H$G$O!"(BX$B%5!<%P!<$G;H$($k%U%)%s%H$@$1$r;H$($^$9!#(B
$B$"$kJ8;z$,2hLL$GCfH4$-$NH"$GI=<($5$l$?$J$i!"(B
$B$=$NJ8;z$K;HMQ$7$?%U%)%s%H%;%C%H$K$O!"(B
$B$=$NJ8;z$KBP$9$k%U%)%s%H$,$J$$$3$H$r0UL#$7$^$9!#(B

@c   Emacs creates two fontsets automatically: the @dfn{standard fontset}
@c and the @dfn{startup fontset}.  The standard fontset is most likely to
@c have fonts for a wide variety of non-ASCII characters; however, this is
@c not the default for Emacs to use.  (By default, Emacs tries to find a
@c font which has bold and italic variants.)  You can specify use of the
@c standard fontset with the @samp{-fn} option, or with the @samp{Font} X
@c resource (@pxref{Font X}).  For example,
Emacs$B$O!"(B@dfn{$BI8=`%U%)%s%H%;%C%H(B}$B$H(B@dfn{$B%9%?!<%H%"%C%W%U%)%s%H%;%C%H(B}$B$N(B
2$B$D$N%U%)%s%H%;%C%H$r<+F0E*$K:n$j$^$9!#(B
$BI8=`%U%)%s%H%;%C%H$O!"Hs(BASCII$BJ8;z8~$1$N9-$$HO0O$N%U%)%s%H$r(B
$B$b$C$H$b;}$A$=$&$J$b$N$G$9!#(B
$B$7$+$7!"$3$l$O!"(BEmacs$B$,;H$&%G%U%)%k%H$G$O$"$j$^$;$s!#(B
$B!J%G%U%)%k%H$G$O!"(B
Emacs$B$O%\!<%k%I$H%$%?%j%C%/$NJQ<o$N%U%)%s%H$r$_$D$1$h$&$H$9$k!#!K(B
$B%*%W%7%g%s(B@samp{-fn}$B$d(BX$B$N%j%=!<%9(B@samp{Font}$B!J(B@pxref{Font X}$B!K$G(B
$B;HMQ$9$kI8=`%U%)%s%H%;%C%H$r;XDj$G$-$^$9!#(B
$B$?$H$($P!"$D$.$N$h$&$K$7$^$9!#(B

@example
emacs -fn fontset-standard
@end example

@c   A fontset does not necessarily specify a font for every character
@c code.  If a fontset specifies no font for a certain character, or if it
@c specifies a font that does not exist on your system, then it cannot
@c display that character properly.  It will display that character as an
@c empty box instead.
$B%U%)%s%H%;%C%H$,!"$9$Y$F$NJ8;z%3!<%I$KBP$9$k%U%)%s%H$r(B
$B;XDj$9$kI,MW$O$"$j$^$;$s!#(B
$B%U%)%s%H%;%C%H$,!"$"$kJ8;z$KBP$7$F%U%)%s%H$r;XDj$7$F$$$J$$!"$"$k$$$O!"(B
$B%7%9%F%`$KB8:_$7$J$$%U%)%s%H$r;XDj$7$F$$$k>l9g$K$O!"(B
$B$=$NJ8;z$r@5$7$/I=<($G$-$^$;$s!#(B
$B$=$N$+$o$j$K!"CfH4$-$NH"$rI=<($7$^$9!#(B 

@vindex highlight-wrong-size-font
@c   The fontset height and width are determined by the ASCII characters
@c (that is, by the font used for ASCII characters in that fontset).  If
@c another font in the fontset has a different height, or a different
@c width, then characters assigned to that font are clipped to the
@c fontset's size.  If @code{highlight-wrong-size-font} is non-@code{nil},
@c a box is displayed around these wrong-size characters as well.
$B%U%)%s%H%;%C%H$N9b$5$HI}$O!"(BASCII$BJ8;z$G7hDj$5$l$^$9(B
$B!J$D$^$j!"$=$N%U%)%s%H%;%C%HFb$G(BASCII$BJ8;zMQ$K;H$o$l$k%U%)%s%H!K!#(B
$B%U%)%s%H%;%C%H$N$"$k%U%)%s%H$,0[$J$k9b$5$dI}$r;}$D>l9g$K$O!"(B
$B$=$N%U%)%s%H$r3d$jEv$F$i$l$?J8;z$O!"(B
$B%U%)%s%H%;%C%H$NBg$-$5$K@Z$j5M$a$i$l$^$9!#(B
@code{highlight-wrong-size-font}$B$,(B@code{nil}$B0J30$J$i$P!"(B
$B$3$l$i$N$^$A$,$C$?Bg$-$5$NJ8;z$OH"$G0O$^$l$FI=<($5$l$^$9!#(B

@node Defining Fontsets
@c @section Defining fontsets
@section $B%U%)%s%H%;%C%H$NDj5AJ}K!(B

@vindex standard-fontset-spec
@cindex $BI8=`%U%)%s%H%;%C%H(B
@c @cindex standard fontset
@c   Emacs creates a standard fontset automatically according to the value
@c of @code{standard-fontset-spec}.  This fontset's name is
Emacs$B$O(B@code{standard-fontset-spec}$B$NCM$K=>$C$F!"(B
$B<+F0E*$KI8=`%U%)%s%H%;%C%H$r:n$j$^$9!#(B
$B%U%)%s%H%;%C%H$NL>A0$O$D$.$N$H$*$j$G$9!#(B

@example
-*-fixed-medium-r-normal-*-16-*-*-*-*-*-fontset-standard
@end example

@noindent
@c or just @samp{fontset-standard} for short.
$B$^$?$O!">JN,$7$F(B@samp{fontset-standard}$B$G$9!#(B

@c   Bold, italic, and bold-italic variants of the standard fontset are
@c created automatically.  Their names have @samp{bold} instead of
@c @samp{medium}, or @samp{i} instead of @samp{r}, or both.
$BI8=`%U%)%s%H%;%C%H$N%\!<%k%I!"%$%?%j%C%/!"%\!<%k%I%$%?%j%C%/$NJQ<o$b(B
$B<+F0E*$K:n$i$l$^$9!#(B
$B$=$l$i$NL>A0$O!"(B@samp{medium}$B$N$+$o$j$K(B@samp{bold}$B!"(B
@samp{r}$B$N$+$o$j$K(B@samp{i}$B!"$"$k$$$O!"N>J}$H$b$=$N$h$&$K$J$j$^$9!#(B

@c @cindex startup fontset
@cindex $B%9%?!<%H%"%C%W%U%)%s%H%;%C%H(B
@c   If you specify a default ASCII font with the @samp{Font} resource or
@c the @samp{-fn} argument, Emacs generates a fontset from it
@c automatically.  This is the @dfn{startup fontset} and its name is
@c @code{fontset-startup}.  It does this by replacing the @var{foundry},
@c @var{family}, @var{add_style}, and @var{average_width} fields of the
@c font name with @samp{*}, replacing @var{charset_registry} field with
@c @samp{fontset}, and replacing @var{charset_encoding} field with
@c @samp{startup}, then using the resulting string to specify a fontset.
$B%j%=!<%9(B@samp{Font}$B$d%*%W%7%g%s(B@samp{-fn}$B$G!"(B
$B%G%U%)%k%H$N(BASCII$B%U%)%s%H$r;XDj$9$k$H!"(B
Emacs$B$O$=$l$+$i<+F0E*$K%U%)%s%H%;%C%H$r@8@.$7$^$9!#(B
$B$3$l$,!"(B@dfn{$B%9%?!<%H%"%C%W%U%)%s%H%;%C%H(B}$B$G!"(B
$B$=$NL>A0$O(B@code{fontset-startup}$B$G$9!#(B
$B$3$l$O!"%U%)%s%HL>$N%U%#!<%k%I!"(B@var{foundry}$B!"(B@var{family}$B!"(B
@var{add_style}$B!"(B@var{average_width}$B$r(B@samp{*}$B$G!"(B
@var{charset_registry}$B$r(B@samp{fontset}$B$G!"(B
@var{charset_encoding}$B$r(B@samp{startup}$B$GCV$-49$($FF@$i$l$?J8;zNs$r(B
$B%U%)%s%H%;%C%H$N;XDj$K;HMQ$7$^$9!#(B

@c   For instance, if you start Emacs this way,
$B$?$H$($P!"(BEmacs$B$r$D$.$N$h$&$K5/F0$7$^$9!#(B

@example
emacs -fn "*courier-medium-r-normal--14-140-*-iso8859-1"
@end example

@noindent
@c Emacs generates the following fontset and uses it for the initial X
@c window frame:
Emacs$B$,$D$.$N%U%)%s%H%;%C%H$r@8@.$7$F!"(B
X$B%&%#%s%I%&$N=i4|%U%l!<%`$K;H$$$^$9!#(B

@example
-*-*-medium-r-normal-*-14-140-*-*-*-*-fontset-startup
@end example

@c   With the X resource @samp{Emacs.Font}, you can specify a fontset name
@c just like an actual font name.  But be careful not to specify a fontset
@c name in a wildcard resource like @samp{Emacs*Font}---that wildcard
@c specification applies to various other purposes, such as menus, and
@c menus cannot handle fontsets.
X$B$N%j%=!<%9(B@samp{Emacs.Font}$B$G!"(B
$B%U%)%s%H%;%C%HL>$r<B:]$N%U%)%s%HL>$N$h$&$K;XDj$G$-$^$9!#(B
$B$7$+$7!"(B@samp{Emacs*Font}$B$N$h$&$J%o%$%k%I%+!<%I$r;H$C$?%j%=!<%9$K(B
$B%U%)%s%H%;%C%HL>$r;XDj$7$J$$$h$&$KCm0U$7$F$/$@$5$$!#(B
$B%o%$%k%I%+!<%I$r;H$C$?;XDj$O!"%U%)%s%H%;%C%H$r07$($J$$%a%K%e!<$N$h$&$J!"(B
$BB>$N$5$^$6$^$JL\E*$K$bE,MQ$5$l$^$9!#(B

@c   You can specify additional fontsets using X resources named
@c @samp{Fontset-@var{n}}, where @var{n} is an integer starting from 0.
@c The resource value should have this form:
@samp{Fontset-@var{n}}$B$H$$$&L>A0$N(BX$B$N%j%=!<%9$r(B
$B;H$C$FDI2C%U%)%s%H%;%C%H$r;XDj$G$-$^$9!#(B
$B$?$@$7!"(B@var{n}$B$O(B0$B$+$i;O$^$k@0?t$G$9!#(B
$B%j%=!<%9$NCM$O$D$.$N$h$&$J7A<0$G$J$1$l$P$J$j$^$;$s!#(B

@smallexample
@var{fontpattern}, @r{[}@var{charsetname}:@var{fontname}@r{]@dots{}}
@end smallexample

@noindent
@c @var{fontpattern} should have the form of a standard X font name, except
@c for the last two fields.  They should have the form
@c @samp{fontset-@var{alias}}.
@var{fontpattern}$B$O!":G8e$N(B2$B$D$N%U%#!<%k%I$r=|$$$F!"(B
$BI8=`$N(BX$B%U%)%s%HL>$N7A<0$G$J$1$l$P$J$j$^$;$s!#(B
$B:G8e$N(B2$B$D$N%U%#!<%k%I$O!"(B@samp{fontset-@var{alias}}$B$N7A<0$r;}$D$Y$-$G$9!#(B

@c   The fontset has two names, one long and one short.  The long name is
@c @var{fontpattern}.  The short name is @samp{fontset-@var{alias}}.  You
@c can refer to the fontset by either name.
$B%U%)%s%H%;%C%H$K$O(B2$B$D$NL>A0!"D9$$L>A0$HC;$$L>A0$,$"$j$^$9!#(B
$BD9$$L>A0$O(B@var{fontpattern}$B$G$9!#(B
$BC;$$L>A0$O(B@samp{fontset-@var{alias}}$B$G$9!#(B
$B$I$A$i$NL>A0$G$b%U%)%s%H%;%C%H$r;2>H$G$-$^$9!#(B

@c   The construct @samp{@var{charset}:@var{font}} specifies which font to
@c use (in this fontset) for one particular character set.  Here,
@c @var{charset} is the name of a character set, and @var{font} is the
@c font to use for that character set.  You can use this construct any
@c number of times in defining one fontset.
@samp{@var{charset}:@var{font}}$B$H$$$&9=@.$O!"(B
$B$"$kJ8;z=89g$KBP$7$F!J$3$N%U%)%s%H%;%C%H$G$O!K(B
$B$I$N%U%)%s%H$r;HMQ$9$k$+$r;XDj$7$^$9!#(B
$B$3$3$G(B@var{charset}$B$O!"J8;z=89g$NL>A0$G!"(B
@var{font}$B$O$=$NJ8;z=89g$K;HMQ$9$k%U%)%s%H$G$9!#(B
1$B$D$N%U%)%s%H%;%C%H$NDj5A$NCf$G$O!"$3$N9=@.$r2?EY$G$b;HMQ$G$-$^$9!#(B

@c   For the other character sets, Emacs chooses a font based on
@c @var{fontpattern}.  It replaces @samp{fontset-@var{alias}} with values
@c that describe the character set.  For the ASCII character font,
@c @samp{fontset-@var{alias}} is replaced with @samp{ISO8859-1}.
$BB>$NJ8;z=89g$KBP$7$F$O!"(BEmacs$B$O(B@var{fontpattern}$B$K4p$E$$$FA*Br$7$^$9!#(B
$B$3$l$K$O!"J8;z=89g$r5-=R$9$kCM$G(B@samp{fontset-@var{alias}}$B$rCV$-49$($^$9!#(B
ASCII$BJ8;z%U%)%s%H$KBP$7$F$O!"(B@samp{fontset-@var{alias}}$B$r(B
@samp{ISO8859-1}$B$GCV$-49$($^$9(B

@c   In addition, when several consecutive fields are wildcards, Emacs
@c collapses them into a single wildcard.  This is to prevent use of
@c auto-scaled fonts.  Fonts made by scaling larger fonts are not usable
@c for editing, and scaling a smaller font is not useful because it is
@c better to use the smaller font in its own size, which Emacs does.
$B$3$l$K2C$($F!"$$$/$D$+O"B3$7$?%U%#!<%k%I$,%o%$%k%I%+!<%I$G$"$k$J$i!"(B
Emacs$B$O$=$l$i$r(B1$B$D$N%o%$%k%I%+!<%I$K$^$H$a$^$9!#(B
$B$3$l$O!"<+F0E*$K3HBg=L>.$7$?%U%)%s%H$N;HMQ$rHr$1$k$?$a$G$9!#(B
$B3HBg$7$?%U%)%s%H$OJT=8$K$O;H$($^$;$s!#(B
$B$^$?!"=L>.$7$?%U%)%s%H$bJXMx$G$O$"$j$^$;$s!#(B
$B$H$$$&$N$O!"(BEmacs$B$,$=$&$9$k$h$&$K!"(B
$B$b$H$b$H>.$5$J%U%)%s%H$r;H$&$[$&$,$h$$$+$i$G$9!#(B

@c   Thus if @var{fontpattern} is this,
$B$7$?$,$C$F!"(B@var{fontpattern}$B$,$D$.$N$h$&$G$"$k$H!"(B

@example
-*-fixed-medium-r-normal-*-24-*-*-*-*-*-fontset-24
@end example

@noindent
@c the font specification for ASCII characters would be this:
ASCII$BJ8;z$KBP$9$k%U%)%s%H;XDj$O$D$.$N$h$&$K$J$j$^$9!#(B

@example
-*-fixed-medium-r-normal-*-24-*-ISO8859-1
@end example

@noindent
@c and the font specification for Chinese GB2312 characters would be this:
$B$^$?!"(BChinese GB2312$BJ8;z$KBP$9$k%U%)%s%H;XDj$O$D$.$N$h$&$K$J$j$^$9!#(B

@example
-*-fixed-medium-r-normal-*-24-*-gb2312*-*
@end example

@c   You may not have any Chinese font matching the above font
@c specification.  Most X distributions include only Chinese fonts that
@c have @samp{song ti} or @samp{fangsong ti} in @var{family} field.  In
@c such a case, @samp{Fontset-@var{n}} can be specified as below:
$B>e$N%U%)%s%H;XDj$K0lCW$9$kCf9q8l%U%)%s%H$,$J$$$+$b$7$l$^$;$s!#(B
$BB?$/$N(BX$B$NG[I[$K$O!"(B@var{family}$B%U%#!<%k%I$,(B
@samp{song ti}$B$+(B@samp{fangsong ti}$B$NCf9q8l%U%)%s%H$@$1$,4^$^$l$F$$$^$9!#(B
$B$=$&$$$C$?>l9g!"(B@samp{Fontset-@var{n}}$B$r$D$.$N$h$&$K;XDj$7$^$9!#(B

@smallexample
Emacs.Fontset-0: -*-fixed-medium-r-normal-*-24-*-*-*-*-*-fontset-24,\
        chinese-gb2312:-*-*-medium-r-normal-*-24-*-gb2312*-*
@end smallexample

@noindent
@c Then, the font specifications for all but Chinese GB2312 characters have
@c @samp{fixed} in the @var{family} field, and the font specification for
@c Chinese GB2312 characters has a wild card @samp{*} in the @var{family}
@c field.
$B$=$&$9$k$H!"(BChinese GB2312$B$NJ8;z$r=|$/%U%)%s%H;XDj$G$O(B
@var{family}$B%U%#!<%k%I$,(B@samp{fixed}$B$H$J$j!"(B
Chinese GB2312$B$NJ8;z$KBP$9$k%U%)%s%H;XDj$G$O(B
@var{family}$B%U%#!<%k%I$,(B@samp{*}$B$H$J$j$^$9!#(B

@findex create-fontset-from-fontset-spec
@c   The function that processes the fontset resource value to create the
@c fontset is called @code{create-fontset-from-fontset-spec}.  You can also
@c call this function explicitly to create a fontset.
$B%U%)%s%H%;%C%H$N%j%=!<%9CM$r=hM}$7$F%U%)%s%H%;%C%H$r:n$k4X?t$O!"(B
@code{create-fontset-from-fontset-spec}$B$G$9!#(B
$B%U%)%s%H%;%C%H$r:n$k$?$a$K!"$3$N4X?t$rL@<(E*$K8F$V$3$H$b$G$-$^$9!#(B

@c   @xref{Font X}, for more information about font naming in X.
X$B$K$*$1$k%U%)%s%H$NL?L>K!$K$D$$$F>\$7$/$O!"(B@xref{Font X}$B!#(B

@node Single-Byte European Support
@c @section Single-byte European Character Support
@section 1$B%P%$%H%h!<%m%C%QJ8;z$N;H$$J}(B

@c @cindex European character sets
@c @cindex accented characters
@c @cindex ISO Latin character sets
@c @cindex Unibyte operation
@cindex $B%h!<%m%C%QJ8;z=89g(B
@cindex $B%"%/%;%s%HJ8;z(B
@cindex ISO Latin $BJ8;z=89g(B
@cindex $B%f%K%P%$%HA`:n(B
@vindex enable-multibyte-characters
@c   The ISO 8859 Latin-@var{n} character sets define character codes in
@c the range 160 to 255 to handle the accented letters and punctuation
@c needed by various European languages.  If you disable multibyte
@c characters, Emacs can still handle @emph{one} of these character codes
@c at a time.  To specify @emph{which} of these codes to use, invoke
@c @kbd{M-x set-language-environment} and specify a suitable language
@c environment such as @samp{Latin-@var{n}}.
ISO 8859 Latin-@var{n}$BJ8;z=89g$O!"(B
$B$5$^$6$^$J%h!<%m%C%Q$N8@8l$GI,MW$H$5$l$k%"%/%;%s%HJ8;z$H6gFIE@5-9f$r(B
$B07$&$?$a$K!"(B160$B$+$i(B250$B$NHO0O$NJ8;z%3!<%I$rDj5A$7$F$$$^$9!#(B
$B%^%k%A%P%$%HJ8;z$r;HMQIT2D$K$7$F$b!"(B
Emacs$B$O!"0lEY$K$O$3$l$i$NJ8;z%3!<%I$N(B@emph{1$B$D(B}$B$r07$($^$9!#(B
$B$3$l$i$N%3!<%I$N(B@emph{$B$I$l(B}$B$r;H$&$+$r;XDj$9$k$K$O!"(B
@kbd{M-x set-language-environment}$B$r5/F0$7$F!"(B
@samp{Latin-@var{n}}$B$N$h$&$JE,@Z$J8@8l4D6-$r;XDj$7$^$9!#(B

@c   For more information about unibyte operation, see @ref{Enabling
@c Multibyte}.  Note particularly that you probably want to ensure that
@c your initialization files are read as unibyte if they contain non-ASCII
@c characters.
$B%f%K%P%$%HA`:n$K$D$$$F$h$j>\$7$/$O!"(B
@ref{Enabling Multibyte}$B$r;2>H$7$F$/$@$5$$!#(B
$BHs(BASCII$BJ8;z$r4^$s$@=i4|2=%U%!%$%k$r%f%K%P%$%H$GFI$`$3$H$rJ]>Z$7$?$$$H$-$K$O(B
$BFC$KCm0U$7$F$/$@$5$$!#(B

@vindex unibyte-display-via-language-environment
@c   Emacs can also display those characters, provided the terminal or font
@c in use supports them.  This works automatically.  Alternatively, if you
@c are using a window system, Emacs can also display single-byte characters
@c through fontsets, in effect by displaying the equivalent multibyte
@c characters according to the current language environment.  To request
@c this, set the variable @code{unibyte-display-via-language-environment}
@c to a non-@code{nil} value.
$BC<Kv$d;H$C$F$$$k%U%)%s%H$G$3$l$i$NJ8;z$r07$($k$J$i$P!"(B
Emacs$B$O$3$l$i$NJ8;z$rI=<($G$-$^$9!#(B
$B$3$l$O<+F0E*$K9T$o$l$^$9!#(B
$B$"$k$$$O!"%&%#%s%I%&%7%9%F%`$r;H$C$F$$$k>l9g$K$O!"(B
$B8=:_$N8@8l4D6-$K=>$C$F$=$l$i$KBP1~$9$k%^%k%A%P%$%HJ8;z$rI=<($9$k$3$H$G!"(B
Emacs$B$O%U%)%s%H%;%C%H$r2p$7$F(B1$B%P%$%HJ8;z$rI=<($G$-$^$9!#(B
$B$3$l$r9T$&$K$O!"(B
$BJQ?t(B@code{unibyte-display-via-language-environment}$B$K(B@code{nil}$B0J30$N(B
$BCM$r@_Dj$7$^$9!#(B

@c @cindex @code{iso-ascii} library
@cindex @code{iso-ascii}$B%i%$%V%i%j(B
@c   If your terminal does not support display of the Latin-1 character
@c set, Emacs can display these characters as ASCII sequences which at
@c least give you a clear idea of what the characters are.  To do this,
@c load the library @code{iso-ascii}.  Similar libraries for other
@c Latin-@var{n} character sets could be implemented, but we don't have
@c them yet.
$B$b$7!"C<Kv$G(BLatin-1$BJ8;z=89g$rI=<($G$-$J$1$l$P!"(B
Emacs$B$O!"$3$l$i$NJ8;z$r$=$NJ8;z$,>/$J$/$H$b2?$G$"$k$+$rL@3N$KM}2r$G$-$k$h$&$J(B
ASCII$BNs$H$7$FI=<($G$-$^$9!#(B
$B$3$l$r9T$&$K$O!"%i%$%V%i%j(B@code{iso-ascii}$B$r%m!<%I$7$^$9!#(B
$BB>$N(BLatin-@var{n}$BJ8;z=89g$KBP$7$F$b;w$?$h$&$J%i%$%V%i%j$r<BAu$G$-$^$9$,!"(B
$B$^$@9T$C$F$$$^$;$s!#(B

@findex standard-display-8bit
@c @cindex 8-bit display
@cindex 8$B%S%C%HI=<((B
@c   Normally non-ISO-8859 characters (between characters 128 and 159
@c inclusive) are displayed as octal escapes.  You can change this for
@c non-standard `extended' versions of ISO-8859 character sets by using the
@c function @code{standard-display-8bit} in the @code{disp-table} library.
$B!JJ8;z(B128$B$+$i(B159$B$N!KHs(BISO 8859$BJ8;z$O!"DL>o!"(B8$B?JI=<($5$l$^$9!#(B
$B%i%$%V%i%j(B@code{disp-table}$B$N4X?t(B@code{standard-display-8bit}$B$r;H$($P!"(B
$B$3$NI=<($rHsI8=`$N!V3HD%!WHG$N(BISO 8859$BJ8;z=89g$KJQ99$G$-$^$9!#(B

@c   There are three different ways you can input single-byte non-ASCII
@c characters:
1$B%P%$%HHs(BASCII$BJ8;z$rF~NO$9$k0[$J$kJ}K!$,(B3$B$D$"$j$^$9!#(B

@itemize @bullet
@item
@c If your keyboard can generate character codes 128 and up, representing
@c non-ASCII characters, execute the following expression to enable Emacs to
@c understand them:
$B%-!<%\!<%I$,!"Hs(BASCII$BJ8;z$rI=8=$9$k(B128$B0J>e$NJ8;z%3!<%I$r@8@.$G$-$k$J$i$P!"(B
Emacs$B$,$=$l$i$rM}2r$G$-$k$h$&$K$D$.$N<0$r<B9T$9$k!#(B

@example
(set-input-mode (car (current-input-mode))
                (nth 1 (current-input-mode))
                0)
@end example

@item
@c You can use an input method for the selected language environment.
@c @xref{Input Methods}.  When you use an input method in a unibyte buffer,
@c the non-ASCII character you specify with it is converted to unibyte.
$BA*Br$7$?8@8l4D6-$NF~NOJ}<0$r;H$&!#(B
@pxref{Input Methods}$B!#(B
$B%f%K%P%$%H$N%P%C%U%!$GF~NOJ}<0$r;H$&$H!"(B
$BF~NO$7$?Hs(BASCII$BJ8;z$O!"%f%K%P%$%H$KJQ49$5$l$k!#(B

@kindex C-x 8
@c @cindex @code{iso-transl} library
@cindex @code{iso-transl} $B%i%$%V%i%j(B
@item
@c For Latin-1 only, you can use the
@c key @kbd{C-x 8} as a ``compose character'' prefix for entry of
@c non-ASCII Latin-1 printing characters.  @kbd{C-x 8} is good for
@c insertion (in the minibuffer as well as other buffers), for searching,
@c and in any other context where a key sequence is allowed.
Latin-1$B$KBP$7$F$@$1$@$,!"Hs(BASCII$B$N(BLatin-1$B$N0u;zJ8;z$NF~NO$N(B
$B!X9g@.J8;z!Y%W%l%U%#%C%/%9$H$7$F(B@kbd{C-x 8}$B$r;H$($k!#(B
@kbd{C-x 8}$B$O!"!J%_%K%P%C%U%!$dB>$N%P%C%U%!$G$N!KA^F~!"C5:w!"(B
$B%-!<Ns$,5v$5$l$kB>$NJ8L.$J$I$G;H$($k!#(B

@c @kbd{C-x 8} works by loading the @code{iso-transl} library.  Once that
@c library is loaded, the @key{ALT} modifier key, if you have one, serves
@c the same purpose as @kbd{C-x 8}; use @key{ALT} together with an accent
@c character to modify the following letter.  In addition, if you have keys
@c for the Latin-1 ``dead accent characters'', they too are defined to
@c compose with the following character, once @code{iso-transl} is loaded.
$B%i%$%V%i%j(B@code{iso-transl}$B$r%m!<%I$9$k$3$H$G(B@kbd{C-x 8}$B$OF0:n$9$k!#(B
$B%i%$%V%i%j$r%m!<%I$7$F$*$/$H!"(B
@key{ALT}$B=$>~%-!<$,$"$k$J$i$P!"(B@kbd{C-x 8}$B$HF1$8L\E*$G;HMQ$G$-$k!#(B
$B8eB3$NJ8;z$r=$>~$9$k$K$O!"%"%/%;%s%HJ8;z$H0l=o$K(B@key{ALT}$B$r;H$&!#(B
$B$5$i$K!"(BLatin-1$B$N!X@lMQ%"%/%;%s%HJ8;z!Y%-!<$,$"$k$H!"(B
@code{iso-transl}$B$r%m!<%I8e$O!"(B
$B$=$l$i$N%-!<$b8eB3$NJ8;z$r9g@.$9$k$h$&$KDj5A$5$l$k!#(B
@end itemize