annotate src/coding.c @ 94880:e1d2da11b5ac

Add autoload for `auth-source-user-or-password'. (smtpmail-try-auth-methods): Use it.

申鐃緒申     1 /* Coding system handler (conversion, detection, etc).
申鐃緒申     2    Copyright (C) 2001, 2002, 2003, 2004, 2005,
申鐃緒申     3                  2006, 2007, 2008 Free Software Foundation, Inc.
申鐃緒申     4    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
申鐃緒申     5      2005, 2006, 2007, 2008
申鐃緒申     6      National Institute of Advanced Industrial Science and Technology (AIST)
申鐃緒申     7      Registration Number H14PRO021
申鐃緒申     8    Copyright (C) 2003
申鐃緒申     9      National Institute of Advanced Industrial Science and Technology (AIST)
申鐃緒申    10      Registration Number H13PRO009
申鐃緒申    11 
申鐃緒申    12 This file is part of GNU Emacs.
申鐃緒申    13 
申鐃緒申    14 GNU Emacs is free software; you can redistribute it and/or modify
申鐃緒申    15 it under the terms of the GNU General Public License as published by
申鐃緒申    16 the Free Software Foundation; either version 3, or (at your option)
申鐃緒申    17 any later version.
申鐃緒申    18 
申鐃緒申    19 GNU Emacs is distributed in the hope that it will be useful,
申鐃緒申    20 but WITHOUT ANY WARRANTY; without even the implied warranty of
申鐃緒申    21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
申鐃緒申    22 GNU General Public License for more details.
申鐃緒申    23 
申鐃緒申    24 You should have received a copy of the GNU General Public License
申鐃緒申    25 along with GNU Emacs; see the file COPYING.  If not, write to
申鐃緒申    26 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
申鐃緒申    27 Boston, MA 02110-1301, USA.  */
申鐃緒申    28 
申鐃緒申    29 /*** TABLE OF CONTENTS ***
申鐃緒申    30 
申鐃緒申    31   0. General comments
申鐃緒申    32   1. Preamble
申鐃緒申    33   2. Emacs' internal format (emacs-utf-8) handlers
申鐃緒申    34   3. UTF-8 handlers
申鐃緒申    35   4. UTF-16 handlers
申鐃緒申    36   5. Charset-base coding systems handlers
申鐃緒申    37   6. emacs-mule (old Emacs' internal format) handlers
申鐃緒申    38   7. ISO2022 handlers
申鐃緒申    39   8. Shift-JIS and BIG5 handlers
申鐃緒申    40   9. CCL handlers
申鐃緒申    41   10. C library functions
申鐃緒申    42   11. Emacs Lisp library functions
申鐃緒申    43   12. Postamble
申鐃緒申    44 
申鐃緒申    45 */
申鐃緒申    46 
申鐃緒申    47 /*** 0. General comments ***
申鐃緒申    48 
申鐃緒申    49 
申鐃緒申    50 CODING SYSTEM
申鐃緒申    51 
申鐃緒申    52   A coding system is an object for an encoding mechanism that contains
申鐃緒申    53   information about how to convert byte sequences to character
申鐃緒申    54   sequences and vice versa.  When we say "decode", it means converting
申鐃緒申    55   a byte sequence of a specific coding system into a character
申鐃緒申    56   sequence that is represented by Emacs' internal coding system
申鐃緒申    57   `emacs-utf-8', and when we say "encode", it means converting a
申鐃緒申    58   character sequence of emacs-utf-8 to a byte sequence of a specific
申鐃緒申    59   coding system.
申鐃緒申    60 
申鐃緒申    61   In Emacs Lisp, a coding system is represented by a Lisp symbol.  In
申鐃緒申    62   C level, a coding system is represented by a vector of attributes
申鐃緒申    63   stored in the hash table Vcharset_hash_table.  The conversion from
申鐃緒申    64   coding system symbol to attributes vector is done by looking up
申鐃緒申    65   Vcharset_hash_table by the symbol.
申鐃緒申    66 
申鐃緒申    67   Coding systems are classified into the following types depending on
申鐃緒申    68   the encoding mechanism.  Here's a brief description of the types.
申鐃緒申    69 
申鐃緒申    70   o UTF-8
申鐃緒申    71 
申鐃緒申    72   o UTF-16
申鐃緒申    73 
申鐃緒申    74   o Charset-base coding system
申鐃緒申    75 
申鐃緒申    76   A coding system defined by one or more (coded) character sets.
申鐃緒申    77   Decoding and encoding are done by a code converter defined for each
申鐃緒申    78   character set.
申鐃緒申    79 
申鐃緒申    80   o Old Emacs internal format (emacs-mule)
申鐃緒申    81 
申鐃緒申    82   The coding system adopted by old versions of Emacs (20 and 21).
申鐃緒申    83 
申鐃緒申    84   o ISO2022-base coding system
申鐃緒申    85 
申鐃緒申    86   The most famous coding system for multiple character sets.  X's
申鐃緒申    87   Compound Text, various EUCs (Extended Unix Code), and coding systems
申鐃緒申    88   used in the Internet communication such as ISO-2022-JP are all
申鐃緒申    89   variants of ISO2022.
申鐃緒申    90 
申鐃緒申    91   o SJIS (or Shift-JIS or MS-Kanji-Code)
申鐃緒申    92 
申鐃緒申    93   A coding system to encode character sets: ASCII, JISX0201, and
申鐃緒申    94   JISX0208.  Widely used for PC's in Japan.  Details are described in
申鐃緒申    95   section 8.
申鐃緒申    96 
申鐃緒申    97   o BIG5
申鐃緒申    98 
申鐃緒申    99   A coding system to encode character sets: ASCII and Big5.  Widely
申鐃緒申   100   used for Chinese (mainly in Taiwan and Hong Kong).  Details are
申鐃緒申   101   described in section 8.  In this file, when we write "big5" (all
申鐃緒申   102   lowercase), we mean the coding system, and when we write "Big5"
申鐃緒申   103   (capitalized), we mean the character set.
申鐃緒申   104 
申鐃緒申   105   o CCL
申鐃緒申   106 
申鐃緒申   107   If a user wants to decode/encode text encoded in a coding system
申鐃緒申   108   not listed above, he can supply a decoder and an encoder for it in
申鐃緒申   109   CCL (Code Conversion Language) programs.  Emacs executes the CCL
申鐃緒申   110   program while decoding/encoding.
申鐃緒申   111 
申鐃緒申   112   o Raw-text
申鐃緒申   113 
申鐃緒申   114   A coding system for text containing raw eight-bit data.  Emacs
申鐃緒申   115   treats each byte of source text as a character (except for
申鐃緒申   116   end-of-line conversion).
申鐃緒申   117 
申鐃緒申   118   o No-conversion
申鐃緒申   119 
申鐃緒申   120   Like raw text, but don't do end-of-line conversion.
申鐃緒申   121 
申鐃緒申   122 
申鐃緒申   123 END-OF-LINE FORMAT
申鐃緒申   124 
申鐃緒申   125   How text end-of-line is encoded depends on operating system.  For
申鐃緒申   126   instance, Unix's format is just one byte of LF (line-feed) code,
申鐃緒申   127   whereas DOS's format is two-byte sequence of `carriage-return' and
申鐃緒申   128   `line-feed' codes.  MacOS's format is usually one byte of
申鐃緒申   129   `carriage-return'.
申鐃緒申   130 
申鐃緒申   131   Since text character encoding and end-of-line encoding are
申鐃緒申   132   independent, any coding system described above can take any format
申鐃緒申   133   of end-of-line (except for no-conversion).
申鐃緒申   134 
申鐃緒申   135 STRUCT CODING_SYSTEM
申鐃緒申   136 
申鐃緒申   137   Before using a coding system for code conversion (i.e. decoding and
申鐃緒申   138   encoding), we setup a structure of type `struct coding_system'.
申鐃緒申   139   This structure keeps various information about a specific code
申鐃緒申   140   conversion (e.g. the location of source and destination data).
申鐃緒申   141 
申鐃緒申   142 */
申鐃緒申   143 
申鐃緒申   144 /* COMMON MACROS */
申鐃緒申   145 
申鐃緒申   146 
申鐃緒申   147 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
申鐃緒申   148 
申鐃緒申   149   These functions check if a byte sequence specified as a source in
申鐃緒申   150   CODING conforms to the format of XXX, and update the members of
申鐃緒申   151   DETECT_INFO.
申鐃緒申   152 
申鐃緒申   153   Return 1 if the byte sequence conforms to XXX, otherwise return 0.
申鐃緒申   154 
申鐃緒申   155   Below is the template of these functions.  */
申鐃緒申   156 
申鐃緒申   157 #if 0
申鐃緒申   158 static int
申鐃緒申   159 detect_coding_XXX (coding, detect_info)
申鐃緒申   160      struct coding_system *coding;
申鐃緒申   161      struct coding_detection_info *detect_info;
申鐃緒申   162 {
申鐃緒申   163   const unsigned char *src = coding->source;
申鐃緒申   164   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申   165   int multibytep = coding->src_multibyte;
申鐃緒申   166   int consumed_chars = 0;
申鐃緒申   167   int found = 0;
申鐃緒申   168   ...;
申鐃緒申   169 
申鐃緒申   170   while (1)
申鐃緒申   171     {
申鐃緒申   172       /* Get one byte from the source.  If the souce is exausted, jump
申鐃緒申   173 	 to no_more_source:.  */
申鐃緒申   174       ONE_MORE_BYTE (c);
申鐃緒申   175 
申鐃緒申   176       if (! __C_conforms_to_XXX___ (c))
申鐃緒申   177 	break;
申鐃緒申   178       if (! __C_strongly_suggests_XXX__ (c))
申鐃緒申   179 	found = CATEGORY_MASK_XXX;
申鐃緒申   180     }
申鐃緒申   181   /* The byte sequence is invalid for XXX.  */
申鐃緒申   182   detect_info->rejected |= CATEGORY_MASK_XXX;
申鐃緒申   183   return 0;
申鐃緒申   184 
申鐃緒申   185  no_more_source:
申鐃緒申   186   /* The source exausted successfully.  */
申鐃緒申   187   detect_info->found |= found;
申鐃緒申   188   return 1;
申鐃緒申   189 }
申鐃緒申   190 #endif
申鐃緒申   191 
申鐃緒申   192 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
申鐃緒申   193 
申鐃緒申   194   These functions decode a byte sequence specified as a source by
申鐃緒申   195   CODING.  The resulting multibyte text goes to a place pointed to by
申鐃緒申   196   CODING->charbuf, the length of which should not exceed
申鐃緒申   197   CODING->charbuf_size;
申鐃緒申   198 
申鐃緒申   199   These functions set the information of original and decoded texts in
申鐃緒申   200   CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
申鐃緒申   201   They also set CODING->result to one of CODING_RESULT_XXX indicating
申鐃緒申   202   how the decoding is finished.
申鐃緒申   203 
申鐃緒申   204   Below is the template of these functions.  */
申鐃緒申   205 
申鐃緒申   206 #if 0
申鐃緒申   207 static void
申鐃緒申   208 decode_coding_XXXX (coding)
申鐃緒申   209      struct coding_system *coding;
申鐃緒申   210 {
申鐃緒申   211   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申   212   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申   213   /* SRC_BASE remembers the start position in source in each loop.
申鐃緒申   214      The loop will be exited when there's not enough source code, or
申鐃緒申   215      when there's no room in CHARBUF for a decoded character.  */
申鐃緒申   216   const unsigned char *src_base;
申鐃緒申   217   /* A buffer to produce decoded characters.  */
申鐃緒申   218   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申   219   int *charbuf_end = coding->charbuf + coding->charbuf_size;
申鐃緒申   220   int multibytep = coding->src_multibyte;
申鐃緒申   221 
申鐃緒申   222   while (1)
申鐃緒申   223     {
申鐃緒申   224       src_base = src;
申鐃緒申   225       if (charbuf < charbuf_end)
申鐃緒申   226 	/* No more room to produce a decoded character.  */
申鐃緒申   227 	break;
申鐃緒申   228       ONE_MORE_BYTE (c);
申鐃緒申   229       /* Decode it. */
申鐃緒申   230     }
申鐃緒申   231 
申鐃緒申   232  no_more_source:
申鐃緒申   233   if (src_base < src_end
申鐃緒申   234       && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申   235     /* If the source ends by partial bytes to construct a character,
申鐃緒申   236        treat them as eight-bit raw data.  */
申鐃緒申   237     while (src_base < src_end && charbuf < charbuf_end)
申鐃緒申   238       *charbuf++ = *src_base++;
申鐃緒申   239   /* Remember how many bytes and characters we consumed.  If the
申鐃緒申   240      source is multibyte, the bytes and chars are not identical.  */
申鐃緒申   241   coding->consumed = coding->consumed_char = src_base - coding->source;
申鐃緒申   242   /* Remember how many characters we produced.  */
申鐃緒申   243   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申   244 }
申鐃緒申   245 #endif
申鐃緒申   246 
申鐃緒申   247 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
申鐃緒申   248 
申鐃緒申   249   These functions encode SRC_BYTES length text at SOURCE of Emacs'
申鐃緒申   250   internal multibyte format by CODING.  The resulting byte sequence
申鐃緒申   251   goes to a place pointed to by DESTINATION, the length of which
申鐃緒申   252   should not exceed DST_BYTES.
申鐃緒申   253 
申鐃緒申   254   These functions set the information of original and encoded texts in
申鐃緒申   255   the members produced, produced_char, consumed, and consumed_char of
申鐃緒申   256   the structure *CODING.  They also set the member result to one of
申鐃緒申   257   CODING_RESULT_XXX indicating how the encoding finished.
申鐃緒申   258 
申鐃緒申   259   DST_BYTES zero means that source area and destination area are
申鐃緒申   260   overlapped, which means that we can produce a encoded text until it
申鐃緒申   261   reaches at the head of not-yet-encoded source text.
申鐃緒申   262 
申鐃緒申   263   Below is a template of these functions.  */
申鐃緒申   264 #if 0
申鐃緒申   265 static void
申鐃緒申   266 encode_coding_XXX (coding)
申鐃緒申   267      struct coding_system *coding;
申鐃緒申   268 {
申鐃緒申   269   int multibytep = coding->dst_multibyte;
申鐃緒申   270   int *charbuf = coding->charbuf;
申鐃緒申   271   int *charbuf_end = charbuf->charbuf + coding->charbuf_used;
申鐃緒申   272   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申   273   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申   274   unsigned char *adjusted_dst_end = dst_end - _MAX_BYTES_PRODUCED_IN_LOOP_;
申鐃緒申   275   int produced_chars = 0;
申鐃緒申   276 
申鐃緒申   277   for (; charbuf < charbuf_end && dst < adjusted_dst_end; charbuf++)
申鐃緒申   278     {
申鐃緒申   279       int c = *charbuf;
申鐃緒申   280       /* Encode C into DST, and increment DST.  */
申鐃緒申   281     }
申鐃緒申   282  label_no_more_destination:
申鐃緒申   283   /* How many chars and bytes we produced.  */
申鐃緒申   284   coding->produced_char += produced_chars;
申鐃緒申   285   coding->produced = dst - coding->destination;
申鐃緒申   286 }
申鐃緒申   287 #endif
申鐃緒申   288 
申鐃緒申   289 
申鐃緒申   290 /*** 1. Preamble ***/
申鐃緒申   291 
申鐃緒申   292 #include <config.h>
申鐃緒申   293 #include <stdio.h>
申鐃緒申   294 
申鐃緒申   295 #include "lisp.h"
申鐃緒申   296 #include "buffer.h"
申鐃緒申   297 #include "character.h"
申鐃緒申   298 #include "charset.h"
申鐃緒申   299 #include "ccl.h"
申鐃緒申   300 #include "composite.h"
申鐃緒申   301 #include "coding.h"
申鐃緒申   302 #include "window.h"
申鐃緒申   303 #include "frame.h"
申鐃緒申   304 #include "termhooks.h"
申鐃緒申   305 
申鐃緒申   306 Lisp_Object Vcoding_system_hash_table;
申鐃緒申   307 
申鐃緒申   308 Lisp_Object Qcoding_system, Qcoding_aliases, Qeol_type;
申鐃緒申   309 Lisp_Object Qunix, Qdos;
申鐃緒申   310 extern Lisp_Object Qmac;	/* frame.c */
申鐃緒申   311 Lisp_Object Qbuffer_file_coding_system;
申鐃緒申   312 Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
申鐃緒申   313 Lisp_Object Qdefault_char;
申鐃緒申   314 Lisp_Object Qno_conversion, Qundecided;
申鐃緒申   315 Lisp_Object Qcharset, Qiso_2022, Qutf_8, Qutf_16, Qshift_jis, Qbig5;
申鐃緒申   316 Lisp_Object Qbig, Qlittle;
申鐃緒申   317 Lisp_Object Qcoding_system_history;
申鐃緒申   318 Lisp_Object Qvalid_codes;
申鐃緒申   319 Lisp_Object QCcategory, QCmnemonic, QCdefalut_char;
申鐃緒申   320 Lisp_Object QCdecode_translation_table, QCencode_translation_table;
申鐃緒申   321 Lisp_Object QCpost_read_conversion, QCpre_write_conversion;
申鐃緒申   322 Lisp_Object QCascii_compatible_p;
申鐃緒申   323 
申鐃緒申   324 extern Lisp_Object Qinsert_file_contents, Qwrite_region;
申鐃緒申   325 Lisp_Object Qcall_process, Qcall_process_region;
申鐃緒申   326 Lisp_Object Qstart_process, Qopen_network_stream;
申鐃緒申   327 Lisp_Object Qtarget_idx;
申鐃緒申   328 
申鐃緒申   329 Lisp_Object Qinsufficient_source, Qinconsistent_eol, Qinvalid_source;
申鐃緒申   330 Lisp_Object Qinterrupted, Qinsufficient_memory;
申鐃緒申   331 
申鐃緒申   332 extern Lisp_Object Qcompletion_ignore_case;
申鐃緒申   333 
申鐃緒申   334 /* If a symbol has this property, evaluate the value to define the
申鐃緒申   335    symbol as a coding system.  */
申鐃緒申   336 static Lisp_Object Qcoding_system_define_form;
申鐃緒申   337 
申鐃緒申   338 int coding_system_require_warning;
申鐃緒申   339 
申鐃緒申   340 Lisp_Object Vselect_safe_coding_system_function;
申鐃緒申   341 
申鐃緒申   342 /* Mnemonic string for each format of end-of-line.  */
申鐃緒申   343 Lisp_Object eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
申鐃緒申   344 /* Mnemonic string to indicate format of end-of-line is not yet
申鐃緒申   345    decided.  */
申鐃緒申   346 Lisp_Object eol_mnemonic_undecided;
申鐃緒申   347 
申鐃緒申   348 /* Format of end-of-line decided by system.  This is Qunix on
申鐃緒申   349    Unix and Mac, Qdos on DOS/Windows.
申鐃緒申   350    This has an effect only for external encoding (i.e. for output to
申鐃緒申   351    file and process), not for in-buffer or Lisp string encoding.  */
申鐃緒申   352 static Lisp_Object system_eol_type;
申鐃緒申   353 
申鐃緒申   354 #ifdef emacs
申鐃緒申   355 
申鐃緒申   356 Lisp_Object Vcoding_system_list, Vcoding_system_alist;
申鐃緒申   357 
申鐃緒申   358 Lisp_Object Qcoding_system_p, Qcoding_system_error;
申鐃緒申   359 
申鐃緒申   360 /* Coding system emacs-mule and raw-text are for converting only
申鐃緒申   361    end-of-line format.  */
申鐃緒申   362 Lisp_Object Qemacs_mule, Qraw_text;
申鐃緒申   363 Lisp_Object Qutf_8_emacs;
申鐃緒申   364 
申鐃緒申   365 /* Coding-systems are handed between Emacs Lisp programs and C internal
申鐃緒申   366    routines by the following three variables.  */
申鐃緒申   367 /* Coding-system for reading files and receiving data from process.  */
申鐃緒申   368 Lisp_Object Vcoding_system_for_read;
申鐃緒申   369 /* Coding-system for writing files and sending data to process.  */
申鐃緒申   370 Lisp_Object Vcoding_system_for_write;
申鐃緒申   371 /* Coding-system actually used in the latest I/O.  */
申鐃緒申   372 Lisp_Object Vlast_coding_system_used;
申鐃緒申   373 /* Set to non-nil when an error is detected while code conversion.  */
申鐃緒申   374 Lisp_Object Vlast_code_conversion_error;
申鐃緒申   375 /* A vector of length 256 which contains information about special
申鐃緒申   376    Latin codes (especially for dealing with Microsoft codes).  */
申鐃緒申   377 Lisp_Object Vlatin_extra_code_table;
申鐃緒申   378 
申鐃緒申   379 /* Flag to inhibit code conversion of end-of-line format.  */
申鐃緒申   380 int inhibit_eol_conversion;
申鐃緒申   381 
申鐃緒申   382 /* Flag to inhibit ISO2022 escape sequence detection.  */
申鐃緒申   383 int inhibit_iso_escape_detection;
申鐃緒申   384 
申鐃緒申   385 /* Flag to make buffer-file-coding-system inherit from process-coding.  */
申鐃緒申   386 int inherit_process_coding_system;
申鐃緒申   387 
申鐃緒申   388 /* Coding system to be used to encode text for terminal display when
申鐃緒申   389    terminal coding system is nil.  */
申鐃緒申   390 struct coding_system safe_terminal_coding;
申鐃緒申   391 
申鐃緒申   392 Lisp_Object Vfile_coding_system_alist;
申鐃緒申   393 Lisp_Object Vprocess_coding_system_alist;
申鐃緒申   394 Lisp_Object Vnetwork_coding_system_alist;
申鐃緒申   395 
申鐃緒申   396 Lisp_Object Vlocale_coding_system;
申鐃緒申   397 
申鐃緒申   398 #endif /* emacs */
申鐃緒申   399 
申鐃緒申   400 /* Flag to tell if we look up translation table on character code
申鐃緒申   401    conversion.  */
申鐃緒申   402 Lisp_Object Venable_character_translation;
申鐃緒申   403 /* Standard translation table to look up on decoding (reading).  */
申鐃緒申   404 Lisp_Object Vstandard_translation_table_for_decode;
申鐃緒申   405 /* Standard translation table to look up on encoding (writing).  */
申鐃緒申   406 Lisp_Object Vstandard_translation_table_for_encode;
申鐃緒申   407 
申鐃緒申   408 Lisp_Object Qtranslation_table;
申鐃緒申   409 Lisp_Object Qtranslation_table_id;
申鐃緒申   410 Lisp_Object Qtranslation_table_for_decode;
申鐃緒申   411 Lisp_Object Qtranslation_table_for_encode;
申鐃緒申   412 
申鐃緒申   413 /* Alist of charsets vs revision number.  */
申鐃緒申   414 static Lisp_Object Vcharset_revision_table;
申鐃緒申   415 
申鐃緒申   416 /* Default coding systems used for process I/O.  */
申鐃緒申   417 Lisp_Object Vdefault_process_coding_system;
申鐃緒申   418 
申鐃緒申   419 /* Char table for translating Quail and self-inserting input.  */
申鐃緒申   420 Lisp_Object Vtranslation_table_for_input;
申鐃緒申   421 
申鐃緒申   422 /* Two special coding systems.  */
申鐃緒申   423 Lisp_Object Vsjis_coding_system;
申鐃緒申   424 Lisp_Object Vbig5_coding_system;
申鐃緒申   425 
申鐃緒申   426 /* ISO2022 section */
申鐃緒申   427 
申鐃緒申   428 #define CODING_ISO_INITIAL(coding, reg)			\
申鐃緒申   429   (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id),	\
申鐃緒申   430 		     coding_attr_iso_initial),		\
申鐃緒申   431 	       reg)))
申鐃緒申   432 
申鐃緒申   433 
申鐃緒申   434 #define CODING_ISO_REQUEST(coding, charset_id)	\
申鐃緒申   435   ((charset_id <= (coding)->max_charset_id	\
申鐃緒申   436     ? (coding)->safe_charsets[charset_id]	\
申鐃緒申   437     : -1))
申鐃緒申   438 
申鐃緒申   439 
申鐃緒申   440 #define CODING_ISO_FLAGS(coding)	\
申鐃緒申   441   ((coding)->spec.iso_2022.flags)
申鐃緒申   442 #define CODING_ISO_DESIGNATION(coding, reg)	\
申鐃緒申   443   ((coding)->spec.iso_2022.current_designation[reg])
申鐃緒申   444 #define CODING_ISO_INVOCATION(coding, plane)	\
申鐃緒申   445   ((coding)->spec.iso_2022.current_invocation[plane])
申鐃緒申   446 #define CODING_ISO_SINGLE_SHIFTING(coding)	\
申鐃緒申   447   ((coding)->spec.iso_2022.single_shifting)
申鐃緒申   448 #define CODING_ISO_BOL(coding)	\
申鐃緒申   449   ((coding)->spec.iso_2022.bol)
申鐃緒申   450 #define CODING_ISO_INVOKED_CHARSET(coding, plane)	\
申鐃緒申   451   CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
申鐃緒申   452 
申鐃緒申   453 /* Control characters of ISO2022.  */
申鐃緒申   454 			/* code */	/* function */
申鐃緒申   455 #define ISO_CODE_LF	0x0A		/* line-feed */
申鐃緒申   456 #define ISO_CODE_CR	0x0D		/* carriage-return */
申鐃緒申   457 #define ISO_CODE_SO	0x0E		/* shift-out */
申鐃緒申   458 #define ISO_CODE_SI	0x0F		/* shift-in */
申鐃緒申   459 #define ISO_CODE_SS2_7	0x19		/* single-shift-2 for 7-bit code */
申鐃緒申   460 #define ISO_CODE_ESC	0x1B		/* escape */
申鐃緒申   461 #define ISO_CODE_SS2	0x8E		/* single-shift-2 */
申鐃緒申   462 #define ISO_CODE_SS3	0x8F		/* single-shift-3 */
申鐃緒申   463 #define ISO_CODE_CSI	0x9B		/* control-sequence-introducer */
申鐃緒申   464 
申鐃緒申   465 /* All code (1-byte) of ISO2022 is classified into one of the
申鐃緒申   466    followings.  */
申鐃緒申   467 enum iso_code_class_type
申鐃緒申   468   {
申鐃緒申   469     ISO_control_0,		/* Control codes in the range
申鐃緒申   470 				   0x00..0x1F and 0x7F, except for the
申鐃緒申   471 				   following 5 codes.  */
申鐃緒申   472     ISO_shift_out,		/* ISO_CODE_SO (0x0E) */
申鐃緒申   473     ISO_shift_in,		/* ISO_CODE_SI (0x0F) */
申鐃緒申   474     ISO_single_shift_2_7,	/* ISO_CODE_SS2_7 (0x19) */
申鐃緒申   475     ISO_escape,			/* ISO_CODE_SO (0x1B) */
申鐃緒申   476     ISO_control_1,		/* Control codes in the range
申鐃緒申   477 				   0x80..0x9F, except for the
申鐃緒申   478 				   following 3 codes.  */
申鐃緒申   479     ISO_single_shift_2,		/* ISO_CODE_SS2 (0x8E) */
申鐃緒申   480     ISO_single_shift_3,		/* ISO_CODE_SS3 (0x8F) */
申鐃緒申   481     ISO_control_sequence_introducer, /* ISO_CODE_CSI (0x9B) */
申鐃緒申   482     ISO_0x20_or_0x7F,		/* Codes of the values 0x20 or 0x7F.  */
申鐃緒申   483     ISO_graphic_plane_0,	/* Graphic codes in the range 0x21..0x7E.  */
申鐃緒申   484     ISO_0xA0_or_0xFF,		/* Codes of the values 0xA0 or 0xFF.  */
申鐃緒申   485     ISO_graphic_plane_1		/* Graphic codes in the range 0xA1..0xFE.  */
申鐃緒申   486   };
申鐃緒申   487 
申鐃緒申   488 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
申鐃緒申   489     `iso-flags' attribute of an iso2022 coding system.  */
申鐃緒申   490 
申鐃緒申   491 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
申鐃緒申   492    instead of the correct short-form sequence (e.g. ESC $ A).  */
申鐃緒申   493 #define CODING_ISO_FLAG_LONG_FORM	0x0001
申鐃緒申   494 
申鐃緒申   495 /* If set, reset graphic planes and registers at end-of-line to the
申鐃緒申   496    initial state.  */
申鐃緒申   497 #define CODING_ISO_FLAG_RESET_AT_EOL	0x0002
申鐃緒申   498 
申鐃緒申   499 /* If set, reset graphic planes and registers before any control
申鐃緒申   500    characters to the initial state.  */
申鐃緒申   501 #define CODING_ISO_FLAG_RESET_AT_CNTL	0x0004
申鐃緒申   502 
申鐃緒申   503 /* If set, encode by 7-bit environment.  */
申鐃緒申   504 #define CODING_ISO_FLAG_SEVEN_BITS	0x0008
申鐃緒申   505 
申鐃緒申   506 /* If set, use locking-shift function.  */
申鐃緒申   507 #define CODING_ISO_FLAG_LOCKING_SHIFT	0x0010
申鐃緒申   508 
申鐃緒申   509 /* If set, use single-shift function.  Overwrite
申鐃緒申   510    CODING_ISO_FLAG_LOCKING_SHIFT.  */
申鐃緒申   511 #define CODING_ISO_FLAG_SINGLE_SHIFT	0x0020
申鐃緒申   512 
申鐃緒申   513 /* If set, use designation escape sequence.  */
申鐃緒申   514 #define CODING_ISO_FLAG_DESIGNATION	0x0040
申鐃緒申   515 
申鐃緒申   516 /* If set, produce revision number sequence.  */
申鐃緒申   517 #define CODING_ISO_FLAG_REVISION	0x0080
申鐃緒申   518 
申鐃緒申   519 /* If set, produce ISO6429's direction specifying sequence.  */
申鐃緒申   520 #define CODING_ISO_FLAG_DIRECTION	0x0100
申鐃緒申   521 
申鐃緒申   522 /* If set, assume designation states are reset at beginning of line on
申鐃緒申   523    output.  */
申鐃緒申   524 #define CODING_ISO_FLAG_INIT_AT_BOL	0x0200
申鐃緒申   525 
申鐃緒申   526 /* If set, designation sequence should be placed at beginning of line
申鐃緒申   527    on output.  */
申鐃緒申   528 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
申鐃緒申   529 
申鐃緒申   530 /* If set, do not encode unsafe charactes on output.  */
申鐃緒申   531 #define CODING_ISO_FLAG_SAFE		0x0800
申鐃緒申   532 
申鐃緒申   533 /* If set, extra latin codes (128..159) are accepted as a valid code
申鐃緒申   534    on input.  */
申鐃緒申   535 #define CODING_ISO_FLAG_LATIN_EXTRA	0x1000
申鐃緒申   536 
申鐃緒申   537 #define CODING_ISO_FLAG_COMPOSITION	0x2000
申鐃緒申   538 
申鐃緒申   539 #define CODING_ISO_FLAG_EUC_TW_SHIFT	0x4000
申鐃緒申   540 
申鐃緒申   541 #define CODING_ISO_FLAG_USE_ROMAN	0x8000
申鐃緒申   542 
申鐃緒申   543 #define CODING_ISO_FLAG_USE_OLDJIS	0x10000
申鐃緒申   544 
申鐃緒申   545 #define CODING_ISO_FLAG_FULL_SUPPORT	0x100000
申鐃緒申   546 
申鐃緒申   547 /* A character to be produced on output if encoding of the original
申鐃緒申   548    character is prohibited by CODING_ISO_FLAG_SAFE.  */
申鐃緒申   549 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION  '?'
申鐃緒申   550 
申鐃緒申   551 
申鐃緒申   552 /* UTF-16 section */
申鐃緒申   553 #define CODING_UTF_16_BOM(coding)	\
申鐃緒申   554   ((coding)->spec.utf_16.bom)
申鐃緒申   555 
申鐃緒申   556 #define CODING_UTF_16_ENDIAN(coding)	\
申鐃緒申   557   ((coding)->spec.utf_16.endian)
申鐃緒申   558 
申鐃緒申   559 #define CODING_UTF_16_SURROGATE(coding)	\
申鐃緒申   560   ((coding)->spec.utf_16.surrogate)
申鐃緒申   561 
申鐃緒申   562 
申鐃緒申   563 /* CCL section */
申鐃緒申   564 #define CODING_CCL_DECODER(coding)	\
申鐃緒申   565   AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
申鐃緒申   566 #define CODING_CCL_ENCODER(coding)	\
申鐃緒申   567   AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
申鐃緒申   568 #define CODING_CCL_VALIDS(coding)					   \
申鐃緒申   569   (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
申鐃緒申   570 
申鐃緒申   571 /* Index for each coding category in `coding_categories' */
申鐃緒申   572 
申鐃緒申   573 enum coding_category
申鐃緒申   574   {
申鐃緒申   575     coding_category_iso_7,
申鐃緒申   576     coding_category_iso_7_tight,
申鐃緒申   577     coding_category_iso_8_1,
申鐃緒申   578     coding_category_iso_8_2,
申鐃緒申   579     coding_category_iso_7_else,
申鐃緒申   580     coding_category_iso_8_else,
申鐃緒申   581     coding_category_utf_8,
申鐃緒申   582     coding_category_utf_16_auto,
申鐃緒申   583     coding_category_utf_16_be,
申鐃緒申   584     coding_category_utf_16_le,
申鐃緒申   585     coding_category_utf_16_be_nosig,
申鐃緒申   586     coding_category_utf_16_le_nosig,
申鐃緒申   587     coding_category_charset,
申鐃緒申   588     coding_category_sjis,
申鐃緒申   589     coding_category_big5,
申鐃緒申   590     coding_category_ccl,
申鐃緒申   591     coding_category_emacs_mule,
申鐃緒申   592     /* All above are targets of code detection.  */
申鐃緒申   593     coding_category_raw_text,
申鐃緒申   594     coding_category_undecided,
申鐃緒申   595     coding_category_max
申鐃緒申   596   };
申鐃緒申   597 
申鐃緒申   598 /* Definitions of flag bits used in detect_coding_XXXX.  */
申鐃緒申   599 #define CATEGORY_MASK_ISO_7		(1 << coding_category_iso_7)
申鐃緒申   600 #define CATEGORY_MASK_ISO_7_TIGHT	(1 << coding_category_iso_7_tight)
申鐃緒申   601 #define CATEGORY_MASK_ISO_8_1		(1 << coding_category_iso_8_1)
申鐃緒申   602 #define CATEGORY_MASK_ISO_8_2		(1 << coding_category_iso_8_2)
申鐃緒申   603 #define CATEGORY_MASK_ISO_7_ELSE	(1 << coding_category_iso_7_else)
申鐃緒申   604 #define CATEGORY_MASK_ISO_8_ELSE	(1 << coding_category_iso_8_else)
申鐃緒申   605 #define CATEGORY_MASK_UTF_8		(1 << coding_category_utf_8)
申鐃緒申   606 #define CATEGORY_MASK_UTF_16_AUTO	(1 << coding_category_utf_16_auto)
申鐃緒申   607 #define CATEGORY_MASK_UTF_16_BE		(1 << coding_category_utf_16_be)
申鐃緒申   608 #define CATEGORY_MASK_UTF_16_LE		(1 << coding_category_utf_16_le)
申鐃緒申   609 #define CATEGORY_MASK_UTF_16_BE_NOSIG	(1 << coding_category_utf_16_be_nosig)
申鐃緒申   610 #define CATEGORY_MASK_UTF_16_LE_NOSIG	(1 << coding_category_utf_16_le_nosig)
申鐃緒申   611 #define CATEGORY_MASK_CHARSET		(1 << coding_category_charset)
申鐃緒申   612 #define CATEGORY_MASK_SJIS		(1 << coding_category_sjis)
申鐃緒申   613 #define CATEGORY_MASK_BIG5		(1 << coding_category_big5)
申鐃緒申   614 #define CATEGORY_MASK_CCL		(1 << coding_category_ccl)
申鐃緒申   615 #define CATEGORY_MASK_EMACS_MULE	(1 << coding_category_emacs_mule)
申鐃緒申   616 #define CATEGORY_MASK_RAW_TEXT		(1 << coding_category_raw_text)
申鐃緒申   617 
申鐃緒申   618 /* This value is returned if detect_coding_mask () find nothing other
申鐃緒申   619    than ASCII characters.  */
申鐃緒申   620 #define CATEGORY_MASK_ANY		\
申鐃緒申   621   (CATEGORY_MASK_ISO_7			\
申鐃緒申   622    | CATEGORY_MASK_ISO_7_TIGHT		\
申鐃緒申   623    | CATEGORY_MASK_ISO_8_1		\
申鐃緒申   624    | CATEGORY_MASK_ISO_8_2		\
申鐃緒申   625    | CATEGORY_MASK_ISO_7_ELSE		\
申鐃緒申   626    | CATEGORY_MASK_ISO_8_ELSE		\
申鐃緒申   627    | CATEGORY_MASK_UTF_8		\
申鐃緒申   628    | CATEGORY_MASK_UTF_16_AUTO		\
申鐃緒申   629    | CATEGORY_MASK_UTF_16_BE		\
申鐃緒申   630    | CATEGORY_MASK_UTF_16_LE		\
申鐃緒申   631    | CATEGORY_MASK_UTF_16_BE_NOSIG	\
申鐃緒申   632    | CATEGORY_MASK_UTF_16_LE_NOSIG	\
申鐃緒申   633    | CATEGORY_MASK_CHARSET		\
申鐃緒申   634    | CATEGORY_MASK_SJIS			\
申鐃緒申   635    | CATEGORY_MASK_BIG5			\
申鐃緒申   636    | CATEGORY_MASK_CCL			\
申鐃緒申   637    | CATEGORY_MASK_EMACS_MULE)
申鐃緒申   638 
申鐃緒申   639 
申鐃緒申   640 #define CATEGORY_MASK_ISO_7BIT \
申鐃緒申   641   (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
申鐃緒申   642 
申鐃緒申   643 #define CATEGORY_MASK_ISO_8BIT \
申鐃緒申   644   (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
申鐃緒申   645 
申鐃緒申   646 #define CATEGORY_MASK_ISO_ELSE \
申鐃緒申   647   (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
申鐃緒申   648 
申鐃緒申   649 #define CATEGORY_MASK_ISO_ESCAPE	\
申鐃緒申   650   (CATEGORY_MASK_ISO_7			\
申鐃緒申   651    | CATEGORY_MASK_ISO_7_TIGHT		\
申鐃緒申   652    | CATEGORY_MASK_ISO_7_ELSE		\
申鐃緒申   653    | CATEGORY_MASK_ISO_8_ELSE)
申鐃緒申   654 
申鐃緒申   655 #define CATEGORY_MASK_ISO	\
申鐃緒申   656   (  CATEGORY_MASK_ISO_7BIT	\
申鐃緒申   657      | CATEGORY_MASK_ISO_8BIT	\
申鐃緒申   658      | CATEGORY_MASK_ISO_ELSE)
申鐃緒申   659 
申鐃緒申   660 #define CATEGORY_MASK_UTF_16		\
申鐃緒申   661   (CATEGORY_MASK_UTF_16_AUTO		\
申鐃緒申   662    | CATEGORY_MASK_UTF_16_BE		\
申鐃緒申   663    | CATEGORY_MASK_UTF_16_LE		\
申鐃緒申   664    | CATEGORY_MASK_UTF_16_BE_NOSIG	\
申鐃緒申   665    | CATEGORY_MASK_UTF_16_LE_NOSIG)
申鐃緒申   666 
申鐃緒申   667 
申鐃緒申   668 /* List of symbols `coding-category-xxx' ordered by priority.  This
申鐃緒申   669    variable is exposed to Emacs Lisp.  */
申鐃緒申   670 static Lisp_Object Vcoding_category_list;
申鐃緒申   671 
申鐃緒申   672 /* Table of coding categories (Lisp symbols).  This variable is for
申鐃緒申   673    internal use oly.  */
申鐃緒申   674 static Lisp_Object Vcoding_category_table;
申鐃緒申   675 
申鐃緒申   676 /* Table of coding-categories ordered by priority.  */
申鐃緒申   677 static enum coding_category coding_priorities[coding_category_max];
申鐃緒申   678 
申鐃緒申   679 /* Nth element is a coding context for the coding system bound to the
申鐃緒申   680    Nth coding category.  */
申鐃緒申   681 static struct coding_system coding_categories[coding_category_max];
申鐃緒申   682 
申鐃緒申   683 /*** Commonly used macros and functions ***/
申鐃緒申   684 
申鐃緒申   685 #ifndef min
申鐃緒申   686 #define min(a, b) ((a) < (b) ? (a) : (b))
申鐃緒申   687 #endif
申鐃緒申   688 #ifndef max
申鐃緒申   689 #define max(a, b) ((a) > (b) ? (a) : (b))
申鐃緒申   690 #endif
申鐃緒申   691 
申鐃緒申   692 #define CODING_GET_INFO(coding, attrs, charset_list)	\
申鐃緒申   693   do {							\
申鐃緒申   694     (attrs) = CODING_ID_ATTRS ((coding)->id);		\
申鐃緒申   695     (charset_list) = CODING_ATTR_CHARSET_LIST (attrs);	\
申鐃緒申   696   } while (0)
申鐃緒申   697 
申鐃緒申   698 
申鐃緒申   699 /* Safely get one byte from the source text pointed by SRC which ends
申鐃緒申   700    at SRC_END, and set C to that byte.  If there are not enough bytes
申鐃緒申   701    in the source, it jumps to `no_more_source'.  If multibytep is
申鐃緒申   702    nonzero, and a multibyte character is found at SRC, set C to the
申鐃緒申   703    negative value of the character code.  The caller should declare
申鐃緒申   704    and set these variables appropriately in advance:
申鐃緒申   705 	src, src_end, multibytep */
申鐃緒申   706 
申鐃緒申   707 #define ONE_MORE_BYTE(c)				\
申鐃緒申   708   do {							\
申鐃緒申   709     if (src == src_end)					\
申鐃緒申   710       {							\
申鐃緒申   711 	if (src_base < src)				\
申鐃緒申   712 	  record_conversion_result			\
申鐃緒申   713 	    (coding, CODING_RESULT_INSUFFICIENT_SRC);	\
申鐃緒申   714 	goto no_more_source;				\
申鐃緒申   715       }							\
申鐃緒申   716     c = *src++;						\
申鐃緒申   717     if (multibytep && (c & 0x80))			\
申鐃緒申   718       {							\
申鐃緒申   719 	if ((c & 0xFE) == 0xC0)				\
申鐃緒申   720 	  c = ((c & 1) << 6) | *src++;			\
申鐃緒申   721 	else						\
申鐃緒申   722 	  {						\
申鐃緒申   723 	    src--;					\
申鐃緒申   724 	    c = - string_char (src, &src, NULL);	\
申鐃緒申   725 	    record_conversion_result			\
申鐃緒申   726 	      (coding, CODING_RESULT_INVALID_SRC);	\
申鐃緒申   727 	  }						\
申鐃緒申   728       }							\
申鐃緒申   729     consumed_chars++;					\
申鐃緒申   730   } while (0)
申鐃緒申   731 
申鐃緒申   732 
申鐃緒申   733 #define ONE_MORE_BYTE_NO_CHECK(c)			\
申鐃緒申   734   do {							\
申鐃緒申   735     c = *src++;						\
申鐃緒申   736     if (multibytep && (c & 0x80))			\
申鐃緒申   737       {							\
申鐃緒申   738 	if ((c & 0xFE) == 0xC0)				\
申鐃緒申   739 	  c = ((c & 1) << 6) | *src++;			\
申鐃緒申   740 	else						\
申鐃緒申   741 	  {						\
申鐃緒申   742 	    src--;					\
申鐃緒申   743 	    c = - string_char (src, &src, NULL);	\
申鐃緒申   744 	    record_conversion_result			\
申鐃緒申   745 	      (coding, CODING_RESULT_INVALID_SRC);	\
申鐃緒申   746 	  }						\
申鐃緒申   747       }							\
申鐃緒申   748     consumed_chars++;					\
申鐃緒申   749   } while (0)
申鐃緒申   750 
申鐃緒申   751 
申鐃緒申   752 /* Store a byte C in the place pointed by DST and increment DST to the
申鐃緒申   753    next free point, and increment PRODUCED_CHARS.  The caller should
申鐃緒申   754    assure that C is 0..127, and declare and set the variable `dst'
申鐃緒申   755    appropriately in advance.
申鐃緒申   756 */
申鐃緒申   757 
申鐃緒申   758 
申鐃緒申   759 #define EMIT_ONE_ASCII_BYTE(c)	\
申鐃緒申   760   do {				\
申鐃緒申   761     produced_chars++;		\
申鐃緒申   762     *dst++ = (c);		\
申鐃緒申   763   } while (0)
申鐃緒申   764 
申鐃緒申   765 
申鐃緒申   766 /* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2.  */
申鐃緒申   767 
申鐃緒申   768 #define EMIT_TWO_ASCII_BYTES(c1, c2)	\
申鐃緒申   769   do {					\
申鐃緒申   770     produced_chars += 2;		\
申鐃緒申   771     *dst++ = (c1), *dst++ = (c2);	\
申鐃緒申   772   } while (0)
申鐃緒申   773 
申鐃緒申   774 
申鐃緒申   775 /* Store a byte C in the place pointed by DST and increment DST to the
申鐃緒申   776    next free point, and increment PRODUCED_CHARS.  If MULTIBYTEP is
申鐃緒申   777    nonzero, store in an appropriate multibyte from.  The caller should
申鐃緒申   778    declare and set the variables `dst' and `multibytep' appropriately
申鐃緒申   779    in advance.  */
申鐃緒申   780 
申鐃緒申   781 #define EMIT_ONE_BYTE(c)		\
申鐃緒申   782   do {					\
申鐃緒申   783     produced_chars++;			\
申鐃緒申   784     if (multibytep)			\
申鐃緒申   785       {					\
申鐃緒申   786 	int ch = (c);			\
申鐃緒申   787 	if (ch >= 0x80)			\
申鐃緒申   788 	  ch = BYTE8_TO_CHAR (ch);	\
申鐃緒申   789 	CHAR_STRING_ADVANCE (ch, dst);	\
申鐃緒申   790       }					\
申鐃緒申   791     else				\
申鐃緒申   792       *dst++ = (c);			\
申鐃緒申   793   } while (0)
申鐃緒申   794 
申鐃緒申   795 
申鐃緒申   796 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2.  */
申鐃緒申   797 
申鐃緒申   798 #define EMIT_TWO_BYTES(c1, c2)		\
申鐃緒申   799   do {					\
申鐃緒申   800     produced_chars += 2;		\
申鐃緒申   801     if (multibytep)			\
申鐃緒申   802       {					\
申鐃緒申   803 	int ch;				\
申鐃緒申   804 					\
申鐃緒申   805 	ch = (c1);			\
申鐃緒申   806 	if (ch >= 0x80)			\
申鐃緒申   807 	  ch = BYTE8_TO_CHAR (ch);	\
申鐃緒申   808 	CHAR_STRING_ADVANCE (ch, dst);	\
申鐃緒申   809 	ch = (c2);			\
申鐃緒申   810 	if (ch >= 0x80)			\
申鐃緒申   811 	  ch = BYTE8_TO_CHAR (ch);	\
申鐃緒申   812 	CHAR_STRING_ADVANCE (ch, dst);	\
申鐃緒申   813       }					\
申鐃緒申   814     else				\
申鐃緒申   815       {					\
申鐃緒申   816 	*dst++ = (c1);			\
申鐃緒申   817 	*dst++ = (c2);			\
申鐃緒申   818       }					\
申鐃緒申   819   } while (0)
申鐃緒申   820 
申鐃緒申   821 
申鐃緒申   822 #define EMIT_THREE_BYTES(c1, c2, c3)	\
申鐃緒申   823   do {					\
申鐃緒申   824     EMIT_ONE_BYTE (c1);			\
申鐃緒申   825     EMIT_TWO_BYTES (c2, c3);		\
申鐃緒申   826   } while (0)
申鐃緒申   827 
申鐃緒申   828 
申鐃緒申   829 #define EMIT_FOUR_BYTES(c1, c2, c3, c4)		\
申鐃緒申   830   do {						\
申鐃緒申   831     EMIT_TWO_BYTES (c1, c2);			\
申鐃緒申   832     EMIT_TWO_BYTES (c3, c4);			\
申鐃緒申   833   } while (0)
申鐃緒申   834 
申鐃緒申   835 
申鐃緒申   836 /* Prototypes for static functions.  */
申鐃緒申   837 static void record_conversion_result P_ ((struct coding_system *coding,
申鐃緒申   838 					  enum coding_result_code result));
申鐃緒申   839 static int detect_coding_utf_8 P_ ((struct coding_system *,
申鐃緒申   840 				    struct coding_detection_info *info));
申鐃緒申   841 static void decode_coding_utf_8 P_ ((struct coding_system *));
申鐃緒申   842 static int encode_coding_utf_8 P_ ((struct coding_system *));
申鐃緒申   843 
申鐃緒申   844 static int detect_coding_utf_16 P_ ((struct coding_system *,
申鐃緒申   845 				     struct coding_detection_info *info));
申鐃緒申   846 static void decode_coding_utf_16 P_ ((struct coding_system *));
申鐃緒申   847 static int encode_coding_utf_16 P_ ((struct coding_system *));
申鐃緒申   848 
申鐃緒申   849 static int detect_coding_iso_2022 P_ ((struct coding_system *,
申鐃緒申   850 				       struct coding_detection_info *info));
申鐃緒申   851 static void decode_coding_iso_2022 P_ ((struct coding_system *));
申鐃緒申   852 static int encode_coding_iso_2022 P_ ((struct coding_system *));
申鐃緒申   853 
申鐃緒申   854 static int detect_coding_emacs_mule P_ ((struct coding_system *,
申鐃緒申   855 					 struct coding_detection_info *info));
申鐃緒申   856 static void decode_coding_emacs_mule P_ ((struct coding_system *));
申鐃緒申   857 static int encode_coding_emacs_mule P_ ((struct coding_system *));
申鐃緒申   858 
申鐃緒申   859 static int detect_coding_sjis P_ ((struct coding_system *,
申鐃緒申   860 				   struct coding_detection_info *info));
申鐃緒申   861 static void decode_coding_sjis P_ ((struct coding_system *));
申鐃緒申   862 static int encode_coding_sjis P_ ((struct coding_system *));
申鐃緒申   863 
申鐃緒申   864 static int detect_coding_big5 P_ ((struct coding_system *,
申鐃緒申   865 				   struct coding_detection_info *info));
申鐃緒申   866 static void decode_coding_big5 P_ ((struct coding_system *));
申鐃緒申   867 static int encode_coding_big5 P_ ((struct coding_system *));
申鐃緒申   868 
申鐃緒申   869 static int detect_coding_ccl P_ ((struct coding_system *,
申鐃緒申   870 				  struct coding_detection_info *info));
申鐃緒申   871 static void decode_coding_ccl P_ ((struct coding_system *));
申鐃緒申   872 static int encode_coding_ccl P_ ((struct coding_system *));
申鐃緒申   873 
申鐃緒申   874 static void decode_coding_raw_text P_ ((struct coding_system *));
申鐃緒申   875 static int encode_coding_raw_text P_ ((struct coding_system *));
申鐃緒申   876 
申鐃緒申   877 static void coding_set_source P_ ((struct coding_system *));
申鐃緒申   878 static void coding_set_destination P_ ((struct coding_system *));
申鐃緒申   879 static void coding_alloc_by_realloc P_ ((struct coding_system *, EMACS_INT));
申鐃緒申   880 static void coding_alloc_by_making_gap P_ ((struct coding_system *,
申鐃緒申   881 					    EMACS_INT, EMACS_INT));
申鐃緒申   882 static unsigned char *alloc_destination P_ ((struct coding_system *,
申鐃緒申   883 					     EMACS_INT, unsigned char *));
申鐃緒申   884 static void setup_iso_safe_charsets P_ ((Lisp_Object));
申鐃緒申   885 static unsigned char *encode_designation_at_bol P_ ((struct coding_system *,
申鐃緒申   886 						     int *, int *,
申鐃緒申   887 						     unsigned char *));
申鐃緒申   888 static int detect_eol P_ ((const unsigned char *,
申鐃緒申   889 			   EMACS_INT, enum coding_category));
申鐃緒申   890 static Lisp_Object adjust_coding_eol_type P_ ((struct coding_system *, int));
申鐃緒申   891 static void decode_eol P_ ((struct coding_system *));
申鐃緒申   892 static Lisp_Object get_translation_table P_ ((Lisp_Object, int, int *));
申鐃緒申   893 static Lisp_Object get_translation P_ ((Lisp_Object, int *, int *,
申鐃緒申   894 					int, int *, int *));
申鐃緒申   895 static int produce_chars P_ ((struct coding_system *, Lisp_Object, int));
申鐃緒申   896 static INLINE void produce_composition P_ ((struct coding_system *, int *,
申鐃緒申   897 					    EMACS_INT));
申鐃緒申   898 static INLINE void produce_charset P_ ((struct coding_system *, int *,
申鐃緒申   899 					EMACS_INT));
申鐃緒申   900 static void produce_annotation P_ ((struct coding_system *, EMACS_INT));
申鐃緒申   901 static int decode_coding P_ ((struct coding_system *));
申鐃緒申   902 static INLINE int *handle_composition_annotation P_ ((EMACS_INT, EMACS_INT,
申鐃緒申   903 						      struct coding_system *,
申鐃緒申   904 						      int *, EMACS_INT *));
申鐃緒申   905 static INLINE int *handle_charset_annotation P_ ((EMACS_INT, EMACS_INT,
申鐃緒申   906 						  struct coding_system *,
申鐃緒申   907 						  int *, EMACS_INT *));
申鐃緒申   908 static void consume_chars P_ ((struct coding_system *, Lisp_Object, int));
申鐃緒申   909 static int encode_coding P_ ((struct coding_system *));
申鐃緒申   910 static Lisp_Object make_conversion_work_buffer P_ ((int));
申鐃緒申   911 static Lisp_Object code_conversion_restore P_ ((Lisp_Object));
申鐃緒申   912 static INLINE int char_encodable_p P_ ((int, Lisp_Object));
申鐃緒申   913 static Lisp_Object make_subsidiaries P_ ((Lisp_Object));
申鐃緒申   914 
申鐃緒申   915 static void
申鐃緒申   916 record_conversion_result (struct coding_system *coding,
申鐃緒申   917 			  enum coding_result_code result)
申鐃緒申   918 {
申鐃緒申   919   coding->result = result;
申鐃緒申   920   switch (result)
申鐃緒申   921     {
申鐃緒申   922     case CODING_RESULT_INSUFFICIENT_SRC:
申鐃緒申   923       Vlast_code_conversion_error = Qinsufficient_source;
申鐃緒申   924       break;
申鐃緒申   925     case CODING_RESULT_INCONSISTENT_EOL:
申鐃緒申   926       Vlast_code_conversion_error = Qinconsistent_eol;
申鐃緒申   927       break;
申鐃緒申   928     case CODING_RESULT_INVALID_SRC:
申鐃緒申   929       Vlast_code_conversion_error = Qinvalid_source;
申鐃緒申   930       break;
申鐃緒申   931     case CODING_RESULT_INTERRUPT:
申鐃緒申   932       Vlast_code_conversion_error = Qinterrupted;
申鐃緒申   933       break;
申鐃緒申   934     case CODING_RESULT_INSUFFICIENT_MEM:
申鐃緒申   935       Vlast_code_conversion_error = Qinsufficient_memory;
申鐃緒申   936       break;
申鐃緒申   937     default:
申鐃緒申   938       Vlast_code_conversion_error = intern ("Unknown error");
申鐃緒申   939     }
申鐃緒申   940 }
申鐃緒申   941 
申鐃緒申   942 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
申鐃緒申   943   do {									     \
申鐃緒申   944     charset_map_loaded = 0;						     \
申鐃緒申   945     c = DECODE_CHAR (charset, code);					     \
申鐃緒申   946     if (charset_map_loaded)						     \
申鐃緒申   947       {									     \
申鐃緒申   948 	const unsigned char *orig = coding->source;			     \
申鐃緒申   949 	EMACS_INT offset;						     \
申鐃緒申   950 									     \
申鐃緒申   951 	coding_set_source (coding);					     \
申鐃緒申   952 	offset = coding->source - orig;					     \
申鐃緒申   953 	src += offset;							     \
申鐃緒申   954 	src_base += offset;						     \
申鐃緒申   955 	src_end += offset;						     \
申鐃緒申   956       }									     \
申鐃緒申   957   } while (0)
申鐃緒申   958 
申鐃緒申   959 
申鐃緒申   960 /* If there are at least BYTES length of room at dst, allocate memory
申鐃緒申   961    for coding->destination and update dst and dst_end.  We don't have
申鐃緒申   962    to take care of coding->source which will be relocated.  It is
申鐃緒申   963    handled by calling coding_set_source in encode_coding.  */
申鐃緒申   964 
申鐃緒申   965 #define ASSURE_DESTINATION(bytes)				\
申鐃緒申   966   do {								\
申鐃緒申   967     if (dst + (bytes) >= dst_end)				\
申鐃緒申   968       {								\
申鐃緒申   969 	int more_bytes = charbuf_end - charbuf + (bytes);	\
申鐃緒申   970 								\
申鐃緒申   971 	dst = alloc_destination (coding, more_bytes, dst);	\
申鐃緒申   972 	dst_end = coding->destination + coding->dst_bytes;	\
申鐃緒申   973       }								\
申鐃緒申   974   } while (0)
申鐃緒申   975 
申鐃緒申   976 
申鐃緒申   977 /* Store multibyte form of the character C in P, and advance P to the
申鐃緒申   978    end of the multibyte form.  This is like CHAR_STRING_ADVANCE but it
申鐃緒申   979    never calls MAYBE_UNIFY_CHAR.  */
申鐃緒申   980 
申鐃緒申   981 #define CHAR_STRING_ADVANCE_NO_UNIFY(c, p)	\
申鐃緒申   982   do {						\
申鐃緒申   983     if ((c) <= MAX_1_BYTE_CHAR)			\
申鐃緒申   984       *(p)++ = (c);				\
申鐃緒申   985     else if ((c) <= MAX_2_BYTE_CHAR)		\
申鐃緒申   986       *(p)++ = (0xC0 | ((c) >> 6)),		\
申鐃緒申   987 	*(p)++ = (0x80 | ((c) & 0x3F));		\
申鐃緒申   988     else if ((c) <= MAX_3_BYTE_CHAR)		\
申鐃緒申   989       *(p)++ = (0xE0 | ((c) >> 12)),		\
申鐃緒申   990 	*(p)++ = (0x80 | (((c) >> 6) & 0x3F)),	\
申鐃緒申   991 	*(p)++ = (0x80 | ((c) & 0x3F));		\
申鐃緒申   992     else if ((c) <= MAX_4_BYTE_CHAR)		\
申鐃緒申   993       *(p)++ = (0xF0 | (c >> 18)),		\
申鐃緒申   994 	*(p)++ = (0x80 | ((c >> 12) & 0x3F)),	\
申鐃緒申   995 	*(p)++ = (0x80 | ((c >> 6) & 0x3F)),	\
申鐃緒申   996 	*(p)++ = (0x80 | (c & 0x3F));		\
申鐃緒申   997     else if ((c) <= MAX_5_BYTE_CHAR)		\
申鐃緒申   998       *(p)++ = 0xF8,				\
申鐃緒申   999 	*(p)++ = (0x80 | ((c >> 18) & 0x0F)),	\
申鐃緒申  1000 	*(p)++ = (0x80 | ((c >> 12) & 0x3F)),	\
申鐃緒申  1001 	*(p)++ = (0x80 | ((c >> 6) & 0x3F)),	\
申鐃緒申  1002 	*(p)++ = (0x80 | (c & 0x3F));		\
申鐃緒申  1003     else					\
申鐃緒申  1004       (p) += BYTE8_STRING ((c) - 0x3FFF80, p);	\
申鐃緒申  1005   } while (0)
申鐃緒申  1006 
申鐃緒申  1007 
申鐃緒申  1008 /* Return the character code of character whose multibyte form is at
申鐃緒申  1009    P, and advance P to the end of the multibyte form.  This is like
申鐃緒申  1010    STRING_CHAR_ADVANCE, but it never calls MAYBE_UNIFY_CHAR.  */
申鐃緒申  1011 
申鐃緒申  1012 #define STRING_CHAR_ADVANCE_NO_UNIFY(p)				\
申鐃緒申  1013   (!((p)[0] & 0x80)						\
申鐃緒申  1014    ? *(p)++							\
申鐃緒申  1015    : ! ((p)[0] & 0x20)						\
申鐃緒申  1016    ? ((p) += 2,							\
申鐃緒申  1017       ((((p)[-2] & 0x1F) << 6)					\
申鐃緒申  1018        | ((p)[-1] & 0x3F)					\
申鐃緒申  1019        | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0)))	\
申鐃緒申  1020    : ! ((p)[0] & 0x10)						\
申鐃緒申  1021    ? ((p) += 3,							\
申鐃緒申  1022       ((((p)[-3] & 0x0F) << 12)					\
申鐃緒申  1023        | (((p)[-2] & 0x3F) << 6)				\
申鐃緒申  1024        | ((p)[-1] & 0x3F)))					\
申鐃緒申  1025    : ! ((p)[0] & 0x08)						\
申鐃緒申  1026    ? ((p) += 4,							\
申鐃緒申  1027       ((((p)[-4] & 0xF) << 18)					\
申鐃緒申  1028        | (((p)[-3] & 0x3F) << 12)				\
申鐃緒申  1029        | (((p)[-2] & 0x3F) << 6)				\
申鐃緒申  1030        | ((p)[-1] & 0x3F)))					\
申鐃緒申  1031    : ((p) += 5,							\
申鐃緒申  1032       ((((p)[-4] & 0x3F) << 18)					\
申鐃緒申  1033        | (((p)[-3] & 0x3F) << 12)				\
申鐃緒申  1034        | (((p)[-2] & 0x3F) << 6)				\
申鐃緒申  1035        | ((p)[-1] & 0x3F))))
申鐃緒申  1036 
申鐃緒申  1037 
申鐃緒申  1038 static void
申鐃緒申  1039 coding_set_source (coding)
申鐃緒申  1040      struct coding_system *coding;
申鐃緒申  1041 {
申鐃緒申  1042   if (BUFFERP (coding->src_object))
申鐃緒申  1043     {
申鐃緒申  1044       struct buffer *buf = XBUFFER (coding->src_object);
申鐃緒申  1045 
申鐃緒申  1046       if (coding->src_pos < 0)
申鐃緒申  1047 	coding->source = BUF_GAP_END_ADDR (buf) + coding->src_pos_byte;
申鐃緒申  1048       else
申鐃緒申  1049 	coding->source = BUF_BYTE_ADDRESS (buf, coding->src_pos_byte);
申鐃緒申  1050     }
申鐃緒申  1051   else if (STRINGP (coding->src_object))
申鐃緒申  1052     {
申鐃緒申  1053       coding->source = SDATA (coding->src_object) + coding->src_pos_byte;
申鐃緒申  1054     }
申鐃緒申  1055   else
申鐃緒申  1056     /* Otherwise, the source is C string and is never relocated
申鐃緒申  1057        automatically.  Thus we don't have to update anything.  */
申鐃緒申  1058     ;
申鐃緒申  1059 }
申鐃緒申  1060 
申鐃緒申  1061 static void
申鐃緒申  1062 coding_set_destination (coding)
申鐃緒申  1063      struct coding_system *coding;
申鐃緒申  1064 {
申鐃緒申  1065   if (BUFFERP (coding->dst_object))
申鐃緒申  1066     {
申鐃緒申  1067       if (coding->src_pos < 0)
申鐃緒申  1068 	{
申鐃緒申  1069 	  coding->destination = BEG_ADDR + coding->dst_pos_byte - BEG_BYTE;
申鐃緒申  1070 	  coding->dst_bytes = (GAP_END_ADDR
申鐃緒申  1071 			       - (coding->src_bytes - coding->consumed)
申鐃緒申  1072 			       - coding->destination);
申鐃緒申  1073 	}
申鐃緒申  1074       else
申鐃緒申  1075 	{
申鐃緒申  1076 	  /* We are sure that coding->dst_pos_byte is before the gap
申鐃緒申  1077 	     of the buffer. */
申鐃緒申  1078 	  coding->destination = (BUF_BEG_ADDR (XBUFFER (coding->dst_object))
申鐃緒申  1079 				 + coding->dst_pos_byte - BEG_BYTE);
申鐃緒申  1080 	  coding->dst_bytes = (BUF_GAP_END_ADDR (XBUFFER (coding->dst_object))
申鐃緒申  1081 			       - coding->destination);
申鐃緒申  1082 	}
申鐃緒申  1083     }
申鐃緒申  1084   else
申鐃緒申  1085     /* Otherwise, the destination is C string and is never relocated
申鐃緒申  1086        automatically.  Thus we don't have to update anything.  */
申鐃緒申  1087     ;
申鐃緒申  1088 }
申鐃緒申  1089 
申鐃緒申  1090 
申鐃緒申  1091 static void
申鐃緒申  1092 coding_alloc_by_realloc (coding, bytes)
申鐃緒申  1093      struct coding_system *coding;
申鐃緒申  1094      EMACS_INT bytes;
申鐃緒申  1095 {
申鐃緒申  1096   coding->destination = (unsigned char *) xrealloc (coding->destination,
申鐃緒申  1097 						    coding->dst_bytes + bytes);
申鐃緒申  1098   coding->dst_bytes += bytes;
申鐃緒申  1099 }
申鐃緒申  1100 
申鐃緒申  1101 static void
申鐃緒申  1102 coding_alloc_by_making_gap (coding, gap_head_used, bytes)
申鐃緒申  1103      struct coding_system *coding;
申鐃緒申  1104      EMACS_INT gap_head_used, bytes;
申鐃緒申  1105 {
申鐃緒申  1106   if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  1107     {
申鐃緒申  1108       /* The gap may contain the produced data at the head and not-yet
申鐃緒申  1109 	 consumed data at the tail.  To preserve those data, we at
申鐃緒申  1110 	 first make the gap size to zero, then increase the gap
申鐃緒申  1111 	 size.  */
申鐃緒申  1112       EMACS_INT add = GAP_SIZE;
申鐃緒申  1113 
申鐃緒申  1114       GPT += gap_head_used, GPT_BYTE += gap_head_used;
申鐃緒申  1115       GAP_SIZE = 0; ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
申鐃緒申  1116       make_gap (bytes);
申鐃緒申  1117       GAP_SIZE += add; ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
申鐃緒申  1118       GPT -= gap_head_used, GPT_BYTE -= gap_head_used;
申鐃緒申  1119     }
申鐃緒申  1120   else
申鐃緒申  1121     {
申鐃緒申  1122       Lisp_Object this_buffer;
申鐃緒申  1123 
申鐃緒申  1124       this_buffer = Fcurrent_buffer ();
申鐃緒申  1125       set_buffer_internal (XBUFFER (coding->dst_object));
申鐃緒申  1126       make_gap (bytes);
申鐃緒申  1127       set_buffer_internal (XBUFFER (this_buffer));
申鐃緒申  1128     }
申鐃緒申  1129 }
申鐃緒申  1130 
申鐃緒申  1131 
申鐃緒申  1132 static unsigned char *
申鐃緒申  1133 alloc_destination (coding, nbytes, dst)
申鐃緒申  1134      struct coding_system *coding;
申鐃緒申  1135      EMACS_INT nbytes;
申鐃緒申  1136      unsigned char *dst;
申鐃緒申  1137 {
申鐃緒申  1138   EMACS_INT offset = dst - coding->destination;
申鐃緒申  1139 
申鐃緒申  1140   if (BUFFERP (coding->dst_object))
申鐃緒申  1141     {
申鐃緒申  1142       struct buffer *buf = XBUFFER (coding->dst_object);
申鐃緒申  1143 
申鐃緒申  1144       coding_alloc_by_making_gap (coding, dst - BUF_GPT_ADDR (buf), nbytes);
申鐃緒申  1145     }
申鐃緒申  1146   else
申鐃緒申  1147     coding_alloc_by_realloc (coding, nbytes);
申鐃緒申  1148   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  1149   coding_set_destination (coding);
申鐃緒申  1150   dst = coding->destination + offset;
申鐃緒申  1151   return dst;
申鐃緒申  1152 }
申鐃緒申  1153 
申鐃緒申  1154 /** Macros for annotations.  */
申鐃緒申  1155 
申鐃緒申  1156 /* Maximum length of annotation data (sum of annotations for
申鐃緒申  1157    composition and charset).  */
申鐃緒申  1158 #define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
申鐃緒申  1159 
申鐃緒申  1160 /* An annotation data is stored in the array coding->charbuf in this
申鐃緒申  1161    format:
申鐃緒申  1162      [ -LENGTH ANNOTATION_MASK NCHARS ... ]
申鐃緒申  1163    LENGTH is the number of elements in the annotation.
申鐃緒申  1164    ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
申鐃緒申  1165    NCHARS is the number of characters in the text annotated.
申鐃緒申  1166 
申鐃緒申  1167    The format of the following elements depend on ANNOTATION_MASK.
申鐃緒申  1168 
申鐃緒申  1169    In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
申鐃緒申  1170    follows:
申鐃緒申  1171      ... METHOD [ COMPOSITION-COMPONENTS ... ]
申鐃緒申  1172    METHOD is one of enum composition_method.
申鐃緒申  1173    Optionnal COMPOSITION-COMPONENTS are characters and composition
申鐃緒申  1174    rules.
申鐃緒申  1175 
申鐃緒申  1176    In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
申鐃緒申  1177    follows.  */
申鐃緒申  1178 
申鐃緒申  1179 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars)	\
申鐃緒申  1180   do {							\
申鐃緒申  1181     *(buf)++ = -(len);					\
申鐃緒申  1182     *(buf)++ = (mask);					\
申鐃緒申  1183     *(buf)++ = (nchars);				\
申鐃緒申  1184     coding->annotated = 1;				\
申鐃緒申  1185   } while (0);
申鐃緒申  1186 
申鐃緒申  1187 #define ADD_COMPOSITION_DATA(buf, nchars, method)			    \
申鐃緒申  1188   do {									    \
申鐃緒申  1189     ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
申鐃緒申  1190     *buf++ = method;							    \
申鐃緒申  1191   } while (0)
申鐃緒申  1192 
申鐃緒申  1193 
申鐃緒申  1194 #define ADD_CHARSET_DATA(buf, nchars, id)				\
申鐃緒申  1195   do {									\
申鐃緒申  1196     ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars);	\
申鐃緒申  1197     *buf++ = id;							\
申鐃緒申  1198   } while (0)
申鐃緒申  1199 
申鐃緒申  1200 
申鐃緒申  1201 /*** 2. Emacs' internal format (emacs-utf-8) ***/
申鐃緒申  1202 
申鐃緒申  1203 
申鐃緒申  1204 
申鐃緒申  1205 
申鐃緒申  1206 /*** 3. UTF-8 ***/
申鐃緒申  1207 
申鐃緒申  1208 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  1209    Check if a text is encoded in UTF-8.  If it is, return 1, else
申鐃緒申  1210    return 0.  */
申鐃緒申  1211 
申鐃緒申  1212 #define UTF_8_1_OCTET_P(c)         ((c) < 0x80)
申鐃緒申  1213 #define UTF_8_EXTRA_OCTET_P(c)     (((c) & 0xC0) == 0x80)
申鐃緒申  1214 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
申鐃緒申  1215 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
申鐃緒申  1216 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
申鐃緒申  1217 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
申鐃緒申  1218 
申鐃緒申  1219 static int
申鐃緒申  1220 detect_coding_utf_8 (coding, detect_info)
申鐃緒申  1221      struct coding_system *coding;
申鐃緒申  1222      struct coding_detection_info *detect_info;
申鐃緒申  1223 {
申鐃緒申  1224   const unsigned char *src = coding->source, *src_base;
申鐃緒申  1225   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1226   int multibytep = coding->src_multibyte;
申鐃緒申  1227   int consumed_chars = 0;
申鐃緒申  1228   int found = 0;
申鐃緒申  1229 
申鐃緒申  1230   detect_info->checked |= CATEGORY_MASK_UTF_8;
申鐃緒申  1231   /* A coding system of this category is always ASCII compatible.  */
申鐃緒申  1232   src += coding->head_ascii;
申鐃緒申  1233 
申鐃緒申  1234   while (1)
申鐃緒申  1235     {
申鐃緒申  1236       int c, c1, c2, c3, c4;
申鐃緒申  1237 
申鐃緒申  1238       src_base = src;
申鐃緒申  1239       ONE_MORE_BYTE (c);
申鐃緒申  1240       if (c < 0 || UTF_8_1_OCTET_P (c))
申鐃緒申  1241 	continue;
申鐃緒申  1242       ONE_MORE_BYTE (c1);
申鐃緒申  1243       if (c1 < 0 || ! UTF_8_EXTRA_OCTET_P (c1))
申鐃緒申  1244 	break;
申鐃緒申  1245       if (UTF_8_2_OCTET_LEADING_P (c))
申鐃緒申  1246 	{
申鐃緒申  1247 	  found = CATEGORY_MASK_UTF_8;
申鐃緒申  1248 	  continue;
申鐃緒申  1249 	}
申鐃緒申  1250       ONE_MORE_BYTE (c2);
申鐃緒申  1251       if (c2 < 0 || ! UTF_8_EXTRA_OCTET_P (c2))
申鐃緒申  1252 	break;
申鐃緒申  1253       if (UTF_8_3_OCTET_LEADING_P (c))
申鐃緒申  1254 	{
申鐃緒申  1255 	  found = CATEGORY_MASK_UTF_8;
申鐃緒申  1256 	  continue;
申鐃緒申  1257 	}
申鐃緒申  1258       ONE_MORE_BYTE (c3);
申鐃緒申  1259       if (c3 < 0 || ! UTF_8_EXTRA_OCTET_P (c3))
申鐃緒申  1260 	break;
申鐃緒申  1261       if (UTF_8_4_OCTET_LEADING_P (c))
申鐃緒申  1262 	{
申鐃緒申  1263 	  found = CATEGORY_MASK_UTF_8;
申鐃緒申  1264 	  continue;
申鐃緒申  1265 	}
申鐃緒申  1266       ONE_MORE_BYTE (c4);
申鐃緒申  1267       if (c4 < 0 || ! UTF_8_EXTRA_OCTET_P (c4))
申鐃緒申  1268 	break;
申鐃緒申  1269       if (UTF_8_5_OCTET_LEADING_P (c))
申鐃緒申  1270 	{
申鐃緒申  1271 	  found = CATEGORY_MASK_UTF_8;
申鐃緒申  1272 	  continue;
申鐃緒申  1273 	}
申鐃緒申  1274       break;
申鐃緒申  1275     }
申鐃緒申  1276   detect_info->rejected |= CATEGORY_MASK_UTF_8;
申鐃緒申  1277   return 0;
申鐃緒申  1278 
申鐃緒申  1279  no_more_source:
申鐃緒申  1280   if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  1281     {
申鐃緒申  1282       detect_info->rejected |= CATEGORY_MASK_UTF_8;
申鐃緒申  1283       return 0;
申鐃緒申  1284     }
申鐃緒申  1285   detect_info->found |= found;
申鐃緒申  1286   return 1;
申鐃緒申  1287 }
申鐃緒申  1288 
申鐃緒申  1289 
申鐃緒申  1290 static void
申鐃緒申  1291 decode_coding_utf_8 (coding)
申鐃緒申  1292      struct coding_system *coding;
申鐃緒申  1293 {
申鐃緒申  1294   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  1295   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1296   const unsigned char *src_base;
申鐃緒申  1297   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  1298   int *charbuf_end = coding->charbuf + coding->charbuf_size;
申鐃緒申  1299   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  1300   int multibytep = coding->src_multibyte;
申鐃緒申  1301   Lisp_Object attr, charset_list;
申鐃緒申  1302   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  1303   int byte_after_cr = -1;
申鐃緒申  1304 
申鐃緒申  1305   CODING_GET_INFO (coding, attr, charset_list);
申鐃緒申  1306 
申鐃緒申  1307   while (1)
申鐃緒申  1308     {
申鐃緒申  1309       int c, c1, c2, c3, c4, c5;
申鐃緒申  1310 
申鐃緒申  1311       src_base = src;
申鐃緒申  1312       consumed_chars_base = consumed_chars;
申鐃緒申  1313 
申鐃緒申  1314       if (charbuf >= charbuf_end)
申鐃緒申  1315 	break;
申鐃緒申  1316 
申鐃緒申  1317       if (byte_after_cr >= 0)
申鐃緒申  1318 	c1 = byte_after_cr, byte_after_cr = -1;
申鐃緒申  1319       else
申鐃緒申  1320 	ONE_MORE_BYTE (c1);
申鐃緒申  1321       if (c1 < 0)
申鐃緒申  1322 	{
申鐃緒申  1323 	  c = - c1;
申鐃緒申  1324 	}
申鐃緒申  1325       else if (UTF_8_1_OCTET_P(c1))
申鐃緒申  1326 	{
申鐃緒申  1327 	  if (eol_crlf && c1 == '\r')
申鐃緒申  1328 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  1329 	  c = c1;
申鐃緒申  1330 	}
申鐃緒申  1331       else
申鐃緒申  1332 	{
申鐃緒申  1333 	  ONE_MORE_BYTE (c2);
申鐃緒申  1334 	  if (c2 < 0 || ! UTF_8_EXTRA_OCTET_P (c2))
申鐃緒申  1335 	    goto invalid_code;
申鐃緒申  1336 	  if (UTF_8_2_OCTET_LEADING_P (c1))
申鐃緒申  1337 	    {
申鐃緒申  1338 	      c = ((c1 & 0x1F) << 6) | (c2 & 0x3F);
申鐃緒申  1339 	      /* Reject overlong sequences here and below.  Encoders
申鐃緒申  1340 		 producing them are incorrect, they can be misleading,
申鐃緒申  1341 		 and they mess up read/write invariance.  */
申鐃緒申  1342 	      if (c < 128)
申鐃緒申  1343 		goto invalid_code;
申鐃緒申  1344 	    }
申鐃緒申  1345 	  else
申鐃緒申  1346 	    {
申鐃緒申  1347 	      ONE_MORE_BYTE (c3);
申鐃緒申  1348 	      if (c3 < 0 || ! UTF_8_EXTRA_OCTET_P (c3))
申鐃緒申  1349 		goto invalid_code;
申鐃緒申  1350 	      if (UTF_8_3_OCTET_LEADING_P (c1))
申鐃緒申  1351 		{
申鐃緒申  1352 		  c = (((c1 & 0xF) << 12)
申鐃緒申  1353 		       | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
申鐃緒申  1354 		  if (c < 0x800
申鐃緒申  1355 		      || (c >= 0xd800 && c < 0xe000)) /* surrogates (invalid) */
申鐃緒申  1356 		    goto invalid_code;
申鐃緒申  1357 		}
申鐃緒申  1358 	      else
申鐃緒申  1359 		{
申鐃緒申  1360 		  ONE_MORE_BYTE (c4);
申鐃緒申  1361 		  if (c4 < 0 || ! UTF_8_EXTRA_OCTET_P (c4))
申鐃緒申  1362 		    goto invalid_code;
申鐃緒申  1363 		  if (UTF_8_4_OCTET_LEADING_P (c1))
申鐃緒申  1364 		    {
申鐃緒申  1365 		    c = (((c1 & 0x7) << 18) | ((c2 & 0x3F) << 12)
申鐃緒申  1366 			 | ((c3 & 0x3F) << 6) | (c4 & 0x3F));
申鐃緒申  1367 		    if (c < 0x10000)
申鐃緒申  1368 		      goto invalid_code;
申鐃緒申  1369 		    }
申鐃緒申  1370 		  else
申鐃緒申  1371 		    {
申鐃緒申  1372 		      ONE_MORE_BYTE (c5);
申鐃緒申  1373 		      if (c5 < 0 || ! UTF_8_EXTRA_OCTET_P (c5))
申鐃緒申  1374 			goto invalid_code;
申鐃緒申  1375 		      if (UTF_8_5_OCTET_LEADING_P (c1))
申鐃緒申  1376 			{
申鐃緒申  1377 			  c = (((c1 & 0x3) << 24) | ((c2 & 0x3F) << 18)
申鐃緒申  1378 			       | ((c3 & 0x3F) << 12) | ((c4 & 0x3F) << 6)
申鐃緒申  1379 			       | (c5 & 0x3F));
申鐃緒申  1380 			  if ((c > MAX_CHAR) || (c < 0x200000))
申鐃緒申  1381 			    goto invalid_code;
申鐃緒申  1382 			}
申鐃緒申  1383 		      else
申鐃緒申  1384 			goto invalid_code;
申鐃緒申  1385 		    }
申鐃緒申  1386 		}
申鐃緒申  1387 	    }
申鐃緒申  1388 	}
申鐃緒申  1389 
申鐃緒申  1390       *charbuf++ = c;
申鐃緒申  1391       continue;
申鐃緒申  1392 
申鐃緒申  1393     invalid_code:
申鐃緒申  1394       src = src_base;
申鐃緒申  1395       consumed_chars = consumed_chars_base;
申鐃緒申  1396       ONE_MORE_BYTE (c);
申鐃緒申  1397       *charbuf++ = ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
申鐃緒申  1398       coding->errors++;
申鐃緒申  1399     }
申鐃緒申  1400 
申鐃緒申  1401  no_more_source:
申鐃緒申  1402   coding->consumed_char += consumed_chars_base;
申鐃緒申  1403   coding->consumed = src_base - coding->source;
申鐃緒申  1404   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  1405 }
申鐃緒申  1406 
申鐃緒申  1407 
申鐃緒申  1408 static int
申鐃緒申  1409 encode_coding_utf_8 (coding)
申鐃緒申  1410      struct coding_system *coding;
申鐃緒申  1411 {
申鐃緒申  1412   int multibytep = coding->dst_multibyte;
申鐃緒申  1413   int *charbuf = coding->charbuf;
申鐃緒申  1414   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  1415   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  1416   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  1417   int produced_chars = 0;
申鐃緒申  1418   int c;
申鐃緒申  1419 
申鐃緒申  1420   if (multibytep)
申鐃緒申  1421     {
申鐃緒申  1422       int safe_room = MAX_MULTIBYTE_LENGTH * 2;
申鐃緒申  1423 
申鐃緒申  1424       while (charbuf < charbuf_end)
申鐃緒申  1425 	{
申鐃緒申  1426 	  unsigned char str[MAX_MULTIBYTE_LENGTH], *p, *pend = str;
申鐃緒申  1427 
申鐃緒申  1428 	  ASSURE_DESTINATION (safe_room);
申鐃緒申  1429 	  c = *charbuf++;
申鐃緒申  1430 	  if (CHAR_BYTE8_P (c))
申鐃緒申  1431 	    {
申鐃緒申  1432 	      c = CHAR_TO_BYTE8 (c);
申鐃緒申  1433 	      EMIT_ONE_BYTE (c);
申鐃緒申  1434 	    }
申鐃緒申  1435 	  else
申鐃緒申  1436 	    {
申鐃緒申  1437 	      CHAR_STRING_ADVANCE_NO_UNIFY (c, pend);
申鐃緒申  1438 	      for (p = str; p < pend; p++)
申鐃緒申  1439 		EMIT_ONE_BYTE (*p);
申鐃緒申  1440 	    }
申鐃緒申  1441 	}
申鐃緒申  1442     }
申鐃緒申  1443   else
申鐃緒申  1444     {
申鐃緒申  1445       int safe_room = MAX_MULTIBYTE_LENGTH;
申鐃緒申  1446 
申鐃緒申  1447       while (charbuf < charbuf_end)
申鐃緒申  1448 	{
申鐃緒申  1449 	  ASSURE_DESTINATION (safe_room);
申鐃緒申  1450 	  c = *charbuf++;
申鐃緒申  1451 	  if (CHAR_BYTE8_P (c))
申鐃緒申  1452 	    *dst++ = CHAR_TO_BYTE8 (c);
申鐃緒申  1453 	  else
申鐃緒申  1454 	    CHAR_STRING_ADVANCE_NO_UNIFY (c, dst);
申鐃緒申  1455 	  produced_chars++;
申鐃緒申  1456 	}
申鐃緒申  1457     }
申鐃緒申  1458   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  1459   coding->produced_char += produced_chars;
申鐃緒申  1460   coding->produced = dst - coding->destination;
申鐃緒申  1461   return 0;
申鐃緒申  1462 }
申鐃緒申  1463 
申鐃緒申  1464 
申鐃緒申  1465 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  1466    Check if a text is encoded in one of UTF-16 based coding systems.
申鐃緒申  1467    If it is, return 1, else return 0.  */
申鐃緒申  1468 
申鐃緒申  1469 #define UTF_16_HIGH_SURROGATE_P(val) \
申鐃緒申  1470   (((val) & 0xFC00) == 0xD800)
申鐃緒申  1471 
申鐃緒申  1472 #define UTF_16_LOW_SURROGATE_P(val) \
申鐃緒申  1473   (((val) & 0xFC00) == 0xDC00)
申鐃緒申  1474 
申鐃緒申  1475 #define UTF_16_INVALID_P(val)	\
申鐃緒申  1476   (((val) == 0xFFFE)		\
申鐃緒申  1477    || ((val) == 0xFFFF)		\
申鐃緒申  1478    || UTF_16_LOW_SURROGATE_P (val))
申鐃緒申  1479 
申鐃緒申  1480 
申鐃緒申  1481 static int
申鐃緒申  1482 detect_coding_utf_16 (coding, detect_info)
申鐃緒申  1483      struct coding_system *coding;
申鐃緒申  1484      struct coding_detection_info *detect_info;
申鐃緒申  1485 {
申鐃緒申  1486   const unsigned char *src = coding->source, *src_base = src;
申鐃緒申  1487   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1488   int multibytep = coding->src_multibyte;
申鐃緒申  1489   int consumed_chars = 0;
申鐃緒申  1490   int c1, c2;
申鐃緒申  1491 
申鐃緒申  1492   detect_info->checked |= CATEGORY_MASK_UTF_16;
申鐃緒申  1493   if (coding->mode & CODING_MODE_LAST_BLOCK
申鐃緒申  1494       && (coding->src_chars & 1))
申鐃緒申  1495     {
申鐃緒申  1496       detect_info->rejected |= CATEGORY_MASK_UTF_16;
申鐃緒申  1497       return 0;
申鐃緒申  1498     }
申鐃緒申  1499 
申鐃緒申  1500   ONE_MORE_BYTE (c1);
申鐃緒申  1501   ONE_MORE_BYTE (c2);
申鐃緒申  1502   if ((c1 == 0xFF) && (c2 == 0xFE))
申鐃緒申  1503     {
申鐃緒申  1504       detect_info->found |= (CATEGORY_MASK_UTF_16_LE
申鐃緒申  1505 			     | CATEGORY_MASK_UTF_16_AUTO);
申鐃緒申  1506       detect_info->rejected |= (CATEGORY_MASK_UTF_16_BE
申鐃緒申  1507 				| CATEGORY_MASK_UTF_16_BE_NOSIG
申鐃緒申  1508 				| CATEGORY_MASK_UTF_16_LE_NOSIG);
申鐃緒申  1509     }
申鐃緒申  1510   else if ((c1 == 0xFE) && (c2 == 0xFF))
申鐃緒申  1511     {
申鐃緒申  1512       detect_info->found |= (CATEGORY_MASK_UTF_16_BE
申鐃緒申  1513 			     | CATEGORY_MASK_UTF_16_AUTO);
申鐃緒申  1514       detect_info->rejected |= (CATEGORY_MASK_UTF_16_LE
申鐃緒申  1515 				| CATEGORY_MASK_UTF_16_BE_NOSIG
申鐃緒申  1516 				| CATEGORY_MASK_UTF_16_LE_NOSIG);
申鐃緒申  1517     }
申鐃緒申  1518   else
申鐃緒申  1519     {
申鐃緒申  1520       /* We check the dispersion of Eth and Oth bytes where E is even and
申鐃緒申  1521 	 O is odd.  If both are high, we assume binary data.*/
申鐃緒申  1522       unsigned char e[256], o[256];
申鐃緒申  1523       unsigned e_num = 1, o_num = 1;
申鐃緒申  1524 
申鐃緒申  1525       memset (e, 0, 256);
申鐃緒申  1526       memset (o, 0, 256);
申鐃緒申  1527       e[c1] = 1;
申鐃緒申  1528       o[c2] = 1;
申鐃緒申  1529 
申鐃緒申  1530       detect_info->rejected
申鐃緒申  1531 	|= (CATEGORY_MASK_UTF_16_BE | CATEGORY_MASK_UTF_16_LE);
申鐃緒申  1532 
申鐃緒申  1533       while (1)
申鐃緒申  1534 	{
申鐃緒申  1535 	  ONE_MORE_BYTE (c1);
申鐃緒申  1536 	  ONE_MORE_BYTE (c2);
申鐃緒申  1537 	  if (! e[c1])
申鐃緒申  1538 	    {
申鐃緒申  1539 	      e[c1] = 1;
申鐃緒申  1540 	      e_num++;
申鐃緒申  1541 	      if (e_num >= 128)
申鐃緒申  1542 		break;
申鐃緒申  1543 	    }
申鐃緒申  1544 	  if (! o[c2])
申鐃緒申  1545 	    {
申鐃緒申  1546 	      o[c1] = 1;
申鐃緒申  1547 	      o_num++;
申鐃緒申  1548 	      if (o_num >= 128)
申鐃緒申  1549 		break;
申鐃緒申  1550 	    }
申鐃緒申  1551 	}
申鐃緒申  1552       detect_info->rejected |= CATEGORY_MASK_UTF_16;
申鐃緒申  1553       return 0;
申鐃緒申  1554     }
申鐃緒申  1555 
申鐃緒申  1556  no_more_source:
申鐃緒申  1557   return 1;
申鐃緒申  1558 }
申鐃緒申  1559 
申鐃緒申  1560 static void
申鐃緒申  1561 decode_coding_utf_16 (coding)
申鐃緒申  1562      struct coding_system *coding;
申鐃緒申  1563 {
申鐃緒申  1564   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  1565   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1566   const unsigned char *src_base;
申鐃緒申  1567   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  1568   int *charbuf_end = coding->charbuf + coding->charbuf_size;
申鐃緒申  1569   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  1570   int multibytep = coding->src_multibyte;
申鐃緒申  1571   enum utf_16_bom_type bom = CODING_UTF_16_BOM (coding);
申鐃緒申  1572   enum utf_16_endian_type endian = CODING_UTF_16_ENDIAN (coding);
申鐃緒申  1573   int surrogate = CODING_UTF_16_SURROGATE (coding);
申鐃緒申  1574   Lisp_Object attr, charset_list;
申鐃緒申  1575   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  1576   int byte_after_cr1 = -1, byte_after_cr2 = -1;
申鐃緒申  1577 
申鐃緒申  1578   CODING_GET_INFO (coding, attr, charset_list);
申鐃緒申  1579 
申鐃緒申  1580   if (bom == utf_16_with_bom)
申鐃緒申  1581     {
申鐃緒申  1582       int c, c1, c2;
申鐃緒申  1583 
申鐃緒申  1584       src_base = src;
申鐃緒申  1585       ONE_MORE_BYTE (c1);
申鐃緒申  1586       ONE_MORE_BYTE (c2);
申鐃緒申  1587       c = (c1 << 8) | c2;
申鐃緒申  1588 
申鐃緒申  1589       if (endian == utf_16_big_endian
申鐃緒申  1590 	  ? c != 0xFEFF : c != 0xFFFE)
申鐃緒申  1591 	{
申鐃緒申  1592 	  /* The first two bytes are not BOM.  Treat them as bytes
申鐃緒申  1593 	     for a normal character.  */
申鐃緒申  1594 	  src = src_base;
申鐃緒申  1595 	  coding->errors++;
申鐃緒申  1596 	}
申鐃緒申  1597       CODING_UTF_16_BOM (coding) = utf_16_without_bom;
申鐃緒申  1598     }
申鐃緒申  1599   else if (bom == utf_16_detect_bom)
申鐃緒申  1600     {
申鐃緒申  1601       /* We have already tried to detect BOM and failed in
申鐃緒申  1602 	 detect_coding.  */
申鐃緒申  1603       CODING_UTF_16_BOM (coding) = utf_16_without_bom;
申鐃緒申  1604     }
申鐃緒申  1605 
申鐃緒申  1606   while (1)
申鐃緒申  1607     {
申鐃緒申  1608       int c, c1, c2;
申鐃緒申  1609 
申鐃緒申  1610       src_base = src;
申鐃緒申  1611       consumed_chars_base = consumed_chars;
申鐃緒申  1612 
申鐃緒申  1613       if (charbuf + 2 >= charbuf_end)
申鐃緒申  1614 	break;
申鐃緒申  1615 
申鐃緒申  1616       if (byte_after_cr1 >= 0)
申鐃緒申  1617 	c1 = byte_after_cr1, byte_after_cr1 = -1;
申鐃緒申  1618       else
申鐃緒申  1619 	ONE_MORE_BYTE (c1);
申鐃緒申  1620       if (c1 < 0)
申鐃緒申  1621 	{
申鐃緒申  1622 	  *charbuf++ = -c1;
申鐃緒申  1623 	  continue;
申鐃緒申  1624 	}
申鐃緒申  1625       if (byte_after_cr2 >= 0)
申鐃緒申  1626 	c2 = byte_after_cr2, byte_after_cr2 = -1;
申鐃緒申  1627       else
申鐃緒申  1628 	ONE_MORE_BYTE (c2);
申鐃緒申  1629       if (c2 < 0)
申鐃緒申  1630 	{
申鐃緒申  1631 	  *charbuf++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
申鐃緒申  1632 	  *charbuf++ = -c2;
申鐃緒申  1633 	  continue;
申鐃緒申  1634 	}
申鐃緒申  1635       c = (endian == utf_16_big_endian
申鐃緒申  1636 	   ? ((c1 << 8) | c2) : ((c2 << 8) | c1));
申鐃緒申  1637 
申鐃緒申  1638       if (surrogate)
申鐃緒申  1639 	{
申鐃緒申  1640 	  if (! UTF_16_LOW_SURROGATE_P (c))
申鐃緒申  1641 	    {
申鐃緒申  1642 	      if (endian == utf_16_big_endian)
申鐃緒申  1643 		c1 = surrogate >> 8, c2 = surrogate & 0xFF;
申鐃緒申  1644 	      else
申鐃緒申  1645 		c1 = surrogate & 0xFF, c2 = surrogate >> 8;
申鐃緒申  1646 	      *charbuf++ = c1;
申鐃緒申  1647 	      *charbuf++ = c2;
申鐃緒申  1648 	      coding->errors++;
申鐃緒申  1649 	      if (UTF_16_HIGH_SURROGATE_P (c))
申鐃緒申  1650 		CODING_UTF_16_SURROGATE (coding) = surrogate = c;
申鐃緒申  1651 	      else
申鐃緒申  1652 		*charbuf++ = c;
申鐃緒申  1653 	    }
申鐃緒申  1654 	  else
申鐃緒申  1655 	    {
申鐃緒申  1656 	      c = ((surrogate - 0xD800) << 10) | (c - 0xDC00);
申鐃緒申  1657 	      CODING_UTF_16_SURROGATE (coding) = surrogate = 0;
申鐃緒申  1658 	      *charbuf++ = 0x10000 + c;
申鐃緒申  1659 	    }
申鐃緒申  1660 	}
申鐃緒申  1661       else
申鐃緒申  1662 	{
申鐃緒申  1663 	  if (UTF_16_HIGH_SURROGATE_P (c))
申鐃緒申  1664 	    CODING_UTF_16_SURROGATE (coding) = surrogate = c;
申鐃緒申  1665 	  else
申鐃緒申  1666 	    {
申鐃緒申  1667 	      if (eol_crlf && c == '\r')
申鐃緒申  1668 		{
申鐃緒申  1669 		  ONE_MORE_BYTE (byte_after_cr1);
申鐃緒申  1670 		  ONE_MORE_BYTE (byte_after_cr2);
申鐃緒申  1671 		}
申鐃緒申  1672 	      *charbuf++ = c;
申鐃緒申  1673 	    }
申鐃緒申  1674 	}
申鐃緒申  1675     }
申鐃緒申  1676 
申鐃緒申  1677  no_more_source:
申鐃緒申  1678   coding->consumed_char += consumed_chars_base;
申鐃緒申  1679   coding->consumed = src_base - coding->source;
申鐃緒申  1680   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  1681 }
申鐃緒申  1682 
申鐃緒申  1683 static int
申鐃緒申  1684 encode_coding_utf_16 (coding)
申鐃緒申  1685      struct coding_system *coding;
申鐃緒申  1686 {
申鐃緒申  1687   int multibytep = coding->dst_multibyte;
申鐃緒申  1688   int *charbuf = coding->charbuf;
申鐃緒申  1689   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  1690   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  1691   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  1692   int safe_room = 8;
申鐃緒申  1693   enum utf_16_bom_type bom = CODING_UTF_16_BOM (coding);
申鐃緒申  1694   int big_endian = CODING_UTF_16_ENDIAN (coding) == utf_16_big_endian;
申鐃緒申  1695   int produced_chars = 0;
申鐃緒申  1696   Lisp_Object attrs, charset_list;
申鐃緒申  1697   int c;
申鐃緒申  1698 
申鐃緒申  1699   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  1700 
申鐃緒申  1701   if (bom != utf_16_without_bom)
申鐃緒申  1702     {
申鐃緒申  1703       ASSURE_DESTINATION (safe_room);
申鐃緒申  1704       if (big_endian)
申鐃緒申  1705 	EMIT_TWO_BYTES (0xFE, 0xFF);
申鐃緒申  1706       else
申鐃緒申  1707 	EMIT_TWO_BYTES (0xFF, 0xFE);
申鐃緒申  1708       CODING_UTF_16_BOM (coding) = utf_16_without_bom;
申鐃緒申  1709     }
申鐃緒申  1710 
申鐃緒申  1711   while (charbuf < charbuf_end)
申鐃緒申  1712     {
申鐃緒申  1713       ASSURE_DESTINATION (safe_room);
申鐃緒申  1714       c = *charbuf++;
申鐃緒申  1715       if (c >= MAX_UNICODE_CHAR)
申鐃緒申  1716 	c = coding->default_char;
申鐃緒申  1717 
申鐃緒申  1718       if (c < 0x10000)
申鐃緒申  1719 	{
申鐃緒申  1720 	  if (big_endian)
申鐃緒申  1721 	    EMIT_TWO_BYTES (c >> 8, c & 0xFF);
申鐃緒申  1722 	  else
申鐃緒申  1723 	    EMIT_TWO_BYTES (c & 0xFF, c >> 8);
申鐃緒申  1724 	}
申鐃緒申  1725       else
申鐃緒申  1726 	{
申鐃緒申  1727 	  int c1, c2;
申鐃緒申  1728 
申鐃緒申  1729 	  c -= 0x10000;
申鐃緒申  1730 	  c1 = (c >> 10) + 0xD800;
申鐃緒申  1731 	  c2 = (c & 0x3FF) + 0xDC00;
申鐃緒申  1732 	  if (big_endian)
申鐃緒申  1733 	    EMIT_FOUR_BYTES (c1 >> 8, c1 & 0xFF, c2 >> 8, c2 & 0xFF);
申鐃緒申  1734 	  else
申鐃緒申  1735 	    EMIT_FOUR_BYTES (c1 & 0xFF, c1 >> 8, c2 & 0xFF, c2 >> 8);
申鐃緒申  1736 	}
申鐃緒申  1737     }
申鐃緒申  1738   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  1739   coding->produced = dst - coding->destination;
申鐃緒申  1740   coding->produced_char += produced_chars;
申鐃緒申  1741   return 0;
申鐃緒申  1742 }
申鐃緒申  1743 
申鐃緒申  1744 
申鐃緒申  1745 /*** 6. Old Emacs' internal format (emacs-mule) ***/
申鐃緒申  1746 
申鐃緒申  1747 /* Emacs' internal format for representation of multiple character
申鐃緒申  1748    sets is a kind of multi-byte encoding, i.e. characters are
申鐃緒申  1749    represented by variable-length sequences of one-byte codes.
申鐃緒申  1750 
申鐃緒申  1751    ASCII characters and control characters (e.g. `tab', `newline') are
申鐃緒申  1752    represented by one-byte sequences which are their ASCII codes, in
申鐃緒申  1753    the range 0x00 through 0x7F.
申鐃緒申  1754 
申鐃緒申  1755    8-bit characters of the range 0x80..0x9F are represented by
申鐃緒申  1756    two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
申鐃緒申  1757    code + 0x20).
申鐃緒申  1758 
申鐃緒申  1759    8-bit characters of the range 0xA0..0xFF are represented by
申鐃緒申  1760    one-byte sequences which are their 8-bit code.
申鐃緒申  1761 
申鐃緒申  1762    The other characters are represented by a sequence of `base
申鐃緒申  1763    leading-code', optional `extended leading-code', and one or two
申鐃緒申  1764    `position-code's.  The length of the sequence is determined by the
申鐃緒申  1765    base leading-code.  Leading-code takes the range 0x81 through 0x9D,
申鐃緒申  1766    whereas extended leading-code and position-code take the range 0xA0
申鐃緒申  1767    through 0xFF.  See `charset.h' for more details about leading-code
申鐃緒申  1768    and position-code.
申鐃緒申  1769 
申鐃緒申  1770    --- CODE RANGE of Emacs' internal format ---
申鐃緒申  1771    character set	range
申鐃緒申  1772    -------------	-----
申鐃緒申  1773    ascii		0x00..0x7F
申鐃緒申  1774    eight-bit-control	LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
申鐃緒申  1775    eight-bit-graphic	0xA0..0xBF
申鐃緒申  1776    ELSE			0x81..0x9D + [0xA0..0xFF]+
申鐃緒申  1777    ---------------------------------------------
申鐃緒申  1778 
申鐃緒申  1779    As this is the internal character representation, the format is
申鐃緒申  1780    usually not used externally (i.e. in a file or in a data sent to a
申鐃緒申  1781    process).  But, it is possible to have a text externally in this
申鐃緒申  1782    format (i.e. by encoding by the coding system `emacs-mule').
申鐃緒申  1783 
申鐃緒申  1784    In that case, a sequence of one-byte codes has a slightly different
申鐃緒申  1785    form.
申鐃緒申  1786 
申鐃緒申  1787    At first, all characters in eight-bit-control are represented by
申鐃緒申  1788    one-byte sequences which are their 8-bit code.
申鐃緒申  1789 
申鐃緒申  1790    Next, character composition data are represented by the byte
申鐃緒申  1791    sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
申鐃緒申  1792    where,
申鐃緒申  1793 	METHOD is 0xF0 plus one of composition method (enum
申鐃緒申  1794 	composition_method),
申鐃緒申  1795 
申鐃緒申  1796 	BYTES is 0xA0 plus a byte length of this composition data,
申鐃緒申  1797 
申鐃緒申  1798 	CHARS is 0x20 plus a number of characters composed by this
申鐃緒申  1799 	data,
申鐃緒申  1800 
申鐃緒申  1801 	COMPONENTs are characters of multibye form or composition
申鐃緒申  1802 	rules encoded by two-byte of ASCII codes.
申鐃緒申  1803 
申鐃緒申  1804    In addition, for backward compatibility, the following formats are
申鐃緒申  1805    also recognized as composition data on decoding.
申鐃緒申  1806 
申鐃緒申  1807    0x80 MSEQ ...
申鐃緒申  1808    0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
申鐃緒申  1809 
申鐃緒申  1810    Here,
申鐃緒申  1811 	MSEQ is a multibyte form but in these special format:
申鐃緒申  1812 	  ASCII: 0xA0 ASCII_CODE+0x80,
申鐃緒申  1813 	  other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
申鐃緒申  1814 	RULE is a one byte code of the range 0xA0..0xF0 that
申鐃緒申  1815 	represents a composition rule.
申鐃緒申  1816   */
申鐃緒申  1817 
申鐃緒申  1818 char emacs_mule_bytes[256];
申鐃緒申  1819 
申鐃緒申  1820 int
申鐃緒申  1821 emacs_mule_char (coding, src, nbytes, nchars, id)
申鐃緒申  1822      struct coding_system *coding;
申鐃緒申  1823      const unsigned char *src;
申鐃緒申  1824      int *nbytes, *nchars, *id;
申鐃緒申  1825 {
申鐃緒申  1826   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1827   const unsigned char *src_base = src;
申鐃緒申  1828   int multibytep = coding->src_multibyte;
申鐃緒申  1829   struct charset *charset;
申鐃緒申  1830   unsigned code;
申鐃緒申  1831   int c;
申鐃緒申  1832   int consumed_chars = 0;
申鐃緒申  1833 
申鐃緒申  1834   ONE_MORE_BYTE (c);
申鐃緒申  1835   if (c < 0)
申鐃緒申  1836     {
申鐃緒申  1837       c = -c;
申鐃緒申  1838       charset = emacs_mule_charset[0];
申鐃緒申  1839     }
申鐃緒申  1840   else
申鐃緒申  1841     {
申鐃緒申  1842       if (c >= 0xA0)
申鐃緒申  1843 	{
申鐃緒申  1844 	  /* Old style component character of a composition.  */
申鐃緒申  1845 	  if (c == 0xA0)
申鐃緒申  1846 	    {
申鐃緒申  1847 	      ONE_MORE_BYTE (c);
申鐃緒申  1848 	      c -= 0x80;
申鐃緒申  1849 	    }
申鐃緒申  1850 	  else
申鐃緒申  1851 	    c -= 0x20;
申鐃緒申  1852 	}
申鐃緒申  1853 
申鐃緒申  1854       switch (emacs_mule_bytes[c])
申鐃緒申  1855 	{
申鐃緒申  1856 	case 2:
申鐃緒申  1857 	  if (! (charset = emacs_mule_charset[c]))
申鐃緒申  1858 	    goto invalid_code;
申鐃緒申  1859 	  ONE_MORE_BYTE (c);
申鐃緒申  1860 	  if (c < 0xA0)
申鐃緒申  1861 	    goto invalid_code;
申鐃緒申  1862 	  code = c & 0x7F;
申鐃緒申  1863 	  break;
申鐃緒申  1864 
申鐃緒申  1865 	case 3:
申鐃緒申  1866 	  if (c == EMACS_MULE_LEADING_CODE_PRIVATE_11
申鐃緒申  1867 	      || c == EMACS_MULE_LEADING_CODE_PRIVATE_12)
申鐃緒申  1868 	    {
申鐃緒申  1869 	      ONE_MORE_BYTE (c);
申鐃緒申  1870 	      if (c < 0xA0 || ! (charset = emacs_mule_charset[c]))
申鐃緒申  1871 		goto invalid_code;
申鐃緒申  1872 	      ONE_MORE_BYTE (c);
申鐃緒申  1873 	      if (c < 0xA0)
申鐃緒申  1874 		goto invalid_code;
申鐃緒申  1875 	      code = c & 0x7F;
申鐃緒申  1876 	    }
申鐃緒申  1877 	  else
申鐃緒申  1878 	    {
申鐃緒申  1879 	      if (! (charset = emacs_mule_charset[c]))
申鐃緒申  1880 		goto invalid_code;
申鐃緒申  1881 	      ONE_MORE_BYTE (c);
申鐃緒申  1882 	      if (c < 0xA0)
申鐃緒申  1883 		goto invalid_code;
申鐃緒申  1884 	      code = (c & 0x7F) << 8;
申鐃緒申  1885 	      ONE_MORE_BYTE (c);
申鐃緒申  1886 	      if (c < 0xA0)
申鐃緒申  1887 		goto invalid_code;
申鐃緒申  1888 	      code |= c & 0x7F;
申鐃緒申  1889 	    }
申鐃緒申  1890 	  break;
申鐃緒申  1891 
申鐃緒申  1892 	case 4:
申鐃緒申  1893 	  ONE_MORE_BYTE (c);
申鐃緒申  1894 	  if (c < 0 || ! (charset = emacs_mule_charset[c]))
申鐃緒申  1895 	    goto invalid_code;
申鐃緒申  1896 	  ONE_MORE_BYTE (c);
申鐃緒申  1897 	  if (c < 0xA0)
申鐃緒申  1898 	    goto invalid_code;
申鐃緒申  1899 	  code = (c & 0x7F) << 8;
申鐃緒申  1900 	  ONE_MORE_BYTE (c);
申鐃緒申  1901 	  if (c < 0xA0)
申鐃緒申  1902 	    goto invalid_code;
申鐃緒申  1903 	  code |= c & 0x7F;
申鐃緒申  1904 	  break;
申鐃緒申  1905 
申鐃緒申  1906 	case 1:
申鐃緒申  1907 	  code = c;
申鐃緒申  1908 	  charset = CHARSET_FROM_ID (ASCII_BYTE_P (code)
申鐃緒申  1909 				     ? charset_ascii : charset_eight_bit);
申鐃緒申  1910 	  break;
申鐃緒申  1911 
申鐃緒申  1912 	default:
申鐃緒申  1913 	  abort ();
申鐃緒申  1914 	}
申鐃緒申  1915       c = DECODE_CHAR (charset, code);
申鐃緒申  1916       if (c < 0)
申鐃緒申  1917 	goto invalid_code;
申鐃緒申  1918     }
申鐃緒申  1919   *nbytes = src - src_base;
申鐃緒申  1920   *nchars = consumed_chars;
申鐃緒申  1921   if (id)
申鐃緒申  1922     *id = charset->id;
申鐃緒申  1923   return c;
申鐃緒申  1924 
申鐃緒申  1925  no_more_source:
申鐃緒申  1926   return -2;
申鐃緒申  1927 
申鐃緒申  1928  invalid_code:
申鐃緒申  1929   return -1;
申鐃緒申  1930 }
申鐃緒申  1931 
申鐃緒申  1932 
申鐃緒申  1933 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  1934    Check if a text is encoded in `emacs-mule'.  If it is, return 1,
申鐃緒申  1935    else return 0.  */
申鐃緒申  1936 
申鐃緒申  1937 static int
申鐃緒申  1938 detect_coding_emacs_mule (coding, detect_info)
申鐃緒申  1939      struct coding_system *coding;
申鐃緒申  1940      struct coding_detection_info *detect_info;
申鐃緒申  1941 {
申鐃緒申  1942   const unsigned char *src = coding->source, *src_base;
申鐃緒申  1943   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  1944   int multibytep = coding->src_multibyte;
申鐃緒申  1945   int consumed_chars = 0;
申鐃緒申  1946   int c;
申鐃緒申  1947   int found = 0;
申鐃緒申  1948 
申鐃緒申  1949   detect_info->checked |= CATEGORY_MASK_EMACS_MULE;
申鐃緒申  1950   /* A coding system of this category is always ASCII compatible.  */
申鐃緒申  1951   src += coding->head_ascii;
申鐃緒申  1952 
申鐃緒申  1953   while (1)
申鐃緒申  1954     {
申鐃緒申  1955       src_base = src;
申鐃緒申  1956       ONE_MORE_BYTE (c);
申鐃緒申  1957       if (c < 0)
申鐃緒申  1958 	continue;
申鐃緒申  1959       if (c == 0x80)
申鐃緒申  1960 	{
申鐃緒申  1961 	  /* Perhaps the start of composite character.  We simple skip
申鐃緒申  1962 	     it because analyzing it is too heavy for detecting.  But,
申鐃緒申  1963 	     at least, we check that the composite character
申鐃緒申  1964 	     constitutes of more than 4 bytes.  */
申鐃緒申  1965 	  const unsigned char *src_base;
申鐃緒申  1966 
申鐃緒申  1967 	repeat:
申鐃緒申  1968 	  src_base = src;
申鐃緒申  1969 	  do
申鐃緒申  1970 	    {
申鐃緒申  1971 	      ONE_MORE_BYTE (c);
申鐃緒申  1972 	    }
申鐃緒申  1973 	  while (c >= 0xA0);
申鐃緒申  1974 
申鐃緒申  1975 	  if (src - src_base <= 4)
申鐃緒申  1976 	    break;
申鐃緒申  1977 	  found = CATEGORY_MASK_EMACS_MULE;
申鐃緒申  1978 	  if (c == 0x80)
申鐃緒申  1979 	    goto repeat;
申鐃緒申  1980 	}
申鐃緒申  1981 
申鐃緒申  1982       if (c < 0x80)
申鐃緒申  1983 	{
申鐃緒申  1984 	  if (c < 0x20
申鐃緒申  1985 	      && (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO))
申鐃緒申  1986 	    break;
申鐃緒申  1987 	}
申鐃緒申  1988       else
申鐃緒申  1989 	{
申鐃緒申  1990 	  int more_bytes = emacs_mule_bytes[*src_base] - 1;
申鐃緒申  1991 
申鐃緒申  1992 	  while (more_bytes > 0)
申鐃緒申  1993 	    {
申鐃緒申  1994 	      ONE_MORE_BYTE (c);
申鐃緒申  1995 	      if (c < 0xA0)
申鐃緒申  1996 		{
申鐃緒申  1997 		  src--;	/* Unread the last byte.  */
申鐃緒申  1998 		  break;
申鐃緒申  1999 		}
申鐃緒申  2000 	      more_bytes--;
申鐃緒申  2001 	    }
申鐃緒申  2002 	  if (more_bytes != 0)
申鐃緒申  2003 	    break;
申鐃緒申  2004 	  found = CATEGORY_MASK_EMACS_MULE;
申鐃緒申  2005 	}
申鐃緒申  2006     }
申鐃緒申  2007   detect_info->rejected |= CATEGORY_MASK_EMACS_MULE;
申鐃緒申  2008   return 0;
申鐃緒申  2009 
申鐃緒申  2010  no_more_source:
申鐃緒申  2011   if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  2012     {
申鐃緒申  2013       detect_info->rejected |= CATEGORY_MASK_EMACS_MULE;
申鐃緒申  2014       return 0;
申鐃緒申  2015     }
申鐃緒申  2016   detect_info->found |= found;
申鐃緒申  2017   return 1;
申鐃緒申  2018 }
申鐃緒申  2019 
申鐃緒申  2020 
申鐃緒申  2021 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
申鐃緒申  2022 
申鐃緒申  2023 /* Decode a character represented as a component of composition
申鐃緒申  2024    sequence of Emacs 20/21 style at SRC.  Set C to that character and
申鐃緒申  2025    update SRC to the head of next character (or an encoded composition
申鐃緒申  2026    rule).  If SRC doesn't points a composition component, set C to -1.
申鐃緒申  2027    If SRC points an invalid byte sequence, global exit by a return
申鐃緒申  2028    value 0.  */
申鐃緒申  2029 
申鐃緒申  2030 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf)			\
申鐃緒申  2031   do    							\
申鐃緒申  2032     {								\
申鐃緒申  2033       int c;							\
申鐃緒申  2034       int nbytes, nchars;					\
申鐃緒申  2035 								\
申鐃緒申  2036       if (src == src_end)					\
申鐃緒申  2037 	break;							\
申鐃緒申  2038       c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
申鐃緒申  2039       if (c < 0)						\
申鐃緒申  2040 	{							\
申鐃緒申  2041 	  if (c == -2)						\
申鐃緒申  2042 	    break;						\
申鐃緒申  2043 	  goto invalid_code;					\
申鐃緒申  2044 	}							\
申鐃緒申  2045       *buf++ = c;						\
申鐃緒申  2046       src += nbytes;						\
申鐃緒申  2047       consumed_chars += nchars;					\
申鐃緒申  2048     }								\
申鐃緒申  2049   while (0)
申鐃緒申  2050 
申鐃緒申  2051 
申鐃緒申  2052 /* Decode a composition rule represented as a component of composition
申鐃緒申  2053    sequence of Emacs 20 style at SRC.  Store the decoded rule in *BUF,
申鐃緒申  2054    and increment BUF.  If SRC points an invalid byte sequence, set C
申鐃緒申  2055    to -1.  */
申鐃緒申  2056 
申鐃緒申  2057 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf)	\
申鐃緒申  2058   do {							\
申鐃緒申  2059     int c, gref, nref;					\
申鐃緒申  2060 							\
申鐃緒申  2061     if (src >= src_end)					\
申鐃緒申  2062       goto invalid_code;				\
申鐃緒申  2063     ONE_MORE_BYTE_NO_CHECK (c);				\
申鐃緒申  2064     c -= 0xA0;						\
申鐃緒申  2065     if (c < 0 || c >= 81)				\
申鐃緒申  2066       goto invalid_code;				\
申鐃緒申  2067 							\
申鐃緒申  2068     gref = c / 9, nref = c % 9;				\
申鐃緒申  2069     *buf++ = COMPOSITION_ENCODE_RULE (gref, nref);	\
申鐃緒申  2070   } while (0)
申鐃緒申  2071 
申鐃緒申  2072 
申鐃緒申  2073 /* Decode a composition rule represented as a component of composition
申鐃緒申  2074    sequence of Emacs 21 style at SRC.  Store the decoded rule in *BUF,
申鐃緒申  2075    and increment BUF.  If SRC points an invalid byte sequence, set C
申鐃緒申  2076    to -1.  */
申鐃緒申  2077 
申鐃緒申  2078 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf)	\
申鐃緒申  2079   do {							\
申鐃緒申  2080     int gref, nref;					\
申鐃緒申  2081 							\
申鐃緒申  2082     if (src + 1>= src_end)				\
申鐃緒申  2083       goto invalid_code;				\
申鐃緒申  2084     ONE_MORE_BYTE_NO_CHECK (gref);			\
申鐃緒申  2085     gref -= 0x20;					\
申鐃緒申  2086     ONE_MORE_BYTE_NO_CHECK (nref);			\
申鐃緒申  2087     nref -= 0x20;					\
申鐃緒申  2088     if (gref < 0 || gref >= 81				\
申鐃緒申  2089 	|| nref < 0 || nref >= 81)			\
申鐃緒申  2090       goto invalid_code;				\
申鐃緒申  2091     *buf++ = COMPOSITION_ENCODE_RULE (gref, nref);	\
申鐃緒申  2092   } while (0)
申鐃緒申  2093 
申鐃緒申  2094 
申鐃緒申  2095 #define DECODE_EMACS_MULE_21_COMPOSITION(c)				\
申鐃緒申  2096   do {									\
申鐃緒申  2097     /* Emacs 21 style format.  The first three bytes at SRC are		\
申鐃緒申  2098        (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is	\
申鐃緒申  2099        the byte length of this composition information, CHARS is the	\
申鐃緒申  2100        number of characters composed by this composition.  */		\
申鐃緒申  2101     enum composition_method method = c - 0xF2;				\
申鐃緒申  2102     int *charbuf_base = charbuf;					\
申鐃緒申  2103     int consumed_chars_limit;						\
申鐃緒申  2104     int nbytes, nchars;							\
申鐃緒申  2105 									\
申鐃緒申  2106     ONE_MORE_BYTE (c);							\
申鐃緒申  2107     if (c < 0)								\
申鐃緒申  2108       goto invalid_code;						\
申鐃緒申  2109     nbytes = c - 0xA0;							\
申鐃緒申  2110     if (nbytes < 3)							\
申鐃緒申  2111       goto invalid_code;						\
申鐃緒申  2112     ONE_MORE_BYTE (c);							\
申鐃緒申  2113     if (c < 0)								\
申鐃緒申  2114       goto invalid_code;						\
申鐃緒申  2115     nchars = c - 0xA0;							\
申鐃緒申  2116     ADD_COMPOSITION_DATA (charbuf, nchars, method);			\
申鐃緒申  2117     consumed_chars_limit = consumed_chars_base + nbytes;		\
申鐃緒申  2118     if (method != COMPOSITION_RELATIVE)					\
申鐃緒申  2119       {									\
申鐃緒申  2120 	int i = 0;							\
申鐃緒申  2121 	while (consumed_chars < consumed_chars_limit)			\
申鐃緒申  2122 	  {								\
申鐃緒申  2123 	    if (i % 2 && method != COMPOSITION_WITH_ALTCHARS)		\
申鐃緒申  2124 	      DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf);		\
申鐃緒申  2125 	    else							\
申鐃緒申  2126 	      DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf);		\
申鐃緒申  2127 	    i++;							\
申鐃緒申  2128 	  }								\
申鐃緒申  2129 	if (consumed_chars < consumed_chars_limit)			\
申鐃緒申  2130 	  goto invalid_code;						\
申鐃緒申  2131 	charbuf_base[0] -= i;						\
申鐃緒申  2132       }									\
申鐃緒申  2133   } while (0)
申鐃緒申  2134 
申鐃緒申  2135 
申鐃緒申  2136 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c)			\
申鐃緒申  2137   do {									\
申鐃緒申  2138     /* Emacs 20 style format for relative composition.  */		\
申鐃緒申  2139     /* Store multibyte form of characters to be composed.  */		\
申鐃緒申  2140     enum composition_method method = COMPOSITION_RELATIVE;		\
申鐃緒申  2141     int components[MAX_COMPOSITION_COMPONENTS * 2 - 1];			\
申鐃緒申  2142     int *buf = components;						\
申鐃緒申  2143     int i, j;								\
申鐃緒申  2144     									\
申鐃緒申  2145     src = src_base;							\
申鐃緒申  2146     ONE_MORE_BYTE (c);		/* skip 0x80 */				\
申鐃緒申  2147     for (i = 0; *src >= 0xA0 && i < MAX_COMPOSITION_COMPONENTS; i++)	\
申鐃緒申  2148       DECODE_EMACS_MULE_COMPOSITION_CHAR (buf);				\
申鐃緒申  2149     if (i < 2)								\
申鐃緒申  2150       goto invalid_code;						\
申鐃緒申  2151     ADD_COMPOSITION_DATA (charbuf, i, method);				\
申鐃緒申  2152     for (j = 0; j < i; j++)						\
申鐃緒申  2153       *charbuf++ = components[j];					\
申鐃緒申  2154   } while (0)
申鐃緒申  2155 
申鐃緒申  2156 
申鐃緒申  2157 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c)		\
申鐃緒申  2158   do {								\
申鐃緒申  2159     /* Emacs 20 style format for rule-base composition.  */	\
申鐃緒申  2160     /* Store multibyte form of characters to be composed.  */	\
申鐃緒申  2161     enum composition_method method = COMPOSITION_WITH_RULE;	\
申鐃緒申  2162     int *charbuf_base = charbuf;				\
申鐃緒申  2163     int components[MAX_COMPOSITION_COMPONENTS * 2 - 1];		\
申鐃緒申  2164     int *buf = components;					\
申鐃緒申  2165     int i, j;							\
申鐃緒申  2166     								\
申鐃緒申  2167     DECODE_EMACS_MULE_COMPOSITION_CHAR (buf);			\
申鐃緒申  2168     for (i = 1; i < MAX_COMPOSITION_COMPONENTS; i++)		\
申鐃緒申  2169       {								\
申鐃緒申  2170 	if (*src < 0xA0)					\
申鐃緒申  2171 	  break;						\
申鐃緒申  2172 	DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf);		\
申鐃緒申  2173 	DECODE_EMACS_MULE_COMPOSITION_CHAR (buf);		\
申鐃緒申  2174       }								\
申鐃緒申  2175     if (i <= 1 || (buf - components) % 2 == 0)			\
申鐃緒申  2176       goto invalid_code;					\
申鐃緒申  2177     if (charbuf + i + (i / 2) + 1 >= charbuf_end)		\
申鐃緒申  2178       goto no_more_source;					\
申鐃緒申  2179     ADD_COMPOSITION_DATA (charbuf, i, method);			\
申鐃緒申  2180     i = i * 2 - 1;						\
申鐃緒申  2181     for (j = 0; j < i; j++)					\
申鐃緒申  2182       *charbuf++ = components[j];				\
申鐃緒申  2183     charbuf_base[0] -= i;					\
申鐃緒申  2184     for (j = 0; j < i; j += 2)					\
申鐃緒申  2185       *charbuf++ = components[j];				\
申鐃緒申  2186   } while (0)
申鐃緒申  2187 
申鐃緒申  2188 
申鐃緒申  2189 static void
申鐃緒申  2190 decode_coding_emacs_mule (coding)
申鐃緒申  2191      struct coding_system *coding;
申鐃緒申  2192 {
申鐃緒申  2193   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  2194   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  2195   const unsigned char *src_base;
申鐃緒申  2196   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  2197   int *charbuf_end
申鐃緒申  2198     = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
申鐃緒申  2199   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  2200   int multibytep = coding->src_multibyte;
申鐃緒申  2201   Lisp_Object attrs, charset_list;
申鐃緒申  2202   int char_offset = coding->produced_char;
申鐃緒申  2203   int last_offset = char_offset;
申鐃緒申  2204   int last_id = charset_ascii;
申鐃緒申  2205   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  2206   int byte_after_cr = -1;
申鐃緒申  2207 
申鐃緒申  2208   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  2209 
申鐃緒申  2210   while (1)
申鐃緒申  2211     {
申鐃緒申  2212       int c;
申鐃緒申  2213 
申鐃緒申  2214       src_base = src;
申鐃緒申  2215       consumed_chars_base = consumed_chars;
申鐃緒申  2216 
申鐃緒申  2217       if (charbuf >= charbuf_end)
申鐃緒申  2218 	break;
申鐃緒申  2219 
申鐃緒申  2220       if (byte_after_cr >= 0)
申鐃緒申  2221 	c = byte_after_cr, byte_after_cr = -1;
申鐃緒申  2222       else
申鐃緒申  2223 	ONE_MORE_BYTE (c);
申鐃緒申  2224       if (c < 0)
申鐃緒申  2225 	{
申鐃緒申  2226 	  *charbuf++ = -c;
申鐃緒申  2227 	  char_offset++;
申鐃緒申  2228 	}
申鐃緒申  2229       else if (c < 0x80)
申鐃緒申  2230 	{
申鐃緒申  2231 	  if (eol_crlf && c == '\r')
申鐃緒申  2232 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  2233 	  *charbuf++ = c;
申鐃緒申  2234 	  char_offset++;
申鐃緒申  2235 	}
申鐃緒申  2236       else if (c == 0x80)
申鐃緒申  2237 	{
申鐃緒申  2238 	  ONE_MORE_BYTE (c);
申鐃緒申  2239 	  if (c < 0)
申鐃緒申  2240 	    goto invalid_code;
申鐃緒申  2241 	  if (c - 0xF2 >= COMPOSITION_RELATIVE
申鐃緒申  2242 	      && c - 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS)
申鐃緒申  2243 	    DECODE_EMACS_MULE_21_COMPOSITION (c);
申鐃緒申  2244 	  else if (c < 0xC0)
申鐃緒申  2245 	    DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c);
申鐃緒申  2246 	  else if (c == 0xFF)
申鐃緒申  2247 	    DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c);
申鐃緒申  2248 	  else
申鐃緒申  2249 	    goto invalid_code;
申鐃緒申  2250 	}
申鐃緒申  2251       else if (c < 0xA0 && emacs_mule_bytes[c] > 1)
申鐃緒申  2252 	{
申鐃緒申  2253 	  int nbytes, nchars;
申鐃緒申  2254 	  int id;
申鐃緒申  2255 
申鐃緒申  2256 	  src = src_base;
申鐃緒申  2257 	  consumed_chars = consumed_chars_base;
申鐃緒申  2258 	  c = emacs_mule_char (coding, src, &nbytes, &nchars, &id);
申鐃緒申  2259 	  if (c < 0)
申鐃緒申  2260 	    {
申鐃緒申  2261 	      if (c == -2)
申鐃緒申  2262 		break;
申鐃緒申  2263 	      goto invalid_code;
申鐃緒申  2264 	    }
申鐃緒申  2265 	  if (last_id != id)
申鐃緒申  2266 	    {
申鐃緒申  2267 	      if (last_id != charset_ascii)
申鐃緒申  2268 		ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  2269 	      last_id = id;
申鐃緒申  2270 	      last_offset = char_offset;
申鐃緒申  2271 	    }
申鐃緒申  2272 	  *charbuf++ = c;
申鐃緒申  2273 	  src += nbytes;
申鐃緒申  2274 	  consumed_chars += nchars;
申鐃緒申  2275 	  char_offset++;
申鐃緒申  2276 	}
申鐃緒申  2277       else
申鐃緒申  2278 	goto invalid_code;
申鐃緒申  2279       continue;
申鐃緒申  2280 
申鐃緒申  2281     invalid_code:
申鐃緒申  2282       src = src_base;
申鐃緒申  2283       consumed_chars = consumed_chars_base;
申鐃緒申  2284       ONE_MORE_BYTE (c);
申鐃緒申  2285       *charbuf++ = ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
申鐃緒申  2286       char_offset++;
申鐃緒申  2287       coding->errors++;
申鐃緒申  2288     }
申鐃緒申  2289 
申鐃緒申  2290  no_more_source:
申鐃緒申  2291   if (last_id != charset_ascii)
申鐃緒申  2292     ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  2293   coding->consumed_char += consumed_chars_base;
申鐃緒申  2294   coding->consumed = src_base - coding->source;
申鐃緒申  2295   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  2296 }
申鐃緒申  2297 
申鐃緒申  2298 
申鐃緒申  2299 #define EMACS_MULE_LEADING_CODES(id, codes)	\
申鐃緒申  2300   do {						\
申鐃緒申  2301     if (id < 0xA0)				\
申鐃緒申  2302       codes[0] = id, codes[1] = 0;		\
申鐃緒申  2303     else if (id < 0xE0)				\
申鐃緒申  2304       codes[0] = 0x9A, codes[1] = id;		\
申鐃緒申  2305     else if (id < 0xF0)				\
申鐃緒申  2306       codes[0] = 0x9B, codes[1] = id;		\
申鐃緒申  2307     else if (id < 0xF5)				\
申鐃緒申  2308       codes[0] = 0x9C, codes[1] = id;		\
申鐃緒申  2309     else					\
申鐃緒申  2310       codes[0] = 0x9D, codes[1] = id;		\
申鐃緒申  2311   } while (0);
申鐃緒申  2312 
申鐃緒申  2313 
申鐃緒申  2314 static int
申鐃緒申  2315 encode_coding_emacs_mule (coding)
申鐃緒申  2316      struct coding_system *coding;
申鐃緒申  2317 {
申鐃緒申  2318   int multibytep = coding->dst_multibyte;
申鐃緒申  2319   int *charbuf = coding->charbuf;
申鐃緒申  2320   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  2321   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  2322   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  2323   int safe_room = 8;
申鐃緒申  2324   int produced_chars = 0;
申鐃緒申  2325   Lisp_Object attrs, charset_list;
申鐃緒申  2326   int c;
申鐃緒申  2327   int preferred_charset_id = -1;
申鐃緒申  2328 
申鐃緒申  2329   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  2330   if (! EQ (charset_list, Vemacs_mule_charset_list))
申鐃緒申  2331     {
申鐃緒申  2332       CODING_ATTR_CHARSET_LIST (attrs)
申鐃緒申  2333 	= charset_list = Vemacs_mule_charset_list;
申鐃緒申  2334     }
申鐃緒申  2335 
申鐃緒申  2336   while (charbuf < charbuf_end)
申鐃緒申  2337     {
申鐃緒申  2338       ASSURE_DESTINATION (safe_room);
申鐃緒申  2339       c = *charbuf++;
申鐃緒申  2340 
申鐃緒申  2341       if (c < 0)
申鐃緒申  2342 	{
申鐃緒申  2343 	  /* Handle an annotation.  */
申鐃緒申  2344 	  switch (*charbuf)
申鐃緒申  2345 	    {
申鐃緒申  2346 	    case CODING_ANNOTATE_COMPOSITION_MASK:
申鐃緒申  2347 	      /* Not yet implemented.  */
申鐃緒申  2348 	      break;
申鐃緒申  2349 	    case CODING_ANNOTATE_CHARSET_MASK:
申鐃緒申  2350 	      preferred_charset_id = charbuf[3];
申鐃緒申  2351 	      if (preferred_charset_id >= 0
申鐃緒申  2352 		  && NILP (Fmemq (make_number (preferred_charset_id),
申鐃緒申  2353 				  charset_list)))
申鐃緒申  2354 		preferred_charset_id = -1;
申鐃緒申  2355 	      break;
申鐃緒申  2356 	    default:
申鐃緒申  2357 	      abort ();
申鐃緒申  2358 	    }
申鐃緒申  2359 	  charbuf += -c - 1;
申鐃緒申  2360 	  continue;
申鐃緒申  2361 	}
申鐃緒申  2362 
申鐃緒申  2363       if (ASCII_CHAR_P (c))
申鐃緒申  2364 	EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  2365       else if (CHAR_BYTE8_P (c))
申鐃緒申  2366 	{
申鐃緒申  2367 	  c = CHAR_TO_BYTE8 (c);
申鐃緒申  2368 	  EMIT_ONE_BYTE (c);
申鐃緒申  2369 	}
申鐃緒申  2370       else
申鐃緒申  2371 	{
申鐃緒申  2372 	  struct charset *charset;
申鐃緒申  2373 	  unsigned code;
申鐃緒申  2374 	  int dimension;
申鐃緒申  2375 	  int emacs_mule_id;
申鐃緒申  2376 	  unsigned char leading_codes[2];
申鐃緒申  2377 
申鐃緒申  2378 	  if (preferred_charset_id >= 0)
申鐃緒申  2379 	    {
申鐃緒申  2380 	      charset = CHARSET_FROM_ID (preferred_charset_id);
申鐃緒申  2381 	      if (! CHAR_CHARSET_P (c, charset))
申鐃緒申  2382 		charset = char_charset (c, charset_list, NULL);
申鐃緒申  2383 	    }
申鐃緒申  2384 	  else
申鐃緒申  2385 	    charset = char_charset (c, charset_list, &code);
申鐃緒申  2386 	  if (! charset)
申鐃緒申  2387 	    {
申鐃緒申  2388 	      c = coding->default_char;
申鐃緒申  2389 	      if (ASCII_CHAR_P (c))
申鐃緒申  2390 		{
申鐃緒申  2391 		  EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  2392 		  continue;
申鐃緒申  2393 		}
申鐃緒申  2394 	      charset = char_charset (c, charset_list, &code);
申鐃緒申  2395 	    }
申鐃緒申  2396 	  dimension = CHARSET_DIMENSION (charset);
申鐃緒申  2397 	  emacs_mule_id = CHARSET_EMACS_MULE_ID (charset);
申鐃緒申  2398 	  EMACS_MULE_LEADING_CODES (emacs_mule_id, leading_codes);
申鐃緒申  2399 	  EMIT_ONE_BYTE (leading_codes[0]);
申鐃緒申  2400 	  if (leading_codes[1])
申鐃緒申  2401 	    EMIT_ONE_BYTE (leading_codes[1]);
申鐃緒申  2402 	  if (dimension == 1)
申鐃緒申  2403 	    EMIT_ONE_BYTE (code | 0x80);
申鐃緒申  2404 	  else
申鐃緒申  2405 	    {
申鐃緒申  2406 	      code |= 0x8080;
申鐃緒申  2407 	      EMIT_ONE_BYTE (code >> 8);
申鐃緒申  2408 	      EMIT_ONE_BYTE (code & 0xFF);
申鐃緒申  2409 	    }
申鐃緒申  2410 	}
申鐃緒申  2411     }
申鐃緒申  2412   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  2413   coding->produced_char += produced_chars;
申鐃緒申  2414   coding->produced = dst - coding->destination;
申鐃緒申  2415   return 0;
申鐃緒申  2416 }
申鐃緒申  2417 
申鐃緒申  2418 
申鐃緒申  2419 /*** 7. ISO2022 handlers ***/
申鐃緒申  2420 
申鐃緒申  2421 /* The following note describes the coding system ISO2022 briefly.
申鐃緒申  2422    Since the intention of this note is to help understand the
申鐃緒申  2423    functions in this file, some parts are NOT ACCURATE or are OVERLY
申鐃緒申  2424    SIMPLIFIED.  For thorough understanding, please refer to the
申鐃緒申  2425    original document of ISO2022.  This is equivalent to the standard
申鐃緒申  2426    ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
申鐃緒申  2427 
申鐃緒申  2428    ISO2022 provides many mechanisms to encode several character sets
申鐃緒申  2429    in 7-bit and 8-bit environments.  For 7-bit environments, all text
申鐃緒申  2430    is encoded using bytes less than 128.  This may make the encoded
申鐃緒申  2431    text a little bit longer, but the text passes more easily through
申鐃緒申  2432    several types of gateway, some of which strip off the MSB (Most
申鐃緒申  2433    Significant Bit).
申鐃緒申  2434 
申鐃緒申  2435    There are two kinds of character sets: control character sets and
申鐃緒申  2436    graphic character sets.  The former contain control characters such
申鐃緒申  2437    as `newline' and `escape' to provide control functions (control
申鐃緒申  2438    functions are also provided by escape sequences).  The latter
申鐃緒申  2439    contain graphic characters such as 'A' and '-'.  Emacs recognizes
申鐃緒申  2440    two control character sets and many graphic character sets.
申鐃緒申  2441 
申鐃緒申  2442    Graphic character sets are classified into one of the following
申鐃緒申  2443    four classes, according to the number of bytes (DIMENSION) and
申鐃緒申  2444    number of characters in one dimension (CHARS) of the set:
申鐃緒申  2445    - DIMENSION1_CHARS94
申鐃緒申  2446    - DIMENSION1_CHARS96
申鐃緒申  2447    - DIMENSION2_CHARS94
申鐃緒申  2448    - DIMENSION2_CHARS96
申鐃緒申  2449 
申鐃緒申  2450    In addition, each character set is assigned an identification tag,
申鐃緒申  2451    unique for each set, called the "final character" (denoted as <F>
申鐃緒申  2452    hereafter).  The <F> of each character set is decided by ECMA(*)
申鐃緒申  2453    when it is registered in ISO.  The code range of <F> is 0x30..0x7F
申鐃緒申  2454    (0x30..0x3F are for private use only).
申鐃緒申  2455 
申鐃緒申  2456    Note (*): ECMA = European Computer Manufacturers Association
申鐃緒申  2457 
申鐃緒申  2458    Here are examples of graphic character sets [NAME(<F>)]:
申鐃緒申  2459 	o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
申鐃緒申  2460 	o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
申鐃緒申  2461 	o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
申鐃緒申  2462 	o DIMENSION2_CHARS96 -- none for the moment
申鐃緒申  2463 
申鐃緒申  2464    A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
申鐃緒申  2465 	C0 [0x00..0x1F] -- control character plane 0
申鐃緒申  2466 	GL [0x20..0x7F] -- graphic character plane 0
申鐃緒申  2467 	C1 [0x80..0x9F] -- control character plane 1
申鐃緒申  2468 	GR [0xA0..0xFF] -- graphic character plane 1
申鐃緒申  2469 
申鐃緒申  2470    A control character set is directly designated and invoked to C0 or
申鐃緒申  2471    C1 by an escape sequence.  The most common case is that:
申鐃緒申  2472    - ISO646's  control character set is designated/invoked to C0, and
申鐃緒申  2473    - ISO6429's control character set is designated/invoked to C1,
申鐃緒申  2474    and usually these designations/invocations are omitted in encoded
申鐃緒申  2475    text.  In a 7-bit environment, only C0 can be used, and a control
申鐃緒申  2476    character for C1 is encoded by an appropriate escape sequence to
申鐃緒申  2477    fit into the environment.  All control characters for C1 are
申鐃緒申  2478    defined to have corresponding escape sequences.
申鐃緒申  2479 
申鐃緒申  2480    A graphic character set is at first designated to one of four
申鐃緒申  2481    graphic registers (G0 through G3), then these graphic registers are
申鐃緒申  2482    invoked to GL or GR.  These designations and invocations can be
申鐃緒申  2483    done independently.  The most common case is that G0 is invoked to
申鐃緒申  2484    GL, G1 is invoked to GR, and ASCII is designated to G0.  Usually
申鐃緒申  2485    these invocations and designations are omitted in encoded text.
申鐃緒申  2486    In a 7-bit environment, only GL can be used.
申鐃緒申  2487 
申鐃緒申  2488    When a graphic character set of CHARS94 is invoked to GL, codes
申鐃緒申  2489    0x20 and 0x7F of the GL area work as control characters SPACE and
申鐃緒申  2490    DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
申鐃緒申  2491    be used.
申鐃緒申  2492 
申鐃緒申  2493    There are two ways of invocation: locking-shift and single-shift.
申鐃緒申  2494    With locking-shift, the invocation lasts until the next different
申鐃緒申  2495    invocation, whereas with single-shift, the invocation affects the
申鐃緒申  2496    following character only and doesn't affect the locking-shift
申鐃緒申  2497    state.  Invocations are done by the following control characters or
申鐃緒申  2498    escape sequences:
申鐃緒申  2499 
申鐃緒申  2500    ----------------------------------------------------------------------
申鐃緒申  2501    abbrev  function	             cntrl escape seq	description
申鐃緒申  2502    ----------------------------------------------------------------------
申鐃緒申  2503    SI/LS0  (shift-in)		     0x0F  none		invoke G0 into GL
申鐃緒申  2504    SO/LS1  (shift-out)		     0x0E  none		invoke G1 into GL
申鐃緒申  2505    LS2     (locking-shift-2)	     none  ESC 'n'	invoke G2 into GL
申鐃緒申  2506    LS3     (locking-shift-3)	     none  ESC 'o'	invoke G3 into GL
申鐃緒申  2507    LS1R    (locking-shift-1 right)   none  ESC '~'      invoke G1 into GR (*)
申鐃緒申  2508    LS2R    (locking-shift-2 right)   none  ESC '}'      invoke G2 into GR (*)
申鐃緒申  2509    LS3R    (locking-shift 3 right)   none  ESC '|'      invoke G3 into GR (*)
申鐃緒申  2510    SS2     (single-shift-2)	     0x8E  ESC 'N'	invoke G2 for one char
申鐃緒申  2511    SS3     (single-shift-3)	     0x8F  ESC 'O'	invoke G3 for one char
申鐃緒申  2512    ----------------------------------------------------------------------
申鐃緒申  2513    (*) These are not used by any known coding system.
申鐃緒申  2514 
申鐃緒申  2515    Control characters for these functions are defined by macros
申鐃緒申  2516    ISO_CODE_XXX in `coding.h'.
申鐃緒申  2517 
申鐃緒申  2518    Designations are done by the following escape sequences:
申鐃緒申  2519    ----------------------------------------------------------------------
申鐃緒申  2520    escape sequence	description
申鐃緒申  2521    ----------------------------------------------------------------------
申鐃緒申  2522    ESC '(' <F>		designate DIMENSION1_CHARS94<F> to G0
申鐃緒申  2523    ESC ')' <F>		designate DIMENSION1_CHARS94<F> to G1
申鐃緒申  2524    ESC '*' <F>		designate DIMENSION1_CHARS94<F> to G2
申鐃緒申  2525    ESC '+' <F>		designate DIMENSION1_CHARS94<F> to G3
申鐃緒申  2526    ESC ',' <F>		designate DIMENSION1_CHARS96<F> to G0 (*)
申鐃緒申  2527    ESC '-' <F>		designate DIMENSION1_CHARS96<F> to G1
申鐃緒申  2528    ESC '.' <F>		designate DIMENSION1_CHARS96<F> to G2
申鐃緒申  2529    ESC '/' <F>		designate DIMENSION1_CHARS96<F> to G3
申鐃緒申  2530    ESC '$' '(' <F>	designate DIMENSION2_CHARS94<F> to G0 (**)
申鐃緒申  2531    ESC '$' ')' <F>	designate DIMENSION2_CHARS94<F> to G1
申鐃緒申  2532    ESC '$' '*' <F>	designate DIMENSION2_CHARS94<F> to G2
申鐃緒申  2533    ESC '$' '+' <F>	designate DIMENSION2_CHARS94<F> to G3
申鐃緒申  2534    ESC '$' ',' <F>	designate DIMENSION2_CHARS96<F> to G0 (*)
申鐃緒申  2535    ESC '$' '-' <F>	designate DIMENSION2_CHARS96<F> to G1
申鐃緒申  2536    ESC '$' '.' <F>	designate DIMENSION2_CHARS96<F> to G2
申鐃緒申  2537    ESC '$' '/' <F>	designate DIMENSION2_CHARS96<F> to G3
申鐃緒申  2538    ----------------------------------------------------------------------
申鐃緒申  2539 
申鐃緒申  2540    In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
申鐃緒申  2541    of dimension 1, chars 94, and final character <F>, etc...
申鐃緒申  2542 
申鐃緒申  2543    Note (*): Although these designations are not allowed in ISO2022,
申鐃緒申  2544    Emacs accepts them on decoding, and produces them on encoding
申鐃緒申  2545    CHARS96 character sets in a coding system which is characterized as
申鐃緒申  2546    7-bit environment, non-locking-shift, and non-single-shift.
申鐃緒申  2547 
申鐃緒申  2548    Note (**): If <F> is '@', 'A', or 'B', the intermediate character
申鐃緒申  2549    '(' must be omitted.  We refer to this as "short-form" hereafter.
申鐃緒申  2550 
申鐃緒申  2551    Now you may notice that there are a lot of ways of encoding the
申鐃緒申  2552    same multilingual text in ISO2022.  Actually, there exist many
申鐃緒申  2553    coding systems such as Compound Text (used in X11's inter client
申鐃緒申  2554    communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
申鐃緒申  2555    (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
申鐃緒申  2556    localized platforms), and all of these are variants of ISO2022.
申鐃緒申  2557 
申鐃緒申  2558    In addition to the above, Emacs handles two more kinds of escape
申鐃緒申  2559    sequences: ISO6429's direction specification and Emacs' private
申鐃緒申  2560    sequence for specifying character composition.
申鐃緒申  2561 
申鐃緒申  2562    ISO6429's direction specification takes the following form:
申鐃緒申  2563 	o CSI ']'      -- end of the current direction
申鐃緒申  2564 	o CSI '0' ']'  -- end of the current direction
申鐃緒申  2565 	o CSI '1' ']'  -- start of left-to-right text
申鐃緒申  2566 	o CSI '2' ']'  -- start of right-to-left text
申鐃緒申  2567    The control character CSI (0x9B: control sequence introducer) is
申鐃緒申  2568    abbreviated to the escape sequence ESC '[' in a 7-bit environment.
申鐃緒申  2569 
申鐃緒申  2570    Character composition specification takes the following form:
申鐃緒申  2571 	o ESC '0' -- start relative composition
申鐃緒申  2572 	o ESC '1' -- end composition
申鐃緒申  2573 	o ESC '2' -- start rule-base composition (*)
申鐃緒申  2574 	o ESC '3' -- start relative composition with alternate chars  (**)
申鐃緒申  2575 	o ESC '4' -- start rule-base composition with alternate chars  (**)
申鐃緒申  2576   Since these are not standard escape sequences of any ISO standard,
申鐃緒申  2577   the use of them with these meanings is restricted to Emacs only.
申鐃緒申  2578 
申鐃緒申  2579   (*) This form is used only in Emacs 20.7 and older versions,
申鐃緒申  2580   but newer versions can safely decode it.
申鐃緒申  2581   (**) This form is used only in Emacs 21.1 and newer versions,
申鐃緒申  2582   and older versions can't decode it.
申鐃緒申  2583 
申鐃緒申  2584   Here's a list of example usages of these composition escape
申鐃緒申  2585   sequences (categorized by `enum composition_method').
申鐃緒申  2586 
申鐃緒申  2587   COMPOSITION_RELATIVE:
申鐃緒申  2588 	ESC 0 CHAR [ CHAR ] ESC 1
申鐃緒申  2589   COMPOSITION_WITH_RULE:
申鐃緒申  2590 	ESC 2 CHAR [ RULE CHAR ] ESC 1
申鐃緒申  2591   COMPOSITION_WITH_ALTCHARS:
申鐃緒申  2592 	ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
申鐃緒申  2593   COMPOSITION_WITH_RULE_ALTCHARS:
申鐃緒申  2594 	ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
申鐃緒申  2595 
申鐃緒申  2596 enum iso_code_class_type iso_code_class[256];
申鐃緒申  2597 
申鐃緒申  2598 #define SAFE_CHARSET_P(coding, id)	\
申鐃緒申  2599   ((id) <= (coding)->max_charset_id	\
申鐃緒申  2600    && (coding)->safe_charsets[id] >= 0)
申鐃緒申  2601 
申鐃緒申  2602 
申鐃緒申  2603 #define SHIFT_OUT_OK(category)	\
申鐃緒申  2604   (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
申鐃緒申  2605 
申鐃緒申  2606 static void
申鐃緒申  2607 setup_iso_safe_charsets (attrs)
申鐃緒申  2608      Lisp_Object attrs;
申鐃緒申  2609 {
申鐃緒申  2610   Lisp_Object charset_list, safe_charsets;
申鐃緒申  2611   Lisp_Object request;
申鐃緒申  2612   Lisp_Object reg_usage;
申鐃緒申  2613   Lisp_Object tail;
申鐃緒申  2614   int reg94, reg96;
申鐃緒申  2615   int flags = XINT (AREF (attrs, coding_attr_iso_flags));
申鐃緒申  2616   int max_charset_id;
申鐃緒申  2617 
申鐃緒申  2618   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  2619   if ((flags & CODING_ISO_FLAG_FULL_SUPPORT)
申鐃緒申  2620       && ! EQ (charset_list, Viso_2022_charset_list))
申鐃緒申  2621     {
申鐃緒申  2622       CODING_ATTR_CHARSET_LIST (attrs)
申鐃緒申  2623 	= charset_list = Viso_2022_charset_list;
申鐃緒申  2624       ASET (attrs, coding_attr_safe_charsets, Qnil);
申鐃緒申  2625     }
申鐃緒申  2626 
申鐃緒申  2627   if (STRINGP (AREF (attrs, coding_attr_safe_charsets)))
申鐃緒申  2628     return;
申鐃緒申  2629 
申鐃緒申  2630   max_charset_id = 0;
申鐃緒申  2631   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  2632     {
申鐃緒申  2633       int id = XINT (XCAR (tail));
申鐃緒申  2634       if (max_charset_id < id)
申鐃緒申  2635 	max_charset_id = id;
申鐃緒申  2636     }
申鐃緒申  2637 
申鐃緒申  2638   safe_charsets = Fmake_string (make_number (max_charset_id + 1),
申鐃緒申  2639 				make_number (255));
申鐃緒申  2640   request = AREF (attrs, coding_attr_iso_request);
申鐃緒申  2641   reg_usage = AREF (attrs, coding_attr_iso_usage);
申鐃緒申  2642   reg94 = XINT (XCAR (reg_usage));
申鐃緒申  2643   reg96 = XINT (XCDR (reg_usage));
申鐃緒申  2644 
申鐃緒申  2645   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  2646     {
申鐃緒申  2647       Lisp_Object id;
申鐃緒申  2648       Lisp_Object reg;
申鐃緒申  2649       struct charset *charset;
申鐃緒申  2650 
申鐃緒申  2651       id = XCAR (tail);
申鐃緒申  2652       charset = CHARSET_FROM_ID (XINT (id));
申鐃緒申  2653       reg = Fcdr (Fassq (id, request));
申鐃緒申  2654       if (! NILP (reg))
申鐃緒申  2655 	SSET (safe_charsets, XINT (id), XINT (reg));
申鐃緒申  2656       else if (charset->iso_chars_96)
申鐃緒申  2657 	{
申鐃緒申  2658 	  if (reg96 < 4)
申鐃緒申  2659 	    SSET (safe_charsets, XINT (id), reg96);
申鐃緒申  2660 	}
申鐃緒申  2661       else
申鐃緒申  2662 	{
申鐃緒申  2663 	  if (reg94 < 4)
申鐃緒申  2664 	    SSET (safe_charsets, XINT (id), reg94);
申鐃緒申  2665 	}
申鐃緒申  2666     }
申鐃緒申  2667   ASET (attrs, coding_attr_safe_charsets, safe_charsets);
申鐃緒申  2668 }
申鐃緒申  2669 
申鐃緒申  2670 
申鐃緒申  2671 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  2672    Check if a text is encoded in one of ISO-2022 based codig systems.
申鐃緒申  2673    If it is, return 1, else return 0.  */
申鐃緒申  2674 
申鐃緒申  2675 static int
申鐃緒申  2676 detect_coding_iso_2022 (coding, detect_info)
申鐃緒申  2677      struct coding_system *coding;
申鐃緒申  2678      struct coding_detection_info *detect_info;
申鐃緒申  2679 {
申鐃緒申  2680   const unsigned char *src = coding->source, *src_base = src;
申鐃緒申  2681   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  2682   int multibytep = coding->src_multibyte;
申鐃緒申  2683   int single_shifting = 0;
申鐃緒申  2684   int id;
申鐃緒申  2685   int c, c1;
申鐃緒申  2686   int consumed_chars = 0;
申鐃緒申  2687   int i;
申鐃緒申  2688   int rejected = 0;
申鐃緒申  2689   int found = 0;
申鐃緒申  2690 
申鐃緒申  2691   detect_info->checked |= CATEGORY_MASK_ISO;
申鐃緒申  2692 
申鐃緒申  2693   for (i = coding_category_iso_7; i <= coding_category_iso_8_else; i++)
申鐃緒申  2694     {
申鐃緒申  2695       struct coding_system *this = &(coding_categories[i]);
申鐃緒申  2696       Lisp_Object attrs, val;
申鐃緒申  2697 
申鐃緒申  2698       attrs = CODING_ID_ATTRS (this->id);
申鐃緒申  2699       if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
申鐃緒申  2700 	  && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs), Viso_2022_charset_list))
申鐃緒申  2701 	setup_iso_safe_charsets (attrs);
申鐃緒申  2702       val = CODING_ATTR_SAFE_CHARSETS (attrs);
申鐃緒申  2703       this->max_charset_id = SCHARS (val) - 1;
申鐃緒申  2704       this->safe_charsets = (char *) SDATA (val);
申鐃緒申  2705     }
申鐃緒申  2706 
申鐃緒申  2707   /* A coding system of this category is always ASCII compatible.  */
申鐃緒申  2708   src += coding->head_ascii;
申鐃緒申  2709 
申鐃緒申  2710   while (rejected != CATEGORY_MASK_ISO)
申鐃緒申  2711     {
申鐃緒申  2712       src_base = src;
申鐃緒申  2713       ONE_MORE_BYTE (c);
申鐃緒申  2714       switch (c)
申鐃緒申  2715 	{
申鐃緒申  2716 	case ISO_CODE_ESC:
申鐃緒申  2717 	  if (inhibit_iso_escape_detection)
申鐃緒申  2718 	    break;
申鐃緒申  2719 	  single_shifting = 0;
申鐃緒申  2720 	  ONE_MORE_BYTE (c);
申鐃緒申  2721 	  if (c >= '(' && c <= '/')
申鐃緒申  2722 	    {
申鐃緒申  2723 	      /* Designation sequence for a charset of dimension 1.  */
申鐃緒申  2724 	      ONE_MORE_BYTE (c1);
申鐃緒申  2725 	      if (c1 < ' ' || c1 >= 0x80
申鐃緒申  2726 		  || (id = iso_charset_table[0][c >= ','][c1]) < 0)
申鐃緒申  2727 		/* Invalid designation sequence.  Just ignore.  */
申鐃緒申  2728 		break;
申鐃緒申  2729 	    }
申鐃緒申  2730 	  else if (c == '$')
申鐃緒申  2731 	    {
申鐃緒申  2732 	      /* Designation sequence for a charset of dimension 2.  */
申鐃緒申  2733 	      ONE_MORE_BYTE (c);
申鐃緒申  2734 	      if (c >= '@' && c <= 'B')
申鐃緒申  2735 		/* Designation for JISX0208.1978, GB2312, or JISX0208.  */
申鐃緒申  2736 		id = iso_charset_table[1][0][c];
申鐃緒申  2737 	      else if (c >= '(' && c <= '/')
申鐃緒申  2738 		{
申鐃緒申  2739 		  ONE_MORE_BYTE (c1);
申鐃緒申  2740 		  if (c1 < ' ' || c1 >= 0x80
申鐃緒申  2741 		      || (id = iso_charset_table[1][c >= ','][c1]) < 0)
申鐃緒申  2742 		    /* Invalid designation sequence.  Just ignore.  */
申鐃緒申  2743 		    break;
申鐃緒申  2744 		}
申鐃緒申  2745 	      else
申鐃緒申  2746 		/* Invalid designation sequence.  Just ignore it.  */
申鐃緒申  2747 		break;
申鐃緒申  2748 	    }
申鐃緒申  2749 	  else if (c == 'N' || c == 'O')
申鐃緒申  2750 	    {
申鐃緒申  2751 	      /* ESC <Fe> for SS2 or SS3.  */
申鐃緒申  2752 	      single_shifting = 1;
申鐃緒申  2753 	      rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_8BIT;
申鐃緒申  2754 	      break;
申鐃緒申  2755 	    }
申鐃緒申  2756 	  else if (c >= '0' && c <= '4')
申鐃緒申  2757 	    {
申鐃緒申  2758 	      /* ESC <Fp> for start/end composition.  */
申鐃緒申  2759 	      found |= CATEGORY_MASK_ISO;
申鐃緒申  2760 	      break;
申鐃緒申  2761 	    }
申鐃緒申  2762 	  else
申鐃緒申  2763 	    {
申鐃緒申  2764 	      /* Invalid escape sequence.  Just ignore it.  */
申鐃緒申  2765 	      break;
申鐃緒申  2766 	    }
申鐃緒申  2767 
申鐃緒申  2768 	  /* We found a valid designation sequence for CHARSET.  */
申鐃緒申  2769 	  rejected |= CATEGORY_MASK_ISO_8BIT;
申鐃緒申  2770 	  if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7],
申鐃緒申  2771 			      id))
申鐃緒申  2772 	    found |= CATEGORY_MASK_ISO_7;
申鐃緒申  2773 	  else
申鐃緒申  2774 	    rejected |= CATEGORY_MASK_ISO_7;
申鐃緒申  2775 	  if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7_tight],
申鐃緒申  2776 			      id))
申鐃緒申  2777 	    found |= CATEGORY_MASK_ISO_7_TIGHT;
申鐃緒申  2778 	  else
申鐃緒申  2779 	    rejected |= CATEGORY_MASK_ISO_7_TIGHT;
申鐃緒申  2780 	  if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7_else],
申鐃緒申  2781 			      id))
申鐃緒申  2782 	    found |= CATEGORY_MASK_ISO_7_ELSE;
申鐃緒申  2783 	  else
申鐃緒申  2784 	    rejected |= CATEGORY_MASK_ISO_7_ELSE;
申鐃緒申  2785 	  if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_8_else],
申鐃緒申  2786 			      id))
申鐃緒申  2787 	    found |= CATEGORY_MASK_ISO_8_ELSE;
申鐃緒申  2788 	  else
申鐃緒申  2789 	    rejected |= CATEGORY_MASK_ISO_8_ELSE;
申鐃緒申  2790 	  break;
申鐃緒申  2791 
申鐃緒申  2792 	case ISO_CODE_SO:
申鐃緒申  2793 	case ISO_CODE_SI:
申鐃緒申  2794 	  /* Locking shift out/in.  */
申鐃緒申  2795 	  if (inhibit_iso_escape_detection)
申鐃緒申  2796 	    break;
申鐃緒申  2797 	  single_shifting = 0;
申鐃緒申  2798 	  rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_8BIT;
申鐃緒申  2799 	  break;
申鐃緒申  2800 
申鐃緒申  2801 	case ISO_CODE_CSI:
申鐃緒申  2802 	  /* Control sequence introducer.  */
申鐃緒申  2803 	  single_shifting = 0;
申鐃緒申  2804 	  rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
申鐃緒申  2805 	  found |= CATEGORY_MASK_ISO_8_ELSE;
申鐃緒申  2806 	  goto check_extra_latin;
申鐃緒申  2807 
申鐃緒申  2808 	case ISO_CODE_SS2:
申鐃緒申  2809 	case ISO_CODE_SS3:
申鐃緒申  2810 	  /* Single shift.   */
申鐃緒申  2811 	  if (inhibit_iso_escape_detection)
申鐃緒申  2812 	    break;
申鐃緒申  2813 	  single_shifting = 0;
申鐃緒申  2814 	  rejected |= CATEGORY_MASK_ISO_7BIT;
申鐃緒申  2815 	  if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
申鐃緒申  2816 	      & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  2817 	    found |= CATEGORY_MASK_ISO_8_1, single_shifting = 1;
申鐃緒申  2818 	  if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_2])
申鐃緒申  2819 	      & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  2820 	    found |= CATEGORY_MASK_ISO_8_2, single_shifting = 1;
申鐃緒申  2821 	  if (single_shifting)
申鐃緒申  2822 	    break;
申鐃緒申  2823 	  goto check_extra_latin;
申鐃緒申  2824 
申鐃緒申  2825 	default:
申鐃緒申  2826 	  if (c < 0)
申鐃緒申  2827 	    continue;
申鐃緒申  2828 	  if (c < 0x80)
申鐃緒申  2829 	    {
申鐃緒申  2830 	      single_shifting = 0;
申鐃緒申  2831 	      break;
申鐃緒申  2832 	    }
申鐃緒申  2833 	  if (c >= 0xA0)
申鐃緒申  2834 	    {
申鐃緒申  2835 	      rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
申鐃緒申  2836 	      found |= CATEGORY_MASK_ISO_8_1;
申鐃緒申  2837 	      /* Check the length of succeeding codes of the range
申鐃緒申  2838                  0xA0..0FF.  If the byte length is even, we include
申鐃緒申  2839                  CATEGORY_MASK_ISO_8_2 in `found'.  We can check this
申鐃緒申  2840                  only when we are not single shifting.  */
申鐃緒申  2841 	      if (! single_shifting
申鐃緒申  2842 		  && ! (rejected & CATEGORY_MASK_ISO_8_2))
申鐃緒申  2843 		{
申鐃緒申  2844 		  int i = 1;
申鐃緒申  2845 		  while (src < src_end)
申鐃緒申  2846 		    {
申鐃緒申  2847 		      ONE_MORE_BYTE (c);
申鐃緒申  2848 		      if (c < 0xA0)
申鐃緒申  2849 			break;
申鐃緒申  2850 		      i++;
申鐃緒申  2851 		    }
申鐃緒申  2852 
申鐃緒申  2853 		  if (i & 1 && src < src_end)
申鐃緒申  2854 		    rejected |= CATEGORY_MASK_ISO_8_2;
申鐃緒申  2855 		  else
申鐃緒申  2856 		    found |= CATEGORY_MASK_ISO_8_2;
申鐃緒申  2857 		}
申鐃緒申  2858 	      break;
申鐃緒申  2859 	    }
申鐃緒申  2860 	check_extra_latin:
申鐃緒申  2861 	  single_shifting = 0;
申鐃緒申  2862 	  if (! VECTORP (Vlatin_extra_code_table)
申鐃緒申  2863 	      || NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
申鐃緒申  2864 	    {
申鐃緒申  2865 	      rejected = CATEGORY_MASK_ISO;
申鐃緒申  2866 	      break;
申鐃緒申  2867 	    }
申鐃緒申  2868 	  if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
申鐃緒申  2869 	      & CODING_ISO_FLAG_LATIN_EXTRA)
申鐃緒申  2870 	    found |= CATEGORY_MASK_ISO_8_1;
申鐃緒申  2871 	  else
申鐃緒申  2872 	    rejected |= CATEGORY_MASK_ISO_8_1;
申鐃緒申  2873 	  rejected |= CATEGORY_MASK_ISO_8_2;
申鐃緒申  2874 	}
申鐃緒申  2875     }
申鐃緒申  2876   detect_info->rejected |= CATEGORY_MASK_ISO;
申鐃緒申  2877   return 0;
申鐃緒申  2878 
申鐃緒申  2879  no_more_source:
申鐃緒申  2880   detect_info->rejected |= rejected;
申鐃緒申  2881   detect_info->found |= (found & ~rejected);
申鐃緒申  2882   return 1;
申鐃緒申  2883 }
申鐃緒申  2884 
申鐃緒申  2885 
申鐃緒申  2886 /* Set designation state into CODING.  Set CHARS_96 to -1 if the
申鐃緒申  2887    escape sequence should be kept.  */
申鐃緒申  2888 #define DECODE_DESIGNATION(reg, dim, chars_96, final)			\
申鐃緒申  2889   do {									\
申鐃緒申  2890     int id, prev;							\
申鐃緒申  2891 									\
申鐃緒申  2892     if (final < '0' || final >= 128					\
申鐃緒申  2893 	|| ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0)	\
申鐃緒申  2894 	|| !SAFE_CHARSET_P (coding, id))				\
申鐃緒申  2895       {									\
申鐃緒申  2896 	CODING_ISO_DESIGNATION (coding, reg) = -2;			\
申鐃緒申  2897 	chars_96 = -1;							\
申鐃緒申  2898 	break;								\
申鐃緒申  2899       }									\
申鐃緒申  2900     prev = CODING_ISO_DESIGNATION (coding, reg);			\
申鐃緒申  2901     if (id == charset_jisx0201_roman)					\
申鐃緒申  2902       {									\
申鐃緒申  2903 	if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN)	\
申鐃緒申  2904 	  id = charset_ascii;						\
申鐃緒申  2905       }									\
申鐃緒申  2906     else if (id == charset_jisx0208_1978)				\
申鐃緒申  2907       {									\
申鐃緒申  2908 	if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS)	\
申鐃緒申  2909 	  id = charset_jisx0208;					\
申鐃緒申  2910       }									\
申鐃緒申  2911     CODING_ISO_DESIGNATION (coding, reg) = id;				\
申鐃緒申  2912     /* If there was an invalid designation to REG previously, and this	\
申鐃緒申  2913        designation is ASCII to REG, we should keep this designation	\
申鐃緒申  2914        sequence.  */							\
申鐃緒申  2915     if (prev == -2 && id == charset_ascii)				\
申鐃緒申  2916       chars_96 = -1;							\
申鐃緒申  2917   } while (0)
申鐃緒申  2918 
申鐃緒申  2919 
申鐃緒申  2920 #define MAYBE_FINISH_COMPOSITION()				\
申鐃緒申  2921   do {								\
申鐃緒申  2922     int i;							\
申鐃緒申  2923     if (composition_state == COMPOSING_NO)			\
申鐃緒申  2924       break;							\
申鐃緒申  2925     /* It is assured that we have enough room for producing	\
申鐃緒申  2926        characters stored in the table `components'.  */		\
申鐃緒申  2927     if (charbuf + component_idx > charbuf_end)			\
申鐃緒申  2928       goto no_more_source;					\
申鐃緒申  2929     composition_state = COMPOSING_NO;				\
申鐃緒申  2930     if (method == COMPOSITION_RELATIVE				\
申鐃緒申  2931 	|| method == COMPOSITION_WITH_ALTCHARS)			\
申鐃緒申  2932       {								\
申鐃緒申  2933 	for (i = 0; i < component_idx; i++)			\
申鐃緒申  2934 	  *charbuf++ = components[i];				\
申鐃緒申  2935 	char_offset += component_idx;				\
申鐃緒申  2936       }								\
申鐃緒申  2937     else							\
申鐃緒申  2938       {								\
申鐃緒申  2939 	for (i = 0; i < component_idx; i += 2)			\
申鐃緒申  2940 	  *charbuf++ = components[i];				\
申鐃緒申  2941 	char_offset += (component_idx / 2) + 1;			\
申鐃緒申  2942       }								\
申鐃緒申  2943   } while (0)
申鐃緒申  2944 
申鐃緒申  2945 
申鐃緒申  2946 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
申鐃緒申  2947    ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
申鐃緒申  2948    ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
申鐃緒申  2949    ESC 3 : altchar composition :  ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
申鐃緒申  2950    ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
申鐃緒申  2951   */
申鐃緒申  2952 
申鐃緒申  2953 #define DECODE_COMPOSITION_START(c1)					\
申鐃緒申  2954   do {									\
申鐃緒申  2955     if (c1 == '0'							\
申鐃緒申  2956 	&& composition_state == COMPOSING_COMPONENT_RULE)		\
申鐃緒申  2957       {									\
申鐃緒申  2958 	component_len = component_idx;					\
申鐃緒申  2959 	composition_state = COMPOSING_CHAR;				\
申鐃緒申  2960       }									\
申鐃緒申  2961     else								\
申鐃緒申  2962       {									\
申鐃緒申  2963 	const unsigned char *p;						\
申鐃緒申  2964 									\
申鐃緒申  2965 	MAYBE_FINISH_COMPOSITION ();					\
申鐃緒申  2966 	if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end)		\
申鐃緒申  2967 	  goto no_more_source;						\
申鐃緒申  2968 	for (p = src; p < src_end - 1; p++)				\
申鐃緒申  2969 	  if (*p == ISO_CODE_ESC && p[1] == '1')			\
申鐃緒申  2970 	    break;							\
申鐃緒申  2971 	if (p == src_end - 1)						\
申鐃緒申  2972 	  {								\
申鐃緒申  2973 	    /* The current composition doesn't end in the current	\
申鐃緒申  2974 	       source.  */						\
申鐃緒申  2975 	    record_conversion_result					\
申鐃緒申  2976 	      (coding, CODING_RESULT_INSUFFICIENT_SRC);			\
申鐃緒申  2977 	    goto no_more_source;					\
申鐃緒申  2978 	  }								\
申鐃緒申  2979 									\
申鐃緒申  2980 	/* This is surely the start of a composition.  */		\
申鐃緒申  2981 	method = (c1 == '0' ? COMPOSITION_RELATIVE			\
申鐃緒申  2982 		  : c1 == '2' ? COMPOSITION_WITH_RULE			\
申鐃緒申  2983 		  : c1 == '3' ? COMPOSITION_WITH_ALTCHARS		\
申鐃緒申  2984 		  : COMPOSITION_WITH_RULE_ALTCHARS);			\
申鐃緒申  2985 	composition_state = (c1 <= '2' ? COMPOSING_CHAR			\
申鐃緒申  2986 			     : COMPOSING_COMPONENT_CHAR);		\
申鐃緒申  2987 	component_idx = component_len = 0;				\
申鐃緒申  2988       }									\
申鐃緒申  2989   } while (0)
申鐃緒申  2990 
申鐃緒申  2991 
申鐃緒申  2992 /* Handle compositoin end sequence ESC 1.  */
申鐃緒申  2993 
申鐃緒申  2994 #define DECODE_COMPOSITION_END()					\
申鐃緒申  2995   do {									\
申鐃緒申  2996     int nchars = (component_len > 0 ? component_idx - component_len	\
申鐃緒申  2997 		  : method == COMPOSITION_RELATIVE ? component_idx	\
申鐃緒申  2998 		  : (component_idx + 1) / 2);				\
申鐃緒申  2999     int i;								\
申鐃緒申  3000     int *saved_charbuf = charbuf;					\
申鐃緒申  3001 									\
申鐃緒申  3002     ADD_COMPOSITION_DATA (charbuf, nchars, method);			\
申鐃緒申  3003     if (method != COMPOSITION_RELATIVE)					\
申鐃緒申  3004       {									\
申鐃緒申  3005 	if (component_len == 0)						\
申鐃緒申  3006 	  for (i = 0; i < component_idx; i++)				\
申鐃緒申  3007 	    *charbuf++ = components[i];					\
申鐃緒申  3008 	else								\
申鐃緒申  3009 	  for (i = 0; i < component_len; i++)				\
申鐃緒申  3010 	    *charbuf++ = components[i];					\
申鐃緒申  3011 	*saved_charbuf = saved_charbuf - charbuf;			\
申鐃緒申  3012       }									\
申鐃緒申  3013     if (method == COMPOSITION_WITH_RULE)				\
申鐃緒申  3014       for (i = 0; i < component_idx; i += 2, char_offset++)		\
申鐃緒申  3015 	*charbuf++ = components[i];					\
申鐃緒申  3016     else								\
申鐃緒申  3017       for (i = component_len; i < component_idx; i++, char_offset++)	\
申鐃緒申  3018 	*charbuf++ = components[i];					\
申鐃緒申  3019     coding->annotated = 1;						\
申鐃緒申  3020     composition_state = COMPOSING_NO;					\
申鐃緒申  3021   } while (0)
申鐃緒申  3022 
申鐃緒申  3023 
申鐃緒申  3024 /* Decode a composition rule from the byte C1 (and maybe one more byte
申鐃緒申  3025    from SRC) and store one encoded composition rule in
申鐃緒申  3026    coding->cmp_data.  */
申鐃緒申  3027 
申鐃緒申  3028 #define DECODE_COMPOSITION_RULE(c1)					\
申鐃緒申  3029   do {									\
申鐃緒申  3030     (c1) -= 32;								\
申鐃緒申  3031     if (c1 < 81)		/* old format (before ver.21) */	\
申鐃緒申  3032       {									\
申鐃緒申  3033 	int gref = (c1) / 9;						\
申鐃緒申  3034 	int nref = (c1) % 9;						\
申鐃緒申  3035 	if (gref == 4) gref = 10;					\
申鐃緒申  3036 	if (nref == 4) nref = 10;					\
申鐃緒申  3037 	c1 = COMPOSITION_ENCODE_RULE (gref, nref);			\
申鐃緒申  3038       }									\
申鐃緒申  3039     else if (c1 < 93)		/* new format (after ver.21) */		\
申鐃緒申  3040       {									\
申鐃緒申  3041 	ONE_MORE_BYTE (c2);						\
申鐃緒申  3042 	c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32);		\
申鐃緒申  3043       }									\
申鐃緒申  3044     else								\
申鐃緒申  3045       c1 = 0;								\
申鐃緒申  3046   } while (0)
申鐃緒申  3047 
申鐃緒申  3048 
申鐃緒申  3049 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
申鐃緒申  3050 
申鐃緒申  3051 static void
申鐃緒申  3052 decode_coding_iso_2022 (coding)
申鐃緒申  3053      struct coding_system *coding;
申鐃緒申  3054 {
申鐃緒申  3055   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  3056   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  3057   const unsigned char *src_base;
申鐃緒申  3058   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  3059   int *charbuf_end
申鐃緒申  3060     = coding->charbuf + coding->charbuf_size - 4 - MAX_ANNOTATION_LENGTH;
申鐃緒申  3061   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  3062   int multibytep = coding->src_multibyte;
申鐃緒申  3063   /* Charsets invoked to graphic plane 0 and 1 respectively.  */
申鐃緒申  3064   int charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3065   int charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
申鐃緒申  3066   int charset_id_2, charset_id_3;
申鐃緒申  3067   struct charset *charset;
申鐃緒申  3068   int c;
申鐃緒申  3069   /* For handling composition sequence.  */
申鐃緒申  3070 #define COMPOSING_NO			0
申鐃緒申  3071 #define COMPOSING_CHAR			1
申鐃緒申  3072 #define COMPOSING_RULE			2
申鐃緒申  3073 #define COMPOSING_COMPONENT_CHAR	3
申鐃緒申  3074 #define COMPOSING_COMPONENT_RULE	4
申鐃緒申  3075 
申鐃緒申  3076   int composition_state = COMPOSING_NO;
申鐃緒申  3077   enum composition_method method;
申鐃緒申  3078   int components[MAX_COMPOSITION_COMPONENTS * 2 + 1];
申鐃緒申  3079   int component_idx;
申鐃緒申  3080   int component_len;
申鐃緒申  3081   Lisp_Object attrs, charset_list;
申鐃緒申  3082   int char_offset = coding->produced_char;
申鐃緒申  3083   int last_offset = char_offset;
申鐃緒申  3084   int last_id = charset_ascii;
申鐃緒申  3085   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  3086   int byte_after_cr = -1;
申鐃緒申  3087 
申鐃緒申  3088   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  3089   setup_iso_safe_charsets (attrs);
申鐃緒申  3090   /* Charset list may have been changed.  */
申鐃緒申  3091   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  3092   coding->safe_charsets = (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs));
申鐃緒申  3093 
申鐃緒申  3094   while (1)
申鐃緒申  3095     {
申鐃緒申  3096       int c1, c2;
申鐃緒申  3097 
申鐃緒申  3098       src_base = src;
申鐃緒申  3099       consumed_chars_base = consumed_chars;
申鐃緒申  3100 
申鐃緒申  3101       if (charbuf >= charbuf_end)
申鐃緒申  3102 	break;
申鐃緒申  3103 
申鐃緒申  3104       if (byte_after_cr >= 0)
申鐃緒申  3105 	c1 = byte_after_cr, byte_after_cr = -1;
申鐃緒申  3106       else
申鐃緒申  3107 	ONE_MORE_BYTE (c1);
申鐃緒申  3108       if (c1 < 0)
申鐃緒申  3109 	goto invalid_code;
申鐃緒申  3110 
申鐃緒申  3111       /* We produce at most one character.  */
申鐃緒申  3112       switch (iso_code_class [c1])
申鐃緒申  3113 	{
申鐃緒申  3114 	case ISO_0x20_or_0x7F:
申鐃緒申  3115 	  if (composition_state != COMPOSING_NO)
申鐃緒申  3116 	    {
申鐃緒申  3117 	      if (composition_state == COMPOSING_RULE
申鐃緒申  3118 		  || composition_state == COMPOSING_COMPONENT_RULE)
申鐃緒申  3119 		{
申鐃緒申  3120 		  DECODE_COMPOSITION_RULE (c1);
申鐃緒申  3121 		  components[component_idx++] = c1;
申鐃緒申  3122 		  composition_state--;
申鐃緒申  3123 		  continue;
申鐃緒申  3124 		}
申鐃緒申  3125 	    }
申鐃緒申  3126 	  if (charset_id_0 < 0
申鐃緒申  3127 	      || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0)))
申鐃緒申  3128 	    /* This is SPACE or DEL.  */
申鐃緒申  3129 	    charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  3130 	  else
申鐃緒申  3131 	    charset = CHARSET_FROM_ID (charset_id_0);
申鐃緒申  3132 	  break;
申鐃緒申  3133 
申鐃緒申  3134 	case ISO_graphic_plane_0:
申鐃緒申  3135 	  if (composition_state != COMPOSING_NO)
申鐃緒申  3136 	    {
申鐃緒申  3137 	      if (composition_state == COMPOSING_RULE
申鐃緒申  3138 		  || composition_state == COMPOSING_COMPONENT_RULE)
申鐃緒申  3139 		{
申鐃緒申  3140 		  DECODE_COMPOSITION_RULE (c1);
申鐃緒申  3141 		  components[component_idx++] = c1;
申鐃緒申  3142 		  composition_state--;
申鐃緒申  3143 		  continue;
申鐃緒申  3144 		}
申鐃緒申  3145 	    }
申鐃緒申  3146 	  if (charset_id_0 < 0)
申鐃緒申  3147 	    charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  3148 	  else
申鐃緒申  3149 	    charset = CHARSET_FROM_ID (charset_id_0);
申鐃緒申  3150 	  break;
申鐃緒申  3151 
申鐃緒申  3152 	case ISO_0xA0_or_0xFF:
申鐃緒申  3153 	  if (charset_id_1 < 0
申鐃緒申  3154 	      || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1))
申鐃緒申  3155 	      || CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)
申鐃緒申  3156 	    goto invalid_code;
申鐃緒申  3157 	  /* This is a graphic character, we fall down ... */
申鐃緒申  3158 
申鐃緒申  3159 	case ISO_graphic_plane_1:
申鐃緒申  3160 	  if (charset_id_1 < 0)
申鐃緒申  3161 	    goto invalid_code;
申鐃緒申  3162 	  charset = CHARSET_FROM_ID (charset_id_1);
申鐃緒申  3163 	  break;
申鐃緒申  3164 
申鐃緒申  3165 	case ISO_control_0:
申鐃緒申  3166 	  if (eol_crlf && c1 == '\r')
申鐃緒申  3167 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  3168 	  MAYBE_FINISH_COMPOSITION ();
申鐃緒申  3169 	  charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  3170 	  break;
申鐃緒申  3171 
申鐃緒申  3172 	case ISO_control_1:
申鐃緒申  3173 	  MAYBE_FINISH_COMPOSITION ();
申鐃緒申  3174 	  goto invalid_code;
申鐃緒申  3175 
申鐃緒申  3176 	case ISO_shift_out:
申鐃緒申  3177 	  if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
申鐃緒申  3178 	      || CODING_ISO_DESIGNATION (coding, 1) < 0)
申鐃緒申  3179 	    goto invalid_code;
申鐃緒申  3180 	  CODING_ISO_INVOCATION (coding, 0) = 1;
申鐃緒申  3181 	  charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3182 	  continue;
申鐃緒申  3183 
申鐃緒申  3184 	case ISO_shift_in:
申鐃緒申  3185 	  if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT))
申鐃緒申  3186 	    goto invalid_code;
申鐃緒申  3187 	  CODING_ISO_INVOCATION (coding, 0) = 0;
申鐃緒申  3188 	  charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3189 	  continue;
申鐃緒申  3190 
申鐃緒申  3191 	case ISO_single_shift_2_7:
申鐃緒申  3192 	case ISO_single_shift_2:
申鐃緒申  3193 	  if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT))
申鐃緒申  3194 	    goto invalid_code;
申鐃緒申  3195 	  /* SS2 is handled as an escape sequence of ESC 'N' */
申鐃緒申  3196 	  c1 = 'N';
申鐃緒申  3197 	  goto label_escape_sequence;
申鐃緒申  3198 
申鐃緒申  3199 	case ISO_single_shift_3:
申鐃緒申  3200 	  if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT))
申鐃緒申  3201 	    goto invalid_code;
申鐃緒申  3202 	  /* SS2 is handled as an escape sequence of ESC 'O' */
申鐃緒申  3203 	  c1 = 'O';
申鐃緒申  3204 	  goto label_escape_sequence;
申鐃緒申  3205 
申鐃緒申  3206 	case ISO_control_sequence_introducer:
申鐃緒申  3207 	  /* CSI is handled as an escape sequence of ESC '[' ...  */
申鐃緒申  3208 	  c1 = '[';
申鐃緒申  3209 	  goto label_escape_sequence;
申鐃緒申  3210 
申鐃緒申  3211 	case ISO_escape:
申鐃緒申  3212 	  ONE_MORE_BYTE (c1);
申鐃緒申  3213 	label_escape_sequence:
申鐃緒申  3214 	  /* Escape sequences handled here are invocation,
申鐃緒申  3215 	     designation, direction specification, and character
申鐃緒申  3216 	     composition specification.  */
申鐃緒申  3217 	  switch (c1)
申鐃緒申  3218 	    {
申鐃緒申  3219 	    case '&':		/* revision of following character set */
申鐃緒申  3220 	      ONE_MORE_BYTE (c1);
申鐃緒申  3221 	      if (!(c1 >= '@' && c1 <= '~'))
申鐃緒申  3222 		goto invalid_code;
申鐃緒申  3223 	      ONE_MORE_BYTE (c1);
申鐃緒申  3224 	      if (c1 != ISO_CODE_ESC)
申鐃緒申  3225 		goto invalid_code;
申鐃緒申  3226 	      ONE_MORE_BYTE (c1);
申鐃緒申  3227 	      goto label_escape_sequence;
申鐃緒申  3228 
申鐃緒申  3229 	    case '$':		/* designation of 2-byte character set */
申鐃緒申  3230 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATION))
申鐃緒申  3231 		goto invalid_code;
申鐃緒申  3232 	      {
申鐃緒申  3233 		int reg, chars96;
申鐃緒申  3234 
申鐃緒申  3235 		ONE_MORE_BYTE (c1);
申鐃緒申  3236 		if (c1 >= '@' && c1 <= 'B')
申鐃緒申  3237 		  {	/* designation of JISX0208.1978, GB2312.1980,
申鐃緒申  3238 			   or JISX0208.1980 */
申鐃緒申  3239 		    reg = 0, chars96 = 0;
申鐃緒申  3240 		  }
申鐃緒申  3241 		else if (c1 >= 0x28 && c1 <= 0x2B)
申鐃緒申  3242 		  { /* designation of DIMENSION2_CHARS94 character set */
申鐃緒申  3243 		    reg = c1 - 0x28, chars96 = 0;
申鐃緒申  3244 		    ONE_MORE_BYTE (c1);
申鐃緒申  3245 		  }
申鐃緒申  3246 		else if (c1 >= 0x2C && c1 <= 0x2F)
申鐃緒申  3247 		  { /* designation of DIMENSION2_CHARS96 character set */
申鐃緒申  3248 		    reg = c1 - 0x2C, chars96 = 1;
申鐃緒申  3249 		    ONE_MORE_BYTE (c1);
申鐃緒申  3250 		  }
申鐃緒申  3251 		else
申鐃緒申  3252 		  goto invalid_code;
申鐃緒申  3253 		DECODE_DESIGNATION (reg, 2, chars96, c1);
申鐃緒申  3254 		/* We must update these variables now.  */
申鐃緒申  3255 		if (reg == 0)
申鐃緒申  3256 		  charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3257 		else if (reg == 1)
申鐃緒申  3258 		  charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
申鐃緒申  3259 		if (chars96 < 0)
申鐃緒申  3260 		  goto invalid_code;
申鐃緒申  3261 	      }
申鐃緒申  3262 	      continue;
申鐃緒申  3263 
申鐃緒申  3264 	    case 'n':		/* invocation of locking-shift-2 */
申鐃緒申  3265 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
申鐃緒申  3266 		  || CODING_ISO_DESIGNATION (coding, 2) < 0)
申鐃緒申  3267 		goto invalid_code;
申鐃緒申  3268 	      CODING_ISO_INVOCATION (coding, 0) = 2;
申鐃緒申  3269 	      charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3270 	      continue;
申鐃緒申  3271 
申鐃緒申  3272 	    case 'o':		/* invocation of locking-shift-3 */
申鐃緒申  3273 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
申鐃緒申  3274 		  || CODING_ISO_DESIGNATION (coding, 3) < 0)
申鐃緒申  3275 		goto invalid_code;
申鐃緒申  3276 	      CODING_ISO_INVOCATION (coding, 0) = 3;
申鐃緒申  3277 	      charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3278 	      continue;
申鐃緒申  3279 
申鐃緒申  3280 	    case 'N':		/* invocation of single-shift-2 */
申鐃緒申  3281 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  3282 		  || CODING_ISO_DESIGNATION (coding, 2) < 0)
申鐃緒申  3283 		goto invalid_code;
申鐃緒申  3284 	      charset_id_2 = CODING_ISO_DESIGNATION (coding, 2);
申鐃緒申  3285 	      if (charset_id_2 < 0)
申鐃緒申  3286 		charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  3287 	      else
申鐃緒申  3288 		charset = CHARSET_FROM_ID (charset_id_2);
申鐃緒申  3289 	      ONE_MORE_BYTE (c1);
申鐃緒申  3290 	      if (c1 < 0x20 || (c1 >= 0x80 && c1 < 0xA0))
申鐃緒申  3291 		goto invalid_code;
申鐃緒申  3292 	      break;
申鐃緒申  3293 
申鐃緒申  3294 	    case 'O':		/* invocation of single-shift-3 */
申鐃緒申  3295 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  3296 		  || CODING_ISO_DESIGNATION (coding, 3) < 0)
申鐃緒申  3297 		goto invalid_code;
申鐃緒申  3298 	      charset_id_3 = CODING_ISO_DESIGNATION (coding, 3);
申鐃緒申  3299 	      if (charset_id_3 < 0)
申鐃緒申  3300 		charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  3301 	      else
申鐃緒申  3302 		charset = CHARSET_FROM_ID (charset_id_3);
申鐃緒申  3303 	      ONE_MORE_BYTE (c1);
申鐃緒申  3304 	      if (c1 < 0x20 || (c1 >= 0x80 && c1 < 0xA0))
申鐃緒申  3305 		goto invalid_code;
申鐃緒申  3306 	      break;
申鐃緒申  3307 
申鐃緒申  3308 	    case '0': case '2':	case '3': case '4': /* start composition */
申鐃緒申  3309 	      if (! (coding->common_flags & CODING_ANNOTATE_COMPOSITION_MASK))
申鐃緒申  3310 		goto invalid_code;
申鐃緒申  3311 	      DECODE_COMPOSITION_START (c1);
申鐃緒申  3312 	      continue;
申鐃緒申  3313 
申鐃緒申  3314 	    case '1':		/* end composition */
申鐃緒申  3315 	      if (composition_state == COMPOSING_NO)
申鐃緒申  3316 		goto invalid_code;
申鐃緒申  3317 	      DECODE_COMPOSITION_END ();
申鐃緒申  3318 	      continue;
申鐃緒申  3319 
申鐃緒申  3320 	    case '[':		/* specification of direction */
申鐃緒申  3321 	      if (! CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DIRECTION)
申鐃緒申  3322 		goto invalid_code;
申鐃緒申  3323 	      /* For the moment, nested direction is not supported.
申鐃緒申  3324 		 So, `coding->mode & CODING_MODE_DIRECTION' zero means
申鐃緒申  3325 		 left-to-right, and nozero means right-to-left.  */
申鐃緒申  3326 	      ONE_MORE_BYTE (c1);
申鐃緒申  3327 	      switch (c1)
申鐃緒申  3328 		{
申鐃緒申  3329 		case ']':	/* end of the current direction */
申鐃緒申  3330 		  coding->mode &= ~CODING_MODE_DIRECTION;
申鐃緒申  3331 
申鐃緒申  3332 		case '0':	/* end of the current direction */
申鐃緒申  3333 		case '1':	/* start of left-to-right direction */
申鐃緒申  3334 		  ONE_MORE_BYTE (c1);
申鐃緒申  3335 		  if (c1 == ']')
申鐃緒申  3336 		    coding->mode &= ~CODING_MODE_DIRECTION;
申鐃緒申  3337 		  else
申鐃緒申  3338 		    goto invalid_code;
申鐃緒申  3339 		  break;
申鐃緒申  3340 
申鐃緒申  3341 		case '2':	/* start of right-to-left direction */
申鐃緒申  3342 		  ONE_MORE_BYTE (c1);
申鐃緒申  3343 		  if (c1 == ']')
申鐃緒申  3344 		    coding->mode |= CODING_MODE_DIRECTION;
申鐃緒申  3345 		  else
申鐃緒申  3346 		    goto invalid_code;
申鐃緒申  3347 		  break;
申鐃緒申  3348 
申鐃緒申  3349 		default:
申鐃緒申  3350 		  goto invalid_code;
申鐃緒申  3351 		}
申鐃緒申  3352 	      continue;
申鐃緒申  3353 
申鐃緒申  3354 	    case '%':
申鐃緒申  3355 	      ONE_MORE_BYTE (c1);
申鐃緒申  3356 	      if (c1 == '/')
申鐃緒申  3357 		{
申鐃緒申  3358 		  /* CTEXT extended segment:
申鐃緒申  3359 		     ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
申鐃緒申  3360 		     We keep these bytes as is for the moment.
申鐃緒申  3361 		     They may be decoded by post-read-conversion.  */
申鐃緒申  3362 		  int dim, M, L;
申鐃緒申  3363 		  int size;
申鐃緒申  3364 
申鐃緒申  3365 		  ONE_MORE_BYTE (dim);
申鐃緒申  3366 		  ONE_MORE_BYTE (M);
申鐃緒申  3367 		  ONE_MORE_BYTE (L);
申鐃緒申  3368 		  size = ((M - 128) * 128) + (L - 128);
申鐃緒申  3369 		  if (charbuf + 8 + size > charbuf_end)
申鐃緒申  3370 		    goto break_loop;
申鐃緒申  3371 		  *charbuf++ = ISO_CODE_ESC;
申鐃緒申  3372 		  *charbuf++ = '%';
申鐃緒申  3373 		  *charbuf++ = '/';
申鐃緒申  3374 		  *charbuf++ = dim;
申鐃緒申  3375 		  *charbuf++ = BYTE8_TO_CHAR (M);
申鐃緒申  3376 		  *charbuf++ = BYTE8_TO_CHAR (L);
申鐃緒申  3377 		  while (size-- > 0)
申鐃緒申  3378 		    {
申鐃緒申  3379 		      ONE_MORE_BYTE (c1);
申鐃緒申  3380 		      *charbuf++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
申鐃緒申  3381 		    }
申鐃緒申  3382 		}
申鐃緒申  3383 	      else if (c1 == 'G')
申鐃緒申  3384 		{
申鐃緒申  3385 		  /* XFree86 extension for embedding UTF-8 in CTEXT:
申鐃緒申  3386 		     ESC % G --UTF-8-BYTES-- ESC % @
申鐃緒申  3387 		     We keep these bytes as is for the moment.
申鐃緒申  3388 		     They may be decoded by post-read-conversion.  */
申鐃緒申  3389 		  int *p = charbuf;
申鐃緒申  3390 
申鐃緒申  3391 		  if (p + 6 > charbuf_end)
申鐃緒申  3392 		    goto break_loop;
申鐃緒申  3393 		  *p++ = ISO_CODE_ESC;
申鐃緒申  3394 		  *p++ = '%';
申鐃緒申  3395 		  *p++ = 'G';
申鐃緒申  3396 		  while (p < charbuf_end)
申鐃緒申  3397 		    {
申鐃緒申  3398 		      ONE_MORE_BYTE (c1);
申鐃緒申  3399 		      if (c1 == ISO_CODE_ESC
申鐃緒申  3400 			  && src + 1 < src_end
申鐃緒申  3401 			  && src[0] == '%'
申鐃緒申  3402 			  && src[1] == '@')
申鐃緒申  3403 			{
申鐃緒申  3404 			  src += 2;
申鐃緒申  3405 			  break;
申鐃緒申  3406 			}
申鐃緒申  3407 		      *p++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
申鐃緒申  3408 		    }
申鐃緒申  3409 		  if (p + 3 > charbuf_end)
申鐃緒申  3410 		    goto break_loop;
申鐃緒申  3411 		  *p++ = ISO_CODE_ESC;
申鐃緒申  3412 		  *p++ = '%';
申鐃緒申  3413 		  *p++ = '@';
申鐃緒申  3414 		  charbuf = p;
申鐃緒申  3415 		}
申鐃緒申  3416 	      else
申鐃緒申  3417 		goto invalid_code;
申鐃緒申  3418 	      continue;
申鐃緒申  3419 	      break;
申鐃緒申  3420 
申鐃緒申  3421 	    default:
申鐃緒申  3422 	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATION))
申鐃緒申  3423 		goto invalid_code;
申鐃緒申  3424 	      {
申鐃緒申  3425 		int reg, chars96;
申鐃緒申  3426 
申鐃緒申  3427 		if (c1 >= 0x28 && c1 <= 0x2B)
申鐃緒申  3428 		  { /* designation of DIMENSION1_CHARS94 character set */
申鐃緒申  3429 		    reg = c1 - 0x28, chars96 = 0;
申鐃緒申  3430 		    ONE_MORE_BYTE (c1);
申鐃緒申  3431 		  }
申鐃緒申  3432 		else if (c1 >= 0x2C && c1 <= 0x2F)
申鐃緒申  3433 		  { /* designation of DIMENSION1_CHARS96 character set */
申鐃緒申  3434 		    reg = c1 - 0x2C, chars96 = 1;
申鐃緒申  3435 		    ONE_MORE_BYTE (c1);
申鐃緒申  3436 		  }
申鐃緒申  3437 		else
申鐃緒申  3438 		  goto invalid_code;
申鐃緒申  3439 		DECODE_DESIGNATION (reg, 1, chars96, c1);
申鐃緒申  3440 		/* We must update these variables now.  */
申鐃緒申  3441 		if (reg == 0)
申鐃緒申  3442 		  charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
申鐃緒申  3443 		else if (reg == 1)
申鐃緒申  3444 		  charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
申鐃緒申  3445 		if (chars96 < 0)
申鐃緒申  3446 		  goto invalid_code;
申鐃緒申  3447 	      }
申鐃緒申  3448 	      continue;
申鐃緒申  3449 	    }
申鐃緒申  3450 	}
申鐃緒申  3451 
申鐃緒申  3452       if (charset->id != charset_ascii
申鐃緒申  3453 	  && last_id != charset->id)
申鐃緒申  3454 	{
申鐃緒申  3455 	  if (last_id != charset_ascii)
申鐃緒申  3456 	    ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  3457 	  last_id = charset->id;
申鐃緒申  3458 	  last_offset = char_offset;
申鐃緒申  3459 	}
申鐃緒申  3460 
申鐃緒申  3461       /* Now we know CHARSET and 1st position code C1 of a character.
申鐃緒申  3462          Produce a decoded character while getting 2nd position code
申鐃緒申  3463          C2 if necessary.  */
申鐃緒申  3464       c1 &= 0x7F;
申鐃緒申  3465       if (CHARSET_DIMENSION (charset) > 1)
申鐃緒申  3466 	{
申鐃緒申  3467 	  ONE_MORE_BYTE (c2);
申鐃緒申  3468 	  if (c2 < 0x20 || (c2 >= 0x80 && c2 < 0xA0))
申鐃緒申  3469 	    /* C2 is not in a valid range.  */
申鐃緒申  3470 	    goto invalid_code;
申鐃緒申  3471 	  c1 = (c1 << 8) | (c2 & 0x7F);
申鐃緒申  3472 	  if (CHARSET_DIMENSION (charset) > 2)
申鐃緒申  3473 	    {
申鐃緒申  3474 	      ONE_MORE_BYTE (c2);
申鐃緒申  3475 	      if (c2 < 0x20 || (c2 >= 0x80 && c2 < 0xA0))
申鐃緒申  3476 		/* C2 is not in a valid range.  */
申鐃緒申  3477 		goto invalid_code;
申鐃緒申  3478 	      c1 = (c1 << 8) | (c2 & 0x7F);
申鐃緒申  3479 	    }
申鐃緒申  3480 	}
申鐃緒申  3481 
申鐃緒申  3482       CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c1, c);
申鐃緒申  3483       if (c < 0)
申鐃緒申  3484 	{
申鐃緒申  3485 	  MAYBE_FINISH_COMPOSITION ();
申鐃緒申  3486 	  for (; src_base < src; src_base++, char_offset++)
申鐃緒申  3487 	    {
申鐃緒申  3488 	      if (ASCII_BYTE_P (*src_base))
申鐃緒申  3489 		*charbuf++ = *src_base;
申鐃緒申  3490 	      else
申鐃緒申  3491 		*charbuf++ = BYTE8_TO_CHAR (*src_base);
申鐃緒申  3492 	    }
申鐃緒申  3493 	}
申鐃緒申  3494       else if (composition_state == COMPOSING_NO)
申鐃緒申  3495 	{
申鐃緒申  3496 	  *charbuf++ = c;
申鐃緒申  3497 	  char_offset++;
申鐃緒申  3498 	}
申鐃緒申  3499       else
申鐃緒申  3500 	{
申鐃緒申  3501 	  components[component_idx++] = c;
申鐃緒申  3502 	  if (method == COMPOSITION_WITH_RULE
申鐃緒申  3503 	      || (method == COMPOSITION_WITH_RULE_ALTCHARS
申鐃緒申  3504 		  && composition_state == COMPOSING_COMPONENT_CHAR))
申鐃緒申  3505 	    composition_state++;
申鐃緒申  3506 	}
申鐃緒申  3507       continue;
申鐃緒申  3508 
申鐃緒申  3509     invalid_code:
申鐃緒申  3510       MAYBE_FINISH_COMPOSITION ();
申鐃緒申  3511       src = src_base;
申鐃緒申  3512       consumed_chars = consumed_chars_base;
申鐃緒申  3513       ONE_MORE_BYTE (c);
申鐃緒申  3514       *charbuf++ = c < 0 ? -c : ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
申鐃緒申  3515       char_offset++;
申鐃緒申  3516       coding->errors++;
申鐃緒申  3517       continue;
申鐃緒申  3518 
申鐃緒申  3519     break_loop:
申鐃緒申  3520       break;
申鐃緒申  3521     }
申鐃緒申  3522 
申鐃緒申  3523  no_more_source:
申鐃緒申  3524   if (last_id != charset_ascii)
申鐃緒申  3525     ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  3526   coding->consumed_char += consumed_chars_base;
申鐃緒申  3527   coding->consumed = src_base - coding->source;
申鐃緒申  3528   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  3529 }
申鐃緒申  3530 
申鐃緒申  3531 
申鐃緒申  3532 /* ISO2022 encoding stuff.  */
申鐃緒申  3533 
申鐃緒申  3534 /*
申鐃緒申  3535    It is not enough to say just "ISO2022" on encoding, we have to
申鐃緒申  3536    specify more details.  In Emacs, each coding system of ISO2022
申鐃緒申  3537    variant has the following specifications:
申鐃緒申  3538 	1. Initial designation to G0 thru G3.
申鐃緒申  3539 	2. Allows short-form designation?
申鐃緒申  3540 	3. ASCII should be designated to G0 before control characters?
申鐃緒申  3541 	4. ASCII should be designated to G0 at end of line?
申鐃緒申  3542 	5. 7-bit environment or 8-bit environment?
申鐃緒申  3543 	6. Use locking-shift?
申鐃緒申  3544 	7. Use Single-shift?
申鐃緒申  3545    And the following two are only for Japanese:
申鐃緒申  3546 	8. Use ASCII in place of JIS0201-1976-Roman?
申鐃緒申  3547 	9. Use JISX0208-1983 in place of JISX0208-1978?
申鐃緒申  3548    These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
申鐃緒申  3549    defined by macros CODING_ISO_FLAG_XXX.  See `coding.h' for more
申鐃緒申  3550    details.
申鐃緒申  3551 */
申鐃緒申  3552 
申鐃緒申  3553 /* Produce codes (escape sequence) for designating CHARSET to graphic
申鐃緒申  3554    register REG at DST, and increment DST.  If <final-char> of CHARSET is
申鐃緒申  3555    '@', 'A', or 'B' and the coding system CODING allows, produce
申鐃緒申  3556    designation sequence of short-form.  */
申鐃緒申  3557 
申鐃緒申  3558 #define ENCODE_DESIGNATION(charset, reg, coding)			\
申鐃緒申  3559   do {									\
申鐃緒申  3560     unsigned char final_char = CHARSET_ISO_FINAL (charset);		\
申鐃緒申  3561     char *intermediate_char_94 = "()*+";				\
申鐃緒申  3562     char *intermediate_char_96 = ",-./";				\
申鐃緒申  3563     int revision = -1;							\
申鐃緒申  3564     int c;								\
申鐃緒申  3565 									\
申鐃緒申  3566     if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION)		\
申鐃緒申  3567       revision = CHARSET_ISO_REVISION (charset);			\
申鐃緒申  3568 									\
申鐃緒申  3569     if (revision >= 0)							\
申鐃緒申  3570       {									\
申鐃緒申  3571 	EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&');			\
申鐃緒申  3572 	EMIT_ONE_BYTE ('@' + revision);					\
申鐃緒申  3573       }									\
申鐃緒申  3574     EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC);					\
申鐃緒申  3575     if (CHARSET_DIMENSION (charset) == 1)				\
申鐃緒申  3576       {									\
申鐃緒申  3577 	if (! CHARSET_ISO_CHARS_96 (charset))				\
申鐃緒申  3578 	  c = intermediate_char_94[reg];				\
申鐃緒申  3579 	else								\
申鐃緒申  3580 	  c = intermediate_char_96[reg];				\
申鐃緒申  3581 	EMIT_ONE_ASCII_BYTE (c);					\
申鐃緒申  3582       }									\
申鐃緒申  3583     else								\
申鐃緒申  3584       {									\
申鐃緒申  3585 	EMIT_ONE_ASCII_BYTE ('$');					\
申鐃緒申  3586 	if (! CHARSET_ISO_CHARS_96 (charset))				\
申鐃緒申  3587 	  {								\
申鐃緒申  3588 	    if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM	\
申鐃緒申  3589 		|| reg != 0						\
申鐃緒申  3590 		|| final_char < '@' || final_char > 'B')		\
申鐃緒申  3591 	      EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]);		\
申鐃緒申  3592 	  }								\
申鐃緒申  3593 	else								\
申鐃緒申  3594 	  EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]);		\
申鐃緒申  3595       }									\
申鐃緒申  3596     EMIT_ONE_ASCII_BYTE (final_char);					\
申鐃緒申  3597 									\
申鐃緒申  3598     CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset);	\
申鐃緒申  3599   } while (0)
申鐃緒申  3600 
申鐃緒申  3601 
申鐃緒申  3602 /* The following two macros produce codes (control character or escape
申鐃緒申  3603    sequence) for ISO2022 single-shift functions (single-shift-2 and
申鐃緒申  3604    single-shift-3).  */
申鐃緒申  3605 
申鐃緒申  3606 #define ENCODE_SINGLE_SHIFT_2						\
申鐃緒申  3607   do {									\
申鐃緒申  3608     if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)		\
申鐃緒申  3609       EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N');				\
申鐃緒申  3610     else								\
申鐃緒申  3611       EMIT_ONE_BYTE (ISO_CODE_SS2);					\
申鐃緒申  3612     CODING_ISO_SINGLE_SHIFTING (coding) = 1;				\
申鐃緒申  3613   } while (0)
申鐃緒申  3614 
申鐃緒申  3615 
申鐃緒申  3616 #define ENCODE_SINGLE_SHIFT_3						\
申鐃緒申  3617   do {									\
申鐃緒申  3618     if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)		\
申鐃緒申  3619       EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O');				\
申鐃緒申  3620     else								\
申鐃緒申  3621       EMIT_ONE_BYTE (ISO_CODE_SS3);					\
申鐃緒申  3622     CODING_ISO_SINGLE_SHIFTING (coding) = 1;				\
申鐃緒申  3623   } while (0)
申鐃緒申  3624 
申鐃緒申  3625 
申鐃緒申  3626 /* The following four macros produce codes (control character or
申鐃緒申  3627    escape sequence) for ISO2022 locking-shift functions (shift-in,
申鐃緒申  3628    shift-out, locking-shift-2, and locking-shift-3).  */
申鐃緒申  3629 
申鐃緒申  3630 #define ENCODE_SHIFT_IN					\
申鐃緒申  3631   do {							\
申鐃緒申  3632     EMIT_ONE_ASCII_BYTE (ISO_CODE_SI);			\
申鐃緒申  3633     CODING_ISO_INVOCATION (coding, 0) = 0;		\
申鐃緒申  3634   } while (0)
申鐃緒申  3635 
申鐃緒申  3636 
申鐃緒申  3637 #define ENCODE_SHIFT_OUT				\
申鐃緒申  3638   do {							\
申鐃緒申  3639     EMIT_ONE_ASCII_BYTE (ISO_CODE_SO);			\
申鐃緒申  3640     CODING_ISO_INVOCATION (coding, 0) = 1;		\
申鐃緒申  3641   } while (0)
申鐃緒申  3642 
申鐃緒申  3643 
申鐃緒申  3644 #define ENCODE_LOCKING_SHIFT_2				\
申鐃緒申  3645   do {							\
申鐃緒申  3646     EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n');		\
申鐃緒申  3647     CODING_ISO_INVOCATION (coding, 0) = 2;		\
申鐃緒申  3648   } while (0)
申鐃緒申  3649 
申鐃緒申  3650 
申鐃緒申  3651 #define ENCODE_LOCKING_SHIFT_3				\
申鐃緒申  3652   do {							\
申鐃緒申  3653     EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n');		\
申鐃緒申  3654     CODING_ISO_INVOCATION (coding, 0) = 3;		\
申鐃緒申  3655   } while (0)
申鐃緒申  3656 
申鐃緒申  3657 
申鐃緒申  3658 /* Produce codes for a DIMENSION1 character whose character set is
申鐃緒申  3659    CHARSET and whose position-code is C1.  Designation and invocation
申鐃緒申  3660    sequences are also produced in advance if necessary.  */
申鐃緒申  3661 
申鐃緒申  3662 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1)			\
申鐃緒申  3663   do {									\
申鐃緒申  3664     int id = CHARSET_ID (charset);					\
申鐃緒申  3665 									\
申鐃緒申  3666     if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN)		\
申鐃緒申  3667 	&& id == charset_ascii)						\
申鐃緒申  3668       {									\
申鐃緒申  3669 	id = charset_jisx0201_roman;					\
申鐃緒申  3670 	charset = CHARSET_FROM_ID (id);					\
申鐃緒申  3671       }									\
申鐃緒申  3672 									\
申鐃緒申  3673     if (CODING_ISO_SINGLE_SHIFTING (coding))				\
申鐃緒申  3674       {									\
申鐃緒申  3675 	if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)	\
申鐃緒申  3676 	  EMIT_ONE_ASCII_BYTE (c1 & 0x7F);				\
申鐃緒申  3677 	else								\
申鐃緒申  3678 	  EMIT_ONE_BYTE (c1 | 0x80);					\
申鐃緒申  3679 	CODING_ISO_SINGLE_SHIFTING (coding) = 0;			\
申鐃緒申  3680 	break;								\
申鐃緒申  3681       }									\
申鐃緒申  3682     else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0))		\
申鐃緒申  3683       {									\
申鐃緒申  3684 	EMIT_ONE_ASCII_BYTE (c1 & 0x7F);				\
申鐃緒申  3685 	break;								\
申鐃緒申  3686       }									\
申鐃緒申  3687     else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1))		\
申鐃緒申  3688       {									\
申鐃緒申  3689 	EMIT_ONE_BYTE (c1 | 0x80);					\
申鐃緒申  3690 	break;								\
申鐃緒申  3691       }									\
申鐃緒申  3692     else								\
申鐃緒申  3693       /* Since CHARSET is not yet invoked to any graphic planes, we	\
申鐃緒申  3694 	 must invoke it, or, at first, designate it to some graphic	\
申鐃緒申  3695 	 register.  Then repeat the loop to actually produce the	\
申鐃緒申  3696 	 character.  */							\
申鐃緒申  3697       dst = encode_invocation_designation (charset, coding, dst,	\
申鐃緒申  3698 					   &produced_chars);		\
申鐃緒申  3699   } while (1)
申鐃緒申  3700 
申鐃緒申  3701 
申鐃緒申  3702 /* Produce codes for a DIMENSION2 character whose character set is
申鐃緒申  3703    CHARSET and whose position-codes are C1 and C2.  Designation and
申鐃緒申  3704    invocation codes are also produced in advance if necessary.  */
申鐃緒申  3705 
申鐃緒申  3706 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2)		\
申鐃緒申  3707   do {									\
申鐃緒申  3708     int id = CHARSET_ID (charset);					\
申鐃緒申  3709 									\
申鐃緒申  3710     if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS)	\
申鐃緒申  3711 	&& id == charset_jisx0208)					\
申鐃緒申  3712       {									\
申鐃緒申  3713 	id = charset_jisx0208_1978;					\
申鐃緒申  3714 	charset = CHARSET_FROM_ID (id);					\
申鐃緒申  3715       }									\
申鐃緒申  3716 									\
申鐃緒申  3717     if (CODING_ISO_SINGLE_SHIFTING (coding))				\
申鐃緒申  3718       {									\
申鐃緒申  3719 	if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)	\
申鐃緒申  3720 	  EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F);		\
申鐃緒申  3721 	else								\
申鐃緒申  3722 	  EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80);			\
申鐃緒申  3723 	CODING_ISO_SINGLE_SHIFTING (coding) = 0;			\
申鐃緒申  3724 	break;								\
申鐃緒申  3725       }									\
申鐃緒申  3726     else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0))		\
申鐃緒申  3727       {									\
申鐃緒申  3728 	EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F);		\
申鐃緒申  3729 	break;								\
申鐃緒申  3730       }									\
申鐃緒申  3731     else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1))		\
申鐃緒申  3732       {									\
申鐃緒申  3733 	EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80);			\
申鐃緒申  3734 	break;								\
申鐃緒申  3735       }									\
申鐃緒申  3736     else								\
申鐃緒申  3737       /* Since CHARSET is not yet invoked to any graphic planes, we	\
申鐃緒申  3738 	 must invoke it, or, at first, designate it to some graphic	\
申鐃緒申  3739 	 register.  Then repeat the loop to actually produce the	\
申鐃緒申  3740 	 character.  */							\
申鐃緒申  3741       dst = encode_invocation_designation (charset, coding, dst,	\
申鐃緒申  3742 					   &produced_chars);		\
申鐃緒申  3743   } while (1)
申鐃緒申  3744 
申鐃緒申  3745 
申鐃緒申  3746 #define ENCODE_ISO_CHARACTER(charset, c)				   \
申鐃緒申  3747   do {									   \
申鐃緒申  3748     int code = ENCODE_CHAR ((charset),(c));				   \
申鐃緒申  3749 									   \
申鐃緒申  3750     if (CHARSET_DIMENSION (charset) == 1)				   \
申鐃緒申  3751       ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code);		   \
申鐃緒申  3752     else								   \
申鐃緒申  3753       ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
申鐃緒申  3754   } while (0)
申鐃緒申  3755 
申鐃緒申  3756 
申鐃緒申  3757 /* Produce designation and invocation codes at a place pointed by DST
申鐃緒申  3758    to use CHARSET.  The element `spec.iso_2022' of *CODING is updated.
申鐃緒申  3759    Return new DST.  */
申鐃緒申  3760 
申鐃緒申  3761 unsigned char *
申鐃緒申  3762 encode_invocation_designation (charset, coding, dst, p_nchars)
申鐃緒申  3763      struct charset *charset;
申鐃緒申  3764      struct coding_system *coding;
申鐃緒申  3765      unsigned char *dst;
申鐃緒申  3766      int *p_nchars;
申鐃緒申  3767 {
申鐃緒申  3768   int multibytep = coding->dst_multibyte;
申鐃緒申  3769   int produced_chars = *p_nchars;
申鐃緒申  3770   int reg;			/* graphic register number */
申鐃緒申  3771   int id = CHARSET_ID (charset);
申鐃緒申  3772 
申鐃緒申  3773   /* At first, check designations.  */
申鐃緒申  3774   for (reg = 0; reg < 4; reg++)
申鐃緒申  3775     if (id == CODING_ISO_DESIGNATION (coding, reg))
申鐃緒申  3776       break;
申鐃緒申  3777 
申鐃緒申  3778   if (reg >= 4)
申鐃緒申  3779     {
申鐃緒申  3780       /* CHARSET is not yet designated to any graphic registers.  */
申鐃緒申  3781       /* At first check the requested designation.  */
申鐃緒申  3782       reg = CODING_ISO_REQUEST (coding, id);
申鐃緒申  3783       if (reg < 0)
申鐃緒申  3784 	/* Since CHARSET requests no special designation, designate it
申鐃緒申  3785 	   to graphic register 0.  */
申鐃緒申  3786 	reg = 0;
申鐃緒申  3787 
申鐃緒申  3788       ENCODE_DESIGNATION (charset, reg, coding);
申鐃緒申  3789     }
申鐃緒申  3790 
申鐃緒申  3791   if (CODING_ISO_INVOCATION (coding, 0) != reg
申鐃緒申  3792       && CODING_ISO_INVOCATION (coding, 1) != reg)
申鐃緒申  3793     {
申鐃緒申  3794       /* Since the graphic register REG is not invoked to any graphic
申鐃緒申  3795 	 planes, invoke it to graphic plane 0.  */
申鐃緒申  3796       switch (reg)
申鐃緒申  3797 	{
申鐃緒申  3798 	case 0:			/* graphic register 0 */
申鐃緒申  3799 	  ENCODE_SHIFT_IN;
申鐃緒申  3800 	  break;
申鐃緒申  3801 
申鐃緒申  3802 	case 1:			/* graphic register 1 */
申鐃緒申  3803 	  ENCODE_SHIFT_OUT;
申鐃緒申  3804 	  break;
申鐃緒申  3805 
申鐃緒申  3806 	case 2:			/* graphic register 2 */
申鐃緒申  3807 	  if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  3808 	    ENCODE_SINGLE_SHIFT_2;
申鐃緒申  3809 	  else
申鐃緒申  3810 	    ENCODE_LOCKING_SHIFT_2;
申鐃緒申  3811 	  break;
申鐃緒申  3812 
申鐃緒申  3813 	case 3:			/* graphic register 3 */
申鐃緒申  3814 	  if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
申鐃緒申  3815 	    ENCODE_SINGLE_SHIFT_3;
申鐃緒申  3816 	  else
申鐃緒申  3817 	    ENCODE_LOCKING_SHIFT_3;
申鐃緒申  3818 	  break;
申鐃緒申  3819 	}
申鐃緒申  3820     }
申鐃緒申  3821 
申鐃緒申  3822   *p_nchars = produced_chars;
申鐃緒申  3823   return dst;
申鐃緒申  3824 }
申鐃緒申  3825 
申鐃緒申  3826 /* The following three macros produce codes for indicating direction
申鐃緒申  3827    of text.  */
申鐃緒申  3828 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER				\
申鐃緒申  3829   do {									\
申鐃緒申  3830     if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS)	\
申鐃緒申  3831       EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '[');				\
申鐃緒申  3832     else								\
申鐃緒申  3833       EMIT_ONE_BYTE (ISO_CODE_CSI);					\
申鐃緒申  3834   } while (0)
申鐃緒申  3835 
申鐃緒申  3836 
申鐃緒申  3837 #define ENCODE_DIRECTION_R2L()			\
申鐃緒申  3838   do {						\
申鐃緒申  3839     ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst);	\
申鐃緒申  3840     EMIT_TWO_ASCII_BYTES ('2', ']');		\
申鐃緒申  3841   } while (0)
申鐃緒申  3842 
申鐃緒申  3843 
申鐃緒申  3844 #define ENCODE_DIRECTION_L2R()			\
申鐃緒申  3845   do {						\
申鐃緒申  3846     ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst);	\
申鐃緒申  3847     EMIT_TWO_ASCII_BYTES ('0', ']');		\
申鐃緒申  3848   } while (0)
申鐃緒申  3849 
申鐃緒申  3850 
申鐃緒申  3851 /* Produce codes for designation and invocation to reset the graphic
申鐃緒申  3852    planes and registers to initial state.  */
申鐃緒申  3853 #define ENCODE_RESET_PLANE_AND_REGISTER()				\
申鐃緒申  3854   do {									\
申鐃緒申  3855     int reg;								\
申鐃緒申  3856     struct charset *charset;						\
申鐃緒申  3857 									\
申鐃緒申  3858     if (CODING_ISO_INVOCATION (coding, 0) != 0)				\
申鐃緒申  3859       ENCODE_SHIFT_IN;							\
申鐃緒申  3860     for (reg = 0; reg < 4; reg++)					\
申鐃緒申  3861       if (CODING_ISO_INITIAL (coding, reg) >= 0				\
申鐃緒申  3862 	  && (CODING_ISO_DESIGNATION (coding, reg)			\
申鐃緒申  3863 	      != CODING_ISO_INITIAL (coding, reg)))			\
申鐃緒申  3864 	{								\
申鐃緒申  3865 	  charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg));	\
申鐃緒申  3866 	  ENCODE_DESIGNATION (charset, reg, coding);			\
申鐃緒申  3867 	}								\
申鐃緒申  3868   } while (0)
申鐃緒申  3869 
申鐃緒申  3870 
申鐃緒申  3871 /* Produce designation sequences of charsets in the line started from
申鐃緒申  3872    SRC to a place pointed by DST, and return updated DST.
申鐃緒申  3873 
申鐃緒申  3874    If the current block ends before any end-of-line, we may fail to
申鐃緒申  3875    find all the necessary designations.  */
申鐃緒申  3876 
申鐃緒申  3877 static unsigned char *
申鐃緒申  3878 encode_designation_at_bol (coding, charbuf, charbuf_end, dst)
申鐃緒申  3879      struct coding_system *coding;
申鐃緒申  3880      int *charbuf, *charbuf_end;
申鐃緒申  3881      unsigned char *dst;
申鐃緒申  3882 {
申鐃緒申  3883   struct charset *charset;
申鐃緒申  3884   /* Table of charsets to be designated to each graphic register.  */
申鐃緒申  3885   int r[4];
申鐃緒申  3886   int c, found = 0, reg;
申鐃緒申  3887   int produced_chars = 0;
申鐃緒申  3888   int multibytep = coding->dst_multibyte;
申鐃緒申  3889   Lisp_Object attrs;
申鐃緒申  3890   Lisp_Object charset_list;
申鐃緒申  3891 
申鐃緒申  3892   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  3893   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  3894   if (EQ (charset_list, Qiso_2022))
申鐃緒申  3895     charset_list = Viso_2022_charset_list;
申鐃緒申  3896 
申鐃緒申  3897   for (reg = 0; reg < 4; reg++)
申鐃緒申  3898     r[reg] = -1;
申鐃緒申  3899 
申鐃緒申  3900   while (found < 4)
申鐃緒申  3901     {
申鐃緒申  3902       int id;
申鐃緒申  3903 
申鐃緒申  3904       c = *charbuf++;
申鐃緒申  3905       if (c == '\n')
申鐃緒申  3906 	break;
申鐃緒申  3907       charset = char_charset (c, charset_list, NULL);
申鐃緒申  3908       id = CHARSET_ID (charset);
申鐃緒申  3909       reg = CODING_ISO_REQUEST (coding, id);
申鐃緒申  3910       if (reg >= 0 && r[reg] < 0)
申鐃緒申  3911 	{
申鐃緒申  3912 	  found++;
申鐃緒申  3913 	  r[reg] = id;
申鐃緒申  3914 	}
申鐃緒申  3915     }
申鐃緒申  3916 
申鐃緒申  3917   if (found)
申鐃緒申  3918     {
申鐃緒申  3919       for (reg = 0; reg < 4; reg++)
申鐃緒申  3920 	if (r[reg] >= 0
申鐃緒申  3921 	    && CODING_ISO_DESIGNATION (coding, reg) != r[reg])
申鐃緒申  3922 	  ENCODE_DESIGNATION (CHARSET_FROM_ID (r[reg]), reg, coding);
申鐃緒申  3923     }
申鐃緒申  3924 
申鐃緒申  3925   return dst;
申鐃緒申  3926 }
申鐃緒申  3927 
申鐃緒申  3928 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".  */
申鐃緒申  3929 
申鐃緒申  3930 static int
申鐃緒申  3931 encode_coding_iso_2022 (coding)
申鐃緒申  3932      struct coding_system *coding;
申鐃緒申  3933 {
申鐃緒申  3934   int multibytep = coding->dst_multibyte;
申鐃緒申  3935   int *charbuf = coding->charbuf;
申鐃緒申  3936   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  3937   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  3938   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  3939   int safe_room = 16;
申鐃緒申  3940   int bol_designation
申鐃緒申  3941     = (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
申鐃緒申  3942        && CODING_ISO_BOL (coding));
申鐃緒申  3943   int produced_chars = 0;
申鐃緒申  3944   Lisp_Object attrs, eol_type, charset_list;
申鐃緒申  3945   int ascii_compatible;
申鐃緒申  3946   int c;
申鐃緒申  3947   int preferred_charset_id = -1;
申鐃緒申  3948 
申鐃緒申  3949   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  3950   eol_type = CODING_ID_EOL_TYPE (coding->id);
申鐃緒申  3951   if (VECTORP (eol_type))
申鐃緒申  3952     eol_type = Qunix;
申鐃緒申  3953 
申鐃緒申  3954   setup_iso_safe_charsets (attrs);
申鐃緒申  3955   /* Charset list may have been changed.  */
申鐃緒申  3956   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  3957   coding->safe_charsets = (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs));
申鐃緒申  3958 
申鐃緒申  3959   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
申鐃緒申  3960 
申鐃緒申  3961   while (charbuf < charbuf_end)
申鐃緒申  3962     {
申鐃緒申  3963       ASSURE_DESTINATION (safe_room);
申鐃緒申  3964 
申鐃緒申  3965       if (bol_designation)
申鐃緒申  3966 	{
申鐃緒申  3967 	  unsigned char *dst_prev = dst;
申鐃緒申  3968 
申鐃緒申  3969 	  /* We have to produce designation sequences if any now.  */
申鐃緒申  3970 	  dst = encode_designation_at_bol (coding, charbuf, charbuf_end, dst);
申鐃緒申  3971 	  bol_designation = 0;
申鐃緒申  3972 	  /* We are sure that designation sequences are all ASCII bytes.  */
申鐃緒申  3973 	  produced_chars += dst - dst_prev;
申鐃緒申  3974 	}
申鐃緒申  3975 
申鐃緒申  3976       c = *charbuf++;
申鐃緒申  3977 
申鐃緒申  3978       if (c < 0)
申鐃緒申  3979 	{
申鐃緒申  3980 	  /* Handle an annotation.  */
申鐃緒申  3981 	  switch (*charbuf)
申鐃緒申  3982 	    {
申鐃緒申  3983 	    case CODING_ANNOTATE_COMPOSITION_MASK:
申鐃緒申  3984 	      /* Not yet implemented.  */
申鐃緒申  3985 	      break;
申鐃緒申  3986 	    case CODING_ANNOTATE_CHARSET_MASK:
申鐃緒申  3987 	      preferred_charset_id = charbuf[2];
申鐃緒申  3988 	      if (preferred_charset_id >= 0
申鐃緒申  3989 		  && NILP (Fmemq (make_number (preferred_charset_id),
申鐃緒申  3990 				  charset_list)))
申鐃緒申  3991 		preferred_charset_id = -1;
申鐃緒申  3992 	      break;
申鐃緒申  3993 	    default:
申鐃緒申  3994 	      abort ();
申鐃緒申  3995 	    }
申鐃緒申  3996 	  charbuf += -c - 1;
申鐃緒申  3997 	  continue;
申鐃緒申  3998 	}
申鐃緒申  3999 
申鐃緒申  4000       /* Now encode the character C.  */
申鐃緒申  4001       if (c < 0x20 || c == 0x7F)
申鐃緒申  4002 	{
申鐃緒申  4003 	  if (c == '\n'
申鐃緒申  4004 	      || (c == '\r' && EQ (eol_type, Qmac)))
申鐃緒申  4005 	    {
申鐃緒申  4006 	      if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_EOL)
申鐃緒申  4007 		ENCODE_RESET_PLANE_AND_REGISTER ();
申鐃緒申  4008 	      if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_INIT_AT_BOL)
申鐃緒申  4009 		{
申鐃緒申  4010 		  int i;
申鐃緒申  4011 
申鐃緒申  4012 		  for (i = 0; i < 4; i++)
申鐃緒申  4013 		    CODING_ISO_DESIGNATION (coding, i)
申鐃緒申  4014 		      = CODING_ISO_INITIAL (coding, i);
申鐃緒申  4015 		}
申鐃緒申  4016 	      bol_designation
申鐃緒申  4017 		= CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL;
申鐃緒申  4018 	    }
申鐃緒申  4019 	  else if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_CNTL)
申鐃緒申  4020 	    ENCODE_RESET_PLANE_AND_REGISTER ();
申鐃緒申  4021 	  EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  4022 	}
申鐃緒申  4023       else if (ASCII_CHAR_P (c))
申鐃緒申  4024 	{
申鐃緒申  4025 	  if (ascii_compatible)
申鐃緒申  4026 	    EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  4027 	  else
申鐃緒申  4028 	    {
申鐃緒申  4029 	      struct charset *charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  4030 	      ENCODE_ISO_CHARACTER (charset, c);
申鐃緒申  4031 	    }
申鐃緒申  4032 	}
申鐃緒申  4033       else if (CHAR_BYTE8_P (c))
申鐃緒申  4034 	{
申鐃緒申  4035 	  c = CHAR_TO_BYTE8 (c);
申鐃緒申  4036 	  EMIT_ONE_BYTE (c);
申鐃緒申  4037 	}
申鐃緒申  4038       else
申鐃緒申  4039 	{
申鐃緒申  4040 	  struct charset *charset;
申鐃緒申  4041 
申鐃緒申  4042 	  if (preferred_charset_id >= 0)
申鐃緒申  4043 	    {
申鐃緒申  4044 	      charset = CHARSET_FROM_ID (preferred_charset_id);
申鐃緒申  4045 	      if (! CHAR_CHARSET_P (c, charset))
申鐃緒申  4046 		charset = char_charset (c, charset_list, NULL);
申鐃緒申  4047 	    }
申鐃緒申  4048 	  else
申鐃緒申  4049 	    charset = char_charset (c, charset_list, NULL);
申鐃緒申  4050 	  if (!charset)
申鐃緒申  4051 	    {
申鐃緒申  4052 	      if (coding->mode & CODING_MODE_SAFE_ENCODING)
申鐃緒申  4053 		{
申鐃緒申  4054 		  c = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
申鐃緒申  4055 		  charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  4056 		}
申鐃緒申  4057 	      else
申鐃緒申  4058 		{
申鐃緒申  4059 		  c = coding->default_char;
申鐃緒申  4060 		  charset = char_charset (c, charset_list, NULL);
申鐃緒申  4061 		}
申鐃緒申  4062 	    }
申鐃緒申  4063 	  ENCODE_ISO_CHARACTER (charset, c);
申鐃緒申  4064 	}
申鐃緒申  4065     }
申鐃緒申  4066 
申鐃緒申  4067   if (coding->mode & CODING_MODE_LAST_BLOCK
申鐃緒申  4068       && CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_EOL)
申鐃緒申  4069     {
申鐃緒申  4070       ASSURE_DESTINATION (safe_room);
申鐃緒申  4071       ENCODE_RESET_PLANE_AND_REGISTER ();
申鐃緒申  4072     }
申鐃緒申  4073   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4074   CODING_ISO_BOL (coding) = bol_designation;
申鐃緒申  4075   coding->produced_char += produced_chars;
申鐃緒申  4076   coding->produced = dst - coding->destination;
申鐃緒申  4077   return 0;
申鐃緒申  4078 }
申鐃緒申  4079 
申鐃緒申  4080 
申鐃緒申  4081 /*** 8,9. SJIS and BIG5 handlers ***/
申鐃緒申  4082 
申鐃緒申  4083 /* Although SJIS and BIG5 are not ISO's coding system, they are used
申鐃緒申  4084    quite widely.  So, for the moment, Emacs supports them in the bare
申鐃緒申  4085    C code.  But, in the future, they may be supported only by CCL.  */
申鐃緒申  4086 
申鐃緒申  4087 /* SJIS is a coding system encoding three character sets: ASCII, right
申鐃緒申  4088    half of JISX0201-Kana, and JISX0208.  An ASCII character is encoded
申鐃緒申  4089    as is.  A character of charset katakana-jisx0201 is encoded by
申鐃緒申  4090    "position-code + 0x80".  A character of charset japanese-jisx0208
申鐃緒申  4091    is encoded in 2-byte but two position-codes are divided and shifted
申鐃緒申  4092    so that it fit in the range below.
申鐃緒申  4093 
申鐃緒申  4094    --- CODE RANGE of SJIS ---
申鐃緒申  4095    (character set)	(range)
申鐃緒申  4096    ASCII		0x00 .. 0x7F
申鐃緒申  4097    KATAKANA-JISX0201	0xA0 .. 0xDF
申鐃緒申  4098    JISX0208 (1st byte)	0x81 .. 0x9F and 0xE0 .. 0xEF
申鐃緒申  4099 	    (2nd byte)	0x40 .. 0x7E and 0x80 .. 0xFC
申鐃緒申  4100    -------------------------------
申鐃緒申  4101 
申鐃緒申  4102 */
申鐃緒申  4103 
申鐃緒申  4104 /* BIG5 is a coding system encoding two character sets: ASCII and
申鐃緒申  4105    Big5.  An ASCII character is encoded as is.  Big5 is a two-byte
申鐃緒申  4106    character set and is encoded in two-byte.
申鐃緒申  4107 
申鐃緒申  4108    --- CODE RANGE of BIG5 ---
申鐃緒申  4109    (character set)	(range)
申鐃緒申  4110    ASCII		0x00 .. 0x7F
申鐃緒申  4111    Big5 (1st byte)	0xA1 .. 0xFE
申鐃緒申  4112 	(2nd byte)	0x40 .. 0x7E and 0xA1 .. 0xFE
申鐃緒申  4113    --------------------------
申鐃緒申  4114 
申鐃緒申  4115   */
申鐃緒申  4116 
申鐃緒申  4117 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  4118    Check if a text is encoded in SJIS.  If it is, return
申鐃緒申  4119    CATEGORY_MASK_SJIS, else return 0.  */
申鐃緒申  4120 
申鐃緒申  4121 static int
申鐃緒申  4122 detect_coding_sjis (coding, detect_info)
申鐃緒申  4123      struct coding_system *coding;
申鐃緒申  4124      struct coding_detection_info *detect_info;
申鐃緒申  4125 {
申鐃緒申  4126   const unsigned char *src = coding->source, *src_base;
申鐃緒申  4127   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4128   int multibytep = coding->src_multibyte;
申鐃緒申  4129   int consumed_chars = 0;
申鐃緒申  4130   int found = 0;
申鐃緒申  4131   int c;
申鐃緒申  4132 
申鐃緒申  4133   detect_info->checked |= CATEGORY_MASK_SJIS;
申鐃緒申  4134   /* A coding system of this category is always ASCII compatible.  */
申鐃緒申  4135   src += coding->head_ascii;
申鐃緒申  4136 
申鐃緒申  4137   while (1)
申鐃緒申  4138     {
申鐃緒申  4139       src_base = src;
申鐃緒申  4140       ONE_MORE_BYTE (c);
申鐃緒申  4141       if (c < 0x80)
申鐃緒申  4142 	continue;
申鐃緒申  4143       if ((c >= 0x81 && c <= 0x9F) || (c >= 0xE0 && c <= 0xEF))
申鐃緒申  4144 	{
申鐃緒申  4145 	  ONE_MORE_BYTE (c);
申鐃緒申  4146 	  if (c < 0x40 || c == 0x7F || c > 0xFC)
申鐃緒申  4147 	    break;
申鐃緒申  4148 	  found = CATEGORY_MASK_SJIS;
申鐃緒申  4149 	}
申鐃緒申  4150       else if (c >= 0xA0 && c < 0xE0)
申鐃緒申  4151 	found = CATEGORY_MASK_SJIS;
申鐃緒申  4152       else
申鐃緒申  4153 	break;
申鐃緒申  4154     }
申鐃緒申  4155   detect_info->rejected |= CATEGORY_MASK_SJIS;
申鐃緒申  4156   return 0;
申鐃緒申  4157 
申鐃緒申  4158  no_more_source:
申鐃緒申  4159   if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  4160     {
申鐃緒申  4161       detect_info->rejected |= CATEGORY_MASK_SJIS;
申鐃緒申  4162       return 0;
申鐃緒申  4163     }
申鐃緒申  4164   detect_info->found |= found;
申鐃緒申  4165   return 1;
申鐃緒申  4166 }
申鐃緒申  4167 
申鐃緒申  4168 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  4169    Check if a text is encoded in BIG5.  If it is, return
申鐃緒申  4170    CATEGORY_MASK_BIG5, else return 0.  */
申鐃緒申  4171 
申鐃緒申  4172 static int
申鐃緒申  4173 detect_coding_big5 (coding, detect_info)
申鐃緒申  4174      struct coding_system *coding;
申鐃緒申  4175      struct coding_detection_info *detect_info;
申鐃緒申  4176 {
申鐃緒申  4177   const unsigned char *src = coding->source, *src_base;
申鐃緒申  4178   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4179   int multibytep = coding->src_multibyte;
申鐃緒申  4180   int consumed_chars = 0;
申鐃緒申  4181   int found = 0;
申鐃緒申  4182   int c;
申鐃緒申  4183 
申鐃緒申  4184   detect_info->checked |= CATEGORY_MASK_BIG5;
申鐃緒申  4185   /* A coding system of this category is always ASCII compatible.  */
申鐃緒申  4186   src += coding->head_ascii;
申鐃緒申  4187 
申鐃緒申  4188   while (1)
申鐃緒申  4189     {
申鐃緒申  4190       src_base = src;
申鐃緒申  4191       ONE_MORE_BYTE (c);
申鐃緒申  4192       if (c < 0x80)
申鐃緒申  4193 	continue;
申鐃緒申  4194       if (c >= 0xA1)
申鐃緒申  4195 	{
申鐃緒申  4196 	  ONE_MORE_BYTE (c);
申鐃緒申  4197 	  if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
申鐃緒申  4198 	    return 0;
申鐃緒申  4199 	  found = CATEGORY_MASK_BIG5;
申鐃緒申  4200 	}
申鐃緒申  4201       else
申鐃緒申  4202 	break;
申鐃緒申  4203     }
申鐃緒申  4204   detect_info->rejected |= CATEGORY_MASK_BIG5;
申鐃緒申  4205   return 0;
申鐃緒申  4206 
申鐃緒申  4207  no_more_source:
申鐃緒申  4208   if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  4209     {
申鐃緒申  4210       detect_info->rejected |= CATEGORY_MASK_BIG5;
申鐃緒申  4211       return 0;
申鐃緒申  4212     }
申鐃緒申  4213   detect_info->found |= found;
申鐃緒申  4214   return 1;
申鐃緒申  4215 }
申鐃緒申  4216 
申鐃緒申  4217 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
申鐃緒申  4218    If SJIS_P is 1, decode SJIS text, else decode BIG5 test.  */
申鐃緒申  4219 
申鐃緒申  4220 static void
申鐃緒申  4221 decode_coding_sjis (coding)
申鐃緒申  4222      struct coding_system *coding;
申鐃緒申  4223 {
申鐃緒申  4224   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  4225   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4226   const unsigned char *src_base;
申鐃緒申  4227   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  4228   int *charbuf_end
申鐃緒申  4229     = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
申鐃緒申  4230   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  4231   int multibytep = coding->src_multibyte;
申鐃緒申  4232   struct charset *charset_roman, *charset_kanji, *charset_kana;
申鐃緒申  4233   struct charset *charset_kanji2;
申鐃緒申  4234   Lisp_Object attrs, charset_list, val;
申鐃緒申  4235   int char_offset = coding->produced_char;
申鐃緒申  4236   int last_offset = char_offset;
申鐃緒申  4237   int last_id = charset_ascii;
申鐃緒申  4238   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  4239   int byte_after_cr = -1;
申鐃緒申  4240 
申鐃緒申  4241   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4242 
申鐃緒申  4243   val = charset_list;
申鐃緒申  4244   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4245   charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4246   charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4247   charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  4248 
申鐃緒申  4249   while (1)
申鐃緒申  4250     {
申鐃緒申  4251       int c, c1;
申鐃緒申  4252       struct charset *charset;
申鐃緒申  4253 
申鐃緒申  4254       src_base = src;
申鐃緒申  4255       consumed_chars_base = consumed_chars;
申鐃緒申  4256 
申鐃緒申  4257       if (charbuf >= charbuf_end)
申鐃緒申  4258 	break;
申鐃緒申  4259 
申鐃緒申  4260       if (byte_after_cr >= 0)
申鐃緒申  4261 	c = byte_after_cr, byte_after_cr = -1;
申鐃緒申  4262       else
申鐃緒申  4263 	ONE_MORE_BYTE (c);
申鐃緒申  4264       if (c < 0)
申鐃緒申  4265 	goto invalid_code;
申鐃緒申  4266       if (c < 0x80)
申鐃緒申  4267 	{
申鐃緒申  4268 	  if (eol_crlf && c == '\r')
申鐃緒申  4269 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  4270 	  charset = charset_roman;
申鐃緒申  4271 	}
申鐃緒申  4272       else if (c == 0x80 || c == 0xA0)
申鐃緒申  4273 	goto invalid_code;
申鐃緒申  4274       else if (c >= 0xA1 && c <= 0xDF)
申鐃緒申  4275 	{
申鐃緒申  4276 	  /* SJIS -> JISX0201-Kana */
申鐃緒申  4277 	  c &= 0x7F;
申鐃緒申  4278 	  charset = charset_kana;
申鐃緒申  4279 	}
申鐃緒申  4280       else if (c <= 0xEF)
申鐃緒申  4281 	{
申鐃緒申  4282 	  /* SJIS -> JISX0208 */
申鐃緒申  4283 	  ONE_MORE_BYTE (c1);
申鐃緒申  4284 	  if (c1 < 0x40 || c1 == 0x7F || c1 > 0xFC)
申鐃緒申  4285 	    goto invalid_code;
申鐃緒申  4286 	  c = (c << 8) | c1;
申鐃緒申  4287 	  SJIS_TO_JIS (c);
申鐃緒申  4288 	  charset = charset_kanji;
申鐃緒申  4289 	}
申鐃緒申  4290       else if (c <= 0xFC && charset_kanji2)
申鐃緒申  4291 	{
申鐃緒申  4292 	  /* SJIS -> JISX0213-2 */
申鐃緒申  4293 	  ONE_MORE_BYTE (c1);
申鐃緒申  4294 	  if (c1 < 0x40 || c1 == 0x7F || c1 > 0xFC)
申鐃緒申  4295 	    goto invalid_code;
申鐃緒申  4296 	  c = (c << 8) | c1;
申鐃緒申  4297 	  SJIS_TO_JIS2 (c);
申鐃緒申  4298 	  charset = charset_kanji2;
申鐃緒申  4299 	}
申鐃緒申  4300       else
申鐃緒申  4301 	goto invalid_code;
申鐃緒申  4302       if (charset->id != charset_ascii
申鐃緒申  4303 	  && last_id != charset->id)
申鐃緒申  4304 	{
申鐃緒申  4305 	  if (last_id != charset_ascii)
申鐃緒申  4306 	    ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  4307 	  last_id = charset->id;
申鐃緒申  4308 	  last_offset = char_offset;
申鐃緒申  4309 	}
申鐃緒申  4310       CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c, c);
申鐃緒申  4311       *charbuf++ = c;
申鐃緒申  4312       char_offset++;
申鐃緒申  4313       continue;
申鐃緒申  4314 
申鐃緒申  4315     invalid_code:
申鐃緒申  4316       src = src_base;
申鐃緒申  4317       consumed_chars = consumed_chars_base;
申鐃緒申  4318       ONE_MORE_BYTE (c);
申鐃緒申  4319       *charbuf++ = c < 0 ? -c : BYTE8_TO_CHAR (c);
申鐃緒申  4320       char_offset++;
申鐃緒申  4321       coding->errors++;
申鐃緒申  4322     }
申鐃緒申  4323 
申鐃緒申  4324  no_more_source:
申鐃緒申  4325   if (last_id != charset_ascii)
申鐃緒申  4326     ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  4327   coding->consumed_char += consumed_chars_base;
申鐃緒申  4328   coding->consumed = src_base - coding->source;
申鐃緒申  4329   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  4330 }
申鐃緒申  4331 
申鐃緒申  4332 static void
申鐃緒申  4333 decode_coding_big5 (coding)
申鐃緒申  4334      struct coding_system *coding;
申鐃緒申  4335 {
申鐃緒申  4336   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  4337   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4338   const unsigned char *src_base;
申鐃緒申  4339   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  4340   int *charbuf_end
申鐃緒申  4341     = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
申鐃緒申  4342   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  4343   int multibytep = coding->src_multibyte;
申鐃緒申  4344   struct charset *charset_roman, *charset_big5;
申鐃緒申  4345   Lisp_Object attrs, charset_list, val;
申鐃緒申  4346   int char_offset = coding->produced_char;
申鐃緒申  4347   int last_offset = char_offset;
申鐃緒申  4348   int last_id = charset_ascii;
申鐃緒申  4349   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  4350   int byte_after_cr = -1;
申鐃緒申  4351 
申鐃緒申  4352   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4353   val = charset_list;
申鐃緒申  4354   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4355   charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  4356 
申鐃緒申  4357   while (1)
申鐃緒申  4358     {
申鐃緒申  4359       int c, c1;
申鐃緒申  4360       struct charset *charset;
申鐃緒申  4361 
申鐃緒申  4362       src_base = src;
申鐃緒申  4363       consumed_chars_base = consumed_chars;
申鐃緒申  4364 
申鐃緒申  4365       if (charbuf >= charbuf_end)
申鐃緒申  4366 	break;
申鐃緒申  4367 
申鐃緒申  4368       if (byte_after_cr >= 0)
申鐃緒申  4369 	c = byte_after_cr, byte_after_cr = -1;
申鐃緒申  4370       else
申鐃緒申  4371 	ONE_MORE_BYTE (c);
申鐃緒申  4372 
申鐃緒申  4373       if (c < 0)
申鐃緒申  4374 	goto invalid_code;
申鐃緒申  4375       if (c < 0x80)
申鐃緒申  4376 	{
申鐃緒申  4377 	  if (eol_crlf && c == '\r')
申鐃緒申  4378 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  4379 	  charset = charset_roman;
申鐃緒申  4380 	}
申鐃緒申  4381       else
申鐃緒申  4382 	{
申鐃緒申  4383 	  /* BIG5 -> Big5 */
申鐃緒申  4384 	  if (c < 0xA1 || c > 0xFE)
申鐃緒申  4385 	    goto invalid_code;
申鐃緒申  4386 	  ONE_MORE_BYTE (c1);
申鐃緒申  4387 	  if (c1 < 0x40 || (c1 > 0x7E && c1 < 0xA1) || c1 > 0xFE)
申鐃緒申  4388 	    goto invalid_code;
申鐃緒申  4389 	  c = c << 8 | c1;
申鐃緒申  4390 	  charset = charset_big5;
申鐃緒申  4391 	}
申鐃緒申  4392       if (charset->id != charset_ascii
申鐃緒申  4393 	  && last_id != charset->id)
申鐃緒申  4394 	{
申鐃緒申  4395 	  if (last_id != charset_ascii)
申鐃緒申  4396 	    ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  4397 	  last_id = charset->id;
申鐃緒申  4398 	  last_offset = char_offset;
申鐃緒申  4399 	}
申鐃緒申  4400       CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c, c);
申鐃緒申  4401       *charbuf++ = c;
申鐃緒申  4402       char_offset++;
申鐃緒申  4403       continue;
申鐃緒申  4404 
申鐃緒申  4405     invalid_code:
申鐃緒申  4406       src = src_base;
申鐃緒申  4407       consumed_chars = consumed_chars_base;
申鐃緒申  4408       ONE_MORE_BYTE (c);
申鐃緒申  4409       *charbuf++ = c < 0 ? -c : BYTE8_TO_CHAR (c);
申鐃緒申  4410       char_offset++;
申鐃緒申  4411       coding->errors++;
申鐃緒申  4412     }
申鐃緒申  4413 
申鐃緒申  4414  no_more_source:
申鐃緒申  4415   if (last_id != charset_ascii)
申鐃緒申  4416     ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  4417   coding->consumed_char += consumed_chars_base;
申鐃緒申  4418   coding->consumed = src_base - coding->source;
申鐃緒申  4419   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  4420 }
申鐃緒申  4421 
申鐃緒申  4422 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
申鐃緒申  4423    This function can encode charsets `ascii', `katakana-jisx0201',
申鐃緒申  4424    `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'.  We
申鐃緒申  4425    are sure that all these charsets are registered as official charset
申鐃緒申  4426    (i.e. do not have extended leading-codes).  Characters of other
申鐃緒申  4427    charsets are produced without any encoding.  If SJIS_P is 1, encode
申鐃緒申  4428    SJIS text, else encode BIG5 text.  */
申鐃緒申  4429 
申鐃緒申  4430 static int
申鐃緒申  4431 encode_coding_sjis (coding)
申鐃緒申  4432      struct coding_system *coding;
申鐃緒申  4433 {
申鐃緒申  4434   int multibytep = coding->dst_multibyte;
申鐃緒申  4435   int *charbuf = coding->charbuf;
申鐃緒申  4436   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  4437   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  4438   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  4439   int safe_room = 4;
申鐃緒申  4440   int produced_chars = 0;
申鐃緒申  4441   Lisp_Object attrs, charset_list, val;
申鐃緒申  4442   int ascii_compatible;
申鐃緒申  4443   struct charset *charset_roman, *charset_kanji, *charset_kana;
申鐃緒申  4444   struct charset *charset_kanji2;
申鐃緒申  4445   int c;
申鐃緒申  4446 
申鐃緒申  4447   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4448   val = charset_list;
申鐃緒申  4449   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4450   charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4451   charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4452   charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  4453 
申鐃緒申  4454   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
申鐃緒申  4455 
申鐃緒申  4456   while (charbuf < charbuf_end)
申鐃緒申  4457     {
申鐃緒申  4458       ASSURE_DESTINATION (safe_room);
申鐃緒申  4459       c = *charbuf++;
申鐃緒申  4460       /* Now encode the character C.  */
申鐃緒申  4461       if (ASCII_CHAR_P (c) && ascii_compatible)
申鐃緒申  4462 	EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  4463       else if (CHAR_BYTE8_P (c))
申鐃緒申  4464 	{
申鐃緒申  4465 	  c = CHAR_TO_BYTE8 (c);
申鐃緒申  4466 	  EMIT_ONE_BYTE (c);
申鐃緒申  4467 	}
申鐃緒申  4468       else
申鐃緒申  4469 	{
申鐃緒申  4470 	  unsigned code;
申鐃緒申  4471 	  struct charset *charset = char_charset (c, charset_list, &code);
申鐃緒申  4472 
申鐃緒申  4473 	  if (!charset)
申鐃緒申  4474 	    {
申鐃緒申  4475 	      if (coding->mode & CODING_MODE_SAFE_ENCODING)
申鐃緒申  4476 		{
申鐃緒申  4477 		  code = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
申鐃緒申  4478 		  charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  4479 		}
申鐃緒申  4480 	      else
申鐃緒申  4481 		{
申鐃緒申  4482 		  c = coding->default_char;
申鐃緒申  4483 		  charset = char_charset (c, charset_list, &code);
申鐃緒申  4484 		}
申鐃緒申  4485 	    }
申鐃緒申  4486 	  if (code == CHARSET_INVALID_CODE (charset))
申鐃緒申  4487 	    abort ();
申鐃緒申  4488 	  if (charset == charset_kanji)
申鐃緒申  4489 	    {
申鐃緒申  4490 	      int c1, c2;
申鐃緒申  4491 	      JIS_TO_SJIS (code);
申鐃緒申  4492 	      c1 = code >> 8, c2 = code & 0xFF;
申鐃緒申  4493 	      EMIT_TWO_BYTES (c1, c2);
申鐃緒申  4494 	    }
申鐃緒申  4495 	  else if (charset == charset_kana)
申鐃緒申  4496 	    EMIT_ONE_BYTE (code | 0x80);
申鐃緒申  4497 	  else if (charset_kanji2 && charset == charset_kanji2)
申鐃緒申  4498 	    {
申鐃緒申  4499 	      int c1, c2;
申鐃緒申  4500 
申鐃緒申  4501 	      c1 = code >> 8;
申鐃緒申  4502 	      if (c1 == 0x21 || (c1 >= 0x23 && c1 < 0x25)
申鐃緒申  4503 		  || (c1 >= 0x2C && c1 <= 0x2F) || c1 >= 0x6E)
申鐃緒申  4504 		{
申鐃緒申  4505 		  JIS_TO_SJIS2 (code);
申鐃緒申  4506 		  c1 = code >> 8, c2 = code & 0xFF;
申鐃緒申  4507 		  EMIT_TWO_BYTES (c1, c2);
申鐃緒申  4508 		}
申鐃緒申  4509 	      else
申鐃緒申  4510 		EMIT_ONE_ASCII_BYTE (code & 0x7F);
申鐃緒申  4511 	    }
申鐃緒申  4512 	  else
申鐃緒申  4513 	    EMIT_ONE_ASCII_BYTE (code & 0x7F);
申鐃緒申  4514 	}
申鐃緒申  4515     }
申鐃緒申  4516   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4517   coding->produced_char += produced_chars;
申鐃緒申  4518   coding->produced = dst - coding->destination;
申鐃緒申  4519   return 0;
申鐃緒申  4520 }
申鐃緒申  4521 
申鐃緒申  4522 static int
申鐃緒申  4523 encode_coding_big5 (coding)
申鐃緒申  4524      struct coding_system *coding;
申鐃緒申  4525 {
申鐃緒申  4526   int multibytep = coding->dst_multibyte;
申鐃緒申  4527   int *charbuf = coding->charbuf;
申鐃緒申  4528   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  4529   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  4530   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  4531   int safe_room = 4;
申鐃緒申  4532   int produced_chars = 0;
申鐃緒申  4533   Lisp_Object attrs, charset_list, val;
申鐃緒申  4534   int ascii_compatible;
申鐃緒申  4535   struct charset *charset_roman, *charset_big5;
申鐃緒申  4536   int c;
申鐃緒申  4537 
申鐃緒申  4538   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4539   val = charset_list;
申鐃緒申  4540   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  4541   charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  4542   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
申鐃緒申  4543 
申鐃緒申  4544   while (charbuf < charbuf_end)
申鐃緒申  4545     {
申鐃緒申  4546       ASSURE_DESTINATION (safe_room);
申鐃緒申  4547       c = *charbuf++;
申鐃緒申  4548       /* Now encode the character C.  */
申鐃緒申  4549       if (ASCII_CHAR_P (c) && ascii_compatible)
申鐃緒申  4550 	EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  4551       else if (CHAR_BYTE8_P (c))
申鐃緒申  4552 	{
申鐃緒申  4553 	  c = CHAR_TO_BYTE8 (c);
申鐃緒申  4554 	  EMIT_ONE_BYTE (c);
申鐃緒申  4555 	}
申鐃緒申  4556       else
申鐃緒申  4557 	{
申鐃緒申  4558 	  unsigned code;
申鐃緒申  4559 	  struct charset *charset = char_charset (c, charset_list, &code);
申鐃緒申  4560 
申鐃緒申  4561 	  if (! charset)
申鐃緒申  4562 	    {
申鐃緒申  4563 	      if (coding->mode & CODING_MODE_SAFE_ENCODING)
申鐃緒申  4564 		{
申鐃緒申  4565 		  code = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
申鐃緒申  4566 		  charset = CHARSET_FROM_ID (charset_ascii);
申鐃緒申  4567 		}
申鐃緒申  4568 	      else
申鐃緒申  4569 		{
申鐃緒申  4570 		  c = coding->default_char;
申鐃緒申  4571 		  charset = char_charset (c, charset_list, &code);
申鐃緒申  4572 		}
申鐃緒申  4573 	    }
申鐃緒申  4574 	  if (code == CHARSET_INVALID_CODE (charset))
申鐃緒申  4575 	    abort ();
申鐃緒申  4576 	  if (charset == charset_big5)
申鐃緒申  4577 	    {
申鐃緒申  4578 	      int c1, c2;
申鐃緒申  4579 
申鐃緒申  4580 	      c1 = code >> 8, c2 = code & 0xFF;
申鐃緒申  4581 	      EMIT_TWO_BYTES (c1, c2);
申鐃緒申  4582 	    }
申鐃緒申  4583 	  else
申鐃緒申  4584 	    EMIT_ONE_ASCII_BYTE (code & 0x7F);
申鐃緒申  4585 	}
申鐃緒申  4586     }
申鐃緒申  4587   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4588   coding->produced_char += produced_chars;
申鐃緒申  4589   coding->produced = dst - coding->destination;
申鐃緒申  4590   return 0;
申鐃緒申  4591 }
申鐃緒申  4592 
申鐃緒申  4593 
申鐃緒申  4594 /*** 10. CCL handlers ***/
申鐃緒申  4595 
申鐃緒申  4596 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  4597    Check if a text is encoded in a coding system of which
申鐃緒申  4598    encoder/decoder are written in CCL program.  If it is, return
申鐃緒申  4599    CATEGORY_MASK_CCL, else return 0.  */
申鐃緒申  4600 
申鐃緒申  4601 static int
申鐃緒申  4602 detect_coding_ccl (coding, detect_info)
申鐃緒申  4603      struct coding_system *coding;
申鐃緒申  4604      struct coding_detection_info *detect_info;
申鐃緒申  4605 {
申鐃緒申  4606   const unsigned char *src = coding->source, *src_base;
申鐃緒申  4607   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4608   int multibytep = coding->src_multibyte;
申鐃緒申  4609   int consumed_chars = 0;
申鐃緒申  4610   int found = 0;
申鐃緒申  4611   unsigned char *valids;
申鐃緒申  4612   int head_ascii = coding->head_ascii;
申鐃緒申  4613   Lisp_Object attrs;
申鐃緒申  4614 
申鐃緒申  4615   detect_info->checked |= CATEGORY_MASK_CCL;
申鐃緒申  4616 
申鐃緒申  4617   coding = &coding_categories[coding_category_ccl];
申鐃緒申  4618   valids = CODING_CCL_VALIDS (coding);
申鐃緒申  4619   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  4620   if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  4621     src += head_ascii;
申鐃緒申  4622 
申鐃緒申  4623   while (1)
申鐃緒申  4624     {
申鐃緒申  4625       int c;
申鐃緒申  4626 
申鐃緒申  4627       src_base = src;
申鐃緒申  4628       ONE_MORE_BYTE (c);
申鐃緒申  4629       if (c < 0 || ! valids[c])
申鐃緒申  4630 	break;
申鐃緒申  4631       if ((valids[c] > 1))
申鐃緒申  4632 	found = CATEGORY_MASK_CCL;
申鐃緒申  4633     }
申鐃緒申  4634   detect_info->rejected |= CATEGORY_MASK_CCL;
申鐃緒申  4635   return 0;
申鐃緒申  4636 
申鐃緒申  4637  no_more_source:
申鐃緒申  4638   detect_info->found |= found;
申鐃緒申  4639   return 1;
申鐃緒申  4640 }
申鐃緒申  4641 
申鐃緒申  4642 static void
申鐃緒申  4643 decode_coding_ccl (coding)
申鐃緒申  4644      struct coding_system *coding;
申鐃緒申  4645 {
申鐃緒申  4646   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  4647   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4648   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  4649   int *charbuf_end = coding->charbuf + coding->charbuf_size;
申鐃緒申  4650   int consumed_chars = 0;
申鐃緒申  4651   int multibytep = coding->src_multibyte;
申鐃緒申  4652   struct ccl_program ccl;
申鐃緒申  4653   int source_charbuf[1024];
申鐃緒申  4654   int source_byteidx[1024];
申鐃緒申  4655   Lisp_Object attrs, charset_list;
申鐃緒申  4656 
申鐃緒申  4657   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4658   setup_ccl_program (&ccl, CODING_CCL_DECODER (coding));
申鐃緒申  4659 
申鐃緒申  4660   while (src < src_end)
申鐃緒申  4661     {
申鐃緒申  4662       const unsigned char *p = src;
申鐃緒申  4663       int *source, *source_end;
申鐃緒申  4664       int i = 0;
申鐃緒申  4665 
申鐃緒申  4666       if (multibytep)
申鐃緒申  4667 	while (i < 1024 && p < src_end)
申鐃緒申  4668 	  {
申鐃緒申  4669 	    source_byteidx[i] = p - src;
申鐃緒申  4670 	    source_charbuf[i++] = STRING_CHAR_ADVANCE (p);
申鐃緒申  4671 	  }
申鐃緒申  4672       else
申鐃緒申  4673 	while (i < 1024 && p < src_end)
申鐃緒申  4674 	  source_charbuf[i++] = *p++;
申鐃緒申  4675 
申鐃緒申  4676       if (p == src_end && coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  4677 	ccl.last_block = 1;
申鐃緒申  4678 
申鐃緒申  4679       source = source_charbuf;
申鐃緒申  4680       source_end = source + i;
申鐃緒申  4681       while (source < source_end)
申鐃緒申  4682 	{
申鐃緒申  4683 	  ccl_driver (&ccl, source, charbuf,
申鐃緒申  4684 		      source_end - source, charbuf_end - charbuf,
申鐃緒申  4685 		      charset_list);
申鐃緒申  4686 	  source += ccl.consumed;
申鐃緒申  4687 	  charbuf += ccl.produced;
申鐃緒申  4688 	  if (ccl.status != CCL_STAT_SUSPEND_BY_DST)
申鐃緒申  4689 	    break;
申鐃緒申  4690 	}
申鐃緒申  4691       if (source < source_end)
申鐃緒申  4692 	src += source_byteidx[source - source_charbuf];
申鐃緒申  4693       else
申鐃緒申  4694 	src = p;
申鐃緒申  4695       consumed_chars += source - source_charbuf;
申鐃緒申  4696 
申鐃緒申  4697       if (ccl.status != CCL_STAT_SUSPEND_BY_SRC
申鐃緒申  4698 	  && ccl.status != CODING_RESULT_INSUFFICIENT_SRC)
申鐃緒申  4699 	break;
申鐃緒申  4700     }
申鐃緒申  4701 
申鐃緒申  4702   switch (ccl.status)
申鐃緒申  4703     {
申鐃緒申  4704     case CCL_STAT_SUSPEND_BY_SRC:
申鐃緒申  4705       record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
申鐃緒申  4706       break;
申鐃緒申  4707     case CCL_STAT_SUSPEND_BY_DST:
申鐃緒申  4708       break;
申鐃緒申  4709     case CCL_STAT_QUIT:
申鐃緒申  4710     case CCL_STAT_INVALID_CMD:
申鐃緒申  4711       record_conversion_result (coding, CODING_RESULT_INTERRUPT);
申鐃緒申  4712       break;
申鐃緒申  4713     default:
申鐃緒申  4714       record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4715       break;
申鐃緒申  4716     }
申鐃緒申  4717   coding->consumed_char += consumed_chars;
申鐃緒申  4718   coding->consumed = src - coding->source;
申鐃緒申  4719   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  4720 }
申鐃緒申  4721 
申鐃緒申  4722 static int
申鐃緒申  4723 encode_coding_ccl (coding)
申鐃緒申  4724      struct coding_system *coding;
申鐃緒申  4725 {
申鐃緒申  4726   struct ccl_program ccl;
申鐃緒申  4727   int multibytep = coding->dst_multibyte;
申鐃緒申  4728   int *charbuf = coding->charbuf;
申鐃緒申  4729   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  4730   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  4731   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  4732   int destination_charbuf[1024];
申鐃緒申  4733   int i, produced_chars = 0;
申鐃緒申  4734   Lisp_Object attrs, charset_list;
申鐃緒申  4735 
申鐃緒申  4736   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  4737   setup_ccl_program (&ccl, CODING_CCL_ENCODER (coding));
申鐃緒申  4738 
申鐃緒申  4739   ccl.last_block = coding->mode & CODING_MODE_LAST_BLOCK;
申鐃緒申  4740   ccl.dst_multibyte = coding->dst_multibyte;
申鐃緒申  4741 
申鐃緒申  4742   while (charbuf < charbuf_end)
申鐃緒申  4743     {
申鐃緒申  4744       ccl_driver (&ccl, charbuf, destination_charbuf,
申鐃緒申  4745 		  charbuf_end - charbuf, 1024, charset_list);
申鐃緒申  4746       if (multibytep)
申鐃緒申  4747 	{
申鐃緒申  4748 	  ASSURE_DESTINATION (ccl.produced * 2);
申鐃緒申  4749 	  for (i = 0; i < ccl.produced; i++)
申鐃緒申  4750 	    EMIT_ONE_BYTE (destination_charbuf[i] & 0xFF);
申鐃緒申  4751 	}
申鐃緒申  4752       else
申鐃緒申  4753 	{
申鐃緒申  4754 	  ASSURE_DESTINATION (ccl.produced);
申鐃緒申  4755 	  for (i = 0; i < ccl.produced; i++)
申鐃緒申  4756 	    *dst++ = destination_charbuf[i] & 0xFF;
申鐃緒申  4757 	  produced_chars += ccl.produced;
申鐃緒申  4758 	}
申鐃緒申  4759       charbuf += ccl.consumed;
申鐃緒申  4760       if (ccl.status == CCL_STAT_QUIT
申鐃緒申  4761 	  || ccl.status == CCL_STAT_INVALID_CMD)
申鐃緒申  4762 	break;
申鐃緒申  4763     }
申鐃緒申  4764 
申鐃緒申  4765   switch (ccl.status)
申鐃緒申  4766     {
申鐃緒申  4767     case CCL_STAT_SUSPEND_BY_SRC:
申鐃緒申  4768       record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
申鐃緒申  4769       break;
申鐃緒申  4770     case CCL_STAT_SUSPEND_BY_DST:
申鐃緒申  4771       record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_DST);
申鐃緒申  4772       break;
申鐃緒申  4773     case CCL_STAT_QUIT:
申鐃緒申  4774     case CCL_STAT_INVALID_CMD:
申鐃緒申  4775       record_conversion_result (coding, CODING_RESULT_INTERRUPT);
申鐃緒申  4776       break;
申鐃緒申  4777     default:
申鐃緒申  4778       record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4779       break;
申鐃緒申  4780     }
申鐃緒申  4781 
申鐃緒申  4782   coding->produced_char += produced_chars;
申鐃緒申  4783   coding->produced = dst - coding->destination;
申鐃緒申  4784   return 0;
申鐃緒申  4785 }
申鐃緒申  4786 
申鐃緒申  4787 
申鐃緒申  4788 
申鐃緒申  4789 /*** 10, 11. no-conversion handlers ***/
申鐃緒申  4790 
申鐃緒申  4791 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
申鐃緒申  4792 
申鐃緒申  4793 static void
申鐃緒申  4794 decode_coding_raw_text (coding)
申鐃緒申  4795      struct coding_system *coding;
申鐃緒申  4796 {
申鐃緒申  4797   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  4798 
申鐃緒申  4799   coding->chars_at_source = 1;
申鐃緒申  4800   coding->consumed_char = coding->src_chars;
申鐃緒申  4801   coding->consumed = coding->src_bytes;
申鐃緒申  4802   if (eol_crlf && coding->source[coding->src_bytes - 1] == '\r')
申鐃緒申  4803     {
申鐃緒申  4804       coding->consumed_char--;
申鐃緒申  4805       coding->consumed--;
申鐃緒申  4806       record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
申鐃緒申  4807     }
申鐃緒申  4808   else
申鐃緒申  4809     record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4810 }
申鐃緒申  4811 
申鐃緒申  4812 static int
申鐃緒申  4813 encode_coding_raw_text (coding)
申鐃緒申  4814      struct coding_system *coding;
申鐃緒申  4815 {
申鐃緒申  4816   int multibytep = coding->dst_multibyte;
申鐃緒申  4817   int *charbuf = coding->charbuf;
申鐃緒申  4818   int *charbuf_end = coding->charbuf + coding->charbuf_used;
申鐃緒申  4819   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  4820   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  4821   int produced_chars = 0;
申鐃緒申  4822   int c;
申鐃緒申  4823 
申鐃緒申  4824   if (multibytep)
申鐃緒申  4825     {
申鐃緒申  4826       int safe_room = MAX_MULTIBYTE_LENGTH * 2;
申鐃緒申  4827 
申鐃緒申  4828       if (coding->src_multibyte)
申鐃緒申  4829 	while (charbuf < charbuf_end)
申鐃緒申  4830 	  {
申鐃緒申  4831 	    ASSURE_DESTINATION (safe_room);
申鐃緒申  4832 	    c = *charbuf++;
申鐃緒申  4833 	    if (ASCII_CHAR_P (c))
申鐃緒申  4834 	      EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  4835 	    else if (CHAR_BYTE8_P (c))
申鐃緒申  4836 	      {
申鐃緒申  4837 		c = CHAR_TO_BYTE8 (c);
申鐃緒申  4838 		EMIT_ONE_BYTE (c);
申鐃緒申  4839 	      }
申鐃緒申  4840 	    else
申鐃緒申  4841 	      {
申鐃緒申  4842 		unsigned char str[MAX_MULTIBYTE_LENGTH], *p0 = str, *p1 = str;
申鐃緒申  4843 
申鐃緒申  4844 		CHAR_STRING_ADVANCE (c, p1);
申鐃緒申  4845 		while (p0 < p1)
申鐃緒申  4846 		  {
申鐃緒申  4847 		    EMIT_ONE_BYTE (*p0);
申鐃緒申  4848 		    p0++;
申鐃緒申  4849 		  }
申鐃緒申  4850 	      }
申鐃緒申  4851 	  }
申鐃緒申  4852       else
申鐃緒申  4853 	while (charbuf < charbuf_end)
申鐃緒申  4854 	  {
申鐃緒申  4855 	    ASSURE_DESTINATION (safe_room);
申鐃緒申  4856 	    c = *charbuf++;
申鐃緒申  4857 	    EMIT_ONE_BYTE (c);
申鐃緒申  4858 	  }
申鐃緒申  4859     }
申鐃緒申  4860   else
申鐃緒申  4861     {
申鐃緒申  4862       if (coding->src_multibyte)
申鐃緒申  4863 	{
申鐃緒申  4864 	  int safe_room = MAX_MULTIBYTE_LENGTH;
申鐃緒申  4865 
申鐃緒申  4866 	  while (charbuf < charbuf_end)
申鐃緒申  4867 	    {
申鐃緒申  4868 	      ASSURE_DESTINATION (safe_room);
申鐃緒申  4869 	      c = *charbuf++;
申鐃緒申  4870 	      if (ASCII_CHAR_P (c))
申鐃緒申  4871 		*dst++ = c;
申鐃緒申  4872 	      else if (CHAR_BYTE8_P (c))
申鐃緒申  4873 		*dst++ = CHAR_TO_BYTE8 (c);
申鐃緒申  4874 	      else
申鐃緒申  4875 		CHAR_STRING_ADVANCE (c, dst);
申鐃緒申  4876 	      produced_chars++;
申鐃緒申  4877 	    }
申鐃緒申  4878 	}
申鐃緒申  4879       else
申鐃緒申  4880 	{
申鐃緒申  4881 	  ASSURE_DESTINATION (charbuf_end - charbuf);
申鐃緒申  4882 	  while (charbuf < charbuf_end && dst < dst_end)
申鐃緒申  4883 	    *dst++ = *charbuf++;
申鐃緒申  4884 	  produced_chars = dst - (coding->destination + coding->dst_bytes);
申鐃緒申  4885 	}
申鐃緒申  4886     }
申鐃緒申  4887   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  4888   coding->produced_char += produced_chars;
申鐃緒申  4889   coding->produced = dst - coding->destination;
申鐃緒申  4890   return 0;
申鐃緒申  4891 }
申鐃緒申  4892 
申鐃緒申  4893 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
申鐃緒申  4894    Check if a text is encoded in a charset-based coding system.  If it
申鐃緒申  4895    is, return 1, else return 0.  */
申鐃緒申  4896 
申鐃緒申  4897 static int
申鐃緒申  4898 detect_coding_charset (coding, detect_info)
申鐃緒申  4899      struct coding_system *coding;
申鐃緒申  4900      struct coding_detection_info *detect_info;
申鐃緒申  4901 {
申鐃緒申  4902   const unsigned char *src = coding->source, *src_base;
申鐃緒申  4903   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4904   int multibytep = coding->src_multibyte;
申鐃緒申  4905   int consumed_chars = 0;
申鐃緒申  4906   Lisp_Object attrs, valids;
申鐃緒申  4907   int found = 0;
申鐃緒申  4908   int head_ascii = coding->head_ascii;
申鐃緒申  4909 
申鐃緒申  4910   detect_info->checked |= CATEGORY_MASK_CHARSET;
申鐃緒申  4911 
申鐃緒申  4912   coding = &coding_categories[coding_category_charset];
申鐃緒申  4913   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  4914   valids = AREF (attrs, coding_attr_charset_valids);
申鐃緒申  4915 
申鐃緒申  4916   if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  4917     src += head_ascii;
申鐃緒申  4918 
申鐃緒申  4919   while (1)
申鐃緒申  4920     {
申鐃緒申  4921       int c;
申鐃緒申  4922       Lisp_Object val;
申鐃緒申  4923       struct charset *charset;
申鐃緒申  4924       int dim, idx;
申鐃緒申  4925 
申鐃緒申  4926       src_base = src;
申鐃緒申  4927       ONE_MORE_BYTE (c);
申鐃緒申  4928       if (c < 0)
申鐃緒申  4929 	continue;
申鐃緒申  4930       val = AREF (valids, c);
申鐃緒申  4931       if (NILP (val))
申鐃緒申  4932 	break;
申鐃緒申  4933       if (c >= 0x80)
申鐃緒申  4934 	found = CATEGORY_MASK_CHARSET;
申鐃緒申  4935       if (INTEGERP (val))
申鐃緒申  4936 	{
申鐃緒申  4937 	  charset = CHARSET_FROM_ID (XFASTINT (val));
申鐃緒申  4938 	  dim = CHARSET_DIMENSION (charset);
申鐃緒申  4939 	  for (idx = 1; idx < dim; idx++)
申鐃緒申  4940 	    {
申鐃緒申  4941 	      if (src == src_end)
申鐃緒申  4942 		goto too_short;
申鐃緒申  4943 	      ONE_MORE_BYTE (c);
申鐃緒申  4944 	      if (c < charset->code_space[(dim - 1 - idx) * 2]
申鐃緒申  4945 		  || c > charset->code_space[(dim - 1 - idx) * 2 + 1])
申鐃緒申  4946 		break;
申鐃緒申  4947 	    }
申鐃緒申  4948 	  if (idx < dim)
申鐃緒申  4949 	    break;
申鐃緒申  4950 	}
申鐃緒申  4951       else
申鐃緒申  4952 	{
申鐃緒申  4953 	  idx = 1;
申鐃緒申  4954 	  for (; CONSP (val); val = XCDR (val))
申鐃緒申  4955 	    {
申鐃緒申  4956 	      charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
申鐃緒申  4957 	      dim = CHARSET_DIMENSION (charset);
申鐃緒申  4958 	      while (idx < dim)
申鐃緒申  4959 		{
申鐃緒申  4960 		  if (src == src_end)
申鐃緒申  4961 		    goto too_short;
申鐃緒申  4962 		  ONE_MORE_BYTE (c);
申鐃緒申  4963 		  if (c < charset->code_space[(dim - 1 - idx) * 4]
申鐃緒申  4964 		      || c > charset->code_space[(dim - 1 - idx) * 4 + 1])
申鐃緒申  4965 		    break;
申鐃緒申  4966 		  idx++;
申鐃緒申  4967 		}
申鐃緒申  4968 	      if (idx == dim)
申鐃緒申  4969 		{
申鐃緒申  4970 		  val = Qnil;
申鐃緒申  4971 		  break;
申鐃緒申  4972 		}
申鐃緒申  4973 	    }
申鐃緒申  4974 	  if (CONSP (val))
申鐃緒申  4975 	    break;
申鐃緒申  4976 	}
申鐃緒申  4977     }
申鐃緒申  4978  too_short:
申鐃緒申  4979   detect_info->rejected |= CATEGORY_MASK_CHARSET;
申鐃緒申  4980   return 0;
申鐃緒申  4981 
申鐃緒申  4982  no_more_source:
申鐃緒申  4983   detect_info->found |= found;
申鐃緒申  4984   return 1;
申鐃緒申  4985 }
申鐃緒申  4986 
申鐃緒申  4987 static void
申鐃緒申  4988 decode_coding_charset (coding)
申鐃緒申  4989      struct coding_system *coding;
申鐃緒申  4990 {
申鐃緒申  4991   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  4992   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  4993   const unsigned char *src_base;
申鐃緒申  4994   int *charbuf = coding->charbuf + coding->charbuf_used;
申鐃緒申  4995   int *charbuf_end
申鐃緒申  4996     = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
申鐃緒申  4997   int consumed_chars = 0, consumed_chars_base;
申鐃緒申  4998   int multibytep = coding->src_multibyte;
申鐃緒申  4999   Lisp_Object attrs, charset_list, valids;
申鐃緒申  5000   int char_offset = coding->produced_char;
申鐃緒申  5001   int last_offset = char_offset;
申鐃緒申  5002   int last_id = charset_ascii;
申鐃緒申  5003   int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
申鐃緒申  5004   int byte_after_cr = -1;
申鐃緒申  5005 
申鐃緒申  5006   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  5007   valids = AREF (attrs, coding_attr_charset_valids);
申鐃緒申  5008 
申鐃緒申  5009   while (1)
申鐃緒申  5010     {
申鐃緒申  5011       int c;
申鐃緒申  5012       Lisp_Object val;
申鐃緒申  5013       struct charset *charset;
申鐃緒申  5014       int dim;
申鐃緒申  5015       int len = 1;
申鐃緒申  5016       unsigned code;
申鐃緒申  5017 
申鐃緒申  5018       src_base = src;
申鐃緒申  5019       consumed_chars_base = consumed_chars;
申鐃緒申  5020 
申鐃緒申  5021       if (charbuf >= charbuf_end)
申鐃緒申  5022 	break;
申鐃緒申  5023 
申鐃緒申  5024       if (byte_after_cr >= 0)
申鐃緒申  5025 	{
申鐃緒申  5026 	  c = byte_after_cr;
申鐃緒申  5027 	  byte_after_cr = -1;
申鐃緒申  5028 	}
申鐃緒申  5029       else
申鐃緒申  5030 	{
申鐃緒申  5031 	  ONE_MORE_BYTE (c);
申鐃緒申  5032 	  if (eol_crlf && c == '\r')
申鐃緒申  5033 	    ONE_MORE_BYTE (byte_after_cr);
申鐃緒申  5034 	}
申鐃緒申  5035       if (c < 0)
申鐃緒申  5036 	goto invalid_code;
申鐃緒申  5037       code = c;
申鐃緒申  5038 
申鐃緒申  5039       val = AREF (valids, c);
申鐃緒申  5040       if (NILP (val))
申鐃緒申  5041 	goto invalid_code;
申鐃緒申  5042       if (INTEGERP (val))
申鐃緒申  5043 	{
申鐃緒申  5044 	  charset = CHARSET_FROM_ID (XFASTINT (val));
申鐃緒申  5045 	  dim = CHARSET_DIMENSION (charset);
申鐃緒申  5046 	  while (len < dim)
申鐃緒申  5047 	    {
申鐃緒申  5048 	      ONE_MORE_BYTE (c);
申鐃緒申  5049 	      code = (code << 8) | c;
申鐃緒申  5050 	      len++;
申鐃緒申  5051 	    }
申鐃緒申  5052 	  CODING_DECODE_CHAR (coding, src, src_base, src_end,
申鐃緒申  5053 			      charset, code, c);
申鐃緒申  5054 	}
申鐃緒申  5055       else
申鐃緒申  5056 	{
申鐃緒申  5057 	  /* VAL is a list of charset IDs.  It is assured that the
申鐃緒申  5058 	     list is sorted by charset dimensions (smaller one
申鐃緒申  5059 	     comes first).  */
申鐃緒申  5060 	  while (CONSP (val))
申鐃緒申  5061 	    {
申鐃緒申  5062 	      charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
申鐃緒申  5063 	      dim = CHARSET_DIMENSION (charset);
申鐃緒申  5064 	      while (len < dim)
申鐃緒申  5065 		{
申鐃緒申  5066 		  ONE_MORE_BYTE (c);
申鐃緒申  5067 		  code = (code << 8) | c;
申鐃緒申  5068 		  len++;
申鐃緒申  5069 		}
申鐃緒申  5070 	      CODING_DECODE_CHAR (coding, src, src_base,
申鐃緒申  5071 				  src_end, charset, code, c);
申鐃緒申  5072 	      if (c >= 0)
申鐃緒申  5073 		break;
申鐃緒申  5074 	      val = XCDR (val);
申鐃緒申  5075 	    }
申鐃緒申  5076 	}
申鐃緒申  5077       if (c < 0)
申鐃緒申  5078 	goto invalid_code;
申鐃緒申  5079       if (charset->id != charset_ascii
申鐃緒申  5080 	  && last_id != charset->id)
申鐃緒申  5081 	{
申鐃緒申  5082 	  if (last_id != charset_ascii)
申鐃緒申  5083 	    ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  5084 	  last_id = charset->id;
申鐃緒申  5085 	  last_offset = char_offset;
申鐃緒申  5086 	}
申鐃緒申  5087 
申鐃緒申  5088       *charbuf++ = c;
申鐃緒申  5089       char_offset++;
申鐃緒申  5090       continue;
申鐃緒申  5091 
申鐃緒申  5092     invalid_code:
申鐃緒申  5093       src = src_base;
申鐃緒申  5094       consumed_chars = consumed_chars_base;
申鐃緒申  5095       ONE_MORE_BYTE (c);
申鐃緒申  5096       *charbuf++ = c < 0 ? -c : ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
申鐃緒申  5097       char_offset++;
申鐃緒申  5098       coding->errors++;
申鐃緒申  5099     }
申鐃緒申  5100 
申鐃緒申  5101  no_more_source:
申鐃緒申  5102   if (last_id != charset_ascii)
申鐃緒申  5103     ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
申鐃緒申  5104   coding->consumed_char += consumed_chars_base;
申鐃緒申  5105   coding->consumed = src_base - coding->source;
申鐃緒申  5106   coding->charbuf_used = charbuf - coding->charbuf;
申鐃緒申  5107 }
申鐃緒申  5108 
申鐃緒申  5109 static int
申鐃緒申  5110 encode_coding_charset (coding)
申鐃緒申  5111      struct coding_system *coding;
申鐃緒申  5112 {
申鐃緒申  5113   int multibytep = coding->dst_multibyte;
申鐃緒申  5114   int *charbuf = coding->charbuf;
申鐃緒申  5115   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  5116   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  5117   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  5118   int safe_room = MAX_MULTIBYTE_LENGTH;
申鐃緒申  5119   int produced_chars = 0;
申鐃緒申  5120   Lisp_Object attrs, charset_list;
申鐃緒申  5121   int ascii_compatible;
申鐃緒申  5122   int c;
申鐃緒申  5123 
申鐃緒申  5124   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  5125   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
申鐃緒申  5126 
申鐃緒申  5127   while (charbuf < charbuf_end)
申鐃緒申  5128     {
申鐃緒申  5129       struct charset *charset;
申鐃緒申  5130       unsigned code;
申鐃緒申  5131 
申鐃緒申  5132       ASSURE_DESTINATION (safe_room);
申鐃緒申  5133       c = *charbuf++;
申鐃緒申  5134       if (ascii_compatible && ASCII_CHAR_P (c))
申鐃緒申  5135 	EMIT_ONE_ASCII_BYTE (c);
申鐃緒申  5136       else if (CHAR_BYTE8_P (c))
申鐃緒申  5137 	{
申鐃緒申  5138 	  c = CHAR_TO_BYTE8 (c);
申鐃緒申  5139 	  EMIT_ONE_BYTE (c);
申鐃緒申  5140 	}
申鐃緒申  5141       else
申鐃緒申  5142 	{
申鐃緒申  5143 	  charset = char_charset (c, charset_list, &code);
申鐃緒申  5144 	  if (charset)
申鐃緒申  5145 	    {
申鐃緒申  5146 	      if (CHARSET_DIMENSION (charset) == 1)
申鐃緒申  5147 		EMIT_ONE_BYTE (code);
申鐃緒申  5148 	      else if (CHARSET_DIMENSION (charset) == 2)
申鐃緒申  5149 		EMIT_TWO_BYTES (code >> 8, code & 0xFF);
申鐃緒申  5150 	      else if (CHARSET_DIMENSION (charset) == 3)
申鐃緒申  5151 		EMIT_THREE_BYTES (code >> 16, (code >> 8) & 0xFF, code & 0xFF);
申鐃緒申  5152 	      else
申鐃緒申  5153 		EMIT_FOUR_BYTES (code >> 24, (code >> 16) & 0xFF,
申鐃緒申  5154 				 (code >> 8) & 0xFF, code & 0xFF);
申鐃緒申  5155 	    }
申鐃緒申  5156 	  else
申鐃緒申  5157 	    {
申鐃緒申  5158 	      if (coding->mode & CODING_MODE_SAFE_ENCODING)
申鐃緒申  5159 		c = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
申鐃緒申  5160 	      else
申鐃緒申  5161 		c = coding->default_char;
申鐃緒申  5162 	      EMIT_ONE_BYTE (c);
申鐃緒申  5163 	    }
申鐃緒申  5164 	}
申鐃緒申  5165     }
申鐃緒申  5166 
申鐃緒申  5167   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  5168   coding->produced_char += produced_chars;
申鐃緒申  5169   coding->produced = dst - coding->destination;
申鐃緒申  5170   return 0;
申鐃緒申  5171 }
申鐃緒申  5172 
申鐃緒申  5173 
申鐃緒申  5174 /*** 7. C library functions ***/
申鐃緒申  5175 
申鐃緒申  5176 /* Setup coding context CODING from information about CODING_SYSTEM.
申鐃緒申  5177    If CODING_SYSTEM is nil, `no-conversion' is assumed.  If
申鐃緒申  5178    CODING_SYSTEM is invalid, signal an error.  */
申鐃緒申  5179 
申鐃緒申  5180 void
申鐃緒申  5181 setup_coding_system (coding_system, coding)
申鐃緒申  5182      Lisp_Object coding_system;
申鐃緒申  5183      struct coding_system *coding;
申鐃緒申  5184 {
申鐃緒申  5185   Lisp_Object attrs;
申鐃緒申  5186   Lisp_Object eol_type;
申鐃緒申  5187   Lisp_Object coding_type;
申鐃緒申  5188   Lisp_Object val;
申鐃緒申  5189 
申鐃緒申  5190   if (NILP (coding_system))
申鐃緒申  5191     coding_system = Qundecided;
申鐃緒申  5192 
申鐃緒申  5193   CHECK_CODING_SYSTEM_GET_ID (coding_system, coding->id);
申鐃緒申  5194 
申鐃緒申  5195   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  5196   eol_type = CODING_ID_EOL_TYPE (coding->id);
申鐃緒申  5197 
申鐃緒申  5198   coding->mode = 0;
申鐃緒申  5199   coding->head_ascii = -1;
申鐃緒申  5200   if (VECTORP (eol_type))
申鐃緒申  5201     coding->common_flags = (CODING_REQUIRE_DECODING_MASK
申鐃緒申  5202 			    | CODING_REQUIRE_DETECTION_MASK);
申鐃緒申  5203   else if (! EQ (eol_type, Qunix))
申鐃緒申  5204     coding->common_flags = (CODING_REQUIRE_DECODING_MASK
申鐃緒申  5205 			    | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5206   else
申鐃緒申  5207     coding->common_flags = 0;
申鐃緒申  5208   if (! NILP (CODING_ATTR_POST_READ (attrs)))
申鐃緒申  5209     coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
申鐃緒申  5210   if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
申鐃緒申  5211     coding->common_flags |= CODING_REQUIRE_ENCODING_MASK;
申鐃緒申  5212   if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs)))
申鐃緒申  5213     coding->common_flags |= CODING_FOR_UNIBYTE_MASK;
申鐃緒申  5214 
申鐃緒申  5215   val = CODING_ATTR_SAFE_CHARSETS (attrs);
申鐃緒申  5216   coding->max_charset_id = SCHARS (val) - 1;
申鐃緒申  5217   coding->safe_charsets = (char *) SDATA (val);
申鐃緒申  5218   coding->default_char = XINT (CODING_ATTR_DEFAULT_CHAR (attrs));
申鐃緒申  5219 
申鐃緒申  5220   coding_type = CODING_ATTR_TYPE (attrs);
申鐃緒申  5221   if (EQ (coding_type, Qundecided))
申鐃緒申  5222     {
申鐃緒申  5223       coding->detector = NULL;
申鐃緒申  5224       coding->decoder = decode_coding_raw_text;
申鐃緒申  5225       coding->encoder = encode_coding_raw_text;
申鐃緒申  5226       coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
申鐃緒申  5227     }
申鐃緒申  5228   else if (EQ (coding_type, Qiso_2022))
申鐃緒申  5229     {
申鐃緒申  5230       int i;
申鐃緒申  5231       int flags = XINT (AREF (attrs, coding_attr_iso_flags));
申鐃緒申  5232 
申鐃緒申  5233       /* Invoke graphic register 0 to plane 0.  */
申鐃緒申  5234       CODING_ISO_INVOCATION (coding, 0) = 0;
申鐃緒申  5235       /* Invoke graphic register 1 to plane 1 if we can use 8-bit.  */
申鐃緒申  5236       CODING_ISO_INVOCATION (coding, 1)
申鐃緒申  5237 	= (flags & CODING_ISO_FLAG_SEVEN_BITS ? -1 : 1);
申鐃緒申  5238       /* Setup the initial status of designation.  */
申鐃緒申  5239       for (i = 0; i < 4; i++)
申鐃緒申  5240 	CODING_ISO_DESIGNATION (coding, i) = CODING_ISO_INITIAL (coding, i);
申鐃緒申  5241       /* Not single shifting initially.  */
申鐃緒申  5242       CODING_ISO_SINGLE_SHIFTING (coding) = 0;
申鐃緒申  5243       /* Beginning of buffer should also be regarded as bol. */
申鐃緒申  5244       CODING_ISO_BOL (coding) = 1;
申鐃緒申  5245       coding->detector = detect_coding_iso_2022;
申鐃緒申  5246       coding->decoder = decode_coding_iso_2022;
申鐃緒申  5247       coding->encoder = encode_coding_iso_2022;
申鐃緒申  5248       if (flags & CODING_ISO_FLAG_SAFE)
申鐃緒申  5249 	coding->mode |= CODING_MODE_SAFE_ENCODING;
申鐃緒申  5250       coding->common_flags
申鐃緒申  5251 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK
申鐃緒申  5252 	    | CODING_REQUIRE_FLUSHING_MASK);
申鐃緒申  5253       if (flags & CODING_ISO_FLAG_COMPOSITION)
申鐃緒申  5254 	coding->common_flags |= CODING_ANNOTATE_COMPOSITION_MASK;
申鐃緒申  5255       if (flags & CODING_ISO_FLAG_DESIGNATION)
申鐃緒申  5256 	coding->common_flags |= CODING_ANNOTATE_CHARSET_MASK;
申鐃緒申  5257       if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
申鐃緒申  5258 	{
申鐃緒申  5259 	  setup_iso_safe_charsets (attrs);
申鐃緒申  5260 	  val = CODING_ATTR_SAFE_CHARSETS (attrs);
申鐃緒申  5261 	  coding->max_charset_id = SCHARS (val) - 1;
申鐃緒申  5262 	  coding->safe_charsets = (char *) SDATA (val);
申鐃緒申  5263 	}
申鐃緒申  5264       CODING_ISO_FLAGS (coding) = flags;
申鐃緒申  5265     }
申鐃緒申  5266   else if (EQ (coding_type, Qcharset))
申鐃緒申  5267     {
申鐃緒申  5268       coding->detector = detect_coding_charset;
申鐃緒申  5269       coding->decoder = decode_coding_charset;
申鐃緒申  5270       coding->encoder = encode_coding_charset;
申鐃緒申  5271       coding->common_flags
申鐃緒申  5272 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5273     }
申鐃緒申  5274   else if (EQ (coding_type, Qutf_8))
申鐃緒申  5275     {
申鐃緒申  5276       coding->detector = detect_coding_utf_8;
申鐃緒申  5277       coding->decoder = decode_coding_utf_8;
申鐃緒申  5278       coding->encoder = encode_coding_utf_8;
申鐃緒申  5279       coding->common_flags
申鐃緒申  5280 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5281     }
申鐃緒申  5282   else if (EQ (coding_type, Qutf_16))
申鐃緒申  5283     {
申鐃緒申  5284       val = AREF (attrs, coding_attr_utf_16_bom);
申鐃緒申  5285       CODING_UTF_16_BOM (coding) = (CONSP (val) ? utf_16_detect_bom
申鐃緒申  5286 				    : EQ (val, Qt) ? utf_16_with_bom
申鐃緒申  5287 				    : utf_16_without_bom);
申鐃緒申  5288       val = AREF (attrs, coding_attr_utf_16_endian);
申鐃緒申  5289       CODING_UTF_16_ENDIAN (coding) = (EQ (val, Qbig) ? utf_16_big_endian
申鐃緒申  5290 				       : utf_16_little_endian);
申鐃緒申  5291       CODING_UTF_16_SURROGATE (coding) = 0;
申鐃緒申  5292       coding->detector = detect_coding_utf_16;
申鐃緒申  5293       coding->decoder = decode_coding_utf_16;
申鐃緒申  5294       coding->encoder = encode_coding_utf_16;
申鐃緒申  5295       coding->common_flags
申鐃緒申  5296 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5297       if (CODING_UTF_16_BOM (coding) == utf_16_detect_bom)
申鐃緒申  5298 	coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
申鐃緒申  5299     }
申鐃緒申  5300   else if (EQ (coding_type, Qccl))
申鐃緒申  5301     {
申鐃緒申  5302       coding->detector = detect_coding_ccl;
申鐃緒申  5303       coding->decoder = decode_coding_ccl;
申鐃緒申  5304       coding->encoder = encode_coding_ccl;
申鐃緒申  5305       coding->common_flags
申鐃緒申  5306 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK
申鐃緒申  5307 	    | CODING_REQUIRE_FLUSHING_MASK);
申鐃緒申  5308     }
申鐃緒申  5309   else if (EQ (coding_type, Qemacs_mule))
申鐃緒申  5310     {
申鐃緒申  5311       coding->detector = detect_coding_emacs_mule;
申鐃緒申  5312       coding->decoder = decode_coding_emacs_mule;
申鐃緒申  5313       coding->encoder = encode_coding_emacs_mule;
申鐃緒申  5314       coding->common_flags
申鐃緒申  5315 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5316       if (! NILP (AREF (attrs, coding_attr_emacs_mule_full))
申鐃緒申  5317 	  && ! EQ (CODING_ATTR_CHARSET_LIST (attrs), Vemacs_mule_charset_list))
申鐃緒申  5318 	{
申鐃緒申  5319 	  Lisp_Object tail, safe_charsets;
申鐃緒申  5320 	  int max_charset_id = 0;
申鐃緒申  5321 
申鐃緒申  5322 	  for (tail = Vemacs_mule_charset_list; CONSP (tail);
申鐃緒申  5323 	       tail = XCDR (tail))
申鐃緒申  5324 	    if (max_charset_id < XFASTINT (XCAR (tail)))
申鐃緒申  5325 	      max_charset_id = XFASTINT (XCAR (tail));
申鐃緒申  5326 	  safe_charsets = Fmake_string (make_number (max_charset_id + 1),
申鐃緒申  5327 					make_number (255));
申鐃緒申  5328 	  for (tail = Vemacs_mule_charset_list; CONSP (tail);
申鐃緒申  5329 	       tail = XCDR (tail))
申鐃緒申  5330 	    SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
申鐃緒申  5331 	  coding->max_charset_id = max_charset_id;
申鐃緒申  5332 	  coding->safe_charsets = (char *) SDATA (safe_charsets);
申鐃緒申  5333 	}
申鐃緒申  5334     }
申鐃緒申  5335   else if (EQ (coding_type, Qshift_jis))
申鐃緒申  5336     {
申鐃緒申  5337       coding->detector = detect_coding_sjis;
申鐃緒申  5338       coding->decoder = decode_coding_sjis;
申鐃緒申  5339       coding->encoder = encode_coding_sjis;
申鐃緒申  5340       coding->common_flags
申鐃緒申  5341 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5342     }
申鐃緒申  5343   else if (EQ (coding_type, Qbig5))
申鐃緒申  5344     {
申鐃緒申  5345       coding->detector = detect_coding_big5;
申鐃緒申  5346       coding->decoder = decode_coding_big5;
申鐃緒申  5347       coding->encoder = encode_coding_big5;
申鐃緒申  5348       coding->common_flags
申鐃緒申  5349 	|= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
申鐃緒申  5350     }
申鐃緒申  5351   else				/* EQ (coding_type, Qraw_text) */
申鐃緒申  5352     {
申鐃緒申  5353       coding->detector = NULL;
申鐃緒申  5354       coding->decoder = decode_coding_raw_text;
申鐃緒申  5355       coding->encoder = encode_coding_raw_text;
申鐃緒申  5356       if (! EQ (eol_type, Qunix))
申鐃緒申  5357 	{
申鐃緒申  5358 	  coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
申鐃緒申  5359 	  if (! VECTORP (eol_type))
申鐃緒申  5360 	    coding->common_flags |= CODING_REQUIRE_ENCODING_MASK;
申鐃緒申  5361 	}
申鐃緒申  5362 
申鐃緒申  5363     }
申鐃緒申  5364 
申鐃緒申  5365   return;
申鐃緒申  5366 }
申鐃緒申  5367 
申鐃緒申  5368 /* Return a list of charsets supported by CODING.  */
申鐃緒申  5369 
申鐃緒申  5370 Lisp_Object
申鐃緒申  5371 coding_charset_list (coding)
申鐃緒申  5372      struct coding_system *coding;
申鐃緒申  5373 {
申鐃緒申  5374   Lisp_Object attrs, charset_list;
申鐃緒申  5375 
申鐃緒申  5376   CODING_GET_INFO (coding, attrs, charset_list);
申鐃緒申  5377   if (EQ (CODING_ATTR_TYPE (attrs), Qiso_2022))
申鐃緒申  5378     {
申鐃緒申  5379       int flags = XINT (AREF (attrs, coding_attr_iso_flags));
申鐃緒申  5380 
申鐃緒申  5381       if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
申鐃緒申  5382 	charset_list = Viso_2022_charset_list;
申鐃緒申  5383     }
申鐃緒申  5384   else if (EQ (CODING_ATTR_TYPE (attrs), Qemacs_mule))
申鐃緒申  5385     {
申鐃緒申  5386       charset_list = Vemacs_mule_charset_list;
申鐃緒申  5387     }
申鐃緒申  5388   return charset_list;
申鐃緒申  5389 }
申鐃緒申  5390 
申鐃緒申  5391 
申鐃緒申  5392 /* Return raw-text or one of its subsidiaries that has the same
申鐃緒申  5393    eol_type as CODING-SYSTEM.  */
申鐃緒申  5394 
申鐃緒申  5395 Lisp_Object
申鐃緒申  5396 raw_text_coding_system (coding_system)
申鐃緒申  5397      Lisp_Object coding_system;
申鐃緒申  5398 {
申鐃緒申  5399   Lisp_Object spec, attrs;
申鐃緒申  5400   Lisp_Object eol_type, raw_text_eol_type;
申鐃緒申  5401 
申鐃緒申  5402   if (NILP (coding_system))
申鐃緒申  5403     return Qraw_text;
申鐃緒申  5404   spec = CODING_SYSTEM_SPEC (coding_system);
申鐃緒申  5405   attrs = AREF (spec, 0);
申鐃緒申  5406 
申鐃緒申  5407   if (EQ (CODING_ATTR_TYPE (attrs), Qraw_text))
申鐃緒申  5408     return coding_system;
申鐃緒申  5409 
申鐃緒申  5410   eol_type = AREF (spec, 2);
申鐃緒申  5411   if (VECTORP (eol_type))
申鐃緒申  5412     return Qraw_text;
申鐃緒申  5413   spec = CODING_SYSTEM_SPEC (Qraw_text);
申鐃緒申  5414   raw_text_eol_type = AREF (spec, 2);
申鐃緒申  5415   return (EQ (eol_type, Qunix) ? AREF (raw_text_eol_type, 0)
申鐃緒申  5416 	  : EQ (eol_type, Qdos) ? AREF (raw_text_eol_type, 1)
申鐃緒申  5417 	  : AREF (raw_text_eol_type, 2));
申鐃緒申  5418 }
申鐃緒申  5419 
申鐃緒申  5420 
申鐃緒申  5421 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
申鐃緒申  5422    does, return one of the subsidiary that has the same eol-spec as
申鐃緒申  5423    PARENT.  Otherwise, return CODING_SYSTEM.  If PARENT is nil,
申鐃緒申  5424    inherit end-of-line format from the system's setting
申鐃緒申  5425    (system_eol_type).  */
申鐃緒申  5426 
申鐃緒申  5427 Lisp_Object
申鐃緒申  5428 coding_inherit_eol_type (coding_system, parent)
申鐃緒申  5429      Lisp_Object coding_system, parent;
申鐃緒申  5430 {
申鐃緒申  5431   Lisp_Object spec, eol_type;
申鐃緒申  5432 
申鐃緒申  5433   if (NILP (coding_system))
申鐃緒申  5434     coding_system = Qraw_text;
申鐃緒申  5435   spec = CODING_SYSTEM_SPEC (coding_system);
申鐃緒申  5436   eol_type = AREF (spec, 2);
申鐃緒申  5437   if (VECTORP (eol_type))
申鐃緒申  5438     {
申鐃緒申  5439       Lisp_Object parent_eol_type;
申鐃緒申  5440 
申鐃緒申  5441       if (! NILP (parent))
申鐃緒申  5442 	{
申鐃緒申  5443 	  Lisp_Object parent_spec;
申鐃緒申  5444 
申鐃緒申  5445 	  parent_spec = CODING_SYSTEM_SPEC (parent);
申鐃緒申  5446 	  parent_eol_type = AREF (parent_spec, 2);
申鐃緒申  5447 	}
申鐃緒申  5448       else
申鐃緒申  5449 	parent_eol_type = system_eol_type;
申鐃緒申  5450       if (EQ (parent_eol_type, Qunix))
申鐃緒申  5451 	coding_system = AREF (eol_type, 0);
申鐃緒申  5452       else if (EQ (parent_eol_type, Qdos))
申鐃緒申  5453 	coding_system = AREF (eol_type, 1);
申鐃緒申  5454       else if (EQ (parent_eol_type, Qmac))
申鐃緒申  5455 	coding_system = AREF (eol_type, 2);
申鐃緒申  5456     }
申鐃緒申  5457   return coding_system;
申鐃緒申  5458 }
申鐃緒申  5459 
申鐃緒申  5460 /* Emacs has a mechanism to automatically detect a coding system if it
申鐃緒申  5461    is one of Emacs' internal format, ISO2022, SJIS, and BIG5.  But,
申鐃緒申  5462    it's impossible to distinguish some coding systems accurately
申鐃緒申  5463    because they use the same range of codes.  So, at first, coding
申鐃緒申  5464    systems are categorized into 7, those are:
申鐃緒申  5465 
申鐃緒申  5466    o coding-category-emacs-mule
申鐃緒申  5467 
申鐃緒申  5468    	The category for a coding system which has the same code range
申鐃緒申  5469 	as Emacs' internal format.  Assigned the coding-system (Lisp
申鐃緒申  5470 	symbol) `emacs-mule' by default.
申鐃緒申  5471 
申鐃緒申  5472    o coding-category-sjis
申鐃緒申  5473 
申鐃緒申  5474 	The category for a coding system which has the same code range
申鐃緒申  5475 	as SJIS.  Assigned the coding-system (Lisp
申鐃緒申  5476 	symbol) `japanese-shift-jis' by default.
申鐃緒申  5477 
申鐃緒申  5478    o coding-category-iso-7
申鐃緒申  5479 
申鐃緒申  5480    	The category for a coding system which has the same code range
申鐃緒申  5481 	as ISO2022 of 7-bit environment.  This doesn't use any locking
申鐃緒申  5482 	shift and single shift functions.  This can encode/decode all
申鐃緒申  5483 	charsets.  Assigned the coding-system (Lisp symbol)
申鐃緒申  5484 	`iso-2022-7bit' by default.
申鐃緒申  5485 
申鐃緒申  5486    o coding-category-iso-7-tight
申鐃緒申  5487 
申鐃緒申  5488 	Same as coding-category-iso-7 except that this can
申鐃緒申  5489 	encode/decode only the specified charsets.
申鐃緒申  5490 
申鐃緒申  5491    o coding-category-iso-8-1
申鐃緒申  5492 
申鐃緒申  5493    	The category for a coding system which has the same code range
申鐃緒申  5494 	as ISO2022 of 8-bit environment and graphic plane 1 used only
申鐃緒申  5495 	for DIMENSION1 charset.  This doesn't use any locking shift
申鐃緒申  5496 	and single shift functions.  Assigned the coding-system (Lisp
申鐃緒申  5497 	symbol) `iso-latin-1' by default.
申鐃緒申  5498 
申鐃緒申  5499    o coding-category-iso-8-2
申鐃緒申  5500 
申鐃緒申  5501    	The category for a coding system which has the same code range
申鐃緒申  5502 	as ISO2022 of 8-bit environment and graphic plane 1 used only
申鐃緒申  5503 	for DIMENSION2 charset.  This doesn't use any locking shift
申鐃緒申  5504 	and single shift functions.  Assigned the coding-system (Lisp
申鐃緒申  5505 	symbol) `japanese-iso-8bit' by default.
申鐃緒申  5506 
申鐃緒申  5507    o coding-category-iso-7-else
申鐃緒申  5508 
申鐃緒申  5509    	The category for a coding system which has the same code range
申鐃緒申  5510 	as ISO2022 of 7-bit environemnt but uses locking shift or
申鐃緒申  5511 	single shift functions.  Assigned the coding-system (Lisp
申鐃緒申  5512 	symbol) `iso-2022-7bit-lock' by default.
申鐃緒申  5513 
申鐃緒申  5514    o coding-category-iso-8-else
申鐃緒申  5515 
申鐃緒申  5516    	The category for a coding system which has the same code range
申鐃緒申  5517 	as ISO2022 of 8-bit environemnt but uses locking shift or
申鐃緒申  5518 	single shift functions.  Assigned the coding-system (Lisp
申鐃緒申  5519 	symbol) `iso-2022-8bit-ss2' by default.
申鐃緒申  5520 
申鐃緒申  5521    o coding-category-big5
申鐃緒申  5522 
申鐃緒申  5523    	The category for a coding system which has the same code range
申鐃緒申  5524 	as BIG5.  Assigned the coding-system (Lisp symbol)
申鐃緒申  5525 	`cn-big5' by default.
申鐃緒申  5526 
申鐃緒申  5527    o coding-category-utf-8
申鐃緒申  5528 
申鐃緒申  5529 	The category for a coding system which has the same code range
申鐃緒申  5530 	as UTF-8 (cf. RFC3629).  Assigned the coding-system (Lisp
申鐃緒申  5531 	symbol) `utf-8' by default.
申鐃緒申  5532 
申鐃緒申  5533    o coding-category-utf-16-be
申鐃緒申  5534 
申鐃緒申  5535 	The category for a coding system in which a text has an
申鐃緒申  5536 	Unicode signature (cf. Unicode Standard) in the order of BIG
申鐃緒申  5537 	endian at the head.  Assigned the coding-system (Lisp symbol)
申鐃緒申  5538 	`utf-16-be' by default.
申鐃緒申  5539 
申鐃緒申  5540    o coding-category-utf-16-le
申鐃緒申  5541 
申鐃緒申  5542 	The category for a coding system in which a text has an
申鐃緒申  5543 	Unicode signature (cf. Unicode Standard) in the order of
申鐃緒申  5544 	LITTLE endian at the head.  Assigned the coding-system (Lisp
申鐃緒申  5545 	symbol) `utf-16-le' by default.
申鐃緒申  5546 
申鐃緒申  5547    o coding-category-ccl
申鐃緒申  5548 
申鐃緒申  5549 	The category for a coding system of which encoder/decoder is
申鐃緒申  5550 	written in CCL programs.  The default value is nil, i.e., no
申鐃緒申  5551 	coding system is assigned.
申鐃緒申  5552 
申鐃緒申  5553    o coding-category-binary
申鐃緒申  5554 
申鐃緒申  5555    	The category for a coding system not categorized in any of the
申鐃緒申  5556 	above.  Assigned the coding-system (Lisp symbol)
申鐃緒申  5557 	`no-conversion' by default.
申鐃緒申  5558 
申鐃緒申  5559    Each of them is a Lisp symbol and the value is an actual
申鐃緒申  5560    `coding-system's (this is also a Lisp symbol) assigned by a user.
申鐃緒申  5561    What Emacs does actually is to detect a category of coding system.
申鐃緒申  5562    Then, it uses a `coding-system' assigned to it.  If Emacs can't
申鐃緒申  5563    decide only one possible category, it selects a category of the
申鐃緒申  5564    highest priority.  Priorities of categories are also specified by a
申鐃緒申  5565    user in a Lisp variable `coding-category-list'.
申鐃緒申  5566 
申鐃緒申  5567 */
申鐃緒申  5568 
申鐃緒申  5569 #define EOL_SEEN_NONE	0
申鐃緒申  5570 #define EOL_SEEN_LF	1
申鐃緒申  5571 #define EOL_SEEN_CR	2
申鐃緒申  5572 #define EOL_SEEN_CRLF	4
申鐃緒申  5573 
申鐃緒申  5574 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
申鐃緒申  5575    SOURCE is encoded.  If CATEGORY is one of
申鐃緒申  5576    coding_category_utf_16_XXXX, assume that CR and LF are encoded by
申鐃緒申  5577    two-byte, else they are encoded by one-byte.
申鐃緒申  5578 
申鐃緒申  5579    Return one of EOL_SEEN_XXX.  */
申鐃緒申  5580 
申鐃緒申  5581 #define MAX_EOL_CHECK_COUNT 3
申鐃緒申  5582 
申鐃緒申  5583 static int
申鐃緒申  5584 detect_eol (source, src_bytes, category)
申鐃緒申  5585      const unsigned char *source;
申鐃緒申  5586      EMACS_INT src_bytes;
申鐃緒申  5587      enum coding_category category;
申鐃緒申  5588 {
申鐃緒申  5589   const unsigned char *src = source, *src_end = src + src_bytes;
申鐃緒申  5590   unsigned char c;
申鐃緒申  5591   int total  = 0;
申鐃緒申  5592   int eol_seen = EOL_SEEN_NONE;
申鐃緒申  5593 
申鐃緒申  5594   if ((1 << category) & CATEGORY_MASK_UTF_16)
申鐃緒申  5595     {
申鐃緒申  5596       int msb, lsb;
申鐃緒申  5597 
申鐃緒申  5598       msb = category == (coding_category_utf_16_le
申鐃緒申  5599 			 | coding_category_utf_16_le_nosig);
申鐃緒申  5600       lsb = 1 - msb;
申鐃緒申  5601 
申鐃緒申  5602       while (src + 1 < src_end)
申鐃緒申  5603 	{
申鐃緒申  5604 	  c = src[lsb];
申鐃緒申  5605 	  if (src[msb] == 0 && (c == '\n' || c == '\r'))
申鐃緒申  5606 	    {
申鐃緒申  5607 	      int this_eol;
申鐃緒申  5608 
申鐃緒申  5609 	      if (c == '\n')
申鐃緒申  5610 		this_eol = EOL_SEEN_LF;
申鐃緒申  5611 	      else if (src + 3 >= src_end
申鐃緒申  5612 		       || src[msb + 2] != 0
申鐃緒申  5613 		       || src[lsb + 2] != '\n')
申鐃緒申  5614 		this_eol = EOL_SEEN_CR;
申鐃緒申  5615 	      else
申鐃緒申  5616 		this_eol = EOL_SEEN_CRLF;
申鐃緒申  5617 
申鐃緒申  5618 	      if (eol_seen == EOL_SEEN_NONE)
申鐃緒申  5619 		/* This is the first end-of-line.  */
申鐃緒申  5620 		eol_seen = this_eol;
申鐃緒申  5621 	      else if (eol_seen != this_eol)
申鐃緒申  5622 		{
申鐃緒申  5623 		  /* The found type is different from what found before.  */
申鐃緒申  5624 		  eol_seen = EOL_SEEN_LF;
申鐃緒申  5625 		  break;
申鐃緒申  5626 		}
申鐃緒申  5627 	      if (++total == MAX_EOL_CHECK_COUNT)
申鐃緒申  5628 		break;
申鐃緒申  5629 	    }
申鐃緒申  5630 	  src += 2;
申鐃緒申  5631 	}
申鐃緒申  5632     }
申鐃緒申  5633   else
申鐃緒申  5634     {
申鐃緒申  5635       while (src < src_end)
申鐃緒申  5636 	{
申鐃緒申  5637 	  c = *src++;
申鐃緒申  5638 	  if (c == '\n' || c == '\r')
申鐃緒申  5639 	    {
申鐃緒申  5640 	      int this_eol;
申鐃緒申  5641 
申鐃緒申  5642 	      if (c == '\n')
申鐃緒申  5643 		this_eol = EOL_SEEN_LF;
申鐃緒申  5644 	      else if (src >= src_end || *src != '\n')
申鐃緒申  5645 		this_eol = EOL_SEEN_CR;
申鐃緒申  5646 	      else
申鐃緒申  5647 		this_eol = EOL_SEEN_CRLF, src++;
申鐃緒申  5648 
申鐃緒申  5649 	      if (eol_seen == EOL_SEEN_NONE)
申鐃緒申  5650 		/* This is the first end-of-line.  */
申鐃緒申  5651 		eol_seen = this_eol;
申鐃緒申  5652 	      else if (eol_seen != this_eol)
申鐃緒申  5653 		{
申鐃緒申  5654 		  /* The found type is different from what found before.  */
申鐃緒申  5655 		  eol_seen = EOL_SEEN_LF;
申鐃緒申  5656 		  break;
申鐃緒申  5657 		}
申鐃緒申  5658 	      if (++total == MAX_EOL_CHECK_COUNT)
申鐃緒申  5659 		break;
申鐃緒申  5660 	    }
申鐃緒申  5661 	}
申鐃緒申  5662     }
申鐃緒申  5663   return eol_seen;
申鐃緒申  5664 }
申鐃緒申  5665 
申鐃緒申  5666 
申鐃緒申  5667 static Lisp_Object
申鐃緒申  5668 adjust_coding_eol_type (coding, eol_seen)
申鐃緒申  5669      struct coding_system *coding;
申鐃緒申  5670      int eol_seen;
申鐃緒申  5671 {
申鐃緒申  5672   Lisp_Object eol_type;
申鐃緒申  5673 
申鐃緒申  5674   eol_type = CODING_ID_EOL_TYPE (coding->id);
申鐃緒申  5675   if (eol_seen & EOL_SEEN_LF)
申鐃緒申  5676     {
申鐃緒申  5677       coding->id = CODING_SYSTEM_ID (AREF (eol_type, 0));
申鐃緒申  5678       eol_type = Qunix;
申鐃緒申  5679     }
申鐃緒申  5680   else if (eol_seen & EOL_SEEN_CRLF)
申鐃緒申  5681     {
申鐃緒申  5682       coding->id = CODING_SYSTEM_ID (AREF (eol_type, 1));
申鐃緒申  5683       eol_type = Qdos;
申鐃緒申  5684     }
申鐃緒申  5685   else if (eol_seen & EOL_SEEN_CR)
申鐃緒申  5686     {
申鐃緒申  5687       coding->id = CODING_SYSTEM_ID (AREF (eol_type, 2));
申鐃緒申  5688       eol_type = Qmac;
申鐃緒申  5689     }
申鐃緒申  5690   return eol_type;
申鐃緒申  5691 }
申鐃緒申  5692 
申鐃緒申  5693 /* Detect how a text specified in CODING is encoded.  If a coding
申鐃緒申  5694    system is detected, update fields of CODING by the detected coding
申鐃緒申  5695    system.  */
申鐃緒申  5696 
申鐃緒申  5697 void
申鐃緒申  5698 detect_coding (coding)
申鐃緒申  5699      struct coding_system *coding;
申鐃緒申  5700 {
申鐃緒申  5701   const unsigned char *src, *src_end;
申鐃緒申  5702 
申鐃緒申  5703   coding->consumed = coding->consumed_char = 0;
申鐃緒申  5704   coding->produced = coding->produced_char = 0;
申鐃緒申  5705   coding_set_source (coding);
申鐃緒申  5706 
申鐃緒申  5707   src_end = coding->source + coding->src_bytes;
申鐃緒申  5708 
申鐃緒申  5709   /* If we have not yet decided the text encoding type, detect it
申鐃緒申  5710      now.  */
申鐃緒申  5711   if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding->id)), Qundecided))
申鐃緒申  5712     {
申鐃緒申  5713       int c, i;
申鐃緒申  5714       struct coding_detection_info detect_info;
申鐃緒申  5715       int null_byte_found = 0, eight_bit_found = 0;
申鐃緒申  5716 
申鐃緒申  5717       detect_info.checked = detect_info.found = detect_info.rejected = 0;
申鐃緒申  5718       coding->head_ascii = -1;
申鐃緒申  5719       for (src = coding->source; src < src_end; src++)
申鐃緒申  5720 	{
申鐃緒申  5721 	  c = *src;
申鐃緒申  5722 	  if (c & 0x80)
申鐃緒申  5723 	    {
申鐃緒申  5724 	      eight_bit_found = 1;
申鐃緒申  5725 	      if (coding->head_ascii < 0)
申鐃緒申  5726 		coding->head_ascii = src - coding->source;
申鐃緒申  5727 	      if (null_byte_found)
申鐃緒申  5728 		break;
申鐃緒申  5729 	    }
申鐃緒申  5730 	  else if (c < 0x20)
申鐃緒申  5731 	    {
申鐃緒申  5732 	      if ((c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
申鐃緒申  5733 		  && ! inhibit_iso_escape_detection
申鐃緒申  5734 		  && ! detect_info.checked)
申鐃緒申  5735 		{
申鐃緒申  5736 		  if (coding->head_ascii < 0)
申鐃緒申  5737 		    coding->head_ascii = src - coding->source;
申鐃緒申  5738 		  if (detect_coding_iso_2022 (coding, &detect_info))
申鐃緒申  5739 		    {
申鐃緒申  5740 		      /* We have scanned the whole data.  */
申鐃緒申  5741 		      if (! (detect_info.rejected & CATEGORY_MASK_ISO_7_ELSE))
申鐃緒申  5742 			/* We didn't find an 8-bit code.  We may have
申鐃緒申  5743 			   found a null-byte, but it's very rare that
申鐃緒申  5744 			   a binary file confirm to ISO-2022.  */
申鐃緒申  5745 			src = src_end;
申鐃緒申  5746 		      break;
申鐃緒申  5747 		    }
申鐃緒申  5748 		}
申鐃緒申  5749 	      else if (! c)
申鐃緒申  5750 		{
申鐃緒申  5751 		  null_byte_found = 1;
申鐃緒申  5752 		  if (eight_bit_found)
申鐃緒申  5753 		    break;
申鐃緒申  5754 		}
申鐃緒申  5755 	    }
申鐃緒申  5756 	}
申鐃緒申  5757       if (coding->head_ascii < 0)
申鐃緒申  5758 	coding->head_ascii = src - coding->source;
申鐃緒申  5759 
申鐃緒申  5760       if (null_byte_found || eight_bit_found
申鐃緒申  5761 	  || coding->head_ascii < coding->src_bytes
申鐃緒申  5762 	  || detect_info.found)
申鐃緒申  5763 	{
申鐃緒申  5764 	  enum coding_category category;
申鐃緒申  5765 	  struct coding_system *this;
申鐃緒申  5766 
申鐃緒申  5767 	  if (coding->head_ascii == coding->src_bytes)
申鐃緒申  5768 	    /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings.  */
申鐃緒申  5769 	    for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  5770 	      {
申鐃緒申  5771 		category = coding_priorities[i];
申鐃緒申  5772 		this = coding_categories + category;
申鐃緒申  5773 		if (detect_info.found & (1 << category))
申鐃緒申  5774 		  break;
申鐃緒申  5775 	      }
申鐃緒申  5776 	  else
申鐃緒申  5777 	    {
申鐃緒申  5778 	      if (null_byte_found)
申鐃緒申  5779 		{
申鐃緒申  5780 		  detect_info.checked |= ~CATEGORY_MASK_UTF_16;
申鐃緒申  5781 		  detect_info.rejected |= ~CATEGORY_MASK_UTF_16;
申鐃緒申  5782 		}
申鐃緒申  5783 	      for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  5784 		{
申鐃緒申  5785 		  category = coding_priorities[i];
申鐃緒申  5786 		  this = coding_categories + category;
申鐃緒申  5787 		  if (this->id < 0)
申鐃緒申  5788 		    {
申鐃緒申  5789 		      /* No coding system of this category is defined.  */
申鐃緒申  5790 		      detect_info.rejected |= (1 << category);
申鐃緒申  5791 		    }
申鐃緒申  5792 		  else if (category >= coding_category_raw_text)
申鐃緒申  5793 		    continue;
申鐃緒申  5794 		  else if (detect_info.checked & (1 << category))
申鐃緒申  5795 		    {
申鐃緒申  5796 		      if (detect_info.found & (1 << category))
申鐃緒申  5797 			break;
申鐃緒申  5798 		    }
申鐃緒申  5799 		  else if ((*(this->detector)) (coding, &detect_info)
申鐃緒申  5800 			   && detect_info.found & (1 << category))
申鐃緒申  5801 		    {
申鐃緒申  5802 		      if (category == coding_category_utf_16_auto)
申鐃緒申  5803 			{
申鐃緒申  5804 			  if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
申鐃緒申  5805 			    category = coding_category_utf_16_le;
申鐃緒申  5806 			  else
申鐃緒申  5807 			    category = coding_category_utf_16_be;
申鐃緒申  5808 			}
申鐃緒申  5809 		      break;
申鐃緒申  5810 		    }
申鐃緒申  5811 		}
申鐃緒申  5812 
申鐃緒申  5813 	      if (i < coding_category_raw_text)
申鐃緒申  5814 		setup_coding_system (CODING_ID_NAME (this->id), coding);
申鐃緒申  5815 	      else if (null_byte_found)
申鐃緒申  5816 		setup_coding_system (Qno_conversion, coding);
申鐃緒申  5817 	      else if ((detect_info.rejected & CATEGORY_MASK_ANY)
申鐃緒申  5818 		       == CATEGORY_MASK_ANY)
申鐃緒申  5819 		setup_coding_system (Qraw_text, coding);
申鐃緒申  5820 	      else if (detect_info.rejected)
申鐃緒申  5821 		for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  5822 		  if (! (detect_info.rejected & (1 << coding_priorities[i])))
申鐃緒申  5823 		    {
申鐃緒申  5824 		      this = coding_categories + coding_priorities[i];
申鐃緒申  5825 		      setup_coding_system (CODING_ID_NAME (this->id), coding);
申鐃緒申  5826 		      break;
申鐃緒申  5827 		    }
申鐃緒申  5828 	    }
申鐃緒申  5829 	}
申鐃緒申  5830     }
申鐃緒申  5831   else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
申鐃緒申  5832 	   == coding_category_utf_16_auto)
申鐃緒申  5833     {
申鐃緒申  5834       Lisp_Object coding_systems;
申鐃緒申  5835       struct coding_detection_info detect_info;
申鐃緒申  5836 
申鐃緒申  5837       coding_systems
申鐃緒申  5838 	= AREF (CODING_ID_ATTRS (coding->id), coding_attr_utf_16_bom);
申鐃緒申  5839       detect_info.found = detect_info.rejected = 0;
申鐃緒申  5840       if (CONSP (coding_systems)
申鐃緒申  5841 	  && detect_coding_utf_16 (coding, &detect_info))
申鐃緒申  5842 	{
申鐃緒申  5843 	  if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
申鐃緒申  5844 	    setup_coding_system (XCAR (coding_systems), coding);
申鐃緒申  5845 	  else if (detect_info.found & CATEGORY_MASK_UTF_16_BE)
申鐃緒申  5846 	    setup_coding_system (XCDR (coding_systems), coding);
申鐃緒申  5847 	}
申鐃緒申  5848     }
申鐃緒申  5849 }
申鐃緒申  5850 
申鐃緒申  5851 
申鐃緒申  5852 static void
申鐃緒申  5853 decode_eol (coding)
申鐃緒申  5854      struct coding_system *coding;
申鐃緒申  5855 {
申鐃緒申  5856   Lisp_Object eol_type;
申鐃緒申  5857   unsigned char *p, *pbeg, *pend;
申鐃緒申  5858 
申鐃緒申  5859   eol_type = CODING_ID_EOL_TYPE (coding->id);
申鐃緒申  5860   if (EQ (eol_type, Qunix))
申鐃緒申  5861     return;
申鐃緒申  5862 
申鐃緒申  5863   if (NILP (coding->dst_object))
申鐃緒申  5864     pbeg = coding->destination;
申鐃緒申  5865   else
申鐃緒申  5866     pbeg = BYTE_POS_ADDR (coding->dst_pos_byte);
申鐃緒申  5867   pend = pbeg + coding->produced;
申鐃緒申  5868 
申鐃緒申  5869   if (VECTORP (eol_type))
申鐃緒申  5870     {
申鐃緒申  5871       int eol_seen = EOL_SEEN_NONE;
申鐃緒申  5872 
申鐃緒申  5873       for (p = pbeg; p < pend; p++)
申鐃緒申  5874 	{
申鐃緒申  5875 	  if (*p == '\n')
申鐃緒申  5876 	    eol_seen |= EOL_SEEN_LF;
申鐃緒申  5877 	  else if (*p == '\r')
申鐃緒申  5878 	    {
申鐃緒申  5879 	      if (p + 1 < pend && *(p + 1) == '\n')
申鐃緒申  5880 		{
申鐃緒申  5881 		  eol_seen |= EOL_SEEN_CRLF;
申鐃緒申  5882 		  p++;
申鐃緒申  5883 		}
申鐃緒申  5884 	      else
申鐃緒申  5885 		eol_seen |= EOL_SEEN_CR;
申鐃緒申  5886 	    }
申鐃緒申  5887 	}
申鐃緒申  5888       if (eol_seen != EOL_SEEN_NONE
申鐃緒申  5889 	  && eol_seen != EOL_SEEN_LF
申鐃緒申  5890 	  && eol_seen != EOL_SEEN_CRLF
申鐃緒申  5891 	  && eol_seen != EOL_SEEN_CR)
申鐃緒申  5892 	eol_seen = EOL_SEEN_LF;
申鐃緒申  5893       if (eol_seen != EOL_SEEN_NONE)
申鐃緒申  5894 	eol_type = adjust_coding_eol_type (coding, eol_seen);
申鐃緒申  5895     }
申鐃緒申  5896 
申鐃緒申  5897   if (EQ (eol_type, Qmac))
申鐃緒申  5898     {
申鐃緒申  5899       for (p = pbeg; p < pend; p++)
申鐃緒申  5900 	if (*p == '\r')
申鐃緒申  5901 	  *p = '\n';
申鐃緒申  5902     }
申鐃緒申  5903   else if (EQ (eol_type, Qdos))
申鐃緒申  5904     {
申鐃緒申  5905       int n = 0;
申鐃緒申  5906 
申鐃緒申  5907       if (NILP (coding->dst_object))
申鐃緒申  5908 	{
申鐃緒申  5909 	  /* Start deleting '\r' from the tail to minimize the memory
申鐃緒申  5910 	     movement.  */
申鐃緒申  5911 	  for (p = pend - 2; p >= pbeg; p--)
申鐃緒申  5912 	    if (*p == '\r')
申鐃緒申  5913 	      {
申鐃緒申  5914 		safe_bcopy ((char *) (p + 1), (char *) p, pend-- - p - 1);
申鐃緒申  5915 		n++;
申鐃緒申  5916 	      }
申鐃緒申  5917 	}
申鐃緒申  5918       else
申鐃緒申  5919 	{
申鐃緒申  5920 	  int pos_byte = coding->dst_pos_byte;
申鐃緒申  5921 	  int pos = coding->dst_pos;
申鐃緒申  5922 	  int pos_end = pos + coding->produced_char - 1;
申鐃緒申  5923 
申鐃緒申  5924 	  while (pos < pos_end)
申鐃緒申  5925 	    {
申鐃緒申  5926 	      p = BYTE_POS_ADDR (pos_byte);
申鐃緒申  5927 	      if (*p == '\r' && p[1] == '\n')
申鐃緒申  5928 		{
申鐃緒申  5929 		  del_range_2 (pos, pos_byte, pos + 1, pos_byte + 1, 0);
申鐃緒申  5930 		  n++;
申鐃緒申  5931 		  pos_end--;
申鐃緒申  5932 		}
申鐃緒申  5933 	      pos++;
申鐃緒申  5934 	      if (coding->dst_multibyte)
申鐃緒申  5935 		pos_byte += BYTES_BY_CHAR_HEAD (*p);
申鐃緒申  5936 	      else
申鐃緒申  5937 		pos_byte++;
申鐃緒申  5938 	    }
申鐃緒申  5939 	}
申鐃緒申  5940       coding->produced -= n;
申鐃緒申  5941       coding->produced_char -= n;
申鐃緒申  5942     }
申鐃緒申  5943 }
申鐃緒申  5944 
申鐃緒申  5945 
申鐃緒申  5946 /* Return a translation table (or list of them) from coding system
申鐃緒申  5947    attribute vector ATTRS for encoding (ENCODEP is nonzero) or
申鐃緒申  5948    decoding (ENCODEP is zero). */
申鐃緒申  5949 
申鐃緒申  5950 static Lisp_Object
申鐃緒申  5951 get_translation_table (attrs, encodep, max_lookup)
申鐃緒申  5952      Lisp_Object attrs;
申鐃緒申  5953      int encodep, *max_lookup;
申鐃緒申  5954 {
申鐃緒申  5955   Lisp_Object standard, translation_table;
申鐃緒申  5956   Lisp_Object val;
申鐃緒申  5957 
申鐃緒申  5958   if (encodep)
申鐃緒申  5959     translation_table = CODING_ATTR_ENCODE_TBL (attrs),
申鐃緒申  5960       standard = Vstandard_translation_table_for_encode;
申鐃緒申  5961   else
申鐃緒申  5962     translation_table = CODING_ATTR_DECODE_TBL (attrs),
申鐃緒申  5963       standard = Vstandard_translation_table_for_decode;
申鐃緒申  5964   if (NILP (translation_table))
申鐃緒申  5965     translation_table = standard;
申鐃緒申  5966   else
申鐃緒申  5967     {
申鐃緒申  5968       if (SYMBOLP (translation_table))
申鐃緒申  5969 	translation_table = Fget (translation_table, Qtranslation_table);
申鐃緒申  5970       else if (CONSP (translation_table))
申鐃緒申  5971 	{
申鐃緒申  5972 	  translation_table = Fcopy_sequence (translation_table);
申鐃緒申  5973 	  for (val = translation_table; CONSP (val); val = XCDR (val))
申鐃緒申  5974 	    if (SYMBOLP (XCAR (val)))
申鐃緒申  5975 	      XSETCAR (val, Fget (XCAR (val), Qtranslation_table));
申鐃緒申  5976 	}
申鐃緒申  5977       if (CHAR_TABLE_P (standard))
申鐃緒申  5978 	{
申鐃緒申  5979 	  if (CONSP (translation_table))
申鐃緒申  5980 	    translation_table = nconc2 (translation_table,
申鐃緒申  5981 					Fcons (standard, Qnil));
申鐃緒申  5982 	  else
申鐃緒申  5983 	    translation_table = Fcons (translation_table,
申鐃緒申  5984 				       Fcons (standard, Qnil));
申鐃緒申  5985 	}
申鐃緒申  5986     }
申鐃緒申  5987 
申鐃緒申  5988   if (max_lookup)
申鐃緒申  5989     {
申鐃緒申  5990       *max_lookup = 1;
申鐃緒申  5991       if (CHAR_TABLE_P (translation_table)
申鐃緒申  5992 	  && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table)) > 1)
申鐃緒申  5993 	{
申鐃緒申  5994 	  val = XCHAR_TABLE (translation_table)->extras[1];
申鐃緒申  5995 	  if (NATNUMP (val) && *max_lookup < XFASTINT (val))
申鐃緒申  5996 	    *max_lookup = XFASTINT (val);
申鐃緒申  5997 	}
申鐃緒申  5998       else if (CONSP (translation_table))
申鐃緒申  5999 	{
申鐃緒申  6000 	  Lisp_Object tail, val;
申鐃緒申  6001 
申鐃緒申  6002 	  for (tail = translation_table; CONSP (tail); tail = XCDR (tail))
申鐃緒申  6003 	    if (CHAR_TABLE_P (XCAR (tail))
申鐃緒申  6004 		&& CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail))) > 1)
申鐃緒申  6005 	      {
申鐃緒申  6006 		val = XCHAR_TABLE (XCAR (tail))->extras[1];
申鐃緒申  6007 		if (NATNUMP (val) && *max_lookup < XFASTINT (val))
申鐃緒申  6008 		  *max_lookup = XFASTINT (val);
申鐃緒申  6009 	      }
申鐃緒申  6010 	}
申鐃緒申  6011     }
申鐃緒申  6012   return translation_table;
申鐃緒申  6013 }
申鐃緒申  6014 
申鐃緒申  6015 #define LOOKUP_TRANSLATION_TABLE(table, c, trans)		\
申鐃緒申  6016   do {								\
申鐃緒申  6017     trans = Qnil;						\
申鐃緒申  6018     if (CHAR_TABLE_P (table))					\
申鐃緒申  6019       {								\
申鐃緒申  6020 	trans = CHAR_TABLE_REF (table, c);			\
申鐃緒申  6021 	if (CHARACTERP (trans))					\
申鐃緒申  6022 	  c = XFASTINT (trans), trans = Qnil;			\
申鐃緒申  6023       }								\
申鐃緒申  6024     else if (CONSP (table))					\
申鐃緒申  6025       {								\
申鐃緒申  6026 	Lisp_Object tail;					\
申鐃緒申  6027 								\
申鐃緒申  6028 	for (tail = table; CONSP (tail); tail = XCDR (tail))	\
申鐃緒申  6029 	  if (CHAR_TABLE_P (XCAR (tail)))			\
申鐃緒申  6030 	    {							\
申鐃緒申  6031 	      trans = CHAR_TABLE_REF (XCAR (tail), c);		\
申鐃緒申  6032 	      if (CHARACTERP (trans))				\
申鐃緒申  6033 		c = XFASTINT (trans), trans = Qnil;		\
申鐃緒申  6034 	      else if (! NILP (trans))				\
申鐃緒申  6035 		break;						\
申鐃緒申  6036 	    }							\
申鐃緒申  6037       }								\
申鐃緒申  6038   } while (0)
申鐃緒申  6039 
申鐃緒申  6040 
申鐃緒申  6041 static Lisp_Object
申鐃緒申  6042 get_translation (val, buf, buf_end, last_block, from_nchars, to_nchars)
申鐃緒申  6043      Lisp_Object val;
申鐃緒申  6044      int *buf, *buf_end;
申鐃緒申  6045      int last_block;
申鐃緒申  6046      int *from_nchars, *to_nchars;
申鐃緒申  6047 {
申鐃緒申  6048   /* VAL is TO or (([FROM-CHAR ...] .  TO) ...) where TO is TO-CHAR or
申鐃緒申  6049      [TO-CHAR ...].  */
申鐃緒申  6050   if (CONSP (val))
申鐃緒申  6051     {
申鐃緒申  6052       Lisp_Object from, tail;
申鐃緒申  6053       int i, len;
申鐃緒申  6054 
申鐃緒申  6055       for (tail = val; CONSP (tail); tail = XCDR (tail))
申鐃緒申  6056 	{
申鐃緒申  6057 	  val = XCAR (tail);
申鐃緒申  6058 	  from = XCAR (val);
申鐃緒申  6059 	  len = ASIZE (from);
申鐃緒申  6060 	  for (i = 0; i < len; i++)
申鐃緒申  6061 	    {
申鐃緒申  6062 	      if (buf + i == buf_end)
申鐃緒申  6063 		{
申鐃緒申  6064 		  if (! last_block)
申鐃緒申  6065 		    return Qt;
申鐃緒申  6066 		  break;
申鐃緒申  6067 		}
申鐃緒申  6068 	      if (XINT (AREF (from, i)) != buf[i])
申鐃緒申  6069 		break;
申鐃緒申  6070 	    }
申鐃緒申  6071 	  if (i == len)
申鐃緒申  6072 	    {
申鐃緒申  6073 	      val = XCDR (val);
申鐃緒申  6074 	      *from_nchars = len;
申鐃緒申  6075 	      break;
申鐃緒申  6076 	    }
申鐃緒申  6077 	}
申鐃緒申  6078       if (! CONSP (tail))
申鐃緒申  6079 	return Qnil;
申鐃緒申  6080     }
申鐃緒申  6081   if (VECTORP (val))
申鐃緒申  6082     *buf = XINT (AREF (val, 0)), *to_nchars = ASIZE (val);
申鐃緒申  6083   else
申鐃緒申  6084     *buf = XINT (val);
申鐃緒申  6085   return val;
申鐃緒申  6086 }
申鐃緒申  6087 
申鐃緒申  6088 
申鐃緒申  6089 static int
申鐃緒申  6090 produce_chars (coding, translation_table, last_block)
申鐃緒申  6091      struct coding_system *coding;
申鐃緒申  6092      Lisp_Object translation_table;
申鐃緒申  6093      int last_block;
申鐃緒申  6094 {
申鐃緒申  6095   unsigned char *dst = coding->destination + coding->produced;
申鐃緒申  6096   unsigned char *dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  6097   EMACS_INT produced;
申鐃緒申  6098   EMACS_INT produced_chars = 0;
申鐃緒申  6099   int carryover = 0;
申鐃緒申  6100 
申鐃緒申  6101   if (! coding->chars_at_source)
申鐃緒申  6102     {
申鐃緒申  6103       /* Source characters are in coding->charbuf.  */
申鐃緒申  6104       int *buf = coding->charbuf;
申鐃緒申  6105       int *buf_end = buf + coding->charbuf_used;
申鐃緒申  6106 
申鐃緒申  6107       if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6108 	{
申鐃緒申  6109 	  coding_set_source (coding);
申鐃緒申  6110 	  dst_end = ((unsigned char *) coding->source) + coding->consumed;
申鐃緒申  6111 	}
申鐃緒申  6112 
申鐃緒申  6113       while (buf < buf_end)
申鐃緒申  6114 	{
申鐃緒申  6115 	  int c = *buf, i;
申鐃緒申  6116 
申鐃緒申  6117 	  if (c >= 0)
申鐃緒申  6118 	    {
申鐃緒申  6119 	      int from_nchars = 1, to_nchars = 1;
申鐃緒申  6120 	      Lisp_Object trans = Qnil;
申鐃緒申  6121 
申鐃緒申  6122 	      LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
申鐃緒申  6123 	      if (! NILP (trans))
申鐃緒申  6124 		{
申鐃緒申  6125 		  trans = get_translation (trans, buf, buf_end, last_block,
申鐃緒申  6126 					   &from_nchars, &to_nchars);
申鐃緒申  6127 		  if (EQ (trans, Qt))
申鐃緒申  6128 		    break;
申鐃緒申  6129 		  c = *buf;
申鐃緒申  6130 		}
申鐃緒申  6131 
申鐃緒申  6132 	      if (dst + MAX_MULTIBYTE_LENGTH * to_nchars > dst_end)
申鐃緒申  6133 		{
申鐃緒申  6134 		  dst = alloc_destination (coding,
申鐃緒申  6135 					   buf_end - buf
申鐃緒申  6136 					   + MAX_MULTIBYTE_LENGTH * to_nchars,
申鐃緒申  6137 					   dst);
申鐃緒申  6138 		  if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6139 		    {
申鐃緒申  6140 		      coding_set_source (coding);
申鐃緒申  6141 		      dst_end = ((unsigned char *) coding->source) + coding->consumed;
申鐃緒申  6142 		    }
申鐃緒申  6143 		  else
申鐃緒申  6144 		    dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  6145 		}
申鐃緒申  6146 
申鐃緒申  6147 	      for (i = 0; i < to_nchars; i++)
申鐃緒申  6148 		{
申鐃緒申  6149 		  if (i > 0)
申鐃緒申  6150 		    c = XINT (AREF (trans, i));
申鐃緒申  6151 		  if (coding->dst_multibyte
申鐃緒申  6152 		      || ! CHAR_BYTE8_P (c))
申鐃緒申  6153 		    CHAR_STRING_ADVANCE_NO_UNIFY (c, dst);
申鐃緒申  6154 		  else
申鐃緒申  6155 		    *dst++ = CHAR_TO_BYTE8 (c);
申鐃緒申  6156 		}
申鐃緒申  6157 	      produced_chars += to_nchars;
申鐃緒申  6158 	      *buf++ = to_nchars;
申鐃緒申  6159 	      while (--from_nchars > 0)
申鐃緒申  6160 		*buf++ = 0;
申鐃緒申  6161 	    }
申鐃緒申  6162 	  else
申鐃緒申  6163 	    /* This is an annotation datum.  (-C) is the length.  */
申鐃緒申  6164 	    buf += -c;
申鐃緒申  6165 	}
申鐃緒申  6166       carryover = buf_end - buf;
申鐃緒申  6167     }
申鐃緒申  6168   else
申鐃緒申  6169     {
申鐃緒申  6170       /* Source characters are at coding->source.  */
申鐃緒申  6171       const unsigned char *src = coding->source;
申鐃緒申  6172       const unsigned char *src_end = src + coding->consumed;
申鐃緒申  6173 
申鐃緒申  6174       if (EQ (coding->dst_object, coding->src_object))
申鐃緒申  6175 	dst_end = (unsigned char *) src;
申鐃緒申  6176       if (coding->src_multibyte != coding->dst_multibyte)
申鐃緒申  6177 	{
申鐃緒申  6178 	  if (coding->src_multibyte)
申鐃緒申  6179 	    {
申鐃緒申  6180 	      int multibytep = 1;
申鐃緒申  6181 	      EMACS_INT consumed_chars;
申鐃緒申  6182 
申鐃緒申  6183 	      while (1)
申鐃緒申  6184 		{
申鐃緒申  6185 		  const unsigned char *src_base = src;
申鐃緒申  6186 		  int c;
申鐃緒申  6187 
申鐃緒申  6188 		  ONE_MORE_BYTE (c);
申鐃緒申  6189 		  if (dst == dst_end)
申鐃緒申  6190 		    {
申鐃緒申  6191 		      if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6192 			dst_end = (unsigned char *) src;
申鐃緒申  6193 		      if (dst == dst_end)
申鐃緒申  6194 			{
申鐃緒申  6195 			  EMACS_INT offset = src - coding->source;
申鐃緒申  6196 
申鐃緒申  6197 			  dst = alloc_destination (coding, src_end - src + 1,
申鐃緒申  6198 						   dst);
申鐃緒申  6199 			  dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  6200 			  coding_set_source (coding);
申鐃緒申  6201 			  src = coding->source + offset;
申鐃緒申  6202 			  src_end = coding->source + coding->src_bytes;
申鐃緒申  6203 			  if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6204 			    dst_end = (unsigned char *) src;
申鐃緒申  6205 			}
申鐃緒申  6206 		    }
申鐃緒申  6207 		  *dst++ = c;
申鐃緒申  6208 		  produced_chars++;
申鐃緒申  6209 		}
申鐃緒申  6210 	    no_more_source:
申鐃緒申  6211 	      ;
申鐃緒申  6212 	    }
申鐃緒申  6213 	  else
申鐃緒申  6214 	    while (src < src_end)
申鐃緒申  6215 	      {
申鐃緒申  6216 		int multibytep = 1;
申鐃緒申  6217 		int c = *src++;
申鐃緒申  6218 
申鐃緒申  6219 		if (dst >= dst_end - 1)
申鐃緒申  6220 		  {
申鐃緒申  6221 		    if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6222 		      dst_end = (unsigned char *) src;
申鐃緒申  6223 		    if (dst >= dst_end - 1)
申鐃緒申  6224 		      {
申鐃緒申  6225 			EMACS_INT offset = src - coding->source;
申鐃緒申  6226 			EMACS_INT more_bytes;
申鐃緒申  6227 
申鐃緒申  6228 			if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6229 			  more_bytes = ((src_end - src) / 2) + 2;
申鐃緒申  6230 			else
申鐃緒申  6231 			  more_bytes = src_end - src + 2;
申鐃緒申  6232 			dst = alloc_destination (coding, more_bytes, dst);
申鐃緒申  6233 			dst_end = coding->destination + coding->dst_bytes;
申鐃緒申  6234 			coding_set_source (coding);
申鐃緒申  6235 			src = coding->source + offset;
申鐃緒申  6236 			src_end = coding->source + coding->src_bytes;
申鐃緒申  6237 			if (EQ (coding->src_object, coding->dst_object))
申鐃緒申  6238 			  dst_end = (unsigned char *) src;
申鐃緒申  6239 		      }
申鐃緒申  6240 		  }
申鐃緒申  6241 		EMIT_ONE_BYTE (c);
申鐃緒申  6242 	      }
申鐃緒申  6243 	}
申鐃緒申  6244       else
申鐃緒申  6245 	{
申鐃緒申  6246 	  if (!EQ (coding->src_object, coding->dst_object))
申鐃緒申  6247 	    {
申鐃緒申  6248 	      EMACS_INT require = coding->src_bytes - coding->dst_bytes;
申鐃緒申  6249 
申鐃緒申  6250 	      if (require > 0)
申鐃緒申  6251 		{
申鐃緒申  6252 		  EMACS_INT offset = src - coding->source;
申鐃緒申  6253 
申鐃緒申  6254 		  dst = alloc_destination (coding, require, dst);
申鐃緒申  6255 		  coding_set_source (coding);
申鐃緒申  6256 		  src = coding->source + offset;
申鐃緒申  6257 		  src_end = coding->source + coding->src_bytes;
申鐃緒申  6258 		}
申鐃緒申  6259 	    }
申鐃緒申  6260 	  produced_chars = coding->consumed_char;
申鐃緒申  6261 	  while (src < src_end)
申鐃緒申  6262 	    *dst++ = *src++;
申鐃緒申  6263 	}
申鐃緒申  6264     }
申鐃緒申  6265 
申鐃緒申  6266   produced = dst - (coding->destination + coding->produced);
申鐃緒申  6267   if (BUFFERP (coding->dst_object) && produced_chars > 0)
申鐃緒申  6268     insert_from_gap (produced_chars, produced);
申鐃緒申  6269   coding->produced += produced;
申鐃緒申  6270   coding->produced_char += produced_chars;
申鐃緒申  6271   return carryover;
申鐃緒申  6272 }
申鐃緒申  6273 
申鐃緒申  6274 /* Compose text in CODING->object according to the annotation data at
申鐃緒申  6275    CHARBUF.  CHARBUF is an array:
申鐃緒申  6276      [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
申鐃緒申  6277  */
申鐃緒申  6278 
申鐃緒申  6279 static INLINE void
申鐃緒申  6280 produce_composition (coding, charbuf, pos)
申鐃緒申  6281      struct coding_system *coding;
申鐃緒申  6282      int *charbuf;
申鐃緒申  6283      EMACS_INT pos;
申鐃緒申  6284 {
申鐃緒申  6285   int len;
申鐃緒申  6286   EMACS_INT to;
申鐃緒申  6287   enum composition_method method;
申鐃緒申  6288   Lisp_Object components;
申鐃緒申  6289 
申鐃緒申  6290   len = -charbuf[0];
申鐃緒申  6291   to = pos + charbuf[2];
申鐃緒申  6292   if (to <= pos)
申鐃緒申  6293     return;
申鐃緒申  6294   method = (enum composition_method) (charbuf[3]);
申鐃緒申  6295 
申鐃緒申  6296   if (method == COMPOSITION_RELATIVE)
申鐃緒申  6297     components = Qnil;
申鐃緒申  6298   else if (method >= COMPOSITION_WITH_RULE
申鐃緒申  6299 	   && method <= COMPOSITION_WITH_RULE_ALTCHARS)
申鐃緒申  6300     {
申鐃緒申  6301       Lisp_Object args[MAX_COMPOSITION_COMPONENTS * 2 - 1];
申鐃緒申  6302       int i;
申鐃緒申  6303 
申鐃緒申  6304       len -= 4;
申鐃緒申  6305       charbuf += 4;
申鐃緒申  6306       for (i = 0; i < len; i++)
申鐃緒申  6307 	{
申鐃緒申  6308 	  args[i] = make_number (charbuf[i]);
申鐃緒申  6309 	  if (charbuf[i] < 0)
申鐃緒申  6310 	    return;
申鐃緒申  6311 	}
申鐃緒申  6312       components = (method == COMPOSITION_WITH_ALTCHARS
申鐃緒申  6313 		    ? Fstring (len, args) : Fvector (len, args));
申鐃緒申  6314     }
申鐃緒申  6315   else
申鐃緒申  6316     return;
申鐃緒申  6317   compose_text (pos, to, components, Qnil, coding->dst_object);
申鐃緒申  6318 }
申鐃緒申  6319 
申鐃緒申  6320 
申鐃緒申  6321 /* Put `charset' property on text in CODING->object according to
申鐃緒申  6322    the annotation data at CHARBUF.  CHARBUF is an array:
申鐃緒申  6323      [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
申鐃緒申  6324  */
申鐃緒申  6325 
申鐃緒申  6326 static INLINE void
申鐃緒申  6327 produce_charset (coding, charbuf, pos)
申鐃緒申  6328      struct coding_system *coding;
申鐃緒申  6329      int *charbuf;
申鐃緒申  6330      EMACS_INT pos;
申鐃緒申  6331 {
申鐃緒申  6332   EMACS_INT from = pos - charbuf[2];
申鐃緒申  6333   struct charset *charset = CHARSET_FROM_ID (charbuf[3]);
申鐃緒申  6334 
申鐃緒申  6335   Fput_text_property (make_number (from), make_number (pos),
申鐃緒申  6336 		      Qcharset, CHARSET_NAME (charset),
申鐃緒申  6337 		      coding->dst_object);
申鐃緒申  6338 }
申鐃緒申  6339 
申鐃緒申  6340 
申鐃緒申  6341 #define CHARBUF_SIZE 0x4000
申鐃緒申  6342 
申鐃緒申  6343 #define ALLOC_CONVERSION_WORK_AREA(coding)				\
申鐃緒申  6344   do {									\
申鐃緒申  6345     int size = CHARBUF_SIZE;;						\
申鐃緒申  6346     									\
申鐃緒申  6347     coding->charbuf = NULL;						\
申鐃緒申  6348     while (size > 1024)							\
申鐃緒申  6349       {									\
申鐃緒申  6350 	coding->charbuf = (int *) alloca (sizeof (int) * size);		\
申鐃緒申  6351 	if (coding->charbuf)						\
申鐃緒申  6352 	  break;							\
申鐃緒申  6353 	size >>= 1;							\
申鐃緒申  6354       }									\
申鐃緒申  6355     if (! coding->charbuf)						\
申鐃緒申  6356       {									\
申鐃緒申  6357 	record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
申鐃緒申  6358 	return coding->result;						\
申鐃緒申  6359       }									\
申鐃緒申  6360     coding->charbuf_size = size;					\
申鐃緒申  6361   } while (0)
申鐃緒申  6362 
申鐃緒申  6363 
申鐃緒申  6364 static void
申鐃緒申  6365 produce_annotation (coding, pos)
申鐃緒申  6366      struct coding_system *coding;
申鐃緒申  6367      EMACS_INT pos;
申鐃緒申  6368 {
申鐃緒申  6369   int *charbuf = coding->charbuf;
申鐃緒申  6370   int *charbuf_end = charbuf + coding->charbuf_used;
申鐃緒申  6371 
申鐃緒申  6372   if (NILP (coding->dst_object))
申鐃緒申  6373     return;
申鐃緒申  6374 
申鐃緒申  6375   while (charbuf < charbuf_end)
申鐃緒申  6376     {
申鐃緒申  6377       if (*charbuf >= 0)
申鐃緒申  6378 	pos += *charbuf++;
申鐃緒申  6379       else
申鐃緒申  6380 	{
申鐃緒申  6381 	  int len = -*charbuf;
申鐃緒申  6382 	  switch (charbuf[1])
申鐃緒申  6383 	    {
申鐃緒申  6384 	    case CODING_ANNOTATE_COMPOSITION_MASK:
申鐃緒申  6385 	      produce_composition (coding, charbuf, pos);
申鐃緒申  6386 	      break;
申鐃緒申  6387 	    case CODING_ANNOTATE_CHARSET_MASK:
申鐃緒申  6388 	      produce_charset (coding, charbuf, pos);
申鐃緒申  6389 	      break;
申鐃緒申  6390 	    default:
申鐃緒申  6391 	      abort ();
申鐃緒申  6392 	    }
申鐃緒申  6393 	  charbuf += len;
申鐃緒申  6394 	}
申鐃緒申  6395     }
申鐃緒申  6396 }
申鐃緒申  6397 
申鐃緒申  6398 /* Decode the data at CODING->src_object into CODING->dst_object.
申鐃緒申  6399    CODING->src_object is a buffer, a string, or nil.
申鐃緒申  6400    CODING->dst_object is a buffer.
申鐃緒申  6401 
申鐃緒申  6402    If CODING->src_object is a buffer, it must be the current buffer.
申鐃緒申  6403    In this case, if CODING->src_pos is positive, it is a position of
申鐃緒申  6404    the source text in the buffer, otherwise, the source text is in the
申鐃緒申  6405    gap area of the buffer, and CODING->src_pos specifies the offset of
申鐃緒申  6406    the text from GPT (which must be the same as PT).  If this is the
申鐃緒申  6407    same buffer as CODING->dst_object, CODING->src_pos must be
申鐃緒申  6408    negative.
申鐃緒申  6409 
申鐃緒申  6410    If CODING->src_object is a string, CODING->src_pos is an index to
申鐃緒申  6411    that string.
申鐃緒申  6412 
申鐃緒申  6413    If CODING->src_object is nil, CODING->source must already point to
申鐃緒申  6414    the non-relocatable memory area.  In this case, CODING->src_pos is
申鐃緒申  6415    an offset from CODING->source.
申鐃緒申  6416 
申鐃緒申  6417    The decoded data is inserted at the current point of the buffer
申鐃緒申  6418    CODING->dst_object.
申鐃緒申  6419 */
申鐃緒申  6420 
申鐃緒申  6421 static int
申鐃緒申  6422 decode_coding (coding)
申鐃緒申  6423      struct coding_system *coding;
申鐃緒申  6424 {
申鐃緒申  6425   Lisp_Object attrs;
申鐃緒申  6426   Lisp_Object undo_list;
申鐃緒申  6427   Lisp_Object translation_table;
申鐃緒申  6428   int carryover;
申鐃緒申  6429   int i;
申鐃緒申  6430 
申鐃緒申  6431   if (BUFFERP (coding->src_object)
申鐃緒申  6432       && coding->src_pos > 0
申鐃緒申  6433       && coding->src_pos < GPT
申鐃緒申  6434       && coding->src_pos + coding->src_chars > GPT)
申鐃緒申  6435     move_gap_both (coding->src_pos, coding->src_pos_byte);
申鐃緒申  6436 
申鐃緒申  6437   undo_list = Qt;
申鐃緒申  6438   if (BUFFERP (coding->dst_object))
申鐃緒申  6439     {
申鐃緒申  6440       if (current_buffer != XBUFFER (coding->dst_object))
申鐃緒申  6441 	set_buffer_internal (XBUFFER (coding->dst_object));
申鐃緒申  6442       if (GPT != PT)
申鐃緒申  6443 	move_gap_both (PT, PT_BYTE);
申鐃緒申  6444       undo_list = current_buffer->undo_list;
申鐃緒申  6445       current_buffer->undo_list = Qt;
申鐃緒申  6446     }
申鐃緒申  6447 
申鐃緒申  6448   coding->consumed = coding->consumed_char = 0;
申鐃緒申  6449   coding->produced = coding->produced_char = 0;
申鐃緒申  6450   coding->chars_at_source = 0;
申鐃緒申  6451   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  6452   coding->errors = 0;
申鐃緒申  6453 
申鐃緒申  6454   ALLOC_CONVERSION_WORK_AREA (coding);
申鐃緒申  6455 
申鐃緒申  6456   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  6457   translation_table = get_translation_table (attrs, 0, NULL);
申鐃緒申  6458 
申鐃緒申  6459   carryover = 0;
申鐃緒申  6460   do
申鐃緒申  6461     {
申鐃緒申  6462       EMACS_INT pos = coding->dst_pos + coding->produced_char;
申鐃緒申  6463 
申鐃緒申  6464       coding_set_source (coding);
申鐃緒申  6465       coding->annotated = 0;
申鐃緒申  6466       coding->charbuf_used = carryover;
申鐃緒申  6467       (*(coding->decoder)) (coding);
申鐃緒申  6468       coding_set_destination (coding);
申鐃緒申  6469       carryover = produce_chars (coding, translation_table, 0);
申鐃緒申  6470       if (coding->annotated)
申鐃緒申  6471 	produce_annotation (coding, pos);
申鐃緒申  6472       for (i = 0; i < carryover; i++)
申鐃緒申  6473 	coding->charbuf[i]
申鐃緒申  6474 	  = coding->charbuf[coding->charbuf_used - carryover + i];
申鐃緒申  6475     }
申鐃緒申  6476   while (coding->consumed < coding->src_bytes
申鐃緒申  6477 	 && (coding->result == CODING_RESULT_SUCCESS
申鐃緒申  6478 	     || coding->result == CODING_RESULT_INVALID_SRC));
申鐃緒申  6479 
申鐃緒申  6480   if (carryover > 0)
申鐃緒申  6481     {
申鐃緒申  6482       coding_set_destination (coding);
申鐃緒申  6483       coding->charbuf_used = carryover;
申鐃緒申  6484       produce_chars (coding, translation_table, 1);
申鐃緒申  6485     }
申鐃緒申  6486 
申鐃緒申  6487   coding->carryover_bytes = 0;
申鐃緒申  6488   if (coding->consumed < coding->src_bytes)
申鐃緒申  6489     {
申鐃緒申  6490       int nbytes = coding->src_bytes - coding->consumed;
申鐃緒申  6491       const unsigned char *src;
申鐃緒申  6492 
申鐃緒申  6493       coding_set_source (coding);
申鐃緒申  6494       coding_set_destination (coding);
申鐃緒申  6495       src = coding->source + coding->consumed;
申鐃緒申  6496 
申鐃緒申  6497       if (coding->mode & CODING_MODE_LAST_BLOCK)
申鐃緒申  6498 	{
申鐃緒申  6499 	  /* Flush out unprocessed data as binary chars.  We are sure
申鐃緒申  6500 	     that the number of data is less than the size of
申鐃緒申  6501 	     coding->charbuf.  */
申鐃緒申  6502 	  coding->charbuf_used = 0;
申鐃緒申  6503 	  while (nbytes-- > 0)
申鐃緒申  6504 	    {
申鐃緒申  6505 	      int c = *src++;
申鐃緒申  6506 
申鐃緒申  6507 	      if (c & 0x80)
申鐃緒申  6508 		c = BYTE8_TO_CHAR (c);
申鐃緒申  6509 	      coding->charbuf[coding->charbuf_used++] = c;
申鐃緒申  6510 	    }
申鐃緒申  6511 	  produce_chars (coding, Qnil, 1);
申鐃緒申  6512 	}
申鐃緒申  6513       else
申鐃緒申  6514 	{
申鐃緒申  6515 	  /* Record unprocessed bytes in coding->carryover.  We are
申鐃緒申  6516 	     sure that the number of data is less than the size of
申鐃緒申  6517 	     coding->carryover.  */
申鐃緒申  6518 	  unsigned char *p = coding->carryover;
申鐃緒申  6519 
申鐃緒申  6520 	  coding->carryover_bytes = nbytes;
申鐃緒申  6521 	  while (nbytes-- > 0)
申鐃緒申  6522 	    *p++ = *src++;
申鐃緒申  6523 	}
申鐃緒申  6524       coding->consumed = coding->src_bytes;
申鐃緒申  6525     }
申鐃緒申  6526 
申鐃緒申  6527   if (! EQ (CODING_ID_EOL_TYPE (coding->id), Qunix))
申鐃緒申  6528     decode_eol (coding);
申鐃緒申  6529   if (BUFFERP (coding->dst_object))
申鐃緒申  6530     {
申鐃緒申  6531       current_buffer->undo_list = undo_list;
申鐃緒申  6532       record_insert (coding->dst_pos, coding->produced_char);
申鐃緒申  6533     }
申鐃緒申  6534   return coding->result;
申鐃緒申  6535 }
申鐃緒申  6536 
申鐃緒申  6537 
申鐃緒申  6538 /* Extract an annotation datum from a composition starting at POS and
申鐃緒申  6539    ending before LIMIT of CODING->src_object (buffer or string), store
申鐃緒申  6540    the data in BUF, set *STOP to a starting position of the next
申鐃緒申  6541    composition (if any) or to LIMIT, and return the address of the
申鐃緒申  6542    next element of BUF.
申鐃緒申  6543 
申鐃緒申  6544    If such an annotation is not found, set *STOP to a starting
申鐃緒申  6545    position of a composition after POS (if any) or to LIMIT, and
申鐃緒申  6546    return BUF.  */
申鐃緒申  6547 
申鐃緒申  6548 static INLINE int *
申鐃緒申  6549 handle_composition_annotation (pos, limit, coding, buf, stop)
申鐃緒申  6550      EMACS_INT pos, limit;
申鐃緒申  6551      struct coding_system *coding;
申鐃緒申  6552      int *buf;
申鐃緒申  6553      EMACS_INT *stop;
申鐃緒申  6554 {
申鐃緒申  6555   EMACS_INT start, end;
申鐃緒申  6556   Lisp_Object prop;
申鐃緒申  6557 
申鐃緒申  6558   if (! find_composition (pos, limit, &start, &end, &prop, coding->src_object)
申鐃緒申  6559       || end > limit)
申鐃緒申  6560     *stop = limit;
申鐃緒申  6561   else if (start > pos)
申鐃緒申  6562     *stop = start;
申鐃緒申  6563   else
申鐃緒申  6564     {
申鐃緒申  6565       if (start == pos)
申鐃緒申  6566 	{
申鐃緒申  6567 	  /* We found a composition.  Store the corresponding
申鐃緒申  6568 	     annotation data in BUF.  */
申鐃緒申  6569 	  int *head = buf;
申鐃緒申  6570 	  enum composition_method method = COMPOSITION_METHOD (prop);
申鐃緒申  6571 	  int nchars = COMPOSITION_LENGTH (prop);
申鐃緒申  6572 
申鐃緒申  6573 	  ADD_COMPOSITION_DATA (buf, nchars, method);
申鐃緒申  6574 	  if (method != COMPOSITION_RELATIVE)
申鐃緒申  6575 	    {
申鐃緒申  6576 	      Lisp_Object components;
申鐃緒申  6577 	      int len, i, i_byte;
申鐃緒申  6578 
申鐃緒申  6579 	      components = COMPOSITION_COMPONENTS (prop);
申鐃緒申  6580 	      if (VECTORP (components))
申鐃緒申  6581 		{
申鐃緒申  6582 		  len = XVECTOR (components)->size;
申鐃緒申  6583 		  for (i = 0; i < len; i++)
申鐃緒申  6584 		    *buf++ = XINT (AREF (components, i));
申鐃緒申  6585 		}
申鐃緒申  6586 	      else if (STRINGP (components))
申鐃緒申  6587 		{
申鐃緒申  6588 		  len = SCHARS (components);
申鐃緒申  6589 		  i = i_byte = 0;
申鐃緒申  6590 		  while (i < len)
申鐃緒申  6591 		    {
申鐃緒申  6592 		      FETCH_STRING_CHAR_ADVANCE (*buf, components, i, i_byte);
申鐃緒申  6593 		      buf++;
申鐃緒申  6594 		    }
申鐃緒申  6595 		}
申鐃緒申  6596 	      else if (INTEGERP (components))
申鐃緒申  6597 		{
申鐃緒申  6598 		  len = 1;
申鐃緒申  6599 		  *buf++ = XINT (components);
申鐃緒申  6600 		}
申鐃緒申  6601 	      else if (CONSP (components))
申鐃緒申  6602 		{
申鐃緒申  6603 		  for (len = 0; CONSP (components);
申鐃緒申  6604 		       len++, components = XCDR (components))
申鐃緒申  6605 		    *buf++ = XINT (XCAR (components));
申鐃緒申  6606 		}
申鐃緒申  6607 	      else
申鐃緒申  6608 		abort ();
申鐃緒申  6609 	      *head -= len;
申鐃緒申  6610 	    }
申鐃緒申  6611 	}
申鐃緒申  6612 
申鐃緒申  6613       if (find_composition (end, limit, &start, &end, &prop,
申鐃緒申  6614 			    coding->src_object)
申鐃緒申  6615 	  && end <= limit)
申鐃緒申  6616 	*stop = start;
申鐃緒申  6617       else
申鐃緒申  6618 	*stop = limit;
申鐃緒申  6619     }
申鐃緒申  6620   return buf;
申鐃緒申  6621 }
申鐃緒申  6622 
申鐃緒申  6623 
申鐃緒申  6624 /* Extract an annotation datum from a text property `charset' at POS of
申鐃緒申  6625    CODING->src_object (buffer of string), store the data in BUF, set
申鐃緒申  6626    *STOP to the position where the value of `charset' property changes
申鐃緒申  6627    (limiting by LIMIT), and return the address of the next element of
申鐃緒申  6628    BUF.
申鐃緒申  6629 
申鐃緒申  6630    If the property value is nil, set *STOP to the position where the
申鐃緒申  6631    property value is non-nil (limiting by LIMIT), and return BUF.  */
申鐃緒申  6632 
申鐃緒申  6633 static INLINE int *
申鐃緒申  6634 handle_charset_annotation (pos, limit, coding, buf, stop)
申鐃緒申  6635      EMACS_INT pos, limit;
申鐃緒申  6636      struct coding_system *coding;
申鐃緒申  6637      int *buf;
申鐃緒申  6638      EMACS_INT *stop;
申鐃緒申  6639 {
申鐃緒申  6640   Lisp_Object val, next;
申鐃緒申  6641   int id;
申鐃緒申  6642 
申鐃緒申  6643   val = Fget_text_property (make_number (pos), Qcharset, coding->src_object);
申鐃緒申  6644   if (! NILP (val) && CHARSETP (val))
申鐃緒申  6645     id = XINT (CHARSET_SYMBOL_ID (val));
申鐃緒申  6646   else
申鐃緒申  6647     id = -1;
申鐃緒申  6648   ADD_CHARSET_DATA (buf, 0, id);
申鐃緒申  6649   next = Fnext_single_property_change (make_number (pos), Qcharset,
申鐃緒申  6650 				       coding->src_object,
申鐃緒申  6651 				       make_number (limit));
申鐃緒申  6652   *stop = XINT (next);
申鐃緒申  6653   return buf;
申鐃緒申  6654 }
申鐃緒申  6655 
申鐃緒申  6656 
申鐃緒申  6657 static void
申鐃緒申  6658 consume_chars (coding, translation_table, max_lookup)
申鐃緒申  6659      struct coding_system *coding;
申鐃緒申  6660      Lisp_Object translation_table;
申鐃緒申  6661      int max_lookup;
申鐃緒申  6662 {
申鐃緒申  6663   int *buf = coding->charbuf;
申鐃緒申  6664   int *buf_end = coding->charbuf + coding->charbuf_size;
申鐃緒申  6665   const unsigned char *src = coding->source + coding->consumed;
申鐃緒申  6666   const unsigned char *src_end = coding->source + coding->src_bytes;
申鐃緒申  6667   EMACS_INT pos = coding->src_pos + coding->consumed_char;
申鐃緒申  6668   EMACS_INT end_pos = coding->src_pos + coding->src_chars;
申鐃緒申  6669   int multibytep = coding->src_multibyte;
申鐃緒申  6670   Lisp_Object eol_type;
申鐃緒申  6671   int c;
申鐃緒申  6672   EMACS_INT stop, stop_composition, stop_charset;
申鐃緒申  6673   int *lookup_buf = NULL;
申鐃緒申  6674 
申鐃緒申  6675   if (! NILP (translation_table))
申鐃緒申  6676     lookup_buf = alloca (sizeof (int) * max_lookup);
申鐃緒申  6677 
申鐃緒申  6678   eol_type = CODING_ID_EOL_TYPE (coding->id);
申鐃緒申  6679   if (VECTORP (eol_type))
申鐃緒申  6680     eol_type = Qunix;
申鐃緒申  6681 
申鐃緒申  6682   /* Note: composition handling is not yet implemented.  */
申鐃緒申  6683   coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
申鐃緒申  6684 
申鐃緒申  6685   if (NILP (coding->src_object))
申鐃緒申  6686     stop = stop_composition = stop_charset = end_pos;
申鐃緒申  6687   else
申鐃緒申  6688     {
申鐃緒申  6689       if (coding->common_flags & CODING_ANNOTATE_COMPOSITION_MASK)
申鐃緒申  6690 	stop = stop_composition = pos;
申鐃緒申  6691       else
申鐃緒申  6692 	stop = stop_composition = end_pos;
申鐃緒申  6693       if (coding->common_flags & CODING_ANNOTATE_CHARSET_MASK)
申鐃緒申  6694 	stop = stop_charset = pos;
申鐃緒申  6695       else
申鐃緒申  6696 	stop_charset = end_pos;
申鐃緒申  6697     }
申鐃緒申  6698 
申鐃緒申  6699   /* Compensate for CRLF and conversion.  */
申鐃緒申  6700   buf_end -= 1 + MAX_ANNOTATION_LENGTH;
申鐃緒申  6701   while (buf < buf_end)
申鐃緒申  6702     {
申鐃緒申  6703       Lisp_Object trans;
申鐃緒申  6704 
申鐃緒申  6705       if (pos == stop)
申鐃緒申  6706 	{
申鐃緒申  6707 	  if (pos == end_pos)
申鐃緒申  6708 	    break;
申鐃緒申  6709 	  if (pos == stop_composition)
申鐃緒申  6710 	    buf = handle_composition_annotation (pos, end_pos, coding,
申鐃緒申  6711 						 buf, &stop_composition);
申鐃緒申  6712 	  if (pos == stop_charset)
申鐃緒申  6713 	    buf = handle_charset_annotation (pos, end_pos, coding,
申鐃緒申  6714 					     buf, &stop_charset);
申鐃緒申  6715 	  stop = (stop_composition < stop_charset
申鐃緒申  6716 		  ? stop_composition : stop_charset);
申鐃緒申  6717 	}
申鐃緒申  6718 
申鐃緒申  6719       if (! multibytep)
申鐃緒申  6720 	{
申鐃緒申  6721 	  EMACS_INT bytes;
申鐃緒申  6722 
申鐃緒申  6723 	  if (coding->encoder == encode_coding_raw_text)
申鐃緒申  6724 	    c = *src++, pos++;
申鐃緒申  6725 	  else if ((bytes = MULTIBYTE_LENGTH (src, src_end)) > 0)
申鐃緒申  6726 	    c = STRING_CHAR_ADVANCE_NO_UNIFY (src), pos += bytes;
申鐃緒申  6727 	  else
申鐃緒申  6728 	    c = BYTE8_TO_CHAR (*src), src++, pos++;
申鐃緒申  6729 	}
申鐃緒申  6730       else
申鐃緒申  6731 	c = STRING_CHAR_ADVANCE_NO_UNIFY (src), pos++;
申鐃緒申  6732       if ((c == '\r') && (coding->mode & CODING_MODE_SELECTIVE_DISPLAY))
申鐃緒申  6733 	c = '\n';
申鐃緒申  6734       if (! EQ (eol_type, Qunix))
申鐃緒申  6735 	{
申鐃緒申  6736 	  if (c == '\n')
申鐃緒申  6737 	    {
申鐃緒申  6738 	      if (EQ (eol_type, Qdos))
申鐃緒申  6739 		*buf++ = '\r';
申鐃緒申  6740 	      else
申鐃緒申  6741 		c = '\r';
申鐃緒申  6742 	    }
申鐃緒申  6743 	}
申鐃緒申  6744 
申鐃緒申  6745       trans = Qnil;
申鐃緒申  6746       LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
申鐃緒申  6747       if (NILP (trans))
申鐃緒申  6748 	*buf++ = c;
申鐃緒申  6749       else
申鐃緒申  6750 	{
申鐃緒申  6751 	  int from_nchars = 1, to_nchars = 1;
申鐃緒申  6752 	  int *lookup_buf_end;
申鐃緒申  6753 	  const unsigned char *p = src;
申鐃緒申  6754 	  int i;
申鐃緒申  6755 
申鐃緒申  6756 	  lookup_buf[0] = c;
申鐃緒申  6757 	  for (i = 1; i < max_lookup && p < src_end; i++)
申鐃緒申  6758 	    lookup_buf[i] = STRING_CHAR_ADVANCE (p);
申鐃緒申  6759 	  lookup_buf_end = lookup_buf + i;
申鐃緒申  6760 	  trans = get_translation (trans, lookup_buf, lookup_buf_end, 1,
申鐃緒申  6761 				   &from_nchars, &to_nchars);
申鐃緒申  6762 	  if (EQ (trans, Qt)
申鐃緒申  6763 	      || buf + to_nchars > buf_end)
申鐃緒申  6764 	    break;
申鐃緒申  6765 	  *buf++ = *lookup_buf;
申鐃緒申  6766 	  for (i = 1; i < to_nchars; i++)
申鐃緒申  6767 	    *buf++ = XINT (AREF (trans, i));
申鐃緒申  6768 	  for (i = 1; i < from_nchars; i++, pos++)
申鐃緒申  6769 	    src += MULTIBYTE_LENGTH_NO_CHECK (src);
申鐃緒申  6770 	}
申鐃緒申  6771     }
申鐃緒申  6772 
申鐃緒申  6773   coding->consumed = src - coding->source;
申鐃緒申  6774   coding->consumed_char = pos - coding->src_pos;
申鐃緒申  6775   coding->charbuf_used = buf - coding->charbuf;
申鐃緒申  6776   coding->chars_at_source = 0;
申鐃緒申  6777 }
申鐃緒申  6778 
申鐃緒申  6779 
申鐃緒申  6780 /* Encode the text at CODING->src_object into CODING->dst_object.
申鐃緒申  6781    CODING->src_object is a buffer or a string.
申鐃緒申  6782    CODING->dst_object is a buffer or nil.
申鐃緒申  6783 
申鐃緒申  6784    If CODING->src_object is a buffer, it must be the current buffer.
申鐃緒申  6785    In this case, if CODING->src_pos is positive, it is a position of
申鐃緒申  6786    the source text in the buffer, otherwise. the source text is in the
申鐃緒申  6787    gap area of the buffer, and coding->src_pos specifies the offset of
申鐃緒申  6788    the text from GPT (which must be the same as PT).  If this is the
申鐃緒申  6789    same buffer as CODING->dst_object, CODING->src_pos must be
申鐃緒申  6790    negative and CODING should not have `pre-write-conversion'.
申鐃緒申  6791 
申鐃緒申  6792    If CODING->src_object is a string, CODING should not have
申鐃緒申  6793    `pre-write-conversion'.
申鐃緒申  6794 
申鐃緒申  6795    If CODING->dst_object is a buffer, the encoded data is inserted at
申鐃緒申  6796    the current point of that buffer.
申鐃緒申  6797 
申鐃緒申  6798    If CODING->dst_object is nil, the encoded data is placed at the
申鐃緒申  6799    memory area specified by CODING->destination.  */
申鐃緒申  6800 
申鐃緒申  6801 static int
申鐃緒申  6802 encode_coding (coding)
申鐃緒申  6803      struct coding_system *coding;
申鐃緒申  6804 {
申鐃緒申  6805   Lisp_Object attrs;
申鐃緒申  6806   Lisp_Object translation_table;
申鐃緒申  6807   int max_lookup;
申鐃緒申  6808 
申鐃緒申  6809   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  6810   if (coding->encoder == encode_coding_raw_text)
申鐃緒申  6811     translation_table = Qnil, max_lookup = 0;
申鐃緒申  6812   else
申鐃緒申  6813     translation_table = get_translation_table (attrs, 1, &max_lookup);
申鐃緒申  6814 
申鐃緒申  6815   if (BUFFERP (coding->dst_object))
申鐃緒申  6816     {
申鐃緒申  6817       set_buffer_internal (XBUFFER (coding->dst_object));
申鐃緒申  6818       coding->dst_multibyte
申鐃緒申  6819 	= ! NILP (current_buffer->enable_multibyte_characters);
申鐃緒申  6820     }
申鐃緒申  6821 
申鐃緒申  6822   coding->consumed = coding->consumed_char = 0;
申鐃緒申  6823   coding->produced = coding->produced_char = 0;
申鐃緒申  6824   record_conversion_result (coding, CODING_RESULT_SUCCESS);
申鐃緒申  6825   coding->errors = 0;
申鐃緒申  6826 
申鐃緒申  6827   ALLOC_CONVERSION_WORK_AREA (coding);
申鐃緒申  6828 
申鐃緒申  6829   do {
申鐃緒申  6830     coding_set_source (coding);
申鐃緒申  6831     consume_chars (coding, translation_table, max_lookup);
申鐃緒申  6832     coding_set_destination (coding);
申鐃緒申  6833     (*(coding->encoder)) (coding);
申鐃緒申  6834   } while (coding->consumed_char < coding->src_chars);
申鐃緒申  6835 
申鐃緒申  6836   if (BUFFERP (coding->dst_object) && coding->produced_char > 0)
申鐃緒申  6837     insert_from_gap (coding->produced_char, coding->produced);
申鐃緒申  6838 
申鐃緒申  6839   return (coding->result);
申鐃緒申  6840 }
申鐃緒申  6841 
申鐃緒申  6842 
申鐃緒申  6843 /* Name (or base name) of work buffer for code conversion.  */
申鐃緒申  6844 static Lisp_Object Vcode_conversion_workbuf_name;
申鐃緒申  6845 
申鐃緒申  6846 /* A working buffer used by the top level conversion.  Once it is
申鐃緒申  6847    created, it is never destroyed.  It has the name
申鐃緒申  6848    Vcode_conversion_workbuf_name.  The other working buffers are
申鐃緒申  6849    destroyed after the use is finished, and their names are modified
申鐃緒申  6850    versions of Vcode_conversion_workbuf_name.  */
申鐃緒申  6851 static Lisp_Object Vcode_conversion_reused_workbuf;
申鐃緒申  6852 
申鐃緒申  6853 /* 1 iff Vcode_conversion_reused_workbuf is already in use.  */
申鐃緒申  6854 static int reused_workbuf_in_use;
申鐃緒申  6855 
申鐃緒申  6856 
申鐃緒申  6857 /* Return a working buffer of code convesion.  MULTIBYTE specifies the
申鐃緒申  6858    multibyteness of returning buffer.  */
申鐃緒申  6859 
申鐃緒申  6860 static Lisp_Object
申鐃緒申  6861 make_conversion_work_buffer (multibyte)
申鐃緒申  6862      int multibyte;
申鐃緒申  6863 {
申鐃緒申  6864   Lisp_Object name, workbuf;
申鐃緒申  6865   struct buffer *current;
申鐃緒申  6866 
申鐃緒申  6867   if (reused_workbuf_in_use++)
申鐃緒申  6868     {
申鐃緒申  6869       name = Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name, Qnil);
申鐃緒申  6870       workbuf = Fget_buffer_create (name);
申鐃緒申  6871     }
申鐃緒申  6872   else
申鐃緒申  6873     {
申鐃緒申  6874       name = Vcode_conversion_workbuf_name;
申鐃緒申  6875       workbuf = Fget_buffer_create (name);
申鐃緒申  6876       if (NILP (Vcode_conversion_reused_workbuf))
申鐃緒申  6877 	Vcode_conversion_reused_workbuf = workbuf;
申鐃緒申  6878     }
申鐃緒申  6879   current = current_buffer;
申鐃緒申  6880   set_buffer_internal (XBUFFER (workbuf));
申鐃緒申  6881   Ferase_buffer ();
申鐃緒申  6882   current_buffer->undo_list = Qt;
申鐃緒申  6883   current_buffer->enable_multibyte_characters = multibyte ? Qt : Qnil;
申鐃緒申  6884   set_buffer_internal (current);
申鐃緒申  6885   return workbuf;
申鐃緒申  6886 }
申鐃緒申  6887 
申鐃緒申  6888 
申鐃緒申  6889 static Lisp_Object
申鐃緒申  6890 code_conversion_restore (arg)
申鐃緒申  6891      Lisp_Object arg;
申鐃緒申  6892 {
申鐃緒申  6893   Lisp_Object current, workbuf;
申鐃緒申  6894   struct gcpro gcpro1;
申鐃緒申  6895 
申鐃緒申  6896   GCPRO1 (arg);
申鐃緒申  6897   current = XCAR (arg);
申鐃緒申  6898   workbuf = XCDR (arg);
申鐃緒申  6899   if (! NILP (workbuf))
申鐃緒申  6900     {
申鐃緒申  6901       if (EQ (workbuf, Vcode_conversion_reused_workbuf))
申鐃緒申  6902 	reused_workbuf_in_use = 0;
申鐃緒申  6903       else if (! NILP (Fbuffer_live_p (workbuf)))
申鐃緒申  6904 	Fkill_buffer (workbuf);
申鐃緒申  6905     }
申鐃緒申  6906   set_buffer_internal (XBUFFER (current));
申鐃緒申  6907   UNGCPRO;
申鐃緒申  6908   return Qnil;
申鐃緒申  6909 }
申鐃緒申  6910 
申鐃緒申  6911 Lisp_Object
申鐃緒申  6912 code_conversion_save (with_work_buf, multibyte)
申鐃緒申  6913      int with_work_buf, multibyte;
申鐃緒申  6914 {
申鐃緒申  6915   Lisp_Object workbuf = Qnil;
申鐃緒申  6916 
申鐃緒申  6917   if (with_work_buf)
申鐃緒申  6918     workbuf = make_conversion_work_buffer (multibyte);
申鐃緒申  6919   record_unwind_protect (code_conversion_restore,
申鐃緒申  6920 			 Fcons (Fcurrent_buffer (), workbuf));
申鐃緒申  6921   return workbuf;
申鐃緒申  6922 }
申鐃緒申  6923 
申鐃緒申  6924 int
申鐃緒申  6925 decode_coding_gap (coding, chars, bytes)
申鐃緒申  6926      struct coding_system *coding;
申鐃緒申  6927      EMACS_INT chars, bytes;
申鐃緒申  6928 {
申鐃緒申  6929   int count = specpdl_ptr - specpdl;
申鐃緒申  6930   Lisp_Object attrs;
申鐃緒申  6931 
申鐃緒申  6932   code_conversion_save (0, 0);
申鐃緒申  6933 
申鐃緒申  6934   coding->src_object = Fcurrent_buffer ();
申鐃緒申  6935   coding->src_chars = chars;
申鐃緒申  6936   coding->src_bytes = bytes;
申鐃緒申  6937   coding->src_pos = -chars;
申鐃緒申  6938   coding->src_pos_byte = -bytes;
申鐃緒申  6939   coding->src_multibyte = chars < bytes;
申鐃緒申  6940   coding->dst_object = coding->src_object;
申鐃緒申  6941   coding->dst_pos = PT;
申鐃緒申  6942   coding->dst_pos_byte = PT_BYTE;
申鐃緒申  6943   coding->dst_multibyte = ! NILP (current_buffer->enable_multibyte_characters);
申鐃緒申  6944 
申鐃緒申  6945   if (CODING_REQUIRE_DETECTION (coding))
申鐃緒申  6946     detect_coding (coding);
申鐃緒申  6947 
申鐃緒申  6948   coding->mode |= CODING_MODE_LAST_BLOCK;
申鐃緒申  6949   current_buffer->text->inhibit_shrinking = 1;
申鐃緒申  6950   decode_coding (coding);
申鐃緒申  6951   current_buffer->text->inhibit_shrinking = 0;
申鐃緒申  6952 
申鐃緒申  6953   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  6954   if (! NILP (CODING_ATTR_POST_READ (attrs)))
申鐃緒申  6955     {
申鐃緒申  6956       EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE;
申鐃緒申  6957       Lisp_Object val;
申鐃緒申  6958 
申鐃緒申  6959       TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
申鐃緒申  6960       val = call1 (CODING_ATTR_POST_READ (attrs),
申鐃緒申  6961 		   make_number (coding->produced_char));
申鐃緒申  6962       CHECK_NATNUM (val);
申鐃緒申  6963       coding->produced_char += Z - prev_Z;
申鐃緒申  6964       coding->produced += Z_BYTE - prev_Z_BYTE;
申鐃緒申  6965     }
申鐃緒申  6966 
申鐃緒申  6967   unbind_to (count, Qnil);
申鐃緒申  6968   return coding->result;
申鐃緒申  6969 }
申鐃緒申  6970 
申鐃緒申  6971 int
申鐃緒申  6972 encode_coding_gap (coding, chars, bytes)
申鐃緒申  6973      struct coding_system *coding;
申鐃緒申  6974      EMACS_INT chars, bytes;
申鐃緒申  6975 {
申鐃緒申  6976   int count = specpdl_ptr - specpdl;
申鐃緒申  6977 
申鐃緒申  6978   code_conversion_save (0, 0);
申鐃緒申  6979 
申鐃緒申  6980   coding->src_object = Fcurrent_buffer ();
申鐃緒申  6981   coding->src_chars = chars;
申鐃緒申  6982   coding->src_bytes = bytes;
申鐃緒申  6983   coding->src_pos = -chars;
申鐃緒申  6984   coding->src_pos_byte = -bytes;
申鐃緒申  6985   coding->src_multibyte = chars < bytes;
申鐃緒申  6986   coding->dst_object = coding->src_object;
申鐃緒申  6987   coding->dst_pos = PT;
申鐃緒申  6988   coding->dst_pos_byte = PT_BYTE;
申鐃緒申  6989 
申鐃緒申  6990   encode_coding (coding);
申鐃緒申  6991 
申鐃緒申  6992   unbind_to (count, Qnil);
申鐃緒申  6993   return coding->result;
申鐃緒申  6994 }
申鐃緒申  6995 
申鐃緒申  6996 
申鐃緒申  6997 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
申鐃緒申  6998    SRC_OBJECT into DST_OBJECT by coding context CODING.
申鐃緒申  6999 
申鐃緒申  7000    SRC_OBJECT is a buffer, a string, or Qnil.
申鐃緒申  7001 
申鐃緒申  7002    If it is a buffer, the text is at point of the buffer.  FROM and TO
申鐃緒申  7003    are positions in the buffer.
申鐃緒申  7004 
申鐃緒申  7005    If it is a string, the text is at the beginning of the string.
申鐃緒申  7006    FROM and TO are indices to the string.
申鐃緒申  7007 
申鐃緒申  7008    If it is nil, the text is at coding->source.  FROM and TO are
申鐃緒申  7009    indices to coding->source.
申鐃緒申  7010 
申鐃緒申  7011    DST_OBJECT is a buffer, Qt, or Qnil.
申鐃緒申  7012 
申鐃緒申  7013    If it is a buffer, the decoded text is inserted at point of the
申鐃緒申  7014    buffer.  If the buffer is the same as SRC_OBJECT, the source text
申鐃緒申  7015    is deleted.
申鐃緒申  7016 
申鐃緒申  7017    If it is Qt, a string is made from the decoded text, and
申鐃緒申  7018    set in CODING->dst_object.
申鐃緒申  7019 
申鐃緒申  7020    If it is Qnil, the decoded text is stored at CODING->destination.
申鐃緒申  7021    The caller must allocate CODING->dst_bytes bytes at
申鐃緒申  7022    CODING->destination by xmalloc.  If the decoded text is longer than
申鐃緒申  7023    CODING->dst_bytes, CODING->destination is relocated by xrealloc.
申鐃緒申  7024  */
申鐃緒申  7025 
申鐃緒申  7026 void
申鐃緒申  7027 decode_coding_object (coding, src_object, from, from_byte, to, to_byte,
申鐃緒申  7028 		      dst_object)
申鐃緒申  7029      struct coding_system *coding;
申鐃緒申  7030      Lisp_Object src_object;
申鐃緒申  7031      EMACS_INT from, from_byte, to, to_byte;
申鐃緒申  7032      Lisp_Object dst_object;
申鐃緒申  7033 {
申鐃緒申  7034   int count = specpdl_ptr - specpdl;
申鐃緒申  7035   unsigned char *destination;
申鐃緒申  7036   EMACS_INT dst_bytes;
申鐃緒申  7037   EMACS_INT chars = to - from;
申鐃緒申  7038   EMACS_INT bytes = to_byte - from_byte;
申鐃緒申  7039   Lisp_Object attrs;
申鐃緒申  7040   int saved_pt = -1, saved_pt_byte;
申鐃緒申  7041   int need_marker_adjustment = 0;
申鐃緒申  7042   Lisp_Object old_deactivate_mark;
申鐃緒申  7043 
申鐃緒申  7044   old_deactivate_mark = Vdeactivate_mark;
申鐃緒申  7045 
申鐃緒申  7046   if (NILP (dst_object))
申鐃緒申  7047     {
申鐃緒申  7048       destination = coding->destination;
申鐃緒申  7049       dst_bytes = coding->dst_bytes;
申鐃緒申  7050     }
申鐃緒申  7051 
申鐃緒申  7052   coding->src_object = src_object;
申鐃緒申  7053   coding->src_chars = chars;
申鐃緒申  7054   coding->src_bytes = bytes;
申鐃緒申  7055   coding->src_multibyte = chars < bytes;
申鐃緒申  7056 
申鐃緒申  7057   if (STRINGP (src_object))
申鐃緒申  7058     {
申鐃緒申  7059       coding->src_pos = from;
申鐃緒申  7060       coding->src_pos_byte = from_byte;
申鐃緒申  7061     }
申鐃緒申  7062   else if (BUFFERP (src_object))
申鐃緒申  7063     {
申鐃緒申  7064       set_buffer_internal (XBUFFER (src_object));
申鐃緒申  7065       if (from != GPT)
申鐃緒申  7066 	move_gap_both (from, from_byte);
申鐃緒申  7067       if (EQ (src_object, dst_object))
申鐃緒申  7068 	{
申鐃緒申  7069 	  struct Lisp_Marker *tail;
申鐃緒申  7070 
申鐃緒申  7071 	  for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
申鐃緒申  7072 	    {
申鐃緒申  7073 	      tail->need_adjustment
申鐃緒申  7074 		= tail->charpos == (tail->insertion_type ? from : to);
申鐃緒申  7075 	      need_marker_adjustment |= tail->need_adjustment;
申鐃緒申  7076 	    }
申鐃緒申  7077 	  saved_pt = PT, saved_pt_byte = PT_BYTE;
申鐃緒申  7078 	  TEMP_SET_PT_BOTH (from, from_byte);
申鐃緒申  7079 	  current_buffer->text->inhibit_shrinking = 1;
申鐃緒申  7080 	  del_range_both (from, from_byte, to, to_byte, 1);
申鐃緒申  7081 	  coding->src_pos = -chars;
申鐃緒申  7082 	  coding->src_pos_byte = -bytes;
申鐃緒申  7083 	}
申鐃緒申  7084       else
申鐃緒申  7085 	{
申鐃緒申  7086 	  coding->src_pos = from;
申鐃緒申  7087 	  coding->src_pos_byte = from_byte;
申鐃緒申  7088 	}
申鐃緒申  7089     }
申鐃緒申  7090 
申鐃緒申  7091   if (CODING_REQUIRE_DETECTION (coding))
申鐃緒申  7092     detect_coding (coding);
申鐃緒申  7093   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  7094 
申鐃緒申  7095   if (EQ (dst_object, Qt)
申鐃緒申  7096       || (! NILP (CODING_ATTR_POST_READ (attrs))
申鐃緒申  7097 	  && NILP (dst_object)))
申鐃緒申  7098     {
申鐃緒申  7099       coding->dst_multibyte = !CODING_FOR_UNIBYTE (coding);
申鐃緒申  7100       coding->dst_object = code_conversion_save (1, coding->dst_multibyte);
申鐃緒申  7101       coding->dst_pos = BEG;
申鐃緒申  7102       coding->dst_pos_byte = BEG_BYTE;
申鐃緒申  7103     }
申鐃緒申  7104   else if (BUFFERP (dst_object))
申鐃緒申  7105     {
申鐃緒申  7106       code_conversion_save (0, 0);
申鐃緒申  7107       coding->dst_object = dst_object;
申鐃緒申  7108       coding->dst_pos = BUF_PT (XBUFFER (dst_object));
申鐃緒申  7109       coding->dst_pos_byte = BUF_PT_BYTE (XBUFFER (dst_object));
申鐃緒申  7110       coding->dst_multibyte
申鐃緒申  7111 	= ! NILP (XBUFFER (dst_object)->enable_multibyte_characters);
申鐃緒申  7112     }
申鐃緒申  7113   else
申鐃緒申  7114     {
申鐃緒申  7115       code_conversion_save (0, 0);
申鐃緒申  7116       coding->dst_object = Qnil;
申鐃緒申  7117       /* Most callers presume this will return a multibyte result, and they
申鐃緒申  7118 	 won't use `binary' or `raw-text' anyway, so let's not worry about
申鐃緒申  7119 	 CODING_FOR_UNIBYTE.  */
申鐃緒申  7120       coding->dst_multibyte = 1;
申鐃緒申  7121     }
申鐃緒申  7122 
申鐃緒申  7123   decode_coding (coding);
申鐃緒申  7124 
申鐃緒申  7125   if (BUFFERP (coding->dst_object))
申鐃緒申  7126     set_buffer_internal (XBUFFER (coding->dst_object));
申鐃緒申  7127 
申鐃緒申  7128   if (! NILP (CODING_ATTR_POST_READ (attrs)))
申鐃緒申  7129     {
申鐃緒申  7130       struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
申鐃緒申  7131       EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE;
申鐃緒申  7132       Lisp_Object val;
申鐃緒申  7133 
申鐃緒申  7134       TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
申鐃緒申  7135       GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
申鐃緒申  7136 	      old_deactivate_mark);
申鐃緒申  7137       val = safe_call1 (CODING_ATTR_POST_READ (attrs),
申鐃緒申  7138 			make_number (coding->produced_char));
申鐃緒申  7139       UNGCPRO;
申鐃緒申  7140       CHECK_NATNUM (val);
申鐃緒申  7141       coding->produced_char += Z - prev_Z;
申鐃緒申  7142       coding->produced += Z_BYTE - prev_Z_BYTE;
申鐃緒申  7143     }
申鐃緒申  7144 
申鐃緒申  7145   if (EQ (dst_object, Qt))
申鐃緒申  7146     {
申鐃緒申  7147       coding->dst_object = Fbuffer_string ();
申鐃緒申  7148     }
申鐃緒申  7149   else if (NILP (dst_object) && BUFFERP (coding->dst_object))
申鐃緒申  7150     {
申鐃緒申  7151       set_buffer_internal (XBUFFER (coding->dst_object));
申鐃緒申  7152       if (dst_bytes < coding->produced)
申鐃緒申  7153 	{
申鐃緒申  7154 	  destination = xrealloc (destination, coding->produced);
申鐃緒申  7155 	  if (! destination)
申鐃緒申  7156 	    {
申鐃緒申  7157 	      record_conversion_result (coding,
申鐃緒申  7158 					CODING_RESULT_INSUFFICIENT_DST);
申鐃緒申  7159 	      unbind_to (count, Qnil);
申鐃緒申  7160 	      return;
申鐃緒申  7161 	    }
申鐃緒申  7162 	  if (BEGV < GPT && GPT < BEGV + coding->produced_char)
申鐃緒申  7163 	    move_gap_both (BEGV, BEGV_BYTE);
申鐃緒申  7164 	  bcopy (BEGV_ADDR, destination, coding->produced);
申鐃緒申  7165 	  coding->destination = destination;
申鐃緒申  7166 	}
申鐃緒申  7167     }
申鐃緒申  7168 
申鐃緒申  7169   if (saved_pt >= 0)
申鐃緒申  7170     {
申鐃緒申  7171       /* This is the case of:
申鐃緒申  7172 	 (BUFFERP (src_object) && EQ (src_object, dst_object))
申鐃緒申  7173 	 As we have moved PT while replacing the original buffer
申鐃緒申  7174 	 contents, we must recover it now.  */
申鐃緒申  7175       set_buffer_internal (XBUFFER (src_object));
申鐃緒申  7176       current_buffer->text->inhibit_shrinking = 0;
申鐃緒申  7177       if (saved_pt < from)
申鐃緒申  7178 	TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte);
申鐃緒申  7179       else if (saved_pt < from + chars)
申鐃緒申  7180 	TEMP_SET_PT_BOTH (from, from_byte);
申鐃緒申  7181       else if (! NILP (current_buffer->enable_multibyte_characters))
申鐃緒申  7182 	TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars),
申鐃緒申  7183 			  saved_pt_byte + (coding->produced - bytes));
申鐃緒申  7184       else
申鐃緒申  7185 	TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes),
申鐃緒申  7186 			  saved_pt_byte + (coding->produced - bytes));
申鐃緒申  7187 
申鐃緒申  7188       if (need_marker_adjustment)
申鐃緒申  7189 	{
申鐃緒申  7190 	  struct Lisp_Marker *tail;
申鐃緒申  7191 
申鐃緒申  7192 	  for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
申鐃緒申  7193 	    if (tail->need_adjustment)
申鐃緒申  7194 	      {
申鐃緒申  7195 		tail->need_adjustment = 0;
申鐃緒申  7196 		if (tail->insertion_type)
申鐃緒申  7197 		  {
申鐃緒申  7198 		    tail->bytepos = from_byte;
申鐃緒申  7199 		    tail->charpos = from;
申鐃緒申  7200 		  }
申鐃緒申  7201 		else
申鐃緒申  7202 		  {
申鐃緒申  7203 		    tail->bytepos = from_byte + coding->produced;
申鐃緒申  7204 		    tail->charpos
申鐃緒申  7205 		      = (NILP (current_buffer->enable_multibyte_characters)
申鐃緒申  7206 			 ? tail->bytepos : from + coding->produced_char);
申鐃緒申  7207 		  }
申鐃緒申  7208 	      }
申鐃緒申  7209 	}
申鐃緒申  7210     }
申鐃緒申  7211 
申鐃緒申  7212   Vdeactivate_mark = old_deactivate_mark;
申鐃緒申  7213   unbind_to (count, coding->dst_object);
申鐃緒申  7214 }
申鐃緒申  7215 
申鐃緒申  7216 
申鐃緒申  7217 void
申鐃緒申  7218 encode_coding_object (coding, src_object, from, from_byte, to, to_byte,
申鐃緒申  7219 		      dst_object)
申鐃緒申  7220      struct coding_system *coding;
申鐃緒申  7221      Lisp_Object src_object;
申鐃緒申  7222      EMACS_INT from, from_byte, to, to_byte;
申鐃緒申  7223      Lisp_Object dst_object;
申鐃緒申  7224 {
申鐃緒申  7225   int count = specpdl_ptr - specpdl;
申鐃緒申  7226   EMACS_INT chars = to - from;
申鐃緒申  7227   EMACS_INT bytes = to_byte - from_byte;
申鐃緒申  7228   Lisp_Object attrs;
申鐃緒申  7229   int saved_pt = -1, saved_pt_byte;
申鐃緒申  7230   int need_marker_adjustment = 0;
申鐃緒申  7231   int kill_src_buffer = 0;
申鐃緒申  7232   Lisp_Object old_deactivate_mark;
申鐃緒申  7233 
申鐃緒申  7234   old_deactivate_mark = Vdeactivate_mark;
申鐃緒申  7235 
申鐃緒申  7236   coding->src_object = src_object;
申鐃緒申  7237   coding->src_chars = chars;
申鐃緒申  7238   coding->src_bytes = bytes;
申鐃緒申  7239   coding->src_multibyte = chars < bytes;
申鐃緒申  7240 
申鐃緒申  7241   attrs = CODING_ID_ATTRS (coding->id);
申鐃緒申  7242 
申鐃緒申  7243   if (EQ (src_object, dst_object))
申鐃緒申  7244     {
申鐃緒申  7245       struct Lisp_Marker *tail;
申鐃緒申  7246 
申鐃緒申  7247       for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
申鐃緒申  7248 	{
申鐃緒申  7249 	  tail->need_adjustment
申鐃緒申  7250 	    = tail->charpos == (tail->insertion_type ? from : to);
申鐃緒申  7251 	  need_marker_adjustment |= tail->need_adjustment;
申鐃緒申  7252 	}
申鐃緒申  7253     }
申鐃緒申  7254 
申鐃緒申  7255   if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
申鐃緒申  7256     {
申鐃緒申  7257       coding->src_object = code_conversion_save (1, coding->src_multibyte);
申鐃緒申  7258       set_buffer_internal (XBUFFER (coding->src_object));
申鐃緒申  7259       if (STRINGP (src_object))
申鐃緒申  7260 	insert_from_string (src_object, from, from_byte, chars, bytes, 0);
申鐃緒申  7261       else if (BUFFERP (src_object))
申鐃緒申  7262 	insert_from_buffer (XBUFFER (src_object), from, chars, 0);
申鐃緒申  7263       else
申鐃緒申  7264 	insert_1_both (coding->source + from, chars, bytes, 0, 0, 0);
申鐃緒申  7265 
申鐃緒申  7266       if (EQ (src_object, dst_object))
申鐃緒申  7267 	{
申鐃緒申  7268 	  set_buffer_internal (XBUFFER (src_object));
申鐃緒申  7269 	  saved_pt = PT, saved_pt_byte = PT_BYTE;
申鐃緒申  7270 	  del_range_both (from, from_byte, to, to_byte, 1);
申鐃緒申  7271 	  set_buffer_internal (XBUFFER (coding->src_object));
申鐃緒申  7272 	}
申鐃緒申  7273 
申鐃緒申  7274       {
申鐃緒申  7275 	Lisp_Object args[3];
申鐃緒申  7276 	struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
申鐃緒申  7277 
申鐃緒申  7278 	GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
申鐃緒申  7279 		old_deactivate_mark);
申鐃緒申  7280 	args[0] = CODING_ATTR_PRE_WRITE (attrs);
申鐃緒申  7281 	args[1] = make_number (BEG);
申鐃緒申  7282 	args[2] = make_number (Z);
申鐃緒申  7283 	safe_call (3, args);
申鐃緒申  7284 	UNGCPRO;
申鐃緒申  7285       }
申鐃緒申  7286       if (XBUFFER (coding->src_object) != current_buffer)
申鐃緒申  7287 	kill_src_buffer = 1;
申鐃緒申  7288       coding->src_object = Fcurrent_buffer ();
申鐃緒申  7289       if (BEG != GPT)
申鐃緒申  7290 	move_gap_both (BEG, BEG_BYTE);
申鐃緒申  7291       coding->src_chars = Z - BEG;
申鐃緒申  7292       coding->src_bytes = Z_BYTE - BEG_BYTE;
申鐃緒申  7293       coding->src_pos = BEG;
申鐃緒申  7294       coding->src_pos_byte = BEG_BYTE;
申鐃緒申  7295       coding->src_multibyte = Z < Z_BYTE;
申鐃緒申  7296     }
申鐃緒申  7297   else if (STRINGP (src_object))
申鐃緒申  7298     {
申鐃緒申  7299       code_conversion_save (0, 0);
申鐃緒申  7300       coding->src_pos = from;
申鐃緒申  7301       coding->src_pos_byte = from_byte;
申鐃緒申  7302     }
申鐃緒申  7303   else if (BUFFERP (src_object))
申鐃緒申  7304     {
申鐃緒申  7305       code_conversion_save (0, 0);
申鐃緒申  7306       set_buffer_internal (XBUFFER (src_object));
申鐃緒申  7307       if (EQ (src_object, dst_object))
申鐃緒申  7308 	{
申鐃緒申  7309 	  saved_pt = PT, saved_pt_byte = PT_BYTE;
申鐃緒申  7310 	  coding->src_object = del_range_1 (from, to, 1, 1);
申鐃緒申  7311 	  coding->src_pos = 0;
申鐃緒申  7312 	  coding->src_pos_byte = 0;
申鐃緒申  7313 	}
申鐃緒申  7314       else
申鐃緒申  7315 	{
申鐃緒申  7316 	  if (from < GPT && to >= GPT)
申鐃緒申  7317 	    move_gap_both (from, from_byte);
申鐃緒申  7318 	  coding->src_pos = from;
申鐃緒申  7319 	  coding->src_pos_byte = from_byte;
申鐃緒申  7320 	}
申鐃緒申  7321     }
申鐃緒申  7322   else
申鐃緒申  7323     code_conversion_save (0, 0);
申鐃緒申  7324 
申鐃緒申  7325   if (BUFFERP (dst_object))
申鐃緒申  7326     {
申鐃緒申  7327       coding->dst_object = dst_object;
申鐃緒申  7328       if (EQ (src_object, dst_object))
申鐃緒申  7329 	{
申鐃緒申  7330 	  coding->dst_pos = from;
申鐃緒申  7331 	  coding->dst_pos_byte = from_byte;
申鐃緒申  7332 	}
申鐃緒申  7333       else
申鐃緒申  7334 	{
申鐃緒申  7335 	  coding->dst_pos = BUF_PT (XBUFFER (dst_object));
申鐃緒申  7336 	  coding->dst_pos_byte = BUF_PT_BYTE (XBUFFER (dst_object));
申鐃緒申  7337 	}
申鐃緒申  7338       coding->dst_multibyte
申鐃緒申  7339 	= ! NILP (XBUFFER (dst_object)->enable_multibyte_characters);
申鐃緒申  7340     }
申鐃緒申  7341   else if (EQ (dst_object, Qt))
申鐃緒申  7342     {
申鐃緒申  7343       coding->dst_object = Qnil;
申鐃緒申  7344       coding->dst_bytes = coding->src_chars;
申鐃緒申  7345       if (coding->dst_bytes == 0)
申鐃緒申  7346 	coding->dst_bytes = 1;
申鐃緒申  7347       coding->destination = (unsigned char *) xmalloc (coding->dst_bytes);
申鐃緒申  7348       coding->dst_multibyte = 0;
申鐃緒申  7349     }
申鐃緒申  7350   else
申鐃緒申  7351     {
申鐃緒申  7352       coding->dst_object = Qnil;
申鐃緒申  7353       coding->dst_multibyte = 0;
申鐃緒申  7354     }
申鐃緒申  7355 
申鐃緒申  7356   encode_coding (coding);
申鐃緒申  7357 
申鐃緒申  7358   if (EQ (dst_object, Qt))
申鐃緒申  7359     {
申鐃緒申  7360       if (BUFFERP (coding->dst_object))
申鐃緒申  7361 	coding->dst_object = Fbuffer_string ();
申鐃緒申  7362       else
申鐃緒申  7363 	{
申鐃緒申  7364 	  coding->dst_object
申鐃緒申  7365 	    = make_unibyte_string ((char *) coding->destination,
申鐃緒申  7366 				   coding->produced);
申鐃緒申  7367 	  xfree (coding->destination);
申鐃緒申  7368 	}
申鐃緒申  7369     }
申鐃緒申  7370 
申鐃緒申  7371   if (saved_pt >= 0)
申鐃緒申  7372     {
申鐃緒申  7373       /* This is the case of:
申鐃緒申  7374 	 (BUFFERP (src_object) && EQ (src_object, dst_object))
申鐃緒申  7375 	 As we have moved PT while replacing the original buffer
申鐃緒申  7376 	 contents, we must recover it now.  */
申鐃緒申  7377       set_buffer_internal (XBUFFER (src_object));
申鐃緒申  7378       if (saved_pt < from)
申鐃緒申  7379 	TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte);
申鐃緒申  7380       else if (saved_pt < from + chars)
申鐃緒申  7381 	TEMP_SET_PT_BOTH (from, from_byte);
申鐃緒申  7382       else if (! NILP (current_buffer->enable_multibyte_characters))
申鐃緒申  7383 	TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars),
申鐃緒申  7384 			  saved_pt_byte + (coding->produced - bytes));
申鐃緒申  7385       else
申鐃緒申  7386 	TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes),
申鐃緒申  7387 			  saved_pt_byte + (coding->produced - bytes));
申鐃緒申  7388 
申鐃緒申  7389       if (need_marker_adjustment)
申鐃緒申  7390 	{
申鐃緒申  7391 	  struct Lisp_Marker *tail;
申鐃緒申  7392 
申鐃緒申  7393 	  for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
申鐃緒申  7394 	    if (tail->need_adjustment)
申鐃緒申  7395 	      {
申鐃緒申  7396 		tail->need_adjustment = 0;
申鐃緒申  7397 		if (tail->insertion_type)
申鐃緒申  7398 		  {
申鐃緒申  7399 		    tail->bytepos = from_byte;
申鐃緒申  7400 		    tail->charpos = from;
申鐃緒申  7401 		  }
申鐃緒申  7402 		else
申鐃緒申  7403 		  {
申鐃緒申  7404 		    tail->bytepos = from_byte + coding->produced;
申鐃緒申  7405 		    tail->charpos
申鐃緒申  7406 		      = (NILP (current_buffer->enable_multibyte_characters)
申鐃緒申  7407 			 ? tail->bytepos : from + coding->produced_char);
申鐃緒申  7408 		  }
申鐃緒申  7409 	      }
申鐃緒申  7410 	}
申鐃緒申  7411     }
申鐃緒申  7412 
申鐃緒申  7413   if (kill_src_buffer)
申鐃緒申  7414     Fkill_buffer (coding->src_object);
申鐃緒申  7415 
申鐃緒申  7416   Vdeactivate_mark = old_deactivate_mark;
申鐃緒申  7417   unbind_to (count, Qnil);
申鐃緒申  7418 }
申鐃緒申  7419 
申鐃緒申  7420 
申鐃緒申  7421 Lisp_Object
申鐃緒申  7422 preferred_coding_system ()
申鐃緒申  7423 {
申鐃緒申  7424   int id = coding_categories[coding_priorities[0]].id;
申鐃緒申  7425 
申鐃緒申  7426   return CODING_ID_NAME (id);
申鐃緒申  7427 }
申鐃緒申  7428 
申鐃緒申  7429 
申鐃緒申  7430 #ifdef emacs
申鐃緒申  7431 /*** 8. Emacs Lisp library functions ***/
申鐃緒申  7432 
申鐃緒申  7433 DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
申鐃緒申  7434        doc: /* Return t if OBJECT is nil or a coding-system.
申鐃緒申  7435 See the documentation of `define-coding-system' for information
申鐃緒申  7436 about coding-system objects.  */)
申鐃緒申  7437      (obj)
申鐃緒申  7438      Lisp_Object obj;
申鐃緒申  7439 {
申鐃緒申  7440   if (NILP (obj)
申鐃緒申  7441       || CODING_SYSTEM_ID (obj) >= 0)
申鐃緒申  7442     return Qt;
申鐃緒申  7443   if (! SYMBOLP (obj)
申鐃緒申  7444       || NILP (Fget (obj, Qcoding_system_define_form)))
申鐃緒申  7445     return Qnil;
申鐃緒申  7446   return Qt;
申鐃緒申  7447 }
申鐃緒申  7448 
申鐃緒申  7449 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
申鐃緒申  7450        Sread_non_nil_coding_system, 1, 1, 0,
申鐃緒申  7451        doc: /* Read a coding system from the minibuffer, prompting with string PROMPT.  */)
申鐃緒申  7452      (prompt)
申鐃緒申  7453      Lisp_Object prompt;
申鐃緒申  7454 {
申鐃緒申  7455   Lisp_Object val;
申鐃緒申  7456   do
申鐃緒申  7457     {
申鐃緒申  7458       val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
申鐃緒申  7459 			      Qt, Qnil, Qcoding_system_history, Qnil, Qnil);
申鐃緒申  7460     }
申鐃緒申  7461   while (SCHARS (val) == 0);
申鐃緒申  7462   return (Fintern (val, Qnil));
申鐃緒申  7463 }
申鐃緒申  7464 
申鐃緒申  7465 DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
申鐃緒申  7466        doc: /* Read a coding system from the minibuffer, prompting with string PROMPT.
申鐃緒申  7467 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
申鐃緒申  7468 Ignores case when completing coding systems (all Emacs coding systems
申鐃緒申  7469 are lower-case).  */)
申鐃緒申  7470      (prompt, default_coding_system)
申鐃緒申  7471      Lisp_Object prompt, default_coding_system;
申鐃緒申  7472 {
申鐃緒申  7473   Lisp_Object val;
申鐃緒申  7474   int count = SPECPDL_INDEX ();
申鐃緒申  7475 
申鐃緒申  7476   if (SYMBOLP (default_coding_system))
申鐃緒申  7477     default_coding_system = SYMBOL_NAME (default_coding_system);
申鐃緒申  7478   specbind (Qcompletion_ignore_case, Qt);
申鐃緒申  7479   val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
申鐃緒申  7480 			  Qt, Qnil, Qcoding_system_history,
申鐃緒申  7481 			  default_coding_system, Qnil);
申鐃緒申  7482   unbind_to (count, Qnil);
申鐃緒申  7483   return (SCHARS (val) == 0 ? Qnil : Fintern (val, Qnil));
申鐃緒申  7484 }
申鐃緒申  7485 
申鐃緒申  7486 DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
申鐃緒申  7487        1, 1, 0,
申鐃緒申  7488        doc: /* Check validity of CODING-SYSTEM.
申鐃緒申  7489 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
申鐃緒申  7490 It is valid if it is nil or a symbol defined as a coding system by the
申鐃緒申  7491 function `define-coding-system'.  */)
申鐃緒申  7492   (coding_system)
申鐃緒申  7493      Lisp_Object coding_system;
申鐃緒申  7494 {
申鐃緒申  7495   Lisp_Object define_form;
申鐃緒申  7496 
申鐃緒申  7497   define_form = Fget (coding_system, Qcoding_system_define_form);
申鐃緒申  7498   if (! NILP (define_form))
申鐃緒申  7499     {
申鐃緒申  7500       Fput (coding_system, Qcoding_system_define_form, Qnil);
申鐃緒申  7501       safe_eval (define_form);
申鐃緒申  7502     }
申鐃緒申  7503   if (!NILP (Fcoding_system_p (coding_system)))
申鐃緒申  7504     return coding_system;
申鐃緒申  7505   xsignal1 (Qcoding_system_error, coding_system);
申鐃緒申  7506 }
申鐃緒申  7507 
申鐃緒申  7508 
申鐃緒申  7509 /* Detect how the bytes at SRC of length SRC_BYTES are encoded.  If
申鐃緒申  7510    HIGHEST is nonzero, return the coding system of the highest
申鐃緒申  7511    priority among the detected coding systems.  Otherwize return a
申鐃緒申  7512    list of detected coding systems sorted by their priorities.  If
申鐃緒申  7513    MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
申鐃緒申  7514    multibyte form but contains only ASCII and eight-bit chars.
申鐃緒申  7515    Otherwise, the bytes are raw bytes.
申鐃緒申  7516 
申鐃緒申  7517    CODING-SYSTEM controls the detection as below:
申鐃緒申  7518 
申鐃緒申  7519    If it is nil, detect both text-format and eol-format.  If the
申鐃緒申  7520    text-format part of CODING-SYSTEM is already specified
申鐃緒申  7521    (e.g. `iso-latin-1'), detect only eol-format.  If the eol-format
申鐃緒申  7522    part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
申鐃緒申  7523    detect only text-format.  */
申鐃緒申  7524 
申鐃緒申  7525 Lisp_Object
申鐃緒申  7526 detect_coding_system (src, src_chars, src_bytes, highest, multibytep,
申鐃緒申  7527 		      coding_system)
申鐃緒申  7528      const unsigned char *src;
申鐃緒申  7529      EMACS_INT src_chars, src_bytes;
申鐃緒申  7530      int highest;
申鐃緒申  7531      int multibytep;
申鐃緒申  7532      Lisp_Object coding_system;
申鐃緒申  7533 {
申鐃緒申  7534   const unsigned char *src_end = src + src_bytes;
申鐃緒申  7535   Lisp_Object attrs, eol_type;
申鐃緒申  7536   Lisp_Object val;
申鐃緒申  7537   struct coding_system coding;
申鐃緒申  7538   int id;
申鐃緒申  7539   struct coding_detection_info detect_info;
申鐃緒申  7540   enum coding_category base_category;
申鐃緒申  7541   int null_byte_found = 0, eight_bit_found = 0;
申鐃緒申  7542 
申鐃緒申  7543   if (NILP (coding_system))
申鐃緒申  7544     coding_system = Qundecided;
申鐃緒申  7545   setup_coding_system (coding_system, &coding);
申鐃緒申  7546   attrs = CODING_ID_ATTRS (coding.id);
申鐃緒申  7547   eol_type = CODING_ID_EOL_TYPE (coding.id);
申鐃緒申  7548   coding_system = CODING_ATTR_BASE_NAME (attrs);
申鐃緒申  7549 
申鐃緒申  7550   coding.source = src;
申鐃緒申  7551   coding.src_chars = src_chars;
申鐃緒申  7552   coding.src_bytes = src_bytes;
申鐃緒申  7553   coding.src_multibyte = multibytep;
申鐃緒申  7554   coding.consumed = 0;
申鐃緒申  7555   coding.mode |= CODING_MODE_LAST_BLOCK;
申鐃緒申  7556 
申鐃緒申  7557   detect_info.checked = detect_info.found = detect_info.rejected = 0;
申鐃緒申  7558 
申鐃緒申  7559   /* At first, detect text-format if necessary.  */
申鐃緒申  7560   base_category = XINT (CODING_ATTR_CATEGORY (attrs));
申鐃緒申  7561   if (base_category == coding_category_undecided)
申鐃緒申  7562     {
申鐃緒申  7563       enum coding_category category;
申鐃緒申  7564       struct coding_system *this;
申鐃緒申  7565       int c, i;
申鐃緒申  7566 
申鐃緒申  7567       coding.head_ascii = -1;
申鐃緒申  7568       /* Skip all ASCII bytes except for a few ISO2022 controls.  */
申鐃緒申  7569       for (; src < src_end; src++)
申鐃緒申  7570 	{
申鐃緒申  7571 	  c = *src;
申鐃緒申  7572 	  if (c & 0x80)
申鐃緒申  7573 	    {
申鐃緒申  7574 	      eight_bit_found = 1;
申鐃緒申  7575 	      if (coding.head_ascii < 0)
申鐃緒申  7576 		coding.head_ascii = src - coding.source;
申鐃緒申  7577 	      if (null_byte_found)
申鐃緒申  7578 		break;
申鐃緒申  7579 	    }
申鐃緒申  7580 	  if (c < 0x20)
申鐃緒申  7581 	    {
申鐃緒申  7582 	      if ((c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
申鐃緒申  7583 		  && ! inhibit_iso_escape_detection
申鐃緒申  7584 		  && ! detect_info.checked)
申鐃緒申  7585 		{
申鐃緒申  7586 		  if (coding.head_ascii < 0)
申鐃緒申  7587 		    coding.head_ascii = src - coding.source;
申鐃緒申  7588 		  if (detect_coding_iso_2022 (&coding, &detect_info))
申鐃緒申  7589 		    {
申鐃緒申  7590 		      /* We have scanned the whole data.  */
申鐃緒申  7591 		      if (! (detect_info.rejected & CATEGORY_MASK_ISO_7_ELSE))
申鐃緒申  7592 			/* We didn't find an 8-bit code.  We may have
申鐃緒申  7593 			   found a null-byte, but it's very rare that
申鐃緒申  7594 			   a binary file confirm to ISO-2022.  */
申鐃緒申  7595 			src = src_end;
申鐃緒申  7596 		      break;
申鐃緒申  7597 		    }
申鐃緒申  7598 		}
申鐃緒申  7599 	      else if (! c)
申鐃緒申  7600 		{
申鐃緒申  7601 		  null_byte_found = 1;
申鐃緒申  7602 		  if (eight_bit_found)
申鐃緒申  7603 		    break;
申鐃緒申  7604 		}
申鐃緒申  7605 	    }
申鐃緒申  7606 	}
申鐃緒申  7607       if (coding.head_ascii < 0)
申鐃緒申  7608 	coding.head_ascii = src - coding.source;
申鐃緒申  7609 
申鐃緒申  7610       if (null_byte_found || eight_bit_found
申鐃緒申  7611 	  || coding.head_ascii < coding.src_bytes
申鐃緒申  7612 	  || detect_info.found)
申鐃緒申  7613 	{
申鐃緒申  7614 	  if (coding.head_ascii == coding.src_bytes)
申鐃緒申  7615 	    /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings.  */
申鐃緒申  7616 	    for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  7617 	      {
申鐃緒申  7618 		category = coding_priorities[i];
申鐃緒申  7619 		this = coding_categories + category;
申鐃緒申  7620 		if (detect_info.found & (1 << category))
申鐃緒申  7621 		  break;
申鐃緒申  7622 	      }
申鐃緒申  7623 	  else
申鐃緒申  7624 	    {
申鐃緒申  7625 	      if (null_byte_found)
申鐃緒申  7626 		{
申鐃緒申  7627 		  detect_info.checked |= ~CATEGORY_MASK_UTF_16;
申鐃緒申  7628 		  detect_info.rejected |= ~CATEGORY_MASK_UTF_16;
申鐃緒申  7629 		}
申鐃緒申  7630 	      for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  7631 		{
申鐃緒申  7632 		  category = coding_priorities[i];
申鐃緒申  7633 		  this = coding_categories + category;
申鐃緒申  7634 
申鐃緒申  7635 		  if (this->id < 0)
申鐃緒申  7636 		    {
申鐃緒申  7637 		      /* No coding system of this category is defined.  */
申鐃緒申  7638 		      detect_info.rejected |= (1 << category);
申鐃緒申  7639 		    }
申鐃緒申  7640 		  else if (category >= coding_category_raw_text)
申鐃緒申  7641 		    continue;
申鐃緒申  7642 		  else if (detect_info.checked & (1 << category))
申鐃緒申  7643 		    {
申鐃緒申  7644 		      if (highest
申鐃緒申  7645 			  && (detect_info.found & (1 << category)))
申鐃緒申  7646 			break;
申鐃緒申  7647 		    }
申鐃緒申  7648 		  else if ((*(this->detector)) (&coding, &detect_info)
申鐃緒申  7649 			   && highest
申鐃緒申  7650 			   && (detect_info.found & (1 << category)))
申鐃緒申  7651 		    {
申鐃緒申  7652 		      if (category == coding_category_utf_16_auto)
申鐃緒申  7653 			{
申鐃緒申  7654 			  if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
申鐃緒申  7655 			    category = coding_category_utf_16_le;
申鐃緒申  7656 			  else
申鐃緒申  7657 			    category = coding_category_utf_16_be;
申鐃緒申  7658 			}
申鐃緒申  7659 		      break;
申鐃緒申  7660 		    }
申鐃緒申  7661 		}
申鐃緒申  7662 	    }
申鐃緒申  7663 	}
申鐃緒申  7664 
申鐃緒申  7665       if ((detect_info.rejected & CATEGORY_MASK_ANY) == CATEGORY_MASK_ANY)
申鐃緒申  7666 	{
申鐃緒申  7667 	  detect_info.found = CATEGORY_MASK_RAW_TEXT;
申鐃緒申  7668 	  id = coding_categories[coding_category_raw_text].id;
申鐃緒申  7669 	  val = Fcons (make_number (id), Qnil);
申鐃緒申  7670 	}
申鐃緒申  7671       else if (! detect_info.rejected && ! detect_info.found)
申鐃緒申  7672 	{
申鐃緒申  7673 	  detect_info.found = CATEGORY_MASK_ANY;
申鐃緒申  7674 	  id = coding_categories[coding_category_undecided].id;
申鐃緒申  7675 	  val = Fcons (make_number (id), Qnil);
申鐃緒申  7676 	}
申鐃緒申  7677       else if (highest)
申鐃緒申  7678 	{
申鐃緒申  7679 	  if (detect_info.found)
申鐃緒申  7680 	    {
申鐃緒申  7681 	      detect_info.found = 1 << category;
申鐃緒申  7682 	      val = Fcons (make_number (this->id), Qnil);
申鐃緒申  7683 	    }
申鐃緒申  7684 	  else
申鐃緒申  7685 	    for (i = 0; i < coding_category_raw_text; i++)
申鐃緒申  7686 	      if (! (detect_info.rejected & (1 << coding_priorities[i])))
申鐃緒申  7687 		{
申鐃緒申  7688 		  detect_info.found = 1 << coding_priorities[i];
申鐃緒申  7689 		  id = coding_categories[coding_priorities[i]].id;
申鐃緒申  7690 		  val = Fcons (make_number (id), Qnil);
申鐃緒申  7691 		  break;
申鐃緒申  7692 		}
申鐃緒申  7693 	}
申鐃緒申  7694       else
申鐃緒申  7695 	{
申鐃緒申  7696 	  int mask = detect_info.rejected | detect_info.found;
申鐃緒申  7697 	  int found = 0;
申鐃緒申  7698 	  val = Qnil;
申鐃緒申  7699 
申鐃緒申  7700 	  for (i = coding_category_raw_text - 1; i >= 0; i--)
申鐃緒申  7701 	    {
申鐃緒申  7702 	      category = coding_priorities[i];
申鐃緒申  7703 	      if (! (mask & (1 << category)))
申鐃緒申  7704 		{
申鐃緒申  7705 		  found |= 1 << category;
申鐃緒申  7706 		  id = coding_categories[category].id;
申鐃緒申  7707 		  if (id >= 0)
申鐃緒申  7708 		    val = Fcons (make_number (id), val);
申鐃緒申  7709 		}
申鐃緒申  7710 	    }
申鐃緒申  7711 	  for (i = coding_category_raw_text - 1; i >= 0; i--)
申鐃緒申  7712 	    {
申鐃緒申  7713 	      category = coding_priorities[i];
申鐃緒申  7714 	      if (detect_info.found & (1 << category))
申鐃緒申  7715 		{
申鐃緒申  7716 		  id = coding_categories[category].id;
申鐃緒申  7717 		  val = Fcons (make_number (id), val);
申鐃緒申  7718 		}
申鐃緒申  7719 	    }
申鐃緒申  7720 	  detect_info.found |= found;
申鐃緒申  7721 	}
申鐃緒申  7722     }
申鐃緒申  7723   else if (base_category == coding_category_utf_16_auto)
申鐃緒申  7724     {
申鐃緒申  7725       if (detect_coding_utf_16 (&coding, &detect_info))
申鐃緒申  7726 	{
申鐃緒申  7727 	  struct coding_system *this;
申鐃緒申  7728 
申鐃緒申  7729 	  if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
申鐃緒申  7730 	    this = coding_categories + coding_category_utf_16_le;
申鐃緒申  7731 	  else if (detect_info.found & CATEGORY_MASK_UTF_16_BE)
申鐃緒申  7732 	    this = coding_categories + coding_category_utf_16_be;
申鐃緒申  7733 	  else if (detect_info.rejected & CATEGORY_MASK_UTF_16_LE_NOSIG)
申鐃緒申  7734 	    this = coding_categories + coding_category_utf_16_be_nosig;
申鐃緒申  7735 	  else
申鐃緒申  7736 	    this = coding_categories + coding_category_utf_16_le_nosig;
申鐃緒申  7737 	  val = Fcons (make_number (this->id), Qnil);
申鐃緒申  7738 	}
申鐃緒申  7739     }
申鐃緒申  7740   else
申鐃緒申  7741     {
申鐃緒申  7742       detect_info.found = 1 << XINT (CODING_ATTR_CATEGORY (attrs));
申鐃緒申  7743       val = Fcons (make_number (coding.id), Qnil);
申鐃緒申  7744     }
申鐃緒申  7745 
申鐃緒申  7746   /* Then, detect eol-format if necessary.  */
申鐃緒申  7747   {
申鐃緒申  7748     int normal_eol = -1, utf_16_be_eol = -1, utf_16_le_eol;
申鐃緒申  7749     Lisp_Object tail;
申鐃緒申  7750 
申鐃緒申  7751     if (VECTORP (eol_type))
申鐃緒申  7752       {
申鐃緒申  7753 	if (detect_info.found & ~CATEGORY_MASK_UTF_16)
申鐃緒申  7754 	  {
申鐃緒申  7755 	    if (null_byte_found)
申鐃緒申  7756 	      normal_eol = EOL_SEEN_LF;
申鐃緒申  7757 	    else
申鐃緒申  7758 	      normal_eol = detect_eol (coding.source, src_bytes,
申鐃緒申  7759 				       coding_category_raw_text);
申鐃緒申  7760 	  }
申鐃緒申  7761 	if (detect_info.found & (CATEGORY_MASK_UTF_16_BE
申鐃緒申  7762 				 | CATEGORY_MASK_UTF_16_BE_NOSIG))
申鐃緒申  7763 	  utf_16_be_eol = detect_eol (coding.source, src_bytes,
申鐃緒申  7764 				      coding_category_utf_16_be);
申鐃緒申  7765 	if (detect_info.found & (CATEGORY_MASK_UTF_16_LE
申鐃緒申  7766 				 | CATEGORY_MASK_UTF_16_LE_NOSIG))
申鐃緒申  7767 	  utf_16_le_eol = detect_eol (coding.source, src_bytes,
申鐃緒申  7768 				      coding_category_utf_16_le);
申鐃緒申  7769       }
申鐃緒申  7770     else
申鐃緒申  7771       {
申鐃緒申  7772 	if (EQ (eol_type, Qunix))
申鐃緒申  7773 	  normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_LF;
申鐃緒申  7774 	else if (EQ (eol_type, Qdos))
申鐃緒申  7775 	  normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CRLF;
申鐃緒申  7776 	else
申鐃緒申  7777 	  normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CR;
申鐃緒申  7778       }
申鐃緒申  7779 
申鐃緒申  7780     for (tail = val; CONSP (tail); tail = XCDR (tail))
申鐃緒申  7781       {
申鐃緒申  7782 	enum coding_category category;
申鐃緒申  7783 	int this_eol;
申鐃緒申  7784 
申鐃緒申  7785 	id = XINT (XCAR (tail));
申鐃緒申  7786 	attrs = CODING_ID_ATTRS (id);
申鐃緒申  7787 	category = XINT (CODING_ATTR_CATEGORY (attrs));
申鐃緒申  7788 	eol_type = CODING_ID_EOL_TYPE (id);
申鐃緒申  7789 	if (VECTORP (eol_type))
申鐃緒申  7790 	  {
申鐃緒申  7791 	    if (category == coding_category_utf_16_be
申鐃緒申  7792 		|| category == coding_category_utf_16_be_nosig)
申鐃緒申  7793 	      this_eol = utf_16_be_eol;
申鐃緒申  7794 	    else if (category == coding_category_utf_16_le
申鐃緒申  7795 		     || category == coding_category_utf_16_le_nosig)
申鐃緒申  7796 	      this_eol = utf_16_le_eol;
申鐃緒申  7797 	    else
申鐃緒申  7798 	      this_eol = normal_eol;
申鐃緒申  7799 
申鐃緒申  7800 	    if (this_eol == EOL_SEEN_LF)
申鐃緒申  7801 	      XSETCAR (tail, AREF (eol_type, 0));
申鐃緒申  7802 	    else if (this_eol == EOL_SEEN_CRLF)
申鐃緒申  7803 	      XSETCAR (tail, AREF (eol_type, 1));
申鐃緒申  7804 	    else if (this_eol == EOL_SEEN_CR)
申鐃緒申  7805 	      XSETCAR (tail, AREF (eol_type, 2));
申鐃緒申  7806 	    else
申鐃緒申  7807 	      XSETCAR (tail, CODING_ID_NAME (id));
申鐃緒申  7808 	  }
申鐃緒申  7809 	else
申鐃緒申  7810 	  XSETCAR (tail, CODING_ID_NAME (id));
申鐃緒申  7811       }
申鐃緒申  7812   }
申鐃緒申  7813 
申鐃緒申  7814   return (highest ? XCAR (val) : val);
申鐃緒申  7815 }
申鐃緒申  7816 
申鐃緒申  7817 
申鐃緒申  7818 DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
申鐃緒申  7819        2, 3, 0,
申鐃緒申  7820        doc: /* Detect coding system of the text in the region between START and END.
申鐃緒申  7821 Return a list of possible coding systems ordered by priority.
申鐃緒申  7822 
申鐃緒申  7823 If only ASCII characters are found (except for such ISO-2022 control
申鐃緒申  7824 characters ISO-2022 as ESC), it returns a list of single element
申鐃緒申  7825 `undecided' or its subsidiary coding system according to a detected
申鐃緒申  7826 end-of-line format.
申鐃緒申  7827 
申鐃緒申  7828 If optional argument HIGHEST is non-nil, return the coding system of
申鐃緒申  7829 highest priority.  */)
申鐃緒申  7830      (start, end, highest)
申鐃緒申  7831      Lisp_Object start, end, highest;
申鐃緒申  7832 {
申鐃緒申  7833   int from, to;
申鐃緒申  7834   int from_byte, to_byte;
申鐃緒申  7835 
申鐃緒申  7836   CHECK_NUMBER_COERCE_MARKER (start);
申鐃緒申  7837   CHECK_NUMBER_COERCE_MARKER (end);
申鐃緒申  7838 
申鐃緒申  7839   validate_region (&start, &end);
申鐃緒申  7840   from = XINT (start), to = XINT (end);
申鐃緒申  7841   from_byte = CHAR_TO_BYTE (from);
申鐃緒申  7842   to_byte = CHAR_TO_BYTE (to);
申鐃緒申  7843 
申鐃緒申  7844   if (from < GPT && to >= GPT)
申鐃緒申  7845     move_gap_both (to, to_byte);
申鐃緒申  7846 
申鐃緒申  7847   return detect_coding_system (BYTE_POS_ADDR (from_byte),
申鐃緒申  7848 			       to - from, to_byte - from_byte,
申鐃緒申  7849 			       !NILP (highest),
申鐃緒申  7850 			       !NILP (current_buffer
申鐃緒申  7851 				      ->enable_multibyte_characters),
申鐃緒申  7852 			       Qnil);
申鐃緒申  7853 }
申鐃緒申  7854 
申鐃緒申  7855 DEFUN ("detect-coding-string", Fdetect_coding_string, Sdetect_coding_string,
申鐃緒申  7856        1, 2, 0,
申鐃緒申  7857        doc: /* Detect coding system of the text in STRING.
申鐃緒申  7858 Return a list of possible coding systems ordered by priority.
申鐃緒申  7859 
申鐃緒申  7860 If only ASCII characters are found (except for such ISO-2022 control
申鐃緒申  7861 characters ISO-2022 as ESC), it returns a list of single element
申鐃緒申  7862 `undecided' or its subsidiary coding system according to a detected
申鐃緒申  7863 end-of-line format.
申鐃緒申  7864 
申鐃緒申  7865 If optional argument HIGHEST is non-nil, return the coding system of
申鐃緒申  7866 highest priority.  */)
申鐃緒申  7867      (string, highest)
申鐃緒申  7868      Lisp_Object string, highest;
申鐃緒申  7869 {
申鐃緒申  7870   CHECK_STRING (string);
申鐃緒申  7871 
申鐃緒申  7872   return detect_coding_system (SDATA (string),
申鐃緒申  7873 			       SCHARS (string), SBYTES (string),
申鐃緒申  7874 			       !NILP (highest), STRING_MULTIBYTE (string),
申鐃緒申  7875 			       Qnil);
申鐃緒申  7876 }
申鐃緒申  7877 
申鐃緒申  7878 
申鐃緒申  7879 static INLINE int
申鐃緒申  7880 char_encodable_p (c, attrs)
申鐃緒申  7881      int c;
申鐃緒申  7882      Lisp_Object attrs;
申鐃緒申  7883 {
申鐃緒申  7884   Lisp_Object tail;
申鐃緒申  7885   struct charset *charset;
申鐃緒申  7886   Lisp_Object translation_table;
申鐃緒申  7887 
申鐃緒申  7888   translation_table = CODING_ATTR_TRANS_TBL (attrs);
申鐃緒申  7889   if (! NILP (translation_table))
申鐃緒申  7890     c = translate_char (translation_table, c);
申鐃緒申  7891   for (tail = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  7892        CONSP (tail); tail = XCDR (tail))
申鐃緒申  7893     {
申鐃緒申  7894       charset = CHARSET_FROM_ID (XINT (XCAR (tail)));
申鐃緒申  7895       if (CHAR_CHARSET_P (c, charset))
申鐃緒申  7896 	break;
申鐃緒申  7897     }
申鐃緒申  7898   return (! NILP (tail));
申鐃緒申  7899 }
申鐃緒申  7900 
申鐃緒申  7901 
申鐃緒申  7902 /* Return a list of coding systems that safely encode the text between
申鐃緒申  7903    START and END.  If EXCLUDE is non-nil, it is a list of coding
申鐃緒申  7904    systems not to check.  The returned list doesn't contain any such
申鐃緒申  7905    coding systems.  In any case, if the text contains only ASCII or is
申鐃緒申  7906    unibyte, return t.  */
申鐃緒申  7907 
申鐃緒申  7908 DEFUN ("find-coding-systems-region-internal",
申鐃緒申  7909        Ffind_coding_systems_region_internal,
申鐃緒申  7910        Sfind_coding_systems_region_internal, 2, 3, 0,
申鐃緒申  7911        doc: /* Internal use only.  */)
申鐃緒申  7912      (start, end, exclude)
申鐃緒申  7913      Lisp_Object start, end, exclude;
申鐃緒申  7914 {
申鐃緒申  7915   Lisp_Object coding_attrs_list, safe_codings;
申鐃緒申  7916   EMACS_INT start_byte, end_byte;
申鐃緒申  7917   const unsigned char *p, *pbeg, *pend;
申鐃緒申  7918   int c;
申鐃緒申  7919   Lisp_Object tail, elt;
申鐃緒申  7920 
申鐃緒申  7921   if (STRINGP (start))
申鐃緒申  7922     {
申鐃緒申  7923       if (!STRING_MULTIBYTE (start)
申鐃緒申  7924 	  || SCHARS (start) == SBYTES (start))
申鐃緒申  7925 	return Qt;
申鐃緒申  7926       start_byte = 0;
申鐃緒申  7927       end_byte = SBYTES (start);
申鐃緒申  7928     }
申鐃緒申  7929   else
申鐃緒申  7930     {
申鐃緒申  7931       CHECK_NUMBER_COERCE_MARKER (start);
申鐃緒申  7932       CHECK_NUMBER_COERCE_MARKER (end);
申鐃緒申  7933       if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
申鐃緒申  7934 	args_out_of_range (start, end);
申鐃緒申  7935       if (NILP (current_buffer->enable_multibyte_characters))
申鐃緒申  7936 	return Qt;
申鐃緒申  7937       start_byte = CHAR_TO_BYTE (XINT (start));
申鐃緒申  7938       end_byte = CHAR_TO_BYTE (XINT (end));
申鐃緒申  7939       if (XINT (end) - XINT (start) == end_byte - start_byte)
申鐃緒申  7940 	return Qt;
申鐃緒申  7941 
申鐃緒申  7942       if (XINT (start) < GPT && XINT (end) > GPT)
申鐃緒申  7943 	{
申鐃緒申  7944 	  if ((GPT - XINT (start)) < (XINT (end) - GPT))
申鐃緒申  7945 	    move_gap_both (XINT (start), start_byte);
申鐃緒申  7946 	  else
申鐃緒申  7947 	    move_gap_both (XINT (end), end_byte);
申鐃緒申  7948 	}
申鐃緒申  7949     }
申鐃緒申  7950 
申鐃緒申  7951   coding_attrs_list = Qnil;
申鐃緒申  7952   for (tail = Vcoding_system_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  7953     if (NILP (exclude)
申鐃緒申  7954 	|| NILP (Fmemq (XCAR (tail), exclude)))
申鐃緒申  7955       {
申鐃緒申  7956 	Lisp_Object attrs;
申鐃緒申  7957 
申鐃緒申  7958 	attrs = AREF (CODING_SYSTEM_SPEC (XCAR (tail)), 0);
申鐃緒申  7959 	if (EQ (XCAR (tail), CODING_ATTR_BASE_NAME (attrs))
申鐃緒申  7960 	    && ! EQ (CODING_ATTR_TYPE (attrs), Qundecided))
申鐃緒申  7961 	  {
申鐃緒申  7962 	    ASET (attrs, coding_attr_trans_tbl,
申鐃緒申  7963 		  get_translation_table (attrs, 1, NULL));
申鐃緒申  7964 	    coding_attrs_list = Fcons (attrs, coding_attrs_list);
申鐃緒申  7965 	  }
申鐃緒申  7966       }
申鐃緒申  7967 
申鐃緒申  7968   if (STRINGP (start))
申鐃緒申  7969     p = pbeg = SDATA (start);
申鐃緒申  7970   else
申鐃緒申  7971     p = pbeg = BYTE_POS_ADDR (start_byte);
申鐃緒申  7972   pend = p + (end_byte - start_byte);
申鐃緒申  7973 
申鐃緒申  7974   while (p < pend && ASCII_BYTE_P (*p)) p++;
申鐃緒申  7975   while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
申鐃緒申  7976 
申鐃緒申  7977   while (p < pend)
申鐃緒申  7978     {
申鐃緒申  7979       if (ASCII_BYTE_P (*p))
申鐃緒申  7980 	p++;
申鐃緒申  7981       else
申鐃緒申  7982 	{
申鐃緒申  7983 	  c = STRING_CHAR_ADVANCE (p);
申鐃緒申  7984 
申鐃緒申  7985 	  charset_map_loaded = 0;
申鐃緒申  7986 	  for (tail = coding_attrs_list; CONSP (tail);)
申鐃緒申  7987 	    {
申鐃緒申  7988 	      elt = XCAR (tail);
申鐃緒申  7989 	      if (NILP (elt))
申鐃緒申  7990 		tail = XCDR (tail);
申鐃緒申  7991 	      else if (char_encodable_p (c, elt))
申鐃緒申  7992 		tail = XCDR (tail);
申鐃緒申  7993 	      else if (CONSP (XCDR (tail)))
申鐃緒申  7994 		{
申鐃緒申  7995 		  XSETCAR (tail, XCAR (XCDR (tail)));
申鐃緒申  7996 		  XSETCDR (tail, XCDR (XCDR (tail)));
申鐃緒申  7997 		}
申鐃緒申  7998 	      else
申鐃緒申  7999 		{
申鐃緒申  8000 		  XSETCAR (tail, Qnil);
申鐃緒申  8001 		  tail = XCDR (tail);
申鐃緒申  8002 		}
申鐃緒申  8003 	    }
申鐃緒申  8004 	  if (charset_map_loaded)
申鐃緒申  8005 	    {
申鐃緒申  8006 	      EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
申鐃緒申  8007 
申鐃緒申  8008 	      if (STRINGP (start))
申鐃緒申  8009 		pbeg = SDATA (start);
申鐃緒申  8010 	      else
申鐃緒申  8011 		pbeg = BYTE_POS_ADDR (start_byte);
申鐃緒申  8012 	      p = pbeg + p_offset;
申鐃緒申  8013 	      pend = pbeg + pend_offset;
申鐃緒申  8014 	    }
申鐃緒申  8015 	}
申鐃緒申  8016     }
申鐃緒申  8017 
申鐃緒申  8018   safe_codings = list2 (Qraw_text, Qno_conversion);
申鐃緒申  8019   for (tail = coding_attrs_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8020     if (! NILP (XCAR (tail)))
申鐃緒申  8021       safe_codings = Fcons (CODING_ATTR_BASE_NAME (XCAR (tail)), safe_codings);
申鐃緒申  8022 
申鐃緒申  8023   return safe_codings;
申鐃緒申  8024 }
申鐃緒申  8025 
申鐃緒申  8026 
申鐃緒申  8027 DEFUN ("unencodable-char-position", Funencodable_char_position,
申鐃緒申  8028        Sunencodable_char_position, 3, 5, 0,
申鐃緒申  8029        doc: /*
申鐃緒申  8030 Return position of first un-encodable character in a region.
申鐃緒申  8031 START and END specfiy the region and CODING-SYSTEM specifies the
申鐃緒申  8032 encoding to check.  Return nil if CODING-SYSTEM does encode the region.
申鐃緒申  8033 
申鐃緒申  8034 If optional 4th argument COUNT is non-nil, it specifies at most how
申鐃緒申  8035 many un-encodable characters to search.  In this case, the value is a
申鐃緒申  8036 list of positions.
申鐃緒申  8037 
申鐃緒申  8038 If optional 5th argument STRING is non-nil, it is a string to search
申鐃緒申  8039 for un-encodable characters.  In that case, START and END are indexes
申鐃緒申  8040 to the string.  */)
申鐃緒申  8041      (start, end, coding_system, count, string)
申鐃緒申  8042      Lisp_Object start, end, coding_system, count, string;
申鐃緒申  8043 {
申鐃緒申  8044   int n;
申鐃緒申  8045   struct coding_system coding;
申鐃緒申  8046   Lisp_Object attrs, charset_list, translation_table;
申鐃緒申  8047   Lisp_Object positions;
申鐃緒申  8048   int from, to;
申鐃緒申  8049   const unsigned char *p, *stop, *pend;
申鐃緒申  8050   int ascii_compatible;
申鐃緒申  8051 
申鐃緒申  8052   setup_coding_system (Fcheck_coding_system (coding_system), &coding);
申鐃緒申  8053   attrs = CODING_ID_ATTRS (coding.id);
申鐃緒申  8054   if (EQ (CODING_ATTR_TYPE (attrs), Qraw_text))
申鐃緒申  8055     return Qnil;
申鐃緒申  8056   ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
申鐃緒申  8057   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  8058   translation_table = get_translation_table (attrs, 1, NULL);
申鐃緒申  8059 
申鐃緒申  8060   if (NILP (string))
申鐃緒申  8061     {
申鐃緒申  8062       validate_region (&start, &end);
申鐃緒申  8063       from = XINT (start);
申鐃緒申  8064       to = XINT (end);
申鐃緒申  8065       if (NILP (current_buffer->enable_multibyte_characters)
申鐃緒申  8066 	  || (ascii_compatible
申鐃緒申  8067 	      && (to - from) == (CHAR_TO_BYTE (to) - (CHAR_TO_BYTE (from)))))
申鐃緒申  8068 	return Qnil;
申鐃緒申  8069       p = CHAR_POS_ADDR (from);
申鐃緒申  8070       pend = CHAR_POS_ADDR (to);
申鐃緒申  8071       if (from < GPT && to >= GPT)
申鐃緒申  8072 	stop = GPT_ADDR;
申鐃緒申  8073       else
申鐃緒申  8074 	stop = pend;
申鐃緒申  8075     }
申鐃緒申  8076   else
申鐃緒申  8077     {
申鐃緒申  8078       CHECK_STRING (string);
申鐃緒申  8079       CHECK_NATNUM (start);
申鐃緒申  8080       CHECK_NATNUM (end);
申鐃緒申  8081       from = XINT (start);
申鐃緒申  8082       to = XINT (end);
申鐃緒申  8083       if (from > to
申鐃緒申  8084 	  || to > SCHARS (string))
申鐃緒申  8085 	args_out_of_range_3 (string, start, end);
申鐃緒申  8086       if (! STRING_MULTIBYTE (string))
申鐃緒申  8087 	return Qnil;
申鐃緒申  8088       p = SDATA (string) + string_char_to_byte (string, from);
申鐃緒申  8089       stop = pend = SDATA (string) + string_char_to_byte (string, to);
申鐃緒申  8090       if (ascii_compatible && (to - from) == (pend - p))
申鐃緒申  8091 	return Qnil;
申鐃緒申  8092     }
申鐃緒申  8093 
申鐃緒申  8094   if (NILP (count))
申鐃緒申  8095     n = 1;
申鐃緒申  8096   else
申鐃緒申  8097     {
申鐃緒申  8098       CHECK_NATNUM (count);
申鐃緒申  8099       n = XINT (count);
申鐃緒申  8100     }
申鐃緒申  8101 
申鐃緒申  8102   positions = Qnil;
申鐃緒申  8103   while (1)
申鐃緒申  8104     {
申鐃緒申  8105       int c;
申鐃緒申  8106 
申鐃緒申  8107       if (ascii_compatible)
申鐃緒申  8108 	while (p < stop && ASCII_BYTE_P (*p))
申鐃緒申  8109 	  p++, from++;
申鐃緒申  8110       if (p >= stop)
申鐃緒申  8111 	{
申鐃緒申  8112 	  if (p >= pend)
申鐃緒申  8113 	    break;
申鐃緒申  8114 	  stop = pend;
申鐃緒申  8115 	  p = GAP_END_ADDR;
申鐃緒申  8116 	}
申鐃緒申  8117 
申鐃緒申  8118       c = STRING_CHAR_ADVANCE (p);
申鐃緒申  8119       if (! (ASCII_CHAR_P (c) && ascii_compatible)
申鐃緒申  8120 	  && ! char_charset (translate_char (translation_table, c),
申鐃緒申  8121 			     charset_list, NULL))
申鐃緒申  8122 	{
申鐃緒申  8123 	  positions = Fcons (make_number (from), positions);
申鐃緒申  8124 	  n--;
申鐃緒申  8125 	  if (n == 0)
申鐃緒申  8126 	    break;
申鐃緒申  8127 	}
申鐃緒申  8128 
申鐃緒申  8129       from++;
申鐃緒申  8130     }
申鐃緒申  8131 
申鐃緒申  8132   return (NILP (count) ? Fcar (positions) : Fnreverse (positions));
申鐃緒申  8133 }
申鐃緒申  8134 
申鐃緒申  8135 
申鐃緒申  8136 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region,
申鐃緒申  8137        Scheck_coding_systems_region, 3, 3, 0,
申鐃緒申  8138        doc: /* Check if the region is encodable by coding systems.
申鐃緒申  8139 
申鐃緒申  8140 START and END are buffer positions specifying the region.
申鐃緒申  8141 CODING-SYSTEM-LIST is a list of coding systems to check.
申鐃緒申  8142 
申鐃緒申  8143 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
申鐃緒申  8144 CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
申鐃緒申  8145 whole region, POS0, POS1, ... are buffer positions where non-encodable
申鐃緒申  8146 characters are found.
申鐃緒申  8147 
申鐃緒申  8148 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
申鐃緒申  8149 value is nil.
申鐃緒申  8150 
申鐃緒申  8151 START may be a string.  In that case, check if the string is
申鐃緒申  8152 encodable, and the value contains indices to the string instead of
申鐃緒申  8153 buffer positions.  END is ignored.  */)
申鐃緒申  8154      (start, end, coding_system_list)
申鐃緒申  8155      Lisp_Object start, end, coding_system_list;
申鐃緒申  8156 {
申鐃緒申  8157   Lisp_Object list;
申鐃緒申  8158   EMACS_INT start_byte, end_byte;
申鐃緒申  8159   int pos;
申鐃緒申  8160   const unsigned char *p, *pbeg, *pend;
申鐃緒申  8161   int c;
申鐃緒申  8162   Lisp_Object tail, elt, attrs;
申鐃緒申  8163 
申鐃緒申  8164   if (STRINGP (start))
申鐃緒申  8165     {
申鐃緒申  8166       if (!STRING_MULTIBYTE (start)
申鐃緒申  8167 	  && SCHARS (start) != SBYTES (start))
申鐃緒申  8168 	return Qnil;
申鐃緒申  8169       start_byte = 0;
申鐃緒申  8170       end_byte = SBYTES (start);
申鐃緒申  8171       pos = 0;
申鐃緒申  8172     }
申鐃緒申  8173   else
申鐃緒申  8174     {
申鐃緒申  8175       CHECK_NUMBER_COERCE_MARKER (start);
申鐃緒申  8176       CHECK_NUMBER_COERCE_MARKER (end);
申鐃緒申  8177       if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
申鐃緒申  8178 	args_out_of_range (start, end);
申鐃緒申  8179       if (NILP (current_buffer->enable_multibyte_characters))
申鐃緒申  8180 	return Qnil;
申鐃緒申  8181       start_byte = CHAR_TO_BYTE (XINT (start));
申鐃緒申  8182       end_byte = CHAR_TO_BYTE (XINT (end));
申鐃緒申  8183       if (XINT (end) - XINT (start) == end_byte - start_byte)
申鐃緒申  8184 	return Qt;
申鐃緒申  8185 
申鐃緒申  8186       if (XINT (start) < GPT && XINT (end) > GPT)
申鐃緒申  8187 	{
申鐃緒申  8188 	  if ((GPT - XINT (start)) < (XINT (end) - GPT))
申鐃緒申  8189 	    move_gap_both (XINT (start), start_byte);
申鐃緒申  8190 	  else
申鐃緒申  8191 	    move_gap_both (XINT (end), end_byte);
申鐃緒申  8192 	}
申鐃緒申  8193       pos = XINT (start);
申鐃緒申  8194     }
申鐃緒申  8195 
申鐃緒申  8196   list = Qnil;
申鐃緒申  8197   for (tail = coding_system_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8198     {
申鐃緒申  8199       elt = XCAR (tail);
申鐃緒申  8200       attrs = AREF (CODING_SYSTEM_SPEC (elt), 0);
申鐃緒申  8201       ASET (attrs, coding_attr_trans_tbl,
申鐃緒申  8202 	    get_translation_table (attrs, 1, NULL));
申鐃緒申  8203       list = Fcons (Fcons (elt, Fcons (attrs, Qnil)), list);
申鐃緒申  8204     }
申鐃緒申  8205 
申鐃緒申  8206   if (STRINGP (start))
申鐃緒申  8207     p = pbeg = SDATA (start);
申鐃緒申  8208   else
申鐃緒申  8209     p = pbeg = BYTE_POS_ADDR (start_byte);
申鐃緒申  8210   pend = p + (end_byte - start_byte);
申鐃緒申  8211 
申鐃緒申  8212   while (p < pend && ASCII_BYTE_P (*p)) p++, pos++;
申鐃緒申  8213   while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
申鐃緒申  8214 
申鐃緒申  8215   while (p < pend)
申鐃緒申  8216     {
申鐃緒申  8217       if (ASCII_BYTE_P (*p))
申鐃緒申  8218 	p++;
申鐃緒申  8219       else
申鐃緒申  8220 	{
申鐃緒申  8221 	  c = STRING_CHAR_ADVANCE (p);
申鐃緒申  8222 
申鐃緒申  8223 	  charset_map_loaded = 0;
申鐃緒申  8224 	  for (tail = list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8225 	    {
申鐃緒申  8226 	      elt = XCDR (XCAR (tail));
申鐃緒申  8227 	      if (! char_encodable_p (c, XCAR (elt)))
申鐃緒申  8228 		XSETCDR (elt, Fcons (make_number (pos), XCDR (elt)));
申鐃緒申  8229 	    }
申鐃緒申  8230 	  if (charset_map_loaded)
申鐃緒申  8231 	    {
申鐃緒申  8232 	      EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
申鐃緒申  8233 
申鐃緒申  8234 	      if (STRINGP (start))
申鐃緒申  8235 		pbeg = SDATA (start);
申鐃緒申  8236 	      else
申鐃緒申  8237 		pbeg = BYTE_POS_ADDR (start_byte);
申鐃緒申  8238 	      p = pbeg + p_offset;
申鐃緒申  8239 	      pend = pbeg + pend_offset;
申鐃緒申  8240 	    }
申鐃緒申  8241 	}
申鐃緒申  8242       pos++;
申鐃緒申  8243     }
申鐃緒申  8244 
申鐃緒申  8245   tail = list;
申鐃緒申  8246   list = Qnil;
申鐃緒申  8247   for (; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8248     {
申鐃緒申  8249       elt = XCAR (tail);
申鐃緒申  8250       if (CONSP (XCDR (XCDR (elt))))
申鐃緒申  8251 	list = Fcons (Fcons (XCAR (elt), Fnreverse (XCDR (XCDR (elt)))),
申鐃緒申  8252 		      list);
申鐃緒申  8253     }
申鐃緒申  8254 
申鐃緒申  8255   return list;
申鐃緒申  8256 }
申鐃緒申  8257 
申鐃緒申  8258 
申鐃緒申  8259 Lisp_Object
申鐃緒申  8260 code_convert_region (start, end, coding_system, dst_object, encodep, norecord)
申鐃緒申  8261      Lisp_Object start, end, coding_system, dst_object;
申鐃緒申  8262      int encodep, norecord;
申鐃緒申  8263 {
申鐃緒申  8264   struct coding_system coding;
申鐃緒申  8265   EMACS_INT from, from_byte, to, to_byte;
申鐃緒申  8266   Lisp_Object src_object;
申鐃緒申  8267 
申鐃緒申  8268   CHECK_NUMBER_COERCE_MARKER (start);
申鐃緒申  8269   CHECK_NUMBER_COERCE_MARKER (end);
申鐃緒申  8270   if (NILP (coding_system))
申鐃緒申  8271     coding_system = Qno_conversion;
申鐃緒申  8272   else
申鐃緒申  8273     CHECK_CODING_SYSTEM (coding_system);
申鐃緒申  8274   src_object = Fcurrent_buffer ();
申鐃緒申  8275   if (NILP (dst_object))
申鐃緒申  8276     dst_object = src_object;
申鐃緒申  8277   else if (! EQ (dst_object, Qt))
申鐃緒申  8278     CHECK_BUFFER (dst_object);
申鐃緒申  8279 
申鐃緒申  8280   validate_region (&start, &end);
申鐃緒申  8281   from = XFASTINT (start);
申鐃緒申  8282   from_byte = CHAR_TO_BYTE (from);
申鐃緒申  8283   to = XFASTINT (end);
申鐃緒申  8284   to_byte = CHAR_TO_BYTE (to);
申鐃緒申  8285 
申鐃緒申  8286   setup_coding_system (coding_system, &coding);
申鐃緒申  8287   coding.mode |= CODING_MODE_LAST_BLOCK;
申鐃緒申  8288 
申鐃緒申  8289   if (encodep)
申鐃緒申  8290     encode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
申鐃緒申  8291 			  dst_object);
申鐃緒申  8292   else
申鐃緒申  8293     decode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
申鐃緒申  8294 			  dst_object);
申鐃緒申  8295   if (! norecord)
申鐃緒申  8296     Vlast_coding_system_used = CODING_ID_NAME (coding.id);
申鐃緒申  8297 
申鐃緒申  8298   return (BUFFERP (dst_object)
申鐃緒申  8299 	  ? make_number (coding.produced_char)
申鐃緒申  8300 	  : coding.dst_object);
申鐃緒申  8301 }
申鐃緒申  8302 
申鐃緒申  8303 
申鐃緒申  8304 DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
申鐃緒申  8305        3, 4, "r\nzCoding system: ",
申鐃緒申  8306        doc: /* Decode the current region from the specified coding system.
申鐃緒申  8307 When called from a program, takes four arguments:
申鐃緒申  8308 	START, END, CODING-SYSTEM, and DESTINATION.
申鐃緒申  8309 START and END are buffer positions.
申鐃緒申  8310 
申鐃緒申  8311 Optional 4th arguments DESTINATION specifies where the decoded text goes.
申鐃緒申  8312 If nil, the region between START and END is replaced by the decoded text.
申鐃緒申  8313 If buffer, the decoded text is inserted in the buffer.
申鐃緒申  8314 If t, the decoded text is returned.
申鐃緒申  8315 
申鐃緒申  8316 This function sets `last-coding-system-used' to the precise coding system
申鐃緒申  8317 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
申鐃緒申  8318 not fully specified.)
申鐃緒申  8319 It returns the length of the decoded text.  */)
申鐃緒申  8320      (start, end, coding_system, destination)
申鐃緒申  8321      Lisp_Object start, end, coding_system, destination;
申鐃緒申  8322 {
申鐃緒申  8323   return code_convert_region (start, end, coding_system, destination, 0, 0);
申鐃緒申  8324 }
申鐃緒申  8325 
申鐃緒申  8326 DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
申鐃緒申  8327        3, 4, "r\nzCoding system: ",
申鐃緒申  8328        doc: /* Encode the current region by specified coding system.
申鐃緒申  8329 When called from a program, takes three arguments:
申鐃緒申  8330 START, END, and CODING-SYSTEM.  START and END are buffer positions.
申鐃緒申  8331 
申鐃緒申  8332 Optional 4th arguments DESTINATION specifies where the encoded text goes.
申鐃緒申  8333 If nil, the region between START and END is replace by the encoded text.
申鐃緒申  8334 If buffer, the encoded text is inserted in the buffer.
申鐃緒申  8335 If t, the encoded text is returned.
申鐃緒申  8336 
申鐃緒申  8337 This function sets `last-coding-system-used' to the precise coding system
申鐃緒申  8338 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
申鐃緒申  8339 not fully specified.)
申鐃緒申  8340 It returns the length of the encoded text.  */)
申鐃緒申  8341   (start, end, coding_system, destination)
申鐃緒申  8342      Lisp_Object start, end, coding_system, destination;
申鐃緒申  8343 {
申鐃緒申  8344   return code_convert_region (start, end, coding_system, destination, 1, 0);
申鐃緒申  8345 }
申鐃緒申  8346 
申鐃緒申  8347 Lisp_Object
申鐃緒申  8348 code_convert_string (string, coding_system, dst_object,
申鐃緒申  8349 		     encodep, nocopy, norecord)
申鐃緒申  8350      Lisp_Object string, coding_system, dst_object;
申鐃緒申  8351      int encodep, nocopy, norecord;
申鐃緒申  8352 {
申鐃緒申  8353   struct coding_system coding;
申鐃緒申  8354   EMACS_INT chars, bytes;
申鐃緒申  8355 
申鐃緒申  8356   CHECK_STRING (string);
申鐃緒申  8357   if (NILP (coding_system))
申鐃緒申  8358     {
申鐃緒申  8359       if (! norecord)
申鐃緒申  8360 	Vlast_coding_system_used = Qno_conversion;
申鐃緒申  8361       if (NILP (dst_object))
申鐃緒申  8362 	return (nocopy ? Fcopy_sequence (string) : string);
申鐃緒申  8363     }
申鐃緒申  8364 
申鐃緒申  8365   if (NILP (coding_system))
申鐃緒申  8366     coding_system = Qno_conversion;
申鐃緒申  8367   else
申鐃緒申  8368     CHECK_CODING_SYSTEM (coding_system);
申鐃緒申  8369   if (NILP (dst_object))
申鐃緒申  8370     dst_object = Qt;
申鐃緒申  8371   else if (! EQ (dst_object, Qt))
申鐃緒申  8372     CHECK_BUFFER (dst_object);
申鐃緒申  8373 
申鐃緒申  8374   setup_coding_system (coding_system, &coding);
申鐃緒申  8375   coding.mode |= CODING_MODE_LAST_BLOCK;
申鐃緒申  8376   chars = SCHARS (string);
申鐃緒申  8377   bytes = SBYTES (string);
申鐃緒申  8378   if (encodep)
申鐃緒申  8379     encode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
申鐃緒申  8380   else
申鐃緒申  8381     decode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
申鐃緒申  8382   if (! norecord)
申鐃緒申  8383     Vlast_coding_system_used = CODING_ID_NAME (coding.id);
申鐃緒申  8384 
申鐃緒申  8385   return (BUFFERP (dst_object)
申鐃緒申  8386 	  ? make_number (coding.produced_char)
申鐃緒申  8387 	  : coding.dst_object);
申鐃緒申  8388 }
申鐃緒申  8389 
申鐃緒申  8390 
申鐃緒申  8391 /* Encode or decode STRING according to CODING_SYSTEM.
申鐃緒申  8392    Do not set Vlast_coding_system_used.
申鐃緒申  8393 
申鐃緒申  8394    This function is called only from macros DECODE_FILE and
申鐃緒申  8395    ENCODE_FILE, thus we ignore character composition.  */
申鐃緒申  8396 
申鐃緒申  8397 Lisp_Object
申鐃緒申  8398 code_convert_string_norecord (string, coding_system, encodep)
申鐃緒申  8399      Lisp_Object string, coding_system;
申鐃緒申  8400      int encodep;
申鐃緒申  8401 {
申鐃緒申  8402   return code_convert_string (string, coding_system, Qt, encodep, 0, 1);
申鐃緒申  8403 }
申鐃緒申  8404 
申鐃緒申  8405 
申鐃緒申  8406 DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
申鐃緒申  8407        2, 4, 0,
申鐃緒申  8408        doc: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
申鐃緒申  8409 
申鐃緒申  8410 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
申鐃緒申  8411 if the decoding operation is trivial.
申鐃緒申  8412 
申鐃緒申  8413 Optional fourth arg BUFFER non-nil meant that the decoded text is
申鐃緒申  8414 inserted in BUFFER instead of returned as a string.  In this case,
申鐃緒申  8415 the return value is BUFFER.
申鐃緒申  8416 
申鐃緒申  8417 This function sets `last-coding-system-used' to the precise coding system
申鐃緒申  8418 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
申鐃緒申  8419 not fully specified.  */)
申鐃緒申  8420   (string, coding_system, nocopy, buffer)
申鐃緒申  8421      Lisp_Object string, coding_system, nocopy, buffer;
申鐃緒申  8422 {
申鐃緒申  8423   return code_convert_string (string, coding_system, buffer,
申鐃緒申  8424 			      0, ! NILP (nocopy), 0);
申鐃緒申  8425 }
申鐃緒申  8426 
申鐃緒申  8427 DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
申鐃緒申  8428        2, 4, 0,
申鐃緒申  8429        doc: /* Encode STRING to CODING-SYSTEM, and return the result.
申鐃緒申  8430 
申鐃緒申  8431 Optional third arg NOCOPY non-nil means it is OK to return STRING
申鐃緒申  8432 itself if the encoding operation is trivial.
申鐃緒申  8433 
申鐃緒申  8434 Optional fourth arg BUFFER non-nil meant that the encoded text is
申鐃緒申  8435 inserted in BUFFER instead of returned as a string.  In this case,
申鐃緒申  8436 the return value is BUFFER.
申鐃緒申  8437 
申鐃緒申  8438 This function sets `last-coding-system-used' to the precise coding system
申鐃緒申  8439 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
申鐃緒申  8440 not fully specified.)  */)
申鐃緒申  8441      (string, coding_system, nocopy, buffer)
申鐃緒申  8442      Lisp_Object string, coding_system, nocopy, buffer;
申鐃緒申  8443 {
申鐃緒申  8444   return code_convert_string (string, coding_system, buffer,
申鐃緒申  8445 			      1, ! NILP (nocopy), 1);
申鐃緒申  8446 }
申鐃緒申  8447 
申鐃緒申  8448 
申鐃緒申  8449 DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
申鐃緒申  8450        doc: /* Decode a Japanese character which has CODE in shift_jis encoding.
申鐃緒申  8451 Return the corresponding character.  */)
申鐃緒申  8452      (code)
申鐃緒申  8453      Lisp_Object code;
申鐃緒申  8454 {
申鐃緒申  8455   Lisp_Object spec, attrs, val;
申鐃緒申  8456   struct charset *charset_roman, *charset_kanji, *charset_kana, *charset;
申鐃緒申  8457   int c;
申鐃緒申  8458 
申鐃緒申  8459   CHECK_NATNUM (code);
申鐃緒申  8460   c = XFASTINT (code);
申鐃緒申  8461   CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
申鐃緒申  8462   attrs = AREF (spec, 0);
申鐃緒申  8463 
申鐃緒申  8464   if (ASCII_BYTE_P (c)
申鐃緒申  8465       && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  8466     return code;
申鐃緒申  8467 
申鐃緒申  8468   val = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  8469   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  8470   charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  8471   charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  8472 
申鐃緒申  8473   if (c <= 0x7F)
申鐃緒申  8474     charset = charset_roman;
申鐃緒申  8475   else if (c >= 0xA0 && c < 0xDF)
申鐃緒申  8476     {
申鐃緒申  8477       charset = charset_kana;
申鐃緒申  8478       c -= 0x80;
申鐃緒申  8479     }
申鐃緒申  8480   else
申鐃緒申  8481     {
申鐃緒申  8482       int s1 = c >> 8, s2 = c & 0xFF;
申鐃緒申  8483 
申鐃緒申  8484       if (s1 < 0x81 || (s1 > 0x9F && s1 < 0xE0) || s1 > 0xEF
申鐃緒申  8485 	  || s2 < 0x40 || s2 == 0x7F || s2 > 0xFC)
申鐃緒申  8486 	error ("Invalid code: %d", code);
申鐃緒申  8487       SJIS_TO_JIS (c);
申鐃緒申  8488       charset = charset_kanji;
申鐃緒申  8489     }
申鐃緒申  8490   c = DECODE_CHAR (charset, c);
申鐃緒申  8491   if (c < 0)
申鐃緒申  8492     error ("Invalid code: %d", code);
申鐃緒申  8493   return make_number (c);
申鐃緒申  8494 }
申鐃緒申  8495 
申鐃緒申  8496 
申鐃緒申  8497 DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
申鐃緒申  8498        doc: /* Encode a Japanese character CH to shift_jis encoding.
申鐃緒申  8499 Return the corresponding code in SJIS.  */)
申鐃緒申  8500      (ch)
申鐃緒申  8501     Lisp_Object ch;
申鐃緒申  8502 {
申鐃緒申  8503   Lisp_Object spec, attrs, charset_list;
申鐃緒申  8504   int c;
申鐃緒申  8505   struct charset *charset;
申鐃緒申  8506   unsigned code;
申鐃緒申  8507 
申鐃緒申  8508   CHECK_CHARACTER (ch);
申鐃緒申  8509   c = XFASTINT (ch);
申鐃緒申  8510   CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
申鐃緒申  8511   attrs = AREF (spec, 0);
申鐃緒申  8512 
申鐃緒申  8513   if (ASCII_CHAR_P (c)
申鐃緒申  8514       && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  8515     return ch;
申鐃緒申  8516 
申鐃緒申  8517   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  8518   charset = char_charset (c, charset_list, &code);
申鐃緒申  8519   if (code == CHARSET_INVALID_CODE (charset))
申鐃緒申  8520     error ("Can't encode by shift_jis encoding: %d", c);
申鐃緒申  8521   JIS_TO_SJIS (code);
申鐃緒申  8522 
申鐃緒申  8523   return make_number (code);
申鐃緒申  8524 }
申鐃緒申  8525 
申鐃緒申  8526 DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
申鐃緒申  8527        doc: /* Decode a Big5 character which has CODE in BIG5 coding system.
申鐃緒申  8528 Return the corresponding character.  */)
申鐃緒申  8529      (code)
申鐃緒申  8530      Lisp_Object code;
申鐃緒申  8531 {
申鐃緒申  8532   Lisp_Object spec, attrs, val;
申鐃緒申  8533   struct charset *charset_roman, *charset_big5, *charset;
申鐃緒申  8534   int c;
申鐃緒申  8535 
申鐃緒申  8536   CHECK_NATNUM (code);
申鐃緒申  8537   c = XFASTINT (code);
申鐃緒申  8538   CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
申鐃緒申  8539   attrs = AREF (spec, 0);
申鐃緒申  8540 
申鐃緒申  8541   if (ASCII_BYTE_P (c)
申鐃緒申  8542       && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  8543     return code;
申鐃緒申  8544 
申鐃緒申  8545   val = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  8546   charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
申鐃緒申  8547   charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
申鐃緒申  8548 
申鐃緒申  8549   if (c <= 0x7F)
申鐃緒申  8550     charset = charset_roman;
申鐃緒申  8551   else
申鐃緒申  8552     {
申鐃緒申  8553       int b1 = c >> 8, b2 = c & 0x7F;
申鐃緒申  8554       if (b1 < 0xA1 || b1 > 0xFE
申鐃緒申  8555 	  || b2 < 0x40 || (b2 > 0x7E && b2 < 0xA1) || b2 > 0xFE)
申鐃緒申  8556 	error ("Invalid code: %d", code);
申鐃緒申  8557       charset = charset_big5;
申鐃緒申  8558     }
申鐃緒申  8559   c = DECODE_CHAR (charset, (unsigned )c);
申鐃緒申  8560   if (c < 0)
申鐃緒申  8561     error ("Invalid code: %d", code);
申鐃緒申  8562   return make_number (c);
申鐃緒申  8563 }
申鐃緒申  8564 
申鐃緒申  8565 DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
申鐃緒申  8566        doc: /* Encode the Big5 character CH to BIG5 coding system.
申鐃緒申  8567 Return the corresponding character code in Big5.  */)
申鐃緒申  8568      (ch)
申鐃緒申  8569      Lisp_Object ch;
申鐃緒申  8570 {
申鐃緒申  8571   Lisp_Object spec, attrs, charset_list;
申鐃緒申  8572   struct charset *charset;
申鐃緒申  8573   int c;
申鐃緒申  8574   unsigned code;
申鐃緒申  8575 
申鐃緒申  8576   CHECK_CHARACTER (ch);
申鐃緒申  8577   c = XFASTINT (ch);
申鐃緒申  8578   CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
申鐃緒申  8579   attrs = AREF (spec, 0);
申鐃緒申  8580   if (ASCII_CHAR_P (c)
申鐃緒申  8581       && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
申鐃緒申  8582     return ch;
申鐃緒申  8583 
申鐃緒申  8584   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
申鐃緒申  8585   charset = char_charset (c, charset_list, &code);
申鐃緒申  8586   if (code == CHARSET_INVALID_CODE (charset))
申鐃緒申  8587     error ("Can't encode by Big5 encoding: %d", c);
申鐃緒申  8588 
申鐃緒申  8589   return make_number (code);
申鐃緒申  8590 }
申鐃緒申  8591 
申鐃緒申  8592 
申鐃緒申  8593 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal,
申鐃緒申  8594        Sset_terminal_coding_system_internal, 1, 2, 0,
申鐃緒申  8595        doc: /* Internal use only.  */)
申鐃緒申  8596      (coding_system, terminal)
申鐃緒申  8597      Lisp_Object coding_system;
申鐃緒申  8598      Lisp_Object terminal;
申鐃緒申  8599 {
申鐃緒申  8600   struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
申鐃緒申  8601   CHECK_SYMBOL (coding_system);
申鐃緒申  8602   setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
申鐃緒申  8603   /* We had better not send unsafe characters to terminal.  */
申鐃緒申  8604   terminal_coding->mode |= CODING_MODE_SAFE_ENCODING;
申鐃緒申  8605   /* Characer composition should be disabled.  */
申鐃緒申  8606   terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
申鐃緒申  8607   terminal_coding->src_multibyte = 1;
申鐃緒申  8608   terminal_coding->dst_multibyte = 0;
申鐃緒申  8609   return Qnil;
申鐃緒申  8610 }
申鐃緒申  8611 
申鐃緒申  8612 DEFUN ("set-safe-terminal-coding-system-internal",
申鐃緒申  8613        Fset_safe_terminal_coding_system_internal,
申鐃緒申  8614        Sset_safe_terminal_coding_system_internal, 1, 1, 0,
申鐃緒申  8615        doc: /* Internal use only.  */)
申鐃緒申  8616      (coding_system)
申鐃緒申  8617      Lisp_Object coding_system;
申鐃緒申  8618 {
申鐃緒申  8619   CHECK_SYMBOL (coding_system);
申鐃緒申  8620   setup_coding_system (Fcheck_coding_system (coding_system),
申鐃緒申  8621 		       &safe_terminal_coding);
申鐃緒申  8622   /* Characer composition should be disabled.  */
申鐃緒申  8623   safe_terminal_coding.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
申鐃緒申  8624   safe_terminal_coding.src_multibyte = 1;
申鐃緒申  8625   safe_terminal_coding.dst_multibyte = 0;
申鐃緒申  8626   return Qnil;
申鐃緒申  8627 }
申鐃緒申  8628 
申鐃緒申  8629 DEFUN ("terminal-coding-system", Fterminal_coding_system,
申鐃緒申  8630        Sterminal_coding_system, 0, 1, 0,
申鐃緒申  8631        doc: /* Return coding system specified for terminal output on the given terminal.
申鐃緒申  8632 TERMINAL may be a terminal id, a frame, or nil for the selected
申鐃緒申  8633 frame's terminal device.  */)
申鐃緒申  8634      (terminal)
申鐃緒申  8635      Lisp_Object terminal;
申鐃緒申  8636 {
申鐃緒申  8637   struct coding_system *terminal_coding
申鐃緒申  8638     = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
申鐃緒申  8639   Lisp_Object coding_system = CODING_ID_NAME (terminal_coding->id);
申鐃緒申  8640 
申鐃緒申  8641   /* For backward compatibility, return nil if it is `undecided'. */
申鐃緒申  8642   return (! EQ (coding_system, Qundecided) ? coding_system : Qnil);
申鐃緒申  8643 }
申鐃緒申  8644 
申鐃緒申  8645 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
申鐃緒申  8646        Sset_keyboard_coding_system_internal, 1, 2, 0,
申鐃緒申  8647        doc: /* Internal use only.  */)
申鐃緒申  8648      (coding_system, terminal)
申鐃緒申  8649      Lisp_Object coding_system;
申鐃緒申  8650      Lisp_Object terminal;
申鐃緒申  8651 {
申鐃緒申  8652   struct terminal *t = get_terminal (terminal, 1);
申鐃緒申  8653   CHECK_SYMBOL (coding_system);
申鐃緒申  8654   setup_coding_system (Fcheck_coding_system (coding_system),
申鐃緒申  8655 		       TERMINAL_KEYBOARD_CODING (t));
申鐃緒申  8656   /* Characer composition should be disabled.  */
申鐃緒申  8657   TERMINAL_KEYBOARD_CODING (t)->common_flags
申鐃緒申  8658     &= ~CODING_ANNOTATE_COMPOSITION_MASK;
申鐃緒申  8659   return Qnil;
申鐃緒申  8660 }
申鐃緒申  8661 
申鐃緒申  8662 DEFUN ("keyboard-coding-system",
申鐃緒申  8663        Fkeyboard_coding_system, Skeyboard_coding_system, 0, 1, 0,
申鐃緒申  8664        doc: /* Return coding system specified for decoding keyboard input.  */)
申鐃緒申  8665      (terminal)
申鐃緒申  8666      Lisp_Object terminal;
申鐃緒申  8667 {
申鐃緒申  8668   return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
申鐃緒申  8669 			 (get_terminal (terminal, 1))->id);
申鐃緒申  8670 }
申鐃緒申  8671 
申鐃緒申  8672 
申鐃緒申  8673 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system,
申鐃緒申  8674        Sfind_operation_coding_system,  1, MANY, 0,
申鐃緒申  8675        doc: /* Choose a coding system for an operation based on the target name.
申鐃緒申  8676 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
申鐃緒申  8677 DECODING-SYSTEM is the coding system to use for decoding
申鐃緒申  8678 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
申鐃緒申  8679 for encoding (in case OPERATION does encoding).
申鐃緒申  8680 
申鐃緒申  8681 The first argument OPERATION specifies an I/O primitive:
申鐃緒申  8682   For file I/O, `insert-file-contents' or `write-region'.
申鐃緒申  8683   For process I/O, `call-process', `call-process-region', or `start-process'.
申鐃緒申  8684   For network I/O, `open-network-stream'.
申鐃緒申  8685 
申鐃緒申  8686 The remaining arguments should be the same arguments that were passed
申鐃緒申  8687 to the primitive.  Depending on which primitive, one of those arguments
申鐃緒申  8688 is selected as the TARGET.  For example, if OPERATION does file I/O,
申鐃緒申  8689 whichever argument specifies the file name is TARGET.
申鐃緒申  8690 
申鐃緒申  8691 TARGET has a meaning which depends on OPERATION:
申鐃緒申  8692   For file I/O, TARGET is a file name (except for the special case below).
申鐃緒申  8693   For process I/O, TARGET is a process name.
申鐃緒申  8694   For network I/O, TARGET is a service name or a port number
申鐃緒申  8695 
申鐃緒申  8696 This function looks up what specified for TARGET in,
申鐃緒申  8697 `file-coding-system-alist', `process-coding-system-alist',
申鐃緒申  8698 or `network-coding-system-alist' depending on OPERATION.
申鐃緒申  8699 They may specify a coding system, a cons of coding systems,
申鐃緒申  8700 or a function symbol to call.
申鐃緒申  8701 In the last case, we call the function with one argument,
申鐃緒申  8702 which is a list of all the arguments given to this function.
申鐃緒申  8703 If the function can't decide a coding system, it can return
申鐃緒申  8704 `undecided' so that the normal code-detection is performed.
申鐃緒申  8705 
申鐃緒申  8706 If OPERATION is `insert-file-contents', the argument corresponding to
申鐃緒申  8707 TARGET may be a cons (FILENAME . BUFFER).  In that case, FILENAME is a
申鐃緒申  8708 file name to look up, and BUFFER is a buffer that contains the file's
申鐃緒申  8709 contents (not yet decoded).  If `file-coding-system-alist' specifies a
申鐃緒申  8710 function to call for FILENAME, that function should examine the
申鐃緒申  8711 contents of BUFFER instead of reading the file.
申鐃緒申  8712 
申鐃緒申  8713 usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
申鐃緒申  8714      (nargs, args)
申鐃緒申  8715      int nargs;
申鐃緒申  8716      Lisp_Object *args;
申鐃緒申  8717 {
申鐃緒申  8718   Lisp_Object operation, target_idx, target, val;
申鐃緒申  8719   register Lisp_Object chain;
申鐃緒申  8720 
申鐃緒申  8721   if (nargs < 2)
申鐃緒申  8722     error ("Too few arguments");
申鐃緒申  8723   operation = args[0];
申鐃緒申  8724   if (!SYMBOLP (operation)
申鐃緒申  8725       || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
申鐃緒申  8726     error ("Invalid first argument");
申鐃緒申  8727   if (nargs < 1 + XINT (target_idx))
申鐃緒申  8728     error ("Too few arguments for operation: %s",
申鐃緒申  8729 	   SDATA (SYMBOL_NAME (operation)));
申鐃緒申  8730   target = args[XINT (target_idx) + 1];
申鐃緒申  8731   if (!(STRINGP (target)
申鐃緒申  8732 	|| (EQ (operation, Qinsert_file_contents) && CONSP (target)
申鐃緒申  8733 	    && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
申鐃緒申  8734 	|| (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
申鐃緒申  8735     error ("Invalid %dth argument", XINT (target_idx) + 1);
申鐃緒申  8736   if (CONSP (target))
申鐃緒申  8737     target = XCAR (target);
申鐃緒申  8738 
申鐃緒申  8739   chain = ((EQ (operation, Qinsert_file_contents)
申鐃緒申  8740 	    || EQ (operation, Qwrite_region))
申鐃緒申  8741 	   ? Vfile_coding_system_alist
申鐃緒申  8742 	   : (EQ (operation, Qopen_network_stream)
申鐃緒申  8743 	      ? Vnetwork_coding_system_alist
申鐃緒申  8744 	      : Vprocess_coding_system_alist));
申鐃緒申  8745   if (NILP (chain))
申鐃緒申  8746     return Qnil;
申鐃緒申  8747 
申鐃緒申  8748   for (; CONSP (chain); chain = XCDR (chain))
申鐃緒申  8749     {
申鐃緒申  8750       Lisp_Object elt;
申鐃緒申  8751 
申鐃緒申  8752       elt = XCAR (chain);
申鐃緒申  8753       if (CONSP (elt)
申鐃緒申  8754 	  && ((STRINGP (target)
申鐃緒申  8755 	       && STRINGP (XCAR (elt))
申鐃緒申  8756 	       && fast_string_match (XCAR (elt), target) >= 0)
申鐃緒申  8757 	      || (INTEGERP (target) && EQ (target, XCAR (elt)))))
申鐃緒申  8758 	{
申鐃緒申  8759 	  val = XCDR (elt);
申鐃緒申  8760 	  /* Here, if VAL is both a valid coding system and a valid
申鐃緒申  8761              function symbol, we return VAL as a coding system.  */
申鐃緒申  8762 	  if (CONSP (val))
申鐃緒申  8763 	    return val;
申鐃緒申  8764 	  if (! SYMBOLP (val))
申鐃緒申  8765 	    return Qnil;
申鐃緒申  8766 	  if (! NILP (Fcoding_system_p (val)))
申鐃緒申  8767 	    return Fcons (val, val);
申鐃緒申  8768 	  if (! NILP (Ffboundp (val)))
申鐃緒申  8769 	    {
申鐃緒申  8770 	      /* We use call1 rather than safe_call1
申鐃緒申  8771 		 so as to get bug reports about functions called here
申鐃緒申  8772 		 which don't handle the current interface.  */
申鐃緒申  8773 	      val = call1 (val, Flist (nargs, args));
申鐃緒申  8774 	      if (CONSP (val))
申鐃緒申  8775 		return val;
申鐃緒申  8776 	      if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
申鐃緒申  8777 		return Fcons (val, val);
申鐃緒申  8778 	    }
申鐃緒申  8779 	  return Qnil;
申鐃緒申  8780 	}
申鐃緒申  8781     }
申鐃緒申  8782   return Qnil;
申鐃緒申  8783 }
申鐃緒申  8784 
申鐃緒申  8785 DEFUN ("set-coding-system-priority", Fset_coding_system_priority,
申鐃緒申  8786        Sset_coding_system_priority, 0, MANY, 0,
申鐃緒申  8787        doc: /* Assign higher priority to the coding systems given as arguments.
申鐃緒申  8788 If multiple coding systems belongs to the same category,
申鐃緒申  8789 all but the first one are ignored.
申鐃緒申  8790 
申鐃緒申  8791 usage: (set-coding-system-priority ...)  */)
申鐃緒申  8792      (nargs, args)
申鐃緒申  8793      int nargs;
申鐃緒申  8794      Lisp_Object *args;
申鐃緒申  8795 {
申鐃緒申  8796   int i, j;
申鐃緒申  8797   int changed[coding_category_max];
申鐃緒申  8798   enum coding_category priorities[coding_category_max];
申鐃緒申  8799 
申鐃緒申  8800   bzero (changed, sizeof changed);
申鐃緒申  8801 
申鐃緒申  8802   for (i = j = 0; i < nargs; i++)
申鐃緒申  8803     {
申鐃緒申  8804       enum coding_category category;
申鐃緒申  8805       Lisp_Object spec, attrs;
申鐃緒申  8806 
申鐃緒申  8807       CHECK_CODING_SYSTEM_GET_SPEC (args[i], spec);
申鐃緒申  8808       attrs = AREF (spec, 0);
申鐃緒申  8809       category = XINT (CODING_ATTR_CATEGORY (attrs));
申鐃緒申  8810       if (changed[category])
申鐃緒申  8811 	/* Ignore this coding system because a coding system of the
申鐃緒申  8812 	   same category already had a higher priority.  */
申鐃緒申  8813 	continue;
申鐃緒申  8814       changed[category] = 1;
申鐃緒申  8815       priorities[j++] = category;
申鐃緒申  8816       if (coding_categories[category].id >= 0
申鐃緒申  8817 	  && ! EQ (args[i], CODING_ID_NAME (coding_categories[category].id)))
申鐃緒申  8818 	setup_coding_system (args[i], &coding_categories[category]);
申鐃緒申  8819       Fset (AREF (Vcoding_category_table, category), args[i]);
申鐃緒申  8820     }
申鐃緒申  8821 
申鐃緒申  8822   /* Now we have decided top J priorities.  Reflect the order of the
申鐃緒申  8823      original priorities to the remaining priorities.  */
申鐃緒申  8824 
申鐃緒申  8825   for (i = j, j = 0; i < coding_category_max; i++, j++)
申鐃緒申  8826     {
申鐃緒申  8827       while (j < coding_category_max
申鐃緒申  8828 	     && changed[coding_priorities[j]])
申鐃緒申  8829 	j++;
申鐃緒申  8830       if (j == coding_category_max)
申鐃緒申  8831 	abort ();
申鐃緒申  8832       priorities[i] = coding_priorities[j];
申鐃緒申  8833     }
申鐃緒申  8834 
申鐃緒申  8835   bcopy (priorities, coding_priorities, sizeof priorities);
申鐃緒申  8836 
申鐃緒申  8837   /* Update `coding-category-list'.  */
申鐃緒申  8838   Vcoding_category_list = Qnil;
申鐃緒申  8839   for (i = coding_category_max - 1; i >= 0; i--)
申鐃緒申  8840     Vcoding_category_list
申鐃緒申  8841       = Fcons (AREF (Vcoding_category_table, priorities[i]),
申鐃緒申  8842 	       Vcoding_category_list);
申鐃緒申  8843 
申鐃緒申  8844   return Qnil;
申鐃緒申  8845 }
申鐃緒申  8846 
申鐃緒申  8847 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list,
申鐃緒申  8848        Scoding_system_priority_list, 0, 1, 0,
申鐃緒申  8849        doc: /* Return a list of coding systems ordered by their priorities.
申鐃緒申  8850 HIGHESTP non-nil means just return the highest priority one.  */)
申鐃緒申  8851      (highestp)
申鐃緒申  8852      Lisp_Object highestp;
申鐃緒申  8853 {
申鐃緒申  8854   int i;
申鐃緒申  8855   Lisp_Object val;
申鐃緒申  8856 
申鐃緒申  8857   for (i = 0, val = Qnil; i < coding_category_max; i++)
申鐃緒申  8858     {
申鐃緒申  8859       enum coding_category category = coding_priorities[i];
申鐃緒申  8860       int id = coding_categories[category].id;
申鐃緒申  8861       Lisp_Object attrs;
申鐃緒申  8862 
申鐃緒申  8863       if (id < 0)
申鐃緒申  8864 	continue;
申鐃緒申  8865       attrs = CODING_ID_ATTRS (id);
申鐃緒申  8866       if (! NILP (highestp))
申鐃緒申  8867 	return CODING_ATTR_BASE_NAME (attrs);
申鐃緒申  8868       val = Fcons (CODING_ATTR_BASE_NAME (attrs), val);
申鐃緒申  8869     }
申鐃緒申  8870   return Fnreverse (val);
申鐃緒申  8871 }
申鐃緒申  8872 
申鐃緒申  8873 static char *suffixes[] = { "-unix", "-dos", "-mac" };
申鐃緒申  8874 
申鐃緒申  8875 static Lisp_Object
申鐃緒申  8876 make_subsidiaries (base)
申鐃緒申  8877      Lisp_Object base;
申鐃緒申  8878 {
申鐃緒申  8879   Lisp_Object subsidiaries;
申鐃緒申  8880   int base_name_len = SBYTES (SYMBOL_NAME (base));
申鐃緒申  8881   char *buf = (char *) alloca (base_name_len + 6);
申鐃緒申  8882   int i;
申鐃緒申  8883 
申鐃緒申  8884   bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
申鐃緒申  8885   subsidiaries = Fmake_vector (make_number (3), Qnil);
申鐃緒申  8886   for (i = 0; i < 3; i++)
申鐃緒申  8887     {
申鐃緒申  8888       bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
申鐃緒申  8889       ASET (subsidiaries, i, intern (buf));
申鐃緒申  8890     }
申鐃緒申  8891   return subsidiaries;
申鐃緒申  8892 }
申鐃緒申  8893 
申鐃緒申  8894 
申鐃緒申  8895 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal,
申鐃緒申  8896        Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
申鐃緒申  8897        doc: /* For internal use only.
申鐃緒申  8898 usage: (define-coding-system-internal ...)  */)
申鐃緒申  8899      (nargs, args)
申鐃緒申  8900      int nargs;
申鐃緒申  8901      Lisp_Object *args;
申鐃緒申  8902 {
申鐃緒申  8903   Lisp_Object name;
申鐃緒申  8904   Lisp_Object spec_vec;		/* [ ATTRS ALIASE EOL_TYPE ] */
申鐃緒申  8905   Lisp_Object attrs;		/* Vector of attributes.  */
申鐃緒申  8906   Lisp_Object eol_type;
申鐃緒申  8907   Lisp_Object aliases;
申鐃緒申  8908   Lisp_Object coding_type, charset_list, safe_charsets;
申鐃緒申  8909   enum coding_category category;
申鐃緒申  8910   Lisp_Object tail, val;
申鐃緒申  8911   int max_charset_id = 0;
申鐃緒申  8912   int i;
申鐃緒申  8913 
申鐃緒申  8914   if (nargs < coding_arg_max)
申鐃緒申  8915     goto short_args;
申鐃緒申  8916 
申鐃緒申  8917   attrs = Fmake_vector (make_number (coding_attr_last_index), Qnil);
申鐃緒申  8918 
申鐃緒申  8919   name = args[coding_arg_name];
申鐃緒申  8920   CHECK_SYMBOL (name);
申鐃緒申  8921   CODING_ATTR_BASE_NAME (attrs) = name;
申鐃緒申  8922 
申鐃緒申  8923   val = args[coding_arg_mnemonic];
申鐃緒申  8924   if (! STRINGP (val))
申鐃緒申  8925     CHECK_CHARACTER (val);
申鐃緒申  8926   CODING_ATTR_MNEMONIC (attrs) = val;
申鐃緒申  8927 
申鐃緒申  8928   coding_type = args[coding_arg_coding_type];
申鐃緒申  8929   CHECK_SYMBOL (coding_type);
申鐃緒申  8930   CODING_ATTR_TYPE (attrs) = coding_type;
申鐃緒申  8931 
申鐃緒申  8932   charset_list = args[coding_arg_charset_list];
申鐃緒申  8933   if (SYMBOLP (charset_list))
申鐃緒申  8934     {
申鐃緒申  8935       if (EQ (charset_list, Qiso_2022))
申鐃緒申  8936 	{
申鐃緒申  8937 	  if (! EQ (coding_type, Qiso_2022))
申鐃緒申  8938 	    error ("Invalid charset-list");
申鐃緒申  8939 	  charset_list = Viso_2022_charset_list;
申鐃緒申  8940 	}
申鐃緒申  8941       else if (EQ (charset_list, Qemacs_mule))
申鐃緒申  8942 	{
申鐃緒申  8943 	  if (! EQ (coding_type, Qemacs_mule))
申鐃緒申  8944 	    error ("Invalid charset-list");
申鐃緒申  8945 	  charset_list = Vemacs_mule_charset_list;
申鐃緒申  8946 	}
申鐃緒申  8947       for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8948 	if (max_charset_id < XFASTINT (XCAR (tail)))
申鐃緒申  8949 	  max_charset_id = XFASTINT (XCAR (tail));
申鐃緒申  8950     }
申鐃緒申  8951   else
申鐃緒申  8952     {
申鐃緒申  8953       charset_list = Fcopy_sequence (charset_list);
申鐃緒申  8954       for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8955 	{
申鐃緒申  8956 	  struct charset *charset;
申鐃緒申  8957 
申鐃緒申  8958 	  val = XCAR (tail);
申鐃緒申  8959 	  CHECK_CHARSET_GET_CHARSET (val, charset);
申鐃緒申  8960 	  if (EQ (coding_type, Qiso_2022)
申鐃緒申  8961 	      ? CHARSET_ISO_FINAL (charset) < 0
申鐃緒申  8962 	      : EQ (coding_type, Qemacs_mule)
申鐃緒申  8963 	      ? CHARSET_EMACS_MULE_ID (charset) < 0
申鐃緒申  8964 	      : 0)
申鐃緒申  8965 	    error ("Can't handle charset `%s'",
申鐃緒申  8966 		   SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  8967 
申鐃緒申  8968 	  XSETCAR (tail, make_number (charset->id));
申鐃緒申  8969 	  if (max_charset_id < charset->id)
申鐃緒申  8970 	    max_charset_id = charset->id;
申鐃緒申  8971 	}
申鐃緒申  8972     }
申鐃緒申  8973   CODING_ATTR_CHARSET_LIST (attrs) = charset_list;
申鐃緒申  8974 
申鐃緒申  8975   safe_charsets = Fmake_string (make_number (max_charset_id + 1),
申鐃緒申  8976 				make_number (255));
申鐃緒申  8977   for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  8978     SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
申鐃緒申  8979   CODING_ATTR_SAFE_CHARSETS (attrs) = safe_charsets;
申鐃緒申  8980 
申鐃緒申  8981   CODING_ATTR_ASCII_COMPAT (attrs) = args[coding_arg_ascii_compatible_p];
申鐃緒申  8982 
申鐃緒申  8983   val = args[coding_arg_decode_translation_table];
申鐃緒申  8984   if (! CHAR_TABLE_P (val) && ! CONSP (val))
申鐃緒申  8985     CHECK_SYMBOL (val);
申鐃緒申  8986   CODING_ATTR_DECODE_TBL (attrs) = val;
申鐃緒申  8987 
申鐃緒申  8988   val = args[coding_arg_encode_translation_table];
申鐃緒申  8989   if (! CHAR_TABLE_P (val) && ! CONSP (val))
申鐃緒申  8990     CHECK_SYMBOL (val);
申鐃緒申  8991   CODING_ATTR_ENCODE_TBL (attrs) = val;
申鐃緒申  8992 
申鐃緒申  8993   val = args[coding_arg_post_read_conversion];
申鐃緒申  8994   CHECK_SYMBOL (val);
申鐃緒申  8995   CODING_ATTR_POST_READ (attrs) = val;
申鐃緒申  8996 
申鐃緒申  8997   val = args[coding_arg_pre_write_conversion];
申鐃緒申  8998   CHECK_SYMBOL (val);
申鐃緒申  8999   CODING_ATTR_PRE_WRITE (attrs) = val;
申鐃緒申  9000 
申鐃緒申  9001   val = args[coding_arg_default_char];
申鐃緒申  9002   if (NILP (val))
申鐃緒申  9003     CODING_ATTR_DEFAULT_CHAR (attrs) = make_number (' ');
申鐃緒申  9004   else
申鐃緒申  9005     {
申鐃緒申  9006       CHECK_CHARACTER (val);
申鐃緒申  9007       CODING_ATTR_DEFAULT_CHAR (attrs) = val;
申鐃緒申  9008     }
申鐃緒申  9009 
申鐃緒申  9010   val = args[coding_arg_for_unibyte];
申鐃緒申  9011   CODING_ATTR_FOR_UNIBYTE (attrs) = NILP (val) ? Qnil : Qt;
申鐃緒申  9012 
申鐃緒申  9013   val = args[coding_arg_plist];
申鐃緒申  9014   CHECK_LIST (val);
申鐃緒申  9015   CODING_ATTR_PLIST (attrs) = val;
申鐃緒申  9016 
申鐃緒申  9017   if (EQ (coding_type, Qcharset))
申鐃緒申  9018     {
申鐃緒申  9019       /* Generate a lisp vector of 256 elements.  Each element is nil,
申鐃緒申  9020 	 integer, or a list of charset IDs.
申鐃緒申  9021 
申鐃緒申  9022 	 If Nth element is nil, the byte code N is invalid in this
申鐃緒申  9023 	 coding system.
申鐃緒申  9024 
申鐃緒申  9025 	 If Nth element is a number NUM, N is the first byte of a
申鐃緒申  9026 	 charset whose ID is NUM.
申鐃緒申  9027 
申鐃緒申  9028 	 If Nth element is a list of charset IDs, N is the first byte
申鐃緒申  9029 	 of one of them.  The list is sorted by dimensions of the
申鐃緒申  9030 	 charsets.  A charset of smaller dimension comes firtst. */
申鐃緒申  9031       val = Fmake_vector (make_number (256), Qnil);
申鐃緒申  9032 
申鐃緒申  9033       for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
申鐃緒申  9034 	{
申鐃緒申  9035 	  struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));
申鐃緒申  9036 	  int dim = CHARSET_DIMENSION (charset);
申鐃緒申  9037 	  int idx = (dim - 1) * 4;
申鐃緒申  9038 
申鐃緒申  9039 	  if (CHARSET_ASCII_COMPATIBLE_P (charset))
申鐃緒申  9040 	    CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9041 
申鐃緒申  9042 	  for (i = charset->code_space[idx];
申鐃緒申  9043 	       i <= charset->code_space[idx + 1]; i++)
申鐃緒申  9044 	    {
申鐃緒申  9045 	      Lisp_Object tmp, tmp2;
申鐃緒申  9046 	      int dim2;
申鐃緒申  9047 
申鐃緒申  9048 	      tmp = AREF (val, i);
申鐃緒申  9049 	      if (NILP (tmp))
申鐃緒申  9050 		tmp = XCAR (tail);
申鐃緒申  9051 	      else if (NUMBERP (tmp))
申鐃緒申  9052 		{
申鐃緒申  9053 		  dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp)));
申鐃緒申  9054 		  if (dim < dim2)
申鐃緒申  9055 		    tmp = Fcons (XCAR (tail), Fcons (tmp, Qnil));
申鐃緒申  9056 		  else
申鐃緒申  9057 		    tmp = Fcons (tmp, Fcons (XCAR (tail), Qnil));
申鐃緒申  9058 		}
申鐃緒申  9059 	      else
申鐃緒申  9060 		{
申鐃緒申  9061 		  for (tmp2 = tmp; CONSP (tmp2); tmp2 = XCDR (tmp2))
申鐃緒申  9062 		    {
申鐃緒申  9063 		      dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2))));
申鐃緒申  9064 		      if (dim < dim2)
申鐃緒申  9065 			break;
申鐃緒申  9066 		    }
申鐃緒申  9067 		  if (NILP (tmp2))
申鐃緒申  9068 		    tmp = nconc2 (tmp, Fcons (XCAR (tail), Qnil));
申鐃緒申  9069 		  else
申鐃緒申  9070 		    {
申鐃緒申  9071 		      XSETCDR (tmp2, Fcons (XCAR (tmp2), XCDR (tmp2)));
申鐃緒申  9072 		      XSETCAR (tmp2, XCAR (tail));
申鐃緒申  9073 		    }
申鐃緒申  9074 		}
申鐃緒申  9075 	      ASET (val, i, tmp);
申鐃緒申  9076 	    }
申鐃緒申  9077 	}
申鐃緒申  9078       ASET (attrs, coding_attr_charset_valids, val);
申鐃緒申  9079       category = coding_category_charset;
申鐃緒申  9080     }
申鐃緒申  9081   else if (EQ (coding_type, Qccl))
申鐃緒申  9082     {
申鐃緒申  9083       Lisp_Object valids;
申鐃緒申  9084 
申鐃緒申  9085       if (nargs < coding_arg_ccl_max)
申鐃緒申  9086 	goto short_args;
申鐃緒申  9087 
申鐃緒申  9088       val = args[coding_arg_ccl_decoder];
申鐃緒申  9089       CHECK_CCL_PROGRAM (val);
申鐃緒申  9090       if (VECTORP (val))
申鐃緒申  9091 	val = Fcopy_sequence (val);
申鐃緒申  9092       ASET (attrs, coding_attr_ccl_decoder, val);
申鐃緒申  9093 
申鐃緒申  9094       val = args[coding_arg_ccl_encoder];
申鐃緒申  9095       CHECK_CCL_PROGRAM (val);
申鐃緒申  9096       if (VECTORP (val))
申鐃緒申  9097 	val = Fcopy_sequence (val);
申鐃緒申  9098       ASET (attrs, coding_attr_ccl_encoder, val);
申鐃緒申  9099 
申鐃緒申  9100       val = args[coding_arg_ccl_valids];
申鐃緒申  9101       valids = Fmake_string (make_number (256), make_number (0));
申鐃緒申  9102       for (tail = val; !NILP (tail); tail = Fcdr (tail))
申鐃緒申  9103 	{
申鐃緒申  9104 	  int from, to;
申鐃緒申  9105 
申鐃緒申  9106 	  val = Fcar (tail);
申鐃緒申  9107 	  if (INTEGERP (val))
申鐃緒申  9108 	    {
申鐃緒申  9109 	      from = to = XINT (val);
申鐃緒申  9110 	      if (from < 0 || from > 255)
申鐃緒申  9111 		args_out_of_range_3 (val, make_number (0), make_number (255));
申鐃緒申  9112 	    }
申鐃緒申  9113 	  else
申鐃緒申  9114 	    {
申鐃緒申  9115 	      CHECK_CONS (val);
申鐃緒申  9116 	      CHECK_NATNUM_CAR (val);
申鐃緒申  9117 	      CHECK_NATNUM_CDR (val);
申鐃緒申  9118 	      from = XINT (XCAR (val));
申鐃緒申  9119 	      if (from > 255)
申鐃緒申  9120 		args_out_of_range_3 (XCAR (val),
申鐃緒申  9121 				     make_number (0), make_number (255));
申鐃緒申  9122 	      to = XINT (XCDR (val));
申鐃緒申  9123 	      if (to < from || to > 255)
申鐃緒申  9124 		args_out_of_range_3 (XCDR (val),
申鐃緒申  9125 				     XCAR (val), make_number (255));
申鐃緒申  9126 	    }
申鐃緒申  9127 	  for (i = from; i <= to; i++)
申鐃緒申  9128 	    SSET (valids, i, 1);
申鐃緒申  9129 	}
申鐃緒申  9130       ASET (attrs, coding_attr_ccl_valids, valids);
申鐃緒申  9131 
申鐃緒申  9132       category = coding_category_ccl;
申鐃緒申  9133     }
申鐃緒申  9134   else if (EQ (coding_type, Qutf_16))
申鐃緒申  9135     {
申鐃緒申  9136       Lisp_Object bom, endian;
申鐃緒申  9137 
申鐃緒申  9138       CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
申鐃緒申  9139 
申鐃緒申  9140       if (nargs < coding_arg_utf16_max)
申鐃緒申  9141 	goto short_args;
申鐃緒申  9142 
申鐃緒申  9143       bom = args[coding_arg_utf16_bom];
申鐃緒申  9144       if (! NILP (bom) && ! EQ (bom, Qt))
申鐃緒申  9145 	{
申鐃緒申  9146 	  CHECK_CONS (bom);
申鐃緒申  9147 	  val = XCAR (bom);
申鐃緒申  9148 	  CHECK_CODING_SYSTEM (val);
申鐃緒申  9149 	  val = XCDR (bom);
申鐃緒申  9150 	  CHECK_CODING_SYSTEM (val);
申鐃緒申  9151 	}
申鐃緒申  9152       ASET (attrs, coding_attr_utf_16_bom, bom);
申鐃緒申  9153 
申鐃緒申  9154       endian = args[coding_arg_utf16_endian];
申鐃緒申  9155       CHECK_SYMBOL (endian);
申鐃緒申  9156       if (NILP (endian))
申鐃緒申  9157 	endian = Qbig;
申鐃緒申  9158       else if (! EQ (endian, Qbig) && ! EQ (endian, Qlittle))
申鐃緒申  9159 	error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian)));
申鐃緒申  9160       ASET (attrs, coding_attr_utf_16_endian, endian);
申鐃緒申  9161 
申鐃緒申  9162       category = (CONSP (bom)
申鐃緒申  9163 		  ? coding_category_utf_16_auto
申鐃緒申  9164 		  : NILP (bom)
申鐃緒申  9165 		  ? (EQ (endian, Qbig)
申鐃緒申  9166 		     ? coding_category_utf_16_be_nosig
申鐃緒申  9167 		     : coding_category_utf_16_le_nosig)
申鐃緒申  9168 		  : (EQ (endian, Qbig)
申鐃緒申  9169 		     ? coding_category_utf_16_be
申鐃緒申  9170 		     : coding_category_utf_16_le));
申鐃緒申  9171     }
申鐃緒申  9172   else if (EQ (coding_type, Qiso_2022))
申鐃緒申  9173     {
申鐃緒申  9174       Lisp_Object initial, reg_usage, request, flags;
申鐃緒申  9175       int i;
申鐃緒申  9176 
申鐃緒申  9177       if (nargs < coding_arg_iso2022_max)
申鐃緒申  9178 	goto short_args;
申鐃緒申  9179 
申鐃緒申  9180       initial = Fcopy_sequence (args[coding_arg_iso2022_initial]);
申鐃緒申  9181       CHECK_VECTOR (initial);
申鐃緒申  9182       for (i = 0; i < 4; i++)
申鐃緒申  9183 	{
申鐃緒申  9184 	  val = Faref (initial, make_number (i));
申鐃緒申  9185 	  if (! NILP (val))
申鐃緒申  9186 	    {
申鐃緒申  9187 	      struct charset *charset;
申鐃緒申  9188 
申鐃緒申  9189 	      CHECK_CHARSET_GET_CHARSET (val, charset);
申鐃緒申  9190 	      ASET (initial, i, make_number (CHARSET_ID (charset)));
申鐃緒申  9191 	      if (i == 0 && CHARSET_ASCII_COMPATIBLE_P (charset))
申鐃緒申  9192 		CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9193 	    }
申鐃緒申  9194 	  else
申鐃緒申  9195 	    ASET (initial, i, make_number (-1));
申鐃緒申  9196 	}
申鐃緒申  9197 
申鐃緒申  9198       reg_usage = args[coding_arg_iso2022_reg_usage];
申鐃緒申  9199       CHECK_CONS (reg_usage);
申鐃緒申  9200       CHECK_NUMBER_CAR (reg_usage);
申鐃緒申  9201       CHECK_NUMBER_CDR (reg_usage);
申鐃緒申  9202 
申鐃緒申  9203       request = Fcopy_sequence (args[coding_arg_iso2022_request]);
申鐃緒申  9204       for (tail = request; ! NILP (tail); tail = Fcdr (tail))
申鐃緒申  9205 	{
申鐃緒申  9206 	  int id;
申鐃緒申  9207 	  Lisp_Object tmp;
申鐃緒申  9208 
申鐃緒申  9209 	  val = Fcar (tail);
申鐃緒申  9210 	  CHECK_CONS (val);
申鐃緒申  9211 	  tmp = XCAR (val);
申鐃緒申  9212 	  CHECK_CHARSET_GET_ID (tmp, id);
申鐃緒申  9213 	  CHECK_NATNUM_CDR (val);
申鐃緒申  9214 	  if (XINT (XCDR (val)) >= 4)
申鐃緒申  9215 	    error ("Invalid graphic register number: %d", XINT (XCDR (val)));
申鐃緒申  9216 	  XSETCAR (val, make_number (id));
申鐃緒申  9217 	}
申鐃緒申  9218 
申鐃緒申  9219       flags = args[coding_arg_iso2022_flags];
申鐃緒申  9220       CHECK_NATNUM (flags);
申鐃緒申  9221       i = XINT (flags);
申鐃緒申  9222       if (EQ (args[coding_arg_charset_list], Qiso_2022))
申鐃緒申  9223 	flags = make_number (i | CODING_ISO_FLAG_FULL_SUPPORT);
申鐃緒申  9224 
申鐃緒申  9225       ASET (attrs, coding_attr_iso_initial, initial);
申鐃緒申  9226       ASET (attrs, coding_attr_iso_usage, reg_usage);
申鐃緒申  9227       ASET (attrs, coding_attr_iso_request, request);
申鐃緒申  9228       ASET (attrs, coding_attr_iso_flags, flags);
申鐃緒申  9229       setup_iso_safe_charsets (attrs);
申鐃緒申  9230 
申鐃緒申  9231       if (i & CODING_ISO_FLAG_SEVEN_BITS)
申鐃緒申  9232 	category = ((i & (CODING_ISO_FLAG_LOCKING_SHIFT
申鐃緒申  9233 			  | CODING_ISO_FLAG_SINGLE_SHIFT))
申鐃緒申  9234 		    ? coding_category_iso_7_else
申鐃緒申  9235 		    : EQ (args[coding_arg_charset_list], Qiso_2022)
申鐃緒申  9236 		    ? coding_category_iso_7
申鐃緒申  9237 		    : coding_category_iso_7_tight);
申鐃緒申  9238       else
申鐃緒申  9239 	{
申鐃緒申  9240 	  int id = XINT (AREF (initial, 1));
申鐃緒申  9241 
申鐃緒申  9242 	  category = (((i & CODING_ISO_FLAG_LOCKING_SHIFT)
申鐃緒申  9243 		       || EQ (args[coding_arg_charset_list], Qiso_2022)
申鐃緒申  9244 		       || id < 0)
申鐃緒申  9245 		      ? coding_category_iso_8_else
申鐃緒申  9246 		      : (CHARSET_DIMENSION (CHARSET_FROM_ID (id)) == 1)
申鐃緒申  9247 		      ? coding_category_iso_8_1
申鐃緒申  9248 		      : coding_category_iso_8_2);
申鐃緒申  9249 	}
申鐃緒申  9250       if (category != coding_category_iso_8_1
申鐃緒申  9251 	  && category != coding_category_iso_8_2)
申鐃緒申  9252 	CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
申鐃緒申  9253     }
申鐃緒申  9254   else if (EQ (coding_type, Qemacs_mule))
申鐃緒申  9255     {
申鐃緒申  9256       if (EQ (args[coding_arg_charset_list], Qemacs_mule))
申鐃緒申  9257 	ASET (attrs, coding_attr_emacs_mule_full, Qt);
申鐃緒申  9258       CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9259       category = coding_category_emacs_mule;
申鐃緒申  9260     }
申鐃緒申  9261   else if (EQ (coding_type, Qshift_jis))
申鐃緒申  9262     {
申鐃緒申  9263 
申鐃緒申  9264       struct charset *charset;
申鐃緒申  9265 
申鐃緒申  9266       if (XINT (Flength (charset_list)) != 3
申鐃緒申  9267 	  && XINT (Flength (charset_list)) != 4)
申鐃緒申  9268 	error ("There should be three or four charsets");
申鐃緒申  9269 
申鐃緒申  9270       charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9271       if (CHARSET_DIMENSION (charset) != 1)
申鐃緒申  9272 	error ("Dimension of charset %s is not one",
申鐃緒申  9273 	       SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9274       if (CHARSET_ASCII_COMPATIBLE_P (charset))
申鐃緒申  9275 	CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9276 
申鐃緒申  9277       charset_list = XCDR (charset_list);
申鐃緒申  9278       charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9279       if (CHARSET_DIMENSION (charset) != 1)
申鐃緒申  9280 	error ("Dimension of charset %s is not one",
申鐃緒申  9281 	       SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9282 
申鐃緒申  9283       charset_list = XCDR (charset_list);
申鐃緒申  9284       charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9285       if (CHARSET_DIMENSION (charset) != 2)
申鐃緒申  9286 	error ("Dimension of charset %s is not two",
申鐃緒申  9287 	       SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9288 
申鐃緒申  9289       charset_list = XCDR (charset_list);
申鐃緒申  9290       if (! NILP (charset_list))
申鐃緒申  9291 	{
申鐃緒申  9292 	  charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9293 	  if (CHARSET_DIMENSION (charset) != 2)
申鐃緒申  9294 	    error ("Dimension of charset %s is not two",
申鐃緒申  9295 		   SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9296 	}
申鐃緒申  9297 
申鐃緒申  9298       category = coding_category_sjis;
申鐃緒申  9299       Vsjis_coding_system = name;
申鐃緒申  9300     }
申鐃緒申  9301   else if (EQ (coding_type, Qbig5))
申鐃緒申  9302     {
申鐃緒申  9303       struct charset *charset;
申鐃緒申  9304 
申鐃緒申  9305       if (XINT (Flength (charset_list)) != 2)
申鐃緒申  9306 	error ("There should be just two charsets");
申鐃緒申  9307 
申鐃緒申  9308       charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9309       if (CHARSET_DIMENSION (charset) != 1)
申鐃緒申  9310 	error ("Dimension of charset %s is not one",
申鐃緒申  9311 	       SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9312       if (CHARSET_ASCII_COMPATIBLE_P (charset))
申鐃緒申  9313 	CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9314 
申鐃緒申  9315       charset_list = XCDR (charset_list);
申鐃緒申  9316       charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
申鐃緒申  9317       if (CHARSET_DIMENSION (charset) != 2)
申鐃緒申  9318 	error ("Dimension of charset %s is not two",
申鐃緒申  9319 	       SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
申鐃緒申  9320 
申鐃緒申  9321       category = coding_category_big5;
申鐃緒申  9322       Vbig5_coding_system = name;
申鐃緒申  9323     }
申鐃緒申  9324   else if (EQ (coding_type, Qraw_text))
申鐃緒申  9325     {
申鐃緒申  9326       category = coding_category_raw_text;
申鐃緒申  9327       CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9328     }
申鐃緒申  9329   else if (EQ (coding_type, Qutf_8))
申鐃緒申  9330     {
申鐃緒申  9331       category = coding_category_utf_8;
申鐃緒申  9332       CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
申鐃緒申  9333     }
申鐃緒申  9334   else if (EQ (coding_type, Qundecided))
申鐃緒申  9335     category = coding_category_undecided;
申鐃緒申  9336   else
申鐃緒申  9337     error ("Invalid coding system type: %s",
申鐃緒申  9338 	   SDATA (SYMBOL_NAME (coding_type)));
申鐃緒申  9339 
申鐃緒申  9340   CODING_ATTR_CATEGORY (attrs) = make_number (category);
申鐃緒申  9341   CODING_ATTR_PLIST (attrs)
申鐃緒申  9342     = Fcons (QCcategory, Fcons (AREF (Vcoding_category_table, category),
申鐃緒申  9343 				CODING_ATTR_PLIST (attrs)));
申鐃緒申  9344   CODING_ATTR_PLIST (attrs)
申鐃緒申  9345     = Fcons (QCascii_compatible_p,
申鐃緒申  9346 	     Fcons (CODING_ATTR_ASCII_COMPAT (attrs),
申鐃緒申  9347 		    CODING_ATTR_PLIST (attrs)));
申鐃緒申  9348 
申鐃緒申  9349   eol_type = args[coding_arg_eol_type];
申鐃緒申  9350   if (! NILP (eol_type)
申鐃緒申  9351       && ! EQ (eol_type, Qunix)
申鐃緒申  9352       && ! EQ (eol_type, Qdos)
申鐃緒申  9353       && ! EQ (eol_type, Qmac))
申鐃緒申  9354     error ("Invalid eol-type");
申鐃緒申  9355 
申鐃緒申  9356   aliases = Fcons (name, Qnil);
申鐃緒申  9357 
申鐃緒申  9358   if (NILP (eol_type))
申鐃緒申  9359     {
申鐃緒申  9360       eol_type = make_subsidiaries (name);
申鐃緒申  9361       for (i = 0; i < 3; i++)
申鐃緒申  9362 	{
申鐃緒申  9363 	  Lisp_Object this_spec, this_name, this_aliases, this_eol_type;
申鐃緒申  9364 
申鐃緒申  9365 	  this_name = AREF (eol_type, i);
申鐃緒申  9366 	  this_aliases = Fcons (this_name, Qnil);
申鐃緒申  9367 	  this_eol_type = (i == 0 ? Qunix : i == 1 ? Qdos : Qmac);
申鐃緒申  9368 	  this_spec = Fmake_vector (make_number (3), attrs);
申鐃緒申  9369 	  ASET (this_spec, 1, this_aliases);
申鐃緒申  9370 	  ASET (this_spec, 2, this_eol_type);
申鐃緒申  9371 	  Fputhash (this_name, this_spec, Vcoding_system_hash_table);
申鐃緒申  9372 	  Vcoding_system_list = Fcons (this_name, Vcoding_system_list);
申鐃緒申  9373 	  val = Fassoc (Fsymbol_name (this_name), Vcoding_system_alist);
申鐃緒申  9374 	  if (NILP (val))
申鐃緒申  9375 	    Vcoding_system_alist
申鐃緒申  9376 	      = Fcons (Fcons (Fsymbol_name (this_name), Qnil),
申鐃緒申  9377 		       Vcoding_system_alist);
申鐃緒申  9378 	}
申鐃緒申  9379     }
申鐃緒申  9380 
申鐃緒申  9381   spec_vec = Fmake_vector (make_number (3), attrs);
申鐃緒申  9382   ASET (spec_vec, 1, aliases);
申鐃緒申  9383   ASET (spec_vec, 2, eol_type);
申鐃緒申  9384 
申鐃緒申  9385   Fputhash (name, spec_vec, Vcoding_system_hash_table);
申鐃緒申  9386   Vcoding_system_list = Fcons (name, Vcoding_system_list);
申鐃緒申  9387   val = Fassoc (Fsymbol_name (name), Vcoding_system_alist);
申鐃緒申  9388   if (NILP (val))
申鐃緒申  9389     Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (name), Qnil),
申鐃緒申  9390 				  Vcoding_system_alist);
申鐃緒申  9391 
申鐃緒申  9392   {
申鐃緒申  9393     int id = coding_categories[category].id;
申鐃緒申  9394 
申鐃緒申  9395     if (id < 0 || EQ (name, CODING_ID_NAME (id)))
申鐃緒申  9396       setup_coding_system (name, &coding_categories[category]);
申鐃緒申  9397   }
申鐃緒申  9398 
申鐃緒申  9399   return Qnil;
申鐃緒申  9400 
申鐃緒申  9401  short_args:
申鐃緒申  9402   return Fsignal (Qwrong_number_of_arguments,
申鐃緒申  9403 		  Fcons (intern ("define-coding-system-internal"),
申鐃緒申  9404 			 make_number (nargs)));
申鐃緒申  9405 }
申鐃緒申  9406 
申鐃緒申  9407 
申鐃緒申  9408 DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
申鐃緒申  9409        3, 3, 0,
申鐃緒申  9410        doc: /* Change value in CODING-SYSTEM's property list PROP to VAL.  */)
申鐃緒申  9411   (coding_system, prop, val)
申鐃緒申  9412      Lisp_Object coding_system, prop, val;
申鐃緒申  9413 {
申鐃緒申  9414   Lisp_Object spec, attrs;
申鐃緒申  9415 
申鐃緒申  9416   CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
申鐃緒申  9417   attrs = AREF (spec, 0);
申鐃緒申  9418   if (EQ (prop, QCmnemonic))
申鐃緒申  9419     {
申鐃緒申  9420       if (! STRINGP (val))
申鐃緒申  9421 	CHECK_CHARACTER (val);
申鐃緒申  9422       CODING_ATTR_MNEMONIC (attrs) = val;
申鐃緒申  9423     }
申鐃緒申  9424   else if (EQ (prop, QCdefalut_char))
申鐃緒申  9425     {
申鐃緒申  9426       if (NILP (val))
申鐃緒申  9427 	val = make_number (' ');
申鐃緒申  9428       else
申鐃緒申  9429 	CHECK_CHARACTER (val);
申鐃緒申  9430       CODING_ATTR_DEFAULT_CHAR (attrs) = val;
申鐃緒申  9431     }
申鐃緒申  9432   else if (EQ (prop, QCdecode_translation_table))
申鐃緒申  9433     {
申鐃緒申  9434       if (! CHAR_TABLE_P (val) && ! CONSP (val))
申鐃緒申  9435 	CHECK_SYMBOL (val);
申鐃緒申  9436       CODING_ATTR_DECODE_TBL (attrs) = val;
申鐃緒申  9437     }
申鐃緒申  9438   else if (EQ (prop, QCencode_translation_table))
申鐃緒申  9439     {
申鐃緒申  9440       if (! CHAR_TABLE_P (val) && ! CONSP (val))
申鐃緒申  9441 	CHECK_SYMBOL (val);
申鐃緒申  9442       CODING_ATTR_ENCODE_TBL (attrs) = val;
申鐃緒申  9443     }
申鐃緒申  9444   else if (EQ (prop, QCpost_read_conversion))
申鐃緒申  9445     {
申鐃緒申  9446       CHECK_SYMBOL (val);
申鐃緒申  9447       CODING_ATTR_POST_READ (attrs) = val;
申鐃緒申  9448     }
申鐃緒申  9449   else if (EQ (prop, QCpre_write_conversion))
申鐃緒申  9450     {
申鐃緒申  9451       CHECK_SYMBOL (val);
申鐃緒申  9452       CODING_ATTR_PRE_WRITE (attrs) = val;
申鐃緒申  9453     }
申鐃緒申  9454   else if (EQ (prop, QCascii_compatible_p))
申鐃緒申  9455     {
申鐃緒申  9456       CODING_ATTR_ASCII_COMPAT (attrs) = val;
申鐃緒申  9457     }
申鐃緒申  9458 
申鐃緒申  9459   CODING_ATTR_PLIST (attrs)
申鐃緒申  9460     = Fplist_put (CODING_ATTR_PLIST (attrs), prop, val);
申鐃緒申  9461   return val;
申鐃緒申  9462 }
申鐃緒申  9463 
申鐃緒申  9464 
申鐃緒申  9465 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias,
申鐃緒申  9466        Sdefine_coding_system_alias, 2, 2, 0,
申鐃緒申  9467        doc: /* Define ALIAS as an alias for CODING-SYSTEM.  */)
申鐃緒申  9468      (alias, coding_system)
申鐃緒申  9469      Lisp_Object alias, coding_system;
申鐃緒申  9470 {
申鐃緒申  9471   Lisp_Object spec, aliases, eol_type, val;
申鐃緒申  9472 
申鐃緒申  9473   CHECK_SYMBOL (alias);
申鐃緒申  9474   CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
申鐃緒申  9475   aliases = AREF (spec, 1);
申鐃緒申  9476   /* ALISES should be a list of length more than zero, and the first
申鐃緒申  9477      element is a base coding system.  Append ALIAS at the tail of the
申鐃緒申  9478      list.  */
申鐃緒申  9479   while (!NILP (XCDR (aliases)))
申鐃緒申  9480     aliases = XCDR (aliases);
申鐃緒申  9481   XSETCDR (aliases, Fcons (alias, Qnil));
申鐃緒申  9482 
申鐃緒申  9483   eol_type = AREF (spec, 2);
申鐃緒申  9484   if (VECTORP (eol_type))
申鐃緒申  9485     {
申鐃緒申  9486       Lisp_Object subsidiaries;
申鐃緒申  9487       int i;
申鐃緒申  9488 
申鐃緒申  9489       subsidiaries = make_subsidiaries (alias);
申鐃緒申  9490       for (i = 0; i < 3; i++)
申鐃緒申  9491 	Fdefine_coding_system_alias (AREF (subsidiaries, i),
申鐃緒申  9492 				     AREF (eol_type, i));
申鐃緒申  9493     }
申鐃緒申  9494 
申鐃緒申  9495   Fputhash (alias, spec, Vcoding_system_hash_table);
申鐃緒申  9496   Vcoding_system_list = Fcons (alias, Vcoding_system_list);
申鐃緒申  9497   val = Fassoc (Fsymbol_name (alias), Vcoding_system_alist);
申鐃緒申  9498   if (NILP (val))
申鐃緒申  9499     Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (alias), Qnil),
申鐃緒申  9500 				  Vcoding_system_alist);
申鐃緒申  9501 
申鐃緒申  9502   return Qnil;
申鐃緒申  9503 }
申鐃緒申  9504 
申鐃緒申  9505 DEFUN ("coding-system-base", Fcoding_system_base, Scoding_system_base,
申鐃緒申  9506        1, 1, 0,
申鐃緒申  9507        doc: /* Return the base of CODING-SYSTEM.
申鐃緒申  9508 Any alias or subsidiary coding system is not a base coding system.  */)
申鐃緒申  9509   (coding_system)
申鐃緒申  9510      Lisp_Object coding_system;
申鐃緒申  9511 {
申鐃緒申  9512   Lisp_Object spec, attrs;
申鐃緒申  9513 
申鐃緒申  9514   if (NILP (coding_system))
申鐃緒申  9515     return (Qno_conversion);
申鐃緒申  9516   CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
申鐃緒申  9517   attrs = AREF (spec, 0);
申鐃緒申  9518   return CODING_ATTR_BASE_NAME (attrs);
申鐃緒申  9519 }
申鐃緒申  9520 
申鐃緒申  9521 DEFUN ("coding-system-plist", Fcoding_system_plist, Scoding_system_plist,
申鐃緒申  9522        1, 1, 0,
申鐃緒申  9523        doc: "Return the property list of CODING-SYSTEM.")
申鐃緒申  9524      (coding_system)
申鐃緒申  9525      Lisp_Object coding_system;
申鐃緒申  9526 {
申鐃緒申  9527   Lisp_Object spec, attrs;
申鐃緒申  9528 
申鐃緒申  9529   if (NILP (coding_system))
申鐃緒申  9530     coding_system = Qno_conversion;
申鐃緒申  9531   CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
申鐃緒申  9532   attrs = AREF (spec, 0);
申鐃緒申  9533   return CODING_ATTR_PLIST (attrs);
申鐃緒申  9534 }
申鐃緒申  9535 
申鐃緒申  9536 
申鐃緒申  9537 DEFUN ("coding-system-aliases", Fcoding_system_aliases, Scoding_system_aliases,
申鐃緒申  9538        1, 1, 0,
申鐃緒申  9539        doc: /* Return the list of aliases of CODING-SYSTEM.  */)
申鐃緒申  9540      (coding_system)
申鐃緒申  9541      Lisp_Object coding_system;
申鐃緒申  9542 {
申鐃緒申  9543   Lisp_Object spec;
申鐃緒申  9544 
申鐃緒申  9545   if (NILP (coding_system))
申鐃緒申  9546     coding_system = Qno_conversion;
申鐃緒申  9547   CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
申鐃緒申  9548   return AREF (spec, 1);
申鐃緒申  9549 }
申鐃緒申  9550 
申鐃緒申  9551 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type,
申鐃緒申  9552        Scoding_system_eol_type, 1, 1, 0,
申鐃緒申  9553        doc: /* Return eol-type of CODING-SYSTEM.
申鐃緒申  9554 An eol-type is integer 0, 1, 2, or a vector of coding systems.
申鐃緒申  9555 
申鐃緒申  9556 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
申鐃緒申  9557 and CR respectively.
申鐃緒申  9558 
申鐃緒申  9559 A vector value indicates that a format of end-of-line should be
申鐃緒申  9560 detected automatically.  Nth element of the vector is the subsidiary
申鐃緒申  9561 coding system whose eol-type is N.  */)
申鐃緒申  9562      (coding_system)
申鐃緒申  9563      Lisp_Object coding_system;
申鐃緒申  9564 {
申鐃緒申  9565   Lisp_Object spec, eol_type;
申鐃緒申  9566   int n;
申鐃緒申  9567 
申鐃緒申  9568   if (NILP (coding_system))
申鐃緒申  9569     coding_system = Qno_conversion;
申鐃緒申  9570   if (! CODING_SYSTEM_P (coding_system))
申鐃緒申  9571     return Qnil;
申鐃緒申  9572   spec = CODING_SYSTEM_SPEC (coding_system);
申鐃緒申  9573   eol_type = AREF (spec, 2);
申鐃緒申  9574   if (VECTORP (eol_type))
申鐃緒申  9575     return Fcopy_sequence (eol_type);
申鐃緒申  9576   n = EQ (eol_type, Qunix) ? 0 : EQ (eol_type, Qdos) ? 1 : 2;
申鐃緒申  9577   return make_number (n);
申鐃緒申  9578 }
申鐃緒申  9579 
申鐃緒申  9580 #endif /* emacs */
申鐃緒申  9581 
申鐃緒申  9582 
申鐃緒申  9583 /*** 9. Post-amble ***/
申鐃緒申  9584 
申鐃緒申  9585 void
申鐃緒申  9586 init_coding_once ()
申鐃緒申  9587 {
申鐃緒申  9588   int i;
申鐃緒申  9589 
申鐃緒申  9590   for (i = 0; i < coding_category_max; i++)
申鐃緒申  9591     {
申鐃緒申  9592       coding_categories[i].id = -1;
申鐃緒申  9593       coding_priorities[i] = i;
申鐃緒申  9594     }
申鐃緒申  9595 
申鐃緒申  9596   /* ISO2022 specific initialize routine.  */
申鐃緒申  9597   for (i = 0; i < 0x20; i++)
申鐃緒申  9598     iso_code_class[i] = ISO_control_0;
申鐃緒申  9599   for (i = 0x21; i < 0x7F; i++)
申鐃緒申  9600     iso_code_class[i] = ISO_graphic_plane_0;
申鐃緒申  9601   for (i = 0x80; i < 0xA0; i++)
申鐃緒申  9602     iso_code_class[i] = ISO_control_1;
申鐃緒申  9603   for (i = 0xA1; i < 0xFF; i++)
申鐃緒申  9604     iso_code_class[i] = ISO_graphic_plane_1;
申鐃緒申  9605   iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
申鐃緒申  9606   iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
申鐃緒申  9607   iso_code_class[ISO_CODE_SO] = ISO_shift_out;
申鐃緒申  9608   iso_code_class[ISO_CODE_SI] = ISO_shift_in;
申鐃緒申  9609   iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
申鐃緒申  9610   iso_code_class[ISO_CODE_ESC] = ISO_escape;
申鐃緒申  9611   iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
申鐃緒申  9612   iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
申鐃緒申  9613   iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
申鐃緒申  9614 
申鐃緒申  9615   for (i = 0; i < 256; i++)
申鐃緒申  9616     {
申鐃緒申  9617       emacs_mule_bytes[i] = 1;
申鐃緒申  9618     }
申鐃緒申  9619   emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_11] = 3;
申鐃緒申  9620   emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_12] = 3;
申鐃緒申  9621   emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_21] = 4;
申鐃緒申  9622   emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_22] = 4;
申鐃緒申  9623 }
申鐃緒申  9624 
申鐃緒申  9625 #ifdef emacs
申鐃緒申  9626 
申鐃緒申  9627 void
申鐃緒申  9628 syms_of_coding ()
申鐃緒申  9629 {
申鐃緒申  9630   staticpro (&Vcoding_system_hash_table);
申鐃緒申  9631   {
申鐃緒申  9632     Lisp_Object args[2];
申鐃緒申  9633     args[0] = QCtest;
申鐃緒申  9634     args[1] = Qeq;
申鐃緒申  9635     Vcoding_system_hash_table = Fmake_hash_table (2, args);
申鐃緒申  9636   }
申鐃緒申  9637 
申鐃緒申  9638   staticpro (&Vsjis_coding_system);
申鐃緒申  9639   Vsjis_coding_system = Qnil;
申鐃緒申  9640 
申鐃緒申  9641   staticpro (&Vbig5_coding_system);
申鐃緒申  9642   Vbig5_coding_system = Qnil;
申鐃緒申  9643 
申鐃緒申  9644   staticpro (&Vcode_conversion_reused_workbuf);
申鐃緒申  9645   Vcode_conversion_reused_workbuf = Qnil;
申鐃緒申  9646 
申鐃緒申  9647   staticpro (&Vcode_conversion_workbuf_name);
申鐃緒申  9648   Vcode_conversion_workbuf_name = build_string (" *code-conversion-work*");
申鐃緒申  9649 
申鐃緒申  9650   reused_workbuf_in_use = 0;
申鐃緒申  9651 
申鐃緒申  9652   DEFSYM (Qcharset, "charset");
申鐃緒申  9653   DEFSYM (Qtarget_idx, "target-idx");
申鐃緒申  9654   DEFSYM (Qcoding_system_history, "coding-system-history");
申鐃緒申  9655   Fset (Qcoding_system_history, Qnil);
申鐃緒申  9656 
申鐃緒申  9657   /* Target FILENAME is the first argument.  */
申鐃緒申  9658   Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
申鐃緒申  9659   /* Target FILENAME is the third argument.  */
申鐃緒申  9660   Fput (Qwrite_region, Qtarget_idx, make_number (2));
申鐃緒申  9661 
申鐃緒申  9662   DEFSYM (Qcall_process, "call-process");
申鐃緒申  9663   /* Target PROGRAM is the first argument.  */
申鐃緒申  9664   Fput (Qcall_process, Qtarget_idx, make_number (0));
申鐃緒申  9665 
申鐃緒申  9666   DEFSYM (Qcall_process_region, "call-process-region");
申鐃緒申  9667   /* Target PROGRAM is the third argument.  */
申鐃緒申  9668   Fput (Qcall_process_region, Qtarget_idx, make_number (2));
申鐃緒申  9669 
申鐃緒申  9670   DEFSYM (Qstart_process, "start-process");
申鐃緒申  9671   /* Target PROGRAM is the third argument.  */
申鐃緒申  9672   Fput (Qstart_process, Qtarget_idx, make_number (2));
申鐃緒申  9673 
申鐃緒申  9674   DEFSYM (Qopen_network_stream, "open-network-stream");
申鐃緒申  9675   /* Target SERVICE is the fourth argument.  */
申鐃緒申  9676   Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
申鐃緒申  9677 
申鐃緒申  9678   DEFSYM (Qcoding_system, "coding-system");
申鐃緒申  9679   DEFSYM (Qcoding_aliases, "coding-aliases");
申鐃緒申  9680 
申鐃緒申  9681   DEFSYM (Qeol_type, "eol-type");
申鐃緒申  9682   DEFSYM (Qunix, "unix");
申鐃緒申  9683   DEFSYM (Qdos, "dos");
申鐃緒申  9684 
申鐃緒申  9685   DEFSYM (Qbuffer_file_coding_system, "buffer-file-coding-system");
申鐃緒申  9686   DEFSYM (Qpost_read_conversion, "post-read-conversion");
申鐃緒申  9687   DEFSYM (Qpre_write_conversion, "pre-write-conversion");
申鐃緒申  9688   DEFSYM (Qdefault_char, "default-char");
申鐃緒申  9689   DEFSYM (Qundecided, "undecided");
申鐃緒申  9690   DEFSYM (Qno_conversion, "no-conversion");
申鐃緒申  9691   DEFSYM (Qraw_text, "raw-text");
申鐃緒申  9692 
申鐃緒申  9693   DEFSYM (Qiso_2022, "iso-2022");
申鐃緒申  9694 
申鐃緒申  9695   DEFSYM (Qutf_8, "utf-8");
申鐃緒申  9696   DEFSYM (Qutf_8_emacs, "utf-8-emacs");
申鐃緒申  9697 
申鐃緒申  9698   DEFSYM (Qutf_16, "utf-16");
申鐃緒申  9699   DEFSYM (Qbig, "big");
申鐃緒申  9700   DEFSYM (Qlittle, "little");
申鐃緒申  9701 
申鐃緒申  9702   DEFSYM (Qshift_jis, "shift-jis");
申鐃緒申  9703   DEFSYM (Qbig5, "big5");
申鐃緒申  9704 
申鐃緒申  9705   DEFSYM (Qcoding_system_p, "coding-system-p");
申鐃緒申  9706 
申鐃緒申  9707   DEFSYM (Qcoding_system_error, "coding-system-error");
申鐃緒申  9708   Fput (Qcoding_system_error, Qerror_conditions,
申鐃緒申  9709 	Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
申鐃緒申  9710   Fput (Qcoding_system_error, Qerror_message,
申鐃緒申  9711 	build_string ("Invalid coding system"));
申鐃緒申  9712 
申鐃緒申  9713   /* Intern this now in case it isn't already done.
申鐃緒申  9714      Setting this variable twice is harmless.
申鐃緒申  9715      But don't staticpro it here--that is done in alloc.c.  */
申鐃緒申  9716   Qchar_table_extra_slots = intern ("char-table-extra-slots");
申鐃緒申  9717 
申鐃緒申  9718   DEFSYM (Qtranslation_table, "translation-table");
申鐃緒申  9719   Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
申鐃緒申  9720   DEFSYM (Qtranslation_table_id, "translation-table-id");
申鐃緒申  9721   DEFSYM (Qtranslation_table_for_decode, "translation-table-for-decode");
申鐃緒申  9722   DEFSYM (Qtranslation_table_for_encode, "translation-table-for-encode");
申鐃緒申  9723 
申鐃緒申  9724   DEFSYM (Qvalid_codes, "valid-codes");
申鐃緒申  9725 
申鐃緒申  9726   DEFSYM (Qemacs_mule, "emacs-mule");
申鐃緒申  9727 
申鐃緒申  9728   DEFSYM (QCcategory, ":category");
申鐃緒申  9729   DEFSYM (QCmnemonic, ":mnemonic");
申鐃緒申  9730   DEFSYM (QCdefalut_char, ":default-char");
申鐃緒申  9731   DEFSYM (QCdecode_translation_table, ":decode-translation-table");
申鐃緒申  9732   DEFSYM (QCencode_translation_table, ":encode-translation-table");
申鐃緒申  9733   DEFSYM (QCpost_read_conversion, ":post-read-conversion");
申鐃緒申  9734   DEFSYM (QCpre_write_conversion, ":pre-write-conversion");
申鐃緒申  9735   DEFSYM (QCascii_compatible_p, ":ascii-compatible-p");
申鐃緒申  9736 
申鐃緒申  9737   Vcoding_category_table
申鐃緒申  9738     = Fmake_vector (make_number (coding_category_max), Qnil);
申鐃緒申  9739   staticpro (&Vcoding_category_table);
申鐃緒申  9740   /* Followings are target of code detection.  */
申鐃緒申  9741   ASET (Vcoding_category_table, coding_category_iso_7,
申鐃緒申  9742 	intern ("coding-category-iso-7"));
申鐃緒申  9743   ASET (Vcoding_category_table, coding_category_iso_7_tight,
申鐃緒申  9744 	intern ("coding-category-iso-7-tight"));
申鐃緒申  9745   ASET (Vcoding_category_table, coding_category_iso_8_1,
申鐃緒申  9746 	intern ("coding-category-iso-8-1"));
申鐃緒申  9747   ASET (Vcoding_category_table, coding_category_iso_8_2,
申鐃緒申  9748 	intern ("coding-category-iso-8-2"));
申鐃緒申  9749   ASET (Vcoding_category_table, coding_category_iso_7_else,
申鐃緒申  9750 	intern ("coding-category-iso-7-else"));
申鐃緒申  9751   ASET (Vcoding_category_table, coding_category_iso_8_else,
申鐃緒申  9752 	intern ("coding-category-iso-8-else"));
申鐃緒申  9753   ASET (Vcoding_category_table, coding_category_utf_8,
申鐃緒申  9754 	intern ("coding-category-utf-8"));
申鐃緒申  9755   ASET (Vcoding_category_table, coding_category_utf_16_be,
申鐃緒申  9756 	intern ("coding-category-utf-16-be"));
申鐃緒申  9757   ASET (Vcoding_category_table, coding_category_utf_16_auto,
申鐃緒申  9758 	intern ("coding-category-utf-16-auto"));
申鐃緒申  9759   ASET (Vcoding_category_table, coding_category_utf_16_le,
申鐃緒申  9760 	intern ("coding-category-utf-16-le"));
申鐃緒申  9761   ASET (Vcoding_category_table, coding_category_utf_16_be_nosig,
申鐃緒申  9762 	intern ("coding-category-utf-16-be-nosig"));
申鐃緒申  9763   ASET (Vcoding_category_table, coding_category_utf_16_le_nosig,
申鐃緒申  9764 	intern ("coding-category-utf-16-le-nosig"));
申鐃緒申  9765   ASET (Vcoding_category_table, coding_category_charset,
申鐃緒申  9766 	intern ("coding-category-charset"));
申鐃緒申  9767   ASET (Vcoding_category_table, coding_category_sjis,
申鐃緒申  9768 	intern ("coding-category-sjis"));
申鐃緒申  9769   ASET (Vcoding_category_table, coding_category_big5,
申鐃緒申  9770 	intern ("coding-category-big5"));
申鐃緒申  9771   ASET (Vcoding_category_table, coding_category_ccl,
申鐃緒申  9772 	intern ("coding-category-ccl"));
申鐃緒申  9773   ASET (Vcoding_category_table, coding_category_emacs_mule,
申鐃緒申  9774 	intern ("coding-category-emacs-mule"));
申鐃緒申  9775   /* Followings are NOT target of code detection.  */
申鐃緒申  9776   ASET (Vcoding_category_table, coding_category_raw_text,
申鐃緒申  9777 	intern ("coding-category-raw-text"));
申鐃緒申  9778   ASET (Vcoding_category_table, coding_category_undecided,
申鐃緒申  9779 	intern ("coding-category-undecided"));
申鐃緒申  9780 
申鐃緒申  9781   DEFSYM (Qinsufficient_source, "insufficient-source");
申鐃緒申  9782   DEFSYM (Qinconsistent_eol, "inconsistent-eol");
申鐃緒申  9783   DEFSYM (Qinvalid_source, "invalid-source");
申鐃緒申  9784   DEFSYM (Qinterrupted, "interrupted");
申鐃緒申  9785   DEFSYM (Qinsufficient_memory, "insufficient-memory");
申鐃緒申  9786   DEFSYM (Qcoding_system_define_form, "coding-system-define-form");
申鐃緒申  9787 
申鐃緒申  9788   defsubr (&Scoding_system_p);
申鐃緒申  9789   defsubr (&Sread_coding_system);
申鐃緒申  9790   defsubr (&Sread_non_nil_coding_system);
申鐃緒申  9791   defsubr (&Scheck_coding_system);
申鐃緒申  9792   defsubr (&Sdetect_coding_region);
申鐃緒申  9793   defsubr (&Sdetect_coding_string);
申鐃緒申  9794   defsubr (&Sfind_coding_systems_region_internal);
申鐃緒申  9795   defsubr (&Sunencodable_char_position);
申鐃緒申  9796   defsubr (&Scheck_coding_systems_region);
申鐃緒申  9797   defsubr (&Sdecode_coding_region);
申鐃緒申  9798   defsubr (&Sencode_coding_region);
申鐃緒申  9799   defsubr (&Sdecode_coding_string);
申鐃緒申  9800   defsubr (&Sencode_coding_string);
申鐃緒申  9801   defsubr (&Sdecode_sjis_char);
申鐃緒申  9802   defsubr (&Sencode_sjis_char);
申鐃緒申  9803   defsubr (&Sdecode_big5_char);
申鐃緒申  9804   defsubr (&Sencode_big5_char);
申鐃緒申  9805   defsubr (&Sset_terminal_coding_system_internal);
申鐃緒申  9806   defsubr (&Sset_safe_terminal_coding_system_internal);
申鐃緒申  9807   defsubr (&Sterminal_coding_system);
申鐃緒申  9808   defsubr (&Sset_keyboard_coding_system_internal);
申鐃緒申  9809   defsubr (&Skeyboard_coding_system);
申鐃緒申  9810   defsubr (&Sfind_operation_coding_system);
申鐃緒申  9811   defsubr (&Sset_coding_system_priority);
申鐃緒申  9812   defsubr (&Sdefine_coding_system_internal);
申鐃緒申  9813   defsubr (&Sdefine_coding_system_alias);
申鐃緒申  9814   defsubr (&Scoding_system_put);
申鐃緒申  9815   defsubr (&Scoding_system_base);
申鐃緒申  9816   defsubr (&Scoding_system_plist);
申鐃緒申  9817   defsubr (&Scoding_system_aliases);
申鐃緒申  9818   defsubr (&Scoding_system_eol_type);
申鐃緒申  9819   defsubr (&Scoding_system_priority_list);
申鐃緒申  9820 
申鐃緒申  9821   DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
申鐃緒申  9822 	       doc: /* List of coding systems.
申鐃緒申  9823 
申鐃緒申  9824 Do not alter the value of this variable manually.  This variable should be
申鐃緒申  9825 updated by the functions `define-coding-system' and
申鐃緒申  9826 `define-coding-system-alias'.  */);
申鐃緒申  9827   Vcoding_system_list = Qnil;
申鐃緒申  9828 
申鐃緒申  9829   DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
申鐃緒申  9830 	       doc: /* Alist of coding system names.
申鐃緒申  9831 Each element is one element list of coding system name.
申鐃緒申  9832 This variable is given to `completing-read' as TABLE argument.
申鐃緒申  9833 
申鐃緒申  9834 Do not alter the value of this variable manually.  This variable should be
申鐃緒申  9835 updated by the functions `make-coding-system' and
申鐃緒申  9836 `define-coding-system-alias'.  */);
申鐃緒申  9837   Vcoding_system_alist = Qnil;
申鐃緒申  9838 
申鐃緒申  9839   DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
申鐃緒申  9840 	       doc: /* List of coding-categories (symbols) ordered by priority.
申鐃緒申  9841 
申鐃緒申  9842 On detecting a coding system, Emacs tries code detection algorithms
申鐃緒申  9843 associated with each coding-category one by one in this order.  When
申鐃緒申  9844 one algorithm agrees with a byte sequence of source text, the coding
申鐃緒申  9845 system bound to the corresponding coding-category is selected.
申鐃緒申  9846 
申鐃緒申  9847 Don't modify this variable directly, but use `set-coding-priority'.  */);
申鐃緒申  9848   {
申鐃緒申  9849     int i;
申鐃緒申  9850 
申鐃緒申  9851     Vcoding_category_list = Qnil;
申鐃緒申  9852     for (i = coding_category_max - 1; i >= 0; i--)
申鐃緒申  9853       Vcoding_category_list
申鐃緒申  9854 	= Fcons (XVECTOR (Vcoding_category_table)->contents[i],
申鐃緒申  9855 		 Vcoding_category_list);
申鐃緒申  9856   }
申鐃緒申  9857 
申鐃緒申  9858   DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
申鐃緒申  9859 	       doc: /* Specify the coding system for read operations.
申鐃緒申  9860 It is useful to bind this variable with `let', but do not set it globally.
申鐃緒申  9861 If the value is a coding system, it is used for decoding on read operation.
申鐃緒申  9862 If not, an appropriate element is used from one of the coding system alists:
申鐃緒申  9863 There are three such tables, `file-coding-system-alist',
申鐃緒申  9864 `process-coding-system-alist', and `network-coding-system-alist'.  */);
申鐃緒申  9865   Vcoding_system_for_read = Qnil;
申鐃緒申  9866 
申鐃緒申  9867   DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
申鐃緒申  9868 	       doc: /* Specify the coding system for write operations.
申鐃緒申  9869 Programs bind this variable with `let', but you should not set it globally.
申鐃緒申  9870 If the value is a coding system, it is used for encoding of output,
申鐃緒申  9871 when writing it to a file and when sending it to a file or subprocess.
申鐃緒申  9872 
申鐃緒申  9873 If this does not specify a coding system, an appropriate element
申鐃緒申  9874 is used from one of the coding system alists:
申鐃緒申  9875 There are three such tables, `file-coding-system-alist',
申鐃緒申  9876 `process-coding-system-alist', and `network-coding-system-alist'.
申鐃緒申  9877 For output to files, if the above procedure does not specify a coding system,
申鐃緒申  9878 the value of `buffer-file-coding-system' is used.  */);
申鐃緒申  9879   Vcoding_system_for_write = Qnil;
申鐃緒申  9880 
申鐃緒申  9881   DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
申鐃緒申  9882 	       doc: /*
申鐃緒申  9883 Coding system used in the latest file or process I/O.  */);
申鐃緒申  9884   Vlast_coding_system_used = Qnil;
申鐃緒申  9885 
申鐃緒申  9886   DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error,
申鐃緒申  9887 	       doc: /*
申鐃緒申  9888 Error status of the last code conversion.
申鐃緒申  9889 
申鐃緒申  9890 When an error was detected in the last code conversion, this variable
申鐃緒申  9891 is set to one of the following symbols.
申鐃緒申  9892   `insufficient-source'
申鐃緒申  9893   `inconsistent-eol'
申鐃緒申  9894   `invalid-source'
申鐃緒申  9895   `interrupted'
申鐃緒申  9896   `insufficient-memory'
申鐃緒申  9897 When no error was detected, the value doesn't change.  So, to check
申鐃緒申  9898 the error status of a code conversion by this variable, you must
申鐃緒申  9899 explicitly set this variable to nil before performing code
申鐃緒申  9900 conversion.  */);
申鐃緒申  9901   Vlast_code_conversion_error = Qnil;
申鐃緒申  9902 
申鐃緒申  9903   DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
申鐃緒申  9904 	       doc: /*
申鐃緒申  9905 *Non-nil means always inhibit code conversion of end-of-line format.
申鐃緒申  9906 See info node `Coding Systems' and info node `Text and Binary' concerning
申鐃緒申  9907 such conversion.  */);
申鐃緒申  9908   inhibit_eol_conversion = 0;
申鐃緒申  9909 
申鐃緒申  9910   DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system,
申鐃緒申  9911 	       doc: /*
申鐃緒申  9912 Non-nil means process buffer inherits coding system of process output.
申鐃緒申  9913 Bind it to t if the process output is to be treated as if it were a file
申鐃緒申  9914 read from some filesystem.  */);
申鐃緒申  9915   inherit_process_coding_system = 0;
申鐃緒申  9916 
申鐃緒申  9917   DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist,
申鐃緒申  9918 	       doc: /*
申鐃緒申  9919 Alist to decide a coding system to use for a file I/O operation.
申鐃緒申  9920 The format is ((PATTERN . VAL) ...),
申鐃緒申  9921 where PATTERN is a regular expression matching a file name,
申鐃緒申  9922 VAL is a coding system, a cons of coding systems, or a function symbol.
申鐃緒申  9923 If VAL is a coding system, it is used for both decoding and encoding
申鐃緒申  9924 the file contents.
申鐃緒申  9925 If VAL is a cons of coding systems, the car part is used for decoding,
申鐃緒申  9926 and the cdr part is used for encoding.
申鐃緒申  9927 If VAL is a function symbol, the function must return a coding system
申鐃緒申  9928 or a cons of coding systems which are used as above.  The function is
申鐃緒申  9929 called with an argument that is a list of the arguments with which
申鐃緒申  9930 `find-operation-coding-system' was called.  If the function can't decide
申鐃緒申  9931 a coding system, it can return `undecided' so that the normal
申鐃緒申  9932 code-detection is performed.
申鐃緒申  9933 
申鐃緒申  9934 See also the function `find-operation-coding-system'
申鐃緒申  9935 and the variable `auto-coding-alist'.  */);
申鐃緒申  9936   Vfile_coding_system_alist = Qnil;
申鐃緒申  9937 
申鐃緒申  9938   DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
申鐃緒申  9939 	       doc: /*
申鐃緒申  9940 Alist to decide a coding system to use for a process I/O operation.
申鐃緒申  9941 The format is ((PATTERN . VAL) ...),
申鐃緒申  9942 where PATTERN is a regular expression matching a program name,
申鐃緒申  9943 VAL is a coding system, a cons of coding systems, or a function symbol.
申鐃緒申  9944 If VAL is a coding system, it is used for both decoding what received
申鐃緒申  9945 from the program and encoding what sent to the program.
申鐃緒申  9946 If VAL is a cons of coding systems, the car part is used for decoding,
申鐃緒申  9947 and the cdr part is used for encoding.
申鐃緒申  9948 If VAL is a function symbol, the function must return a coding system
申鐃緒申  9949 or a cons of coding systems which are used as above.
申鐃緒申  9950 
申鐃緒申  9951 See also the function `find-operation-coding-system'.  */);
申鐃緒申  9952   Vprocess_coding_system_alist = Qnil;
申鐃緒申  9953 
申鐃緒申  9954   DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist,
申鐃緒申  9955 	       doc: /*
申鐃緒申  9956 Alist to decide a coding system to use for a network I/O operation.
申鐃緒申  9957 The format is ((PATTERN . VAL) ...),
申鐃緒申  9958 where PATTERN is a regular expression matching a network service name
申鐃緒申  9959 or is a port number to connect to,
申鐃緒申  9960 VAL is a coding system, a cons of coding systems, or a function symbol.
申鐃緒申  9961 If VAL is a coding system, it is used for both decoding what received
申鐃緒申  9962 from the network stream and encoding what sent to the network stream.
申鐃緒申  9963 If VAL is a cons of coding systems, the car part is used for decoding,
申鐃緒申  9964 and the cdr part is used for encoding.
申鐃緒申  9965 If VAL is a function symbol, the function must return a coding system
申鐃緒申  9966 or a cons of coding systems which are used as above.
申鐃緒申  9967 
申鐃緒申  9968 See also the function `find-operation-coding-system'.  */);
申鐃緒申  9969   Vnetwork_coding_system_alist = Qnil;
申鐃緒申  9970 
申鐃緒申  9971   DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system,
申鐃緒申  9972 	       doc: /* Coding system to use with system messages.
申鐃緒申  9973 Also used for decoding keyboard input on X Window system.  */);
申鐃緒申  9974   Vlocale_coding_system = Qnil;
申鐃緒申  9975 
申鐃緒申  9976   /* The eol mnemonics are reset in startup.el system-dependently.  */
申鐃緒申  9977   DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
申鐃緒申  9978 	       doc: /*
申鐃緒申  9979 *String displayed in mode line for UNIX-like (LF) end-of-line format.  */);
申鐃緒申  9980   eol_mnemonic_unix = build_string (":");
申鐃緒申  9981 
申鐃緒申  9982   DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
申鐃緒申  9983 	       doc: /*
申鐃緒申  9984 *String displayed in mode line for DOS-like (CRLF) end-of-line format.  */);
申鐃緒申  9985   eol_mnemonic_dos = build_string ("\\");
申鐃緒申  9986 
申鐃緒申  9987   DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
申鐃緒申  9988 	       doc: /*
申鐃緒申  9989 *String displayed in mode line for MAC-like (CR) end-of-line format.  */);
申鐃緒申  9990   eol_mnemonic_mac = build_string ("/");
申鐃緒申  9991 
申鐃緒申  9992   DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
申鐃緒申  9993 	       doc: /*
申鐃緒申  9994 *String displayed in mode line when end-of-line format is not yet determined.  */);
申鐃緒申  9995   eol_mnemonic_undecided = build_string (":");
申鐃緒申  9996 
申鐃緒申  9997   DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
申鐃緒申  9998 	       doc: /*
申鐃緒申  9999 *Non-nil enables character translation while encoding and decoding.  */);
申鐃緒申 10000   Venable_character_translation = Qt;
申鐃緒申 10001 
申鐃緒申 10002   DEFVAR_LISP ("standard-translation-table-for-decode",
申鐃緒申 10003 	       &Vstandard_translation_table_for_decode,
申鐃緒申 10004 	       doc: /* Table for translating characters while decoding.  */);
申鐃緒申 10005   Vstandard_translation_table_for_decode = Qnil;
申鐃緒申 10006 
申鐃緒申 10007   DEFVAR_LISP ("standard-translation-table-for-encode",
申鐃緒申 10008 	       &Vstandard_translation_table_for_encode,
申鐃緒申 10009 	       doc: /* Table for translating characters while encoding.  */);
申鐃緒申 10010   Vstandard_translation_table_for_encode = Qnil;
申鐃緒申 10011 
申鐃緒申 10012   DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table,
申鐃緒申 10013 	       doc: /* Alist of charsets vs revision numbers.
申鐃緒申 10014 While encoding, if a charset (car part of an element) is found,
申鐃緒申 10015 designate it with the escape sequence identifying revision (cdr part
申鐃緒申 10016 of the element).  */);
申鐃緒申 10017   Vcharset_revision_table = Qnil;
申鐃緒申 10018 
申鐃緒申 10019   DEFVAR_LISP ("default-process-coding-system",
申鐃緒申 10020 	       &Vdefault_process_coding_system,
申鐃緒申 10021 	       doc: /* Cons of coding systems used for process I/O by default.
申鐃緒申 10022 The car part is used for decoding a process output,
申鐃緒申 10023 the cdr part is used for encoding a text to be sent to a process.  */);
申鐃緒申 10024   Vdefault_process_coding_system = Qnil;
申鐃緒申 10025 
申鐃緒申 10026   DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table,
申鐃緒申 10027 	       doc: /*
申鐃緒申 10028 Table of extra Latin codes in the range 128..159 (inclusive).
申鐃緒申 10029 This is a vector of length 256.
申鐃緒申 10030 If Nth element is non-nil, the existence of code N in a file
申鐃緒申 10031 \(or output of subprocess) doesn't prevent it to be detected as
申鐃緒申 10032 a coding system of ISO 2022 variant which has a flag
申鐃緒申 10033 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
申鐃緒申 10034 or reading output of a subprocess.
申鐃緒申 10035 Only 128th through 159th elements has a meaning.  */);
申鐃緒申 10036   Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
申鐃緒申 10037 
申鐃緒申 10038   DEFVAR_LISP ("select-safe-coding-system-function",
申鐃緒申 10039 	       &Vselect_safe_coding_system_function,
申鐃緒申 10040 	       doc: /*
申鐃緒申 10041 Function to call to select safe coding system for encoding a text.
申鐃緒申 10042 
申鐃緒申 10043 If set, this function is called to force a user to select a proper
申鐃緒申 10044 coding system which can encode the text in the case that a default
申鐃緒申 10045 coding system used in each operation can't encode the text.  The
申鐃緒申 10046 function should take care that the buffer is not modified while
申鐃緒申 10047 the coding system is being selected.
申鐃緒申 10048 
申鐃緒申 10049 The default value is `select-safe-coding-system' (which see).  */);
申鐃緒申 10050   Vselect_safe_coding_system_function = Qnil;
申鐃緒申 10051 
申鐃緒申 10052   DEFVAR_BOOL ("coding-system-require-warning",
申鐃緒申 10053 	       &coding_system_require_warning,
申鐃緒申 10054 	       doc: /* Internal use only.
申鐃緒申 10055 If non-nil, on writing a file, `select-safe-coding-system-function' is
申鐃緒申 10056 called even if `coding-system-for-write' is non-nil.  The command
申鐃緒申 10057 `universal-coding-system-argument' binds this variable to t temporarily.  */);
申鐃緒申 10058   coding_system_require_warning = 0;
申鐃緒申 10059 
申鐃緒申 10060 
申鐃緒申 10061   DEFVAR_BOOL ("inhibit-iso-escape-detection",
申鐃緒申 10062 	       &inhibit_iso_escape_detection,
申鐃緒申 10063 	       doc: /*
申鐃緒申 10064 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
申鐃緒申 10065 
申鐃緒申 10066 By default, on reading a file, Emacs tries to detect how the text is
申鐃緒申 10067 encoded.  This code detection is sensitive to escape sequences.  If
申鐃緒申 10068 the sequence is valid as ISO2022, the code is determined as one of
申鐃緒申 10069 the ISO2022 encodings, and the file is decoded by the corresponding
申鐃緒申 10070 coding system (e.g. `iso-2022-7bit').
申鐃緒申 10071 
申鐃緒申 10072 However, there may be a case that you want to read escape sequences in
申鐃緒申 10073 a file as is.  In such a case, you can set this variable to non-nil.
申鐃緒申 10074 Then, as the code detection ignores any escape sequences, no file is
申鐃緒申 10075 detected as encoded in some ISO2022 encoding.  The result is that all
申鐃緒申 10076 escape sequences become visible in a buffer.
申鐃緒申 10077 
申鐃緒申 10078 The default value is nil, and it is strongly recommended not to change
申鐃緒申 10079 it.  That is because many Emacs Lisp source files that contain
申鐃緒申 10080 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
申鐃緒申 10081 in Emacs's distribution, and they won't be decoded correctly on
申鐃緒申 10082 reading if you suppress escape sequence detection.
申鐃緒申 10083 
申鐃緒申 10084 The other way to read escape sequences in a file without decoding is
申鐃緒申 10085 to explicitly specify some coding system that doesn't use ISO2022's
申鐃緒申 10086 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument].  */);
申鐃緒申 10087   inhibit_iso_escape_detection = 0;
申鐃緒申 10088 
申鐃緒申 10089   DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input,
申鐃緒申 10090 	       doc: /* Char table for translating self-inserting characters.
申鐃緒申 10091 This is applied to the result of input methods, not their input.  See also
申鐃緒申 10092 `keyboard-translate-table'.  */);
申鐃緒申 10093     Vtranslation_table_for_input = Qnil;
申鐃緒申 10094 
申鐃緒申 10095   {
申鐃緒申 10096     Lisp_Object args[coding_arg_max];
申鐃緒申 10097     Lisp_Object plist[16];
申鐃緒申 10098     int i;
申鐃緒申 10099 
申鐃緒申 10100     for (i = 0; i < coding_arg_max; i++)
申鐃緒申 10101       args[i] = Qnil;
申鐃緒申 10102 
申鐃緒申 10103     plist[0] = intern (":name");
申鐃緒申 10104     plist[1] = args[coding_arg_name] = Qno_conversion;
申鐃緒申 10105     plist[2] = intern (":mnemonic");
申鐃緒申 10106     plist[3] = args[coding_arg_mnemonic] = make_number ('=');
申鐃緒申 10107     plist[4] = intern (":coding-type");
申鐃緒申 10108     plist[5] = args[coding_arg_coding_type] = Qraw_text;
申鐃緒申 10109     plist[6] = intern (":ascii-compatible-p");
申鐃緒申 10110     plist[7] = args[coding_arg_ascii_compatible_p] = Qt;
申鐃緒申 10111     plist[8] = intern (":default-char");
申鐃緒申 10112     plist[9] = args[coding_arg_default_char] = make_number (0);
申鐃緒申 10113     plist[10] = intern (":for-unibyte");
申鐃緒申 10114     plist[11] = args[coding_arg_for_unibyte] = Qt;
申鐃緒申 10115     plist[12] = intern (":docstring");
申鐃緒申 10116     plist[13] = build_string ("Do no conversion.\n\
申鐃緒申 10117 \n\
申鐃緒申 10118 When you visit a file with this coding, the file is read into a\n\
申鐃緒申 10119 unibyte buffer as is, thus each byte of a file is treated as a\n\
申鐃緒申 10120 character.");
申鐃緒申 10121     plist[14] = intern (":eol-type");
申鐃緒申 10122     plist[15] = args[coding_arg_eol_type] = Qunix;
申鐃緒申 10123     args[coding_arg_plist] = Flist (16, plist);
申鐃緒申 10124     Fdefine_coding_system_internal (coding_arg_max, args);
申鐃緒申 10125 
申鐃緒申 10126     plist[1] = args[coding_arg_name] = Qundecided;
申鐃緒申 10127     plist[3] = args[coding_arg_mnemonic] = make_number ('-');
申鐃緒申 10128     plist[5] = args[coding_arg_coding_type] = Qundecided;
申鐃緒申 10129     /* This is already set.
申鐃緒申 10130        plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
申鐃緒申 10131     plist[8] = intern (":charset-list");
申鐃緒申 10132     plist[9] = args[coding_arg_charset_list] = Fcons (Qascii, Qnil);
申鐃緒申 10133     plist[11] = args[coding_arg_for_unibyte] = Qnil;
申鐃緒申 10134     plist[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
申鐃緒申 10135     plist[15] = args[coding_arg_eol_type] = Qnil;
申鐃緒申 10136     args[coding_arg_plist] = Flist (16, plist);
申鐃緒申 10137     Fdefine_coding_system_internal (coding_arg_max, args);
申鐃緒申 10138   }
申鐃緒申 10139 
申鐃緒申 10140   setup_coding_system (Qno_conversion, &safe_terminal_coding);
申鐃緒申 10141 
申鐃緒申 10142   {
申鐃緒申 10143     int i;
申鐃緒申 10144 
申鐃緒申 10145     for (i = 0; i < coding_category_max; i++)
申鐃緒申 10146       Fset (AREF (Vcoding_category_table, i), Qno_conversion);
申鐃緒申 10147   }
申鐃緒申 10148 #if defined (MSDOS) || defined (WINDOWSNT)
申鐃緒申 10149   system_eol_type = Qdos;
申鐃緒申 10150 #else
申鐃緒申 10151   system_eol_type = Qunix;
申鐃緒申 10152 #endif
申鐃緒申 10153   staticpro (&system_eol_type);
申鐃緒申 10154 }
申鐃緒申 10155 
申鐃緒申 10156 char *
申鐃緒申 10157 emacs_strerror (error_number)
申鐃緒申 10158      int error_number;
申鐃緒申 10159 {
申鐃緒申 10160   char *str;
申鐃緒申 10161 
申鐃緒申 10162   synchronize_system_messages_locale ();
申鐃緒申 10163   str = strerror (error_number);
申鐃緒申 10164 
申鐃緒申 10165   if (! NILP (Vlocale_coding_system))
申鐃緒申 10166     {
申鐃緒申 10167       Lisp_Object dec = code_convert_string_norecord (build_string (str),
申鐃緒申 10168 						      Vlocale_coding_system,
申鐃緒申 10169 						      0);
申鐃緒申 10170       str = (char *) SDATA (dec);
申鐃緒申 10171     }
申鐃緒申 10172 
申鐃緒申 10173   return str;
申鐃緒申 10174 }
申鐃緒申 10175 
申鐃緒申 10176 #endif /* emacs */
申鐃緒申 10177 
申鐃緒申 10178 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
申鐃緒申 10179    (do not change this comment) */