Initial revision

1 files changed, 3520 insertions, 0 deletions

diff --git a/src/coding.c b/src/coding.c
new file mode 100644
index 00000000000..95bbd26fef9
--- /dev/null
+++ b/src/coding.c
@@ -0,0 +1,3520 @@
+/* Coding system handler (conversion, detection, and etc).
+   Ver.1.0.
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*** TABLE OF CONTENTS ***
+
+  1. Preamble
+  2. Emacs' internal format handlers
+  3. ISO2022 handlers
+  4. Shift-JIS and BIG5 handlers
+  5. End-of-line handlers
+  6. C library functions
+  7. Emacs Lisp library functions
+  8. Post-amble
+
+*/
+
+/*** GENERAL NOTE on CODING SYSTEM ***
+
+  Coding system is an encoding mechanism of one or more character
+  sets.  Here's a list of coding systems which Emacs can handle.  When
+  we say "decode", it means converting some other coding system to
+  Emacs' internal format, and when we say "encode", it means
+  converting Emacs' internal format to some other coding system.
+
+  0. Emacs' internal format
+
+  Emacs itself holds a multi-lingual character in a buffer and a string
+  in a special format.  Details are described in the section 2.
+
+  1. ISO2022
+
+  The most famous coding system for multiple character sets.  X's
+  Compound Text, various EUCs (Extended Unix Code), and such coding
+  systems used in Internet communication as ISO-2022-JP are all
+  variants of ISO2022.  Details are described in the section 3.
+
+  2. SJIS (or Shift-JIS or MS-Kanji-Code)
+   
+  A coding system to encode character sets: ASCII, JISX0201, and
+  JISX0208.  Widely used for PC's in Japan.  Details are described in
+  the section 4.
+
+  3. BIG5
+
+  A coding system to encode character sets: ASCII and Big5.  Widely
+  used by Chinese (mainly in Taiwan and Hong Kong).  Details are
+  described in the section 4.  In this file, when written as "BIG5"
+  (all uppercase), it means the coding system, and when written as
+  "Big5" (capitalized), it means the character set.
+
+  4. Else
+
+  If a user want to read/write a text encoded in a coding system not
+  listed above, he can supply a decoder and an encoder for it in CCL
+  (Code Conversion Language) programs.  Emacs executes the CCL program
+  while reading/writing.
+
+  Emacs represent a coding-system by a Lisp symbol that has a property
+  `coding-system'.  But, before actually using the coding-system, the
+  information about it is set in a structure of type `struct
+  coding_system' for rapid processing.  See the section 6 for more
+  detail.
+
+*/
+
+/*** GENERAL NOTES on END-OF-LINE FORMAT ***
+
+  How end-of-line of a text is encoded depends on a system.  For
+  instance, Unix's format is just one byte of `line-feed' code,
+  whereas DOS's format is two bytes sequence of `carriage-return' and
+  `line-feed' codes.  MacOS's format is one byte of `carriage-return'.
+
+  Since how characters in a text is encoded and how end-of-line is
+  encoded is independent, any coding system described above can take
+  any format of end-of-line.  So, Emacs has information of format of
+  end-of-line in each coding-system.  See the section 6 for more
+  detail.
+
+*/
+
+/*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
+
+  These functions check if a text between SRC and SRC_END is encoded
+  in the coding system category XXX.  Each returns an integer value in
+  which appropriate flag bits for the category XXX is set.  The flag
+  bits are defined in macros CODING_CATEGORY_MASK_XXX.  Below is the
+  template of these functions.  */
+#if 0
+int
+detect_coding_internal (src, src_end)
+     unsigned char *src, *src_end;
+{
+  ...
+}
+#endif
+
+/*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
+
+  These functions decode SRC_BYTES length text at SOURCE encoded in
+  CODING to Emacs' internal format.  The resulting text goes to a
+  place pointed by DESTINATION, the length of which should not exceed
+  DST_BYTES.  The bytes actually processed is returned as *CONSUMED.
+  The return value is the length of the decoded text.  Below is a
+  template of these functions.  */
+#if 0
+decode_coding_XXX (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  ...
+}
+#endif
+
+/*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
+
+  These functions encode SRC_BYTES length text at SOURCE of Emacs
+  internal format to CODING.  The resulting text goes to a place
+  pointed by DESTINATION, the length of which should not exceed
+  DST_BYTES.  The bytes actually processed is returned as *CONSUMED.
+  The return value is the length of the encoded text.  Below is a
+  template of these functions.  */
+#if 0
+encode_coding_XXX (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  ...
+}
+#endif
+
+/*** COMMONLY USED MACROS ***/
+
+/* The following three macros ONE_MORE_BYTE, TWO_MORE_BYTES, and
+   THREE_MORE_BYTES safely get one, two, and three bytes from the
+   source text respectively.  If there are not enough bytes in the
+   source, they jump to `label_end_of_loop'.  The caller should set
+   variables `src' and `src_end' to appropriate areas in advance.  */
+
+#define ONE_MORE_BYTE(c1)   	\
+  do {			     	\
+    if (src < src_end)	     	\
+      c1 = *src++;	     	\
+    else		     	\
+      goto label_end_of_loop;	\
+  } while (0)
+
+#define TWO_MORE_BYTES(c1, c2) 	\
+  do {			       	\
+    if (src + 1 < src_end)     	\
+      c1 = *src++, c2 = *src++;	\
+    else		       	\
+      goto label_end_of_loop;  	\
+  } while (0)
+
+#define THREE_MORE_BYTES(c1, c2, c3)	    	\
+  do {					    	\
+    if (src + 2 < src_end)		    	\
+      c1 = *src++, c2 = *src++, c3 = *src++;	\
+    else				    	\
+      goto label_end_of_loop;		    	\
+  } while (0)
+
+/* The following three macros DECODE_CHARACTER_ASCII,
+   DECODE_CHARACTER_DIMENSION1, and DECODE_CHARACTER_DIMENSION2 put
+   the multi-byte form of a character of each class at the place
+   pointed by `dst'.  The caller should set the variable `dst' to
+   point to an appropriate area and the variable `coding' to point to
+   the coding-system of the currently decoding text in advance.  */
+
+/* Decode one ASCII character C.  */
+
+#define DECODE_CHARACTER_ASCII(c)				\
+  do {								\
+    if (COMPOSING_P (coding->composing))			\
+      *dst++ = 0xA0, *dst++ = (c) | 0x80;			\
+    else							\
+      *dst++ = (c);						\
+  } while (0)
+
+/* Decode one DIMENSION1 character of which charset is CHARSET and
+   position-code is C.  */
+
+#define DECODE_CHARACTER_DIMENSION1(charset, c)				\
+  do {									\
+    unsigned char leading_code = CHARSET_LEADING_CODE_BASE (charset);	\
+    if (COMPOSING_P (coding->composing))				\
+      *dst++ = leading_code + 0x20;					\
+    else								\
+      *dst++ = leading_code;						\
+    if (leading_code = CHARSET_LEADING_CODE_EXT (charset))		\
+      *dst++ = leading_code;						\
+    *dst++ = (c) | 0x80;						\
+  } while (0)
+
+/* Decode one DIMENSION2 character of which charset is CHARSET and
+   position-codes are C1 and C2.  */
+
+#define DECODE_CHARACTER_DIMENSION2(charset, c1, c2)	\
+  do {							\
+    DECODE_CHARACTER_DIMENSION1 (charset, c1);		\
+    *dst++ = (c2) | 0x80;				\
+  } while (0)
+
+
+/*** 1. Preamble ***/
+
+#include <stdio.h>
+
+#ifdef emacs
+
+#include <config.h>
+#include "lisp.h"
+#include "buffer.h"
+#include "charset.h"
+#include "ccl.h"
+#include "coding.h"
+#include "window.h"
+
+#else  /* not emacs */
+
+#include "mulelib.h"
+
+#endif /* not emacs */
+
+Lisp_Object Qcoding_system, Qeol_type;
+Lisp_Object Qbuffer_file_coding_system;
+Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
+
+extern Lisp_Object Qinsert_file_contents, Qwrite_region;
+Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
+Lisp_Object Qstart_process, Qopen_network_stream;
+Lisp_Object Qtarget_idx;
+
+/* Mnemonic character of each format of end-of-line.  */
+int eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
+/* Mnemonic character to indicate format of end-of-line is not yet
+   decided.  */
+int eol_mnemonic_undecided;
+
+#ifdef emacs
+
+Lisp_Object Qcoding_system_vector, Qcoding_system_p, Qcoding_system_error;
+
+/* Coding-systems are handed between Emacs Lisp programs and C internal
+   routines by the following three variables.  */
+/* Coding-system for reading files and receiving data from process.  */
+Lisp_Object Vcoding_system_for_read;
+/* Coding-system for writing files and sending data to process.  */
+Lisp_Object Vcoding_system_for_write;
+/* Coding-system actually used in the latest I/O.  */
+Lisp_Object Vlast_coding_system_used;
+
+/* Coding-system of what terminal accept for displaying.  */
+struct coding_system terminal_coding;
+
+/* Coding-system of what is sent from terminal keyboard.  */
+struct coding_system keyboard_coding;
+
+Lisp_Object Vcoding_system_alist;
+
+#endif /* emacs */
+
+Lisp_Object Qcoding_category_index;
+
+/* List of symbols `coding-category-xxx' ordered by priority.  */
+Lisp_Object Vcoding_category_list;
+
+/* Table of coding-systems currently assigned to each coding-category.  */
+Lisp_Object coding_category_table[CODING_CATEGORY_IDX_MAX];
+
+/* Table of names of symbol for each coding-category.  */
+char *coding_category_name[CODING_CATEGORY_IDX_MAX] = {
+  "coding-category-internal",
+  "coding-category-sjis",
+  "coding-category-iso-7",
+  "coding-category-iso-8-1",
+  "coding-category-iso-8-2",
+  "coding-category-iso-else",
+  "coding-category-big5",
+  "coding-category-binary"
+};
+
+/* Alist of charsets vs the alternate charsets.  */
+Lisp_Object Valternate_charset_table;
+
+/* Alist of charsets vs revision number.  */
+Lisp_Object Vcharset_revision_alist;
+
+
+/*** 2. Emacs internal format handlers ***/
+
+/* Emacs' internal format for encoding multiple character sets is a
+   kind of multi-byte encoding, i.e. encoding a character by a sequence
+   of one-byte codes of variable length.  ASCII characters and control
+   characters (e.g. `tab', `newline') are represented by one-byte as
+   is.  It takes the range 0x00 through 0x7F.  The other characters
+   are represented by a sequence of `base leading-code', optional
+   `extended leading-code', and one or two `position-code's.  Length
+   of the sequence is decided by the base leading-code.  Leading-code
+   takes the range 0x80 through 0x9F, whereas extended leading-code
+   and position-code take the range 0xA0 through 0xFF.  See the
+   document of `charset.h' for more detail about leading-code and
+   position-code.
+
+   There's one exception in this rule.  Special leading-code
+   `leading-code-composition' denotes that the following several
+   characters should be composed into one character.  Leading-codes of
+   components (except for ASCII) are added 0x20.  An ASCII character
+   component is represented by a 2-byte sequence of `0xA0' and
+   `ASCII-code + 0x80'.  See also the document in `charset.h' for the
+   detail of composite character.  Hence, we can summarize the code
+   range as follows:
+
+   --- CODE RANGE of Emacs' internal format ---
+   (character set)	(range)
+   ASCII		0x00 .. 0x7F
+   ELSE (1st byte)	0x80 .. 0x9F
+	(rest bytes)	0xA0 .. 0xFF
+   ---------------------------------------------
+
+  */
+
+enum emacs_code_class_type emacs_code_class[256];
+
+/* Go to the next statement only if *SRC is accessible and the code is
+   greater than 0xA0.  */
+#define CHECK_CODE_RANGE_A0_FF 	\
+  do {			       	\
+    if (src >= src_end)	       	\
+      goto label_end_of_switch;	\
+    else if (*src++ < 0xA0)    	\
+      return 0;		       	\
+  } while (0)
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in Emacs' internal format.  If it is,
+   return CODING_CATEGORY_MASK_INTERNAL, else return 0.  */
+
+int
+detect_coding_internal (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+  int composing = 0;
+
+  while (src < src_end)
+    {
+      c = *src++;
+
+      if (composing)
+	{
+	  if (c < 0xA0)
+	    composing = 0;
+	  else
+	    c -= 0x20;
+	}
+
+      switch (emacs_code_class[c])
+	{
+	case EMACS_ascii_code:
+	case EMACS_linefeed_code:
+	  break;
+
+	case EMACS_control_code:
+	  if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+	    return 0;
+	  break;
+
+	case EMACS_invalid_code:
+	  return 0;
+
+	case EMACS_leading_code_composition: /* c == 0x80 */
+	  if (composing)
+	    CHECK_CODE_RANGE_A0_FF;
+	  else
+	    composing = 1;
+	  break;
+
+	case EMACS_leading_code_4:
+	  CHECK_CODE_RANGE_A0_FF;
+	  /* fall down to check it two more times ...  */
+
+	case EMACS_leading_code_3:
+	  CHECK_CODE_RANGE_A0_FF;
+	  /* fall down to check it one more time ...  */
+
+	case EMACS_leading_code_2:
+	  CHECK_CODE_RANGE_A0_FF;
+	  break;
+
+	default:
+	label_end_of_switch:
+	  break;
+	}
+    }
+  return CODING_CATEGORY_MASK_INTERNAL;
+}
+
+
+/*** 3. ISO2022 handlers ***/
+
+/* The following note describes the coding system ISO2022 briefly.
+   Since the intension of this note is to help understanding of the
+   programs in this file, some parts are NOT ACCURATE or OVERLY
+   SIMPLIFIED.  For the thorough understanding, please refer to the
+   original document of ISO2022.
+
+   ISO2022 provides many mechanisms to encode several character sets
+   in 7-bit and 8-bit environment.  If one choose 7-bite environment,
+   all text is encoded by codes of less than 128.  This may make the
+   encoded text a little bit longer, but the text get more stability
+   to pass through several gateways (some of them split MSB off).
+
+   There are two kind of character set: control character set and
+   graphic character set.  The former contains control characters such
+   as `newline' and `escape' to provide control functions (control
+   functions are provided also by escape sequence).  The latter
+   contains graphic characters such as ' A' and '-'.  Emacs recognizes
+   two control character sets and many graphic character sets.
+
+   Graphic character sets are classified into one of the following
+   four classes, DIMENSION1_CHARS94, DIMENSION1_CHARS96,
+   DIMENSION2_CHARS94, DIMENSION2_CHARS96 according to the number of
+   bytes (DIMENSION) and the number of characters in one dimension
+   (CHARS) of the set.  In addition, each character set is assigned an
+   identification tag (called "final character" and denoted as <F>
+   here after) which is unique in each class.  <F> of each character
+   set is decided by ECMA(*) when it is registered in ISO.  Code range
+   of <F> is 0x30..0x7F (0x30..0x3F are for private use only).
+
+   Note (*): ECMA = European Computer Manufacturers Association
+
+   Here are examples of graphic character set [NAME(<F>)]:
+	o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
+	o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
+	o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
+	o DIMENSION2_CHARS96 -- none for the moment
+
+   A code area (1byte=8bits) is divided into 4 areas, C0, GL, C1, and GR.
+	C0 [0x00..0x1F] -- control character plane 0
+	GL [0x20..0x7F] -- graphic character plane 0
+	C1 [0x80..0x9F] -- control character plane 1
+	GR [0xA0..0xFF] -- graphic character plane 1
+
+   A control character set is directly designated and invoked to C0 or
+   C1 by an escape sequence.  The most common case is that ISO646's
+   control character set is designated/invoked to C0 and ISO6429's
+   control character set is designated/invoked to C1, and usually
+   these designations/invocations are omitted in a coded text.  With
+   7-bit environment, only C0 can be used, and a control character for
+   C1 is encoded by an appropriate escape sequence to fit in the
+   environment.  All control characters for C1 are defined the
+   corresponding escape sequences.
+
+   A graphic character set is at first designated to one of four
+   graphic registers (G0 through G3), then these graphic registers are
+   invoked to GL or GR.  These designations and invocations can be
+   done independently.  The most common case is that G0 is invoked to
+   GL, G1 is invoked to GR, and ASCII is designated to G0, and usually
+   these invocations and designations are omitted in a coded text.
+   With 7-bit environment, only GL can be used.
+
+   When a graphic character set of CHARS94 is invoked to GL, code 0x20
+   and 0x7F of GL area work as control characters SPACE and DEL
+   respectively, and code 0xA0 and 0xFF of GR area should not be used.
+
+   There are two ways of invocation: locking-shift and single-shift.
+   With locking-shift, the invocation lasts until the next different
+   invocation, whereas with single-shift, the invocation works only
+   for the following character and doesn't affect locking-shift.
+   Invocations are done by the following control characters or escape
+   sequences.
+
+   ----------------------------------------------------------------------
+   function		control char	escape sequence	description
+   ----------------------------------------------------------------------
+   SI  (shift-in)		0x0F	none		invoke G0 to GL
+   SI  (shift-out)		0x0E	none		invoke G1 to GL
+   LS2 (locking-shift-2)	none	ESC 'n'		invoke G2 into GL
+   LS3 (locking-shift-3)	none	ESC 'o'		invoke G3 into GL
+   SS2 (single-shift-2)		0x8E	ESC 'N'		invoke G2 into GL
+   SS3 (single-shift-3)		0x8F	ESC 'O'		invoke G3 into GL
+   ----------------------------------------------------------------------
+   The first four are for locking-shift.  Control characters for these
+   functions are defined by macros ISO_CODE_XXX in `coding.h'.
+
+   Designations are done by the following escape sequences.
+   ----------------------------------------------------------------------
+   escape sequence	description
+   ----------------------------------------------------------------------
+   ESC '(' <F>		designate DIMENSION1_CHARS94<F> to G0
+   ESC ')' <F>		designate DIMENSION1_CHARS94<F> to G1
+   ESC '*' <F>		designate DIMENSION1_CHARS94<F> to G2
+   ESC '+' <F>		designate DIMENSION1_CHARS94<F> to G3
+   ESC ',' <F>		designate DIMENSION1_CHARS96<F> to G0 (*)
+   ESC '-' <F>		designate DIMENSION1_CHARS96<F> to G1
+   ESC '.' <F>		designate DIMENSION1_CHARS96<F> to G2
+   ESC '/' <F>		designate DIMENSION1_CHARS96<F> to G3
+   ESC '$' '(' <F>	designate DIMENSION2_CHARS94<F> to G0 (**)
+   ESC '$' ')' <F>	designate DIMENSION2_CHARS94<F> to G1
+   ESC '$' '*' <F>	designate DIMENSION2_CHARS94<F> to G2
+   ESC '$' '+' <F>	designate DIMENSION2_CHARS94<F> to G3
+   ESC '$' ',' <F>	designate DIMENSION2_CHARS96<F> to G0 (*)
+   ESC '$' '-' <F>	designate DIMENSION2_CHARS96<F> to G1
+   ESC '$' '.' <F>	designate DIMENSION2_CHARS96<F> to G2
+   ESC '$' '/' <F>	designate DIMENSION2_CHARS96<F> to G3
+   ----------------------------------------------------------------------
+
+   In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
+   of dimension 1, chars 94, and final character <F>, and etc.
+
+   Note (*): Although these designations are not allowed in ISO2022,
+   Emacs accepts them on decoding, and produces them on encoding
+   CHARS96 character set in a coding system which is characterized as
+   7-bit environment, non-locking-shift, and non-single-shift.
+
+   Note (**): If <F> is '@', 'A', or 'B', the intermediate character
+   '(' can be omitted.  We call this as "short-form" here after.
+
+   Now you may notice that there are a lot of ways for encoding the
+   same multilingual text in ISO2022.  Actually, there exist many
+   coding systems such as Compound Text (used in X's inter client
+   communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
+   (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
+   localized platforms), and all of these are variants of ISO2022.
+
+   In addition to the above, Emacs handles two more kinds of escape
+   sequences: ISO6429's direction specification and Emacs' private
+   sequence for specifying character composition.
+
+   ISO6429's direction specification takes the following format:
+	o CSI ']'      -- end of the current direction
+	o CSI '0' ']'  -- end of the current direction
+	o CSI '1' ']'  -- start of left-to-right text
+	o CSI '2' ']'  -- start of right-to-left text
+   The control character CSI (0x9B: control sequence introducer) is
+   abbreviated to the escape sequence ESC '[' in 7-bit environment.
+   
+   Character composition specification takes the following format:
+	o ESC '0' -- start character composition
+	o ESC '1' -- end character composition
+   Since these are not standard escape sequences of any ISO, the use
+   of them for these meaning is restricted to Emacs only.  */
+
+enum iso_code_class_type iso_code_class[256];
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in ISO2022.  If it is, returns an
+   integer in which appropriate flag bits any of:
+	CODING_CATEGORY_MASK_ISO_7
+	CODING_CATEGORY_MASK_ISO_8_1
+	CODING_CATEGORY_MASK_ISO_8_2
+	CODING_CATEGORY_MASK_ISO_ELSE
+   are set.  If a code which should never appear in ISO2022 is found,
+   returns 0.  */
+
+int
+detect_coding_iso2022 (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char graphic_register[4];
+  unsigned char c, esc_cntl;
+  int mask = (CODING_CATEGORY_MASK_ISO_7
+	      | CODING_CATEGORY_MASK_ISO_8_1
+	      | CODING_CATEGORY_MASK_ISO_8_2);
+  /* We may look ahead maximum 3 bytes.  */
+  unsigned char *adjusted_src_end = src_end - 3;
+  int i;
+
+  for (i = 0; i < 4; i++)
+    graphic_register[i] = CHARSET_ASCII;
+
+  while (src < adjusted_src_end)
+    {
+      c = *src++;
+      switch (c)
+	{
+	case ISO_CODE_ESC:
+	  if (src >= adjusted_src_end)
+	    break;
+	  c = *src++;
+	  if (c == '$')
+	    {
+	      /* Designation of 2-byte character set.  */
+	      if (src >= adjusted_src_end)
+		break;
+	      c = *src++;
+	    }
+	  if ((c >= ')' && c <= '+') || (c >= '-' && c <= '/'))
+	    /* Designation to graphic register 1, 2, or 3.  */
+	    mask &= ~CODING_CATEGORY_MASK_ISO_7;
+	  else if (c == 'N' || c == 'O' || c == 'n' || c == 'o')
+	    return CODING_CATEGORY_MASK_ISO_ELSE;
+	  break;
+
+	case ISO_CODE_SI:
+	case ISO_CODE_SO:
+	  return CODING_CATEGORY_MASK_ISO_ELSE;
+
+	case ISO_CODE_CSI:
+	case ISO_CODE_SS2:
+	case ISO_CODE_SS3:
+	  mask &= ~CODING_CATEGORY_MASK_ISO_7;
+	  break;
+
+	default:
+	  if (c < 0x80)
+	    break;
+	  else if (c < 0xA0)
+	    return 0;
+	  else
+	    {
+	      int count = 1;
+
+	      mask &= ~CODING_CATEGORY_MASK_ISO_7;
+	      while (src < adjusted_src_end && *src >= 0xA0)
+		count++, src++;
+	      if (count & 1 && src < adjusted_src_end)
+		mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
+	    }
+	  break;
+	}
+    }
+
+  return mask;
+}
+
+/* Decode a character of which charset is CHARSET and the 1st position
+   code is C1.  If dimension of CHARSET 2, the 2nd position code is
+   fetched from SRC and set to C2.  If CHARSET is negative, it means
+   that we are decoding ill formed text, and what we can do is just to
+   read C1 as is.  */
+
+#define DECODE_ISO_CHARACTER(charset, c1)			\
+  do {								\
+    if ((charset) >= 0 && CHARSET_DIMENSION (charset) == 2)	\
+      ONE_MORE_BYTE (c2);					\
+    if (COMPOSING_HEAD_P (coding->composing))			\
+      {								\
+	*dst++ = LEADING_CODE_COMPOSITION;			\
+	if (COMPOSING_WITH_RULE_P (coding->composing))		\
+	  /* To tell composition rules are embeded.  */		\
+	  *dst++ = 0xFF;					\
+	coding->composing += 2;					\
+      }								\
+    if ((charset) < 0)						\
+      *dst++ = c1;						\
+    else if ((charset) == CHARSET_ASCII)			\
+      DECODE_CHARACTER_ASCII (c1);				\
+    else if (CHARSET_DIMENSION (charset) == 1)			\
+      DECODE_CHARACTER_DIMENSION1 (charset, c1);		\
+    else							\
+      DECODE_CHARACTER_DIMENSION2 (charset, c1, c2);		\
+    if (COMPOSING_WITH_RULE_P (coding->composing))		\
+      /* To tell a composition rule follows.  */		\
+      coding->composing = COMPOSING_WITH_RULE_RULE;		\
+  } while (0)
+
+/* Set designation state into CODING.  */
+#define DECODE_DESIGNATION(reg, dimension, chars, final_char)		\
+  do {							      		\
+    int charset = ISO_CHARSET_TABLE (dimension, chars, final_char);	\
+    Lisp_Object temp							\
+      = Fassq (CHARSET_SYMBOL (charset), Valternate_charset_table);	\
+    if (! NILP (temp))							\
+      charset = get_charset_id (XCONS (temp)->cdr);			\
+    if (charset >= 0)					      		\
+      {					      				\
+        if (coding->direction == 1					\
+	    && CHARSET_REVERSE_CHARSET (charset) >= 0)      		\
+          charset = CHARSET_REVERSE_CHARSET (charset);      		\
+        CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;		\
+      }						      			\
+  } while (0)
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
+
+int
+decode_coding_iso2022 (coding, source, destination,
+		       src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 7, we subtract 6
+     from DST_END to assure that overflow checking is necessary only
+     at the head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 6;
+  int charset;
+  /* Charsets invoked to graphic plane 0 and 1 respectively.  */
+  int charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+  int charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+	 The loop will be exited when there's not enough source text
+	 to analyze long escape sequence or 2-byte code (within macros
+	 ONE_MORE_BYTE or TWO_MORE_BYTES).  In that case, SRC is reset
+	 to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, cmprule;
+
+      switch (iso_code_class [c1])
+	{
+	case ISO_0x20_or_0x7F:
+	  if (!coding->composing
+	      && (charset0 < 0 || CHARSET_CHARS (charset0) == 94))
+	    {
+	      /* This is SPACE or DEL.  */
+	      *dst++ = c1;
+	      break;
+	    }
+	  /* This is a graphic character, we fall down ...  */
+
+	case ISO_graphic_plane_0:
+	  if (coding->composing == COMPOSING_WITH_RULE_RULE)
+	    {
+	      /* This is a composition rule.  */
+	      *dst++ = c1 | 0x80;
+	      coding->composing = COMPOSING_WITH_RULE_TAIL;
+	    }
+	  else
+	    DECODE_ISO_CHARACTER (charset0, c1);
+	  break;
+
+	case ISO_0xA0_or_0xFF:
+	  if (charset1 < 0 || CHARSET_CHARS (charset1) == 94)
+	    {
+	      /* Invalid code.  */
+	      *dst++ = c1;
+	      break;
+	    }
+	  /* This is a graphic character, we fall down ... */
+
+	case ISO_graphic_plane_1:
+	  DECODE_ISO_CHARACTER (charset1, c1);
+	  break;
+
+	case ISO_control_code:
+	  /* All ISO2022 control characters in this class have the
+             same representation in Emacs internal format.  */
+	  *dst++ = c1;
+	  break;
+
+	case ISO_carriage_return:
+	  if (coding->eol_type == CODING_EOL_CR)
+	    {
+	      *dst++ = '\n';
+	    }
+	  else if (coding->eol_type == CODING_EOL_CRLF)
+	    {
+	      ONE_MORE_BYTE (c1);
+	      if (c1 == ISO_CODE_LF)
+		*dst++ = '\n';
+	      else
+		{
+		  src--;
+		  *dst++ = c1;
+		}
+	    }
+	  else
+	    {
+	      *dst++ = c1;
+	    }
+	  break;
+
+	case ISO_shift_out:
+	  CODING_SPEC_ISO_INVOCATION (coding, 0) = 1;
+	  charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+	  break;
+
+	case ISO_shift_in:
+	  CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
+	  charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+	  break;
+
+	case ISO_single_shift_2_7:
+	case ISO_single_shift_2:
+	  /* SS2 is handled as an escape sequence of ESC 'N' */
+	  c1 = 'N';
+	  goto label_escape_sequence;
+
+	case ISO_single_shift_3:
+	  /* SS2 is handled as an escape sequence of ESC 'O' */
+	  c1 = 'O';
+	  goto label_escape_sequence;
+
+	case ISO_control_sequence_introducer:
+	  /* CSI is handled as an escape sequence of ESC '[' ...  */
+	  c1 = '[';
+	  goto label_escape_sequence;
+
+	case ISO_escape:
+	  ONE_MORE_BYTE (c1);
+	label_escape_sequence:
+	  /* Escape sequences handled by Emacs are invocation,
+	     designation, direction specification, and character
+	     composition specification.  */
+	  switch (c1)
+	    {
+	    case '&':		/* revision of following character set */
+	      ONE_MORE_BYTE (c1);
+	      if (!(c1 >= '@' && c1 <= '~'))
+		{
+		  goto label_invalid_escape_sequence;
+		}
+	      ONE_MORE_BYTE (c1);
+	      if (c1 != ISO_CODE_ESC)
+		{
+		  goto label_invalid_escape_sequence;
+		}
+	      ONE_MORE_BYTE (c1);
+	      goto label_escape_sequence;
+
+	    case '$':		/* designation of 2-byte character set */
+	      ONE_MORE_BYTE (c1);
+	      if (c1 >= '@' && c1 <= 'B')
+		{	/* designation of JISX0208.1978, GB2312.1980,
+				   or JISX0208.1980 */
+		  DECODE_DESIGNATION (0, 2, 94, c1);
+		}
+	      else if (c1 >= 0x28 && c1 <= 0x2B)
+		{	/* designation of DIMENSION2_CHARS94 character set */
+		  ONE_MORE_BYTE (c2);
+		  DECODE_DESIGNATION (c1 - 0x28, 2, 94, c2);
+		}
+	      else if (c1 >= 0x2C && c1 <= 0x2F)
+		{	/* designation of DIMENSION2_CHARS96 character set */
+		  ONE_MORE_BYTE (c2);
+		  DECODE_DESIGNATION (c1 - 0x2C, 2, 96, c2);
+		}
+	      else
+		{
+		  goto label_invalid_escape_sequence;
+		}
+	      break;
+
+	    case 'n':		/* invocation of locking-shift-2 */
+	      CODING_SPEC_ISO_INVOCATION (coding, 0) = 2;
+	      break;
+
+	    case 'o':		/* invocation of locking-shift-3 */
+	      CODING_SPEC_ISO_INVOCATION (coding, 0) = 3;
+	      break;
+
+	    case 'N':		/* invocation of single-shift-2 */
+	      ONE_MORE_BYTE (c1);
+	      charset = CODING_SPEC_ISO_DESIGNATION (coding, 2);
+	      DECODE_ISO_CHARACTER (charset, c1);
+	      break;
+
+	    case 'O':		/* invocation of single-shift-3 */
+	      ONE_MORE_BYTE (c1);
+	      charset = CODING_SPEC_ISO_DESIGNATION (coding, 3);
+	      DECODE_ISO_CHARACTER (charset, c1);
+	      break;
+
+	    case '0':		/* start composing without embeded rules */
+	      coding->composing = COMPOSING_NO_RULE_HEAD;
+	      break;
+
+	    case '1':		/* end composing */
+	      coding->composing = COMPOSING_NO;
+	      break;
+
+	    case '2':		/* start composing with embeded rules */
+	      coding->composing = COMPOSING_WITH_RULE_HEAD;
+	      break;
+
+	    case '[':		/* specification of direction */
+	      /* For the moment, nested direction is not supported.
+		 So, the value of `coding->direction' is 0 or 1: 0
+		 means left-to-right, 1 means right-to-left.  */
+	      ONE_MORE_BYTE (c1);
+	      switch (c1)
+		{
+		case ']':	/* end of the current direction */
+		  coding->direction = 0;
+
+		case '0':	/* end of the current direction */
+		case '1':	/* start of left-to-right direction */
+		  ONE_MORE_BYTE (c1);
+		  if (c1 == ']')
+		    coding->direction = 0;
+		  else
+		    goto label_invalid_escape_sequence;
+		  break;
+
+		case '2':	/* start of right-to-left direction */
+		  ONE_MORE_BYTE (c1);
+		  if (c1 == ']')
+		    coding->direction= 1;
+		  else
+		    goto label_invalid_escape_sequence;
+		  break;
+
+		default:
+		  goto label_invalid_escape_sequence;
+		}
+	      break;
+
+	    default:
+	      if (c1 >= 0x28 && c1 <= 0x2B)
+		{	/* designation of DIMENSION1_CHARS94 character set */
+		  ONE_MORE_BYTE (c2);
+		  DECODE_DESIGNATION (c1 - 0x28, 1, 94, c2);
+		}
+	      else if (c1 >= 0x2C && c1 <= 0x2F)
+		{	/* designation of DIMENSION1_CHARS96 character set */
+		  ONE_MORE_BYTE (c2);
+		  DECODE_DESIGNATION (c1 - 0x2C, 1, 96, c2);
+		}
+	      else
+		{
+		  goto label_invalid_escape_sequence;
+		}
+	    }
+	  /* We must update these variables now.  */
+	  charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+	  charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
+	  break;
+
+	label_invalid_escape_sequence:
+	  {
+	    int length = src - src_base;
+
+	    bcopy (src_base, dst, length);
+	    dst += length;
+	  }
+	}
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  /* If this is the last block of the text to be decoded, we had
+     better just flush out all remaining codes in the text although
+     they are not valid characters.  */
+  if (coding->last_block)
+    {
+      bcopy (src, dst, src_end - src);
+      dst += (src_end - src);
+      src = src_end;
+    }
+  *consumed = src - source;
+  return dst - destination;
+}
+
+/* ISO2022 encoding staffs.  */
+
+/*
+   It is not enough to say just "ISO2022" on encoding, but we have to
+   specify more details.  In Emacs, each coding-system of ISO2022
+   variant has the following specifications:
+	1. Initial designation to G0 thru G3.
+	2. Allows short-form designation?
+	3. ASCII should be designated to G0 before control characters?
+	4. ASCII should be designated to G0 at end of line?
+	5. 7-bit environment or 8-bit environment?
+	6. Use locking-shift?
+	7. Use Single-shift?
+   And the following two are only for Japanese:
+	8. Use ASCII in place of JIS0201-1976-Roman?
+	9. Use JISX0208-1983 in place of JISX0208-1978?
+   These specifications are encoded in `coding->flags' as flag bits
+   defined by macros CODING_FLAG_ISO_XXX.  See `coding.h' for more
+   detail.
+*/
+
+/* Produce codes (escape sequence) for designating CHARSET to graphic
+   register REG.  If <final-char> of CHARSET is '@', 'A', or 'B' and
+   the coding system CODING allows, produce designation sequence of
+   short-form.  */
+
+#define ENCODE_DESIGNATION(charset, reg, coding)			\
+  do {									\
+    unsigned char final_char = CHARSET_ISO_FINAL_CHAR (charset);	\
+    char *intermediate_char_94 = "()*+";				\
+    char *intermediate_char_96 = ",-./";				\
+    Lisp_Object temp							\
+      = Fassq (make_number (charset), Vcharset_revision_alist);		\
+    if (! NILP (temp))							\
+	{								\
+	*dst++ = ISO_CODE_ESC;						\
+	*dst++ = '&';							\
+	*dst++ = XINT (XCONS (temp)->cdr) + '@';			\
+      }									\
+    *dst++ = ISO_CODE_ESC;				       		\
+    if (CHARSET_DIMENSION (charset) == 1)				\
+      {									\
+	if (CHARSET_CHARS (charset) == 94)				\
+	  *dst++ = (unsigned char) (intermediate_char_94[reg]);		\
+	else								\
+	  *dst++ = (unsigned char) (intermediate_char_96[reg]);		\
+      }									\
+    else								\
+      {									\
+	*dst++ = '$';							\
+	if (CHARSET_CHARS (charset) == 94)				\
+	  {								\
+	    if (! (coding->flags & CODING_FLAG_ISO_SHORT_FORM)     	\
+		|| reg != 0					       	\
+		|| final_char < '@' || final_char > 'B')	       	\
+	      *dst++ = (unsigned char) (intermediate_char_94[reg]);	\
+	  }								\
+	else								\
+	  *dst++ = (unsigned char) (intermediate_char_96[reg]);  	\
+      }									\
+    *dst++ = final_char;				       		\
+    CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;		\
+  } while (0)
+
+/* The following two macros produce codes (control character or escape
+   sequence) for ISO2022 single-shift functions (single-shift-2 and
+   single-shift-3).  */
+
+#define ENCODE_SINGLE_SHIFT_2				\
+  do {							\
+    if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)	\
+      *dst++ = ISO_CODE_ESC, *dst++ = 'N';		\
+    else						\
+      *dst++ = ISO_CODE_SS2;				\
+    CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;	\
+  } while (0)
+
+#define ENCODE_SINGLE_SHIFT_3			   	\
+  do {						   	\
+    if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)	\
+      *dst++ = ISO_CODE_ESC, *dst++ = 'O';	   	\
+    else					   	\
+      *dst++ = ISO_CODE_SS3;			   	\
+    CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;	\
+  } while (0)
+
+/* The following four macros produce codes (control character or
+   escape sequence) for ISO2022 locking-shift functions (shift-in,
+   shift-out, locking-shift-2, and locking-shift-3).  */
+
+#define ENCODE_SHIFT_IN			  	\
+  do {					  	\
+    *dst++ = ISO_CODE_SI;		  	\
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;	\
+  } while (0)
+
+#define ENCODE_SHIFT_OUT		  	\
+  do {					  	\
+    *dst++ = ISO_CODE_SO;		  	\
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 1;	\
+  } while (0)
+
+#define ENCODE_LOCKING_SHIFT_2			\
+  do {						\
+    *dst++ = ISO_CODE_ESC, *dst++ = 'n';	\
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 2;	\
+  } while (0)
+
+#define ENCODE_LOCKING_SHIFT_3		  	\
+  do {					  	\
+    *dst++ = ISO_CODE_ESC, *dst++ = 'o';  	\
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 3;	\
+  } while (0)
+
+/* Produce codes for a DIMENSION1 character of which character set is
+   CHARSET and position-code is C1.  Designation and invocation
+   sequences are also produced in advance if necessary.  */
+
+
+#define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1)			\
+  do {									\
+    if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))			\
+      {									\
+	if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)			\
+	  *dst++ = c1 & 0x7F;						\
+	else								\
+	  *dst++ = c1 | 0x80;						\
+	CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;			\
+	break;								\
+      }									\
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))	\
+      {									\
+	*dst++ = c1 & 0x7F;						\
+	break;								\
+      }									\
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))	\
+      {									\
+	*dst++ = c1 | 0x80;						\
+	break;								\
+      }									\
+    else								\
+      /* Since CHARSET is not yet invoked to any graphic planes, we	\
+	 must invoke it, or, at first, designate it to some graphic	\
+	 register.  Then repeat the loop to actually produce the	\
+	 character.  */							\
+      dst = encode_invocation_designation (charset, coding, dst);	\
+  } while (1)
+
+/* Produce codes for a DIMENSION2 character of which character set is
+   CHARSET and position-codes are C1 and C2.  Designation and
+   invocation codes are also produced in advance if necessary.  */
+
+#define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2)		\
+  do {									\
+    if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))			\
+      {									\
+	if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)			\
+	  *dst++ = c1 & 0x7F, *dst++ = c2 & 0x7F;			\
+	else								\
+	  *dst++ = c1 | 0x80, *dst++ = c2 | 0x80;			\
+	CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;			\
+	break;								\
+      }									\
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))	\
+      {									\
+	*dst++ = c1 & 0x7F, *dst++= c2 & 0x7F;				\
+	break;								\
+      }									\
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))	\
+      {									\
+	*dst++ = c1 | 0x80, *dst++= c2 | 0x80;				\
+	break;								\
+      }									\
+    else								\
+      /* Since CHARSET is not yet invoked to any graphic planes, we	\
+	 must invoke it, or, at first, designate it to some graphic	\
+	 register.  Then repeat the loop to actually produce the	\
+	 character.  */							\
+      dst = encode_invocation_designation (charset, coding, dst);	\
+  } while (1)
+
+/* Produce designation and invocation codes at a place pointed by DST
+   to use CHARSET.  The element `spec.iso2022' of *CODING is updated.
+   Return new DST.  */
+
+unsigned char *
+encode_invocation_designation (charset, coding, dst)
+     int charset;
+     struct coding_system *coding;
+     unsigned char *dst;
+{
+  int reg;			/* graphic register number */
+
+  /* At first, check designations.  */
+  for (reg = 0; reg < 4; reg++)
+    if (charset == CODING_SPEC_ISO_DESIGNATION (coding, reg))
+      break;
+
+  if (reg >= 4)
+    {
+      /* CHARSET is not yet designated to any graphic registers.  */
+      /* At first check the requested designation.  */
+      reg = CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset);
+      if (reg < 0)
+	/* Since CHARSET requests no special designation, designate to
+	   graphic register 0.  */
+	reg = 0;
+
+      ENCODE_DESIGNATION (charset, reg, coding);
+    }
+
+  if (CODING_SPEC_ISO_INVOCATION (coding, 0) != reg
+      && CODING_SPEC_ISO_INVOCATION (coding, 1) != reg)
+    {
+      /* Since the graphic register REG is not invoked to any graphic
+	 planes, invoke it to graphic plane 0.  */
+      switch (reg)
+	{
+	case 0:			/* graphic register 0 */
+	  ENCODE_SHIFT_IN;
+	  break;
+
+	case 1:			/* graphic register 1 */
+	  ENCODE_SHIFT_OUT;
+	  break;
+
+	case 2:			/* graphic register 2 */
+	  if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
+	    ENCODE_SINGLE_SHIFT_2;
+	  else
+	    ENCODE_LOCKING_SHIFT_2;
+	  break;
+
+	case 3:			/* graphic register 3 */
+	  if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
+	    ENCODE_SINGLE_SHIFT_3;
+	  else
+	    ENCODE_LOCKING_SHIFT_3;
+	  break;
+	}
+    }
+  return dst;
+}
+
+/* The following two macros produce codes for indicating composition.  */
+#define ENCODE_COMPOSITION_NO_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '0'
+#define ENCODE_COMPOSITION_WITH_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '2'
+#define ENCODE_COMPOSITION_END    *dst++ = ISO_CODE_ESC, *dst++ = '1'
+
+/* The following three macros produce codes for indicating direction
+   of text.  */
+#define ENCODE_CONTROL_SEQUENCE_INTRODUCER	    	\
+  do {						    	\
+    if (coding->flags == CODING_FLAG_ISO_SEVEN_BITS)	\
+      *dst++ = ISO_CODE_ESC, *dst++ = '[';	    	\
+    else					    	\
+      *dst++ = ISO_CODE_CSI;			    	\
+  } while (0)
+
+#define ENCODE_DIRECTION_R2L	\
+  ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '2', *dst++ = ']'
+
+#define ENCODE_DIRECTION_L2R	\
+  ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '0', *dst++ = ']'
+
+/* Produce codes for designation and invocation to reset the graphic
+   planes and registers to initial state.  */
+#define ENCODE_RESET_PLANE_AND_REGISTER(eol)				      \
+  do {									      \
+    int reg;								      \
+    if (CODING_SPEC_ISO_INVOCATION (coding, 0) != 0)			      \
+      ENCODE_SHIFT_IN;							      \
+    for (reg = 0; reg < 4; reg++)					      \
+      {									      \
+	if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg) < 0)	      \
+	  {								      \
+	    if (eol) CODING_SPEC_ISO_DESIGNATION (coding, reg) = -1;	      \
+	  }								      \
+	else if (CODING_SPEC_ISO_DESIGNATION (coding, reg)		      \
+		 != CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg))	      \
+	  ENCODE_DESIGNATION						      \
+	    (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg), reg, coding); \
+      }									      \
+  } while (0)
+
+/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".  */
+
+int
+encode_coding_iso2022 (coding, source, destination,
+		       src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 6, we subtract 5
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 5;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+	 The loop will be exited when there's not enough source text
+	 to analyze multi-byte codes (within macros ONE_MORE_BYTE,
+	 TWO_MORE_BYTES, and THREE_MORE_BYTES).  In that case, SRC is
+	 reset to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+      int charset;
+
+      /* If we are seeing a component of a composite character, we are
+	 seeing a leading-code specially encoded for composition, or a
+	 composition rule if composing with rule.  We must set C1
+	 to a normal leading-code or an ASCII code.  If we are not at
+	 a composed character, we must reset the composition state.  */
+      if (COMPOSING_P (coding->composing))
+	{
+	  if (c1 < 0xA0)
+	    {
+	      /* We are not in a composite character any longer.  */
+	      coding->composing = COMPOSING_NO;
+	      ENCODE_COMPOSITION_END;
+	    }
+	  else
+	    {
+	      if (coding->composing == COMPOSING_WITH_RULE_RULE)
+		{
+		  *dst++ = c1 & 0x7F;
+		  coding->composing = COMPOSING_WITH_RULE_HEAD;
+		  continue;
+		}
+	      else if (coding->composing == COMPOSING_WITH_RULE_HEAD)
+		coding->composing = COMPOSING_WITH_RULE_RULE;
+	      if (c1 == 0xA0)
+		{
+		  /* This is an ASCII component.  */
+		  ONE_MORE_BYTE (c1);
+		  c1 &= 0x7F;
+		}
+	      else
+		/* This is a leading-code of non ASCII component.  */
+		c1 -= 0x20;
+	    }
+	}
+	
+      /* Now encode one character.  C1 is a control character, an
+         ASCII character, or a leading-code of multi-byte character.  */
+      switch (emacs_code_class[c1])
+	{
+	case EMACS_ascii_code:
+	  ENCODE_ISO_CHARACTER_DIMENSION1 (CHARSET_ASCII, c1);
+	  break;
+
+	case EMACS_control_code:
+	  if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
+	    ENCODE_RESET_PLANE_AND_REGISTER (0);
+	  *dst++ = c1;
+	  break;
+
+	case EMACS_carriage_return_code:
+	  if (!coding->selective)
+	    {
+	      if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
+		ENCODE_RESET_PLANE_AND_REGISTER (0);
+	      *dst++ = c1;
+	      break;
+	    }
+	  /* fall down to treat '\r' as '\n' ...  */
+
+	case EMACS_linefeed_code:
+	  if (coding->flags & CODING_FLAG_ISO_RESET_AT_EOL)
+	    ENCODE_RESET_PLANE_AND_REGISTER (1);
+	  if (coding->eol_type == CODING_EOL_LF
+	      || coding->eol_type == CODING_EOL_AUTOMATIC)
+	    *dst++ = ISO_CODE_LF;
+	  else if (coding->eol_type == CODING_EOL_CRLF)
+	    *dst++ = ISO_CODE_CR, *dst++ = ISO_CODE_LF;
+	  else
+	    *dst++ = ISO_CODE_CR;
+	  break;
+
+	case EMACS_leading_code_2:
+	  ONE_MORE_BYTE (c2);
+	  ENCODE_ISO_CHARACTER_DIMENSION1 (c1, c2);
+	  break;
+
+	case EMACS_leading_code_3:
+	  TWO_MORE_BYTES (c2, c3);
+	  if (c1 < LEADING_CODE_PRIVATE_11)
+	    ENCODE_ISO_CHARACTER_DIMENSION2 (c1, c2, c3);
+	  else
+	    ENCODE_ISO_CHARACTER_DIMENSION1 (c2, c3);
+	  break;
+
+	case EMACS_leading_code_4:
+	  THREE_MORE_BYTES (c2, c3, c4);
+	  ENCODE_ISO_CHARACTER_DIMENSION2 (c2, c3, c4);
+	  break;
+
+	case EMACS_leading_code_composition:
+	  ONE_MORE_BYTE (c1);
+	  if (c1 == 0xFF)
+	    {
+	      coding->composing = COMPOSING_WITH_RULE_HEAD;
+	      ENCODE_COMPOSITION_WITH_RULE_START;
+	    }
+	  else
+	    {
+	      /* Rewind one byte because it is a character code of
+                 composition elements.  */
+	      src--;
+	      coding->composing = COMPOSING_NO_RULE_HEAD;
+	      ENCODE_COMPOSITION_NO_RULE_START;
+	    }
+	  break;
+
+	case EMACS_invalid_code:
+	  *dst++ = c1;
+	  break;
+	}
+      continue;
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  /* If this is the last block of the text to be encoded, we must
+     reset the state of graphic planes and registers to initial one.
+     In addition, we had better just flush out all remaining codes in
+     the text although they are not valid characters.  */
+  if (coding->last_block)
+    {
+      ENCODE_RESET_PLANE_AND_REGISTER (1);
+      bcopy(src, dst, src_end - src);
+      dst += (src_end - src);
+      src = src_end;
+    }
+  *consumed = src - source;
+  return dst - destination;
+}
+
+
+/*** 4. SJIS and BIG5 handlers ***/
+
+/* Although SJIS and BIG5 are not ISO's coding system, They are used
+   quite widely.  So, for the moment, Emacs supports them in the bare
+   C code.  But, in the future, they may be supported only by CCL.  */
+
+/* SJIS is a coding system encoding three character sets: ASCII, right
+   half of JISX0201-Kana, and JISX0208.  An ASCII character is encoded
+   as is.  A character of charset katakana-jisx0201 is encoded by
+   "position-code + 0x80".  A character of charset japanese-jisx0208
+   is encoded in 2-byte but two position-codes are divided and shifted
+   so that it fit in the range below.
+
+   --- CODE RANGE of SJIS ---
+   (character set)	(range)
+   ASCII		0x00 .. 0x7F
+   KATAKANA-JISX0201	0xA0 .. 0xDF
+   JISX0208 (1st byte)	0x80 .. 0x9F and 0xE0 .. 0xFF
+	    (2nd byte)	0x40 .. 0xFF
+   -------------------------------
+
+*/
+
+/* BIG5 is a coding system encoding two character sets: ASCII and
+   Big5.  An ASCII character is encoded as is.  Big5 is a two-byte
+   character set and is encoded in two-byte.
+
+   --- CODE RANGE of BIG5 ---
+   (character set)	(range)
+   ASCII		0x00 .. 0x7F
+   Big5 (1st byte)	0xA1 .. 0xFE
+	(2nd byte)	0x40 .. 0x7E and 0xA1 .. 0xFE
+   --------------------------
+
+   Since the number of characters in Big5 is larger than maximum
+   characters in Emacs' charset (96x96), it can't be handled as one
+   charset.  So, in Emacs, Big5 is divided into two: `charset-big5-1'
+   and `charset-big5-2'.  Both are DIMENSION2 and CHARS94.  The former
+   contains frequently used characters and the latter contains less
+   frequently used characters.  */
+
+/* Macros to decode or encode a character of Big5 in BIG5.  B1 and B2
+   are the 1st and 2nd position-codes of Big5 in BIG5 coding system.
+   C1 and C2 are the 1st and 2nd position-codes of of Emacs' internal
+   format.  CHARSET is `charset_big5_1' or `charset_big5_2'.  */
+
+/* Number of Big5 characters which have the same code in 1st byte.  */
+#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
+
+#define DECODE_BIG5(b1, b2, charset, c1, c2)			     	\
+  do {								     	\
+    unsigned int temp						     	\
+      = (b1 - 0xA1) * BIG5_SAME_ROW + b2 - (b2 < 0x7F ? 0x40 : 0x62);	\
+    if (b1 < 0xC9)						     	\
+      charset = charset_big5_1;					     	\
+    else							     	\
+      {								     	\
+	charset = charset_big5_2;				     	\
+	temp -= (0xC9 - 0xA1) * BIG5_SAME_ROW;			     	\
+      }								     	\
+    c1 = temp / (0xFF - 0xA1) + 0x21;				     	\
+    c2 = temp % (0xFF - 0xA1) + 0x21;				     	\
+  } while (0)
+
+#define ENCODE_BIG5(charset, c1, c2, b1, b2)			  	\
+  do {								  	\
+    unsigned int temp = (c1 - 0x21) * (0xFF - 0xA1) + (c2 - 0x21);	\
+    if (charset == charset_big5_2)				  	\
+      temp += BIG5_SAME_ROW * (0xC9 - 0xA1);			  	\
+    b1 = temp / BIG5_SAME_ROW + 0xA1;				  	\
+    b2 = temp % BIG5_SAME_ROW;					  	\
+    b2 += b2 < 0x3F ? 0x40 : 0x62;				  	\
+  } while (0)
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in SJIS.  If it is, return
+   CODING_CATEGORY_MASK_SJIS, else return 0.  */
+
+int
+detect_coding_sjis (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+	return 0;
+      if ((c >= 0x80 && c < 0xA0) || c >= 0xE0)
+	{
+	  if (src < src_end && *src++ < 0x40)
+	    return 0;
+	}
+    }
+  return CODING_CATEGORY_MASK_SJIS;
+}
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in BIG5.  If it is, return
+   CODING_CATEGORY_MASK_BIG5, else return 0.  */
+
+int
+detect_coding_big5 (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+	return 0;
+      if (c >= 0xA1)
+	{
+	  if (src >= src_end)
+	    break;
+	  c = *src++;
+	  if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
+	    return 0;
+	}
+    }
+  return CODING_CATEGORY_MASK_BIG5;
+}
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
+   If SJIS_P is 1, decode SJIS text, else decode BIG5 test.  */
+
+int
+decode_coding_sjis_big5 (coding, source, destination,
+			 src_bytes, dst_bytes, consumed, sjis_p)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+     int sjis_p;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 4, we subtract 3
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 3;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+	 The loop will be exited when there's not enough source text
+	 to analyze two-byte character (within macro ONE_MORE_BYTE).
+	 In that case, SRC is reset to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+
+      if (c1 == '\r')
+	{
+	  if (coding->eol_type == CODING_EOL_CRLF)
+	    {
+	      ONE_MORE_BYTE (c2);
+	      if (c2 == '\n')
+		*dst++ = c2;
+	      else
+		/* To process C2 again, SRC is subtracted by 1.  */
+		*dst++ = c1, src--;
+	    }
+	  else
+	    *dst++ = c1;
+	}
+      else if (c1 < 0x80)
+	*dst++ = c1;
+      else if (c1 < 0xA0 || c1 >= 0xE0)
+	{
+	  /* SJIS -> JISX0208, BIG5 -> Big5 (only if 0xE0 <= c1 < 0xFF) */
+	  if (sjis_p)
+	    {
+	      ONE_MORE_BYTE (c2);
+	      DECODE_SJIS (c1, c2, c3, c4);
+	      DECODE_CHARACTER_DIMENSION2 (charset_jisx0208, c3, c4);
+	    }
+	  else if (c1 >= 0xE0 && c1 < 0xFF)
+	    {
+	      int charset;
+
+	      ONE_MORE_BYTE (c2);
+	      DECODE_BIG5 (c1, c2, charset, c3, c4);
+	      DECODE_CHARACTER_DIMENSION2 (charset, c3, c4);
+	    }
+	  else			/* Invalid code */
+	    *dst++ = c1;
+	}
+      else
+	{
+	  /* SJIS -> JISX0201-Kana, BIG5 -> Big5 */
+	  if (sjis_p)
+	    DECODE_CHARACTER_DIMENSION1 (charset_katakana_jisx0201, c1);
+	  else
+	    {
+	      int charset;
+
+	      ONE_MORE_BYTE (c2);
+	      DECODE_BIG5 (c1, c2, charset, c3, c4);
+	      DECODE_CHARACTER_DIMENSION2 (charset, c3, c4);
+	    }
+	}
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  *consumed = src - source;
+  return dst - destination;
+}
+
+/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
+   This function can encode `charset_ascii', `charset_katakana_jisx0201',
+   `charset_jisx0208', `charset_big5_1', and `charset_big5-2'.  We are
+   sure that all these charsets are registered as official charset
+   (i.e. do not have extended leading-codes).  Characters of other
+   charsets are produced without any encoding.  If SJIS_P is 1, encode
+   SJIS text, else encode BIG5 text.  */
+
+int
+encode_coding_sjis_big5 (coding, source, destination,
+			 src_bytes, dst_bytes, consumed, sjis_p)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+     int sjis_p;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 2, we subtract 1
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 1;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+	 The loop will be exited when there's not enough source text
+	 to analyze multi-byte codes (within macros ONE_MORE_BYTE and
+	 TWO_MORE_BYTES).  In that case, SRC is reset to SRC_BASE
+	 before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+
+      if (coding->composing)
+	{
+	  if (c1 == 0xA0)
+	    {
+	      ONE_MORE_BYTE (c1);
+	      c1 &= 0x7F;
+	    }
+	  else if (c1 >= 0xA0)
+	    c1 -= 0x20;
+	  else
+	    coding->composing = 0;
+	}
+
+      switch (emacs_code_class[c1])
+	{
+	case EMACS_ascii_code:
+	case EMACS_control_code:
+	  *dst++ = c1;
+	  break;
+
+	case EMACS_carriage_return_code:
+	  if (!coding->selective)
+	    {
+	      *dst++ = c1;
+	      break;
+	    }
+	  /* fall down to treat '\r' as '\n' ...  */
+
+	case EMACS_linefeed_code:
+	  if (coding->eol_type == CODING_EOL_LF
+	      || coding->eol_type == CODING_EOL_AUTOMATIC)
+	    *dst++ = '\n';
+	  else if (coding->eol_type == CODING_EOL_CRLF)
+	    *dst++ = '\r', *dst++ = '\n';
+	  else
+	    *dst++ = '\r';
+	  break;
+
+	case EMACS_leading_code_2:
+	  ONE_MORE_BYTE (c2);
+	  if (sjis_p && c1 == charset_katakana_jisx0201)
+	    *dst++ = c2;
+	  else
+	    *dst++ = c1, *dst++ = c2;
+	  break;
+
+	case EMACS_leading_code_3:
+	  TWO_MORE_BYTES (c2, c3);
+	  c2 &= 0x7F, c3 &= 0x7F;
+	  if (sjis_p && c1 == charset_jisx0208)
+	    {
+	      unsigned char s1, s2;
+
+	      ENCODE_SJIS (c2, c3, s1, s2);
+	      *dst++ = s1, *dst++ = s2;
+	    }
+	  else if (!sjis_p && (c1 == charset_big5_1 || c1 == charset_big5_2))
+	    {
+	      unsigned char b1, b2;
+
+	      ENCODE_BIG5 (c1, c2, c3, b1, b2);
+	      *dst++ = b1, *dst++ = b2;
+	    }
+	  else
+	    *dst++ = c1, *dst++ = c2, *dst++ = c3;
+	  break;
+
+	case EMACS_leading_code_4:
+	  THREE_MORE_BYTES (c2, c3, c4);
+	  *dst++ = c1, *dst++ = c2, *dst++ = c3, *dst++ = c4;
+	  break;
+
+	case EMACS_leading_code_composition:
+	  coding->composing = 1;
+	  break;
+
+	default:		/* i.e. case EMACS_invalid_code: */
+	  *dst++ = c1;
+	}
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  *consumed = src - source;
+  return dst - destination;
+}
+
+
+/*** 5. End-of-line handlers ***/
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
+   This function is called only when `coding->eol_type' is
+   CODING_EOL_CRLF or CODING_EOL_CR.  */
+
+decode_eol (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  int produced;
+
+  switch (coding->eol_type)
+    {
+    case CODING_EOL_CRLF:
+      {
+	/* Since the maximum bytes produced by each loop is 2, we
+	   subtract 1 from DST_END to assure overflow checking is
+	   necessary only at the head of loop.  */
+	unsigned char *adjusted_dst_end = dst_end - 1;
+
+	while (src < src_end && dst < adjusted_dst_end)
+	  {
+	    unsigned char *src_base = src;
+	    unsigned char c = *src++;
+	    if (c == '\r')
+	      {
+		ONE_MORE_BYTE (c);
+		if (c != '\n')
+		  *dst++ = '\r';
+
+	      }
+	    else
+	      *dst++ = c;
+	    continue;
+
+	  label_end_of_loop:
+	    coding->carryover_size = src - src_base;
+	    bcopy (src_base, coding->carryover, coding->carryover_size);
+	    src = src_base;
+	    break;
+	  }
+	*consumed = src - source;
+	produced = dst - destination;
+	break;
+      }
+
+    case CODING_EOL_CR:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      dst_end = destination + produced;
+      while (dst < dst_end)
+	if (*dst++ == '\r') dst[-1] = '\n';
+      *consumed = produced;
+      break;
+
+    default:			/* i.e. case: CODING_EOL_LF */
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      *consumed = produced;
+      break;
+    }
+
+  return produced;
+}
+
+/* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  Encode
+   format of end-of-line according to `coding->eol_type'.  If
+   `coding->selective' is 1, code '\r' in source text also means
+   end-of-line.  */
+
+encode_eol (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *dst = destination;
+  int produced;
+
+  if (src_bytes <= 0)
+    return 0;
+
+  switch (coding->eol_type)
+    {
+    case CODING_EOL_LF:
+    case CODING_EOL_AUTOMATIC:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      if (coding->selective)
+	{
+	  int i = produced;
+	  while (i--)
+	    if (*dst++ == '\r') dst[-1] = '\n';
+	}
+      *consumed = produced;
+      
+    case CODING_EOL_CRLF:
+      {
+	unsigned char c;
+	unsigned char *src_end = source + src_bytes;
+	unsigned char *dst_end = destination + dst_bytes;
+	/* Since the maximum bytes produced by each loop is 2, we
+	   subtract 1 from DST_END to assure overflow checking is
+	   necessary only at the head of loop.  */
+	unsigned char *adjusted_dst_end = dst_end - 1;
+
+	while (src < src_end && dst < adjusted_dst_end)
+	  {
+	    c = *src++;
+	    if (c == '\n' || (c == '\r' && coding->selective))
+	      *dst++ = '\r', *dst++ = '\n';
+	    else
+	      *dst++ = c;
+	  }
+	produced = dst - destination;
+	*consumed = src - source;
+	break;
+      }
+
+    default:			/* i.e. case CODING_EOL_CR: */
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      {
+	int i = produced;
+	while (i--)
+	  if (*dst++ == '\n') dst[-1] = '\r';
+      }
+      *consumed = produced;
+    }
+
+  return produced;
+}
+
+
+/*** 6. C library functions ***/
+
+/* In Emacs Lisp, coding system is represented by a Lisp symbol which
+   has a property `coding-system'.  The value of this property is a
+   vector of length 5 (called as coding-vector).  Among elements of
+   this vector, the first (element[0]) and the fifth (element[4])
+   carry important information for decoding/encoding.  Before
+   decoding/encoding, this information should be set in fields of a
+   structure of type `coding_system'.
+
+   A value of property `coding-system' can be a symbol of another
+   subsidiary coding-system.  In that case, Emacs gets coding-vector
+   from that symbol.
+
+   `element[0]' contains information to be set in `coding->type'.  The
+   value and its meaning is as follows:
+
+   0 -- coding_system_internal
+   1 -- coding_system_sjis
+   2 -- coding_system_iso2022
+   3 -- coding_system_big5
+   4 -- coding_system_ccl
+   nil -- coding_system_no_conversion
+   t -- coding_system_automatic
+
+   `element[4]' contains information to be set in `coding->flags' and
+   `coding->spec'.  The meaning varies by `coding->type'.
+
+   If `coding->type' is `coding_type_iso2022', element[4] is a vector
+   of length 32 (of which the first 13 sub-elements are used now).
+   Meanings of these sub-elements are:
+
+   sub-element[N] where N is 0 through 3: to be set in `coding->spec.iso2022'
+   	If the value is an integer of valid charset, the charset is
+	assumed to be designated to graphic register N initially.
+
+	If the value is minus, it is a minus value of charset which
+	reserves graphic register N, which means that the charset is
+	not designated initially but should be designated to graphic
+	register N just before encoding a character in that charset.
+
+	If the value is nil, graphic register N is never used on
+	encoding.
+   
+   sub-element[N] where N is 4 through 11: to be set in `coding->flags'
+   	Each value takes t or nil.  See the section ISO2022 of
+	`coding.h' for more information.
+
+   If `coding->type' is `coding_type_big5', element[4] is t to denote
+   BIG5-ETen or nil to denote BIG5-HKU.
+
+   If `coding->type' takes the other value, element[4] is ignored.
+
+   Emacs Lisp's coding system also carries information about format of
+   end-of-line in a value of property `eol-type'.  If the value is
+   integer, 0 means CODING_EOL_LF, 1 means CODING_EOL_CRLF, and 2
+   means CODING_EOL_CR.  If it is not integer, it should be a vector
+   of subsidiary coding systems of which property `eol-type' has one
+   of above values.
+
+*/
+
+/* Extract information for decoding/encoding from CODING_SYSTEM_SYMBOL
+   and set it in CODING.  If CODING_SYSTEM_SYMBOL is invalid, CODING
+   is setup so that no conversion is necessary and return -1, else
+   return 0.  */
+
+int
+setup_coding_system (coding_system_symbol, coding)
+     Lisp_Object coding_system_symbol;
+     struct coding_system *coding;
+{
+  Lisp_Object coding_system_vector = Qnil;
+  Lisp_Object type, eol_type;
+
+  /* At first, set several fields default values.  */
+  coding->require_flushing = 0;
+  coding->last_block = 0;
+  coding->selective = 0;
+  coding->composing = 0;
+  coding->direction = 0;
+  coding->carryover_size = 0;
+  coding->symbol = Qnil;
+  coding->post_read_conversion = coding->pre_write_conversion = Qnil;
+
+  /* Get value of property `coding-system'.  If it is a Lisp symbol
+     pointing another coding system, fetch its property until we get a
+     vector.  */
+  while (!NILP (coding_system_symbol))
+    {
+      coding->symbol = coding_system_symbol;
+      if (NILP (coding->post_read_conversion))
+	coding->post_read_conversion = Fget (coding_system_symbol,
+					     Qpost_read_conversion);
+      if (NILP (coding->pre_write_conversion))
+	coding->pre_write_conversion = Fget (coding_system_symbol,
+					     Qpre_write_conversion);
+
+      coding_system_vector = Fget (coding_system_symbol, Qcoding_system);
+      if (VECTORP (coding_system_vector))
+	break;
+      coding_system_symbol = coding_system_vector;
+    }
+  Vlast_coding_system_used = coding->symbol;
+
+  if (!VECTORP (coding_system_vector)
+      || XVECTOR (coding_system_vector)->size != 5)
+    goto label_invalid_coding_system;
+
+  /* Get value of property `eol-type' by searching from the root
+     coding-system.  */
+  coding_system_symbol = coding->symbol;
+  eol_type = Qnil;
+  while (SYMBOLP (coding_system_symbol) && !NILP (coding_system_symbol))
+    {
+      eol_type = Fget (coding_system_symbol, Qeol_type);
+      if (!NILP (eol_type))
+	break;
+      coding_system_symbol = Fget (coding_system_symbol, Qcoding_system);
+    }
+
+  if (VECTORP (eol_type))
+    coding->eol_type = CODING_EOL_AUTOMATIC;
+  else if (XFASTINT (eol_type) == 1)
+    coding->eol_type = CODING_EOL_CRLF;
+  else if (XFASTINT (eol_type) == 2)
+    coding->eol_type = CODING_EOL_CR;
+  else
+    coding->eol_type = CODING_EOL_LF;
+
+  type = XVECTOR (coding_system_vector)->contents[0];
+  switch (XFASTINT (type))
+    {
+    case 0:
+      coding->type = coding_type_internal;
+      break;
+
+    case 1:
+      coding->type = coding_type_sjis;
+      break;
+
+    case 2:
+      coding->type = coding_type_iso2022;
+      {
+	Lisp_Object val = XVECTOR (coding_system_vector)->contents[4];
+	Lisp_Object *flags;
+	int i, charset, default_reg_bits = 0;
+
+	if (!VECTORP (val) || XVECTOR (val)->size != 32)
+	  goto label_invalid_coding_system;
+
+	flags = XVECTOR (val)->contents;
+	coding->flags
+	  = ((NILP (flags[4]) ? 0 : CODING_FLAG_ISO_SHORT_FORM)
+	     | (NILP (flags[5]) ? 0 : CODING_FLAG_ISO_RESET_AT_EOL)
+	     | (NILP (flags[6]) ? 0 : CODING_FLAG_ISO_RESET_AT_CNTL)
+	     | (NILP (flags[7]) ? 0 : CODING_FLAG_ISO_SEVEN_BITS)
+	     | (NILP (flags[8]) ? 0 : CODING_FLAG_ISO_LOCKING_SHIFT)
+	     | (NILP (flags[9]) ? 0 : CODING_FLAG_ISO_SINGLE_SHIFT)
+	     | (NILP (flags[10]) ? 0 : CODING_FLAG_ISO_USE_ROMAN)
+	     | (NILP (flags[11]) ? 0 : CODING_FLAG_ISO_USE_OLDJIS)
+	     | (NILP (flags[12]) ? 0 : CODING_FLAG_ISO_NO_DIRECTION));
+
+	/* Invoke graphic register 0 to plane 0.  */
+	CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
+	/* Invoke graphic register 1 to plane 1 if we can use full 8-bit.  */
+	CODING_SPEC_ISO_INVOCATION (coding, 1)
+	  = (coding->flags & CODING_FLAG_ISO_SEVEN_BITS ? -1 : 1);
+	/* Not single shifting at first.  */
+	CODING_SPEC_ISO_SINGLE_SHIFTING(coding) = 0;
+
+	/* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
+	   FLAGS[REG] can be one of below:
+		integer CHARSET: CHARSET occupies register I,
+		t: designate nothing to REG initially, but can be used
+		  by any charsets,
+		list of integer, nil, or t: designate the first
+		  element (if integer) to REG initially, the remaining
+		  elements (if integer) is designated to REG on request,
+		  if an element is t, REG can be used by any charset,
+		nil: REG is never used.  */
+	for (charset = 0; charset < MAX_CHARSET; charset++)
+	  CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) = -1;
+	for (i = 0; i < 4; i++)
+	  {
+	    if (INTEGERP (flags[i])
+		&& (charset = XINT (flags[i]), CHARSET_VALID_P (charset)))
+	      {
+		CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
+		CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) = i;
+	      }
+	    else if (EQ (flags[i], Qt))
+	      {
+		CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+		default_reg_bits |= 1 << i;
+	      }
+	    else if (CONSP (flags[i]))
+	      {
+		Lisp_Object tail = flags[i];
+
+		if (INTEGERP (XCONS (tail)->car)
+		    && (charset = XINT (XCONS (tail)->car),
+			CHARSET_VALID_P (charset)))
+		  {
+		    CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
+		    CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) =i;
+		  }
+		else
+		  CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+		tail = XCONS (tail)->cdr;
+		while (CONSP (tail))
+		  {
+		    if (INTEGERP (XCONS (tail)->car)
+			&& (charset = XINT (XCONS (tail)->car),
+			    CHARSET_VALID_P (charset)))
+		      CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+			= i;
+		    else if (EQ (XCONS (tail)->car, Qt))
+		      default_reg_bits |= 1 << i;
+		    tail = XCONS (tail)->cdr;
+		  }
+	      }
+	    else
+	      CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+	    
+	    CODING_SPEC_ISO_DESIGNATION (coding, i)
+	      = CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i);
+	  }
+
+	if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT))
+	  {
+	    /* REG 1 can be used only by locking shift in 7-bit env.  */
+	    if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
+	      default_reg_bits &= ~2;
+	    if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT))
+	      /* Without any shifting, only REG 0 and 1 can be used.  */
+	      default_reg_bits &= 3;
+	  }
+
+	for (charset = 0; charset < MAX_CHARSET; charset++)
+	  if (CHARSET_VALID_P (charset)
+	      && CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) < 0)
+	    {
+	      /* We have not yet decided where to designate CHARSET.  */
+	      int reg_bits = default_reg_bits;
+
+	      if (CHARSET_CHARS (charset) == 96)
+		/* A charset of CHARS96 can't be designated to REG 0.  */
+		reg_bits &= ~1;
+
+	      if (reg_bits)
+		/* There exist some default graphic register.  */
+		CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+		  = (reg_bits & 1
+		     ? 0 : (reg_bits & 2 ? 1 : (reg_bits & 4 ? 2 : 3)));
+	      else
+		/* We anyway have to designate CHARSET to somewhere.  */
+		CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+		  = (CHARSET_CHARS (charset) == 94
+		     ? 0
+		     : ((coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT
+			 || ! coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
+			? 1
+			: (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT
+			   ? 2 : 0)));
+	    }
+      }
+      coding->require_flushing = 1;
+      break;
+
+    case 3:
+      coding->type = coding_type_big5;
+      coding->flags
+	= (NILP (XVECTOR (coding_system_vector)->contents[4])
+	   ? CODING_FLAG_BIG5_HKU
+	   : CODING_FLAG_BIG5_ETEN);
+      break;
+
+    case 4:
+      coding->type = coding_type_ccl;
+      {
+	Lisp_Object val = XVECTOR (coding_system_vector)->contents[4];
+	if (CONSP  (val)
+	    && VECTORP (XCONS (val)->car)
+	    && VECTORP (XCONS (val)->cdr))
+	  {
+	    setup_ccl_program (&(coding->spec.ccl.decoder), XCONS (val)->car);
+	    setup_ccl_program (&(coding->spec.ccl.encoder), XCONS (val)->cdr);
+	  }
+	else
+	  goto label_invalid_coding_system;
+      }
+      coding->require_flushing = 1;
+      break;
+
+    default:
+      if (EQ (type, Qt))
+	coding->type = coding_type_automatic;
+      else
+	coding->type = coding_type_no_conversion;
+      break;
+    }
+  return 0;
+
+ label_invalid_coding_system:
+  coding->type = coding_type_no_conversion;
+  return -1;
+}
+
+/* Emacs has a mechanism to automatically detect a coding system if it
+   is one of Emacs' internal format, ISO2022, SJIS, and BIG5.  But,
+   it's impossible to distinguish some coding systems accurately
+   because they use the same range of codes.  So, at first, coding
+   systems are categorized into 7, those are:
+
+   o coding-category-internal
+
+   	The category for a coding system which has the same code range
+	as Emacs' internal format.  Assigned the coding-system (Lisp
+	symbol) `coding-system-internal' by default.
+
+   o coding-category-sjis
+
+	The category for a coding system which has the same code range
+	as SJIS.  Assigned the coding-system (Lisp
+	symbol) `coding-system-sjis' by default.
+
+   o coding-category-iso-7
+
+   	The category for a coding system which has the same code range
+	as ISO2022 of 7-bit environment.  Assigned the coding-system
+	(Lisp symbol) `coding-system-junet' by default.
+
+   o coding-category-iso-8-1
+
+   	The category for a coding system which has the same code range
+	as ISO2022 of 8-bit environment and graphic plane 1 used only
+	for DIMENSION1 charset.  Assigned the coding-system (Lisp
+	symbol) `coding-system-ctext' by default.
+
+   o coding-category-iso-8-2
+
+   	The category for a coding system which has the same code range
+	as ISO2022 of 8-bit environment and graphic plane 1 used only
+	for DIMENSION2 charset.  Assigned the coding-system (Lisp
+	symbol) `coding-system-euc-japan' by default.
+
+   o coding-category-iso-else
+
+   	The category for a coding system which has the same code range
+	as ISO2022 but not belongs to any of the above three
+	categories.  Assigned the coding-system (Lisp symbol)
+	`coding-system-iso-2022-ss2-7' by default.
+
+   o coding-category-big5
+
+   	The category for a coding system which has the same code range
+	as BIG5.  Assigned the coding-system (Lisp symbol)
+	`coding-system-big5' by default.
+
+   o coding-category-binary
+
+   	The category for a coding system not categorized in any of the
+	above.  Assigned the coding-system (Lisp symbol)
+	`coding-system-noconv' by default.
+
+   Each of them is a Lisp symbol and the value is an actual
+   `coding-system's (this is also a Lisp symbol) assigned by a user.
+   What Emacs does actually is to detect a category of coding system.
+   Then, it uses a `coding-system' assigned to it.  If Emacs can't
+   decide only one possible category, it selects a category of the
+   highest priority.  Priorities of categories are also specified by a
+   user in a Lisp variable `coding-category-list'.
+
+*/
+
+/* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
+   If it detects possible coding systems, return an integer in which
+   appropriate flag bits are set.  Flag bits are defined by macros
+   CODING_CATEGORY_MASK_XXX in `coding.h'.  */
+
+int
+detect_coding_mask (src, src_bytes)
+     unsigned char *src;
+     int src_bytes;
+{
+  register unsigned char c;
+  unsigned char *src_end = src + src_bytes;
+  int mask;
+
+  /* At first, skip all ASCII characters and control characters except
+     for three ISO2022 specific control characters.  */
+  while (src < src_end)
+    {
+      c = *src;
+      if (c >= 0x80
+	  || (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO))
+	break;
+      src++;
+    }
+
+  if (src >= src_end)
+    /* We found nothing other than ASCII.  There's nothing to do.  */
+    return CODING_CATEGORY_MASK_ANY;
+
+  /* The text seems to be encoded in some multilingual coding system.
+     Now, try to find in which coding system the text is encoded.  */
+  if (c < 0x80)
+    /* i.e. (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) */
+    /* C is an ISO2022 specific control code of C0.  */
+    mask = detect_coding_iso2022 (src, src_end);
+
+  else if (c == ISO_CODE_SS2 || c == ISO_CODE_SS3 || c == ISO_CODE_CSI)
+    /* C is an ISO2022 specific control code of C1,
+       or the first byte of SJIS's 2-byte character code,
+       or a leading code of Emacs.  */
+    mask = (detect_coding_iso2022 (src, src_end)
+	    | detect_coding_sjis (src, src_end)
+	    | detect_coding_internal (src, src_end));
+
+  else if (c < 0xA0)
+    /* C is the first byte of SJIS character code,
+       or a leading-code of Emacs.  */
+    mask = (detect_coding_sjis (src, src_end)
+	    | detect_coding_internal (src, src_end));
+
+  else
+    /* C is a character of ISO2022 in graphic plane right,
+       or a SJIS's 1-byte character code (i.e. JISX0201),
+       or the first byte of BIG5's 2-byte code.  */
+    mask = (detect_coding_iso2022 (src, src_end)
+	    | detect_coding_sjis (src, src_end)
+	    | detect_coding_big5 (src, src_end));
+
+  return mask;
+}
+
+/* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
+   The information of the detected coding system is set in CODING.  */
+
+void
+detect_coding (coding, src, src_bytes)
+     struct coding_system *coding;
+     unsigned char *src;
+     int src_bytes;
+{
+  int mask = detect_coding_mask (src, src_bytes);
+  int idx;
+
+  if (mask == CODING_CATEGORY_MASK_ANY)
+    /* We found nothing other than ASCII.  There's nothing to do.  */
+    return;
+
+  if (!mask)
+    /* The source text seems to be encoded in unknown coding system.
+       Emacs regards the category of such a kind of coding system as
+       `coding-category-binary'.  We assume that a user has assigned
+       an appropriate coding system for a `coding-category-binary'.  */
+    idx = CODING_CATEGORY_IDX_BINARY;
+  else
+    {
+      /* We found some plausible coding systems.  Let's use a coding
+	 system of the highest priority.  */
+      Lisp_Object val = Vcoding_category_list;
+
+      if (CONSP (val))
+	while (!NILP (val))
+	  {
+	    idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
+	    if ((idx < CODING_CATEGORY_IDX_MAX) && (mask & (1 << idx)))
+	      break;
+	    val = XCONS (val)->cdr;
+	  }
+      else
+	val = Qnil;
+
+      if (NILP (val))
+	{
+	  /* For unknown reason, `Vcoding_category_list' contains none
+	     of found categories.  Let's use any of them.  */
+	  for (idx = 0; idx < CODING_CATEGORY_IDX_MAX; idx++)
+	    if (mask & (1 << idx))
+	      break;
+	}
+    }
+  setup_coding_system (XSYMBOL (coding_category_table[idx])->value, coding);
+}
+
+/* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
+   is encoded.  Return one of CODING_EOL_LF, CODING_EOL_CRLF,
+   CODING_EOL_CR, and CODING_EOL_AUTOMATIC.  */
+
+int
+detect_eol_type (src, src_bytes)
+     unsigned char *src;
+     int src_bytes;
+{
+  unsigned char *src_end = src + src_bytes;
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == '\n')
+	return CODING_EOL_LF;
+      else if (c == '\r')
+	{
+	  if (src < src_end && *src == '\n')
+	    return CODING_EOL_CRLF;
+	  else
+	    return CODING_EOL_CR;
+	}
+    }
+  return CODING_EOL_AUTOMATIC;
+}
+
+/* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
+   is encoded.  If it detects an appropriate format of end-of-line, it
+   sets the information in *CODING.  */
+
+void
+detect_eol (coding, src, src_bytes)
+     struct coding_system *coding;
+     unsigned char *src;
+     int src_bytes;
+{
+  Lisp_Object val;
+  int eol_type = detect_eol_type (src, src_bytes);
+
+  if (eol_type == CODING_EOL_AUTOMATIC)
+    /*  We found no end-of-line in the source text.  */
+    return;
+
+  val = Fget (coding->symbol, Qeol_type);
+  if (VECTORP (val) && XVECTOR (val)->size == 3)
+    setup_coding_system (XVECTOR (val)->contents[eol_type], coding);
+}
+
+/* See "GENERAL NOTES about `decode_coding_XXX ()' functions".  Before
+   decoding, it may detect coding system and format of end-of-line if
+   those are not yet decided.  */
+
+int
+decode_coding (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  int produced;
+
+  if (src_bytes <= 0)
+    {
+      *consumed = 0;
+      return 0;
+    }
+
+  if (coding->type == coding_type_automatic)
+    detect_coding (coding, source, src_bytes);
+
+  if (coding->eol_type == CODING_EOL_AUTOMATIC)
+    detect_eol (coding, source, src_bytes);
+
+  coding->carryover_size = 0;
+  switch (coding->type)
+    {
+    case coding_type_no_conversion:
+    label_no_conversion:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      *consumed = produced;
+      break;
+
+    case coding_type_internal:
+    case coding_type_automatic:
+      if (coding->eol_type == CODING_EOL_LF
+	  ||  coding->eol_type == CODING_EOL_AUTOMATIC)
+	goto label_no_conversion;
+      produced = decode_eol (coding, source, destination,
+			     src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_sjis:
+      produced = decode_coding_sjis_big5 (coding, source, destination,
+					  src_bytes, dst_bytes, consumed,
+					  1);
+      break;
+
+    case coding_type_iso2022:
+      produced = decode_coding_iso2022 (coding, source, destination,
+					src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_big5:
+      produced = decode_coding_sjis_big5 (coding, source, destination,
+					  src_bytes, dst_bytes, consumed,
+					  0);
+      break;
+
+    case coding_type_ccl:
+      produced = ccl_driver (&coding->spec.ccl.decoder, source, destination,
+			     src_bytes, dst_bytes, consumed);
+      break;
+    }
+
+  return produced;
+}
+
+/* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  */
+
+int
+encode_coding (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  int produced;
+
+  coding->carryover_size = 0;
+  switch (coding->type)
+    {
+    case coding_type_no_conversion:
+    label_no_conversion:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      if (produced > 0)
+	{
+	  bcopy (source, destination, produced);
+	  if (coding->selective)
+	    {
+	      unsigned char *p = destination, *pend = destination + produced;
+	      while (p < pend)
+		if (*p++ = '\015') p[-1] = '\n';
+	    }
+	}
+      *consumed = produced;
+      break;
+
+    case coding_type_internal:
+    case coding_type_automatic:
+      if (coding->eol_type == CODING_EOL_LF
+	  ||  coding->eol_type == CODING_EOL_AUTOMATIC)
+	goto label_no_conversion;
+      produced = encode_eol (coding, source, destination,
+			     src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_sjis:
+      produced = encode_coding_sjis_big5 (coding, source, destination,
+					  src_bytes, dst_bytes, consumed,
+					  1);
+      break;
+
+    case coding_type_iso2022:
+      produced = encode_coding_iso2022 (coding, source, destination,
+					src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_big5:
+      produced = encode_coding_sjis_big5 (coding, source, destination,
+					  src_bytes, dst_bytes, consumed,
+					  0);
+      break;
+
+    case coding_type_ccl:
+      produced = ccl_driver (&coding->spec.ccl.encoder, source, destination,
+			     src_bytes, dst_bytes, consumed);
+      break;
+    }
+
+  return produced;
+}
+
+#define CONVERSION_BUFFER_EXTRA_ROOM 256
+
+/* Return maximum size (bytes) of a buffer enough for decoding
+   SRC_BYTES of text encoded in CODING.  */
+
+int
+decoding_buffer_size (coding, src_bytes)
+     struct coding_system *coding;
+     int src_bytes;
+{
+  int magnification;
+
+  if (coding->type == coding_type_iso2022)
+    magnification = 3;
+  else if (coding->type == coding_type_ccl)
+    magnification = coding->spec.ccl.decoder.buf_magnification;
+  else
+    magnification = 2;
+
+  return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
+}
+
+/* Return maximum size (bytes) of a buffer enough for encoding
+   SRC_BYTES of text to CODING.  */
+
+int
+encoding_buffer_size (coding, src_bytes)
+     struct coding_system *coding;
+     int src_bytes;
+{
+  int magnification;
+
+  if (coding->type == coding_type_ccl)
+    magnification = coding->spec.ccl.encoder.buf_magnification;
+  else
+    magnification = 3;
+
+  return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
+}
+
+#ifndef MINIMUM_CONVERSION_BUFFER_SIZE
+#define MINIMUM_CONVERSION_BUFFER_SIZE 1024
+#endif
+
+char *conversion_buffer;
+int conversion_buffer_size;
+
+/* Return a pointer to a SIZE bytes of buffer to be used for encoding
+   or decoding.  Sufficient memory is allocated automatically.  If we
+   run out of memory, return NULL.  */
+
+char *
+get_conversion_buffer (size)
+     int size;
+{
+  if (size > conversion_buffer_size)
+    {
+      char *buf;
+      int real_size = conversion_buffer_size * 2;
+
+      while (real_size < size) real_size *= 2;
+      buf = (char *) xmalloc (real_size);
+      xfree (conversion_buffer);
+      conversion_buffer = buf;
+      conversion_buffer_size = real_size;
+    }
+  return conversion_buffer;
+}
+
+
+#ifdef emacs
+/*** 7. Emacs Lisp library functions ***/
+
+DEFUN ("coding-system-vector", Fcoding_system_vector, Scoding_system_vector,
+       1, 1, 0,
+  "Return coding-vector of CODING-SYSTEM.\n\
+If CODING-SYSTEM is not a valid coding-system, return nil.")
+  (obj)
+     Lisp_Object obj;
+{
+  while (SYMBOLP (obj) && !NILP (obj))
+    obj = Fget (obj, Qcoding_system);
+  return ((NILP (obj) || !VECTORP (obj) || XVECTOR (obj)->size != 5)
+	  ? Qnil : obj);
+}
+
+DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
+  "Return t if OBJECT is nil or a coding-system.\n\
+See document of make-coding-system for coding-system object.")
+  (obj)
+     Lisp_Object obj;
+{
+  return ((NILP (obj) || !NILP (Fcoding_system_vector (obj))) ? Qt : Qnil);
+}
+
+DEFUN ("read-non-nil-coding-system",
+       Fread_non_nil_coding_system, Sread_non_nil_coding_system, 1, 1, 0,
+  "Read a coding-system from the minibuffer, prompting with string PROMPT.")
+  (prompt)
+     Lisp_Object prompt;
+{
+  return Fintern (Fcompleting_read (prompt, Vobarray, Qcoding_system_vector,
+				    Qt, Qnil, Qnil),
+		  Qnil);
+}
+
+DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 1, 0,
+  "Read a coding-system or nil from the minibuffer, prompting with string PROMPT.")
+  (prompt)
+     Lisp_Object prompt;
+{
+  return Fintern (Fcompleting_read (prompt, Vobarray, Qcoding_system_p,
+				    Qt, Qnil, Qnil),
+		  Qnil);
+}
+
+DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
+       1, 1, 0,
+  "Check validity of CODING-SYSTEM.\n\
+If valid, return CODING-SYSTEM, else `coding-system-error' is signaled.\n\
+CODING-SYSTEM is valid if it is a symbol and has \"coding-system\" property.\n\
+The value of property should be a vector of length 5.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  if (!NILP (Fcoding_system_p (coding_system)))
+    return coding_system;
+  while (1)
+    Fsignal (Qcoding_system_error, coding_system);
+}
+
+DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
+       2, 2, 0,
+  "Detect coding-system of the text in the region between START and END.\n\
+Return a list of possible coding-systems ordered by priority.\n\
+If only ASCII characters are found, it returns `coding-system-automatic'\n\
+ or its subsidiary coding-system according to a detected end-of-line format.")
+  (b, e)
+     Lisp_Object b, e;
+{
+  int coding_mask, eol_type;
+  Lisp_Object val;
+  int beg, end;
+
+  validate_region (&b, &e);
+  beg = XINT (b), end = XINT (e);
+  if (beg < GPT && end >= GPT) move_gap (end);
+
+  coding_mask = detect_coding_mask (POS_ADDR (beg), end - beg);
+  eol_type  = detect_eol_type (POS_ADDR (beg), end - beg);
+
+  if (coding_mask == CODING_CATEGORY_MASK_ANY)
+    {
+      val = intern ("coding-system-automatic");
+      if (eol_type != CODING_EOL_AUTOMATIC)
+	{
+	  Lisp_Object val2 = Fget (val, Qeol_type);
+	  if (VECTORP (val2))
+	    val = XVECTOR (val2)->contents[eol_type];
+	}
+    }
+  else
+    {
+      Lisp_Object val2;
+
+      /* At first, gather possible coding-systems in VAL in a reverse
+	 order.  */
+      val = Qnil;
+      for (val2 = Vcoding_category_list;
+	   !NILP (val2);
+	   val2 = XCONS (val2)->cdr)
+	{
+	  int idx
+	    = XFASTINT (Fget (XCONS (val2)->car, Qcoding_category_index));
+	  if (coding_mask & (1 << idx))
+	    val = Fcons (Fsymbol_value (XCONS (val2)->car), val);
+	}
+
+      /* Then, change the order of the list, while getting subsidiary
+	 coding-systems.  */
+      val2 = val;
+      val = Qnil;
+      for (; !NILP (val2); val2 = XCONS (val2)->cdr)
+	{
+	  if (eol_type == CODING_EOL_AUTOMATIC)
+	    val = Fcons (XCONS (val2)->car, val);
+	  else
+	    {
+	      Lisp_Object val3 = Fget (XCONS (val2)->car, Qeol_type);
+	      if (VECTORP (val3))
+		val = Fcons (XVECTOR (val3)->contents[eol_type], val);
+	      else
+		val = Fcons (XCONS (val2)->car, val);
+	    }
+	}
+    }
+
+  return val;
+}
+
+/* Scan text in the region between *BEGP and *ENDP, skip characters
+   which we never have to encode to (iff ENCODEP is 1) or decode from
+   coding system CODING at the head and tail, then set BEGP and ENDP
+   to the addresses of start and end of the text we actually convert.  */
+
+void
+shrink_conversion_area (begp, endp, coding, encodep)
+     unsigned char **begp, **endp;
+     struct coding_system *coding;
+     int encodep;
+{
+  register unsigned char *beg_addr = *begp, *end_addr = *endp;
+
+  if (coding->eol_type != CODING_EOL_LF
+      && coding->eol_type != CODING_EOL_AUTOMATIC)
+    /* Since we anyway have to convert end-of-line format, it is not
+       worth skipping at most 100 bytes or so.  */
+    return;
+
+  if (encodep)			/* for encoding */
+    {
+      switch (coding->type)
+	{
+	case coding_type_no_conversion:
+	case coding_type_internal:
+	case coding_type_automatic:
+	  /* We need no conversion.  */
+	  *begp = *endp;
+	  return;
+	case coding_type_ccl:
+	  /* We can't skip any data.  */
+	  return;
+	default:
+	  /* We can skip all ASCII characters at the head and tail.  */
+	  while (beg_addr < end_addr && *beg_addr < 0x80) beg_addr++;
+	  while (beg_addr < end_addr && *(end_addr - 1) < 0x80) end_addr--;
+	  break;
+	}
+    }
+  else				/* for decoding */
+    {
+      switch (coding->type)
+	{
+	case coding_type_no_conversion:
+	  /* We need no conversion.  */
+	  *begp = *endp;
+	  return;
+	case coding_type_internal:
+	  if (coding->eol_type == CODING_EOL_LF)
+	    {
+	      /* We need no conversion.  */
+	      *begp = *endp;
+	      return;
+	    }
+	  /* We can skip all but carriage-return.  */
+	  while (beg_addr < end_addr && *beg_addr != '\r') beg_addr++;
+	  while (beg_addr < end_addr && *(end_addr - 1) != '\r') end_addr--;
+	  break;
+	case coding_type_sjis:
+	case coding_type_big5:
+	  /* We can skip all ASCII characters at the head.  */
+	  while (beg_addr < end_addr && *beg_addr < 0x80) beg_addr++;
+	  /* We can skip all ASCII characters at the tail except for
+	     the second byte of SJIS or BIG5 code.  */
+	  while (beg_addr < end_addr && *(end_addr - 1) < 0x80) end_addr--;
+	  if (end_addr != *endp)
+	    end_addr++;
+	  break;
+	case coding_type_ccl:
+	  /* We can't skip any data.  */
+	  return;
+	default:		/* i.e. case coding_type_iso2022: */
+	  {
+	    unsigned char c;
+
+	    /* We can skip all ASCII characters except for a few
+	       control codes at the head.  */
+	    while (beg_addr < end_addr && (c = *beg_addr) < 0x80
+		   && c != ISO_CODE_CR && c != ISO_CODE_SO
+		   && c != ISO_CODE_SI && c != ISO_CODE_ESC)
+	      beg_addr++;
+	  }
+	  break;
+	}
+    }
+  *begp = beg_addr;
+  *endp = end_addr;
+  return;
+}
+
+/* Encode to (iff ENCODEP is 1) or decode form coding system CODING a
+   text between B and E.  B and E are buffer position.  */
+
+Lisp_Object
+code_convert_region (b, e, coding, encodep)
+     Lisp_Object b, e;
+     struct coding_system *coding;
+     int encodep;
+{
+  int beg, end, len, consumed, produced;
+  char *buf;
+  unsigned char *begp, *endp;
+  int pos = PT;
+
+  validate_region (&b, &e);
+  beg = XINT (b), end = XINT (e);
+  if (beg < GPT && end >= GPT)
+    move_gap (end);
+
+  if (encodep && !NILP (coding->pre_write_conversion))
+    {
+      /* We must call a pre-conversion function which may put a new
+	 text to be converted in a new buffer.  */
+      struct buffer *old = current_buffer, *new;
+
+      TEMP_SET_PT (beg);
+      call2 (coding->pre_write_conversion, b, e);
+      if (old != current_buffer)
+	{
+	  /* Replace the original text by the text just generated.  */
+	  len = ZV - BEGV;
+	  new = current_buffer;
+	  set_buffer_internal (old);
+	  del_range (beg, end);
+	  insert_from_buffer (new, 1, len, 0);
+	  end = beg + len;
+	}
+    }
+
+  /* We may be able to shrink the conversion region.  */
+  begp = POS_ADDR (beg); endp = begp + (end - beg);
+  shrink_conversion_area (&begp, &endp, coding, encodep);
+
+  if (begp == endp)
+    /* We need no conversion.  */
+    len = end - beg;
+  else
+    {
+      beg += begp - POS_ADDR (beg);
+      end =  beg + (endp - begp);
+
+      if (encodep)
+	len = encoding_buffer_size (coding, end - beg);
+      else
+	len = decoding_buffer_size (coding, end - beg);
+      buf = get_conversion_buffer (len);
+
+      coding->last_block = 1;
+      produced = (encodep
+		  ? encode_coding (coding, POS_ADDR (beg), buf, end - beg, len,
+				   &consumed)
+		  : decode_coding (coding, POS_ADDR (beg), buf, end - beg, len,
+				   &consumed));
+
+      len = produced + (beg - XINT (b)) + (XINT (e) - end);
+
+      TEMP_SET_PT (beg);
+      insert (buf, produced);
+      del_range (PT, PT + end - beg);
+      if (pos >= end)
+	pos = PT + (pos - end);
+      else if (pos > beg)
+	pos = beg;
+      TEMP_SET_PT (pos);
+  }
+
+  if (!encodep && !NILP (coding->post_read_conversion))
+    {
+      /* We must call a post-conversion function which may alter
+	 the text just converted.  */
+      Lisp_Object insval;
+
+      beg = XINT (b);
+      TEMP_SET_PT (beg);
+      insval = call1 (coding->post_read_conversion, make_number (len));
+      CHECK_NUMBER (insval, 0);
+      len = XINT (insval);
+    }
+
+  return make_number (len);
+}
+
+Lisp_Object
+code_convert_string (str, coding, encodep)
+     Lisp_Object str;
+     struct coding_system *coding;
+     int encodep;
+{
+  int len, consumed, produced;
+  char *buf;
+  unsigned char *begp, *endp;
+  int head_skip, tail_skip;
+  struct gcpro gcpro1;
+
+  if (encodep && !NILP (coding->pre_write_conversion)
+      || !encodep && !NILP (coding->post_read_conversion))
+    {
+      /* Since we have to call Lisp functions which assume target text
+         is in a buffer, after setting a temporary buffer, call
+         code_convert_region.  */
+      int count = specpdl_ptr - specpdl;
+      int len = XSTRING (str)->size;
+      Lisp_Object result;
+      struct buffer *old = current_buffer;
+
+      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+      temp_output_buffer_setup (" *code-converting-work*");
+      set_buffer_internal (XBUFFER (Vstandard_output));
+      insert_from_string (str, 0, len, 0);
+      code_convert_region (make_number (BEGV), make_number (ZV),
+			   coding, encodep);
+      result = make_buffer_string (BEGV, ZV, 0);
+      set_buffer_internal (old);
+      return unbind_to (count, result);
+    }
+
+  /* We may be able to shrink the conversion region.  */
+  begp = XSTRING (str)->data;
+  endp = begp + XSTRING (str)->size;
+  shrink_conversion_area (&begp, &endp, coding, encodep);
+
+  if (begp == endp)
+    /* We need no conversion.  */
+    return str;
+
+  head_skip = begp - XSTRING (str)->data;
+  tail_skip = XSTRING (str)->size - head_skip - (endp - begp);
+
+  GCPRO1 (str);
+
+  if (encodep)
+    len = encoding_buffer_size (coding, endp - begp);
+  else
+    len = decoding_buffer_size (coding, endp - begp);
+  buf = get_conversion_buffer (len + head_skip + tail_skip);
+
+  bcopy (XSTRING (str)->data, buf, head_skip);
+  coding->last_block = 1;
+  produced = (encodep
+	      ? encode_coding (coding, XSTRING (str)->data + head_skip,
+			       buf + head_skip, endp - begp, len, &consumed)
+	      : decode_coding (coding, XSTRING (str)->data + head_skip,
+			       buf + head_skip, endp - begp, len, &consumed));
+  bcopy (XSTRING (str)->data + head_skip + (endp - begp),
+	 buf + head_skip + produced,
+	 tail_skip);
+
+  UNGCPRO;
+
+  return make_string (buf, head_skip + produced + tail_skip);
+}
+
+DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
+       3, 3, 0,
+  "Decode the text between START and END which is encoded in CODING-SYSTEM.\n\
+Return length of decoded text.")
+  (b, e, coding_system)
+     Lisp_Object b, e, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_NUMBER_COERCE_MARKER (b, 0);
+  CHECK_NUMBER_COERCE_MARKER (e, 1);
+  CHECK_SYMBOL (coding_system, 2);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_region (b, e, &coding, 0);
+}
+
+DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
+       3, 3, 0,
+  "Encode the text between START and END to CODING-SYSTEM.\n\
+Return length of encoded text.")
+  (b, e, coding_system)
+     Lisp_Object b, e, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_NUMBER_COERCE_MARKER (b, 0);
+  CHECK_NUMBER_COERCE_MARKER (e, 1);
+  CHECK_SYMBOL (coding_system, 2);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_region (b, e, &coding, 1);
+}
+
+DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
+       2, 2, 0,
+  "Decode STRING which is encoded in CODING-SYSTEM, and return the result.")
+  (string, coding_system)
+     Lisp_Object string, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_STRING (string, 0);
+  CHECK_SYMBOL (coding_system, 1);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_string (string, &coding, 0);
+}
+
+DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
+       2, 2, 0,
+  "Encode STRING to CODING-SYSTEM, and return the result.")
+  (string, coding_system)
+     Lisp_Object string, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_STRING (string, 0);
+  CHECK_SYMBOL (coding_system, 1);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_string (string, &coding, 1);
+}
+
+DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
+  "Decode a JISX0208 character of SJIS coding-system-sjis.\n\
+CODE is the character code in SJIS.\n\
+Return the corresponding character.")
+  (code)
+     Lisp_Object code;
+{
+  unsigned char c1, c2, s1, s2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (code, 0);
+  s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
+  DECODE_SJIS (s1, s2, c1, c2);
+  XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
+  return val;
+}
+
+DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
+  "Encode a JISX0208 character CHAR to SJIS coding-system.\n\
+Return the corresponding character code in SJIS.")
+  (ch)
+     Lisp_Object ch;
+{
+  int charset;
+  unsigned char c1, c2, s1, s2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (ch, 0);
+  SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
+  if (charset == charset_jisx0208)
+    {
+      ENCODE_SJIS (c1, c2, s1, s2);
+      XSETFASTINT (val, ((int)s1 << 8) | s2);
+    }
+  else
+    XSETFASTINT (val, 0);
+  return val;
+}
+
+DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
+  "Decode a Big5 character CODE of BIG5 coding-system.\n\
+CODE is the character code in BIG5.\n\
+Return the corresponding character.")
+  (code)
+     Lisp_Object code;
+{
+  int charset;
+  unsigned char b1, b2, c1, c2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (code, 0);
+  b1 = (XFASTINT (code)) >> 8, b2 = (XFASTINT (code)) & 0xFF;
+  DECODE_BIG5 (b1, b2, charset, c1, c2);
+  XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset, c1, c2));
+  return val;
+}
+
+DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
+  "Encode the Big5 character CHAR to BIG5 coding-system.\n\
+Return the corresponding character code in Big5.")
+  (ch)
+     Lisp_Object ch;
+{
+  int charset;
+  unsigned char c1, c2, b1, b2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (ch, 0);
+  SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
+  if (charset == charset_big5_1 || charset == charset_big5_2)
+    {
+      ENCODE_BIG5 (charset, c1, c2, b1, b2);
+      XSETFASTINT (val, ((int)b1 << 8) | b2);
+    }
+  else
+    XSETFASTINT (val, 0);
+  return val;
+}
+
+DEFUN ("set-terminal-coding-system",
+       Fset_terminal_coding_system, Sset_terminal_coding_system, 1, 1,
+       "zCoding-system for terminal display: ",
+  "Set coding-system of your terminal to CODING-SYSTEM.\n\
+All outputs to terminal are encoded to this coding-system.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  setup_coding_system (Fcheck_coding_system (coding_system), &terminal_coding);
+  update_mode_lines++;
+  if (!NILP (Finteractive_p ()))
+    Fredraw_display ();
+  return Qnil;
+}
+
+DEFUN ("terminal-coding-system",
+       Fterminal_coding_system, Sterminal_coding_system, 0, 0, 0,
+  "Return coding-system of your terminal.")
+  ()
+{
+  return terminal_coding.symbol;
+}
+
+DEFUN ("set-keyboard-coding-system",
+       Fset_keyboard_coding_system, Sset_keyboard_coding_system, 1, 1,
+       "zCoding-system for keyboard input: ",
+  "Set coding-system of what is sent from terminal keyboard to CODING-SYSTEM.\n\
+All inputs from terminal are decoded from this coding-system.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
+  return Qnil;
+}
+
+DEFUN ("keyboard-coding-system",
+       Fkeyboard_coding_system, Skeyboard_coding_system, 0, 0, 0,
+  "Return coding-system of what is sent from terminal keyboard.")
+  ()
+{
+  return keyboard_coding.symbol;
+}
+
+
+DEFUN ("find-coding-system", Ffind_coding_system, Sfind_coding_system,
+       1, MANY, 0,
+  "Return a cons of coding systems for I/O primitive OPERATION.\n\
+Remaining arguments are for OPERATION.\n\
+OPERATION is one of the following Emacs I/O primitives:\n\
+  For file I/O, insert-file-contents or write-region.\n\
+  For process I/O, call-process, call-process-region, or start-process.\n\
+  For network I/O, open-network-stream.\n\
+For each OPERATION, TARGET is selected from the arguments as below:\n\
+  For file I/O, TARGET is a file name.\n\
+  For process I/O, TARGET is a process name.\n\
+  For network I/O, TARGET is a service name or a port number\n\
+\n\
+The return value is a cons of coding systems for decoding and encoding\n\
+registered in nested alist `coding-system-alist' (which see) at a slot\n\
+corresponding to OPERATION and TARGET.
+If a function symbol is at the slot, return a result of the function call.\n\
+The function is called with one argument, a list of all the arguments.")
+  (nargs, args)
+     int nargs;
+     Lisp_Object *args;
+{
+  Lisp_Object operation, target_idx, target, val;
+  register Lisp_Object chain;
+
+  if (nargs < 2)
+    error ("Too few arguments");
+  operation = args[0];
+  if (!SYMBOLP (operation)
+      || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
+    error ("Invalid first arguement");
+  if (nargs < 1 + XINT (target_idx))
+    error ("Too few arguments for operation: %s",
+	   XSYMBOL (operation)->name->data);
+  target = args[XINT (target_idx) + 1];
+  if (!(STRINGP (target)
+	|| (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
+    error ("Invalid %dth argument", XINT (target_idx) + 1);
+
+  chain = Fassq (operation, Vcoding_system_alist);
+  if (NILP (chain))
+    return Qnil;
+
+  for (chain = XCONS (chain)->cdr; CONSP (chain); chain = XCONS (chain)->cdr)
+    {
+      Lisp_Object elt = XCONS (chain)->car;
+
+      if (CONSP (elt)
+	  && ((STRINGP (target)
+	       && STRINGP (XCONS (elt)->car)
+	       && fast_string_match (XCONS (elt)->car, target) >= 0)
+	      || (INTEGERP (target) && EQ (target, XCONS (elt)->car))))
+	return (CONSP (val = XCONS (elt)->cdr)
+		? val
+		: ((SYMBOLP (val) && Fboundp (val)
+		    ? call2 (val, Flist (nargs, args))
+		    : Qnil)));
+    }
+  return Qnil;
+}
+
+#endif /* emacs */
+
+
+/*** 8. Post-amble ***/
+
+init_coding_once ()
+{
+  int i;
+
+  /* Emacs internal format specific initialize routine.  */ 
+  for (i = 0; i <= 0x20; i++)
+    emacs_code_class[i] = EMACS_control_code;
+  emacs_code_class[0x0A] = EMACS_linefeed_code;
+  emacs_code_class[0x0D] = EMACS_carriage_return_code;
+  for (i = 0x21 ; i < 0x7F; i++)
+    emacs_code_class[i] = EMACS_ascii_code;
+  emacs_code_class[0x7F] = EMACS_control_code;
+  emacs_code_class[0x80] = EMACS_leading_code_composition;
+  for (i = 0x81; i < 0xFF; i++)
+    emacs_code_class[i] = EMACS_invalid_code;
+  emacs_code_class[LEADING_CODE_PRIVATE_11] = EMACS_leading_code_3;
+  emacs_code_class[LEADING_CODE_PRIVATE_12] = EMACS_leading_code_3;
+  emacs_code_class[LEADING_CODE_PRIVATE_21] = EMACS_leading_code_4;
+  emacs_code_class[LEADING_CODE_PRIVATE_22] = EMACS_leading_code_4;
+
+  /* ISO2022 specific initialize routine.  */
+  for (i = 0; i < 0x20; i++)
+    iso_code_class[i] = ISO_control_code;
+  for (i = 0x21; i < 0x7F; i++)
+    iso_code_class[i] = ISO_graphic_plane_0;
+  for (i = 0x80; i < 0xA0; i++)
+    iso_code_class[i] = ISO_control_code;
+  for (i = 0xA1; i < 0xFF; i++)
+    iso_code_class[i] = ISO_graphic_plane_1;
+  iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
+  iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
+  iso_code_class[ISO_CODE_CR] = ISO_carriage_return;
+  iso_code_class[ISO_CODE_SO] = ISO_shift_out;
+  iso_code_class[ISO_CODE_SI] = ISO_shift_in;
+  iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
+  iso_code_class[ISO_CODE_ESC] = ISO_escape;
+  iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
+  iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
+  iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
+
+  Qcoding_system = intern ("coding-system");
+  staticpro (&Qcoding_system);
+
+  Qeol_type = intern ("eol-type");
+  staticpro (&Qeol_type);
+
+  Qbuffer_file_coding_system = intern ("buffer-file-coding-system");
+  staticpro (&Qbuffer_file_coding_system);
+
+  Qpost_read_conversion = intern ("post-read-conversion");
+  staticpro (&Qpost_read_conversion);
+
+  Qpre_write_conversion = intern ("pre-write-conversion");
+  staticpro (&Qpre_write_conversion);
+
+  Qcoding_system_vector = intern ("coding-system-vector");
+  staticpro (&Qcoding_system_vector);
+
+  Qcoding_system_p = intern ("coding-system-p");
+  staticpro (&Qcoding_system_p);
+
+  Qcoding_system_error = intern ("coding-system-error");
+  staticpro (&Qcoding_system_error);
+
+  Fput (Qcoding_system_error, Qerror_conditions,
+	Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
+  Fput (Qcoding_system_error, Qerror_message,
+	build_string ("Coding-system error"));
+
+  Qcoding_category_index = intern ("coding-category-index");
+  staticpro (&Qcoding_category_index);
+
+  {
+    int i;
+    for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
+      {
+	coding_category_table[i] = intern (coding_category_name[i]);
+	staticpro (&coding_category_table[i]);
+	Fput (coding_category_table[i], Qcoding_category_index,
+	      make_number (i));
+      }
+  }
+
+  conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
+  conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
+
+  setup_coding_system (Qnil, &keyboard_coding);
+  setup_coding_system (Qnil, &terminal_coding);
+}
+
+#ifdef emacs
+
+syms_of_coding ()
+{
+  Qtarget_idx = intern ("target-idx");
+  staticpro (&Qtarget_idx);
+
+  Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
+  Fput (Qwrite_region, Qtarget_idx, make_number (2));
+
+  Qcall_process = intern ("call-process");
+  staticpro (&Qcall_process);
+  Fput (Qcall_process, Qtarget_idx, make_number (0));
+
+  Qcall_process_region = intern ("call-process-region");
+  staticpro (&Qcall_process_region);
+  Fput (Qcall_process_region, Qtarget_idx, make_number (2));
+
+  Qstart_process = intern ("start-process");
+  staticpro (&Qstart_process);
+  Fput (Qstart_process, Qtarget_idx, make_number (2));
+
+  Qopen_network_stream = intern ("open-network-stream");
+  staticpro (&Qopen_network_stream);
+  Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
+
+  defsubr (&Scoding_system_vector);
+  defsubr (&Scoding_system_p);
+  defsubr (&Sread_coding_system);
+  defsubr (&Sread_non_nil_coding_system);
+  defsubr (&Scheck_coding_system);
+  defsubr (&Sdetect_coding_region);
+  defsubr (&Sdecode_coding_region);
+  defsubr (&Sencode_coding_region);
+  defsubr (&Sdecode_coding_string);
+  defsubr (&Sencode_coding_string);
+  defsubr (&Sdecode_sjis_char);
+  defsubr (&Sencode_sjis_char);
+  defsubr (&Sdecode_big5_char);
+  defsubr (&Sencode_big5_char);
+  defsubr (&Sset_terminal_coding_system);
+  defsubr (&Sterminal_coding_system);
+  defsubr (&Sset_keyboard_coding_system);
+  defsubr (&Skeyboard_coding_system);
+  defsubr (&Sfind_coding_system);
+
+  DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
+    "List of coding-categories (symbols) ordered by priority.");
+  {
+    int i;
+
+    Vcoding_category_list = Qnil;
+    for (i = CODING_CATEGORY_IDX_MAX - 1; i >= 0; i--)
+      Vcoding_category_list
+	= Fcons (coding_category_table[i], Vcoding_category_list);
+  }
+
+  DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
+    "A variable of internal use only.\n\
+If the value is a coding system, it is used for decoding on read operation.\n\
+If not, an appropriate element in `coding-system-alist' (which see) is used.");
+  Vcoding_system_for_read = Qnil;
+
+  DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
+    "A variable of internal use only.\n\
+If the value is a coding system, it is used for encoding on write operation.\n\
+If not, an appropriate element in `coding-system-alist' (which see) is used.");
+  Vcoding_system_for_write = Qnil;
+
+  DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
+    "Coding-system used in the latest file or process I/O.");
+  Vlast_coding_system_used = Qnil;
+
+  DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
+    "Nested alist to decide a coding system for a specific I/O operation.\n\
+The format is ((OPERATION . ((REGEXP . CODING-SYSTEMS) ...)) ...).\n\
+
+OPERATION is one of the following Emacs I/O primitives:\n\
+  For file I/O, insert-file-contents and write-region.\n\
+  For process I/O, call-process, call-process-region, and start-process.\n\
+  For network I/O, open-network-stream.\n\
+In addition, for process I/O, `process-argument' can be specified for\n\
+encoding arguments of the process.\n\
+\n\
+REGEXP is a regular expression matching a target of OPERATION, where\n\
+target is a file name for file I/O operations, a process name for\n\
+process I/O operations, or a service name for network I/O\n\
+operations.  REGEXP might be a port number for network I/O operation.\n\
+\n\
+CODING-SYSTEMS is a cons of coding systems to encode and decode\n\
+character code on OPERATION, or a function symbol returning the cons.\n\
+See the documentation of `find-coding-system' for more detail.");
+  Vcoding_system_alist = Qnil;
+
+  DEFVAR_INT ("eol-mnemonic-unix", &eol_mnemonic_unix,
+    "Mnemonic character indicating UNIX-like end-of-line format (i.e. LF) .");
+  eol_mnemonic_unix = '.';
+
+  DEFVAR_INT ("eol-mnemonic-dos", &eol_mnemonic_dos,
+    "Mnemonic character indicating DOS-like end-of-line format (i.e. CRLF).");
+  eol_mnemonic_dos = ':';
+
+  DEFVAR_INT ("eol-mnemonic-mac", &eol_mnemonic_mac,
+    "Mnemonic character indicating MAC-like end-of-line format (i.e. CR).");
+  eol_mnemonic_mac = '\'';
+
+  DEFVAR_INT ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
+    "Mnemonic character indicating end-of-line format is not yet decided.");
+  eol_mnemonic_undecided = '-';
+
+  DEFVAR_LISP ("alternate-charset-table", &Valternate_charset_table,
+    "Alist of charsets vs the alternate charsets.\n\
+While decoding, if a charset (car part of an element) is found,\n\
+decode it as the alternate charset (cdr part of the element).");
+  Valternate_charset_table = Qnil;
+
+  DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_alist,
+    "Alist of charsets vs revision numbers.\n\
+While encoding, if a charset (car part of an element) is found,\n\
+designate it with the escape sequence identifing revision (cdr part of the element).");
+  Vcharset_revision_alist = Qnil;
+}
+
+#endif /* emacs */