home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / coding.c < prev    next >
Text File  |  1999-07-31  |  182KB  |  5,520 lines
  1. /* Coding system handler (conversion, detection, and etc).
  2.    Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
  3.    Licensed to the Free Software Foundation.
  4.  
  5. This file is part of GNU Emacs.
  6.  
  7. GNU Emacs is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU Emacs is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Emacs; see the file COPYING.  If not, write to
  19. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20. Boston, MA 02111-1307, USA.  */
  21.  
  22. /*** TABLE OF CONTENTS ***
  23.  
  24.   1. Preamble
  25.   2. Emacs' internal format (emacs-mule) handlers
  26.   3. ISO2022 handlers
  27.   4. Shift-JIS and BIG5 handlers
  28.   5. CCL handlers
  29.   6. End-of-line handlers
  30.   7. C library functions
  31.   8. Emacs Lisp library functions
  32.   9. Post-amble
  33.  
  34. */
  35.  
  36. /*** GENERAL NOTE on CODING SYSTEM ***
  37.  
  38.   Coding system is an encoding mechanism of one or more character
  39.   sets.  Here's a list of coding systems which Emacs can handle.  When
  40.   we say "decode", it means converting some other coding system to
  41.   Emacs' internal format (emacs-internal), and when we say "encode",
  42.   it means converting the coding system emacs-mule to some other
  43.   coding system.
  44.  
  45.   0. Emacs' internal format (emacs-mule)
  46.  
  47.   Emacs itself holds a multi-lingual character in a buffer and a string
  48.   in a special format.  Details are described in section 2.
  49.  
  50.   1. ISO2022
  51.  
  52.   The most famous coding system for multiple character sets.  X's
  53.   Compound Text, various EUCs (Extended Unix Code), and coding
  54.   systems used in Internet communication such as ISO-2022-JP are
  55.   all variants of ISO2022.  Details are described in section 3.
  56.  
  57.   2. SJIS (or Shift-JIS or MS-Kanji-Code)
  58.    
  59.   A coding system to encode character sets: ASCII, JISX0201, and
  60.   JISX0208.  Widely used for PC's in Japan.  Details are described in
  61.   section 4.
  62.  
  63.   3. BIG5
  64.  
  65.   A coding system to encode character sets: ASCII and Big5.  Widely
  66.   used by Chinese (mainly in Taiwan and Hong Kong).  Details are
  67.   described in section 4.  In this file, when we write "BIG5"
  68.   (all uppercase), we mean the coding system, and when we write
  69.   "Big5" (capitalized), we mean the character set.
  70.  
  71.   4. Raw text
  72.  
  73.   A coding system for a text containing random 8-bit code.  Emacs does
  74.   no code conversion on such a text except for end-of-line format.
  75.  
  76.   5. Other
  77.  
  78.   If a user wants to read/write a text encoded in a coding system not
  79.   listed above, he can supply a decoder and an encoder for it in CCL
  80.   (Code Conversion Language) programs.  Emacs executes the CCL program
  81.   while reading/writing.
  82.  
  83.   Emacs represents a coding system by a Lisp symbol that has a property
  84.   `coding-system'.  But, before actually using the coding system, the
  85.   information about it is set in a structure of type `struct
  86.   coding_system' for rapid processing.  See section 6 for more details.
  87.  
  88. */
  89.  
  90. /*** GENERAL NOTES on END-OF-LINE FORMAT ***
  91.  
  92.   How end-of-line of a text is encoded depends on a system.  For
  93.   instance, Unix's format is just one byte of `line-feed' code,
  94.   whereas DOS's format is two-byte sequence of `carriage-return' and
  95.   `line-feed' codes.  MacOS's format is usually one byte of
  96.   `carriage-return'.
  97.  
  98.   Since text characters encoding and end-of-line encoding are
  99.   independent, any coding system described above can take
  100.   any format of end-of-line.  So, Emacs has information of format of
  101.   end-of-line in each coding-system.  See section 6 for more details.
  102.  
  103. */
  104.  
  105. /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
  106.  
  107.   These functions check if a text between SRC and SRC_END is encoded
  108.   in the coding system category XXX.  Each returns an integer value in
  109.   which appropriate flag bits for the category XXX is set.  The flag
  110.   bits are defined in macros CODING_CATEGORY_MASK_XXX.  Below is the
  111.   template of these functions.  */
  112. #if 0
  113. int
  114. detect_coding_emacs_mule (src, src_end)
  115.      unsigned char *src, *src_end;
  116. {
  117.   ...
  118. }
  119. #endif
  120.  
  121. /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
  122.  
  123.   These functions decode SRC_BYTES length text at SOURCE encoded in
  124.   CODING to Emacs' internal format (emacs-mule).  The resulting text
  125.   goes to a place pointed to by DESTINATION, the length of which
  126.   should not exceed DST_BYTES.  These functions set the information of
  127.   original and decoded texts in the members produced, produced_char,
  128.   consumed, and consumed_char of the structure *CODING.
  129.  
  130.   The return value is an integer (CODING_FINISH_XXX) indicating how
  131.   the decoding finished.
  132.  
  133.   DST_BYTES zero means that source area and destination area are
  134.   overlapped, which means that we can produce a decoded text until it
  135.   reaches at the head of not-yet-decoded source text.
  136.  
  137.   Below is a template of these functions.  */
  138. #if 0
  139. decode_coding_XXX (coding, source, destination, src_bytes, dst_bytes)
  140.      struct coding_system *coding;
  141.      unsigned char *source, *destination;
  142.      int src_bytes, dst_bytes;
  143. {
  144.   ...
  145. }
  146. #endif
  147.  
  148. /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
  149.  
  150.   These functions encode SRC_BYTES length text at SOURCE of Emacs'
  151.   internal format (emacs-mule) to CODING.  The resulting text goes to
  152.   a place pointed to by DESTINATION, the length of which should not
  153.   exceed DST_BYTES.  These functions set the information of
  154.   original and encoded texts in the members produced, produced_char,
  155.   consumed, and consumed_char of the structure *CODING.
  156.  
  157.   The return value is an integer (CODING_FINISH_XXX) indicating how
  158.   the encoding finished.
  159.  
  160.   DST_BYTES zero means that source area and destination area are
  161.   overlapped, which means that we can produce a decoded text until it
  162.   reaches at the head of not-yet-decoded source text.
  163.  
  164.   Below is a template of these functions.  */
  165. #if 0
  166. encode_coding_XXX (coding, source, destination, src_bytes, dst_bytes)
  167.      struct coding_system *coding;
  168.      unsigned char *source, *destination;
  169.      int src_bytes, dst_bytes;
  170. {
  171.   ...
  172. }
  173. #endif
  174.  
  175. /*** COMMONLY USED MACROS ***/
  176.  
  177. /* The following three macros ONE_MORE_BYTE, TWO_MORE_BYTES, and
  178.    THREE_MORE_BYTES safely get one, two, and three bytes from the
  179.    source text respectively.  If there are not enough bytes in the
  180.    source, they jump to `label_end_of_loop'.  The caller should set
  181.    variables `src' and `src_end' to appropriate areas in advance.  */
  182.  
  183. #define ONE_MORE_BYTE(c1)       \
  184.   do {                     \
  185.     if (src < src_end)             \
  186.       c1 = *src++;             \
  187.     else                 \
  188.       goto label_end_of_loop;    \
  189.   } while (0)
  190.  
  191. #define TWO_MORE_BYTES(c1, c2)     \
  192.   do {                       \
  193.     if (src + 1 < src_end)         \
  194.       c1 = *src++, c2 = *src++;    \
  195.     else                   \
  196.       goto label_end_of_loop;      \
  197.   } while (0)
  198.  
  199. #define THREE_MORE_BYTES(c1, c2, c3)            \
  200.   do {                            \
  201.     if (src + 2 < src_end)                \
  202.       c1 = *src++, c2 = *src++, c3 = *src++;    \
  203.     else                        \
  204.       goto label_end_of_loop;                \
  205.   } while (0)
  206.  
  207. /* The following three macros DECODE_CHARACTER_ASCII,
  208.    DECODE_CHARACTER_DIMENSION1, and DECODE_CHARACTER_DIMENSION2 put
  209.    the multi-byte form of a character of each class at the place
  210.    pointed by `dst'.  The caller should set the variable `dst' to
  211.    point to an appropriate area and the variable `coding' to point to
  212.    the coding-system of the currently decoding text in advance.  */
  213.  
  214. /* Decode one ASCII character C.  */
  215.  
  216. #define DECODE_CHARACTER_ASCII(c)                \
  217.   do {                                \
  218.     if (COMPOSING_P (coding->composing))            \
  219.       *dst++ = 0xA0, *dst++ = (c) | 0x80;            \
  220.     else                            \
  221.       {                                \
  222.     *dst++ = (c);                        \
  223.     coding->produced_char++;                \
  224.       }                                \
  225.   } while (0)
  226.  
  227. /* Decode one DIMENSION1 character whose charset is CHARSET and whose
  228.    position-code is C.  */
  229.  
  230. #define DECODE_CHARACTER_DIMENSION1(charset, c)                \
  231.   do {                                    \
  232.     unsigned char leading_code = CHARSET_LEADING_CODE_BASE (charset);    \
  233.     if (COMPOSING_P (coding->composing))                \
  234.       *dst++ = leading_code + 0x20;                    \
  235.     else                                \
  236.       {                                    \
  237.     *dst++ = leading_code;                        \
  238.     coding->produced_char++;                    \
  239.       }                                    \
  240.     if (leading_code = CHARSET_LEADING_CODE_EXT (charset))        \
  241.       *dst++ = leading_code;                        \
  242.     *dst++ = (c) | 0x80;                        \
  243.   } while (0)
  244.  
  245. /* Decode one DIMENSION2 character whose charset is CHARSET and whose
  246.    position-codes are C1 and C2.  */
  247.  
  248. #define DECODE_CHARACTER_DIMENSION2(charset, c1, c2)    \
  249.   do {                            \
  250.     DECODE_CHARACTER_DIMENSION1 (charset, c1);        \
  251.     *dst++ = (c2) | 0x80;                \
  252.   } while (0)
  253.  
  254.  
  255. /*** 1. Preamble ***/
  256.  
  257. #include <stdio.h>
  258.  
  259. #ifdef emacs
  260.  
  261. #include <config.h>
  262. #include "lisp.h"
  263. #include "buffer.h"
  264. #include "charset.h"
  265. #include "ccl.h"
  266. #include "coding.h"
  267. #include "window.h"
  268.  
  269. #else  /* not emacs */
  270.  
  271. #include "mulelib.h"
  272.  
  273. #endif /* not emacs */
  274.  
  275. Lisp_Object Qcoding_system, Qeol_type;
  276. Lisp_Object Qbuffer_file_coding_system;
  277. Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
  278. Lisp_Object Qno_conversion, Qundecided;
  279. Lisp_Object Qcoding_system_history;
  280. Lisp_Object Qsafe_charsets;
  281. Lisp_Object Qvalid_codes;
  282.  
  283. extern Lisp_Object Qinsert_file_contents, Qwrite_region;
  284. Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
  285. Lisp_Object Qstart_process, Qopen_network_stream;
  286. Lisp_Object Qtarget_idx;
  287.  
  288. Lisp_Object Vselect_safe_coding_system_function;
  289.  
  290. /* Mnemonic character of each format of end-of-line.  */
  291. int eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
  292. /* Mnemonic character to indicate format of end-of-line is not yet
  293.    decided.  */
  294. int eol_mnemonic_undecided;
  295.  
  296. /* Format of end-of-line decided by system.  This is CODING_EOL_LF on
  297.    Unix, CODING_EOL_CRLF on DOS/Windows, and CODING_EOL_CR on Mac.  */
  298. int system_eol_type;
  299.  
  300. #ifdef emacs
  301.  
  302. Lisp_Object Vcoding_system_list, Vcoding_system_alist;
  303.  
  304. Lisp_Object Qcoding_system_p, Qcoding_system_error;
  305.  
  306. /* Coding system emacs-mule and raw-text are for converting only
  307.    end-of-line format.  */
  308. Lisp_Object Qemacs_mule, Qraw_text;
  309.  
  310. /* Coding-systems are handed between Emacs Lisp programs and C internal
  311.    routines by the following three variables.  */
  312. /* Coding-system for reading files and receiving data from process.  */
  313. Lisp_Object Vcoding_system_for_read;
  314. /* Coding-system for writing files and sending data to process.  */
  315. Lisp_Object Vcoding_system_for_write;
  316. /* Coding-system actually used in the latest I/O.  */
  317. Lisp_Object Vlast_coding_system_used;
  318.  
  319. /* A vector of length 256 which contains information about special
  320.    Latin codes (especially for dealing with Microsoft codes).  */
  321. Lisp_Object Vlatin_extra_code_table;
  322.  
  323. /* Flag to inhibit code conversion of end-of-line format.  */
  324. int inhibit_eol_conversion;
  325.  
  326. /* Flag to make buffer-file-coding-system inherit from process-coding.  */
  327. int inherit_process_coding_system;
  328.  
  329. /* Coding system to be used to encode text for terminal display.  */
  330. struct coding_system terminal_coding;
  331.  
  332. /* Coding system to be used to encode text for terminal display when
  333.    terminal coding system is nil.  */
  334. struct coding_system safe_terminal_coding;
  335.  
  336. /* Coding system of what is sent from terminal keyboard.  */
  337. struct coding_system keyboard_coding;
  338.  
  339. /* Default coding system to be used to write a file.  */
  340. struct coding_system default_buffer_file_coding;
  341.  
  342. Lisp_Object Vfile_coding_system_alist;
  343. Lisp_Object Vprocess_coding_system_alist;
  344. Lisp_Object Vnetwork_coding_system_alist;
  345.  
  346. #endif /* emacs */
  347.  
  348. Lisp_Object Qcoding_category, Qcoding_category_index;
  349.  
  350. /* List of symbols `coding-category-xxx' ordered by priority.  */
  351. Lisp_Object Vcoding_category_list;
  352.  
  353. /* Table of coding categories (Lisp symbols).  */
  354. Lisp_Object Vcoding_category_table;
  355.  
  356. /* Table of names of symbol for each coding-category.  */
  357. char *coding_category_name[CODING_CATEGORY_IDX_MAX] = {
  358.   "coding-category-emacs-mule",
  359.   "coding-category-sjis",
  360.   "coding-category-iso-7",
  361.   "coding-category-iso-7-tight",
  362.   "coding-category-iso-8-1",
  363.   "coding-category-iso-8-2",
  364.   "coding-category-iso-7-else",
  365.   "coding-category-iso-8-else",
  366.   "coding-category-ccl",
  367.   "coding-category-big5",
  368.   "coding-category-raw-text",
  369.   "coding-category-binary"
  370. };
  371.  
  372. /* Table of pointers to coding systems corresponding to each coding
  373.    categories.  */
  374. struct coding_system *coding_system_table[CODING_CATEGORY_IDX_MAX];
  375.  
  376. /* Table of coding category masks.  Nth element is a mask for a coding
  377.    cateogry of which priority is Nth.  */
  378. static
  379. int coding_priorities[CODING_CATEGORY_IDX_MAX];
  380.  
  381. /* Flag to tell if we look up translation table on character code
  382.    conversion.  */
  383. Lisp_Object Venable_character_translation;
  384. /* Standard translation table to look up on decoding (reading).  */
  385. Lisp_Object Vstandard_translation_table_for_decode;
  386. /* Standard translation table to look up on encoding (writing).  */
  387. Lisp_Object Vstandard_translation_table_for_encode;
  388.  
  389. Lisp_Object Qtranslation_table;
  390. Lisp_Object Qtranslation_table_id;
  391. Lisp_Object Qtranslation_table_for_decode;
  392. Lisp_Object Qtranslation_table_for_encode;
  393.  
  394. /* Alist of charsets vs revision number.  */
  395. Lisp_Object Vcharset_revision_alist;
  396.  
  397. /* Default coding systems used for process I/O.  */
  398. Lisp_Object Vdefault_process_coding_system;
  399.  
  400.  
  401. /*** 2. Emacs internal format (emacs-mule) handlers ***/
  402.  
  403. /* Emacs' internal format for encoding multiple character sets is a
  404.    kind of multi-byte encoding, i.e. characters are encoded by
  405.    variable-length sequences of one-byte codes.  ASCII characters
  406.    and control characters (e.g. `tab', `newline') are represented by
  407.    one-byte sequences which are their ASCII codes, in the range 0x00
  408.    through 0x7F.  The other characters are represented by a sequence
  409.    of `base leading-code', optional `extended leading-code', and one
  410.    or two `position-code's.  The length of the sequence is determined
  411.    by the base leading-code.  Leading-code takes the range 0x80
  412.    through 0x9F, whereas extended leading-code and position-code take
  413.    the range 0xA0 through 0xFF.  See `charset.h' for more details
  414.    about leading-code and position-code.
  415.  
  416.    There's one exception to this rule.  Special leading-code
  417.    `leading-code-composition' denotes that the following several
  418.    characters should be composed into one character.  Leading-codes of
  419.    components (except for ASCII) are added 0x20.  An ASCII character
  420.    component is represented by a 2-byte sequence of `0xA0' and
  421.    `ASCII-code + 0x80'.  See also the comments in `charset.h' for the
  422.    details of composite character.  Hence, we can summarize the code
  423.    range as follows:
  424.  
  425.    --- CODE RANGE of Emacs' internal format ---
  426.    (character set)    (range)
  427.    ASCII        0x00 .. 0x7F
  428.    ELSE (1st byte)    0x80 .. 0x9F
  429.     (rest bytes)    0xA0 .. 0xFF
  430.    ---------------------------------------------
  431.  
  432.   */
  433.  
  434. enum emacs_code_class_type emacs_code_class[256];
  435.  
  436. /* Go to the next statement only if *SRC is accessible and the code is
  437.    greater than 0xA0.  */
  438. #define CHECK_CODE_RANGE_A0_FF     \
  439.   do {                       \
  440.     if (src >= src_end)               \
  441.       goto label_end_of_switch;    \
  442.     else if (*src++ < 0xA0)        \
  443.       return 0;                   \
  444.   } while (0)
  445.  
  446. /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
  447.    Check if a text is encoded in Emacs' internal format.  If it is,
  448.    return CODING_CATEGORY_MASK_EMACS_MULE, else return 0.  */
  449.  
  450. int
  451. detect_coding_emacs_mule (src, src_end)
  452.      unsigned char *src, *src_end;
  453. {
  454.   unsigned char c;
  455.   int composing = 0;
  456.  
  457.   while (src < src_end)
  458.     {
  459.       c = *src++;
  460.  
  461.       if (composing)
  462.     {
  463.       if (c < 0xA0)
  464.         composing = 0;
  465.       else
  466.         c -= 0x20;
  467.     }
  468.  
  469.       switch (emacs_code_class[c])
  470.     {
  471.     case EMACS_ascii_code:
  472.     case EMACS_linefeed_code:
  473.       break;
  474.  
  475.     case EMACS_control_code:
  476.       if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
  477.         return 0;
  478.       break;
  479.  
  480.     case EMACS_invalid_code:
  481.       return 0;
  482.  
  483.     case EMACS_leading_code_composition: /* c == 0x80 */
  484.       if (composing)
  485.         CHECK_CODE_RANGE_A0_FF;
  486.       else
  487.         composing = 1;
  488.       break;
  489.  
  490.     case EMACS_leading_code_4:
  491.       CHECK_CODE_RANGE_A0_FF;
  492.       /* fall down to check it two more times ...  */
  493.  
  494.     case EMACS_leading_code_3:
  495.       CHECK_CODE_RANGE_A0_FF;
  496.       /* fall down to check it one more time ...  */
  497.  
  498.     case EMACS_leading_code_2:
  499.       CHECK_CODE_RANGE_A0_FF;
  500.       break;
  501.  
  502.     default:
  503.     label_end_of_switch:
  504.       break;
  505.     }
  506.     }
  507.   return CODING_CATEGORY_MASK_EMACS_MULE;
  508. }
  509.  
  510.  
  511. /*** 3. ISO2022 handlers ***/
  512.  
  513. /* The following note describes the coding system ISO2022 briefly.
  514.    Since the intention of this note is to help in understanding of
  515.    the programs in this file, some parts are NOT ACCURATE or OVERLY
  516.    SIMPLIFIED.  For the thorough understanding, please refer to the
  517.    original document of ISO2022.
  518.  
  519.    ISO2022 provides many mechanisms to encode several character sets
  520.    in 7-bit and 8-bit environment.  If one chooses 7-bite environment,
  521.    all text is encoded by codes of less than 128.  This may make the
  522.    encoded text a little bit longer, but the text gets more stability
  523.    to pass through several gateways (some of them strip off the MSB).
  524.  
  525.    There are two kinds of character set: control character set and
  526.    graphic character set.  The former contains control characters such
  527.    as `newline' and `escape' to provide control functions (control
  528.    functions are provided also by escape sequences).  The latter
  529.    contains graphic characters such as ' A' and '-'.  Emacs recognizes
  530.    two control character sets and many graphic character sets.
  531.  
  532.    Graphic character sets are classified into one of the following
  533.    four classes, DIMENSION1_CHARS94, DIMENSION1_CHARS96,
  534.    DIMENSION2_CHARS94, DIMENSION2_CHARS96 according to the number of
  535.    bytes (DIMENSION) and the number of characters in one dimension
  536.    (CHARS) of the set.  In addition, each character set is assigned an
  537.    identification tag (called "final character" and denoted as <F>
  538.    here after) which is unique in each class.  <F> of each character
  539.    set is decided by ECMA(*) when it is registered in ISO.  Code range
  540.    of <F> is 0x30..0x7F (0x30..0x3F are for private use only).
  541.  
  542.    Note (*): ECMA = European Computer Manufacturers Association
  543.  
  544.    Here are examples of graphic character set [NAME(<F>)]:
  545.     o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
  546.     o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
  547.     o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
  548.     o DIMENSION2_CHARS96 -- none for the moment
  549.  
  550.    A code area (1byte=8bits) is divided into 4 areas, C0, GL, C1, and GR.
  551.     C0 [0x00..0x1F] -- control character plane 0
  552.     GL [0x20..0x7F] -- graphic character plane 0
  553.     C1 [0x80..0x9F] -- control character plane 1
  554.     GR [0xA0..0xFF] -- graphic character plane 1
  555.  
  556.    A control character set is directly designated and invoked to C0 or
  557.    C1 by an escape sequence.  The most common case is that ISO646's
  558.    control character set is designated/invoked to C0 and ISO6429's
  559.    control character set is designated/invoked to C1, and usually
  560.    these designations/invocations are omitted in a coded text.  With
  561.    7-bit environment, only C0 can be used, and a control character for
  562.    C1 is encoded by an appropriate escape sequence to fit in the
  563.    environment.  All control characters for C1 are defined the
  564.    corresponding escape sequences.
  565.  
  566.    A graphic character set is at first designated to one of four
  567.    graphic registers (G0 through G3), then these graphic registers are
  568.    invoked to GL or GR.  These designations and invocations can be
  569.    done independently.  The most common case is that G0 is invoked to
  570.    GL, G1 is invoked to GR, and ASCII is designated to G0, and usually
  571.    these invocations and designations are omitted in a coded text.
  572.    With 7-bit environment, only GL can be used.
  573.  
  574.    When a graphic character set of CHARS94 is invoked to GL, code 0x20
  575.    and 0x7F of GL area work as control characters SPACE and DEL
  576.    respectively, and code 0xA0 and 0xFF of GR area should not be used.
  577.  
  578.    There are two ways of invocation: locking-shift and single-shift.
  579.    With locking-shift, the invocation lasts until the next different
  580.    invocation, whereas with single-shift, the invocation works only
  581.    for the following character and doesn't affect locking-shift.
  582.    Invocations are done by the following control characters or escape
  583.    sequences.
  584.  
  585.    ----------------------------------------------------------------------
  586.    function        control char    escape sequence    description
  587.    ----------------------------------------------------------------------
  588.    SI  (shift-in)        0x0F    none        invoke G0 to GL
  589.    SO  (shift-out)        0x0E    none        invoke G1 to GL
  590.    LS2 (locking-shift-2)    none    ESC 'n'        invoke G2 into GL
  591.    LS3 (locking-shift-3)    none    ESC 'o'        invoke G3 into GL
  592.    SS2 (single-shift-2)        0x8E    ESC 'N'        invoke G2 into GL
  593.    SS3 (single-shift-3)        0x8F    ESC 'O'        invoke G3 into GL
  594.    ----------------------------------------------------------------------
  595.    The first four are for locking-shift.  Control characters for these
  596.    functions are defined by macros ISO_CODE_XXX in `coding.h'.
  597.  
  598.    Designations are done by the following escape sequences.
  599.    ----------------------------------------------------------------------
  600.    escape sequence    description
  601.    ----------------------------------------------------------------------
  602.    ESC '(' <F>        designate DIMENSION1_CHARS94<F> to G0
  603.    ESC ')' <F>        designate DIMENSION1_CHARS94<F> to G1
  604.    ESC '*' <F>        designate DIMENSION1_CHARS94<F> to G2
  605.    ESC '+' <F>        designate DIMENSION1_CHARS94<F> to G3
  606.    ESC ',' <F>        designate DIMENSION1_CHARS96<F> to G0 (*)
  607.    ESC '-' <F>        designate DIMENSION1_CHARS96<F> to G1
  608.    ESC '.' <F>        designate DIMENSION1_CHARS96<F> to G2
  609.    ESC '/' <F>        designate DIMENSION1_CHARS96<F> to G3
  610.    ESC '$' '(' <F>    designate DIMENSION2_CHARS94<F> to G0 (**)
  611.    ESC '$' ')' <F>    designate DIMENSION2_CHARS94<F> to G1
  612.    ESC '$' '*' <F>    designate DIMENSION2_CHARS94<F> to G2
  613.    ESC '$' '+' <F>    designate DIMENSION2_CHARS94<F> to G3
  614.    ESC '$' ',' <F>    designate DIMENSION2_CHARS96<F> to G0 (*)
  615.    ESC '$' '-' <F>    designate DIMENSION2_CHARS96<F> to G1
  616.    ESC '$' '.' <F>    designate DIMENSION2_CHARS96<F> to G2
  617.    ESC '$' '/' <F>    designate DIMENSION2_CHARS96<F> to G3
  618.    ----------------------------------------------------------------------
  619.  
  620.    In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
  621.    of dimension 1, chars 94, and final character <F>, and etc.
  622.  
  623.    Note (*): Although these designations are not allowed in ISO2022,
  624.    Emacs accepts them on decoding, and produces them on encoding
  625.    CHARS96 character set in a coding system which is characterized as
  626.    7-bit environment, non-locking-shift, and non-single-shift.
  627.  
  628.    Note (**): If <F> is '@', 'A', or 'B', the intermediate character
  629.    '(' can be omitted.  We call this as "short-form" here after.
  630.  
  631.    Now you may notice that there are a lot of ways for encoding the
  632.    same multilingual text in ISO2022.  Actually, there exists many
  633.    coding systems such as Compound Text (used in X's inter client
  634.    communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
  635.    (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
  636.    localized platforms), and all of these are variants of ISO2022.
  637.  
  638.    In addition to the above, Emacs handles two more kinds of escape
  639.    sequences: ISO6429's direction specification and Emacs' private
  640.    sequence for specifying character composition.
  641.  
  642.    ISO6429's direction specification takes the following format:
  643.     o CSI ']'      -- end of the current direction
  644.     o CSI '0' ']'  -- end of the current direction
  645.     o CSI '1' ']'  -- start of left-to-right text
  646.     o CSI '2' ']'  -- start of right-to-left text
  647.    The control character CSI (0x9B: control sequence introducer) is
  648.    abbreviated to the escape sequence ESC '[' in 7-bit environment.
  649.    
  650.    Character composition specification takes the following format:
  651.     o ESC '0' -- start character composition
  652.     o ESC '1' -- end character composition
  653.    Since these are not standard escape sequences of any ISO, the use
  654.    of them for these meaning is restricted to Emacs only.  */
  655.  
  656. enum iso_code_class_type iso_code_class[256];
  657.  
  658. #define CHARSET_OK(idx, charset)                \
  659.   (coding_system_table[idx]                    \
  660.    && (coding_system_table[idx]->safe_charsets[charset]        \
  661.        || (CODING_SPEC_ISO_REQUESTED_DESIGNATION        \
  662.             (coding_system_table[idx], charset)            \
  663.            != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)))
  664.  
  665. #define SHIFT_OUT_OK(idx) \
  666.   (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
  667.  
  668. /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
  669.    Check if a text is encoded in ISO2022.  If it is, returns an
  670.    integer in which appropriate flag bits any of:
  671.     CODING_CATEGORY_MASK_ISO_7
  672.     CODING_CATEGORY_MASK_ISO_7_TIGHT
  673.     CODING_CATEGORY_MASK_ISO_8_1
  674.     CODING_CATEGORY_MASK_ISO_8_2
  675.     CODING_CATEGORY_MASK_ISO_7_ELSE
  676.     CODING_CATEGORY_MASK_ISO_8_ELSE
  677.    are set.  If a code which should never appear in ISO2022 is found,
  678.    returns 0.  */
  679.  
  680. int
  681. detect_coding_iso2022 (src, src_end)
  682.      unsigned char *src, *src_end;
  683. {
  684.   int mask = CODING_CATEGORY_MASK_ISO;
  685.   int mask_found = 0;
  686.   int reg[4], shift_out = 0;
  687.   int c, c1, i, charset;
  688.  
  689.   reg[0] = CHARSET_ASCII, reg[1] = reg[2] = reg[3] = -1;
  690.   while (mask && src < src_end)
  691.     {
  692.       c = *src++;
  693.       switch (c)
  694.     {
  695.     case ISO_CODE_ESC:
  696.       if (src >= src_end)
  697.         break;
  698.       c = *src++;
  699.       if (c >= '(' && c <= '/')
  700.         {
  701.           /* Designation sequence for a charset of dimension 1.  */
  702.           if (src >= src_end)
  703.         break;
  704.           c1 = *src++;
  705.           if (c1 < ' ' || c1 >= 0x80
  706.           || (charset = iso_charset_table[0][c >= ','][c1]) < 0)
  707.         /* Invalid designation sequence.  Just ignore.  */
  708.         break;
  709.           reg[(c - '(') % 4] = charset;
  710.         }
  711.       else if (c == '$')
  712.         {
  713.           /* Designation sequence for a charset of dimension 2.  */
  714.           if (src >= src_end)
  715.         break;
  716.           c = *src++;
  717.           if (c >= '@' && c <= 'B')
  718.         /* Designation for JISX0208.1978, GB2312, or JISX0208.  */
  719.         reg[0] = charset = iso_charset_table[1][0][c];
  720.           else if (c >= '(' && c <= '/')
  721.         {
  722.           if (src >= src_end)
  723.             break;
  724.           c1 = *src++;
  725.           if (c1 < ' ' || c1 >= 0x80
  726.               || (charset = iso_charset_table[1][c >= ','][c1]) < 0)
  727.             /* Invalid designation sequence.  Just ignore.  */
  728.             break;
  729.           reg[(c - '(') % 4] = charset;
  730.         }
  731.           else
  732.         /* Invalid designation sequence.  Just ignore.  */
  733.         break;
  734.         }
  735.       else if (c == 'N' || c == 'n')
  736.         {
  737.           if (shift_out == 0
  738.           && (reg[1] >= 0
  739.               || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_7_ELSE)
  740.               || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_8_ELSE)))
  741.         {
  742.           /* Locking shift out.  */
  743.           mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
  744.           mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
  745.           shift_out = 1;
  746.         }
  747.           break;
  748.         }
  749.       else if (c == 'O' || c == 'o')
  750.         {
  751.           if (shift_out == 1)
  752.         {
  753.           /* Locking shift in.  */
  754.           mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
  755.           mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
  756.           shift_out = 0;
  757.         }
  758.           break;
  759.         }
  760.       else if (c == '0' || c == '1' || c == '2')
  761.         /* Start/end composition.  Just ignore.  */
  762.         break;
  763.       else
  764.         /* Invalid escape sequence.  Just ignore.  */
  765.         break;
  766.  
  767.       /* We found a valid designation sequence for CHARSET.  */
  768.       mask &= ~CODING_CATEGORY_MASK_ISO_8BIT;
  769.       if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7, charset))
  770.         mask_found |= CODING_CATEGORY_MASK_ISO_7;
  771.       else
  772.         mask &= ~CODING_CATEGORY_MASK_ISO_7;
  773.       if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_TIGHT, charset))
  774.         mask_found |= CODING_CATEGORY_MASK_ISO_7_TIGHT;
  775.       else
  776.         mask &= ~CODING_CATEGORY_MASK_ISO_7_TIGHT;
  777.       if (! CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_ELSE, charset))
  778.         mask &= ~CODING_CATEGORY_MASK_ISO_7_ELSE;
  779.       if (! CHARSET_OK (CODING_CATEGORY_IDX_ISO_8_ELSE, charset))
  780.         mask &= ~CODING_CATEGORY_MASK_ISO_8_ELSE;
  781.       break;
  782.  
  783.     case ISO_CODE_SO:
  784.       if (shift_out == 0
  785.           && (reg[1] >= 0
  786.           || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_7_ELSE)
  787.           || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_8_ELSE)))
  788.         {
  789.           /* Locking shift out.  */
  790.           mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
  791.           mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
  792.         }
  793.       break;
  794.       
  795.     case ISO_CODE_SI:
  796.       if (shift_out == 1)
  797.         {
  798.           /* Locking shift in.  */
  799.           mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
  800.           mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
  801.         }
  802.       break;
  803.  
  804.     case ISO_CODE_CSI:
  805.     case ISO_CODE_SS2:
  806.     case ISO_CODE_SS3:
  807.       {
  808.         int newmask = CODING_CATEGORY_MASK_ISO_8_ELSE;
  809.  
  810.         if (c != ISO_CODE_CSI)
  811.           {
  812.         if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_1]->flags
  813.             & CODING_FLAG_ISO_SINGLE_SHIFT)
  814.           newmask |= CODING_CATEGORY_MASK_ISO_8_1;
  815.         if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_2]->flags
  816.             & CODING_FLAG_ISO_SINGLE_SHIFT)
  817.           newmask |= CODING_CATEGORY_MASK_ISO_8_2;
  818.           }
  819.         if (VECTORP (Vlatin_extra_code_table)
  820.         && !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
  821.           {
  822.         if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_1]->flags
  823.             & CODING_FLAG_ISO_LATIN_EXTRA)
  824.           newmask |= CODING_CATEGORY_MASK_ISO_8_1;
  825.         if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_2]->flags
  826.             & CODING_FLAG_ISO_LATIN_EXTRA)
  827.           newmask |= CODING_CATEGORY_MASK_ISO_8_2;
  828.           }
  829.         mask &= newmask;
  830.         mask_found |= newmask;
  831.       }
  832.       break;
  833.  
  834.     default:
  835.       if (c < 0x80)
  836.         break;
  837.       else if (c < 0xA0)
  838.         {
  839.           if (VECTORP (Vlatin_extra_code_table)
  840.           && !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
  841.         {
  842.           int newmask = 0;
  843.  
  844.           if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_1]->flags
  845.               & CODING_FLAG_ISO_LATIN_EXTRA)
  846.             newmask |= CODING_CATEGORY_MASK_ISO_8_1;
  847.           if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_2]->flags
  848.               & CODING_FLAG_ISO_LATIN_EXTRA)
  849.             newmask |= CODING_CATEGORY_MASK_ISO_8_2;
  850.           mask &= newmask;
  851.           mask_found |= newmask;
  852.         }
  853.           else
  854.         return 0;
  855.         }
  856.       else
  857.         {
  858.           unsigned char *src_begin = src;
  859.  
  860.           mask &= ~(CODING_CATEGORY_MASK_ISO_7BIT
  861.             | CODING_CATEGORY_MASK_ISO_7_ELSE);
  862.           mask_found |= CODING_CATEGORY_MASK_ISO_8_1;
  863.           while (src < src_end && *src >= 0xA0)
  864.         src++;
  865.           if ((src - src_begin - 1) & 1 && src < src_end)
  866.         mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
  867.           else
  868.         mask_found |= CODING_CATEGORY_MASK_ISO_8_2;
  869.         }
  870.       break;
  871.     }
  872.     }
  873.  
  874.   return (mask & mask_found);
  875. }
  876.  
  877. /* Decode a character of which charset is CHARSET and the 1st position
  878.    code is C1.  If dimension of CHARSET is 2, the 2nd position code is
  879.    fetched from SRC and set to C2.  If CHARSET is negative, it means
  880.    that we are decoding ill formed text, and what we can do is just to
  881.    read C1 as is.  */
  882.  
  883. #define DECODE_ISO_CHARACTER(charset, c1)                \
  884.   do {                                    \
  885.     int c_alt, charset_alt = (charset);                    \
  886.     if (COMPOSING_HEAD_P (coding->composing))                \
  887.       {                                    \
  888.     *dst++ = LEADING_CODE_COMPOSITION;                \
  889.     if (COMPOSING_WITH_RULE_P (coding->composing))            \
  890.       /* To tell composition rules are embeded.  */            \
  891.       *dst++ = 0xFF;                        \
  892.     coding->composing += 2;                        \
  893.       }                                    \
  894.     if (charset_alt >= 0)                        \
  895.       {                                    \
  896.     if (CHARSET_DIMENSION (charset_alt) == 2)            \
  897.       {                                \
  898.         ONE_MORE_BYTE (c2);                        \
  899.         if (iso_code_class[(c2) & 0x7F] != ISO_0x20_or_0x7F        \
  900.         && iso_code_class[(c2) & 0x7F] != ISO_graphic_plane_0)    \
  901.           {                                \
  902.         src--;                            \
  903.         charset_alt = CHARSET_ASCII;                \
  904.           }                                \
  905.       }                                \
  906.     if (!NILP (translation_table)                    \
  907.         && ((c_alt = translate_char (translation_table,        \
  908.                      -1, charset_alt, c1, c2)) >= 0)) \
  909.       SPLIT_CHAR (c_alt, charset_alt, c1, c2);            \
  910.       }                                    \
  911.     if (charset_alt == CHARSET_ASCII || charset_alt < 0)        \
  912.       DECODE_CHARACTER_ASCII (c1);                    \
  913.     else if (CHARSET_DIMENSION (charset_alt) == 1)            \
  914.       DECODE_CHARACTER_DIMENSION1 (charset_alt, c1);            \
  915.     else                                \
  916.       DECODE_CHARACTER_DIMENSION2 (charset_alt, c1, c2);        \
  917.     if (COMPOSING_WITH_RULE_P (coding->composing))            \
  918.       /* To tell a composition rule follows.  */            \
  919.       coding->composing = COMPOSING_WITH_RULE_RULE;            \
  920.   } while (0)
  921.  
  922. /* Set designation state into CODING.  */
  923. #define DECODE_DESIGNATION(reg, dimension, chars, final_char)           \
  924.   do {                                       \
  925.     int charset = ISO_CHARSET_TABLE (make_number (dimension),           \
  926.                      make_number (chars),           \
  927.                      make_number (final_char));           \
  928.     if (charset >= 0                               \
  929.     && (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg \
  930.         || coding->safe_charsets[charset]))                   \
  931.       {                                       \
  932.     if (coding->spec.iso2022.last_invalid_designation_register == 0       \
  933.         && reg == 0                               \
  934.         && charset == CHARSET_ASCII)                   \
  935.       {                                   \
  936.         /* We should insert this designation sequence as is so       \
  937.                that it is surely written back to a file.  */           \
  938.         coding->spec.iso2022.last_invalid_designation_register = -1;   \
  939.         goto label_invalid_code;                       \
  940.       }                                   \
  941.     coding->spec.iso2022.last_invalid_designation_register = -1;       \
  942.         if ((coding->mode & CODING_MODE_DIRECTION)               \
  943.         && CHARSET_REVERSE_CHARSET (charset) >= 0)               \
  944.           charset = CHARSET_REVERSE_CHARSET (charset);               \
  945.         CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;           \
  946.       }                                       \
  947.     else                                   \
  948.       {                                       \
  949.     coding->spec.iso2022.last_invalid_designation_register = reg;       \
  950.     goto label_invalid_code;                       \
  951.       }                                       \
  952.   } while (0)
  953.  
  954. /* Check if the current composing sequence contains only valid codes.
  955.    If the composing sequence doesn't end before SRC_END, return -1.
  956.    Else, if it contains only valid codes, return 0.
  957.    Else return the length of the composing sequence.  */
  958.  
  959. int
  960. check_composing_code (coding, src, src_end)
  961.      struct coding_system *coding;
  962.      unsigned char *src, *src_end;
  963. {
  964.   unsigned char *src_start = src;
  965.   int invalid_code_found = 0;
  966.   int charset, c, c1, dim;
  967.  
  968.   while (src < src_end)
  969.     {
  970.       if (*src++ != ISO_CODE_ESC) continue;
  971.       if (src >= src_end) break;
  972.       if ((c = *src++) == '1') /* end of compsition */
  973.     return (invalid_code_found ? src - src_start : 0);
  974.       if (src + 2 >= src_end) break;
  975.       if (!coding->flags & CODING_FLAG_ISO_DESIGNATION)
  976.     invalid_code_found = 1;
  977.       else
  978.     {
  979.       dim = 0;
  980.       if (c == '$')
  981.         {
  982.           dim = 1;
  983.           c = (*src >= '@' && *src <= 'B') ? '(' : *src++;
  984.         }
  985.       if (c >= '(' && c <= '/')
  986.         {
  987.           c1 = *src++;
  988.           if ((c1 < ' ' || c1 >= 0x80)
  989.           || (charset = iso_charset_table[dim][c >= ','][c1]) < 0
  990.           || ! coding->safe_charsets[charset]
  991.           || (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
  992.               == CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
  993.         invalid_code_found = 1;
  994.         }
  995.       else
  996.         invalid_code_found = 1;
  997.     }
  998.     }
  999.   return (invalid_code_found
  1000.       ? src - src_start
  1001.       : (coding->mode & CODING_MODE_LAST_BLOCK ? 0 : -1));
  1002. }
  1003.  
  1004. /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
  1005.  
  1006. int
  1007. decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
  1008.      struct coding_system *coding;
  1009.      unsigned char *source, *destination;
  1010.      int src_bytes, dst_bytes;
  1011. {
  1012.   unsigned char *src = source;
  1013.   unsigned char *src_end = source + src_bytes;
  1014.   unsigned char *dst = destination;
  1015.   unsigned char *dst_end = destination + dst_bytes;
  1016.   /* Since the maximum bytes produced by each loop is 7, we subtract 6
  1017.      from DST_END to assure that overflow checking is necessary only
  1018.      at the head of loop.  */
  1019.   unsigned char *adjusted_dst_end = dst_end - 6;
  1020.   int charset;
  1021.   /* Charsets invoked to graphic plane 0 and 1 respectively.  */
  1022.   int charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1023.   int charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
  1024.   Lisp_Object translation_table
  1025.     = coding->translation_table_for_decode;
  1026.   int result = CODING_FINISH_NORMAL;
  1027.  
  1028.   if (!NILP (Venable_character_translation) && NILP (translation_table))
  1029.     translation_table = Vstandard_translation_table_for_decode;
  1030.  
  1031.   coding->produced_char = 0;
  1032.   coding->fake_multibyte = 0;
  1033.   while (src < src_end && (dst_bytes
  1034.                ? (dst < adjusted_dst_end)
  1035.                : (dst < src - 6)))
  1036.     {
  1037.       /* SRC_BASE remembers the start position in source in each loop.
  1038.      The loop will be exited when there's not enough source text
  1039.      to analyze long escape sequence or 2-byte code (within macros
  1040.      ONE_MORE_BYTE or TWO_MORE_BYTES).  In that case, SRC is reset
  1041.      to SRC_BASE before exiting.  */
  1042.       unsigned char *src_base = src;
  1043.       int c1 = *src++, c2;
  1044.  
  1045.       switch (iso_code_class [c1])
  1046.     {
  1047.     case ISO_0x20_or_0x7F:
  1048.       if (!coding->composing
  1049.           && (charset0 < 0 || CHARSET_CHARS (charset0) == 94))
  1050.         {
  1051.           /* This is SPACE or DEL.  */
  1052.           *dst++ = c1;
  1053.           coding->produced_char++;
  1054.           break;
  1055.         }
  1056.       /* This is a graphic character, we fall down ...  */
  1057.  
  1058.     case ISO_graphic_plane_0:
  1059.       if (coding->composing == COMPOSING_WITH_RULE_RULE)
  1060.         {
  1061.           /* This is a composition rule.  */
  1062.           *dst++ = c1 | 0x80;
  1063.           coding->composing = COMPOSING_WITH_RULE_TAIL;
  1064.         }
  1065.       else
  1066.         DECODE_ISO_CHARACTER (charset0, c1);
  1067.       break;
  1068.  
  1069.     case ISO_0xA0_or_0xFF:
  1070.       if (charset1 < 0 || CHARSET_CHARS (charset1) == 94
  1071.           || coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
  1072.         goto label_invalid_code;
  1073.       /* This is a graphic character, we fall down ... */
  1074.  
  1075.     case ISO_graphic_plane_1:
  1076.       if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
  1077.         goto label_invalid_code;
  1078.       else
  1079.         DECODE_ISO_CHARACTER (charset1, c1);
  1080.       break;
  1081.  
  1082.     case ISO_control_code:
  1083.       /* All ISO2022 control characters in this class have the
  1084.              same representation in Emacs internal format.  */
  1085.       if (c1 == '\n'
  1086.           && (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  1087.           && (coding->eol_type == CODING_EOL_CR
  1088.           || coding->eol_type == CODING_EOL_CRLF))
  1089.         {
  1090.           result = CODING_FINISH_INCONSISTENT_EOL;
  1091.           goto label_end_of_loop_2;
  1092.         }
  1093.       *dst++ = c1;
  1094.       coding->produced_char++;
  1095.       break;
  1096.  
  1097.     case ISO_carriage_return:
  1098.       if (coding->eol_type == CODING_EOL_CR)
  1099.         *dst++ = '\n';
  1100.       else if (coding->eol_type == CODING_EOL_CRLF)
  1101.         {
  1102.           ONE_MORE_BYTE (c1);
  1103.           if (c1 == ISO_CODE_LF)
  1104.         *dst++ = '\n';
  1105.           else
  1106.         {
  1107.           if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  1108.             {
  1109.               result = CODING_FINISH_INCONSISTENT_EOL;
  1110.               goto label_end_of_loop_2;
  1111.             }
  1112.           src--;
  1113.           *dst++ = '\r';
  1114.         }
  1115.         }
  1116.       else
  1117.         *dst++ = c1;
  1118.       coding->produced_char++;
  1119.       break;
  1120.  
  1121.     case ISO_shift_out:
  1122.       if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT)
  1123.           || CODING_SPEC_ISO_DESIGNATION (coding, 1) < 0)
  1124.         goto label_invalid_code;
  1125.       CODING_SPEC_ISO_INVOCATION (coding, 0) = 1;
  1126.       charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1127.       break;
  1128.  
  1129.     case ISO_shift_in:
  1130.       if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT))
  1131.         goto label_invalid_code;
  1132.       CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
  1133.       charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1134.       break;
  1135.  
  1136.     case ISO_single_shift_2_7:
  1137.     case ISO_single_shift_2:
  1138.       if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT))
  1139.         goto label_invalid_code;
  1140.       /* SS2 is handled as an escape sequence of ESC 'N' */
  1141.       c1 = 'N';
  1142.       goto label_escape_sequence;
  1143.  
  1144.     case ISO_single_shift_3:
  1145.       if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT))
  1146.         goto label_invalid_code;
  1147.       /* SS2 is handled as an escape sequence of ESC 'O' */
  1148.       c1 = 'O';
  1149.       goto label_escape_sequence;
  1150.  
  1151.     case ISO_control_sequence_introducer:
  1152.       /* CSI is handled as an escape sequence of ESC '[' ...  */
  1153.       c1 = '[';
  1154.       goto label_escape_sequence;
  1155.  
  1156.     case ISO_escape:
  1157.       ONE_MORE_BYTE (c1);
  1158.     label_escape_sequence:
  1159.       /* Escape sequences handled by Emacs are invocation,
  1160.          designation, direction specification, and character
  1161.          composition specification.  */
  1162.       switch (c1)
  1163.         {
  1164.         case '&':        /* revision of following character set */
  1165.           ONE_MORE_BYTE (c1);
  1166.           if (!(c1 >= '@' && c1 <= '~'))
  1167.         goto label_invalid_code;
  1168.           ONE_MORE_BYTE (c1);
  1169.           if (c1 != ISO_CODE_ESC)
  1170.         goto label_invalid_code;
  1171.           ONE_MORE_BYTE (c1);
  1172.           goto label_escape_sequence;
  1173.  
  1174.         case '$':        /* designation of 2-byte character set */
  1175.           if (! (coding->flags & CODING_FLAG_ISO_DESIGNATION))
  1176.         goto label_invalid_code;
  1177.           ONE_MORE_BYTE (c1);
  1178.           if (c1 >= '@' && c1 <= 'B')
  1179.         {    /* designation of JISX0208.1978, GB2312.1980,
  1180.                    or JISX0208.1980 */
  1181.           DECODE_DESIGNATION (0, 2, 94, c1);
  1182.         }
  1183.           else if (c1 >= 0x28 && c1 <= 0x2B)
  1184.         {    /* designation of DIMENSION2_CHARS94 character set */
  1185.           ONE_MORE_BYTE (c2);
  1186.           DECODE_DESIGNATION (c1 - 0x28, 2, 94, c2);
  1187.         }
  1188.           else if (c1 >= 0x2C && c1 <= 0x2F)
  1189.         {    /* designation of DIMENSION2_CHARS96 character set */
  1190.           ONE_MORE_BYTE (c2);
  1191.           DECODE_DESIGNATION (c1 - 0x2C, 2, 96, c2);
  1192.         }
  1193.           else
  1194.         goto label_invalid_code;
  1195.           break;
  1196.  
  1197.         case 'n':        /* invocation of locking-shift-2 */
  1198.           if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT)
  1199.           || CODING_SPEC_ISO_DESIGNATION (coding, 2) < 0)
  1200.         goto label_invalid_code;
  1201.           CODING_SPEC_ISO_INVOCATION (coding, 0) = 2;
  1202.           charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1203.           break;
  1204.  
  1205.         case 'o':        /* invocation of locking-shift-3 */
  1206.           if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT)
  1207.           || CODING_SPEC_ISO_DESIGNATION (coding, 3) < 0)
  1208.         goto label_invalid_code;
  1209.           CODING_SPEC_ISO_INVOCATION (coding, 0) = 3;
  1210.           charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1211.           break;
  1212.  
  1213.         case 'N':        /* invocation of single-shift-2 */
  1214.           if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
  1215.           || CODING_SPEC_ISO_DESIGNATION (coding, 2) < 0)
  1216.         goto label_invalid_code;
  1217.           ONE_MORE_BYTE (c1);
  1218.           charset = CODING_SPEC_ISO_DESIGNATION (coding, 2);
  1219.           DECODE_ISO_CHARACTER (charset, c1);
  1220.           break;
  1221.  
  1222.         case 'O':        /* invocation of single-shift-3 */
  1223.           if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
  1224.           || CODING_SPEC_ISO_DESIGNATION (coding, 3) < 0)
  1225.         goto label_invalid_code;
  1226.           ONE_MORE_BYTE (c1);
  1227.           charset = CODING_SPEC_ISO_DESIGNATION (coding, 3);
  1228.           DECODE_ISO_CHARACTER (charset, c1);
  1229.           break;
  1230.  
  1231.         case '0': case '2':    /* start composing */
  1232.           /* Before processing composing, we must be sure that all
  1233.          characters being composed are supported by CODING.
  1234.          If not, we must give up composing and insert the
  1235.          bunch of codes for composing as is without decoding.  */
  1236.           {
  1237.         int result1;
  1238.  
  1239.         result1 = check_composing_code (coding, src, src_end);
  1240.         if (result1 == 0)
  1241.           {
  1242.             coding->composing = (c1 == '0'
  1243.                      ? COMPOSING_NO_RULE_HEAD
  1244.                      : COMPOSING_WITH_RULE_HEAD);
  1245.             coding->produced_char++;
  1246.           }
  1247.         else if (result1 > 0)
  1248.           {
  1249.             if (result1 + 2 < (dst_bytes ? dst_end : src_base) - dst)
  1250.               {
  1251.             bcopy (src_base, dst, result1 + 2);
  1252.             src += result1;
  1253.             dst += result1 + 2;
  1254.             coding->produced_char += result1 + 2;
  1255.               }
  1256.             else
  1257.               {
  1258.             result = CODING_FINISH_INSUFFICIENT_DST;
  1259.             goto label_end_of_loop_2;
  1260.               }
  1261.           }
  1262.         else
  1263.           goto label_end_of_loop;
  1264.           }
  1265.           break;
  1266.  
  1267.         case '1':        /* end composing */
  1268.           coding->composing = COMPOSING_NO;
  1269.           break;
  1270.  
  1271.         case '[':        /* specification of direction */
  1272.           if (coding->flags & CODING_FLAG_ISO_NO_DIRECTION)
  1273.         goto label_invalid_code;
  1274.           /* For the moment, nested direction is not supported.
  1275.          So, `coding->mode & CODING_MODE_DIRECTION' zero means
  1276.          left-to-right, and nozero means right-to-left.  */
  1277.           ONE_MORE_BYTE (c1);
  1278.           switch (c1)
  1279.         {
  1280.         case ']':    /* end of the current direction */
  1281.           coding->mode &= ~CODING_MODE_DIRECTION;
  1282.  
  1283.         case '0':    /* end of the current direction */
  1284.         case '1':    /* start of left-to-right direction */
  1285.           ONE_MORE_BYTE (c1);
  1286.           if (c1 == ']')
  1287.             coding->mode &= ~CODING_MODE_DIRECTION;
  1288.           else
  1289.             goto label_invalid_code;
  1290.           break;
  1291.  
  1292.         case '2':    /* start of right-to-left direction */
  1293.           ONE_MORE_BYTE (c1);
  1294.           if (c1 == ']')
  1295.             coding->mode |= CODING_MODE_DIRECTION;
  1296.           else
  1297.             goto label_invalid_code;
  1298.           break;
  1299.  
  1300.         default:
  1301.           goto label_invalid_code;
  1302.         }
  1303.           break;
  1304.  
  1305.         default:
  1306.           if (! (coding->flags & CODING_FLAG_ISO_DESIGNATION))
  1307.         goto label_invalid_code;
  1308.           if (c1 >= 0x28 && c1 <= 0x2B)
  1309.         {    /* designation of DIMENSION1_CHARS94 character set */
  1310.           ONE_MORE_BYTE (c2);
  1311.           DECODE_DESIGNATION (c1 - 0x28, 1, 94, c2);
  1312.         }
  1313.           else if (c1 >= 0x2C && c1 <= 0x2F)
  1314.         {    /* designation of DIMENSION1_CHARS96 character set */
  1315.           ONE_MORE_BYTE (c2);
  1316.           DECODE_DESIGNATION (c1 - 0x2C, 1, 96, c2);
  1317.         }
  1318.           else
  1319.         {
  1320.           goto label_invalid_code;
  1321.         }
  1322.         }
  1323.       /* We must update these variables now.  */
  1324.       charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
  1325.       charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
  1326.       break;
  1327.  
  1328.     label_invalid_code:
  1329.       while (src_base < src)
  1330.         *dst++ = *src_base++;
  1331.       coding->fake_multibyte = 1;
  1332.     }
  1333.       continue;
  1334.  
  1335.     label_end_of_loop:
  1336.       result = CODING_FINISH_INSUFFICIENT_SRC;
  1337.     label_end_of_loop_2:
  1338.       src = src_base;
  1339.       break;
  1340.     }
  1341.  
  1342.   if (src < src_end)
  1343.     {
  1344.       if (result == CODING_FINISH_NORMAL)
  1345.     result = CODING_FINISH_INSUFFICIENT_DST;
  1346.       else if (result != CODING_FINISH_INCONSISTENT_EOL
  1347.            && coding->mode & CODING_MODE_LAST_BLOCK)
  1348.     {
  1349.       /* This is the last block of the text to be decoded.  We had
  1350.          better just flush out all remaining codes in the text
  1351.          although they are not valid characters.  */
  1352.       src_bytes = src_end - src;
  1353.       if (dst_bytes && (dst_end - dst < src_bytes))
  1354.         src_bytes = dst_end - dst;
  1355.       bcopy (src, dst, src_bytes);
  1356.       dst += src_bytes;
  1357.       src += src_bytes;
  1358.       coding->fake_multibyte = 1;
  1359.     }
  1360.     }
  1361.  
  1362.   coding->consumed = coding->consumed_char = src - source;
  1363.   coding->produced = dst - destination;
  1364.   return result;
  1365. }
  1366.  
  1367. /* ISO2022 encoding stuff.  */
  1368.  
  1369. /*
  1370.    It is not enough to say just "ISO2022" on encoding, we have to
  1371.    specify more details.  In Emacs, each coding system of ISO2022
  1372.    variant has the following specifications:
  1373.     1. Initial designation to G0 thru G3.
  1374.     2. Allows short-form designation?
  1375.     3. ASCII should be designated to G0 before control characters?
  1376.     4. ASCII should be designated to G0 at end of line?
  1377.     5. 7-bit environment or 8-bit environment?
  1378.     6. Use locking-shift?
  1379.     7. Use Single-shift?
  1380.    And the following two are only for Japanese:
  1381.     8. Use ASCII in place of JIS0201-1976-Roman?
  1382.     9. Use JISX0208-1983 in place of JISX0208-1978?
  1383.    These specifications are encoded in `coding->flags' as flag bits
  1384.    defined by macros CODING_FLAG_ISO_XXX.  See `coding.h' for more
  1385.    details.
  1386. */
  1387.  
  1388. /* Produce codes (escape sequence) for designating CHARSET to graphic
  1389.    register REG.  If <final-char> of CHARSET is '@', 'A', or 'B' and
  1390.    the coding system CODING allows, produce designation sequence of
  1391.    short-form.  */
  1392.  
  1393. #define ENCODE_DESIGNATION(charset, reg, coding)            \
  1394.   do {                                    \
  1395.     unsigned char final_char = CHARSET_ISO_FINAL_CHAR (charset);    \
  1396.     char *intermediate_char_94 = "()*+";                \
  1397.     char *intermediate_char_96 = ",-./";                \
  1398.     int revision = CODING_SPEC_ISO_REVISION_NUMBER(coding, charset);    \
  1399.     if (revision < 255)                            \
  1400.       {                                    \
  1401.     *dst++ = ISO_CODE_ESC;                        \
  1402.     *dst++ = '&';                            \
  1403.     *dst++ = '@' + revision;                    \
  1404.       }                                    \
  1405.     *dst++ = ISO_CODE_ESC;                               \
  1406.     if (CHARSET_DIMENSION (charset) == 1)                \
  1407.       {                                    \
  1408.     if (CHARSET_CHARS (charset) == 94)                \
  1409.       *dst++ = (unsigned char) (intermediate_char_94[reg]);        \
  1410.     else                                \
  1411.       *dst++ = (unsigned char) (intermediate_char_96[reg]);        \
  1412.       }                                    \
  1413.     else                                \
  1414.       {                                    \
  1415.     *dst++ = '$';                            \
  1416.     if (CHARSET_CHARS (charset) == 94)                \
  1417.       {                                \
  1418.         if (! (coding->flags & CODING_FLAG_ISO_SHORT_FORM)         \
  1419.         || reg != 0                               \
  1420.         || final_char < '@' || final_char > 'B')               \
  1421.           *dst++ = (unsigned char) (intermediate_char_94[reg]);    \
  1422.       }                                \
  1423.     else                                \
  1424.       *dst++ = (unsigned char) (intermediate_char_96[reg]);      \
  1425.       }                                    \
  1426.     *dst++ = final_char;                               \
  1427.     CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;        \
  1428.   } while (0)
  1429.  
  1430. /* The following two macros produce codes (control character or escape
  1431.    sequence) for ISO2022 single-shift functions (single-shift-2 and
  1432.    single-shift-3).  */
  1433.  
  1434. #define ENCODE_SINGLE_SHIFT_2                \
  1435.   do {                            \
  1436.     if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)    \
  1437.       *dst++ = ISO_CODE_ESC, *dst++ = 'N';        \
  1438.     else                        \
  1439.       {                            \
  1440.     *dst++ = ISO_CODE_SS2;                \
  1441.     coding->fake_multibyte = 1;            \
  1442.       }                            \
  1443.     CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;    \
  1444.   } while (0)
  1445.  
  1446. #define ENCODE_SINGLE_SHIFT_3                \
  1447.   do {                            \
  1448.     if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)    \
  1449.       *dst++ = ISO_CODE_ESC, *dst++ = 'O';        \
  1450.     else                        \
  1451.       {                            \
  1452.     *dst++ = ISO_CODE_SS3;                \
  1453.     coding->fake_multibyte = 1;            \
  1454.       }                            \
  1455.     CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;    \
  1456.   } while (0)
  1457.  
  1458. /* The following four macros produce codes (control character or
  1459.    escape sequence) for ISO2022 locking-shift functions (shift-in,
  1460.    shift-out, locking-shift-2, and locking-shift-3).  */
  1461.  
  1462. #define ENCODE_SHIFT_IN                  \
  1463.   do {                          \
  1464.     *dst++ = ISO_CODE_SI;              \
  1465.     CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;    \
  1466.   } while (0)
  1467.  
  1468. #define ENCODE_SHIFT_OUT              \
  1469.   do {                          \
  1470.     *dst++ = ISO_CODE_SO;              \
  1471.     CODING_SPEC_ISO_INVOCATION (coding, 0) = 1;    \
  1472.   } while (0)
  1473.  
  1474. #define ENCODE_LOCKING_SHIFT_2            \
  1475.   do {                        \
  1476.     *dst++ = ISO_CODE_ESC, *dst++ = 'n';    \
  1477.     CODING_SPEC_ISO_INVOCATION (coding, 0) = 2;    \
  1478.   } while (0)
  1479.  
  1480. #define ENCODE_LOCKING_SHIFT_3              \
  1481.   do {                          \
  1482.     *dst++ = ISO_CODE_ESC, *dst++ = 'o';      \
  1483.     CODING_SPEC_ISO_INVOCATION (coding, 0) = 3;    \
  1484.   } while (0)
  1485.  
  1486. /* Produce codes for a DIMENSION1 character whose character set is
  1487.    CHARSET and whose position-code is C1.  Designation and invocation
  1488.    sequences are also produced in advance if necessary.  */
  1489.  
  1490.  
  1491. #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1)            \
  1492.   do {                                    \
  1493.     if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))            \
  1494.       {                                    \
  1495.     if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)            \
  1496.       *dst++ = c1 & 0x7F;                        \
  1497.     else                                \
  1498.       *dst++ = c1 | 0x80;                        \
  1499.     CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;            \
  1500.     break;                                \
  1501.       }                                    \
  1502.     else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))    \
  1503.       {                                    \
  1504.     *dst++ = c1 & 0x7F;                        \
  1505.     break;                                \
  1506.       }                                    \
  1507.     else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))    \
  1508.       {                                    \
  1509.     *dst++ = c1 | 0x80;                        \
  1510.     break;                                \
  1511.       }                                    \
  1512.     else if (coding->flags & CODING_FLAG_ISO_SAFE            \
  1513.          && !coding->safe_charsets[charset])            \
  1514.       {                                    \
  1515.     /* We should not encode this character, instead produce one or    \
  1516.        two `?'s.  */                        \
  1517.     *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;            \
  1518.     if (CHARSET_WIDTH (charset) == 2)                \
  1519.       *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;        \
  1520.     break;                                \
  1521.       }                                    \
  1522.     else                                \
  1523.       /* Since CHARSET is not yet invoked to any graphic planes, we    \
  1524.      must invoke it, or, at first, designate it to some graphic    \
  1525.      register.  Then repeat the loop to actually produce the    \
  1526.      character.  */                            \
  1527.       dst = encode_invocation_designation (charset, coding, dst);    \
  1528.   } while (1)
  1529.  
  1530. /* Produce codes for a DIMENSION2 character whose character set is
  1531.    CHARSET and whose position-codes are C1 and C2.  Designation and
  1532.    invocation codes are also produced in advance if necessary.  */
  1533.  
  1534. #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2)        \
  1535.   do {                                    \
  1536.     if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))            \
  1537.       {                                    \
  1538.     if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)            \
  1539.       *dst++ = c1 & 0x7F, *dst++ = c2 & 0x7F;            \
  1540.     else                                \
  1541.       *dst++ = c1 | 0x80, *dst++ = c2 | 0x80;            \
  1542.     CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;            \
  1543.     break;                                \
  1544.       }                                    \
  1545.     else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))    \
  1546.       {                                    \
  1547.     *dst++ = c1 & 0x7F, *dst++= c2 & 0x7F;                \
  1548.     break;                                \
  1549.       }                                    \
  1550.     else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))    \
  1551.       {                                    \
  1552.     *dst++ = c1 | 0x80, *dst++= c2 | 0x80;                \
  1553.     break;                                \
  1554.       }                                    \
  1555.     else if (coding->flags & CODING_FLAG_ISO_SAFE            \
  1556.          && !coding->safe_charsets[charset])            \
  1557.       {                                    \
  1558.     /* We should not encode this character, instead produce one or    \
  1559.        two `?'s.  */                        \
  1560.     *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;            \
  1561.     if (CHARSET_WIDTH (charset) == 2)                \
  1562.       *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;        \
  1563.     break;                                \
  1564.       }                                    \
  1565.     else                                \
  1566.       /* Since CHARSET is not yet invoked to any graphic planes, we    \
  1567.      must invoke it, or, at first, designate it to some graphic    \
  1568.      register.  Then repeat the loop to actually produce the    \
  1569.      character.  */                            \
  1570.       dst = encode_invocation_designation (charset, coding, dst);    \
  1571.   } while (1)
  1572.  
  1573. #define ENCODE_ISO_CHARACTER(charset, c1, c2)            \
  1574.   do {                                \
  1575.     int c_alt, charset_alt;                    \
  1576.     if (!NILP (translation_table)                \
  1577.     && ((c_alt = translate_char (translation_table, -1,    \
  1578.                      charset, c1, c2))        \
  1579.         >= 0))                        \
  1580.       SPLIT_CHAR (c_alt, charset_alt, c1, c2);            \
  1581.     else                            \
  1582.       charset_alt = charset;                    \
  1583.     if (CHARSET_DIMENSION (charset_alt) == 1)            \
  1584.       {                                \
  1585.     if (charset == CHARSET_ASCII                \
  1586.         && coding->flags & CODING_FLAG_ISO_USE_ROMAN)    \
  1587.       charset_alt = charset_latin_jisx0201;            \
  1588.     ENCODE_ISO_CHARACTER_DIMENSION1 (charset_alt, c1);    \
  1589.       }                                \
  1590.     else                            \
  1591.       {                                \
  1592.     if (charset == charset_jisx0208                \
  1593.         && coding->flags & CODING_FLAG_ISO_USE_OLDJIS)    \
  1594.       charset_alt = charset_jisx0208_1978;            \
  1595.     ENCODE_ISO_CHARACTER_DIMENSION2 (charset_alt, c1, c2);    \
  1596.       }                                \
  1597.     if (! COMPOSING_P (coding->composing))            \
  1598.       coding->consumed_char++;                    \
  1599.   } while (0)
  1600.  
  1601. /* Produce designation and invocation codes at a place pointed by DST
  1602.    to use CHARSET.  The element `spec.iso2022' of *CODING is updated.
  1603.    Return new DST.  */
  1604.  
  1605. unsigned char *
  1606. encode_invocation_designation (charset, coding, dst)
  1607.      int charset;
  1608.      struct coding_system *coding;
  1609.      unsigned char *dst;
  1610. {
  1611.   int reg;            /* graphic register number */
  1612.  
  1613.   /* At first, check designations.  */
  1614.   for (reg = 0; reg < 4; reg++)
  1615.     if (charset == CODING_SPEC_ISO_DESIGNATION (coding, reg))
  1616.       break;
  1617.  
  1618.   if (reg >= 4)
  1619.     {
  1620.       /* CHARSET is not yet designated to any graphic registers.  */
  1621.       /* At first check the requested designation.  */
  1622.       reg = CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset);
  1623.       if (reg == CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)
  1624.     /* Since CHARSET requests no special designation, designate it
  1625.        to graphic register 0.  */
  1626.     reg = 0;
  1627.  
  1628.       ENCODE_DESIGNATION (charset, reg, coding);
  1629.     }
  1630.  
  1631.   if (CODING_SPEC_ISO_INVOCATION (coding, 0) != reg
  1632.       && CODING_SPEC_ISO_INVOCATION (coding, 1) != reg)
  1633.     {
  1634.       /* Since the graphic register REG is not invoked to any graphic
  1635.      planes, invoke it to graphic plane 0.  */
  1636.       switch (reg)
  1637.     {
  1638.     case 0:            /* graphic register 0 */
  1639.       ENCODE_SHIFT_IN;
  1640.       break;
  1641.  
  1642.     case 1:            /* graphic register 1 */
  1643.       ENCODE_SHIFT_OUT;
  1644.       break;
  1645.  
  1646.     case 2:            /* graphic register 2 */
  1647.       if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
  1648.         ENCODE_SINGLE_SHIFT_2;
  1649.       else
  1650.         ENCODE_LOCKING_SHIFT_2;
  1651.       break;
  1652.  
  1653.     case 3:            /* graphic register 3 */
  1654.       if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
  1655.         ENCODE_SINGLE_SHIFT_3;
  1656.       else
  1657.         ENCODE_LOCKING_SHIFT_3;
  1658.       break;
  1659.     }
  1660.     }
  1661.   return dst;
  1662. }
  1663.  
  1664. /* The following two macros produce codes for indicating composition.  */
  1665. #define ENCODE_COMPOSITION_NO_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '0'
  1666. #define ENCODE_COMPOSITION_WITH_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '2'
  1667. #define ENCODE_COMPOSITION_END    *dst++ = ISO_CODE_ESC, *dst++ = '1'
  1668.  
  1669. /* The following three macros produce codes for indicating direction
  1670.    of text.  */
  1671. #define ENCODE_CONTROL_SEQUENCE_INTRODUCER            \
  1672.   do {                                \
  1673.     if (coding->flags == CODING_FLAG_ISO_SEVEN_BITS)    \
  1674.       *dst++ = ISO_CODE_ESC, *dst++ = '[';            \
  1675.     else                            \
  1676.       *dst++ = ISO_CODE_CSI;                    \
  1677.   } while (0)
  1678.  
  1679. #define ENCODE_DIRECTION_R2L    \
  1680.   ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '2', *dst++ = ']'
  1681.  
  1682. #define ENCODE_DIRECTION_L2R    \
  1683.   ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '0', *dst++ = ']'
  1684.  
  1685. /* Produce codes for designation and invocation to reset the graphic
  1686.    planes and registers to initial state.  */
  1687. #define ENCODE_RESET_PLANE_AND_REGISTER                        \
  1688.   do {                                        \
  1689.     int reg;                                    \
  1690.     if (CODING_SPEC_ISO_INVOCATION (coding, 0) != 0)                \
  1691.       ENCODE_SHIFT_IN;                                \
  1692.     for (reg = 0; reg < 4; reg++)                        \
  1693.       if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg) >= 0        \
  1694.       && (CODING_SPEC_ISO_DESIGNATION (coding, reg)                \
  1695.           != CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg)))        \
  1696.     ENCODE_DESIGNATION                            \
  1697.       (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg), reg, coding); \
  1698.   } while (0)
  1699.  
  1700. /* Produce designation sequences of charsets in the line started from
  1701.    SRC to a place pointed by *DSTP, and update DSTP.
  1702.  
  1703.    If the current block ends before any end-of-line, we may fail to
  1704.    find all the necessary designations.  */
  1705.  
  1706. void
  1707. encode_designation_at_bol (coding, table, src, src_end, dstp)
  1708.      struct coding_system *coding;
  1709.      Lisp_Object table;
  1710.      unsigned char *src, *src_end, **dstp;
  1711. {
  1712.   int charset, c, found = 0, reg;
  1713.   /* Table of charsets to be designated to each graphic register.  */
  1714.   int r[4];
  1715.   unsigned char *dst = *dstp;
  1716.  
  1717.   for (reg = 0; reg < 4; reg++)
  1718.     r[reg] = -1;
  1719.  
  1720.   while (src < src_end && *src != '\n' && found < 4)
  1721.     {
  1722.       int bytes = BYTES_BY_CHAR_HEAD (*src);
  1723.       
  1724.       if (NILP (table))
  1725.     charset = CHARSET_AT (src);
  1726.       else
  1727.     {
  1728.       int c_alt;
  1729.       unsigned char c1, c2;
  1730.  
  1731.       SPLIT_STRING(src, bytes, charset, c1, c2);
  1732.       if ((c_alt = translate_char (table, -1, charset, c1, c2)) >= 0)
  1733.         charset = CHAR_CHARSET (c_alt);
  1734.     }
  1735.  
  1736.       reg = CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset);
  1737.       if (reg != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION && r[reg] < 0)
  1738.     {
  1739.       found++;
  1740.       r[reg] = charset;
  1741.     }
  1742.  
  1743.       src += bytes;
  1744.     }
  1745.  
  1746.   if (found)
  1747.     {
  1748.       for (reg = 0; reg < 4; reg++)
  1749.     if (r[reg] >= 0
  1750.         && CODING_SPEC_ISO_DESIGNATION (coding, reg) != r[reg])
  1751.       ENCODE_DESIGNATION (r[reg], reg, coding);
  1752.       *dstp = dst;
  1753.     }
  1754. }
  1755.  
  1756. /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".  */
  1757.  
  1758. int
  1759. encode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
  1760.      struct coding_system *coding;
  1761.      unsigned char *source, *destination;
  1762.      int src_bytes, dst_bytes;
  1763. {
  1764.   unsigned char *src = source;
  1765.   unsigned char *src_end = source + src_bytes;
  1766.   unsigned char *dst = destination;
  1767.   unsigned char *dst_end = destination + dst_bytes;
  1768.   /* Since the maximum bytes produced by each loop is 20, we subtract 19
  1769.      from DST_END to assure overflow checking is necessary only at the
  1770.      head of loop.  */
  1771.   unsigned char *adjusted_dst_end = dst_end - 19;
  1772.   Lisp_Object translation_table
  1773.       = coding->translation_table_for_encode;
  1774.   int result = CODING_FINISH_NORMAL;
  1775.  
  1776.   if (!NILP (Venable_character_translation) && NILP (translation_table))
  1777.     translation_table = Vstandard_translation_table_for_encode;
  1778.  
  1779.   coding->consumed_char = 0;
  1780.   coding->fake_multibyte = 0;
  1781.   while (src < src_end && (dst_bytes
  1782.                ? (dst < adjusted_dst_end)
  1783.                : (dst < src - 19)))
  1784.     {
  1785.       /* SRC_BASE remembers the start position in source in each loop.
  1786.      The loop will be exited when there's not enough source text
  1787.      to analyze multi-byte codes (within macros ONE_MORE_BYTE,
  1788.      TWO_MORE_BYTES, and THREE_MORE_BYTES).  In that case, SRC is
  1789.      reset to SRC_BASE before exiting.  */
  1790.       unsigned char *src_base = src;
  1791.       int charset, c1, c2, c3, c4;
  1792.  
  1793.       if (coding->flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL
  1794.       && CODING_SPEC_ISO_BOL (coding))
  1795.     {
  1796.       /* We have to produce designation sequences if any now.  */
  1797.       encode_designation_at_bol (coding, translation_table,
  1798.                      src, src_end, &dst);
  1799.       CODING_SPEC_ISO_BOL (coding) = 0;
  1800.     }
  1801.  
  1802.       c1 = *src++;
  1803.       /* If we are seeing a component of a composite character, we are
  1804.      seeing a leading-code encoded irregularly for composition, or
  1805.      a composition rule if composing with rule.  We must set C1 to
  1806.      a normal leading-code or an ASCII code.  If we are not seeing
  1807.      a composite character, we must reset composition,
  1808.      designation, and invocation states.  */
  1809.       if (COMPOSING_P (coding->composing))
  1810.     {
  1811.       if (c1 < 0xA0)
  1812.         {
  1813.           /* We are not in a composite character any longer.  */
  1814.           coding->composing = COMPOSING_NO;
  1815.           ENCODE_RESET_PLANE_AND_REGISTER;
  1816.           ENCODE_COMPOSITION_END;
  1817.         }
  1818.       else
  1819.         {
  1820.           if (coding->composing == COMPOSING_WITH_RULE_RULE)
  1821.         {
  1822.           *dst++ = c1 & 0x7F;
  1823.           coding->composing = COMPOSING_WITH_RULE_HEAD;
  1824.           continue;
  1825.         }
  1826.           else if (coding->composing == COMPOSING_WITH_RULE_HEAD)
  1827.         coding->composing = COMPOSING_WITH_RULE_RULE;
  1828.           if (c1 == 0xA0)
  1829.         {
  1830.           /* This is an ASCII component.  */
  1831.           ONE_MORE_BYTE (c1);
  1832.           c1 &= 0x7F;
  1833.         }
  1834.           else
  1835.         /* This is a leading-code of non ASCII component.  */
  1836.         c1 -= 0x20;
  1837.         }
  1838.     }
  1839.     
  1840.       /* Now encode one character.  C1 is a control character, an
  1841.          ASCII character, or a leading-code of multi-byte character.  */
  1842.       switch (emacs_code_class[c1])
  1843.     {
  1844.     case EMACS_ascii_code:
  1845.       ENCODE_ISO_CHARACTER (CHARSET_ASCII, c1, /* dummy */ c2);
  1846.       break;
  1847.  
  1848.     case EMACS_control_code:
  1849.       if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
  1850.         ENCODE_RESET_PLANE_AND_REGISTER;
  1851.       *dst++ = c1;
  1852.       coding->consumed_char++;
  1853.       break;
  1854.  
  1855.     case EMACS_carriage_return_code:
  1856.       if (! (coding->mode & CODING_MODE_SELECTIVE_DISPLAY))
  1857.         {
  1858.           if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
  1859.         ENCODE_RESET_PLANE_AND_REGISTER;
  1860.           *dst++ = c1;
  1861.           coding->consumed_char++;
  1862.           break;
  1863.         }
  1864.       /* fall down to treat '\r' as '\n' ...  */
  1865.  
  1866.     case EMACS_linefeed_code:
  1867.       if (coding->flags & CODING_FLAG_ISO_RESET_AT_EOL)
  1868.         ENCODE_RESET_PLANE_AND_REGISTER;
  1869.       if (coding->flags & CODING_FLAG_ISO_INIT_AT_BOL)
  1870.         bcopy (coding->spec.iso2022.initial_designation,
  1871.            coding->spec.iso2022.current_designation,
  1872.            sizeof coding->spec.iso2022.initial_designation);
  1873.       if (coding->eol_type == CODING_EOL_LF
  1874.           || coding->eol_type == CODING_EOL_UNDECIDED)
  1875.         *dst++ = ISO_CODE_LF;
  1876.       else if (coding->eol_type == CODING_EOL_CRLF)
  1877.         *dst++ = ISO_CODE_CR, *dst++ = ISO_CODE_LF;
  1878.       else
  1879.         *dst++ = ISO_CODE_CR;
  1880.       CODING_SPEC_ISO_BOL (coding) = 1;
  1881.       coding->consumed_char++;
  1882.       break;
  1883.  
  1884.     case EMACS_leading_code_2:
  1885.       ONE_MORE_BYTE (c2);
  1886.       if (c2 < 0xA0)
  1887.         {
  1888.           /* invalid sequence */
  1889.           *dst++ = c1;
  1890.           src--;
  1891.           coding->consumed_char++;
  1892.         }
  1893.       else
  1894.         ENCODE_ISO_CHARACTER (c1, c2, /* dummy */ c3);
  1895.       break;
  1896.  
  1897.     case EMACS_leading_code_3:
  1898.       TWO_MORE_BYTES (c2, c3);
  1899.       if (c2 < 0xA0 || c3 < 0xA0)
  1900.         {
  1901.           /* invalid sequence */
  1902.           *dst++ = c1;
  1903.           src -= 2;
  1904.           coding->consumed_char++;
  1905.         }
  1906.       else if (c1 < LEADING_CODE_PRIVATE_11)
  1907.         ENCODE_ISO_CHARACTER (c1, c2, c3);
  1908.       else
  1909.         ENCODE_ISO_CHARACTER (c2, c3, /* dummy */ c4);
  1910.       break;
  1911.  
  1912.     case EMACS_leading_code_4:
  1913.       THREE_MORE_BYTES (c2, c3, c4);
  1914.       if (c2 < 0xA0 || c3 < 0xA0 || c4 < 0xA0)
  1915.         {
  1916.           /* invalid sequence */
  1917.           *dst++ = c1;
  1918.           src -= 3;
  1919.           coding->consumed_char++;
  1920.         }
  1921.       else
  1922.         ENCODE_ISO_CHARACTER (c2, c3, c4);
  1923.       break;
  1924.  
  1925.     case EMACS_leading_code_composition:
  1926.       ONE_MORE_BYTE (c2);
  1927.       if (c2 < 0xA0)
  1928.         {
  1929.           /* invalid sequence */
  1930.           *dst++ = c1;
  1931.           src--;
  1932.           coding->consumed_char++;
  1933.         }
  1934.       else if (c2 == 0xFF)
  1935.         {
  1936.           ENCODE_RESET_PLANE_AND_REGISTER;
  1937.           coding->composing = COMPOSING_WITH_RULE_HEAD;
  1938.           ENCODE_COMPOSITION_WITH_RULE_START;
  1939.           coding->consumed_char++;
  1940.         }
  1941.       else
  1942.         {
  1943.           ENCODE_RESET_PLANE_AND_REGISTER;
  1944.           /* Rewind one byte because it is a character code of
  1945.                  composition elements.  */
  1946.           src--;
  1947.           coding->composing = COMPOSING_NO_RULE_HEAD;
  1948.           ENCODE_COMPOSITION_NO_RULE_START;
  1949.           coding->consumed_char++;
  1950.         }
  1951.       break;
  1952.  
  1953.     case EMACS_invalid_code:
  1954.       *dst++ = c1;
  1955.       coding->consumed_char++;
  1956.       break;
  1957.     }
  1958.       continue;
  1959.     label_end_of_loop:
  1960.       result = CODING_FINISH_INSUFFICIENT_SRC;
  1961.       src = src_base;
  1962.       break;
  1963.     }
  1964.  
  1965.   if (src < src_end && result == CODING_FINISH_NORMAL)
  1966.     result = CODING_FINISH_INSUFFICIENT_DST;
  1967.  
  1968.   /* If this is the last block of the text to be encoded, we must
  1969.      reset graphic planes and registers to the initial state, and
  1970.      flush out the carryover if any.  */
  1971.   if (coding->mode & CODING_MODE_LAST_BLOCK)
  1972.     {
  1973.       ENCODE_RESET_PLANE_AND_REGISTER;
  1974.       if (COMPOSING_P (coding->composing))
  1975.     ENCODE_COMPOSITION_END;
  1976.     }
  1977.   coding->consumed = src - source;
  1978.   coding->produced = coding->produced_char = dst - destination;
  1979.   return result;
  1980. }
  1981.  
  1982.  
  1983. /*** 4. SJIS and BIG5 handlers ***/
  1984.  
  1985. /* Although SJIS and BIG5 are not ISO's coding system, they are used
  1986.    quite widely.  So, for the moment, Emacs supports them in the bare
  1987.    C code.  But, in the future, they may be supported only by CCL.  */
  1988.  
  1989. /* SJIS is a coding system encoding three character sets: ASCII, right
  1990.    half of JISX0201-Kana, and JISX0208.  An ASCII character is encoded
  1991.    as is.  A character of charset katakana-jisx0201 is encoded by
  1992.    "position-code + 0x80".  A character of charset japanese-jisx0208
  1993.    is encoded in 2-byte but two position-codes are divided and shifted
  1994.    so that it fit in the range below.
  1995.  
  1996.    --- CODE RANGE of SJIS ---
  1997.    (character set)    (range)
  1998.    ASCII        0x00 .. 0x7F
  1999.    KATAKANA-JISX0201    0xA0 .. 0xDF
  2000.    JISX0208 (1st byte)    0x80 .. 0x9F and 0xE0 .. 0xEF
  2001.         (2nd byte)    0x40 .. 0xFF
  2002.    -------------------------------
  2003.  
  2004. */
  2005.  
  2006. /* BIG5 is a coding system encoding two character sets: ASCII and
  2007.    Big5.  An ASCII character is encoded as is.  Big5 is a two-byte
  2008.    character set and is encoded in two-byte.
  2009.  
  2010.    --- CODE RANGE of BIG5 ---
  2011.    (character set)    (range)
  2012.    ASCII        0x00 .. 0x7F
  2013.    Big5 (1st byte)    0xA1 .. 0xFE
  2014.     (2nd byte)    0x40 .. 0x7E and 0xA1 .. 0xFE
  2015.    --------------------------
  2016.  
  2017.    Since the number of characters in Big5 is larger than maximum
  2018.    characters in Emacs' charset (96x96), it can't be handled as one
  2019.    charset.  So, in Emacs, Big5 is divided into two: `charset-big5-1'
  2020.    and `charset-big5-2'.  Both are DIMENSION2 and CHARS94.  The former
  2021.    contains frequently used characters and the latter contains less
  2022.    frequently used characters.  */
  2023.  
  2024. /* Macros to decode or encode a character of Big5 in BIG5.  B1 and B2
  2025.    are the 1st and 2nd position-codes of Big5 in BIG5 coding system.
  2026.    C1 and C2 are the 1st and 2nd position-codes of of Emacs' internal
  2027.    format.  CHARSET is `charset_big5_1' or `charset_big5_2'.  */
  2028.  
  2029. /* Number of Big5 characters which have the same code in 1st byte.  */
  2030. #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
  2031.  
  2032. #define DECODE_BIG5(b1, b2, charset, c1, c2)                     \
  2033.   do {                                         \
  2034.     unsigned int temp                                 \
  2035.       = (b1 - 0xA1) * BIG5_SAME_ROW + b2 - (b2 < 0x7F ? 0x40 : 0x62);    \
  2036.     if (b1 < 0xC9)                                 \
  2037.       charset = charset_big5_1;                             \
  2038.     else                                     \
  2039.       {                                         \
  2040.     charset = charset_big5_2;                         \
  2041.     temp -= (0xC9 - 0xA1) * BIG5_SAME_ROW;                     \
  2042.       }                                         \
  2043.     c1 = temp / (0xFF - 0xA1) + 0x21;                         \
  2044.     c2 = temp % (0xFF - 0xA1) + 0x21;                         \
  2045.   } while (0)
  2046.  
  2047. #define ENCODE_BIG5(charset, c1, c2, b1, b2)                  \
  2048.   do {                                      \
  2049.     unsigned int temp = (c1 - 0x21) * (0xFF - 0xA1) + (c2 - 0x21);    \
  2050.     if (charset == charset_big5_2)                      \
  2051.       temp += BIG5_SAME_ROW * (0xC9 - 0xA1);                  \
  2052.     b1 = temp / BIG5_SAME_ROW + 0xA1;                      \
  2053.     b2 = temp % BIG5_SAME_ROW;                          \
  2054.     b2 += b2 < 0x3F ? 0x40 : 0x62;                      \
  2055.   } while (0)
  2056.  
  2057. #define DECODE_SJIS_BIG5_CHARACTER(charset, c1, c2)            \
  2058.   do {                                    \
  2059.     int c_alt, charset_alt = (charset);                    \
  2060.     if (!NILP (translation_table)                    \
  2061.     && ((c_alt = translate_char (translation_table,            \
  2062.                      -1, (charset), c1, c2)) >= 0))    \
  2063.       SPLIT_CHAR (c_alt, charset_alt, c1, c2);            \
  2064.     if (charset_alt == CHARSET_ASCII || charset_alt < 0)        \
  2065.       DECODE_CHARACTER_ASCII (c1);                    \
  2066.     else if (CHARSET_DIMENSION (charset_alt) == 1)            \
  2067.       DECODE_CHARACTER_DIMENSION1 (charset_alt, c1);            \
  2068.     else                                \
  2069.       DECODE_CHARACTER_DIMENSION2 (charset_alt, c1, c2);        \
  2070.   } while (0)
  2071.  
  2072. #define ENCODE_SJIS_BIG5_CHARACTER(charset, c1, c2)        \
  2073.   do {                                \
  2074.     int c_alt, charset_alt;                    \
  2075.     if (!NILP (translation_table)                \
  2076.     && ((c_alt = translate_char (translation_table, -1,    \
  2077.                      charset, c1, c2))        \
  2078.         >= 0))                        \
  2079.       SPLIT_CHAR (c_alt, charset_alt, c1, c2);            \
  2080.     else                            \
  2081.       charset_alt = charset;                    \
  2082.     if (charset_alt == charset_ascii)                \
  2083.       *dst++ = c1;                        \
  2084.     else if (CHARSET_DIMENSION (charset_alt) == 1)        \
  2085.       {                                \
  2086.     if (sjis_p && charset_alt == charset_katakana_jisx0201)    \
  2087.       *dst++ = c1;                        \
  2088.     else                            \
  2089.       {                            \
  2090.         *dst++ = charset_alt, *dst++ = c1;            \
  2091.         coding->fake_multibyte = 1;                \
  2092.       }                            \
  2093.       }                                \
  2094.     else                            \
  2095.       {                                \
  2096.     c1 &= 0x7F, c2 &= 0x7F;                    \
  2097.     if (sjis_p && charset_alt == charset_jisx0208)        \
  2098.       {                            \
  2099.         unsigned char s1, s2;                \
  2100.                                     \
  2101.         ENCODE_SJIS (c1, c2, s1, s2);            \
  2102.         *dst++ = s1, *dst++ = s2;                \
  2103.         coding->fake_multibyte = 1;                \
  2104.       }                            \
  2105.     else if (!sjis_p                    \
  2106.          && (charset_alt == charset_big5_1        \
  2107.              || charset_alt == charset_big5_2))        \
  2108.       {                            \
  2109.         unsigned char b1, b2;                \
  2110.                                     \
  2111.         ENCODE_BIG5 (charset_alt, c1, c2, b1, b2);        \
  2112.         *dst++ = b1, *dst++ = b2;                \
  2113.       }                            \
  2114.     else                            \
  2115.       {                            \
  2116.         *dst++ = charset_alt, *dst++ = c1, *dst++ = c2;    \
  2117.         coding->fake_multibyte = 1;                \
  2118.       }                            \
  2119.       }                                \
  2120.     coding->consumed_char++;                    \
  2121.   } while (0);
  2122.  
  2123. /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
  2124.    Check if a text is encoded in SJIS.  If it is, return
  2125.    CODING_CATEGORY_MASK_SJIS, else return 0.  */
  2126.  
  2127. int
  2128. detect_coding_sjis (src, src_end)
  2129.      unsigned char *src, *src_end;
  2130. {
  2131.   unsigned char c;
  2132.  
  2133.   while (src < src_end)
  2134.     {
  2135.       c = *src++;
  2136.       if ((c >= 0x80 && c < 0xA0) || c >= 0xE0)
  2137.     {
  2138.       if (src < src_end && *src++ < 0x40)
  2139.         return 0;
  2140.     }
  2141.     }
  2142.   return CODING_CATEGORY_MASK_SJIS;
  2143. }
  2144.  
  2145. /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
  2146.    Check if a text is encoded in BIG5.  If it is, return
  2147.    CODING_CATEGORY_MASK_BIG5, else return 0.  */
  2148.  
  2149. int
  2150. detect_coding_big5 (src, src_end)
  2151.      unsigned char *src, *src_end;
  2152. {
  2153.   unsigned char c;
  2154.  
  2155.   while (src < src_end)
  2156.     {
  2157.       c = *src++;
  2158.       if (c >= 0xA1)
  2159.     {
  2160.       if (src >= src_end)
  2161.         break;
  2162.       c = *src++;
  2163.       if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
  2164.         return 0;
  2165.     }
  2166.     }
  2167.   return CODING_CATEGORY_MASK_BIG5;
  2168. }
  2169.  
  2170. /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
  2171.    If SJIS_P is 1, decode SJIS text, else decode BIG5 test.  */
  2172.  
  2173. int
  2174. decode_coding_sjis_big5 (coding, source, destination,
  2175.              src_bytes, dst_bytes, sjis_p)
  2176.      struct coding_system *coding;
  2177.      unsigned char *source, *destination;
  2178.      int src_bytes, dst_bytes;
  2179.      int sjis_p;
  2180. {
  2181.   unsigned char *src = source;
  2182.   unsigned char *src_end = source + src_bytes;
  2183.   unsigned char *dst = destination;
  2184.   unsigned char *dst_end = destination + dst_bytes;
  2185.   /* Since the maximum bytes produced by each loop is 4, we subtract 3
  2186.      from DST_END to assure overflow checking is necessary only at the
  2187.      head of loop.  */
  2188.   unsigned char *adjusted_dst_end = dst_end - 3;
  2189.   Lisp_Object translation_table
  2190.       = coding->translation_table_for_decode;
  2191.   int result = CODING_FINISH_NORMAL;
  2192.  
  2193.   if (!NILP (Venable_character_translation) && NILP (translation_table))
  2194.     translation_table = Vstandard_translation_table_for_decode;
  2195.  
  2196.   coding->produced_char = 0;
  2197.   coding->fake_multibyte = 0;
  2198.   while (src < src_end && (dst_bytes
  2199.                ? (dst < adjusted_dst_end)
  2200.                : (dst < src - 3)))
  2201.     {
  2202.       /* SRC_BASE remembers the start position in source in each loop.
  2203.      The loop will be exited when there's not enough source text
  2204.      to analyze two-byte character (within macro ONE_MORE_BYTE).
  2205.      In that case, SRC is reset to SRC_BASE before exiting.  */
  2206.       unsigned char *src_base = src;
  2207.       unsigned char c1 = *src++, c2, c3, c4;
  2208.  
  2209.       if (c1 < 0x20)
  2210.     {
  2211.       if (c1 == '\r')
  2212.         {
  2213.           if (coding->eol_type == CODING_EOL_CRLF)
  2214.         {
  2215.           ONE_MORE_BYTE (c2);
  2216.           if (c2 == '\n')
  2217.             *dst++ = c2;
  2218.           else if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  2219.             {
  2220.               result = CODING_FINISH_INCONSISTENT_EOL;
  2221.               goto label_end_of_loop_2;
  2222.             }
  2223.           else
  2224.             /* To process C2 again, SRC is subtracted by 1.  */
  2225.             *dst++ = c1, src--;
  2226.         }
  2227.           else if (coding->eol_type == CODING_EOL_CR)
  2228.         *dst++ = '\n';
  2229.           else
  2230.         *dst++ = c1;
  2231.         }
  2232.       else if (c1 == '\n'
  2233.            && (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  2234.            && (coding->eol_type == CODING_EOL_CR
  2235.                || coding->eol_type == CODING_EOL_CRLF))
  2236.         {
  2237.           result = CODING_FINISH_INCONSISTENT_EOL;
  2238.           goto label_end_of_loop_2;
  2239.         }
  2240.       else
  2241.         *dst++ = c1;
  2242.       coding->produced_char++;
  2243.     }
  2244.       else if (c1 < 0x80)
  2245.     DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
  2246.       else
  2247.     {
  2248.       if (sjis_p)
  2249.         {
  2250.           if (c1 < 0xA0 || (c1 >= 0xE0 && c1 < 0xF0))
  2251.         {
  2252.           /* SJIS -> JISX0208 */
  2253.           ONE_MORE_BYTE (c2);
  2254.           if (c2 >= 0x40)
  2255.             {
  2256.               DECODE_SJIS (c1, c2, c3, c4);
  2257.               DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
  2258.             }
  2259.           else
  2260.             goto label_invalid_code_2;
  2261.         }
  2262.           else if (c1 < 0xE0)
  2263.         /* SJIS -> JISX0201-Kana */
  2264.         DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
  2265.                         /* dummy */ c2);
  2266.           else
  2267.         goto label_invalid_code_1;
  2268.         }
  2269.       else
  2270.         {
  2271.           /* BIG5 -> Big5 */
  2272.           if (c1 >= 0xA1 && c1 <= 0xFE)
  2273.         {
  2274.           ONE_MORE_BYTE (c2);
  2275.           if ((c2 >= 0x40 && c2 <= 0x7E) || (c2 >= 0xA1 && c2 <= 0xFE))
  2276.             {
  2277.               int charset;
  2278.  
  2279.               DECODE_BIG5 (c1, c2, charset, c3, c4);
  2280.               DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
  2281.             }
  2282.           else
  2283.             goto label_invalid_code_2;
  2284.         }
  2285.           else
  2286.         goto label_invalid_code_1;
  2287.         }
  2288.     }
  2289.       continue;
  2290.  
  2291.     label_invalid_code_1:
  2292.       *dst++ = c1;
  2293.       coding->produced_char++;
  2294.       coding->fake_multibyte = 1;
  2295.       continue;
  2296.  
  2297.     label_invalid_code_2:
  2298.       *dst++ = c1; *dst++= c2;
  2299.       coding->produced_char += 2;
  2300.       coding->fake_multibyte = 1;
  2301.       continue;
  2302.  
  2303.     label_end_of_loop:
  2304.       result = CODING_FINISH_INSUFFICIENT_SRC;
  2305.     label_end_of_loop_2:
  2306.       src = src_base;
  2307.       break;
  2308.     }
  2309.  
  2310.   if (src < src_end)
  2311.     {
  2312.       if (result == CODING_FINISH_NORMAL)
  2313.     result = CODING_FINISH_INSUFFICIENT_DST;
  2314.       else if (result != CODING_FINISH_INCONSISTENT_EOL
  2315.            && coding->mode & CODING_MODE_LAST_BLOCK)
  2316.     {
  2317.       src_bytes = src_end - src;
  2318.       if (dst_bytes && (dst_end - dst < src_bytes))
  2319.         src_bytes = dst_end - dst;
  2320.       bcopy (dst, src, src_bytes);
  2321.       src += src_bytes;
  2322.       dst += src_bytes;
  2323.       coding->fake_multibyte = 1;
  2324.     }
  2325.     }
  2326.  
  2327.   coding->consumed = coding->consumed_char = src - source;
  2328.   coding->produced = dst - destination;
  2329.   return result;
  2330. }
  2331.  
  2332. /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
  2333.    This function can encode `charset_ascii', `charset_katakana_jisx0201',
  2334.    `charset_jisx0208', `charset_big5_1', and `charset_big5-2'.  We are
  2335.    sure that all these charsets are registered as official charset
  2336.    (i.e. do not have extended leading-codes).  Characters of other
  2337.    charsets are produced without any encoding.  If SJIS_P is 1, encode
  2338.    SJIS text, else encode BIG5 text.  */
  2339.  
  2340. int
  2341. encode_coding_sjis_big5 (coding, source, destination,
  2342.              src_bytes, dst_bytes, sjis_p)
  2343.      struct coding_system *coding;
  2344.      unsigned char *source, *destination;
  2345.      int src_bytes, dst_bytes;
  2346.      int sjis_p;
  2347. {
  2348.   unsigned char *src = source;
  2349.   unsigned char *src_end = source + src_bytes;
  2350.   unsigned char *dst = destination;
  2351.   unsigned char *dst_end = destination + dst_bytes;
  2352.   /* Since the maximum bytes produced by each loop is 2, we subtract 1
  2353.      from DST_END to assure overflow checking is necessary only at the
  2354.      head of loop.  */
  2355.   unsigned char *adjusted_dst_end = dst_end - 1;
  2356.   Lisp_Object translation_table
  2357.       = coding->translation_table_for_encode;
  2358.   int result = CODING_FINISH_NORMAL;
  2359.  
  2360.   if (!NILP (Venable_character_translation) && NILP (translation_table))
  2361.     translation_table = Vstandard_translation_table_for_encode;
  2362.  
  2363.   coding->consumed_char = 0;
  2364.   coding->fake_multibyte = 0;
  2365.   while (src < src_end && (dst_bytes
  2366.                ? (dst < adjusted_dst_end)
  2367.                : (dst < src - 1)))
  2368.     {
  2369.       /* SRC_BASE remembers the start position in source in each loop.
  2370.      The loop will be exited when there's not enough source text
  2371.      to analyze multi-byte codes (within macros ONE_MORE_BYTE and
  2372.      TWO_MORE_BYTES).  In that case, SRC is reset to SRC_BASE
  2373.      before exiting.  */
  2374.       unsigned char *src_base = src;
  2375.       unsigned char c1 = *src++, c2, c3, c4;
  2376.  
  2377.       if (coding->composing)
  2378.     {
  2379.       if (c1 == 0xA0)
  2380.         {
  2381.           ONE_MORE_BYTE (c1);
  2382.           c1 &= 0x7F;
  2383.         }
  2384.       else if (c1 >= 0xA0)
  2385.         c1 -= 0x20;
  2386.       else
  2387.         coding->composing = 0;
  2388.     }
  2389.  
  2390.       switch (emacs_code_class[c1])
  2391.     {
  2392.     case EMACS_ascii_code:
  2393.       ENCODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
  2394.       break;
  2395.  
  2396.     case EMACS_control_code:
  2397.       *dst++ = c1;
  2398.       coding->consumed_char++;
  2399.       break;
  2400.  
  2401.     case EMACS_carriage_return_code:
  2402.       if (! (coding->mode & CODING_MODE_SELECTIVE_DISPLAY))
  2403.         {
  2404.           *dst++ = c1;
  2405.           coding->consumed_char++;
  2406.           break;
  2407.         }
  2408.       /* fall down to treat '\r' as '\n' ...  */
  2409.  
  2410.     case EMACS_linefeed_code:
  2411.       if (coding->eol_type == CODING_EOL_LF
  2412.           || coding->eol_type == CODING_EOL_UNDECIDED)
  2413.         *dst++ = '\n';
  2414.       else if (coding->eol_type == CODING_EOL_CRLF)
  2415.         *dst++ = '\r', *dst++ = '\n';
  2416.       else
  2417.         *dst++ = '\r';
  2418.       coding->consumed_char++;
  2419.       break;
  2420.  
  2421.     case EMACS_leading_code_2:
  2422.       ONE_MORE_BYTE (c2);
  2423.       ENCODE_SJIS_BIG5_CHARACTER (c1, c2, /* dummy */ c3);
  2424.       break;
  2425.  
  2426.     case EMACS_leading_code_3:
  2427.       TWO_MORE_BYTES (c2, c3);
  2428.       ENCODE_SJIS_BIG5_CHARACTER (c1, c2, c3);
  2429.       break;
  2430.  
  2431.     case EMACS_leading_code_4:
  2432.       THREE_MORE_BYTES (c2, c3, c4);
  2433.       ENCODE_SJIS_BIG5_CHARACTER (c2, c3, c4);
  2434.       break;
  2435.  
  2436.     case EMACS_leading_code_composition:
  2437.       coding->composing = 1;
  2438.       break;
  2439.  
  2440.     default:        /* i.e. case EMACS_invalid_code: */
  2441.       *dst++ = c1;
  2442.       coding->consumed_char++;
  2443.     }
  2444.       continue;
  2445.  
  2446.     label_end_of_loop:
  2447.       result = CODING_FINISH_INSUFFICIENT_SRC;
  2448.       src = src_base;
  2449.       break;
  2450.     }
  2451.  
  2452.   if (result == CODING_FINISH_NORMAL
  2453.       && src < src_end)
  2454.     result = CODING_FINISH_INSUFFICIENT_DST;
  2455.   coding->consumed = src - source;
  2456.   coding->produced = coding->produced_char = dst - destination;
  2457.   return result;
  2458. }
  2459.  
  2460.  
  2461. /*** 5. CCL handlers ***/
  2462.  
  2463. /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
  2464.    Check if a text is encoded in a coding system of which
  2465.    encoder/decoder are written in CCL program.  If it is, return
  2466.    CODING_CATEGORY_MASK_CCL, else return 0.  */
  2467.  
  2468. int
  2469. detect_coding_ccl (src, src_end)
  2470.      unsigned char *src, *src_end;
  2471. {
  2472.   unsigned char *valid;
  2473.  
  2474.   /* No coding system is assigned to coding-category-ccl.  */
  2475.   if (!coding_system_table[CODING_CATEGORY_IDX_CCL])
  2476.     return 0;
  2477.  
  2478.   valid = coding_system_table[CODING_CATEGORY_IDX_CCL]->spec.ccl.valid_codes;
  2479.   while (src < src_end)
  2480.     {
  2481.       if (! valid[*src]) return 0;
  2482.       src++;
  2483.     }
  2484.   return CODING_CATEGORY_MASK_CCL;
  2485. }
  2486.  
  2487.  
  2488. /*** 6. End-of-line handlers ***/
  2489.  
  2490. /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
  2491.    This function is called only when `coding->eol_type' is
  2492.    CODING_EOL_CRLF or CODING_EOL_CR.  */
  2493.  
  2494. int
  2495. decode_eol (coding, source, destination, src_bytes, dst_bytes)
  2496.      struct coding_system *coding;
  2497.      unsigned char *source, *destination;
  2498.      int src_bytes, dst_bytes;
  2499. {
  2500.   unsigned char *src = source;
  2501.   unsigned char *src_end = source + src_bytes;
  2502.   unsigned char *dst = destination;
  2503.   unsigned char *dst_end = destination + dst_bytes;
  2504.   unsigned char c;
  2505.   int result = CODING_FINISH_NORMAL;
  2506.  
  2507.   coding->fake_multibyte = 0;
  2508.  
  2509.   if (src_bytes <= 0)
  2510.     return result;
  2511.  
  2512.   switch (coding->eol_type)
  2513.     {
  2514.     case CODING_EOL_CRLF:
  2515.       {
  2516.     /* Since the maximum bytes produced by each loop is 2, we
  2517.        subtract 1 from DST_END to assure overflow checking is
  2518.        necessary only at the head of loop.  */
  2519.     unsigned char *adjusted_dst_end = dst_end - 1;
  2520.  
  2521.     while (src < src_end && (dst_bytes
  2522.                  ? (dst < adjusted_dst_end)
  2523.                  : (dst < src - 1)))
  2524.       {
  2525.         unsigned char *src_base = src;
  2526.  
  2527.         c = *src++;
  2528.         if (c == '\r')
  2529.           {
  2530.         ONE_MORE_BYTE (c);
  2531.         if (c != '\n')
  2532.           {
  2533.             if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  2534.               {
  2535.             result = CODING_FINISH_INCONSISTENT_EOL;
  2536.             goto label_end_of_loop_2;
  2537.               }
  2538.             *dst++ = '\r';
  2539.             if (BASE_LEADING_CODE_P (c))
  2540.               coding->fake_multibyte = 1;
  2541.           }
  2542.         *dst++ = c;
  2543.           }
  2544.         else if (c == '\n'
  2545.              && (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL))
  2546.           {
  2547.         result = CODING_FINISH_INCONSISTENT_EOL;
  2548.         goto label_end_of_loop_2;
  2549.           }
  2550.         else
  2551.           {
  2552.         *dst++ = c;
  2553.         if (BASE_LEADING_CODE_P (c))
  2554.           coding->fake_multibyte = 1;
  2555.           }
  2556.         continue;
  2557.  
  2558.       label_end_of_loop:
  2559.         result = CODING_FINISH_INSUFFICIENT_SRC;
  2560.       label_end_of_loop_2:
  2561.         src = src_base;
  2562.         break;
  2563.       }
  2564.     if (result == CODING_FINISH_NORMAL
  2565.         && src < src_end)
  2566.       result = CODING_FINISH_INSUFFICIENT_DST;
  2567.       }
  2568.       break;
  2569.  
  2570.     case CODING_EOL_CR:
  2571.       if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
  2572.     {
  2573.       while (src < src_end)
  2574.         {
  2575.           if ((c = *src++) == '\n')
  2576.         break;
  2577.           if (BASE_LEADING_CODE_P (c))
  2578.         coding->fake_multibyte = 1;
  2579.         }
  2580.       if (*--src == '\n')
  2581.         {
  2582.           src_bytes = src - source;
  2583.           result = CODING_FINISH_INCONSISTENT_EOL;
  2584.         }
  2585.     }
  2586.       if (dst_bytes && src_bytes > dst_bytes)
  2587.     {
  2588.       result = CODING_FINISH_INSUFFICIENT_DST;
  2589.       src_bytes = dst_bytes;
  2590.     }
  2591.       if (dst_bytes)
  2592.     bcopy (source, destination, src_bytes);
  2593.       else
  2594.     safe_bcopy (source, destination, src_bytes);
  2595.       src = source + src_bytes;
  2596.       while (src_bytes--) if (*dst++ == '\r') dst[-1] = '\n';
  2597.       break;
  2598.  
  2599.     default:            /* i.e. case: CODING_EOL_LF */
  2600.       if (dst_bytes && src_bytes > dst_bytes)
  2601.     {
  2602.       result = CODING_FINISH_INSUFFICIENT_DST;
  2603.       src_bytes = dst_bytes;
  2604.     }
  2605.       if (dst_bytes)
  2606.     bcopy (source, destination, src_bytes);
  2607.       else
  2608.     safe_bcopy (source, destination, src_bytes);
  2609.       src += src_bytes;
  2610.       dst += src_bytes;
  2611.       coding->fake_multibyte = 1;
  2612.       break;
  2613.     }
  2614.  
  2615.   coding->consumed = coding->consumed_char = src - source;
  2616.   coding->produced = coding->produced_char = dst - destination;
  2617.   return result;
  2618. }
  2619.  
  2620. /* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  Encode
  2621.    format of end-of-line according to `coding->eol_type'.  If
  2622.    `coding->mode & CODING_MODE_SELECTIVE_DISPLAY' is nonzero, code
  2623.    '\r' in source text also means end-of-line.  */
  2624.  
  2625. int
  2626. encode_eol (coding, source, destination, src_bytes, dst_bytes)
  2627.      struct coding_system *coding;
  2628.      unsigned char *source, *destination;
  2629.      int src_bytes, dst_bytes;
  2630. {
  2631.   unsigned char *src = source;
  2632.   unsigned char *dst = destination;
  2633.   int result = CODING_FINISH_NORMAL;
  2634.  
  2635.   coding->fake_multibyte = 0;
  2636.  
  2637.   if (coding->eol_type == CODING_EOL_CRLF)
  2638.     {
  2639.       unsigned char c;
  2640.       unsigned char *src_end = source + src_bytes;
  2641.       unsigned char *dst_end = destination + dst_bytes;
  2642.       /* Since the maximum bytes produced by each loop is 2, we
  2643.      subtract 1 from DST_END to assure overflow checking is
  2644.      necessary only at the head of loop.  */
  2645.       unsigned char *adjusted_dst_end = dst_end - 1;
  2646.  
  2647.       while (src < src_end && (dst_bytes
  2648.                    ? (dst < adjusted_dst_end)
  2649.                    : (dst < src - 1)))
  2650.     {
  2651.       c = *src++;
  2652.       if (c == '\n'
  2653.           || (c == '\r' && (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)))
  2654.         *dst++ = '\r', *dst++ = '\n';
  2655.       else
  2656.         {
  2657.           *dst++ = c;
  2658.           if (BASE_LEADING_CODE_P (c))
  2659.         coding->fake_multibyte = 1;
  2660.         }
  2661.     }
  2662.       if (src < src_end)
  2663.     result = CODING_FINISH_INSUFFICIENT_DST;
  2664.     }
  2665.   else
  2666.     {
  2667.       unsigned char c;
  2668.  
  2669.       if (dst_bytes && src_bytes > dst_bytes)
  2670.     {
  2671.       src_bytes = dst_bytes;
  2672.       result = CODING_FINISH_INSUFFICIENT_DST;
  2673.     }
  2674.       if (dst_bytes)
  2675.     bcopy (source, destination, src_bytes);
  2676.       else
  2677.     safe_bcopy (source, destination, src_bytes);
  2678.       dst_bytes = src_bytes;
  2679.       if (coding->eol_type == CODING_EOL_CR)
  2680.     {
  2681.       while (src_bytes--)
  2682.         {
  2683.           if ((c = *dst++) == '\n')
  2684.         dst[-1] = '\r';
  2685.           else if (BASE_LEADING_CODE_P (c))
  2686.         coding->fake_multibyte = 1;
  2687.         }
  2688.     }
  2689.       else
  2690.     {
  2691.       if (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)
  2692.         {
  2693.           while (src_bytes--)
  2694.         if (*dst++ == '\r') dst[-1] = '\n';
  2695.         }
  2696.       coding->fake_multibyte = 1;
  2697.     }
  2698.       src = source + dst_bytes;
  2699.       dst = destination + dst_bytes;
  2700.     }
  2701.  
  2702.   coding->consumed = coding->consumed_char = src - source;
  2703.   coding->produced = coding->produced_char = dst - destination;
  2704.   return result;
  2705. }
  2706.  
  2707.  
  2708. /*** 7. C library functions ***/
  2709.  
  2710. /* In Emacs Lisp, coding system is represented by a Lisp symbol which
  2711.    has a property `coding-system'.  The value of this property is a
  2712.    vector of length 5 (called as coding-vector).  Among elements of
  2713.    this vector, the first (element[0]) and the fifth (element[4])
  2714.    carry important information for decoding/encoding.  Before
  2715.    decoding/encoding, this information should be set in fields of a
  2716.    structure of type `coding_system'.
  2717.  
  2718.    A value of property `coding-system' can be a symbol of another
  2719.    subsidiary coding-system.  In that case, Emacs gets coding-vector
  2720.    from that symbol.
  2721.  
  2722.    `element[0]' contains information to be set in `coding->type'.  The
  2723.    value and its meaning is as follows:
  2724.  
  2725.    0 -- coding_type_emacs_mule
  2726.    1 -- coding_type_sjis
  2727.    2 -- coding_type_iso2022
  2728.    3 -- coding_type_big5
  2729.    4 -- coding_type_ccl encoder/decoder written in CCL
  2730.    nil -- coding_type_no_conversion
  2731.    t -- coding_type_undecided (automatic conversion on decoding,
  2732.                       no-conversion on encoding)
  2733.  
  2734.    `element[4]' contains information to be set in `coding->flags' and
  2735.    `coding->spec'.  The meaning varies by `coding->type'.
  2736.  
  2737.    If `coding->type' is `coding_type_iso2022', element[4] is a vector
  2738.    of length 32 (of which the first 13 sub-elements are used now).
  2739.    Meanings of these sub-elements are:
  2740.  
  2741.    sub-element[N] where N is 0 through 3: to be set in `coding->spec.iso2022'
  2742.        If the value is an integer of valid charset, the charset is
  2743.     assumed to be designated to graphic register N initially.
  2744.  
  2745.     If the value is minus, it is a minus value of charset which
  2746.     reserves graphic register N, which means that the charset is
  2747.     not designated initially but should be designated to graphic
  2748.     register N just before encoding a character in that charset.
  2749.  
  2750.     If the value is nil, graphic register N is never used on
  2751.     encoding.
  2752.    
  2753.    sub-element[N] where N is 4 through 11: to be set in `coding->flags'
  2754.        Each value takes t or nil.  See the section ISO2022 of
  2755.     `coding.h' for more information.
  2756.  
  2757.    If `coding->type' is `coding_type_big5', element[4] is t to denote
  2758.    BIG5-ETen or nil to denote BIG5-HKU.
  2759.  
  2760.    If `coding->type' takes the other value, element[4] is ignored.
  2761.  
  2762.    Emacs Lisp's coding system also carries information about format of
  2763.    end-of-line in a value of property `eol-type'.  If the value is
  2764.    integer, 0 means CODING_EOL_LF, 1 means CODING_EOL_CRLF, and 2
  2765.    means CODING_EOL_CR.  If it is not integer, it should be a vector
  2766.    of subsidiary coding systems of which property `eol-type' has one
  2767.    of above values.
  2768.  
  2769. */
  2770.  
  2771. /* Extract information for decoding/encoding from CODING_SYSTEM_SYMBOL
  2772.    and set it in CODING.  If CODING_SYSTEM_SYMBOL is invalid, CODING
  2773.    is setup so that no conversion is necessary and return -1, else
  2774.    return 0.  */
  2775.  
  2776. int
  2777. setup_coding_system (coding_system, coding)
  2778.      Lisp_Object coding_system;
  2779.      struct coding_system *coding;
  2780. {
  2781.   Lisp_Object coding_spec, coding_type, eol_type, plist;
  2782.   Lisp_Object val;
  2783.   int i;
  2784.  
  2785.   /* Initialize some fields required for all kinds of coding systems.  */
  2786.   coding->symbol = coding_system;
  2787.   coding->common_flags = 0;
  2788.   coding->mode = 0;
  2789.   coding->heading_ascii = -1;
  2790.   coding->post_read_conversion = coding->pre_write_conversion = Qnil;
  2791.   coding_spec = Fget (coding_system, Qcoding_system);
  2792.   if (!VECTORP (coding_spec)
  2793.       || XVECTOR (coding_spec)->size != 5
  2794.       || !CONSP (XVECTOR (coding_spec)->contents[3]))
  2795.     goto label_invalid_coding_system;
  2796.  
  2797.   eol_type = inhibit_eol_conversion ? Qnil : Fget (coding_system, Qeol_type);
  2798.   if (VECTORP (eol_type))
  2799.     {
  2800.       coding->eol_type = CODING_EOL_UNDECIDED;
  2801.       coding->common_flags = CODING_REQUIRE_DETECTION_MASK;
  2802.     }
  2803.   else if (XFASTINT (eol_type) == 1)
  2804.     {
  2805.       coding->eol_type = CODING_EOL_CRLF;
  2806.       coding->common_flags
  2807.     = CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  2808.     }
  2809.   else if (XFASTINT (eol_type) == 2)
  2810.     {
  2811.       coding->eol_type = CODING_EOL_CR;
  2812.       coding->common_flags
  2813.     = CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  2814.     }
  2815.   else
  2816.     coding->eol_type = CODING_EOL_LF;
  2817.  
  2818.   coding_type = XVECTOR (coding_spec)->contents[0];
  2819.   /* Try short cut.  */
  2820.   if (SYMBOLP (coding_type))
  2821.     {
  2822.       if (EQ (coding_type, Qt))
  2823.     {
  2824.       coding->type = coding_type_undecided;
  2825.       coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
  2826.     }
  2827.       else
  2828.     coding->type = coding_type_no_conversion;
  2829.       return 0;
  2830.     }
  2831.  
  2832.   /* Initialize remaining fields.  */
  2833.   coding->composing = 0;
  2834.   coding->translation_table_for_decode = Qnil;
  2835.   coding->translation_table_for_encode = Qnil;
  2836.  
  2837.   /* Get values of coding system properties:
  2838.      `post-read-conversion', `pre-write-conversion',
  2839.      `translation-table-for-decode', `translation-table-for-encode'.  */
  2840.   plist = XVECTOR (coding_spec)->contents[3];
  2841.   coding->post_read_conversion = Fplist_get (plist, Qpost_read_conversion);
  2842.   coding->pre_write_conversion = Fplist_get (plist, Qpre_write_conversion);
  2843.   val = Fplist_get (plist, Qtranslation_table_for_decode);
  2844.   if (SYMBOLP (val))
  2845.     val = Fget (val, Qtranslation_table_for_decode);
  2846.   coding->translation_table_for_decode = CHAR_TABLE_P (val) ? val : Qnil;
  2847.   val = Fplist_get (plist, Qtranslation_table_for_encode);
  2848.   if (SYMBOLP (val))
  2849.     val = Fget (val, Qtranslation_table_for_encode);
  2850.   coding->translation_table_for_encode = CHAR_TABLE_P (val) ? val : Qnil;
  2851.   val = Fplist_get (plist, Qcoding_category);
  2852.   if (!NILP (val))
  2853.     {
  2854.       val = Fget (val, Qcoding_category_index);
  2855.       if (INTEGERP (val))
  2856.     coding->category_idx = XINT (val);
  2857.       else
  2858.     goto label_invalid_coding_system;
  2859.     }
  2860.   else
  2861.     goto label_invalid_coding_system;
  2862.   
  2863.   val = Fplist_get (plist, Qsafe_charsets);
  2864.   if (EQ (val, Qt))
  2865.     {
  2866.       for (i = 0; i <= MAX_CHARSET; i++)
  2867.     coding->safe_charsets[i] = 1;
  2868.     }
  2869.   else
  2870.     {
  2871.       bzero (coding->safe_charsets, MAX_CHARSET + 1);
  2872.       while (CONSP (val))
  2873.     {
  2874.       if ((i = get_charset_id (XCONS (val)->car)) >= 0)
  2875.         coding->safe_charsets[i] = 1;
  2876.       val = XCONS (val)->cdr;
  2877.     }
  2878.     }
  2879.  
  2880.   switch (XFASTINT (coding_type))
  2881.     {
  2882.     case 0:
  2883.       coding->type = coding_type_emacs_mule;
  2884.       if (!NILP (coding->post_read_conversion))
  2885.     coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
  2886.       if (!NILP (coding->pre_write_conversion))
  2887.     coding->common_flags |= CODING_REQUIRE_ENCODING_MASK;
  2888.       break;
  2889.  
  2890.     case 1:
  2891.       coding->type = coding_type_sjis;
  2892.       coding->common_flags
  2893.     |= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  2894.       break;
  2895.  
  2896.     case 2:
  2897.       coding->type = coding_type_iso2022;
  2898.       coding->common_flags
  2899.     |= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  2900.       {
  2901.     Lisp_Object val, temp;
  2902.     Lisp_Object *flags;
  2903.     int i, charset, reg_bits = 0;
  2904.  
  2905.     val = XVECTOR (coding_spec)->contents[4];
  2906.  
  2907.     if (!VECTORP (val) || XVECTOR (val)->size != 32)
  2908.       goto label_invalid_coding_system;
  2909.  
  2910.     flags = XVECTOR (val)->contents;
  2911.     coding->flags
  2912.       = ((NILP (flags[4]) ? 0 : CODING_FLAG_ISO_SHORT_FORM)
  2913.          | (NILP (flags[5]) ? 0 : CODING_FLAG_ISO_RESET_AT_EOL)
  2914.          | (NILP (flags[6]) ? 0 : CODING_FLAG_ISO_RESET_AT_CNTL)
  2915.          | (NILP (flags[7]) ? 0 : CODING_FLAG_ISO_SEVEN_BITS)
  2916.          | (NILP (flags[8]) ? 0 : CODING_FLAG_ISO_LOCKING_SHIFT)
  2917.          | (NILP (flags[9]) ? 0 : CODING_FLAG_ISO_SINGLE_SHIFT)
  2918.          | (NILP (flags[10]) ? 0 : CODING_FLAG_ISO_USE_ROMAN)
  2919.          | (NILP (flags[11]) ? 0 : CODING_FLAG_ISO_USE_OLDJIS)
  2920.          | (NILP (flags[12]) ? 0 : CODING_FLAG_ISO_NO_DIRECTION)
  2921.          | (NILP (flags[13]) ? 0 : CODING_FLAG_ISO_INIT_AT_BOL)
  2922.          | (NILP (flags[14]) ? 0 : CODING_FLAG_ISO_DESIGNATE_AT_BOL)
  2923.          | (NILP (flags[15]) ? 0 : CODING_FLAG_ISO_SAFE)
  2924.          | (NILP (flags[16]) ? 0 : CODING_FLAG_ISO_LATIN_EXTRA)
  2925.          );
  2926.  
  2927.     /* Invoke graphic register 0 to plane 0.  */
  2928.     CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
  2929.     /* Invoke graphic register 1 to plane 1 if we can use full 8-bit.  */
  2930.     CODING_SPEC_ISO_INVOCATION (coding, 1)
  2931.       = (coding->flags & CODING_FLAG_ISO_SEVEN_BITS ? -1 : 1);
  2932.     /* Not single shifting at first.  */
  2933.     CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;
  2934.     /* Beginning of buffer should also be regarded as bol. */
  2935.     CODING_SPEC_ISO_BOL (coding) = 1;
  2936.  
  2937.     for (charset = 0; charset <= MAX_CHARSET; charset++)
  2938.       CODING_SPEC_ISO_REVISION_NUMBER (coding, charset) = 255;
  2939.     val = Vcharset_revision_alist;
  2940.     while (CONSP (val))
  2941.       {
  2942.         charset = get_charset_id (Fcar_safe (XCONS (val)->car));
  2943.         if (charset >= 0
  2944.         && (temp = Fcdr_safe (XCONS (val)->car), INTEGERP (temp))
  2945.         && (i = XINT (temp), (i >= 0 && (i + '@') < 128)))
  2946.           CODING_SPEC_ISO_REVISION_NUMBER (coding, charset) = i;
  2947.         val = XCONS (val)->cdr;
  2948.       }
  2949.  
  2950.     /* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
  2951.        FLAGS[REG] can be one of below:
  2952.         integer CHARSET: CHARSET occupies register I,
  2953.         t: designate nothing to REG initially, but can be used
  2954.           by any charsets,
  2955.         list of integer, nil, or t: designate the first
  2956.           element (if integer) to REG initially, the remaining
  2957.           elements (if integer) is designated to REG on request,
  2958.           if an element is t, REG can be used by any charsets,
  2959.         nil: REG is never used.  */
  2960.     for (charset = 0; charset <= MAX_CHARSET; charset++)
  2961.       CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
  2962.         = CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION;
  2963.     for (i = 0; i < 4; i++)
  2964.       {
  2965.         if (INTEGERP (flags[i])
  2966.         && (charset = XINT (flags[i]), CHARSET_VALID_P (charset))
  2967.         || (charset = get_charset_id (flags[i])) >= 0)
  2968.           {
  2969.         CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
  2970.         CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) = i;
  2971.           }
  2972.         else if (EQ (flags[i], Qt))
  2973.           {
  2974.         CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
  2975.         reg_bits |= 1 << i;
  2976.         coding->flags |= CODING_FLAG_ISO_DESIGNATION;
  2977.           }
  2978.         else if (CONSP (flags[i]))
  2979.           {
  2980.         Lisp_Object tail;
  2981.         tail = flags[i];
  2982.  
  2983.         coding->flags |= CODING_FLAG_ISO_DESIGNATION;
  2984.         if (INTEGERP (XCONS (tail)->car)
  2985.             && (charset = XINT (XCONS (tail)->car),
  2986.             CHARSET_VALID_P (charset))
  2987.             || (charset = get_charset_id (XCONS (tail)->car)) >= 0)
  2988.           {
  2989.             CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
  2990.             CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) =i;
  2991.           }
  2992.         else
  2993.           CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
  2994.         tail = XCONS (tail)->cdr;
  2995.         while (CONSP (tail))
  2996.           {
  2997.             if (INTEGERP (XCONS (tail)->car)
  2998.             && (charset = XINT (XCONS (tail)->car),
  2999.                 CHARSET_VALID_P (charset))
  3000.             || (charset = get_charset_id (XCONS (tail)->car)) >= 0)
  3001.               CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
  3002.             = i;
  3003.             else if (EQ (XCONS (tail)->car, Qt))
  3004.               reg_bits |= 1 << i;
  3005.             tail = XCONS (tail)->cdr;
  3006.           }
  3007.           }
  3008.         else
  3009.           CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
  3010.         
  3011.         CODING_SPEC_ISO_DESIGNATION (coding, i)
  3012.           = CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i);
  3013.       }
  3014.  
  3015.     if (reg_bits && ! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT))
  3016.       {
  3017.         /* REG 1 can be used only by locking shift in 7-bit env.  */
  3018.         if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
  3019.           reg_bits &= ~2;
  3020.         if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT))
  3021.           /* Without any shifting, only REG 0 and 1 can be used.  */
  3022.           reg_bits &= 3;
  3023.       }
  3024.  
  3025.     if (reg_bits)
  3026.       for (charset = 0; charset <= MAX_CHARSET; charset++)
  3027.         {
  3028.           if (CHARSET_VALID_P (charset))
  3029.         {
  3030.           /* There exist some default graphic registers to be
  3031.              used CHARSET.  */
  3032.  
  3033.           /* We had better avoid designating a charset of
  3034.              CHARS96 to REG 0 as far as possible.  */
  3035.           if (CHARSET_CHARS (charset) == 96)
  3036.             CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
  3037.               = (reg_bits & 2
  3038.              ? 1 : (reg_bits & 4 ? 2 : (reg_bits & 8 ? 3 : 0)));
  3039.           else
  3040.             CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
  3041.               = (reg_bits & 1
  3042.              ? 0 : (reg_bits & 2 ? 1 : (reg_bits & 4 ? 2 : 3)));
  3043.         }
  3044.         }
  3045.       }
  3046.       coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
  3047.       coding->spec.iso2022.last_invalid_designation_register = -1;
  3048.       break;
  3049.  
  3050.     case 3:
  3051.       coding->type = coding_type_big5;
  3052.       coding->common_flags
  3053.     |= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  3054.       coding->flags
  3055.     = (NILP (XVECTOR (coding_spec)->contents[4])
  3056.        ? CODING_FLAG_BIG5_HKU
  3057.        : CODING_FLAG_BIG5_ETEN);
  3058.       break;
  3059.  
  3060.     case 4:
  3061.       coding->type = coding_type_ccl;
  3062.       coding->common_flags
  3063.     |= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
  3064.       {
  3065.     Lisp_Object val;
  3066.     Lisp_Object decoder, encoder;
  3067.  
  3068.     val = XVECTOR (coding_spec)->contents[4];
  3069.     if (CONSP  (val)
  3070.         && SYMBOLP (XCONS (val)->car)
  3071.         && !NILP (decoder = Fget (XCONS (val)->car, Qccl_program_idx))
  3072.         && !NILP (decoder = Fcdr (Faref (Vccl_program_table, decoder)))
  3073.         && SYMBOLP (XCONS (val)->cdr)
  3074.         && !NILP (encoder = Fget (XCONS (val)->cdr, Qccl_program_idx))
  3075.         && !NILP (encoder = Fcdr (Faref (Vccl_program_table, encoder))))
  3076.       {
  3077.         setup_ccl_program (&(coding->spec.ccl.decoder), decoder);
  3078.         setup_ccl_program (&(coding->spec.ccl.encoder), encoder);
  3079.       }
  3080.     else
  3081.       goto label_invalid_coding_system;
  3082.  
  3083.     bzero (coding->spec.ccl.valid_codes, 256);
  3084.     val = Fplist_get (plist, Qvalid_codes);
  3085.     if (CONSP (val))
  3086.       {
  3087.         Lisp_Object this;
  3088.  
  3089.         for (; CONSP (val); val = XCONS (val)->cdr)
  3090.           {
  3091.         this = XCONS (val)->car;
  3092.         if (INTEGERP (this)
  3093.             && XINT (this) >= 0 && XINT (this) < 256)
  3094.           coding->spec.ccl.valid_codes[XINT (this)] = 1;
  3095.         else if (CONSP (this)
  3096.              && INTEGERP (XCONS (this)->car)
  3097.              && INTEGERP (XCONS (this)->cdr))
  3098.           {
  3099.             int start = XINT (XCONS (this)->car);
  3100.             int end = XINT (XCONS (this)->cdr);
  3101.  
  3102.             if (start >= 0 && start <= end && end < 256)
  3103.               while (start < end)
  3104.             coding->spec.ccl.valid_codes[start++] = 1;
  3105.           }
  3106.           }
  3107.       }
  3108.       }
  3109.       coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
  3110.       break;
  3111.  
  3112.     case 5:
  3113.       coding->type = coding_type_raw_text;
  3114.       break;
  3115.  
  3116.     default:
  3117.       goto label_invalid_coding_system;
  3118.     }
  3119.   return 0;
  3120.  
  3121.  label_invalid_coding_system:
  3122.   coding->type = coding_type_no_conversion;
  3123.   coding->category_idx = CODING_CATEGORY_IDX_BINARY;
  3124.   coding->common_flags = 0;
  3125.   coding->eol_type = CODING_EOL_LF;
  3126.   coding->pre_write_conversion = coding->post_read_conversion = Qnil;
  3127.   return -1;
  3128. }
  3129.  
  3130. /* Setup raw-text or one of its subsidiaries in the structure
  3131.    coding_system CODING according to the already setup value eol_type
  3132.    in CODING.  CODING should be setup for some coding system in
  3133.    advance.  */
  3134.  
  3135. void
  3136. setup_raw_text_coding_system (coding)
  3137.      struct coding_system *coding;
  3138. {
  3139.   if (coding->type != coding_type_raw_text)
  3140.     {
  3141.       coding->symbol = Qraw_text;
  3142.       coding->type = coding_type_raw_text;
  3143.       if (coding->eol_type != CODING_EOL_UNDECIDED)
  3144.     {
  3145.       Lisp_Object subsidiaries;
  3146.       subsidiaries = Fget (Qraw_text, Qeol_type);
  3147.  
  3148.       if (VECTORP (subsidiaries)
  3149.           && XVECTOR (subsidiaries)->size == 3)
  3150.         coding->symbol
  3151.           = XVECTOR (subsidiaries)->contents[coding->eol_type];
  3152.     }
  3153.     }
  3154.   return;
  3155. }
  3156.  
  3157. /* Emacs has a mechanism to automatically detect a coding system if it
  3158.    is one of Emacs' internal format, ISO2022, SJIS, and BIG5.  But,
  3159.    it's impossible to distinguish some coding systems accurately
  3160.    because they use the same range of codes.  So, at first, coding
  3161.    systems are categorized into 7, those are:
  3162.  
  3163.    o coding-category-emacs-mule
  3164.  
  3165.        The category for a coding system which has the same code range
  3166.     as Emacs' internal format.  Assigned the coding-system (Lisp
  3167.     symbol) `emacs-mule' by default.
  3168.  
  3169.    o coding-category-sjis
  3170.  
  3171.     The category for a coding system which has the same code range
  3172.     as SJIS.  Assigned the coding-system (Lisp
  3173.     symbol) `japanese-shift-jis' by default.
  3174.  
  3175.    o coding-category-iso-7
  3176.  
  3177.        The category for a coding system which has the same code range
  3178.     as ISO2022 of 7-bit environment.  This doesn't use any locking
  3179.     shift and single shift functions.  This can encode/decode all
  3180.     charsets.  Assigned the coding-system (Lisp symbol)
  3181.     `iso-2022-7bit' by default.
  3182.  
  3183.    o coding-category-iso-7-tight
  3184.  
  3185.     Same as coding-category-iso-7 except that this can
  3186.     encode/decode only the specified charsets.
  3187.  
  3188.    o coding-category-iso-8-1
  3189.  
  3190.        The category for a coding system which has the same code range
  3191.     as ISO2022 of 8-bit environment and graphic plane 1 used only
  3192.     for DIMENSION1 charset.  This doesn't use any locking shift
  3193.     and single shift functions.  Assigned the coding-system (Lisp
  3194.     symbol) `iso-latin-1' by default.
  3195.  
  3196.    o coding-category-iso-8-2
  3197.  
  3198.        The category for a coding system which has the same code range
  3199.     as ISO2022 of 8-bit environment and graphic plane 1 used only
  3200.     for DIMENSION2 charset.  This doesn't use any locking shift
  3201.     and single shift functions.  Assigned the coding-system (Lisp
  3202.     symbol) `japanese-iso-8bit' by default.
  3203.  
  3204.    o coding-category-iso-7-else
  3205.  
  3206.        The category for a coding system which has the same code range
  3207.     as ISO2022 of 7-bit environemnt but uses locking shift or
  3208.     single shift functions.  Assigned the coding-system (Lisp
  3209.     symbol) `iso-2022-7bit-lock' by default.
  3210.  
  3211.    o coding-category-iso-8-else
  3212.  
  3213.        The category for a coding system which has the same code range
  3214.     as ISO2022 of 8-bit environemnt but uses locking shift or
  3215.     single shift functions.  Assigned the coding-system (Lisp
  3216.     symbol) `iso-2022-8bit-ss2' by default.
  3217.  
  3218.    o coding-category-big5
  3219.  
  3220.        The category for a coding system which has the same code range
  3221.     as BIG5.  Assigned the coding-system (Lisp symbol)
  3222.     `cn-big5' by default.
  3223.  
  3224.    o coding-category-ccl
  3225.  
  3226.     The category for a coding system of which encoder/decoder is
  3227.     written in CCL programs.  The default value is nil, i.e., no
  3228.     coding system is assigned.
  3229.  
  3230.    o coding-category-binary
  3231.  
  3232.        The category for a coding system not categorized in any of the
  3233.     above.  Assigned the coding-system (Lisp symbol)
  3234.     `no-conversion' by default.
  3235.  
  3236.    Each of them is a Lisp symbol and the value is an actual
  3237.    `coding-system's (this is also a Lisp symbol) assigned by a user.
  3238.    What Emacs does actually is to detect a category of coding system.
  3239.    Then, it uses a `coding-system' assigned to it.  If Emacs can't
  3240.    decide only one possible category, it selects a category of the
  3241.    highest priority.  Priorities of categories are also specified by a
  3242.    user in a Lisp variable `coding-category-list'.
  3243.  
  3244. */
  3245.  
  3246. static
  3247. int ascii_skip_code[256];
  3248.  
  3249. /* Detect how a text of length SRC_BYTES pointed by SOURCE is encoded.
  3250.    If it detects possible coding systems, return an integer in which
  3251.    appropriate flag bits are set.  Flag bits are defined by macros
  3252.    CODING_CATEGORY_MASK_XXX in `coding.h'.
  3253.  
  3254.    How many ASCII characters are at the head is returned as *SKIP.  */
  3255.  
  3256. static int
  3257. detect_coding_mask (source, src_bytes, priorities, skip)
  3258.      unsigned char *source;
  3259.      int src_bytes, *priorities, *skip;
  3260. {
  3261.   register unsigned char c;
  3262.   unsigned char *src = source, *src_end = source + src_bytes;
  3263.   unsigned int mask;
  3264.   int i;
  3265.  
  3266.   /* At first, skip all ASCII characters and control characters except
  3267.      for three ISO2022 specific control characters.  */
  3268.   ascii_skip_code[ISO_CODE_SO] = 0;
  3269.   ascii_skip_code[ISO_CODE_SI] = 0;
  3270.   ascii_skip_code[ISO_CODE_ESC] = 0;
  3271.  
  3272.  label_loop_detect_coding:
  3273.   while (src < src_end && ascii_skip_code[*src]) src++;
  3274.   *skip = src - source;
  3275.  
  3276.   if (src >= src_end)
  3277.     /* We found nothing other than ASCII.  There's nothing to do.  */
  3278.     return 0;
  3279.  
  3280.   c = *src;
  3281.   /* The text seems to be encoded in some multilingual coding system.
  3282.      Now, try to find in which coding system the text is encoded.  */
  3283.   if (c < 0x80)
  3284.     {
  3285.       /* i.e. (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) */
  3286.       /* C is an ISO2022 specific control code of C0.  */
  3287.       mask = detect_coding_iso2022 (src, src_end);
  3288.       if (mask == 0)
  3289.     {
  3290.       /* No valid ISO2022 code follows C.  Try again.  */
  3291.       src++;
  3292.       if (c == ISO_CODE_ESC)
  3293.         ascii_skip_code[ISO_CODE_ESC] = 1;
  3294.       else
  3295.         ascii_skip_code[ISO_CODE_SO] = ascii_skip_code[ISO_CODE_SI] = 1;
  3296.       goto label_loop_detect_coding;
  3297.     }
  3298.       if (priorities)
  3299.     goto label_return_highest_only;
  3300.     }
  3301.   else
  3302.     {
  3303.       int try;
  3304.  
  3305.       if (c < 0xA0)
  3306.     {
  3307.       /* C is the first byte of SJIS character code,
  3308.          or a leading-code of Emacs' internal format (emacs-mule).  */
  3309.       try = CODING_CATEGORY_MASK_SJIS | CODING_CATEGORY_MASK_EMACS_MULE;
  3310.  
  3311.       /* Or, if C is a special latin extra code,
  3312.          or is an ISO2022 specific control code of C1 (SS2 or SS3), 
  3313.          or is an ISO2022 control-sequence-introducer (CSI),
  3314.          we should also consider the possibility of ISO2022 codings.  */
  3315.       if ((VECTORP (Vlatin_extra_code_table)
  3316.            && !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
  3317.           || (c == ISO_CODE_SS2 || c == ISO_CODE_SS3)
  3318.           || (c == ISO_CODE_CSI
  3319.           && (src < src_end
  3320.               && (*src == ']'
  3321.               || ((*src == '0' || *src == '1' || *src == '2')
  3322.                   && src + 1 < src_end
  3323.                   && src[1] == ']')))))
  3324.         try |= (CODING_CATEGORY_MASK_ISO_8_ELSE
  3325.              | CODING_CATEGORY_MASK_ISO_8BIT);
  3326.     }
  3327.       else
  3328.     /* C is a character of ISO2022 in graphic plane right,
  3329.        or a SJIS's 1-byte character code (i.e. JISX0201),
  3330.        or the first byte of BIG5's 2-byte code.  */
  3331.     try = (CODING_CATEGORY_MASK_ISO_8_ELSE
  3332.         | CODING_CATEGORY_MASK_ISO_8BIT
  3333.         | CODING_CATEGORY_MASK_SJIS
  3334.         | CODING_CATEGORY_MASK_BIG5);
  3335.  
  3336.       /* Or, we may have to consider the possibility of CCL.  */
  3337.       if (coding_system_table[CODING_CATEGORY_IDX_CCL]
  3338.       && (coding_system_table[CODING_CATEGORY_IDX_CCL]
  3339.           ->spec.ccl.valid_codes)[c])
  3340.     try |= CODING_CATEGORY_MASK_CCL;
  3341.  
  3342.       mask = 0;
  3343.       if (priorities)
  3344.     {
  3345.       for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
  3346.         {
  3347.           if (priorities[i] & try & CODING_CATEGORY_MASK_ISO)
  3348.         mask = detect_coding_iso2022 (src, src_end);
  3349.           else if (priorities[i] & try & CODING_CATEGORY_MASK_SJIS)
  3350.         mask = detect_coding_sjis (src, src_end);
  3351.           else if (priorities[i] & try & CODING_CATEGORY_MASK_BIG5)
  3352.         mask = detect_coding_big5 (src, src_end);      
  3353.           else if (priorities[i] & try & CODING_CATEGORY_MASK_EMACS_MULE)
  3354.         mask = detect_coding_emacs_mule (src, src_end);      
  3355.           else if (priorities[i] & try & CODING_CATEGORY_MASK_CCL)
  3356.         mask = detect_coding_ccl (src, src_end);
  3357.           else if (priorities[i] & CODING_CATEGORY_MASK_RAW_TEXT)
  3358.         mask = CODING_CATEGORY_MASK_RAW_TEXT;
  3359.           else if (priorities[i] & CODING_CATEGORY_MASK_BINARY)
  3360.         mask = CODING_CATEGORY_MASK_BINARY;
  3361.           if (mask)
  3362.         goto label_return_highest_only;
  3363.         }
  3364.       return CODING_CATEGORY_MASK_RAW_TEXT;
  3365.     }
  3366.       if (try & CODING_CATEGORY_MASK_ISO)
  3367.     mask |= detect_coding_iso2022 (src, src_end);
  3368.       if (try & CODING_CATEGORY_MASK_SJIS)
  3369.     mask |= detect_coding_sjis (src, src_end);
  3370.       if (try & CODING_CATEGORY_MASK_BIG5)
  3371.     mask |= detect_coding_big5 (src, src_end);      
  3372.       if (try & CODING_CATEGORY_MASK_EMACS_MULE)
  3373.     mask |= detect_coding_emacs_mule (src, src_end);
  3374.       if (try & CODING_CATEGORY_MASK_CCL)
  3375.     mask |= detect_coding_ccl (src, src_end);
  3376.     }
  3377.   return (mask | CODING_CATEGORY_MASK_RAW_TEXT | CODING_CATEGORY_MASK_BINARY);
  3378.  
  3379.  label_return_highest_only:
  3380.   for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
  3381.     {
  3382.       if (mask & priorities[i])
  3383.     return priorities[i];
  3384.     }
  3385.   return CODING_CATEGORY_MASK_RAW_TEXT;
  3386. }
  3387.  
  3388. /* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
  3389.    The information of the detected coding system is set in CODING.  */
  3390.  
  3391. void
  3392. detect_coding (coding, src, src_bytes)
  3393.      struct coding_system *coding;
  3394.      unsigned char *src;
  3395.      int src_bytes;
  3396. {
  3397.   unsigned int idx;
  3398.   int skip, mask, i;
  3399.   Lisp_Object val;
  3400.  
  3401.   val = Vcoding_category_list;
  3402.   mask = detect_coding_mask (src, src_bytes, coding_priorities, &skip);
  3403.   coding->heading_ascii = skip;
  3404.  
  3405.   if (!mask) return;
  3406.  
  3407.   /* We found a single coding system of the highest priority in MASK.  */
  3408.   idx = 0;
  3409.   while (mask && ! (mask & 1)) mask >>= 1, idx++;
  3410.   if (! mask)
  3411.     idx = CODING_CATEGORY_IDX_RAW_TEXT;
  3412.  
  3413.   val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[idx])->value;
  3414.  
  3415.   if (coding->eol_type != CODING_EOL_UNDECIDED)
  3416.     {
  3417.       Lisp_Object tmp;
  3418.  
  3419.       tmp = Fget (val, Qeol_type);
  3420.       if (VECTORP (tmp))
  3421.     val = XVECTOR (tmp)->contents[coding->eol_type];
  3422.     }
  3423.   setup_coding_system (val, coding);
  3424.   /* Set this again because setup_coding_system reset this member.  */
  3425.   coding->heading_ascii = skip;
  3426. }
  3427.  
  3428. /* Detect how end-of-line of a text of length SRC_BYTES pointed by
  3429.    SOURCE is encoded.  Return one of CODING_EOL_LF, CODING_EOL_CRLF,
  3430.    CODING_EOL_CR, and CODING_EOL_UNDECIDED.
  3431.  
  3432.    How many non-eol characters are at the head is returned as *SKIP.  */
  3433.  
  3434. #define MAX_EOL_CHECK_COUNT 3
  3435.  
  3436. static int
  3437. detect_eol_type (source, src_bytes, skip)
  3438.      unsigned char *source;
  3439.      int src_bytes, *skip;
  3440. {
  3441.   unsigned char *src = source, *src_end = src + src_bytes;
  3442.   unsigned char c;
  3443.   int total = 0;        /* How many end-of-lines are found so far.  */
  3444.   int eol_type = CODING_EOL_UNDECIDED;
  3445.   int this_eol_type;
  3446.  
  3447.   *skip = 0;
  3448.  
  3449.   while (src < src_end && total < MAX_EOL_CHECK_COUNT)
  3450.     {
  3451.       c = *src++;
  3452.       if (c == '\n' || c == '\r')
  3453.     {
  3454.       if (*skip == 0)
  3455.         *skip = src - 1 - source;
  3456.       total++;
  3457.       if (c == '\n')
  3458.         this_eol_type = CODING_EOL_LF;
  3459.       else if (src >= src_end || *src != '\n')
  3460.         this_eol_type = CODING_EOL_CR;
  3461.       else
  3462.         this_eol_type = CODING_EOL_CRLF, src++;
  3463.  
  3464.       if (eol_type == CODING_EOL_UNDECIDED)
  3465.         /* This is the first end-of-line.  */
  3466.         eol_type = this_eol_type;
  3467.       else if (eol_type != this_eol_type)
  3468.         {
  3469.           /* The found type is different from what found before.  */
  3470.           eol_type = CODING_EOL_INCONSISTENT;
  3471.           break;
  3472.         }
  3473.     }
  3474.     }
  3475.  
  3476.   if (*skip == 0)
  3477.     *skip = src_end - source;
  3478.   return eol_type;
  3479. }
  3480.  
  3481. /* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
  3482.    is encoded.  If it detects an appropriate format of end-of-line, it
  3483.    sets the information in *CODING.  */
  3484.  
  3485. void
  3486. detect_eol (coding, src, src_bytes)
  3487.      struct coding_system *coding;
  3488.      unsigned char *src;
  3489.      int src_bytes;
  3490. {
  3491.   Lisp_Object val;
  3492.   int skip;
  3493.   int eol_type = detect_eol_type (src, src_bytes, &skip);
  3494.  
  3495.   if (coding->heading_ascii > skip)
  3496.     coding->heading_ascii = skip;
  3497.   else
  3498.     skip = coding->heading_ascii;
  3499.  
  3500.   if (eol_type == CODING_EOL_UNDECIDED)
  3501.     return;
  3502.   if (eol_type == CODING_EOL_INCONSISTENT)
  3503.     {
  3504. #if 0
  3505.       /* This code is suppressed until we find a better way to
  3506.      distinguish raw text file and binary file.  */
  3507.  
  3508.       /* If we have already detected that the coding is raw-text, the
  3509.      coding should actually be no-conversion.  */
  3510.       if (coding->type == coding_type_raw_text)
  3511.     {
  3512.       setup_coding_system (Qno_conversion, coding);
  3513.       return;
  3514.     }
  3515.       /* Else, let's decode only text code anyway.  */
  3516. #endif /* 0 */
  3517.       eol_type = CODING_EOL_LF;
  3518.     }
  3519.  
  3520.   val = Fget (coding->symbol, Qeol_type);
  3521.   if (VECTORP (val) && XVECTOR (val)->size == 3)
  3522.     {
  3523.       setup_coding_system (XVECTOR (val)->contents[eol_type], coding);
  3524.       coding->heading_ascii = skip;
  3525.     }
  3526. }
  3527.  
  3528. #define CONVERSION_BUFFER_EXTRA_ROOM 256
  3529.  
  3530. #define DECODING_BUFFER_MAG(coding)                         \
  3531.   (coding->type == coding_type_iso2022                         \
  3532.    ? 3                                         \
  3533.    : ((coding->type == coding_type_sjis || coding->type == coding_type_big5) \
  3534.       ? 2                                     \
  3535.       : (coding->type == coding_type_raw_text                     \
  3536.      ? 1                                     \
  3537.      : (coding->type == coding_type_ccl                     \
  3538.         ? coding->spec.ccl.decoder.buf_magnification             \
  3539.         : 2))))
  3540.  
  3541. /* Return maximum size (bytes) of a buffer enough for decoding
  3542.    SRC_BYTES of text encoded in CODING.  */
  3543.  
  3544. int
  3545. decoding_buffer_size (coding, src_bytes)
  3546.      struct coding_system *coding;
  3547.      int src_bytes;
  3548. {
  3549.   return (src_bytes * DECODING_BUFFER_MAG (coding)
  3550.       + CONVERSION_BUFFER_EXTRA_ROOM);
  3551. }
  3552.  
  3553. /* Return maximum size (bytes) of a buffer enough for encoding
  3554.    SRC_BYTES of text to CODING.  */
  3555.  
  3556. int
  3557. encoding_buffer_size (coding, src_bytes)
  3558.      struct coding_system *coding;
  3559.      int src_bytes;
  3560. {
  3561.   int magnification;
  3562.  
  3563.   if (coding->type == coding_type_ccl)
  3564.     magnification = coding->spec.ccl.encoder.buf_magnification;
  3565.   else
  3566.     magnification = 3;
  3567.  
  3568.   return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
  3569. }
  3570.  
  3571. #ifndef MINIMUM_CONVERSION_BUFFER_SIZE
  3572. #define MINIMUM_CONVERSION_BUFFER_SIZE 1024
  3573. #endif
  3574.  
  3575. char *conversion_buffer;
  3576. int conversion_buffer_size;
  3577.  
  3578. /* Return a pointer to a SIZE bytes of buffer to be used for encoding
  3579.    or decoding.  Sufficient memory is allocated automatically.  If we
  3580.    run out of memory, return NULL.  */
  3581.  
  3582. char *
  3583. get_conversion_buffer (size)
  3584.      int size;
  3585. {
  3586.   if (size > conversion_buffer_size)
  3587.     {
  3588.       char *buf;
  3589.       int real_size = conversion_buffer_size * 2;
  3590.  
  3591.       while (real_size < size) real_size *= 2;
  3592.       buf = (char *) xmalloc (real_size);
  3593.       xfree (conversion_buffer);
  3594.       conversion_buffer = buf;
  3595.       conversion_buffer_size = real_size;
  3596.     }
  3597.   return conversion_buffer;
  3598. }
  3599.  
  3600. int
  3601. ccl_coding_driver (coding, source, destination, src_bytes, dst_bytes, encodep)
  3602.      struct coding_system *coding;
  3603.      unsigned char *source, *destination;
  3604.      int src_bytes, dst_bytes, encodep;
  3605. {
  3606.   struct ccl_program *ccl
  3607.     = encodep ? &coding->spec.ccl.encoder : &coding->spec.ccl.decoder;
  3608.   int result;
  3609.  
  3610.   if (encodep)
  3611.     ccl->last_block = coding->mode & CODING_MODE_LAST_BLOCK;
  3612.  
  3613.   coding->produced = ccl_driver (ccl, source, destination,
  3614.                  src_bytes, dst_bytes, &(coding->consumed));
  3615.   if (encodep)
  3616.     {
  3617.       coding->produced_char = coding->produced;
  3618.       coding->consumed_char
  3619.     = multibyte_chars_in_text (source, coding->consumed);
  3620.     }
  3621.   else
  3622.     {
  3623.       coding->produced_char
  3624.     = multibyte_chars_in_text (destination, coding->produced);
  3625.       coding->consumed_char = coding->consumed;
  3626.     }
  3627.   switch (ccl->status)
  3628.     {
  3629.     case CCL_STAT_SUSPEND_BY_SRC:
  3630.       result = CODING_FINISH_INSUFFICIENT_SRC;
  3631.       break;
  3632.     case CCL_STAT_SUSPEND_BY_DST:
  3633.       result = CODING_FINISH_INSUFFICIENT_DST;
  3634.       break;
  3635.     default:
  3636.       result = CODING_FINISH_NORMAL;
  3637.       break;
  3638.     }
  3639.   return result;
  3640. }
  3641.  
  3642. /* See "GENERAL NOTES about `decode_coding_XXX ()' functions".  Before
  3643.    decoding, it may detect coding system and format of end-of-line if
  3644.    those are not yet decided.  */
  3645.  
  3646. int
  3647. decode_coding (coding, source, destination, src_bytes, dst_bytes)
  3648.      struct coding_system *coding;
  3649.      unsigned char *source, *destination;
  3650.      int src_bytes, dst_bytes;
  3651. {
  3652.   int result;
  3653.  
  3654.   if (src_bytes <= 0)
  3655.     {
  3656.       coding->produced = coding->produced_char = 0;
  3657.       coding->consumed = coding->consumed_char = 0;
  3658.       coding->fake_multibyte = 0;
  3659.       return CODING_FINISH_NORMAL;
  3660.     }
  3661.  
  3662.   if (coding->type == coding_type_undecided)
  3663.     detect_coding (coding, source, src_bytes);
  3664.  
  3665.   if (coding->eol_type == CODING_EOL_UNDECIDED)
  3666.     detect_eol (coding, source, src_bytes);
  3667.  
  3668.   switch (coding->type)
  3669.     {
  3670.     case coding_type_emacs_mule:
  3671.     case coding_type_undecided:
  3672.     case coding_type_raw_text:
  3673.       if (coding->eol_type == CODING_EOL_LF
  3674.       ||  coding->eol_type == CODING_EOL_UNDECIDED)
  3675.     goto label_no_conversion;
  3676.       result = decode_eol (coding, source, destination, src_bytes, dst_bytes);
  3677.       break;
  3678.  
  3679.     case coding_type_sjis:
  3680.       result = decode_coding_sjis_big5 (coding, source, destination,
  3681.                     src_bytes, dst_bytes, 1);
  3682.       break;
  3683.  
  3684.     case coding_type_iso2022:
  3685.       result = decode_coding_iso2022 (coding, source, destination,
  3686.                       src_bytes, dst_bytes);
  3687.       break;
  3688.  
  3689.     case coding_type_big5:
  3690.       result = decode_coding_sjis_big5 (coding, source, destination,
  3691.                     src_bytes, dst_bytes, 0);
  3692.       break;
  3693.  
  3694.     case coding_type_ccl:
  3695.       result = ccl_coding_driver (coding, source, destination,
  3696.                   src_bytes, dst_bytes, 0);
  3697.       break;
  3698.  
  3699.     default:            /* i.e. case coding_type_no_conversion: */
  3700.     label_no_conversion:
  3701.       if (dst_bytes && src_bytes > dst_bytes)
  3702.     {
  3703.       coding->produced = dst_bytes;
  3704.       result = CODING_FINISH_INSUFFICIENT_DST;
  3705.     }
  3706.       else
  3707.     {
  3708.       coding->produced = src_bytes;
  3709.       result = CODING_FINISH_NORMAL;
  3710.     }
  3711.       if (dst_bytes)
  3712.     bcopy (source, destination, coding->produced);
  3713.       else
  3714.     safe_bcopy (source, destination, coding->produced);
  3715.       coding->fake_multibyte = 1;
  3716.       coding->consumed
  3717.     = coding->consumed_char = coding->produced_char = coding->produced;
  3718.       break;
  3719.     }
  3720.  
  3721.   return result;
  3722. }
  3723.  
  3724. /* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  */
  3725.  
  3726. int
  3727. encode_coding (coding, source, destination, src_bytes, dst_bytes)
  3728.      struct coding_system *coding;
  3729.      unsigned char *source, *destination;
  3730.      int src_bytes, dst_bytes;
  3731. {
  3732.   int result;
  3733.  
  3734.   if (src_bytes <= 0)
  3735.     {
  3736.       coding->produced = coding->produced_char = 0;
  3737.       coding->consumed = coding->consumed_char = 0;
  3738.       coding->fake_multibyte = 0;
  3739.       return CODING_FINISH_NORMAL;
  3740.     }
  3741.  
  3742.   switch (coding->type)
  3743.     {
  3744.     case coding_type_emacs_mule:
  3745.     case coding_type_undecided:
  3746.     case coding_type_raw_text:
  3747.       if (coding->eol_type == CODING_EOL_LF
  3748.       ||  coding->eol_type == CODING_EOL_UNDECIDED)
  3749.     goto label_no_conversion;
  3750.       result = encode_eol (coding, source, destination, src_bytes, dst_bytes);
  3751.       break;
  3752.  
  3753.     case coding_type_sjis:
  3754.       result = encode_coding_sjis_big5 (coding, source, destination,
  3755.                     src_bytes, dst_bytes, 1);
  3756.       break;
  3757.  
  3758.     case coding_type_iso2022:
  3759.       result = encode_coding_iso2022 (coding, source, destination,
  3760.                       src_bytes, dst_bytes);
  3761.       break;
  3762.  
  3763.     case coding_type_big5:
  3764.       result = encode_coding_sjis_big5 (coding, source, destination,
  3765.                     src_bytes, dst_bytes, 0);
  3766.       break;
  3767.  
  3768.     case coding_type_ccl:
  3769.       result = ccl_coding_driver (coding, source, destination,
  3770.                   src_bytes, dst_bytes, 1);
  3771.       break;
  3772.  
  3773.     default:            /* i.e. case coding_type_no_conversion: */
  3774.     label_no_conversion:
  3775.       if (dst_bytes && src_bytes > dst_bytes)
  3776.     {
  3777.       coding->produced = dst_bytes;
  3778.       result = CODING_FINISH_INSUFFICIENT_DST;
  3779.     }
  3780.       else
  3781.     {
  3782.       coding->produced = src_bytes;
  3783.       result = CODING_FINISH_NORMAL;
  3784.     }
  3785.       if (dst_bytes)
  3786.     bcopy (source, destination, coding->produced);
  3787.       else
  3788.     safe_bcopy (source, destination, coding->produced);
  3789.       if (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)
  3790.     {
  3791.       unsigned char *p = destination, *pend = p + coding->produced;
  3792.       while (p < pend)
  3793.         if (*p++ == '\015') p[-1] = '\n';
  3794.     }
  3795.       coding->fake_multibyte = 1;
  3796.       coding->consumed
  3797.     = coding->consumed_char = coding->produced_char = coding->produced;
  3798.       break;
  3799.     }
  3800.  
  3801.   return result;
  3802. }
  3803.  
  3804. /* Scan text in the region between *BEG and *END (byte positions),
  3805.    skip characters which we don't have to decode by coding system
  3806.    CODING at the head and tail, then set *BEG and *END to the region
  3807.    of the text we actually have to convert.  The caller should move
  3808.    the gap out of the region in advance.
  3809.  
  3810.    If STR is not NULL, *BEG and *END are indices into STR.  */
  3811.  
  3812. static void
  3813. shrink_decoding_region (beg, end, coding, str)
  3814.      int *beg, *end;
  3815.      struct coding_system *coding;
  3816.      unsigned char *str;
  3817. {
  3818.   unsigned char *begp_orig, *begp, *endp_orig, *endp, c;
  3819.   int eol_conversion;
  3820.  
  3821.   if (coding->type == coding_type_ccl
  3822.       || coding->type == coding_type_undecided
  3823.       || !NILP (coding->post_read_conversion))
  3824.     {
  3825.       /* We can't skip any data.  */
  3826.       return;
  3827.     }
  3828.   else if (coding->type == coding_type_no_conversion)
  3829.     {
  3830.       /* We need no conversion, but don't have to skip any data here.
  3831.          Decoding routine handles them effectively anyway.  */
  3832.       return;
  3833.     }
  3834.  
  3835.   eol_conversion = (coding->eol_type != CODING_EOL_LF);
  3836.  
  3837.   if ((! eol_conversion) && (coding->heading_ascii >= 0))
  3838.     /* Detection routine has already found how much we can skip at the
  3839.        head.  */
  3840.     *beg += coding->heading_ascii;
  3841.  
  3842.   if (str)
  3843.     {
  3844.       begp_orig = begp = str + *beg;
  3845.       endp_orig = endp = str + *end;
  3846.     }
  3847.   else
  3848.     {
  3849.       begp_orig = begp = BYTE_POS_ADDR (*beg);
  3850.       endp_orig = endp = begp + *end - *beg;
  3851.     }
  3852.  
  3853.   switch (coding->type)
  3854.     {
  3855.     case coding_type_emacs_mule:
  3856.     case coding_type_raw_text:
  3857.       if (eol_conversion)
  3858.     {
  3859.       if (coding->heading_ascii < 0)
  3860.         while (begp < endp && *begp != '\r' && *begp < 0x80) begp++;
  3861.       while (begp < endp && endp[-1] != '\r' && endp[-1] < 0x80)
  3862.         endp--;
  3863.       /* Do not consider LF as ascii if preceded by CR, since that
  3864.              confuses eol decoding. */
  3865.       if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
  3866.         endp++;
  3867.     }
  3868.       else
  3869.     begp = endp;
  3870.       break;
  3871.  
  3872.     case coding_type_sjis:
  3873.     case coding_type_big5:
  3874.       /* We can skip all ASCII characters at the head.  */
  3875.       if (coding->heading_ascii < 0)
  3876.     {
  3877.       if (eol_conversion)
  3878.         while (begp < endp && *begp < 0x80 && *begp != '\r') begp++;
  3879.       else
  3880.         while (begp < endp && *begp < 0x80) begp++;
  3881.     }
  3882.       /* We can skip all ASCII characters at the tail except for the
  3883.      second byte of SJIS or BIG5 code.  */
  3884.       if (eol_conversion)
  3885.     while (begp < endp && endp[-1] < 0x80 && endp[-1] != '\r') endp--;
  3886.       else
  3887.     while (begp < endp && endp[-1] < 0x80) endp--;
  3888.       /* Do not consider LF as ascii if preceded by CR, since that
  3889.      confuses eol decoding. */
  3890.       if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
  3891.     endp++;
  3892.       if (begp < endp && endp < endp_orig && endp[-1] >= 0x80)
  3893.     endp++;
  3894.       break;
  3895.  
  3896.     default:        /* i.e. case coding_type_iso2022: */
  3897.       if (coding->heading_ascii < 0)
  3898.     {
  3899.       /* We can skip all ASCII characters at the head except for a
  3900.          few control codes.  */
  3901.       while (begp < endp && (c = *begp) < 0x80
  3902.          && c != ISO_CODE_CR && c != ISO_CODE_SO
  3903.          && c != ISO_CODE_SI && c != ISO_CODE_ESC
  3904.          && (!eol_conversion || c != ISO_CODE_LF))
  3905.         begp++;
  3906.     }
  3907.       switch (coding->category_idx)
  3908.     {
  3909.     case CODING_CATEGORY_IDX_ISO_8_1:
  3910.     case CODING_CATEGORY_IDX_ISO_8_2:
  3911.       /* We can skip all ASCII characters at the tail.  */
  3912.       if (eol_conversion)
  3913.         while (begp < endp && (c = endp[-1]) < 0x80 && c != '\r') endp--;
  3914.       else
  3915.         while (begp < endp && endp[-1] < 0x80) endp--;
  3916.       /* Do not consider LF as ascii if preceded by CR, since that
  3917.              confuses eol decoding. */
  3918.       if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
  3919.         endp++;
  3920.       break;
  3921.  
  3922.     case CODING_CATEGORY_IDX_ISO_7:
  3923.     case CODING_CATEGORY_IDX_ISO_7_TIGHT:
  3924.       /* We can skip all charactes at the tail except for ESC and
  3925.              the following 2-byte at the tail.  */
  3926.       if (eol_conversion)
  3927.         while (begp < endp
  3928.            && (c = endp[-1]) < 0x80 && c != ISO_CODE_ESC && c != '\r')
  3929.           endp--;
  3930.       else
  3931.         while (begp < endp
  3932.            && (c = endp[-1]) < 0x80 && c != ISO_CODE_ESC)
  3933.           endp--;
  3934.       /* Do not consider LF as ascii if preceded by CR, since that
  3935.              confuses eol decoding. */
  3936.       if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
  3937.         endp++;
  3938.       if (begp < endp && endp[-1] == ISO_CODE_ESC)
  3939.         {
  3940.           if (endp + 1 < endp_orig && end[0] == '(' && end[1] == 'B')
  3941.         /* This is an ASCII designation sequence.  We can
  3942.                     surely skip the tail.  */
  3943.         endp += 2;
  3944.           else
  3945.         /* Hmmm, we can't skip the tail.  */
  3946.         endp = endp_orig;
  3947.         }
  3948.     }
  3949.     }
  3950.   *beg += begp - begp_orig;
  3951.   *end += endp - endp_orig;
  3952.   return;
  3953. }
  3954.  
  3955. /* Like shrink_decoding_region but for encoding.  */
  3956.  
  3957. static void
  3958. shrink_encoding_region (beg, end, coding, str)
  3959.      int *beg, *end;
  3960.      struct coding_system *coding;
  3961.      unsigned char *str;
  3962. {
  3963.   unsigned char *begp_orig, *begp, *endp_orig, *endp;
  3964.   int eol_conversion;
  3965.  
  3966.   if (coding->type == coding_type_ccl)
  3967.     /* We can't skip any data.  */
  3968.     return;
  3969.   else if (coding->type == coding_type_no_conversion)
  3970.     {
  3971.       /* We need no conversion.  */
  3972.       *beg = *end;
  3973.       return;
  3974.     }
  3975.  
  3976.   if (str)
  3977.     {
  3978.       begp_orig = begp = str + *beg;
  3979.       endp_orig = endp = str + *end;
  3980.     }
  3981.   else
  3982.     {
  3983.       begp_orig = begp = BYTE_POS_ADDR (*beg);
  3984.       endp_orig = endp = begp + *end - *beg;
  3985.     }
  3986.  
  3987.   eol_conversion = (coding->eol_type == CODING_EOL_CR
  3988.             || coding->eol_type == CODING_EOL_CRLF);
  3989.  
  3990.   /* Here, we don't have to check coding->pre_write_conversion because
  3991.      the caller is expected to have handled it already.  */
  3992.   switch (coding->type)
  3993.     {
  3994.     case coding_type_undecided:
  3995.     case coding_type_emacs_mule:
  3996.     case coding_type_raw_text:
  3997.       if (eol_conversion)
  3998.     {
  3999.       while (begp < endp && *begp != '\n') begp++;
  4000.       while (begp < endp && endp[-1] != '\n') endp--;
  4001.     }
  4002.       else
  4003.     begp = endp;
  4004.       break;
  4005.  
  4006.     case coding_type_iso2022:
  4007.       if (coding->flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL)
  4008.     {
  4009.       unsigned char *bol = begp; 
  4010.       while (begp < endp && *begp < 0x80)
  4011.         {
  4012.           begp++;
  4013.           if (begp[-1] == '\n')
  4014.         bol = begp;
  4015.         }
  4016.       begp = bol;
  4017.       goto label_skip_tail;
  4018.     }
  4019.       /* fall down ... */
  4020.  
  4021.     default:
  4022.       /* We can skip all ASCII characters at the head and tail.  */
  4023.       if (eol_conversion)
  4024.     while (begp < endp && *begp < 0x80 && *begp != '\n') begp++;
  4025.       else
  4026.     while (begp < endp && *begp < 0x80) begp++;
  4027.     label_skip_tail:
  4028.       if (eol_conversion)
  4029.     while (begp < endp && endp[-1] < 0x80 && endp[-1] != '\n') endp--;
  4030.       else
  4031.     while (begp < endp && *(endp - 1) < 0x80) endp--;
  4032.       break;
  4033.     }
  4034.  
  4035.   *beg += begp - begp_orig;
  4036.   *end += endp - endp_orig;
  4037.   return;
  4038. }
  4039.  
  4040. /* Decode (if ENCODEP is zero) or encode (if ENCODEP is nonzero) the
  4041.    text from FROM to TO (byte positions are FROM_BYTE and TO_BYTE) by
  4042.    coding system CODING, and return the status code of code conversion
  4043.    (currently, this value has no meaning).
  4044.  
  4045.    How many characters (and bytes) are converted to how many
  4046.    characters (and bytes) are recorded in members of the structure
  4047.    CODING.
  4048.  
  4049.    If REPLACE is nonzero, we do various things as if the original text
  4050.    is deleted and a new text is inserted.  See the comments in
  4051.    replace_range (insdel.c) to know what we are doing.  */
  4052.  
  4053. int
  4054. code_convert_region (from, from_byte, to, to_byte, coding, encodep, replace)
  4055.      int from, from_byte, to, to_byte, encodep, replace;
  4056.      struct coding_system *coding;
  4057. {
  4058.   int len = to - from, len_byte = to_byte - from_byte;
  4059.   int require, inserted, inserted_byte;
  4060.   int head_skip, tail_skip, total_skip;
  4061.   Lisp_Object saved_coding_symbol;
  4062.   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
  4063.   int first = 1;
  4064.   int fake_multibyte = 0;
  4065.   unsigned char *src, *dst;
  4066.   Lisp_Object deletion;
  4067.  
  4068.   deletion = Qnil;
  4069.   saved_coding_symbol = Qnil;
  4070.  
  4071.   if (from < PT && PT < to)
  4072.     SET_PT_BOTH (from, from_byte);
  4073.  
  4074.   if (replace)
  4075.     {
  4076.       int saved_from = from;
  4077.  
  4078.       prepare_to_modify_buffer (from, to, &from);
  4079.       if (saved_from != from)
  4080.     {
  4081.       to = from + len;
  4082.       if (multibyte)
  4083.         from_byte = CHAR_TO_BYTE (from), to_byte = CHAR_TO_BYTE (to);
  4084.       else
  4085.         from_byte = from, to_byte = to;
  4086.       len_byte = to_byte - from_byte;
  4087.     }
  4088.     }
  4089.  
  4090.   if (! encodep && CODING_REQUIRE_DETECTION (coding))
  4091.     {
  4092.       /* We must detect encoding of text and eol format.  */
  4093.  
  4094.       if (from < GPT && to > GPT)
  4095.     move_gap_both (from, from_byte);
  4096.       if (coding->type == coding_type_undecided)
  4097.     {
  4098.       detect_coding (coding, BYTE_POS_ADDR (from_byte), len_byte);
  4099.       if (coding->type == coding_type_undecided)
  4100.         /* It seems that the text contains only ASCII, but we
  4101.            should not left it undecided because the deeper
  4102.            decoding routine (decode_coding) tries to detect the
  4103.            encodings again in vain.  */
  4104.         coding->type = coding_type_emacs_mule;
  4105.     }
  4106.       if (coding->eol_type == CODING_EOL_UNDECIDED)
  4107.     {
  4108.       saved_coding_symbol = coding->symbol;
  4109.       detect_eol (coding, BYTE_POS_ADDR (from_byte), len_byte);
  4110.       if (coding->eol_type == CODING_EOL_UNDECIDED)
  4111.         coding->eol_type = CODING_EOL_LF;
  4112.       /* We had better recover the original eol format if we
  4113.          encounter an inconsitent eol format while decoding.  */
  4114.       coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
  4115.     }
  4116.     }
  4117.  
  4118.   coding->consumed_char = len, coding->consumed = len_byte;
  4119.  
  4120.   if (encodep
  4121.       ? ! CODING_REQUIRE_ENCODING (coding)
  4122.       : ! CODING_REQUIRE_DECODING (coding))
  4123.     {
  4124.       coding->produced = len_byte;
  4125.       if (multibyte
  4126.       && ! replace
  4127.       /* See the comment of the member heading_ascii in coding.h.  */
  4128.       && coding->heading_ascii < len_byte)
  4129.     {
  4130.       /* We still may have to combine byte at the head and the
  4131.              tail of the text in the region.  */
  4132.       if (from < GPT && GPT < to)
  4133.         move_gap_both (to, to_byte);
  4134.       len = multibyte_chars_in_text (BYTE_POS_ADDR (from_byte), len_byte);
  4135.       adjust_after_insert (from, from_byte, to, to_byte, len);
  4136.       coding->produced_char = len;
  4137.     }
  4138.       else
  4139.     {
  4140.       if (!replace)
  4141.         adjust_after_insert (from, from_byte, to, to_byte, len_byte);
  4142.       coding->produced_char = len_byte;
  4143.     }
  4144.       return 0;
  4145.     }
  4146.  
  4147.   /* Now we convert the text.  */
  4148.  
  4149.   /* For encoding, we must process pre-write-conversion in advance.  */
  4150.   if (encodep
  4151.       && ! NILP (coding->pre_write_conversion)
  4152.       && SYMBOLP (coding->pre_write_conversion)
  4153.       && ! NILP (Ffboundp (coding->pre_write_conversion)))
  4154.     {
  4155.       /* The function in pre-write-conversion may put a new text in a
  4156.          new buffer.  */
  4157.       struct buffer *prev = current_buffer, *new;
  4158.  
  4159.       call2 (coding->pre_write_conversion,
  4160.          make_number (from), make_number (to));
  4161.       if (current_buffer != prev)
  4162.     {
  4163.       len = ZV - BEGV;
  4164.       new = current_buffer;
  4165.       set_buffer_internal_1 (prev);
  4166.       del_range_2 (from, from_byte, to, to_byte);
  4167.       insert_from_buffer (new, BEG, len, 0);
  4168.       to = from + len;
  4169.       to_byte = multibyte ? CHAR_TO_BYTE (to) : to;
  4170.       len_byte = to_byte - from_byte;
  4171.     }
  4172.     }
  4173.  
  4174.   if (replace)
  4175.     deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
  4176.  
  4177.   /* Try to skip the heading and tailing ASCIIs.  */
  4178.   {
  4179.     int from_byte_orig = from_byte, to_byte_orig = to_byte;
  4180.  
  4181.     if (from < GPT && GPT < to)
  4182.       move_gap_both (from, from_byte);
  4183.     if (encodep)
  4184.       shrink_encoding_region (&from_byte, &to_byte, coding, NULL);
  4185.     else
  4186.       shrink_decoding_region (&from_byte, &to_byte, coding, NULL);
  4187.     if (from_byte == to_byte)
  4188.       {
  4189.     coding->produced = len_byte;
  4190.     coding->produced_char = multibyte ? len : len_byte;
  4191.     if (!replace)
  4192.       /* We must record and adjust for this new text now.  */
  4193.       adjust_after_insert (from, from_byte_orig, to, to_byte_orig, len);
  4194.     return 0;
  4195.       }
  4196.  
  4197.     head_skip = from_byte - from_byte_orig;
  4198.     tail_skip = to_byte_orig - to_byte;
  4199.     total_skip = head_skip + tail_skip;
  4200.     from += head_skip;
  4201.     to -= tail_skip;
  4202.     len -= total_skip; len_byte -= total_skip;
  4203.   }
  4204.  
  4205.   /* For converion, we must put the gap before the text in addition to
  4206.      making the gap larger for efficient decoding.  The required gap
  4207.      size starts from 2000 which is the magic number used in make_gap.
  4208.      But, after one batch of conversion, it will be incremented if we
  4209.      find that it is not enough .  */
  4210.   require = 2000;
  4211.  
  4212.   if (GAP_SIZE  < require)
  4213.     make_gap (require - GAP_SIZE);
  4214.   move_gap_both (from, from_byte);
  4215.  
  4216.   if (GPT - BEG < beg_unchanged)
  4217.     beg_unchanged = GPT - BEG;
  4218.   if (Z - GPT < end_unchanged)
  4219.     end_unchanged = Z - GPT;
  4220.  
  4221.   inserted = inserted_byte = 0;
  4222.   src = GAP_END_ADDR, dst = GPT_ADDR;
  4223.  
  4224.   GAP_SIZE += len_byte;
  4225.   ZV -= len;
  4226.   Z -= len;
  4227.   ZV_BYTE -= len_byte;
  4228.   Z_BYTE -= len_byte;
  4229.  
  4230.   for (;;)
  4231.     {
  4232.       int result;
  4233.  
  4234.       /* The buffer memory is changed from:
  4235.      +--------+converted-text+---------+-------original-text------+---+
  4236.      |<-from->|<--inserted-->|---------|<-----------len---------->|---|
  4237.           |<------------------- GAP_SIZE -------------------->|  */
  4238.       if (encodep)
  4239.     result = encode_coding (coding, src, dst, len_byte, 0);
  4240.       else
  4241.     result = decode_coding (coding, src, dst, len_byte, 0);
  4242.       /* to:
  4243.      +--------+-------converted-text--------+--+---original-text--+---+
  4244.      |<-from->|<--inserted-->|<--produced-->|--|<-(len-consumed)->|---|
  4245.           |<------------------- GAP_SIZE -------------------->|  */
  4246.       if (coding->fake_multibyte)
  4247.     fake_multibyte = 1;
  4248.  
  4249.       if (!encodep && !multibyte)
  4250.     coding->produced_char = coding->produced;
  4251.       inserted += coding->produced_char;
  4252.       inserted_byte += coding->produced;
  4253.       len_byte -= coding->consumed;
  4254.       src += coding->consumed;
  4255.       dst += inserted_byte;
  4256.  
  4257.       if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
  4258.     {
  4259.       unsigned char *pend = dst, *p = pend - inserted_byte;
  4260.  
  4261.       /* Encode LFs back to the original eol format (CR or CRLF).  */
  4262.       if (coding->eol_type == CODING_EOL_CR)
  4263.         {
  4264.           while (p < pend) if (*p++ == '\n') p[-1] = '\r';
  4265.         }
  4266.       else
  4267.         {
  4268.           int count = 0;
  4269.  
  4270.           while (p < pend) if (*p++ == '\n') count++;
  4271.           if (src - dst < count)
  4272.         {
  4273.           /* We don't have sufficient room for putting LFs
  4274.              back to CRLF.  We must record converted and
  4275.              not-yet-converted text back to the buffer
  4276.              content, enlarge the gap, then record them out of
  4277.              the buffer contents again.  */
  4278.           int add = len_byte + inserted_byte;
  4279.  
  4280.           GAP_SIZE -= add;
  4281.           ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
  4282.           GPT += inserted_byte; GPT_BYTE += inserted_byte;
  4283.           make_gap (count - GAP_SIZE);
  4284.           GAP_SIZE += add;
  4285.           ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
  4286.           GPT -= inserted_byte; GPT_BYTE -= inserted_byte;
  4287.           /* Don't forget to update SRC, DST, and PEND.  */
  4288.           src = GAP_END_ADDR - len_byte;
  4289.           dst = GPT_ADDR + inserted_byte;
  4290.           pend = dst;
  4291.         }
  4292.           inserted += count;
  4293.           inserted_byte += count;
  4294.           coding->produced += count;
  4295.           p = dst = pend + count;
  4296.           while (count)
  4297.         {
  4298.           *--p = *--pend;
  4299.           if (*p == '\n') count--, *--p = '\r';
  4300.         }
  4301.         }
  4302.  
  4303.       /* Suppress eol-format conversion in the further conversion.  */
  4304.       coding->eol_type = CODING_EOL_LF;
  4305.  
  4306.       /* Restore the original symbol.  */
  4307.       coding->symbol = saved_coding_symbol;
  4308.       
  4309.       continue;
  4310.     }
  4311.       if (len_byte <= 0)
  4312.     break;
  4313.       if (result == CODING_FINISH_INSUFFICIENT_SRC)
  4314.     {
  4315.       /* The source text ends in invalid codes.  Let's just
  4316.          make them valid buffer contents, and finish conversion.  */
  4317.       inserted += len_byte;
  4318.       inserted_byte += len_byte;
  4319.       while (len_byte--)
  4320.         *dst++ = *src++;
  4321.       fake_multibyte = 1;
  4322.       break;
  4323.     }
  4324.       if (first)
  4325.     {
  4326.       /* We have just done the first batch of conversion which was
  4327.          stoped because of insufficient gap.  Let's reconsider the
  4328.          required gap size (i.e. SRT - DST) now.
  4329.  
  4330.          We have converted ORIG bytes (== coding->consumed) into
  4331.          NEW bytes (coding->produced).  To convert the remaining
  4332.          LEN bytes, we may need REQUIRE bytes of gap, where:
  4333.         REQUIRE + LEN_BYTE = LEN_BYTE * (NEW / ORIG)
  4334.         REQUIRE = LEN_BYTE * (NEW - ORIG) / ORIG
  4335.          Here, we are sure that NEW >= ORIG.  */
  4336.       float ratio = coding->produced - coding->consumed;
  4337.       ratio /= coding->consumed;
  4338.       require = len_byte * ratio;
  4339.       first = 0;
  4340.     }
  4341.       if ((src - dst) < (require + 2000))
  4342.     {
  4343.       /* See the comment above the previous call of make_gap.  */
  4344.       int add = len_byte + inserted_byte;
  4345.  
  4346.       GAP_SIZE -= add;
  4347.       ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
  4348.       GPT += inserted_byte; GPT_BYTE += inserted_byte;
  4349.       make_gap (require + 2000);
  4350.       GAP_SIZE += add;
  4351.       ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
  4352.       GPT -= inserted_byte; GPT_BYTE -= inserted_byte;
  4353.       /* Don't forget to update SRC, DST.  */
  4354.       src = GAP_END_ADDR - len_byte;
  4355.       dst = GPT_ADDR + inserted_byte;
  4356.     }
  4357.     }
  4358.   if (src - dst > 0) *dst = 0; /* Put an anchor.  */
  4359.  
  4360.   if (multibyte
  4361.       && (fake_multibyte
  4362.       || !encodep && (to - from) != (to_byte - from_byte)))
  4363.     inserted = multibyte_chars_in_text (GPT_ADDR, inserted_byte);
  4364.  
  4365.   /* If we have shrinked the conversion area, adjust it now.  */ 
  4366.   if (total_skip > 0)
  4367.     {
  4368.       if (tail_skip > 0)
  4369.     safe_bcopy (GAP_END_ADDR, GPT_ADDR + inserted_byte, tail_skip);
  4370.       inserted += total_skip; inserted_byte += total_skip;
  4371.       GAP_SIZE += total_skip;
  4372.       GPT -= head_skip; GPT_BYTE -= head_skip;
  4373.       ZV -= total_skip; ZV_BYTE -= total_skip;
  4374.       Z -= total_skip; Z_BYTE -= total_skip;
  4375.       from -= head_skip; from_byte -= head_skip;
  4376.       to += tail_skip; to_byte += tail_skip;
  4377.     }
  4378.  
  4379.   adjust_after_replace (from, from_byte, deletion, inserted, inserted_byte);
  4380.  
  4381.   if (! encodep && ! NILP (coding->post_read_conversion))
  4382.     {
  4383.       Lisp_Object val;
  4384.       int orig_inserted = inserted, pos = PT;
  4385.  
  4386.       if (from != pos)
  4387.     temp_set_point_both (current_buffer, from, from_byte);
  4388.       val = call1 (coding->post_read_conversion, make_number (inserted));
  4389.       if (! NILP (val))
  4390.     {
  4391.       CHECK_NUMBER (val, 0);
  4392.       inserted = XFASTINT (val);
  4393.     }
  4394.       if (pos >= from + orig_inserted)
  4395.     temp_set_point (current_buffer, pos + (inserted - orig_inserted));
  4396.     }
  4397.  
  4398.   signal_after_change (from, to - from, inserted);
  4399.  
  4400.   {
  4401.     coding->consumed = to_byte - from_byte;
  4402.     coding->consumed_char = to - from;
  4403.     coding->produced = inserted_byte;
  4404.     coding->produced_char = inserted;
  4405.   }
  4406.  
  4407.   return 0;
  4408. }
  4409.  
  4410. Lisp_Object
  4411. code_convert_string (str, coding, encodep, nocopy)
  4412.      Lisp_Object str;
  4413.      struct coding_system *coding;
  4414.      int encodep, nocopy;
  4415. {
  4416.   int len;
  4417.   char *buf;
  4418.   int from = 0, to = XSTRING (str)->size;
  4419.   int to_byte = STRING_BYTES (XSTRING (str));
  4420.   struct gcpro gcpro1;
  4421.   Lisp_Object saved_coding_symbol;
  4422.   int result;
  4423.  
  4424.   saved_coding_symbol = Qnil;
  4425.   if (encodep && !NILP (coding->pre_write_conversion)
  4426.       || !encodep && !NILP (coding->post_read_conversion))
  4427.     {
  4428.       /* Since we have to call Lisp functions which assume target text
  4429.          is in a buffer, after setting a temporary buffer, call
  4430.          code_convert_region.  */
  4431.       int count = specpdl_ptr - specpdl;
  4432.       struct buffer *prev = current_buffer;
  4433.       
  4434.       record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
  4435.       temp_output_buffer_setup (" *code-converting-work*");
  4436.       set_buffer_internal (XBUFFER (Vstandard_output));
  4437.       if (encodep)
  4438.     insert_from_string (str, 0, 0, to, to_byte, 0);
  4439.       else
  4440.     {
  4441.       /* We must insert the contents of STR as is without
  4442.              unibyte<->multibyte conversion.  */
  4443.       current_buffer->enable_multibyte_characters = Qnil;
  4444.       insert_from_string (str, 0, 0, to_byte, to_byte, 0);
  4445.       current_buffer->enable_multibyte_characters = Qt;
  4446.     }
  4447.       code_convert_region (BEGV, BEGV_BYTE, ZV, ZV_BYTE, coding, encodep, 1);
  4448.       if (encodep)
  4449.     /* We must return the buffer contents as unibyte string.  */
  4450.     current_buffer->enable_multibyte_characters = Qnil;
  4451.       str = make_buffer_string (BEGV, ZV, 0);
  4452.       set_buffer_internal (prev);
  4453.       return unbind_to (count, str);
  4454.     }
  4455.  
  4456.   if (! encodep && CODING_REQUIRE_DETECTION (coding))
  4457.     {
  4458.       /* See the comments in code_convert_region.  */
  4459.       if (coding->type == coding_type_undecided)
  4460.     {
  4461.       detect_coding (coding, XSTRING (str)->data, to_byte);
  4462.       if (coding->type == coding_type_undecided)
  4463.         coding->type = coding_type_emacs_mule;
  4464.     }
  4465.       if (coding->eol_type == CODING_EOL_UNDECIDED)
  4466.     {
  4467.       saved_coding_symbol = coding->symbol;
  4468.       detect_eol (coding, XSTRING (str)->data, to_byte);
  4469.       if (coding->eol_type == CODING_EOL_UNDECIDED)
  4470.         coding->eol_type = CODING_EOL_LF;
  4471.       /* We had better recover the original eol format if we
  4472.          encounter an inconsitent eol format while decoding.  */
  4473.       coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
  4474.     }
  4475.     }
  4476.  
  4477.   if (encodep
  4478.       ? ! CODING_REQUIRE_ENCODING (coding)
  4479.       : ! CODING_REQUIRE_DECODING (coding))
  4480.     from = to_byte;
  4481.   else
  4482.     {
  4483.       /* Try to skip the heading and tailing ASCIIs.  */
  4484.       if (encodep)
  4485.     shrink_encoding_region (&from, &to_byte, coding, XSTRING (str)->data);
  4486.       else
  4487.     shrink_decoding_region (&from, &to_byte, coding, XSTRING (str)->data);
  4488.     }
  4489.   if (from == to_byte)
  4490.     return (nocopy ? str : Fcopy_sequence (str));
  4491.  
  4492.   if (encodep)
  4493.     len = encoding_buffer_size (coding, to_byte - from);
  4494.   else
  4495.     len = decoding_buffer_size (coding, to_byte - from);
  4496.   len += from + STRING_BYTES (XSTRING (str)) - to_byte;
  4497.   GCPRO1 (str);
  4498.   buf = get_conversion_buffer (len);
  4499.   UNGCPRO;
  4500.  
  4501.   if (from > 0)
  4502.     bcopy (XSTRING (str)->data, buf, from);
  4503.   result = (encodep
  4504.         ? encode_coding (coding, XSTRING (str)->data + from,
  4505.                  buf + from, to_byte - from, len)
  4506.         : decode_coding (coding, XSTRING (str)->data + from,
  4507.                  buf + from, to_byte - from, len));
  4508.   if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
  4509.     {
  4510.       /* We simple try to decode the whole string again but without
  4511.          eol-conversion this time.  */
  4512.       coding->eol_type = CODING_EOL_LF;
  4513.       coding->symbol = saved_coding_symbol;
  4514.       return code_convert_string (str, coding, encodep, nocopy);
  4515.     }
  4516.  
  4517.   bcopy (XSTRING (str)->data + to_byte, buf + from + coding->produced,
  4518.      STRING_BYTES (XSTRING (str)) - to_byte);
  4519.  
  4520.   len = from + STRING_BYTES (XSTRING (str)) - to_byte;
  4521.   if (encodep)
  4522.     str = make_unibyte_string (buf, len + coding->produced);
  4523.   else
  4524.     {
  4525.       int chars= (coding->fake_multibyte
  4526.           ? multibyte_chars_in_text (buf + from, coding->produced)
  4527.           : coding->produced_char);
  4528.       str = make_multibyte_string (buf, len + chars, len + coding->produced);
  4529.     }
  4530.  
  4531.   return str;
  4532. }
  4533.  
  4534.  
  4535. #ifdef emacs
  4536. /*** 8. Emacs Lisp library functions ***/
  4537.  
  4538. DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
  4539.   "Return t if OBJECT is nil or a coding-system.\n\
  4540. See the documentation of `make-coding-system' for information\n\
  4541. about coding-system objects.")
  4542.   (obj)
  4543.      Lisp_Object obj;
  4544. {
  4545.   if (NILP (obj))
  4546.     return Qt;
  4547.   if (!SYMBOLP (obj))
  4548.     return Qnil;
  4549.   /* Get coding-spec vector for OBJ.  */
  4550.   obj = Fget (obj, Qcoding_system);
  4551.   return ((VECTORP (obj) && XVECTOR (obj)->size == 5)
  4552.       ? Qt : Qnil);
  4553. }
  4554.  
  4555. DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
  4556.        Sread_non_nil_coding_system, 1, 1, 0,
  4557.   "Read a coding system from the minibuffer, prompting with string PROMPT.")
  4558.   (prompt)
  4559.      Lisp_Object prompt;
  4560. {
  4561.   Lisp_Object val;
  4562.   do
  4563.     {
  4564.       val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
  4565.                   Qt, Qnil, Qcoding_system_history, Qnil, Qnil);
  4566.     }
  4567.   while (XSTRING (val)->size == 0);
  4568.   return (Fintern (val, Qnil));
  4569. }
  4570.  
  4571. DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
  4572.   "Read a coding system from the minibuffer, prompting with string PROMPT.\n\
  4573. If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.")
  4574.   (prompt, default_coding_system)
  4575.      Lisp_Object prompt, default_coding_system;
  4576. {
  4577.   Lisp_Object val;
  4578.   if (SYMBOLP (default_coding_system))
  4579.     XSETSTRING (default_coding_system, XSYMBOL (default_coding_system)->name);
  4580.   val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
  4581.               Qt, Qnil, Qcoding_system_history,
  4582.               default_coding_system, Qnil);
  4583.   return (XSTRING (val)->size == 0 ? Qnil : Fintern (val, Qnil));
  4584. }
  4585.  
  4586. DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
  4587.        1, 1, 0,
  4588.   "Check validity of CODING-SYSTEM.\n\
  4589. If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.\n\
  4590. It is valid if it is a symbol with a non-nil `coding-system' property.\n\
  4591. The value of property should be a vector of length 5.")
  4592.   (coding_system)
  4593.      Lisp_Object coding_system;
  4594. {
  4595.   CHECK_SYMBOL (coding_system, 0);
  4596.   if (!NILP (Fcoding_system_p (coding_system)))
  4597.     return coding_system;
  4598.   while (1)
  4599.     Fsignal (Qcoding_system_error, Fcons (coding_system, Qnil));
  4600. }
  4601.  
  4602. Lisp_Object
  4603. detect_coding_system (src, src_bytes, highest)
  4604.      unsigned char *src;
  4605.      int src_bytes, highest;
  4606. {
  4607.   int coding_mask, eol_type;
  4608.   Lisp_Object val, tmp;
  4609.   int dummy;
  4610.  
  4611.   coding_mask = detect_coding_mask (src, src_bytes, NULL, &dummy);
  4612.   eol_type  = detect_eol_type (src, src_bytes, &dummy);
  4613.   if (eol_type == CODING_EOL_INCONSISTENT)
  4614.     eol_type == CODING_EOL_UNDECIDED;
  4615.  
  4616.   if (!coding_mask)
  4617.     {
  4618.       val = Qundecided;
  4619.       if (eol_type != CODING_EOL_UNDECIDED)
  4620.     {
  4621.       Lisp_Object val2;
  4622.       val2 = Fget (Qundecided, Qeol_type);
  4623.       if (VECTORP (val2))
  4624.         val = XVECTOR (val2)->contents[eol_type];
  4625.     }
  4626.       return (highest ? val : Fcons (val, Qnil));
  4627.     }
  4628.  
  4629.   /* At first, gather possible coding systems in VAL.  */
  4630.   val = Qnil;
  4631.   for (tmp = Vcoding_category_list; !NILP (tmp); tmp = XCONS (tmp)->cdr)
  4632.     {
  4633.       int idx
  4634.     = XFASTINT (Fget (XCONS (tmp)->car, Qcoding_category_index));
  4635.       if (coding_mask & (1 << idx))
  4636.     {
  4637.       val = Fcons (Fsymbol_value (XCONS (tmp)->car), val);
  4638.       if (highest)
  4639.         break;
  4640.     }
  4641.     }
  4642.   if (!highest)
  4643.     val = Fnreverse (val);
  4644.  
  4645.   /* Then, replace the elements with subsidiary coding systems.  */
  4646.   for (tmp = val; !NILP (tmp); tmp = XCONS (tmp)->cdr)
  4647.     {
  4648.       if (eol_type != CODING_EOL_UNDECIDED
  4649.       && eol_type != CODING_EOL_INCONSISTENT)
  4650.     {
  4651.       Lisp_Object eol;
  4652.       eol = Fget (XCONS (tmp)->car, Qeol_type);
  4653.       if (VECTORP (eol))
  4654.         XCONS (tmp)->car = XVECTOR (eol)->contents[eol_type];
  4655.     }
  4656.     }
  4657.   return (highest ? XCONS (val)->car : val);
  4658. }  
  4659.  
  4660. DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
  4661.        2, 3, 0,
  4662.   "Detect coding system of the text in the region between START and END.\n\
  4663. Return a list of possible coding systems ordered by priority.\n\
  4664. \n\
  4665. If only ASCII characters are found, it returns a list of single element\n\
  4666. `undecided' or its subsidiary coding system according to a detected\n\
  4667. end-of-line format.\n\
  4668. \n\
  4669. If optional argument HIGHEST is non-nil, return the coding system of\n\
  4670. highest priority.")
  4671.   (start, end, highest)
  4672.      Lisp_Object start, end, highest;
  4673. {
  4674.   int from, to;
  4675.   int from_byte, to_byte;
  4676.  
  4677.   CHECK_NUMBER_COERCE_MARKER (start, 0);
  4678.   CHECK_NUMBER_COERCE_MARKER (end, 1);
  4679.  
  4680.   validate_region (&start, &end);
  4681.   from = XINT (start), to = XINT (end);
  4682.   from_byte = CHAR_TO_BYTE (from);
  4683.   to_byte = CHAR_TO_BYTE (to);
  4684.  
  4685.   if (from < GPT && to >= GPT)
  4686.     move_gap_both (to, to_byte);
  4687.  
  4688.   return detect_coding_system (BYTE_POS_ADDR (from_byte),
  4689.                    to_byte - from_byte,
  4690.                    !NILP (highest));
  4691. }
  4692.  
  4693. DEFUN ("detect-coding-string", Fdetect_coding_string, Sdetect_coding_string,
  4694.        1, 2, 0,
  4695.   "Detect coding system of the text in STRING.\n\
  4696. Return a list of possible coding systems ordered by priority.\n\
  4697. \n\
  4698. If only ASCII characters are found, it returns a list of single element\n\
  4699. `undecided' or its subsidiary coding system according to a detected\n\
  4700. end-of-line format.\n\
  4701. \n\
  4702. If optional argument HIGHEST is non-nil, return the coding system of\n\
  4703. highest priority.")
  4704.   (string, highest)
  4705.      Lisp_Object string, highest;
  4706. {
  4707.   CHECK_STRING (string, 0);
  4708.  
  4709.   return detect_coding_system (XSTRING (string)->data,
  4710.                    STRING_BYTES (XSTRING (string)),
  4711.                    !NILP (highest));
  4712. }
  4713.  
  4714. Lisp_Object
  4715. code_convert_region1 (start, end, coding_system, encodep)
  4716.      Lisp_Object start, end, coding_system;
  4717.      int encodep;
  4718. {
  4719.   struct coding_system coding;
  4720.   int from, to, len;
  4721.  
  4722.   CHECK_NUMBER_COERCE_MARKER (start, 0);
  4723.   CHECK_NUMBER_COERCE_MARKER (end, 1);
  4724.   CHECK_SYMBOL (coding_system, 2);
  4725.  
  4726.   validate_region (&start, &end);
  4727.   from = XFASTINT (start);
  4728.   to = XFASTINT (end);
  4729.  
  4730.   if (NILP (coding_system))
  4731.     return make_number (to - from);
  4732.  
  4733.   if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
  4734.     error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
  4735.  
  4736.   coding.mode |= CODING_MODE_LAST_BLOCK;
  4737.   code_convert_region (from, CHAR_TO_BYTE (from), to, CHAR_TO_BYTE (to),
  4738.                &coding, encodep, 1);
  4739.   Vlast_coding_system_used = coding.symbol;
  4740.   return make_number (coding.produced_char);
  4741. }
  4742.  
  4743. DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
  4744.        3, 3, "r\nzCoding system: ",
  4745.   "Decode the current region by specified coding system.\n\
  4746. When called from a program, takes three arguments:\n\
  4747. START, END, and CODING-SYSTEM.  START and END are buffer positions.\n\
  4748. This function sets `last-coding-system-used' to the precise coding system\n\
  4749. used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
  4750. not fully specified.)\n\
  4751. It returns the length of the decoded text.")
  4752.   (start, end, coding_system)
  4753.      Lisp_Object start, end, coding_system;
  4754. {
  4755.   return code_convert_region1 (start, end, coding_system, 0);
  4756. }
  4757.  
  4758. DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
  4759.        3, 3, "r\nzCoding system: ",
  4760.   "Encode the current region by specified coding system.\n\
  4761. When called from a program, takes three arguments:\n\
  4762. START, END, and CODING-SYSTEM.  START and END are buffer positions.\n\
  4763. This function sets `last-coding-system-used' to the precise coding system\n\
  4764. used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
  4765. not fully specified.)\n\
  4766. It returns the length of the encoded text.")
  4767.   (start, end, coding_system)
  4768.      Lisp_Object start, end, coding_system;
  4769. {
  4770.   return code_convert_region1 (start, end, coding_system, 1);
  4771. }
  4772.  
  4773. Lisp_Object
  4774. code_convert_string1 (string, coding_system, nocopy, encodep)
  4775.      Lisp_Object string, coding_system, nocopy;
  4776.      int encodep;
  4777. {
  4778.   struct coding_system coding;
  4779.  
  4780.   CHECK_STRING (string, 0);
  4781.   CHECK_SYMBOL (coding_system, 1);
  4782.  
  4783.   if (NILP (coding_system))
  4784.     return (NILP (nocopy) ? Fcopy_sequence (string) : string);
  4785.  
  4786.   if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
  4787.     error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
  4788.  
  4789.   coding.mode |= CODING_MODE_LAST_BLOCK;
  4790.   Vlast_coding_system_used = coding.symbol;
  4791.   return code_convert_string (string, &coding, encodep, !NILP (nocopy));
  4792. }
  4793.  
  4794. DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
  4795.        2, 3, 0,
  4796.   "Decode STRING which is encoded in CODING-SYSTEM, and return the result.\n\
  4797. Optional arg NOCOPY non-nil means it is ok to return STRING itself\n\
  4798. if the decoding operation is trivial.\n\
  4799. This function sets `last-coding-system-used' to the precise coding system\n\
  4800. used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
  4801. not fully specified.)")
  4802.   (string, coding_system, nocopy)
  4803.      Lisp_Object string, coding_system, nocopy;
  4804. {
  4805.   return code_convert_string1 (string, coding_system, nocopy, 0);
  4806. }
  4807.  
  4808. DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
  4809.        2, 3, 0,
  4810.   "Encode STRING to CODING-SYSTEM, and return the result.\n\
  4811. Optional arg NOCOPY non-nil means it is ok to return STRING itself\n\
  4812. if the encoding operation is trivial.\n\
  4813. This function sets `last-coding-system-used' to the precise coding system\n\
  4814. used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
  4815. not fully specified.)")
  4816.   (string, coding_system, nocopy)
  4817.      Lisp_Object string, coding_system, nocopy;
  4818. {
  4819.   return code_convert_string1 (string, coding_system, nocopy, 1);
  4820. }
  4821.  
  4822. /* Encode or decode STRING according to CODING_SYSTEM.
  4823.    Do not set Vlast_coding_system_used.  */
  4824.  
  4825. Lisp_Object
  4826. code_convert_string_norecord (string, coding_system, encodep)
  4827.      Lisp_Object string, coding_system;
  4828.      int encodep;
  4829. {
  4830.   struct coding_system coding;
  4831.  
  4832.   CHECK_STRING (string, 0);
  4833.   CHECK_SYMBOL (coding_system, 1);
  4834.  
  4835.   if (NILP (coding_system))
  4836.     return string;
  4837.  
  4838.   if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
  4839.     error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
  4840.  
  4841.   coding.mode |= CODING_MODE_LAST_BLOCK;
  4842.   return code_convert_string (string, &coding, encodep, Qt);
  4843. }
  4844.  
  4845. DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
  4846.   "Decode a JISX0208 character of shift-jis encoding.\n\
  4847. CODE is the character code in SJIS.\n\
  4848. Return the corresponding character.")
  4849.   (code)
  4850.      Lisp_Object code;
  4851. {
  4852.   unsigned char c1, c2, s1, s2;
  4853.   Lisp_Object val;
  4854.  
  4855.   CHECK_NUMBER (code, 0);
  4856.   s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
  4857.   DECODE_SJIS (s1, s2, c1, c2);
  4858.   XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
  4859.   return val;
  4860. }
  4861.  
  4862. DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
  4863.   "Encode a JISX0208 character CHAR to SJIS coding system.\n\
  4864. Return the corresponding character code in SJIS.")
  4865.   (ch)
  4866.      Lisp_Object ch;
  4867. {
  4868.   int charset, c1, c2, s1, s2;
  4869.   Lisp_Object val;
  4870.  
  4871.   CHECK_NUMBER (ch, 0);
  4872.   SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
  4873.   if (charset == charset_jisx0208)
  4874.     {
  4875.       ENCODE_SJIS (c1, c2, s1, s2);
  4876.       XSETFASTINT (val, (s1 << 8) | s2);
  4877.     }
  4878.   else
  4879.     XSETFASTINT (val, 0);
  4880.   return val;
  4881. }
  4882.  
  4883. DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
  4884.   "Decode a Big5 character CODE of BIG5 coding system.\n\
  4885. CODE is the character code in BIG5.\n\
  4886. Return the corresponding character.")
  4887.   (code)
  4888.      Lisp_Object code;
  4889. {
  4890.   int charset;
  4891.   unsigned char b1, b2, c1, c2;
  4892.   Lisp_Object val;
  4893.  
  4894.   CHECK_NUMBER (code, 0);
  4895.   b1 = (XFASTINT (code)) >> 8, b2 = (XFASTINT (code)) & 0xFF;
  4896.   DECODE_BIG5 (b1, b2, charset, c1, c2);
  4897.   XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset, c1, c2));
  4898.   return val;
  4899. }
  4900.  
  4901. DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
  4902.   "Encode the Big5 character CHAR to BIG5 coding system.\n\
  4903. Return the corresponding character code in Big5.")
  4904.   (ch)
  4905.      Lisp_Object ch;
  4906. {
  4907.   int charset, c1, c2, b1, b2;
  4908.   Lisp_Object val;
  4909.  
  4910.   CHECK_NUMBER (ch, 0);
  4911.   SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
  4912.   if (charset == charset_big5_1 || charset == charset_big5_2)
  4913.     {
  4914.       ENCODE_BIG5 (charset, c1, c2, b1, b2);
  4915.       XSETFASTINT (val, (b1 << 8) | b2);
  4916.     }
  4917.   else
  4918.     XSETFASTINT (val, 0);
  4919.   return val;
  4920. }
  4921.  
  4922. DEFUN ("set-terminal-coding-system-internal",
  4923.        Fset_terminal_coding_system_internal,
  4924.        Sset_terminal_coding_system_internal, 1, 1, 0, "")
  4925.   (coding_system)
  4926.      Lisp_Object coding_system;
  4927. {
  4928.   CHECK_SYMBOL (coding_system, 0);
  4929.   setup_coding_system (Fcheck_coding_system (coding_system), &terminal_coding);
  4930.   /* We had better not send unsafe characters to terminal.  */
  4931.   terminal_coding.flags |= CODING_FLAG_ISO_SAFE;
  4932.  
  4933.   return Qnil;
  4934. }
  4935.  
  4936. DEFUN ("set-safe-terminal-coding-system-internal",
  4937.        Fset_safe_terminal_coding_system_internal,
  4938.        Sset_safe_terminal_coding_system_internal, 1, 1, 0, "")
  4939.   (coding_system)
  4940.      Lisp_Object coding_system;
  4941. {
  4942.   CHECK_SYMBOL (coding_system, 0);
  4943.   setup_coding_system (Fcheck_coding_system (coding_system),
  4944.                &safe_terminal_coding);
  4945.   return Qnil;
  4946. }
  4947.  
  4948. DEFUN ("terminal-coding-system",
  4949.        Fterminal_coding_system, Sterminal_coding_system, 0, 0, 0,
  4950.   "Return coding system specified for terminal output.")
  4951.   ()
  4952. {
  4953.   return terminal_coding.symbol;
  4954. }
  4955.  
  4956. DEFUN ("set-keyboard-coding-system-internal",
  4957.        Fset_keyboard_coding_system_internal,
  4958.        Sset_keyboard_coding_system_internal, 1, 1, 0, "")
  4959.   (coding_system)
  4960.      Lisp_Object coding_system;
  4961. {
  4962.   CHECK_SYMBOL (coding_system, 0);
  4963.   setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
  4964.   return Qnil;
  4965. }
  4966.  
  4967. DEFUN ("keyboard-coding-system",
  4968.        Fkeyboard_coding_system, Skeyboard_coding_system, 0, 0, 0,
  4969.   "Return coding system specified for decoding keyboard input.")
  4970.   ()
  4971. {
  4972.   return keyboard_coding.symbol;
  4973. }
  4974.  
  4975.  
  4976. DEFUN ("find-operation-coding-system", Ffind_operation_coding_system,
  4977.        Sfind_operation_coding_system,  1, MANY, 0,
  4978.   "Choose a coding system for an operation based on the target name.\n\
  4979. The value names a pair of coding systems: (DECODING-SYSTEM ENCODING-SYSTEM).\n\
  4980. DECODING-SYSTEM is the coding system to use for decoding\n\
  4981. \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system\n\
  4982. for encoding (in case OPERATION does encoding).\n\
  4983. \n\
  4984. The first argument OPERATION specifies an I/O primitive:\n\
  4985.   For file I/O, `insert-file-contents' or `write-region'.\n\
  4986.   For process I/O, `call-process', `call-process-region', or `start-process'.\n\
  4987.   For network I/O, `open-network-stream'.\n\
  4988. \n\
  4989. The remaining arguments should be the same arguments that were passed\n\
  4990. to the primitive.  Depending on which primitive, one of those arguments\n\
  4991. is selected as the TARGET.  For example, if OPERATION does file I/O,\n\
  4992. whichever argument specifies the file name is TARGET.\n\
  4993. \n\
  4994. TARGET has a meaning which depends on OPERATION:\n\
  4995.   For file I/O, TARGET is a file name.\n\
  4996.   For process I/O, TARGET is a process name.\n\
  4997.   For network I/O, TARGET is a service name or a port number\n\
  4998. \n\
  4999. This function looks up what specified for TARGET in,\n\
  5000. `file-coding-system-alist', `process-coding-system-alist',\n\
  5001. or `network-coding-system-alist' depending on OPERATION.\n\
  5002. They may specify a coding system, a cons of coding systems,\n\
  5003. or a function symbol to call.\n\
  5004. In the last case, we call the function with one argument,\n\
  5005. which is a list of all the arguments given to this function.")
  5006.   (nargs, args)
  5007.      int nargs;
  5008.      Lisp_Object *args;
  5009. {
  5010.   Lisp_Object operation, target_idx, target, val;
  5011.   register Lisp_Object chain;
  5012.  
  5013.   if (nargs < 2)
  5014.     error ("Too few arguments");
  5015.   operation = args[0];
  5016.   if (!SYMBOLP (operation)
  5017.       || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
  5018.     error ("Invalid first arguement");
  5019.   if (nargs < 1 + XINT (target_idx))
  5020.     error ("Too few arguments for operation: %s",
  5021.        XSYMBOL (operation)->name->data);
  5022.   target = args[XINT (target_idx) + 1];
  5023.   if (!(STRINGP (target)
  5024.     || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
  5025.     error ("Invalid %dth argument", XINT (target_idx) + 1);
  5026.  
  5027.   chain = ((EQ (operation, Qinsert_file_contents)
  5028.         || EQ (operation, Qwrite_region))
  5029.        ? Vfile_coding_system_alist
  5030.        : (EQ (operation, Qopen_network_stream)
  5031.           ? Vnetwork_coding_system_alist
  5032.           : Vprocess_coding_system_alist));
  5033.   if (NILP (chain))
  5034.     return Qnil;
  5035.  
  5036.   for (; CONSP (chain); chain = XCONS (chain)->cdr)
  5037.     {
  5038.       Lisp_Object elt;
  5039.       elt = XCONS (chain)->car;
  5040.  
  5041.       if (CONSP (elt)
  5042.       && ((STRINGP (target)
  5043.            && STRINGP (XCONS (elt)->car)
  5044.            && fast_string_match (XCONS (elt)->car, target) >= 0)
  5045.           || (INTEGERP (target) && EQ (target, XCONS (elt)->car))))
  5046.     {
  5047.       val = XCONS (elt)->cdr;
  5048.       /* Here, if VAL is both a valid coding system and a valid
  5049.              function symbol, we return VAL as a coding system.  */
  5050.       if (CONSP (val))
  5051.         return val;
  5052.       if (! SYMBOLP (val))
  5053.         return Qnil;
  5054.       if (! NILP (Fcoding_system_p (val)))
  5055.         return Fcons (val, val);
  5056.       if (! NILP (Ffboundp (val)))
  5057.         {
  5058.           val = call1 (val, Flist (nargs, args));
  5059.           if (CONSP (val))
  5060.         return val;
  5061.           if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
  5062.         return Fcons (val, val);
  5063.         }
  5064.       return Qnil;
  5065.     }
  5066.     }
  5067.   return Qnil;
  5068. }
  5069.  
  5070. DEFUN ("update-coding-systems-internal",  Fupdate_coding_systems_internal,
  5071.        Supdate_coding_systems_internal, 0, 0, 0,
  5072.   "Update internal database for ISO2022 and CCL based coding systems.\n\
  5073. When values of the following coding categories are changed, you must\n\
  5074. call this function:\n\
  5075.   coding-category-iso-7, coding-category-iso-7-tight,\n\
  5076.   coding-category-iso-8-1, coding-category-iso-8-2,\n\
  5077.   coding-category-iso-7-else, coding-category-iso-8-else,\n\
  5078.   coding-category-ccl")
  5079.   ()
  5080. {
  5081.   int i;
  5082.  
  5083.   for (i = CODING_CATEGORY_IDX_ISO_7; i <= CODING_CATEGORY_IDX_CCL; i++)
  5084.     {
  5085.       Lisp_Object val;
  5086.  
  5087.       val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value;
  5088.       if (!NILP (val))
  5089.     {
  5090.       if (! coding_system_table[i])
  5091.         coding_system_table[i] = ((struct coding_system *)
  5092.                       xmalloc (sizeof (struct coding_system)));
  5093.       setup_coding_system (val, coding_system_table[i]);
  5094.     }
  5095.       else if (coding_system_table[i])
  5096.     {
  5097.       xfree (coding_system_table[i]);
  5098.       coding_system_table[i] = NULL;
  5099.     }
  5100.     }
  5101.  
  5102.   return Qnil;
  5103. }
  5104.  
  5105. DEFUN ("set-coding-priority-internal", Fset_coding_priority_internal,
  5106.        Sset_coding_priority_internal, 0, 0, 0,
  5107.   "Update internal database for the current value of `coding-category-list'.\n\
  5108. This function is internal use only.")
  5109.   ()
  5110. {
  5111.   int i = 0, idx;
  5112.   Lisp_Object val;
  5113.  
  5114.   val = Vcoding_category_list;
  5115.  
  5116.   while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
  5117.     {
  5118.       if (! SYMBOLP (XCONS (val)->car))
  5119.     break;
  5120.       idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
  5121.       if (idx >= CODING_CATEGORY_IDX_MAX)
  5122.     break;
  5123.       coding_priorities[i++] = (1 << idx);
  5124.       val = XCONS (val)->cdr;
  5125.     }
  5126.   /* If coding-category-list is valid and contains all coding
  5127.      categories, `i' should be CODING_CATEGORY_IDX_MAX now.  If not,
  5128.      the following code saves Emacs from craching.  */
  5129.   while (i < CODING_CATEGORY_IDX_MAX)
  5130.     coding_priorities[i++] = CODING_CATEGORY_MASK_RAW_TEXT;
  5131.  
  5132.   return Qnil;
  5133. }
  5134.  
  5135. #endif /* emacs */
  5136.  
  5137.  
  5138. /*** 9. Post-amble ***/
  5139.  
  5140. void
  5141. init_coding ()
  5142. {
  5143.   conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
  5144. }
  5145.  
  5146. void
  5147. init_coding_once ()
  5148. {
  5149.   int i;
  5150.  
  5151.   /* Emacs' internal format specific initialize routine.  */ 
  5152.   for (i = 0; i <= 0x20; i++)
  5153.     emacs_code_class[i] = EMACS_control_code;
  5154.   emacs_code_class[0x0A] = EMACS_linefeed_code;
  5155.   emacs_code_class[0x0D] = EMACS_carriage_return_code;
  5156.   for (i = 0x21 ; i < 0x7F; i++)
  5157.     emacs_code_class[i] = EMACS_ascii_code;
  5158.   emacs_code_class[0x7F] = EMACS_control_code;
  5159.   emacs_code_class[0x80] = EMACS_leading_code_composition;
  5160.   for (i = 0x81; i < 0xFF; i++)
  5161.     emacs_code_class[i] = EMACS_invalid_code;
  5162.   emacs_code_class[LEADING_CODE_PRIVATE_11] = EMACS_leading_code_3;
  5163.   emacs_code_class[LEADING_CODE_PRIVATE_12] = EMACS_leading_code_3;
  5164.   emacs_code_class[LEADING_CODE_PRIVATE_21] = EMACS_leading_code_4;
  5165.   emacs_code_class[LEADING_CODE_PRIVATE_22] = EMACS_leading_code_4;
  5166.  
  5167.   /* ISO2022 specific initialize routine.  */
  5168.   for (i = 0; i < 0x20; i++)
  5169.     iso_code_class[i] = ISO_control_code;
  5170.   for (i = 0x21; i < 0x7F; i++)
  5171.     iso_code_class[i] = ISO_graphic_plane_0;
  5172.   for (i = 0x80; i < 0xA0; i++)
  5173.     iso_code_class[i] = ISO_control_code;
  5174.   for (i = 0xA1; i < 0xFF; i++)
  5175.     iso_code_class[i] = ISO_graphic_plane_1;
  5176.   iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
  5177.   iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
  5178.   iso_code_class[ISO_CODE_CR] = ISO_carriage_return;
  5179.   iso_code_class[ISO_CODE_SO] = ISO_shift_out;
  5180.   iso_code_class[ISO_CODE_SI] = ISO_shift_in;
  5181.   iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
  5182.   iso_code_class[ISO_CODE_ESC] = ISO_escape;
  5183.   iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
  5184.   iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
  5185.   iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
  5186.  
  5187.   conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
  5188.  
  5189.   setup_coding_system (Qnil, &keyboard_coding);
  5190.   setup_coding_system (Qnil, &terminal_coding);
  5191.   setup_coding_system (Qnil, &safe_terminal_coding);
  5192.   setup_coding_system (Qnil, &default_buffer_file_coding);
  5193.  
  5194.   bzero (coding_system_table, sizeof coding_system_table);
  5195.  
  5196.   bzero (ascii_skip_code, sizeof ascii_skip_code);
  5197.   for (i = 0; i < 128; i++)
  5198.     ascii_skip_code[i] = 1;
  5199.  
  5200. #if defined (MSDOS) || defined (WINDOWSNT)
  5201.   system_eol_type = CODING_EOL_CRLF;
  5202. #else
  5203.   system_eol_type = CODING_EOL_LF;
  5204. #endif
  5205. }
  5206.  
  5207. #ifdef emacs
  5208.  
  5209. void
  5210. syms_of_coding ()
  5211. {
  5212.   Qtarget_idx = intern ("target-idx");
  5213.   staticpro (&Qtarget_idx);
  5214.  
  5215.   Qcoding_system_history = intern ("coding-system-history");
  5216.   staticpro (&Qcoding_system_history);
  5217.   Fset (Qcoding_system_history, Qnil);
  5218.  
  5219.   /* Target FILENAME is the first argument.  */
  5220.   Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
  5221.   /* Target FILENAME is the third argument.  */
  5222.   Fput (Qwrite_region, Qtarget_idx, make_number (2));
  5223.  
  5224.   Qcall_process = intern ("call-process");
  5225.   staticpro (&Qcall_process);
  5226.   /* Target PROGRAM is the first argument.  */
  5227.   Fput (Qcall_process, Qtarget_idx, make_number (0));
  5228.  
  5229.   Qcall_process_region = intern ("call-process-region");
  5230.   staticpro (&Qcall_process_region);
  5231.   /* Target PROGRAM is the third argument.  */
  5232.   Fput (Qcall_process_region, Qtarget_idx, make_number (2));
  5233.  
  5234.   Qstart_process = intern ("start-process");
  5235.   staticpro (&Qstart_process);
  5236.   /* Target PROGRAM is the third argument.  */
  5237.   Fput (Qstart_process, Qtarget_idx, make_number (2));
  5238.  
  5239.   Qopen_network_stream = intern ("open-network-stream");
  5240.   staticpro (&Qopen_network_stream);
  5241.   /* Target SERVICE is the fourth argument.  */
  5242.   Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
  5243.  
  5244.   Qcoding_system = intern ("coding-system");
  5245.   staticpro (&Qcoding_system);
  5246.  
  5247.   Qeol_type = intern ("eol-type");
  5248.   staticpro (&Qeol_type);
  5249.  
  5250.   Qbuffer_file_coding_system = intern ("buffer-file-coding-system");
  5251.   staticpro (&Qbuffer_file_coding_system);
  5252.  
  5253.   Qpost_read_conversion = intern ("post-read-conversion");
  5254.   staticpro (&Qpost_read_conversion);
  5255.  
  5256.   Qpre_write_conversion = intern ("pre-write-conversion");
  5257.   staticpro (&Qpre_write_conversion);
  5258.  
  5259.   Qno_conversion = intern ("no-conversion");
  5260.   staticpro (&Qno_conversion);
  5261.  
  5262.   Qundecided = intern ("undecided");
  5263.   staticpro (&Qundecided);
  5264.  
  5265.   Qcoding_system_p = intern ("coding-system-p");
  5266.   staticpro (&Qcoding_system_p);
  5267.  
  5268.   Qcoding_system_error = intern ("coding-system-error");
  5269.   staticpro (&Qcoding_system_error);
  5270.  
  5271.   Fput (Qcoding_system_error, Qerror_conditions,
  5272.     Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
  5273.   Fput (Qcoding_system_error, Qerror_message,
  5274.     build_string ("Invalid coding system"));
  5275.  
  5276.   Qcoding_category = intern ("coding-category");
  5277.   staticpro (&Qcoding_category);
  5278.   Qcoding_category_index = intern ("coding-category-index");
  5279.   staticpro (&Qcoding_category_index);
  5280.  
  5281.   Vcoding_category_table
  5282.     = Fmake_vector (make_number (CODING_CATEGORY_IDX_MAX), Qnil);
  5283.   staticpro (&Vcoding_category_table);
  5284.   {
  5285.     int i;
  5286.     for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
  5287.       {
  5288.     XVECTOR (Vcoding_category_table)->contents[i]
  5289.       = intern (coding_category_name[i]);
  5290.     Fput (XVECTOR (Vcoding_category_table)->contents[i],
  5291.           Qcoding_category_index, make_number (i));
  5292.       }
  5293.   }
  5294.  
  5295.   Qtranslation_table = intern ("translation-table");
  5296.   staticpro (&Qtranslation_table);
  5297.   Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (1));
  5298.  
  5299.   Qtranslation_table_id = intern ("translation-table-id");
  5300.   staticpro (&Qtranslation_table_id);
  5301.  
  5302.   Qtranslation_table_for_decode = intern ("translation-table-for-decode");
  5303.   staticpro (&Qtranslation_table_for_decode);
  5304.  
  5305.   Qtranslation_table_for_encode = intern ("translation-table-for-encode");
  5306.   staticpro (&Qtranslation_table_for_encode);
  5307.  
  5308.   Qsafe_charsets = intern ("safe-charsets");
  5309.   staticpro (&Qsafe_charsets);
  5310.  
  5311.   Qvalid_codes = intern ("valid-codes");
  5312.   staticpro (&Qvalid_codes);
  5313.  
  5314.   Qemacs_mule = intern ("emacs-mule");
  5315.   staticpro (&Qemacs_mule);
  5316.  
  5317.   Qraw_text = intern ("raw-text");
  5318.   staticpro (&Qraw_text);
  5319.  
  5320.   defsubr (&Scoding_system_p);
  5321.   defsubr (&Sread_coding_system);
  5322.   defsubr (&Sread_non_nil_coding_system);
  5323.   defsubr (&Scheck_coding_system);
  5324.   defsubr (&Sdetect_coding_region);
  5325.   defsubr (&Sdetect_coding_string);
  5326.   defsubr (&Sdecode_coding_region);
  5327.   defsubr (&Sencode_coding_region);
  5328.   defsubr (&Sdecode_coding_string);
  5329.   defsubr (&Sencode_coding_string);
  5330.   defsubr (&Sdecode_sjis_char);
  5331.   defsubr (&Sencode_sjis_char);
  5332.   defsubr (&Sdecode_big5_char);
  5333.   defsubr (&Sencode_big5_char);
  5334.   defsubr (&Sset_terminal_coding_system_internal);
  5335.   defsubr (&Sset_safe_terminal_coding_system_internal);
  5336.   defsubr (&Sterminal_coding_system);
  5337.   defsubr (&Sset_keyboard_coding_system_internal);
  5338.   defsubr (&Skeyboard_coding_system);
  5339.   defsubr (&Sfind_operation_coding_system);
  5340.   defsubr (&Supdate_coding_systems_internal);
  5341.   defsubr (&Sset_coding_priority_internal);
  5342.  
  5343.   DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
  5344.     "List of coding systems.\n\
  5345. \n\
  5346. Do not alter the value of this variable manually.  This variable should be\n\
  5347. updated by the functions `make-coding-system' and\n\
  5348. `define-coding-system-alias'.");
  5349.   Vcoding_system_list = Qnil;
  5350.  
  5351.   DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
  5352.     "Alist of coding system names.\n\
  5353. Each element is one element list of coding system name.\n\
  5354. This variable is given to `completing-read' as TABLE argument.\n\
  5355. \n\
  5356. Do not alter the value of this variable manually.  This variable should be\n\
  5357. updated by the functions `make-coding-system' and\n\
  5358. `define-coding-system-alias'.");
  5359.   Vcoding_system_alist = Qnil;
  5360.  
  5361.   DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
  5362.     "List of coding-categories (symbols) ordered by priority.");
  5363.   {
  5364.     int i;
  5365.  
  5366.     Vcoding_category_list = Qnil;
  5367.     for (i = CODING_CATEGORY_IDX_MAX - 1; i >= 0; i--)
  5368.       Vcoding_category_list
  5369.     = Fcons (XVECTOR (Vcoding_category_table)->contents[i],
  5370.          Vcoding_category_list);
  5371.   }
  5372.  
  5373.   DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
  5374.     "Specify the coding system for read operations.\n\
  5375. It is useful to bind this variable with `let', but do not set it globally.\n\
  5376. If the value is a coding system, it is used for decoding on read operation.\n\
  5377. If not, an appropriate element is used from one of the coding system alists:\n\
  5378. There are three such tables, `file-coding-system-alist',\n\
  5379. `process-coding-system-alist', and `network-coding-system-alist'.");
  5380.   Vcoding_system_for_read = Qnil;
  5381.  
  5382.   DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
  5383.     "Specify the coding system for write operations.\n\
  5384. It is useful to bind this variable with `let', but do not set it globally.\n\
  5385. If the value is a coding system, it is used for encoding on write operation.\n\
  5386. If not, an appropriate element is used from one of the coding system alists:\n\
  5387. There are three such tables, `file-coding-system-alist',\n\
  5388. `process-coding-system-alist', and `network-coding-system-alist'.");
  5389.   Vcoding_system_for_write = Qnil;
  5390.  
  5391.   DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
  5392.     "Coding system used in the latest file or process I/O.");
  5393.   Vlast_coding_system_used = Qnil;
  5394.  
  5395.   DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
  5396.     "*Non-nil inhibit code conversion of end-of-line format in any cases.");
  5397.   inhibit_eol_conversion = 0;
  5398.  
  5399.   DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system,
  5400.     "Non-nil means process buffer inherits coding system of process output.\n\
  5401. Bind it to t if the process output is to be treated as if it were a file\n\
  5402. read from some filesystem.");
  5403.   inherit_process_coding_system = 0;
  5404.  
  5405.   DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist,
  5406.     "Alist to decide a coding system to use for a file I/O operation.\n\
  5407. The format is ((PATTERN . VAL) ...),\n\
  5408. where PATTERN is a regular expression matching a file name,\n\
  5409. VAL is a coding system, a cons of coding systems, or a function symbol.\n\
  5410. If VAL is a coding system, it is used for both decoding and encoding\n\
  5411. the file contents.\n\
  5412. If VAL is a cons of coding systems, the car part is used for decoding,\n\
  5413. and the cdr part is used for encoding.\n\
  5414. If VAL is a function symbol, the function must return a coding system\n\
  5415. or a cons of coding systems which are used as above.\n\
  5416. \n\
  5417. See also the function `find-operation-coding-system'.\n\
  5418. and the variable `auto-coding-alist'.");
  5419.   Vfile_coding_system_alist = Qnil;
  5420.  
  5421.   DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
  5422.     "Alist to decide a coding system to use for a process I/O operation.\n\
  5423. The format is ((PATTERN . VAL) ...),\n\
  5424. where PATTERN is a regular expression matching a program name,\n\
  5425. VAL is a coding system, a cons of coding systems, or a function symbol.\n\
  5426. If VAL is a coding system, it is used for both decoding what received\n\
  5427. from the program and encoding what sent to the program.\n\
  5428. If VAL is a cons of coding systems, the car part is used for decoding,\n\
  5429. and the cdr part is used for encoding.\n\
  5430. If VAL is a function symbol, the function must return a coding system\n\
  5431. or a cons of coding systems which are used as above.\n\
  5432. \n\
  5433. See also the function `find-operation-coding-system'.");
  5434.   Vprocess_coding_system_alist = Qnil;
  5435.  
  5436.   DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist,
  5437.     "Alist to decide a coding system to use for a network I/O operation.\n\
  5438. The format is ((PATTERN . VAL) ...),\n\
  5439. where PATTERN is a regular expression matching a network service name\n\
  5440. or is a port number to connect to,\n\
  5441. VAL is a coding system, a cons of coding systems, or a function symbol.\n\
  5442. If VAL is a coding system, it is used for both decoding what received\n\
  5443. from the network stream and encoding what sent to the network stream.\n\
  5444. If VAL is a cons of coding systems, the car part is used for decoding,\n\
  5445. and the cdr part is used for encoding.\n\
  5446. If VAL is a function symbol, the function must return a coding system\n\
  5447. or a cons of coding systems which are used as above.\n\
  5448. \n\
  5449. See also the function `find-operation-coding-system'.");
  5450.   Vnetwork_coding_system_alist = Qnil;
  5451.  
  5452.   DEFVAR_INT ("eol-mnemonic-unix", &eol_mnemonic_unix,
  5453.     "Mnemonic character indicating UNIX-like end-of-line format (i.e. LF) .");
  5454.   eol_mnemonic_unix = ':';
  5455.  
  5456.   DEFVAR_INT ("eol-mnemonic-dos", &eol_mnemonic_dos,
  5457.     "Mnemonic character indicating DOS-like end-of-line format (i.e. CRLF).");
  5458.   eol_mnemonic_dos = '\\';
  5459.  
  5460.   DEFVAR_INT ("eol-mnemonic-mac", &eol_mnemonic_mac,
  5461.     "Mnemonic character indicating MAC-like end-of-line format (i.e. CR).");
  5462.   eol_mnemonic_mac = '/';
  5463.  
  5464.   DEFVAR_INT ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
  5465.     "Mnemonic character indicating end-of-line format is not yet decided.");
  5466.   eol_mnemonic_undecided = ':';
  5467.  
  5468.   DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
  5469.     "*Non-nil enables character translation while encoding and decoding.");
  5470.   Venable_character_translation = Qt;
  5471.  
  5472.   DEFVAR_LISP ("standard-translation-table-for-decode",
  5473.     &Vstandard_translation_table_for_decode,
  5474.     "Table for translating characters while decoding.");
  5475.   Vstandard_translation_table_for_decode = Qnil;
  5476.  
  5477.   DEFVAR_LISP ("standard-translation-table-for-encode",
  5478.     &Vstandard_translation_table_for_encode,
  5479.     "Table for translationg characters while encoding.");
  5480.   Vstandard_translation_table_for_encode = Qnil;
  5481.  
  5482.   DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_alist,
  5483.     "Alist of charsets vs revision numbers.\n\
  5484. While encoding, if a charset (car part of an element) is found,\n\
  5485. designate it with the escape sequence identifing revision (cdr part of the element).");
  5486.   Vcharset_revision_alist = Qnil;
  5487.  
  5488.   DEFVAR_LISP ("default-process-coding-system",
  5489.            &Vdefault_process_coding_system,
  5490.     "Cons of coding systems used for process I/O by default.\n\
  5491. The car part is used for decoding a process output,\n\
  5492. the cdr part is used for encoding a text to be sent to a process.");
  5493.   Vdefault_process_coding_system = Qnil;
  5494.  
  5495.   DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table,
  5496.     "Table of extra Latin codes in the range 128..159 (inclusive).\n\
  5497. This is a vector of length 256.\n\
  5498. If Nth element is non-nil, the existence of code N in a file\n\
  5499. \(or output of subprocess) doesn't prevent it to be detected as\n\
  5500. a coding system of ISO 2022 variant which has a flag\n\
  5501. `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file\n\
  5502. or reading output of a subprocess.\n\
  5503. Only 128th through 159th elements has a meaning.");
  5504.   Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
  5505.  
  5506.   DEFVAR_LISP ("select-safe-coding-system-function",
  5507.            &Vselect_safe_coding_system_function,
  5508.     "Function to call to select safe coding system for encoding a text.\n\
  5509. \n\
  5510. If set, this function is called to force a user to select a proper\n\
  5511. coding system which can encode the text in the case that a default\n\
  5512. coding system used in each operation can't encode the text.\n\
  5513. \n\
  5514. The default value is `select-safe-codign-system' (which see).");
  5515.   Vselect_safe_coding_system_function = Qnil;
  5516.  
  5517. }
  5518.  
  5519. #endif /* emacs */
  5520.