HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Include coding.h and termhooks.h.
[bpt/emacs.git] / src / coding.c
CommitLineData
9542cb1f 1/* Coding system handler (conversion, detection, etc).
aaef169d 2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
76b6f707 3 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
7976eda0 4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
76b6f707 5 2005, 2006, 2007, 2008, 2009
ce03bf76
KH		 6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H14PRO021
8f924df7 8 Copyright (C) 2003
df7492f9
KH		 9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
4ed46869 11
369314dc
KH		 12This file is part of GNU Emacs.
13
9ec0b715 14GNU Emacs is free software: you can redistribute it and/or modify
369314dc 15it under the terms of the GNU General Public License as published by
9ec0b715
GM		 16the Free Software Foundation, either version 3 of the License, or
17(at your option) any later version.
4ed46869 18
369314dc
KH		 19GNU Emacs is distributed in the hope that it will be useful,
20but WITHOUT ANY WARRANTY; without even the implied warranty of
21MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22GNU General Public License for more details.
4ed46869 23
369314dc 24You should have received a copy of the GNU General Public License
9ec0b715 25along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
4ed46869
KH		 26
27/*** TABLE OF CONTENTS ***
28
b73bfc1c 29 0. General comments
4ed46869 30 1. Preamble
df7492f9
KH		 31 2. Emacs' internal format (emacs-utf-8) handlers
32 3. UTF-8 handlers
33 4. UTF-16 handlers
34 5. Charset-base coding systems handlers
35 6. emacs-mule (old Emacs' internal format) handlers
36 7. ISO2022 handlers
37 8. Shift-JIS and BIG5 handlers
38 9. CCL handlers
39 10. C library functions
40 11. Emacs Lisp library functions
41 12. Postamble
4ed46869
KH		 42
43*/
44
df7492f9 45/*** 0. General comments ***
b73bfc1c
KH		 46
47
df7492f9 48CODING SYSTEM
4ed46869 49
5bad0796
DL		 50 A coding system is an object for an encoding mechanism that contains
51 information about how to convert byte sequences to character
e19c3639
KH		 52 sequences and vice versa. When we say "decode", it means converting
53 a byte sequence of a specific coding system into a character
54 sequence that is represented by Emacs' internal coding system
55 `emacs-utf-8', and when we say "encode", it means converting a
56 character sequence of emacs-utf-8 to a byte sequence of a specific
0ef69138 57 coding system.
4ed46869 58
e19c3639
KH		 59 In Emacs Lisp, a coding system is represented by a Lisp symbol. In
60 C level, a coding system is represented by a vector of attributes
5bad0796 61 stored in the hash table Vcharset_hash_table. The conversion from
e19c3639
KH		 62 coding system symbol to attributes vector is done by looking up
63 Vcharset_hash_table by the symbol.
4ed46869 64
e19c3639 65 Coding systems are classified into the following types depending on
5bad0796 66 the encoding mechanism. Here's a brief description of the types.
4ed46869 67
df7492f9
KH		 68 o UTF-8
69
70 o UTF-16
71
72 o Charset-base coding system
73
74 A coding system defined by one or more (coded) character sets.
5bad0796 75 Decoding and encoding are done by a code converter defined for each
df7492f9
KH		 76 character set.
77
5bad0796 78 o Old Emacs internal format (emacs-mule)
df7492f9 79
5bad0796 80 The coding system adopted by old versions of Emacs (20 and 21).
4ed46869 81
df7492f9 82 o ISO2022-base coding system
4ed46869
KH		 83
84 The most famous coding system for multiple character sets. X's
df7492f9
KH		 85 Compound Text, various EUCs (Extended Unix Code), and coding systems
86 used in the Internet communication such as ISO-2022-JP are all
87 variants of ISO2022.
4ed46869 88
df7492f9 89 o SJIS (or Shift-JIS or MS-Kanji-Code)
93dec019 90
4ed46869
KH		 91 A coding system to encode character sets: ASCII, JISX0201, and
92 JISX0208. Widely used for PC's in Japan. Details are described in
df7492f9 93 section 8.
4ed46869 94
df7492f9 95 o BIG5
4ed46869 96
df7492f9 97 A coding system to encode character sets: ASCII and Big5. Widely
cfb43547 98 used for Chinese (mainly in Taiwan and Hong Kong). Details are
df7492f9
KH		 99 described in section 8. In this file, when we write "big5" (all
100 lowercase), we mean the coding system, and when we write "Big5"
101 (capitalized), we mean the character set.
4ed46869 102
df7492f9 103 o CCL
27901516 104
5bad0796 105 If a user wants to decode/encode text encoded in a coding system
df7492f9
KH		 106 not listed above, he can supply a decoder and an encoder for it in
107 CCL (Code Conversion Language) programs. Emacs executes the CCL
108 program while decoding/encoding.
27901516 109
df7492f9 110 o Raw-text
4ed46869 111
5a936b46 112 A coding system for text containing raw eight-bit data. Emacs
5bad0796 113 treats each byte of source text as a character (except for
df7492f9 114 end-of-line conversion).
4ed46869 115
df7492f9
KH		 116 o No-conversion
117
118 Like raw text, but don't do end-of-line conversion.
4ed46869 119
4ed46869 120
df7492f9 121END-OF-LINE FORMAT
4ed46869 122
5bad0796 123 How text end-of-line is encoded depends on operating system. For
df7492f9 124 instance, Unix's format is just one byte of LF (line-feed) code,
f4dee582 125 whereas DOS's format is two-byte sequence of `carriage-return' and
d46c5b12
KH		 126 `line-feed' codes. MacOS's format is usually one byte of
127 `carriage-return'.
4ed46869 128
cfb43547 129 Since text character encoding and end-of-line encoding are
df7492f9
KH		 130 independent, any coding system described above can take any format
131 of end-of-line (except for no-conversion).
4ed46869 132
e19c3639
KH		 133STRUCT CODING_SYSTEM
134
135 Before using a coding system for code conversion (i.e. decoding and
136 encoding), we setup a structure of type `struct coding_system'.
137 This structure keeps various information about a specific code
5bad0796 138 conversion (e.g. the location of source and destination data).
4ed46869
KH		 139
140*/
141
df7492f9
KH		 142/* COMMON MACROS */
143
144
4ed46869
KH		 145/*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
146
df7492f9 147 These functions check if a byte sequence specified as a source in
ff0dacd7
KH		 148 CODING conforms to the format of XXX, and update the members of
149 DETECT_INFO.
df7492f9 150
ff0dacd7 151 Return 1 if the byte sequence conforms to XXX, otherwise return 0.
df7492f9
KH		 152
153 Below is the template of these functions. */
154
4ed46869 155#if 0
df7492f9 156static int
ff0dacd7 157detect_coding_XXX (coding, detect_info)
df7492f9 158 struct coding_system *coding;
ff0dacd7 159 struct coding_detection_info *detect_info;
4ed46869 160{
f1d34bca
MB		 161 const unsigned char *src = coding->source;
162 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9 163 int multibytep = coding->src_multibyte;
ff0dacd7 164 int consumed_chars = 0;
df7492f9
KH		 165 int found = 0;
166 ...;
167
168 while (1)
169 {
170 /* Get one byte from the source. If the souce is exausted, jump
171 to no_more_source:. */
172 ONE_MORE_BYTE (c);
ff0dacd7
KH		 173
174 if (! __C_conforms_to_XXX___ (c))
175 break;
176 if (! __C_strongly_suggests_XXX__ (c))
177 found = CATEGORY_MASK_XXX;
df7492f9 178 }
ff0dacd7
KH		 179 /* The byte sequence is invalid for XXX. */
180 detect_info->rejected |= CATEGORY_MASK_XXX;
df7492f9 181 return 0;
ff0dacd7 182
df7492f9 183 no_more_source:
ff0dacd7
KH		 184 /* The source exausted successfully. */
185 detect_info->found |= found;
df7492f9 186 return 1;
4ed46869
KH		 187}
188#endif
189
190/*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
191
df7492f9
KH		 192 These functions decode a byte sequence specified as a source by
193 CODING. The resulting multibyte text goes to a place pointed to by
194 CODING->charbuf, the length of which should not exceed
195 CODING->charbuf_size;
d46c5b12 196
df7492f9
KH		 197 These functions set the information of original and decoded texts in
198 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
199 They also set CODING->result to one of CODING_RESULT_XXX indicating
200 how the decoding is finished.
d46c5b12 201
df7492f9 202 Below is the template of these functions. */
d46c5b12 203
4ed46869 204#if 0
b73bfc1c 205static void
df7492f9 206decode_coding_XXXX (coding)
4ed46869 207 struct coding_system *coding;
4ed46869 208{
f1d34bca
MB		 209 const unsigned char *src = coding->source + coding->consumed;
210 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 211 /* SRC_BASE remembers the start position in source in each loop.
212 The loop will be exited when there's not enough source code, or
213 when there's no room in CHARBUF for a decoded character. */
f1d34bca 214 const unsigned char *src_base;
df7492f9 215 /* A buffer to produce decoded characters. */
69a80ea3
KH		 216 int *charbuf = coding->charbuf + coding->charbuf_used;
217 int *charbuf_end = coding->charbuf + coding->charbuf_size;
df7492f9
KH		 218 int multibytep = coding->src_multibyte;
219
220 while (1)
221 {
222 src_base = src;
223 if (charbuf < charbuf_end)
224 /* No more room to produce a decoded character. */
225 break;
226 ONE_MORE_BYTE (c);
227 /* Decode it. */
228 }
229
230 no_more_source:
231 if (src_base < src_end
232 && coding->mode & CODING_MODE_LAST_BLOCK)
233 /* If the source ends by partial bytes to construct a character,
234 treat them as eight-bit raw data. */
235 while (src_base < src_end && charbuf < charbuf_end)
236 *charbuf++ = *src_base++;
237 /* Remember how many bytes and characters we consumed. If the
238 source is multibyte, the bytes and chars are not identical. */
239 coding->consumed = coding->consumed_char = src_base - coding->source;
240 /* Remember how many characters we produced. */
241 coding->charbuf_used = charbuf - coding->charbuf;
4ed46869
KH		 242}
243#endif
244
245/*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
246
df7492f9
KH		 247 These functions encode SRC_BYTES length text at SOURCE of Emacs'
248 internal multibyte format by CODING. The resulting byte sequence
b73bfc1c
KH		 249 goes to a place pointed to by DESTINATION, the length of which
250 should not exceed DST_BYTES.
d46c5b12 251
df7492f9
KH		 252 These functions set the information of original and encoded texts in
253 the members produced, produced_char, consumed, and consumed_char of
254 the structure *CODING. They also set the member result to one of
255 CODING_RESULT_XXX indicating how the encoding finished.
d46c5b12 256
df7492f9
KH		 257 DST_BYTES zero means that source area and destination area are
258 overlapped, which means that we can produce a encoded text until it
259 reaches at the head of not-yet-encoded source text.
d46c5b12 260
df7492f9 261 Below is a template of these functions. */
4ed46869 262#if 0
b73bfc1c 263static void
df7492f9 264encode_coding_XXX (coding)
4ed46869 265 struct coding_system *coding;
4ed46869 266{
df7492f9
KH		 267 int multibytep = coding->dst_multibyte;
268 int *charbuf = coding->charbuf;
269 int *charbuf_end = charbuf->charbuf + coding->charbuf_used;
270 unsigned char *dst = coding->destination + coding->produced;
271 unsigned char *dst_end = coding->destination + coding->dst_bytes;
272 unsigned char *adjusted_dst_end = dst_end - _MAX_BYTES_PRODUCED_IN_LOOP_;
273 int produced_chars = 0;
274
275 for (; charbuf < charbuf_end && dst < adjusted_dst_end; charbuf++)
276 {
277 int c = *charbuf;
278 /* Encode C into DST, and increment DST. */
279 }
280 label_no_more_destination:
281 /* How many chars and bytes we produced. */
282 coding->produced_char += produced_chars;
283 coding->produced = dst - coding->destination;
4ed46869
KH		 284}
285#endif
286
4ed46869
KH		 287\f
288/*** 1. Preamble ***/
289
68c45bf0 290#include <config.h>
4ed46869
KH		 291#include <stdio.h>
292
4ed46869
KH		 293#include "lisp.h"
294#include "buffer.h"
df7492f9 295#include "character.h"
4ed46869
KH		 296#include "charset.h"
297#include "ccl.h"
df7492f9 298#include "composite.h"
4ed46869
KH		 299#include "coding.h"
300#include "window.h"
b8299c66
KL		 301#include "frame.h"
302#include "termhooks.h"
4ed46869 303
df7492f9 304Lisp_Object Vcoding_system_hash_table;
4ed46869 305
df7492f9 306Lisp_Object Qcoding_system, Qcoding_aliases, Qeol_type;
1965cb73
DL		 307Lisp_Object Qunix, Qdos;
308extern Lisp_Object Qmac; /* frame.c */
4ed46869
KH		 309Lisp_Object Qbuffer_file_coding_system;
310Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
df7492f9 311Lisp_Object Qdefault_char;
27901516 312Lisp_Object Qno_conversion, Qundecided;
df7492f9 313Lisp_Object Qcharset, Qiso_2022, Qutf_8, Qutf_16, Qshift_jis, Qbig5;
b49a1807 314Lisp_Object Qbig, Qlittle;
bb0115a2 315Lisp_Object Qcoding_system_history;
1397dc18 316Lisp_Object Qvalid_codes;
2133e2d1 317Lisp_Object QCcategory, QCmnemonic, QCdefault_char;
a6f87d34
KH		 318Lisp_Object QCdecode_translation_table, QCencode_translation_table;
319Lisp_Object QCpost_read_conversion, QCpre_write_conversion;
35befdaa 320Lisp_Object QCascii_compatible_p;
4ed46869
KH		 321
322extern Lisp_Object Qinsert_file_contents, Qwrite_region;
387f6ba5 323Lisp_Object Qcall_process, Qcall_process_region;
4ed46869
KH		 324Lisp_Object Qstart_process, Qopen_network_stream;
325Lisp_Object Qtarget_idx;
326
065e3595
KH		 327Lisp_Object Qinsufficient_source, Qinconsistent_eol, Qinvalid_source;
328Lisp_Object Qinterrupted, Qinsufficient_memory;
329
c7183fb8
GM		 330extern Lisp_Object Qcompletion_ignore_case;
331
44e8490d
KH		 332/* If a symbol has this property, evaluate the value to define the
333 symbol as a coding system. */
334static Lisp_Object Qcoding_system_define_form;
335
5d5bf4d8
KH		 336int coding_system_require_warning;
337
d46c5b12
KH		 338Lisp_Object Vselect_safe_coding_system_function;
339
7722baf9
EZ		 340/* Mnemonic string for each format of end-of-line. */
341Lisp_Object eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
342/* Mnemonic string to indicate format of end-of-line is not yet
4ed46869 343 decided. */
7722baf9 344Lisp_Object eol_mnemonic_undecided;
4ed46869 345
fcbcfb64
KH		 346/* Format of end-of-line decided by system. This is Qunix on
347 Unix and Mac, Qdos on DOS/Windows.
348 This has an effect only for external encoding (i.e. for output to
349 file and process), not for in-buffer or Lisp string encoding. */
350static Lisp_Object system_eol_type;
351
4ed46869
KH		 352#ifdef emacs
353
4608c386
KH		 354Lisp_Object Vcoding_system_list, Vcoding_system_alist;
355
356Lisp_Object Qcoding_system_p, Qcoding_system_error;
4ed46869 357
d46c5b12
KH		 358/* Coding system emacs-mule and raw-text are for converting only
359 end-of-line format. */
360Lisp_Object Qemacs_mule, Qraw_text;
8f924df7 361Lisp_Object Qutf_8_emacs;
ecf488bc 362
4ed46869
KH		 363/* Coding-systems are handed between Emacs Lisp programs and C internal
364 routines by the following three variables. */
365/* Coding-system for reading files and receiving data from process. */
366Lisp_Object Vcoding_system_for_read;
367/* Coding-system for writing files and sending data to process. */
368Lisp_Object Vcoding_system_for_write;
369/* Coding-system actually used in the latest I/O. */
370Lisp_Object Vlast_coding_system_used;
065e3595
KH		 371/* Set to non-nil when an error is detected while code conversion. */
372Lisp_Object Vlast_code_conversion_error;
c4825358 373/* A vector of length 256 which contains information about special
94487c4e 374 Latin codes (especially for dealing with Microsoft codes). */
3f003981 375Lisp_Object Vlatin_extra_code_table;
c4825358 376
9ce27fde
KH		 377/* Flag to inhibit code conversion of end-of-line format. */
378int inhibit_eol_conversion;
379
74383408
KH		 380/* Flag to inhibit ISO2022 escape sequence detection. */
381int inhibit_iso_escape_detection;
382
97b1b294
EZ		 383/* Flag to inhibit detection of binary files through null bytes. */
384int inhibit_null_byte_detection;
385
ed29121d
EZ		 386/* Flag to make buffer-file-coding-system inherit from process-coding. */
387int inherit_process_coding_system;
388
c4825358
KH		 389/* Coding system to be used to encode text for terminal display when
390 terminal coding system is nil. */
391struct coding_system safe_terminal_coding;
392
02ba4723
KH		 393Lisp_Object Vfile_coding_system_alist;
394Lisp_Object Vprocess_coding_system_alist;
395Lisp_Object Vnetwork_coding_system_alist;
4ed46869 396
68c45bf0
PE		 397Lisp_Object Vlocale_coding_system;
398
4ed46869
KH		 399#endif /* emacs */
400
f967223b
KH		 401/* Flag to tell if we look up translation table on character code
402 conversion. */
84fbb8a0 403Lisp_Object Venable_character_translation;
f967223b
KH		 404/* Standard translation table to look up on decoding (reading). */
405Lisp_Object Vstandard_translation_table_for_decode;
406/* Standard translation table to look up on encoding (writing). */
407Lisp_Object Vstandard_translation_table_for_encode;
84fbb8a0 408
f967223b
KH		 409Lisp_Object Qtranslation_table;
410Lisp_Object Qtranslation_table_id;
411Lisp_Object Qtranslation_table_for_decode;
412Lisp_Object Qtranslation_table_for_encode;
4ed46869
KH		 413
414/* Alist of charsets vs revision number. */
df7492f9 415static Lisp_Object Vcharset_revision_table;
4ed46869 416
02ba4723
KH		 417/* Default coding systems used for process I/O. */
418Lisp_Object Vdefault_process_coding_system;
419
002fdb44
DL		 420/* Char table for translating Quail and self-inserting input. */
421Lisp_Object Vtranslation_table_for_input;
422
df7492f9
KH		 423/* Two special coding systems. */
424Lisp_Object Vsjis_coding_system;
425Lisp_Object Vbig5_coding_system;
426
df7492f9
KH		 427/* ISO2022 section */
428
429#define CODING_ISO_INITIAL(coding, reg) \
430 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
431 coding_attr_iso_initial), \
432 reg)))
433
434
435#define CODING_ISO_REQUEST(coding, charset_id) \
436 ((charset_id <= (coding)->max_charset_id \
437 ? (coding)->safe_charsets[charset_id] \
438 : -1))
439
440
441#define CODING_ISO_FLAGS(coding) \
442 ((coding)->spec.iso_2022.flags)
443#define CODING_ISO_DESIGNATION(coding, reg) \
444 ((coding)->spec.iso_2022.current_designation[reg])
445#define CODING_ISO_INVOCATION(coding, plane) \
446 ((coding)->spec.iso_2022.current_invocation[plane])
447#define CODING_ISO_SINGLE_SHIFTING(coding) \
448 ((coding)->spec.iso_2022.single_shifting)
449#define CODING_ISO_BOL(coding) \
450 ((coding)->spec.iso_2022.bol)
451#define CODING_ISO_INVOKED_CHARSET(coding, plane) \
452 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
453
454/* Control characters of ISO2022. */
455 /* code */ /* function */
456#define ISO_CODE_LF 0x0A /* line-feed */
457#define ISO_CODE_CR 0x0D /* carriage-return */
458#define ISO_CODE_SO 0x0E /* shift-out */
459#define ISO_CODE_SI 0x0F /* shift-in */
460#define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
461#define ISO_CODE_ESC 0x1B /* escape */
462#define ISO_CODE_SS2 0x8E /* single-shift-2 */
463#define ISO_CODE_SS3 0x8F /* single-shift-3 */
464#define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
465
466/* All code (1-byte) of ISO2022 is classified into one of the
467 followings. */
468enum iso_code_class_type
469 {
470 ISO_control_0, /* Control codes in the range
471 0x00..0x1F and 0x7F, except for the
472 following 5 codes. */
df7492f9
KH		 473 ISO_shift_out, /* ISO_CODE_SO (0x0E) */
474 ISO_shift_in, /* ISO_CODE_SI (0x0F) */
475 ISO_single_shift_2_7, /* ISO_CODE_SS2_7 (0x19) */
476 ISO_escape, /* ISO_CODE_SO (0x1B) */
477 ISO_control_1, /* Control codes in the range
478 0x80..0x9F, except for the
479 following 3 codes. */
480 ISO_single_shift_2, /* ISO_CODE_SS2 (0x8E) */
481 ISO_single_shift_3, /* ISO_CODE_SS3 (0x8F) */
482 ISO_control_sequence_introducer, /* ISO_CODE_CSI (0x9B) */
483 ISO_0x20_or_0x7F, /* Codes of the values 0x20 or 0x7F. */
484 ISO_graphic_plane_0, /* Graphic codes in the range 0x21..0x7E. */
485 ISO_0xA0_or_0xFF, /* Codes of the values 0xA0 or 0xFF. */
486 ISO_graphic_plane_1 /* Graphic codes in the range 0xA1..0xFE. */
487 };
05e6f5dc 488
df7492f9
KH		 489/** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
490 `iso-flags' attribute of an iso2022 coding system. */
05e6f5dc 491
df7492f9
KH		 492/* If set, produce long-form designation sequence (e.g. ESC $ ( A)
493 instead of the correct short-form sequence (e.g. ESC $ A). */
494#define CODING_ISO_FLAG_LONG_FORM 0x0001
93dec019 495
df7492f9
KH		 496/* If set, reset graphic planes and registers at end-of-line to the
497 initial state. */
498#define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
05e6f5dc 499
df7492f9
KH		 500/* If set, reset graphic planes and registers before any control
501 characters to the initial state. */
502#define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
05e6f5dc 503
df7492f9
KH		 504/* If set, encode by 7-bit environment. */
505#define CODING_ISO_FLAG_SEVEN_BITS 0x0008
4ed46869 506
df7492f9
KH		 507/* If set, use locking-shift function. */
508#define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
b73bfc1c 509
df7492f9
KH		 510/* If set, use single-shift function. Overwrite
511 CODING_ISO_FLAG_LOCKING_SHIFT. */
512#define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
b73bfc1c 513
df7492f9
KH		 514/* If set, use designation escape sequence. */
515#define CODING_ISO_FLAG_DESIGNATION 0x0040
b73bfc1c 516
df7492f9
KH		 517/* If set, produce revision number sequence. */
518#define CODING_ISO_FLAG_REVISION 0x0080
b73bfc1c 519
df7492f9
KH		 520/* If set, produce ISO6429's direction specifying sequence. */
521#define CODING_ISO_FLAG_DIRECTION 0x0100
f4dee582 522
df7492f9
KH		 523/* If set, assume designation states are reset at beginning of line on
524 output. */
525#define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
4ed46869 526
df7492f9
KH		 527/* If set, designation sequence should be placed at beginning of line
528 on output. */
529#define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
aa72b389 530
df7492f9
KH		 531/* If set, do not encode unsafe charactes on output. */
532#define CODING_ISO_FLAG_SAFE 0x0800
aa72b389 533
df7492f9
KH		 534/* If set, extra latin codes (128..159) are accepted as a valid code
535 on input. */
536#define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
aa72b389 537
df7492f9 538#define CODING_ISO_FLAG_COMPOSITION 0x2000
aa72b389 539
df7492f9 540#define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000
aa72b389 541
bf16eb23 542#define CODING_ISO_FLAG_USE_ROMAN 0x8000
aa72b389 543
bf16eb23 544#define CODING_ISO_FLAG_USE_OLDJIS 0x10000
aa72b389 545
bf16eb23 546#define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
aa72b389 547
df7492f9
KH		 548/* A character to be produced on output if encoding of the original
549 character is prohibited by CODING_ISO_FLAG_SAFE. */
550#define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
aa72b389 551
a470d443
KH		 552/* UTF-8 section */
553#define CODING_UTF_8_BOM(coding) \
554 ((coding)->spec.utf_8_bom)
4ed46869 555
df7492f9
KH		 556/* UTF-16 section */
557#define CODING_UTF_16_BOM(coding) \
558 ((coding)->spec.utf_16.bom)
4ed46869 559
df7492f9
KH		 560#define CODING_UTF_16_ENDIAN(coding) \
561 ((coding)->spec.utf_16.endian)
4ed46869 562
df7492f9
KH		 563#define CODING_UTF_16_SURROGATE(coding) \
564 ((coding)->spec.utf_16.surrogate)
4ed46869 565
4ed46869 566
df7492f9
KH		 567/* CCL section */
568#define CODING_CCL_DECODER(coding) \
569 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
570#define CODING_CCL_ENCODER(coding) \
571 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
572#define CODING_CCL_VALIDS(coding) \
8f924df7 573 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
4ed46869 574
5a936b46 575/* Index for each coding category in `coding_categories' */
4ed46869 576
df7492f9
KH		 577enum coding_category
578 {
579 coding_category_iso_7,
580 coding_category_iso_7_tight,
581 coding_category_iso_8_1,
582 coding_category_iso_8_2,
583 coding_category_iso_7_else,
584 coding_category_iso_8_else,
a470d443
KH		 585 coding_category_utf_8_auto,
586 coding_category_utf_8_nosig,
587 coding_category_utf_8_sig,
df7492f9
KH		 588 coding_category_utf_16_auto,
589 coding_category_utf_16_be,
590 coding_category_utf_16_le,
591 coding_category_utf_16_be_nosig,
592 coding_category_utf_16_le_nosig,
593 coding_category_charset,
594 coding_category_sjis,
595 coding_category_big5,
596 coding_category_ccl,
597 coding_category_emacs_mule,
598 /* All above are targets of code detection. */
599 coding_category_raw_text,
600 coding_category_undecided,
601 coding_category_max
602 };
603
604/* Definitions of flag bits used in detect_coding_XXXX. */
605#define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
606#define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
607#define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
608#define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
609#define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
610#define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
a470d443
KH		 611#define CATEGORY_MASK_UTF_8_AUTO (1 << coding_category_utf_8_auto)
612#define CATEGORY_MASK_UTF_8_NOSIG (1 << coding_category_utf_8_nosig)
613#define CATEGORY_MASK_UTF_8_SIG (1 << coding_category_utf_8_sig)
b49a1807 614#define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
df7492f9
KH		 615#define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
616#define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
617#define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
618#define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
619#define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
620#define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
621#define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
622#define CATEGORY_MASK_CCL (1 << coding_category_ccl)
623#define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
ff0dacd7 624#define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
df7492f9
KH		 625
626/* This value is returned if detect_coding_mask () find nothing other
627 than ASCII characters. */
628#define CATEGORY_MASK_ANY \
629 (CATEGORY_MASK_ISO_7 \
630 | CATEGORY_MASK_ISO_7_TIGHT \
631 | CATEGORY_MASK_ISO_8_1 \
632 | CATEGORY_MASK_ISO_8_2 \
633 | CATEGORY_MASK_ISO_7_ELSE \
634 | CATEGORY_MASK_ISO_8_ELSE \
a470d443
KH		 635 | CATEGORY_MASK_UTF_8_AUTO \
636 | CATEGORY_MASK_UTF_8_NOSIG \
637 | CATEGORY_MASK_UTF_8_SIG \
2f3cbb32 638 | CATEGORY_MASK_UTF_16_AUTO \
df7492f9
KH		 639 | CATEGORY_MASK_UTF_16_BE \
640 | CATEGORY_MASK_UTF_16_LE \
641 | CATEGORY_MASK_UTF_16_BE_NOSIG \
642 | CATEGORY_MASK_UTF_16_LE_NOSIG \
643 | CATEGORY_MASK_CHARSET \
644 | CATEGORY_MASK_SJIS \
645 | CATEGORY_MASK_BIG5 \
646 | CATEGORY_MASK_CCL \
647 | CATEGORY_MASK_EMACS_MULE)
648
649
650#define CATEGORY_MASK_ISO_7BIT \
651 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
652
653#define CATEGORY_MASK_ISO_8BIT \
654 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
655
656#define CATEGORY_MASK_ISO_ELSE \
657 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
658
659#define CATEGORY_MASK_ISO_ESCAPE \
660 (CATEGORY_MASK_ISO_7 \
661 | CATEGORY_MASK_ISO_7_TIGHT \
662 | CATEGORY_MASK_ISO_7_ELSE \
663 | CATEGORY_MASK_ISO_8_ELSE)
664
665#define CATEGORY_MASK_ISO \
666 ( CATEGORY_MASK_ISO_7BIT \
667 | CATEGORY_MASK_ISO_8BIT \
668 | CATEGORY_MASK_ISO_ELSE)
669
670#define CATEGORY_MASK_UTF_16 \
2f3cbb32
KH		 671 (CATEGORY_MASK_UTF_16_AUTO \
672 | CATEGORY_MASK_UTF_16_BE \
df7492f9
KH		 673 | CATEGORY_MASK_UTF_16_LE \
674 | CATEGORY_MASK_UTF_16_BE_NOSIG \
675 | CATEGORY_MASK_UTF_16_LE_NOSIG)
676
a470d443
KH		 677#define CATEGORY_MASK_UTF_8 \
678 (CATEGORY_MASK_UTF_8_AUTO \
679 | CATEGORY_MASK_UTF_8_NOSIG \
680 | CATEGORY_MASK_UTF_8_SIG)
df7492f9
KH		 681
682/* List of symbols `coding-category-xxx' ordered by priority. This
683 variable is exposed to Emacs Lisp. */
684static Lisp_Object Vcoding_category_list;
685
686/* Table of coding categories (Lisp symbols). This variable is for
687 internal use oly. */
688static Lisp_Object Vcoding_category_table;
689
690/* Table of coding-categories ordered by priority. */
691static enum coding_category coding_priorities[coding_category_max];
692
693/* Nth element is a coding context for the coding system bound to the
694 Nth coding category. */
695static struct coding_system coding_categories[coding_category_max];
696
df7492f9
KH		 697/*** Commonly used macros and functions ***/
698
699#ifndef min
700#define min(a, b) ((a) < (b) ? (a) : (b))
701#endif
702#ifndef max
703#define max(a, b) ((a) > (b) ? (a) : (b))
704#endif
4ed46869 705
24a73b0a
KH		 706#define CODING_GET_INFO(coding, attrs, charset_list) \
707 do { \
708 (attrs) = CODING_ID_ATTRS ((coding)->id); \
709 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
df7492f9 710 } while (0)
4ed46869 711
4ed46869 712
df7492f9
KH		 713/* Safely get one byte from the source text pointed by SRC which ends
714 at SRC_END, and set C to that byte. If there are not enough bytes
065e3595
KH		 715 in the source, it jumps to `no_more_source'. If multibytep is
716 nonzero, and a multibyte character is found at SRC, set C to the
717 negative value of the character code. The caller should declare
718 and set these variables appropriately in advance:
719 src, src_end, multibytep */
aa72b389 720
065e3595
KH		 721#define ONE_MORE_BYTE(c) \
722 do { \
723 if (src == src_end) \
724 { \
725 if (src_base < src) \
726 record_conversion_result \
727 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
728 goto no_more_source; \
729 } \
730 c = *src++; \
731 if (multibytep && (c & 0x80)) \
732 { \
733 if ((c & 0xFE) == 0xC0) \
734 c = ((c & 1) << 6) | *src++; \
735 else \
736 { \
35befdaa
KH		 737 src--; \
738 c = - string_char (src, &src, NULL); \
065e3595
KH		 739 record_conversion_result \
740 (coding, CODING_RESULT_INVALID_SRC); \
741 } \
742 } \
743 consumed_chars++; \
aa72b389
KH		 744 } while (0)
745
f56a4450 746/* Safely get two bytes from the source text pointed by SRC which ends
220eeac9
KH		 747 at SRC_END, and set C1 and C2 to those bytes while skipping the
748 heading multibyte characters. If there are not enough bytes in the
749 source, it jumps to `no_more_source'. If multibytep is nonzero and
750 a multibyte character is found for C2, set C2 to the negative value
751 of the character code. The caller should declare and set these
752 variables appropriately in advance:
f56a4450
KH		 753 src, src_end, multibytep
754 It is intended that this macro is used in detect_coding_utf_16. */
755
220eeac9
KH		 756#define TWO_MORE_BYTES(c1, c2) \
757 do { \
758 do { \
759 if (src == src_end) \
760 goto no_more_source; \
761 c1 = *src++; \
762 if (multibytep && (c1 & 0x80)) \
763 { \
764 if ((c1 & 0xFE) == 0xC0) \
765 c1 = ((c1 & 1) << 6) | *src++; \
766 else \
767 { \
768 src += BYTES_BY_CHAR_HEAD (c1) - 1; \
769 c1 = -1; \
770 } \
771 } \
772 } while (c1 < 0); \
773 if (src == src_end) \
774 goto no_more_source; \
775 c2 = *src++; \
776 if (multibytep && (c2 & 0x80)) \
777 { \
778 if ((c2 & 0xFE) == 0xC0) \
779 c2 = ((c2 & 1) << 6) | *src++; \
780 else \
781 c2 = -1; \
782 } \
f56a4450
KH		 783 } while (0)
784
aa72b389 785
065e3595
KH		 786#define ONE_MORE_BYTE_NO_CHECK(c) \
787 do { \
788 c = *src++; \
789 if (multibytep && (c & 0x80)) \
790 { \
791 if ((c & 0xFE) == 0xC0) \
792 c = ((c & 1) << 6) | *src++; \
793 else \
794 { \
35befdaa
KH		 795 src--; \
796 c = - string_char (src, &src, NULL); \
065e3595
KH		 797 record_conversion_result \
798 (coding, CODING_RESULT_INVALID_SRC); \
799 } \
800 } \
801 consumed_chars++; \
aa72b389
KH		 802 } while (0)
803
aa72b389 804
df7492f9
KH		 805/* Store a byte C in the place pointed by DST and increment DST to the
806 next free point, and increment PRODUCED_CHARS. The caller should
807 assure that C is 0..127, and declare and set the variable `dst'
808 appropriately in advance.
809*/
aa72b389
KH		 810
811
df7492f9
KH		 812#define EMIT_ONE_ASCII_BYTE(c) \
813 do { \
814 produced_chars++; \
815 *dst++ = (c); \
b6871cc7 816 } while (0)
aa72b389
KH		 817
818
df7492f9 819/* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
aa72b389 820
df7492f9
KH		 821#define EMIT_TWO_ASCII_BYTES(c1, c2) \
822 do { \
823 produced_chars += 2; \
824 *dst++ = (c1), *dst++ = (c2); \
825 } while (0)
aa72b389
KH		 826
827
df7492f9
KH		 828/* Store a byte C in the place pointed by DST and increment DST to the
829 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
830 nonzero, store in an appropriate multibyte from. The caller should
831 declare and set the variables `dst' and `multibytep' appropriately
832 in advance. */
833
834#define EMIT_ONE_BYTE(c) \
835 do { \
836 produced_chars++; \
837 if (multibytep) \
838 { \
839 int ch = (c); \
840 if (ch >= 0x80) \
841 ch = BYTE8_TO_CHAR (ch); \
842 CHAR_STRING_ADVANCE (ch, dst); \
843 } \
844 else \
845 *dst++ = (c); \
aa72b389 846 } while (0)
aa72b389 847
aa72b389 848
df7492f9 849/* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
aa72b389 850
e19c3639
KH		 851#define EMIT_TWO_BYTES(c1, c2) \
852 do { \
853 produced_chars += 2; \
854 if (multibytep) \
855 { \
856 int ch; \
857 \
858 ch = (c1); \
859 if (ch >= 0x80) \
860 ch = BYTE8_TO_CHAR (ch); \
861 CHAR_STRING_ADVANCE (ch, dst); \
862 ch = (c2); \
863 if (ch >= 0x80) \
864 ch = BYTE8_TO_CHAR (ch); \
865 CHAR_STRING_ADVANCE (ch, dst); \
866 } \
867 else \
868 { \
869 *dst++ = (c1); \
870 *dst++ = (c2); \
871 } \
aa72b389
KH		 872 } while (0)
873
874
df7492f9
KH		 875#define EMIT_THREE_BYTES(c1, c2, c3) \
876 do { \
877 EMIT_ONE_BYTE (c1); \
878 EMIT_TWO_BYTES (c2, c3); \
879 } while (0)
aa72b389 880
aa72b389 881
df7492f9
KH		 882#define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
883 do { \
884 EMIT_TWO_BYTES (c1, c2); \
885 EMIT_TWO_BYTES (c3, c4); \
886 } while (0)
aa72b389 887
aa72b389 888
f6cbaf43
KH		 889/* Prototypes for static functions. */
890static void record_conversion_result P_ ((struct coding_system *coding,
891 enum coding_result_code result));
892static int detect_coding_utf_8 P_ ((struct coding_system *,
893 struct coding_detection_info *info));
894static void decode_coding_utf_8 P_ ((struct coding_system *));
895static int encode_coding_utf_8 P_ ((struct coding_system *));
896
897static int detect_coding_utf_16 P_ ((struct coding_system *,
898 struct coding_detection_info *info));
899static void decode_coding_utf_16 P_ ((struct coding_system *));
900static int encode_coding_utf_16 P_ ((struct coding_system *));
901
902static int detect_coding_iso_2022 P_ ((struct coding_system *,
903 struct coding_detection_info *info));
904static void decode_coding_iso_2022 P_ ((struct coding_system *));
905static int encode_coding_iso_2022 P_ ((struct coding_system *));
906
907static int detect_coding_emacs_mule P_ ((struct coding_system *,
908 struct coding_detection_info *info));
909static void decode_coding_emacs_mule P_ ((struct coding_system *));
910static int encode_coding_emacs_mule P_ ((struct coding_system *));
911
912static int detect_coding_sjis P_ ((struct coding_system *,
913 struct coding_detection_info *info));
914static void decode_coding_sjis P_ ((struct coding_system *));
915static int encode_coding_sjis P_ ((struct coding_system *));
916
917static int detect_coding_big5 P_ ((struct coding_system *,
918 struct coding_detection_info *info));
919static void decode_coding_big5 P_ ((struct coding_system *));
920static int encode_coding_big5 P_ ((struct coding_system *));
921
922static int detect_coding_ccl P_ ((struct coding_system *,
923 struct coding_detection_info *info));
924static void decode_coding_ccl P_ ((struct coding_system *));
925static int encode_coding_ccl P_ ((struct coding_system *));
926
927static void decode_coding_raw_text P_ ((struct coding_system *));
928static int encode_coding_raw_text P_ ((struct coding_system *));
929
930static void coding_set_source P_ ((struct coding_system *));
931static void coding_set_destination P_ ((struct coding_system *));
932static void coding_alloc_by_realloc P_ ((struct coding_system *, EMACS_INT));
933static void coding_alloc_by_making_gap P_ ((struct coding_system *,
287c57d7 934 EMACS_INT, EMACS_INT));
f6cbaf43
KH		 935static unsigned char *alloc_destination P_ ((struct coding_system *,
936 EMACS_INT, unsigned char *));
937static void setup_iso_safe_charsets P_ ((Lisp_Object));
938static unsigned char *encode_designation_at_bol P_ ((struct coding_system *,
939 int *, int *,
940 unsigned char *));
941static int detect_eol P_ ((const unsigned char *,
942 EMACS_INT, enum coding_category));
943static Lisp_Object adjust_coding_eol_type P_ ((struct coding_system *, int));
944static void decode_eol P_ ((struct coding_system *));
945static Lisp_Object get_translation_table P_ ((Lisp_Object, int, int *));
946static Lisp_Object get_translation P_ ((Lisp_Object, int *, int *,
947 int, int *, int *));
948static int produce_chars P_ ((struct coding_system *, Lisp_Object, int));
949static INLINE void produce_composition P_ ((struct coding_system *, int *,
950 EMACS_INT));
951static INLINE void produce_charset P_ ((struct coding_system *, int *,
952 EMACS_INT));
953static void produce_annotation P_ ((struct coding_system *, EMACS_INT));
954static int decode_coding P_ ((struct coding_system *));
955static INLINE int *handle_composition_annotation P_ ((EMACS_INT, EMACS_INT,
3ed051d4 956 struct coding_system *,
f6cbaf43
KH		 957 int *, EMACS_INT *));
958static INLINE int *handle_charset_annotation P_ ((EMACS_INT, EMACS_INT,
959 struct coding_system *,
960 int *, EMACS_INT *));
961static void consume_chars P_ ((struct coding_system *, Lisp_Object, int));
962static int encode_coding P_ ((struct coding_system *));
963static Lisp_Object make_conversion_work_buffer P_ ((int));
964static Lisp_Object code_conversion_restore P_ ((Lisp_Object));
965static INLINE int char_encodable_p P_ ((int, Lisp_Object));
966static Lisp_Object make_subsidiaries P_ ((Lisp_Object));
967
065e3595
KH		 968static void
969record_conversion_result (struct coding_system *coding,
970 enum coding_result_code result)
971{
972 coding->result = result;
973 switch (result)
974 {
975 case CODING_RESULT_INSUFFICIENT_SRC:
976 Vlast_code_conversion_error = Qinsufficient_source;
977 break;
978 case CODING_RESULT_INCONSISTENT_EOL:
979 Vlast_code_conversion_error = Qinconsistent_eol;
980 break;
981 case CODING_RESULT_INVALID_SRC:
982 Vlast_code_conversion_error = Qinvalid_source;
983 break;
984 case CODING_RESULT_INTERRUPT:
985 Vlast_code_conversion_error = Qinterrupted;
986 break;
987 case CODING_RESULT_INSUFFICIENT_MEM:
988 Vlast_code_conversion_error = Qinsufficient_memory;
989 break;
35befdaa
KH		 990 default:
991 Vlast_code_conversion_error = intern ("Unknown error");
065e3595
KH		 992 }
993}
994
df7492f9
KH		 995#define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
996 do { \
997 charset_map_loaded = 0; \
998 c = DECODE_CHAR (charset, code); \
999 if (charset_map_loaded) \
1000 { \
8f924df7 1001 const unsigned char *orig = coding->source; \
df7492f9
KH		 1002 EMACS_INT offset; \
1003 \
1004 coding_set_source (coding); \
1005 offset = coding->source - orig; \
1006 src += offset; \
1007 src_base += offset; \
1008 src_end += offset; \
1009 } \
aa72b389
KH		 1010 } while (0)
1011
1012
119852e7
KH		 1013/* If there are at least BYTES length of room at dst, allocate memory
1014 for coding->destination and update dst and dst_end. We don't have
1015 to take care of coding->source which will be relocated. It is
1016 handled by calling coding_set_source in encode_coding. */
1017
df7492f9
KH		 1018#define ASSURE_DESTINATION(bytes) \
1019 do { \
1020 if (dst + (bytes) >= dst_end) \
1021 { \
1022 int more_bytes = charbuf_end - charbuf + (bytes); \
1023 \
1024 dst = alloc_destination (coding, more_bytes, dst); \
1025 dst_end = coding->destination + coding->dst_bytes; \
1026 } \
1027 } while (0)
aa72b389 1028
aa72b389 1029
db274c7a
KH		 1030/* Store multibyte form of the character C in P, and advance P to the
1031 end of the multibyte form. This is like CHAR_STRING_ADVANCE but it
1032 never calls MAYBE_UNIFY_CHAR. */
1033
1034#define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) \
1035 do { \
1036 if ((c) <= MAX_1_BYTE_CHAR) \
1037 *(p)++ = (c); \
1038 else if ((c) <= MAX_2_BYTE_CHAR) \
1039 *(p)++ = (0xC0 | ((c) >> 6)), \
1040 *(p)++ = (0x80 | ((c) & 0x3F)); \
1041 else if ((c) <= MAX_3_BYTE_CHAR) \
1042 *(p)++ = (0xE0 | ((c) >> 12)), \
1043 *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \
1044 *(p)++ = (0x80 | ((c) & 0x3F)); \
1045 else if ((c) <= MAX_4_BYTE_CHAR) \
1046 *(p)++ = (0xF0 | (c >> 18)), \
1047 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
1048 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
1049 *(p)++ = (0x80 | (c & 0x3F)); \
1050 else if ((c) <= MAX_5_BYTE_CHAR) \
1051 *(p)++ = 0xF8, \
1052 *(p)++ = (0x80 | ((c >> 18) & 0x0F)), \
1053 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
1054 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
1055 *(p)++ = (0x80 | (c & 0x3F)); \
1056 else \
1057 (p) += BYTE8_STRING ((c) - 0x3FFF80, p); \
1058 } while (0)
1059
1060
1061/* Return the character code of character whose multibyte form is at
1062 P, and advance P to the end of the multibyte form. This is like
1063 STRING_CHAR_ADVANCE, but it never calls MAYBE_UNIFY_CHAR. */
1064
1065#define STRING_CHAR_ADVANCE_NO_UNIFY(p) \
1066 (!((p)[0] & 0x80) \
1067 ? *(p)++ \
1068 : ! ((p)[0] & 0x20) \
1069 ? ((p) += 2, \
1070 ((((p)[-2] & 0x1F) << 6) \
1071 | ((p)[-1] & 0x3F) \
1072 | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0))) \
1073 : ! ((p)[0] & 0x10) \
1074 ? ((p) += 3, \
1075 ((((p)[-3] & 0x0F) << 12) \
1076 | (((p)[-2] & 0x3F) << 6) \
1077 | ((p)[-1] & 0x3F))) \
1078 : ! ((p)[0] & 0x08) \
1079 ? ((p) += 4, \
1080 ((((p)[-4] & 0xF) << 18) \
1081 | (((p)[-3] & 0x3F) << 12) \
1082 | (((p)[-2] & 0x3F) << 6) \
1083 | ((p)[-1] & 0x3F))) \
1084 : ((p) += 5, \
1085 ((((p)[-4] & 0x3F) << 18) \
1086 | (((p)[-3] & 0x3F) << 12) \
1087 | (((p)[-2] & 0x3F) << 6) \
1088 | ((p)[-1] & 0x3F))))
1089
aa72b389 1090
df7492f9
KH		 1091static void
1092coding_set_source (coding)
aa72b389 1093 struct coding_system *coding;
aa72b389 1094{
df7492f9
KH		 1095 if (BUFFERP (coding->src_object))
1096 {
2cb26057 1097 struct buffer *buf = XBUFFER (coding->src_object);
aa72b389 1098
df7492f9 1099 if (coding->src_pos < 0)
2cb26057 1100 coding->source = BUF_GAP_END_ADDR (buf) + coding->src_pos_byte;
df7492f9 1101 else
2cb26057 1102 coding->source = BUF_BYTE_ADDRESS (buf, coding->src_pos_byte);
aa72b389 1103 }
df7492f9 1104 else if (STRINGP (coding->src_object))
aa72b389 1105 {
8f924df7 1106 coding->source = SDATA (coding->src_object) + coding->src_pos_byte;
aa72b389 1107 }
df7492f9
KH		 1108 else
1109 /* Otherwise, the source is C string and is never relocated
1110 automatically. Thus we don't have to update anything. */
1111 ;
1112}
aa72b389 1113
df7492f9
KH		 1114static void
1115coding_set_destination (coding)
1116 struct coding_system *coding;
1117{
1118 if (BUFFERP (coding->dst_object))
aa72b389 1119 {
df7492f9 1120 if (coding->src_pos < 0)
aa72b389 1121 {
13818c30 1122 coding->destination = BEG_ADDR + coding->dst_pos_byte - BEG_BYTE;
28f67a95
KH		 1123 coding->dst_bytes = (GAP_END_ADDR
1124 - (coding->src_bytes - coding->consumed)
1125 - coding->destination);
aa72b389 1126 }
df7492f9 1127 else
28f67a95
KH		 1128 {
1129 /* We are sure that coding->dst_pos_byte is before the gap
1130 of the buffer. */
1131 coding->destination = (BUF_BEG_ADDR (XBUFFER (coding->dst_object))
13818c30 1132 + coding->dst_pos_byte - BEG_BYTE);
28f67a95
KH		 1133 coding->dst_bytes = (BUF_GAP_END_ADDR (XBUFFER (coding->dst_object))
1134 - coding->destination);
1135 }
df7492f9
KH		 1136 }
1137 else
1138 /* Otherwise, the destination is C string and is never relocated
1139 automatically. Thus we don't have to update anything. */
1140 ;
1141}
1142
1143
1144static void
1145coding_alloc_by_realloc (coding, bytes)
1146 struct coding_system *coding;
1147 EMACS_INT bytes;
1148{
1149 coding->destination = (unsigned char *) xrealloc (coding->destination,
1150 coding->dst_bytes + bytes);
1151 coding->dst_bytes += bytes;
1152}
1153
1154static void
db274c7a 1155coding_alloc_by_making_gap (coding, gap_head_used, bytes)
df7492f9 1156 struct coding_system *coding;
db274c7a 1157 EMACS_INT gap_head_used, bytes;
df7492f9 1158{
db274c7a 1159 if (EQ (coding->src_object, coding->dst_object))
df7492f9 1160 {
db274c7a
KH		 1161 /* The gap may contain the produced data at the head and not-yet
1162 consumed data at the tail. To preserve those data, we at
1163 first make the gap size to zero, then increase the gap
1164 size. */
1165 EMACS_INT add = GAP_SIZE;
1166
1167 GPT += gap_head_used, GPT_BYTE += gap_head_used;
1168 GAP_SIZE = 0; ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
df7492f9
KH		 1169 make_gap (bytes);
1170 GAP_SIZE += add; ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
db274c7a 1171 GPT -= gap_head_used, GPT_BYTE -= gap_head_used;
df7492f9 1172 }
730fff51 1173 else
df7492f9 1174 {
2c78b7e1
KH		 1175 Lisp_Object this_buffer;
1176
1177 this_buffer = Fcurrent_buffer ();
df7492f9
KH		 1178 set_buffer_internal (XBUFFER (coding->dst_object));
1179 make_gap (bytes);
1180 set_buffer_internal (XBUFFER (this_buffer));
aa72b389 1181 }
df7492f9 1182}
8f924df7 1183
df7492f9
KH		 1184
1185static unsigned char *
1186alloc_destination (coding, nbytes, dst)
1187 struct coding_system *coding;
3e139625 1188 EMACS_INT nbytes;
df7492f9
KH		 1189 unsigned char *dst;
1190{
1191 EMACS_INT offset = dst - coding->destination;
1192
1193 if (BUFFERP (coding->dst_object))
db274c7a
KH		 1194 {
1195 struct buffer *buf = XBUFFER (coding->dst_object);
1196
1197 coding_alloc_by_making_gap (coding, dst - BUF_GPT_ADDR (buf), nbytes);
1198 }
aa72b389 1199 else
df7492f9 1200 coding_alloc_by_realloc (coding, nbytes);
065e3595 1201 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 1202 coding_set_destination (coding);
1203 dst = coding->destination + offset;
1204 return dst;
1205}
aa72b389 1206
ff0dacd7
KH		 1207/** Macros for annotations. */
1208
1209/* Maximum length of annotation data (sum of annotations for
1210 composition and charset). */
69a80ea3 1211#define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
ff0dacd7
KH		 1212
1213/* An annotation data is stored in the array coding->charbuf in this
1214 format:
69a80ea3 1215 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
ff0dacd7
KH		 1216 LENGTH is the number of elements in the annotation.
1217 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
69a80ea3 1218 NCHARS is the number of characters in the text annotated.
ff0dacd7
KH		 1219
1220 The format of the following elements depend on ANNOTATION_MASK.
1221
1222 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1223 follows:
1224 ... METHOD [ COMPOSITION-COMPONENTS ... ]
1225 METHOD is one of enum composition_method.
1226 Optionnal COMPOSITION-COMPONENTS are characters and composition
1227 rules.
1228
1229 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1230 follows. */
1231
69a80ea3 1232#define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
ff0dacd7
KH		 1233 do { \
1234 *(buf)++ = -(len); \
1235 *(buf)++ = (mask); \
69a80ea3 1236 *(buf)++ = (nchars); \
ff0dacd7
KH		 1237 coding->annotated = 1; \
1238 } while (0);
1239
69a80ea3
KH		 1240#define ADD_COMPOSITION_DATA(buf, nchars, method) \
1241 do { \
1242 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1243 *buf++ = method; \
ff0dacd7
KH		 1244 } while (0)
1245
1246
69a80ea3
KH		 1247#define ADD_CHARSET_DATA(buf, nchars, id) \
1248 do { \
1249 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1250 *buf++ = id; \
ff0dacd7
KH		 1251 } while (0)
1252
df7492f9
KH		 1253\f
1254/*** 2. Emacs' internal format (emacs-utf-8) ***/
1255
1256
1257
1258\f
1259/*** 3. UTF-8 ***/
1260
1261/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
ff0dacd7
KH		 1262 Check if a text is encoded in UTF-8. If it is, return 1, else
1263 return 0. */
df7492f9
KH		 1264
1265#define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1266#define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1267#define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1268#define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1269#define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1270#define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1271
a470d443
KH		 1272#define UTF_BOM 0xFEFF
1273#define UTF_8_BOM_1 0xEF
1274#define UTF_8_BOM_2 0xBB
1275#define UTF_8_BOM_3 0xBF
1276
df7492f9 1277static int
ff0dacd7 1278detect_coding_utf_8 (coding, detect_info)
df7492f9 1279 struct coding_system *coding;
ff0dacd7 1280 struct coding_detection_info *detect_info;
df7492f9 1281{
065e3595 1282 const unsigned char *src = coding->source, *src_base;
8f924df7 1283 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 1284 int multibytep = coding->src_multibyte;
1285 int consumed_chars = 0;
a470d443 1286 int bom_found = 0;
df7492f9
KH		 1287 int found = 0;
1288
ff0dacd7 1289 detect_info->checked |= CATEGORY_MASK_UTF_8;
df7492f9
KH		 1290 /* A coding system of this category is always ASCII compatible. */
1291 src += coding->head_ascii;
1292
1293 while (1)
aa72b389 1294 {
df7492f9 1295 int c, c1, c2, c3, c4;
aa72b389 1296
065e3595 1297 src_base = src;
df7492f9 1298 ONE_MORE_BYTE (c);
065e3595 1299 if (c < 0 || UTF_8_1_OCTET_P (c))
df7492f9
KH		 1300 continue;
1301 ONE_MORE_BYTE (c1);
065e3595 1302 if (c1 < 0 || ! UTF_8_EXTRA_OCTET_P (c1))
df7492f9
KH		 1303 break;
1304 if (UTF_8_2_OCTET_LEADING_P (c))
aa72b389 1305 {
a470d443 1306 found = 1;
df7492f9 1307 continue;
aa72b389 1308 }
df7492f9 1309 ONE_MORE_BYTE (c2);
065e3595 1310 if (c2 < 0 || ! UTF_8_EXTRA_OCTET_P (c2))
df7492f9
KH		 1311 break;
1312 if (UTF_8_3_OCTET_LEADING_P (c))
aa72b389 1313 {
a470d443
KH		 1314 found = 1;
1315 if (src_base == coding->source
1316 && c == UTF_8_BOM_1 && c1 == UTF_8_BOM_2 && c2 == UTF_8_BOM_3)
1317 bom_found = 1;
df7492f9 1318 continue;
aa72b389 1319 }
df7492f9 1320 ONE_MORE_BYTE (c3);
065e3595 1321 if (c3 < 0 || ! UTF_8_EXTRA_OCTET_P (c3))
df7492f9
KH		 1322 break;
1323 if (UTF_8_4_OCTET_LEADING_P (c))
aa72b389 1324 {
a470d443 1325 found = 1;
df7492f9
KH		 1326 continue;
1327 }
1328 ONE_MORE_BYTE (c4);
065e3595 1329 if (c4 < 0 || ! UTF_8_EXTRA_OCTET_P (c4))
df7492f9
KH		 1330 break;
1331 if (UTF_8_5_OCTET_LEADING_P (c))
1332 {
a470d443 1333 found = 1;
df7492f9
KH		 1334 continue;
1335 }
1336 break;
aa72b389 1337 }
ff0dacd7 1338 detect_info->rejected |= CATEGORY_MASK_UTF_8;
df7492f9 1339 return 0;
aa72b389 1340
df7492f9 1341 no_more_source:
065e3595 1342 if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
aa72b389 1343 {
ff0dacd7 1344 detect_info->rejected |= CATEGORY_MASK_UTF_8;
89528eb3 1345 return 0;
aa72b389 1346 }
a470d443
KH		 1347 if (bom_found)
1348 {
1349 /* The first character 0xFFFE doesn't necessarily mean a BOM. */
1350 detect_info->found |= CATEGORY_MASK_UTF_8_SIG | CATEGORY_MASK_UTF_8_NOSIG;
1351 }
1352 else
1353 {
1354 detect_info->rejected |= CATEGORY_MASK_UTF_8_SIG;
0e17387a
KH		 1355 if (found)
1356 detect_info->found |= CATEGORY_MASK_UTF_8_NOSIG;
a470d443 1357 }
ff0dacd7 1358 return 1;
aa72b389
KH		 1359}
1360
4ed46869 1361
b73bfc1c 1362static void
df7492f9 1363decode_coding_utf_8 (coding)
b73bfc1c 1364 struct coding_system *coding;
b73bfc1c 1365{
8f924df7
KH		 1366 const unsigned char *src = coding->source + coding->consumed;
1367 const unsigned char *src_end = coding->source + coding->src_bytes;
1368 const unsigned char *src_base;
69a80ea3
KH		 1369 int *charbuf = coding->charbuf + coding->charbuf_used;
1370 int *charbuf_end = coding->charbuf + coding->charbuf_size;
453b38f0 1371 int consumed_chars = 0, consumed_chars_base = 0;
df7492f9 1372 int multibytep = coding->src_multibyte;
a470d443 1373 enum utf_bom_type bom = CODING_UTF_8_BOM (coding);
24a73b0a 1374 Lisp_Object attr, charset_list;
119852e7
KH		 1375 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
1376 int byte_after_cr = -1;
4ed46869 1377
24a73b0a 1378 CODING_GET_INFO (coding, attr, charset_list);
df7492f9 1379
a470d443
KH		 1380 if (bom != utf_without_bom)
1381 {
1382 int c1, c2, c3;
1383
1384 src_base = src;
1385 ONE_MORE_BYTE (c1);
1386 if (! UTF_8_3_OCTET_LEADING_P (c1))
1387 src = src_base;
1388 else
1389 {
159bd5a2 1390 ONE_MORE_BYTE (c2);
a470d443
KH		 1391 if (! UTF_8_EXTRA_OCTET_P (c2))
1392 src = src_base;
1393 else
1394 {
159bd5a2 1395 ONE_MORE_BYTE (c3);
a470d443
KH		 1396 if (! UTF_8_EXTRA_OCTET_P (c3))
1397 src = src_base;
1398 else
1399 {
1400 if ((c1 != UTF_8_BOM_1)
1401 || (c2 != UTF_8_BOM_2) || (c3 != UTF_8_BOM_3))
1402 src = src_base;
1403 else
1404 CODING_UTF_8_BOM (coding) = utf_without_bom;
1405 }
1406 }
1407 }
1408 }
1409 CODING_UTF_8_BOM (coding) = utf_without_bom;
1410
1411
1412
df7492f9 1413 while (1)
b73bfc1c 1414 {
df7492f9 1415 int c, c1, c2, c3, c4, c5;
ec6d2bb8 1416
df7492f9
KH		 1417 src_base = src;
1418 consumed_chars_base = consumed_chars;
4af310db 1419
df7492f9 1420 if (charbuf >= charbuf_end)
b71f6f73
KH		 1421 {
1422 if (byte_after_cr >= 0)
1423 src_base--;
1424 break;
1425 }
df7492f9 1426
119852e7
KH		 1427 if (byte_after_cr >= 0)
1428 c1 = byte_after_cr, byte_after_cr = -1;
1429 else
1430 ONE_MORE_BYTE (c1);
065e3595
KH		 1431 if (c1 < 0)
1432 {
1433 c = - c1;
1434 }
1435 else if (UTF_8_1_OCTET_P(c1))
df7492f9 1436 {
119852e7
KH		 1437 if (eol_crlf && c1 == '\r')
1438 ONE_MORE_BYTE (byte_after_cr);
df7492f9 1439 c = c1;
4af310db 1440 }
df7492f9 1441 else
4af310db 1442 {
df7492f9 1443 ONE_MORE_BYTE (c2);
065e3595 1444 if (c2 < 0 || ! UTF_8_EXTRA_OCTET_P (c2))
df7492f9
KH		 1445 goto invalid_code;
1446 if (UTF_8_2_OCTET_LEADING_P (c1))
4af310db 1447 {
b0edb2c5
DL		 1448 c = ((c1 & 0x1F) << 6) | (c2 & 0x3F);
1449 /* Reject overlong sequences here and below. Encoders
1450 producing them are incorrect, they can be misleading,
1451 and they mess up read/write invariance. */
1452 if (c < 128)
1453 goto invalid_code;
4af310db 1454 }
df7492f9 1455 else
aa72b389 1456 {
df7492f9 1457 ONE_MORE_BYTE (c3);
065e3595 1458 if (c3 < 0 || ! UTF_8_EXTRA_OCTET_P (c3))
df7492f9
KH		 1459 goto invalid_code;
1460 if (UTF_8_3_OCTET_LEADING_P (c1))
b0edb2c5
DL		 1461 {
1462 c = (((c1 & 0xF) << 12)
1463 | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
72fe1301
DL		 1464 if (c < 0x800
1465 || (c >= 0xd800 && c < 0xe000)) /* surrogates (invalid) */
b0edb2c5
DL		 1466 goto invalid_code;
1467 }
df7492f9
KH		 1468 else
1469 {
1470 ONE_MORE_BYTE (c4);
065e3595 1471 if (c4 < 0 || ! UTF_8_EXTRA_OCTET_P (c4))
df7492f9
KH		 1472 goto invalid_code;
1473 if (UTF_8_4_OCTET_LEADING_P (c1))
b0edb2c5 1474 {
df7492f9
KH		 1475 c = (((c1 & 0x7) << 18) | ((c2 & 0x3F) << 12)
1476 | ((c3 & 0x3F) << 6) | (c4 & 0x3F));
b0edb2c5
DL		 1477 if (c < 0x10000)
1478 goto invalid_code;
1479 }
df7492f9
KH		 1480 else
1481 {
1482 ONE_MORE_BYTE (c5);
065e3595 1483 if (c5 < 0 || ! UTF_8_EXTRA_OCTET_P (c5))
df7492f9
KH		 1484 goto invalid_code;
1485 if (UTF_8_5_OCTET_LEADING_P (c1))
1486 {
1487 c = (((c1 & 0x3) << 24) | ((c2 & 0x3F) << 18)
1488 | ((c3 & 0x3F) << 12) | ((c4 & 0x3F) << 6)
1489 | (c5 & 0x3F));
b0edb2c5 1490 if ((c > MAX_CHAR) || (c < 0x200000))
df7492f9
KH		 1491 goto invalid_code;
1492 }
1493 else
1494 goto invalid_code;
1495 }
1496 }
aa72b389 1497 }
b73bfc1c 1498 }
df7492f9
KH		 1499
1500 *charbuf++ = c;
1501 continue;
1502
1503 invalid_code:
1504 src = src_base;
1505 consumed_chars = consumed_chars_base;
1506 ONE_MORE_BYTE (c);
1507 *charbuf++ = ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
1508 coding->errors++;
aa72b389
KH		 1509 }
1510
df7492f9
KH		 1511 no_more_source:
1512 coding->consumed_char += consumed_chars_base;
1513 coding->consumed = src_base - coding->source;
1514 coding->charbuf_used = charbuf - coding->charbuf;
1515}
1516
1517
1518static int
1519encode_coding_utf_8 (coding)
1520 struct coding_system *coding;
1521{
1522 int multibytep = coding->dst_multibyte;
1523 int *charbuf = coding->charbuf;
1524 int *charbuf_end = charbuf + coding->charbuf_used;
1525 unsigned char *dst = coding->destination + coding->produced;
1526 unsigned char *dst_end = coding->destination + coding->dst_bytes;
e19c3639 1527 int produced_chars = 0;
df7492f9
KH		 1528 int c;
1529
a470d443
KH		 1530 if (CODING_UTF_8_BOM (coding) == utf_with_bom)
1531 {
1532 ASSURE_DESTINATION (3);
1533 EMIT_THREE_BYTES (UTF_8_BOM_1, UTF_8_BOM_2, UTF_8_BOM_3);
1534 CODING_UTF_8_BOM (coding) = utf_without_bom;
1535 }
1536
df7492f9 1537 if (multibytep)
aa72b389 1538 {
df7492f9
KH		 1539 int safe_room = MAX_MULTIBYTE_LENGTH * 2;
1540
1541 while (charbuf < charbuf_end)
b73bfc1c 1542 {
df7492f9 1543 unsigned char str[MAX_MULTIBYTE_LENGTH], *p, *pend = str;
8f924df7 1544
df7492f9
KH		 1545 ASSURE_DESTINATION (safe_room);
1546 c = *charbuf++;
28f67a95
KH		 1547 if (CHAR_BYTE8_P (c))
1548 {
1549 c = CHAR_TO_BYTE8 (c);
1550 EMIT_ONE_BYTE (c);
1551 }
1552 else
1553 {
db274c7a 1554 CHAR_STRING_ADVANCE_NO_UNIFY (c, pend);
28f67a95
KH		 1555 for (p = str; p < pend; p++)
1556 EMIT_ONE_BYTE (*p);
1557 }
b73bfc1c 1558 }
aa72b389 1559 }
df7492f9
KH		 1560 else
1561 {
1562 int safe_room = MAX_MULTIBYTE_LENGTH;
1563
1564 while (charbuf < charbuf_end)
b73bfc1c 1565 {
df7492f9
KH		 1566 ASSURE_DESTINATION (safe_room);
1567 c = *charbuf++;
f03caae0
KH		 1568 if (CHAR_BYTE8_P (c))
1569 *dst++ = CHAR_TO_BYTE8 (c);
1570 else
db274c7a 1571 CHAR_STRING_ADVANCE_NO_UNIFY (c, dst);
df7492f9 1572 produced_chars++;
4ed46869
KH		 1573 }
1574 }
065e3595 1575 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 1576 coding->produced_char += produced_chars;
1577 coding->produced = dst - coding->destination;
1578 return 0;
4ed46869
KH		 1579}
1580
b73bfc1c 1581
df7492f9 1582/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
ff0dacd7
KH		 1583 Check if a text is encoded in one of UTF-16 based coding systems.
1584 If it is, return 1, else return 0. */
aa72b389 1585
df7492f9
KH		 1586#define UTF_16_HIGH_SURROGATE_P(val) \
1587 (((val) & 0xFC00) == 0xD800)
1588
1589#define UTF_16_LOW_SURROGATE_P(val) \
1590 (((val) & 0xFC00) == 0xDC00)
93dec019 1591
df7492f9
KH		 1592#define UTF_16_INVALID_P(val) \
1593 (((val) == 0xFFFE) \
1594 || ((val) == 0xFFFF) \
1595 || UTF_16_LOW_SURROGATE_P (val))
aa72b389 1596
aa72b389 1597
df7492f9 1598static int
ff0dacd7 1599detect_coding_utf_16 (coding, detect_info)
aa72b389 1600 struct coding_system *coding;
ff0dacd7 1601 struct coding_detection_info *detect_info;
aa72b389 1602{
8f924df7
KH		 1603 const unsigned char *src = coding->source, *src_base = src;
1604 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 1605 int multibytep = coding->src_multibyte;
1606 int consumed_chars = 0;
1607 int c1, c2;
aa72b389 1608
ff0dacd7 1609 detect_info->checked |= CATEGORY_MASK_UTF_16;
ff0dacd7 1610 if (coding->mode & CODING_MODE_LAST_BLOCK
24a73b0a 1611 && (coding->src_chars & 1))
ff0dacd7
KH		 1612 {
1613 detect_info->rejected |= CATEGORY_MASK_UTF_16;
1614 return 0;
1615 }
24a73b0a 1616
f56a4450 1617 TWO_MORE_BYTES (c1, c2);
df7492f9 1618 if ((c1 == 0xFF) && (c2 == 0xFE))
aa72b389 1619 {
b49a1807
KH		 1620 detect_info->found |= (CATEGORY_MASK_UTF_16_LE
1621 | CATEGORY_MASK_UTF_16_AUTO);
24a73b0a
KH		 1622 detect_info->rejected |= (CATEGORY_MASK_UTF_16_BE
1623 | CATEGORY_MASK_UTF_16_BE_NOSIG
1624 | CATEGORY_MASK_UTF_16_LE_NOSIG);
aa72b389 1625 }
df7492f9 1626 else if ((c1 == 0xFE) && (c2 == 0xFF))
ff0dacd7 1627 {
b49a1807
KH		 1628 detect_info->found |= (CATEGORY_MASK_UTF_16_BE
1629 | CATEGORY_MASK_UTF_16_AUTO);
24a73b0a
KH		 1630 detect_info->rejected |= (CATEGORY_MASK_UTF_16_LE
1631 | CATEGORY_MASK_UTF_16_BE_NOSIG
1632 | CATEGORY_MASK_UTF_16_LE_NOSIG);
1633 }
220eeac9 1634 else if (c2 < 0)
f56a4450
KH		 1635 {
1636 detect_info->rejected |= CATEGORY_MASK_UTF_16;
1637 return 0;
1638 }
2f3cbb32 1639 else
24a73b0a 1640 {
2f3cbb32
KH		 1641 /* We check the dispersion of Eth and Oth bytes where E is even and
1642 O is odd. If both are high, we assume binary data.*/
1643 unsigned char e[256], o[256];
1644 unsigned e_num = 1, o_num = 1;
1645
1646 memset (e, 0, 256);
1647 memset (o, 0, 256);
1648 e[c1] = 1;
1649 o[c2] = 1;
1650
24a73b0a
KH		 1651 detect_info->rejected
1652 |= (CATEGORY_MASK_UTF_16_BE | CATEGORY_MASK_UTF_16_LE);
2f3cbb32
KH		 1653
1654 while (1)
1655 {
f56a4450 1656 TWO_MORE_BYTES (c1, c2);
220eeac9 1657 if (c2 < 0)
f56a4450 1658 break;
2f3cbb32
KH		 1659 if (! e[c1])
1660 {
1661 e[c1] = 1;
1662 e_num++;
1663 if (e_num >= 128)
1664 break;
1665 }
1666 if (! o[c2])
1667 {
1668 o[c1] = 1;
1669 o_num++;
1670 if (o_num >= 128)
1671 break;
1672 }
1673 }
1674 detect_info->rejected |= CATEGORY_MASK_UTF_16;
1675 return 0;
ff0dacd7 1676 }
2f3cbb32 1677
df7492f9 1678 no_more_source:
ff0dacd7 1679 return 1;
df7492f9 1680}
aa72b389 1681
df7492f9
KH		 1682static void
1683decode_coding_utf_16 (coding)
1684 struct coding_system *coding;
1685{
8f924df7
KH		 1686 const unsigned char *src = coding->source + coding->consumed;
1687 const unsigned char *src_end = coding->source + coding->src_bytes;
1688 const unsigned char *src_base;
69a80ea3
KH		 1689 int *charbuf = coding->charbuf + coding->charbuf_used;
1690 int *charbuf_end = coding->charbuf + coding->charbuf_size;
3a8406e1 1691 int consumed_chars = 0, consumed_chars_base = 0;
df7492f9 1692 int multibytep = coding->src_multibyte;
a470d443 1693 enum utf_bom_type bom = CODING_UTF_16_BOM (coding);
df7492f9
KH		 1694 enum utf_16_endian_type endian = CODING_UTF_16_ENDIAN (coding);
1695 int surrogate = CODING_UTF_16_SURROGATE (coding);
24a73b0a 1696 Lisp_Object attr, charset_list;
119852e7
KH		 1697 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
1698 int byte_after_cr1 = -1, byte_after_cr2 = -1;
df7492f9 1699
24a73b0a 1700 CODING_GET_INFO (coding, attr, charset_list);
df7492f9 1701
a470d443 1702 if (bom == utf_with_bom)
aa72b389 1703 {
df7492f9 1704 int c, c1, c2;
4af310db 1705
aa72b389 1706 src_base = src;
df7492f9
KH		 1707 ONE_MORE_BYTE (c1);
1708 ONE_MORE_BYTE (c2);
e19c3639 1709 c = (c1 << 8) | c2;
aa72b389 1710
b49a1807
KH		 1711 if (endian == utf_16_big_endian
1712 ? c != 0xFEFF : c != 0xFFFE)
aa72b389 1713 {
b49a1807
KH		 1714 /* The first two bytes are not BOM. Treat them as bytes
1715 for a normal character. */
1716 src = src_base;
1717 coding->errors++;
aa72b389 1718 }
a470d443 1719 CODING_UTF_16_BOM (coding) = utf_without_bom;
b49a1807 1720 }
a470d443 1721 else if (bom == utf_detect_bom)
b49a1807
KH		 1722 {
1723 /* We have already tried to detect BOM and failed in
1724 detect_coding. */
a470d443 1725 CODING_UTF_16_BOM (coding) = utf_without_bom;
df7492f9 1726 }
aa72b389 1727
df7492f9
KH		 1728 while (1)
1729 {
1730 int c, c1, c2;
1731
1732 src_base = src;
1733 consumed_chars_base = consumed_chars;
1734
1735 if (charbuf + 2 >= charbuf_end)
b71f6f73
KH		 1736 {
1737 if (byte_after_cr1 >= 0)
1738 src_base -= 2;
1739 break;
1740 }
df7492f9 1741
119852e7
KH		 1742 if (byte_after_cr1 >= 0)
1743 c1 = byte_after_cr1, byte_after_cr1 = -1;
1744 else
1745 ONE_MORE_BYTE (c1);
065e3595
KH		 1746 if (c1 < 0)
1747 {
1748 *charbuf++ = -c1;
1749 continue;
1750 }
119852e7
KH		 1751 if (byte_after_cr2 >= 0)
1752 c2 = byte_after_cr2, byte_after_cr2 = -1;
1753 else
1754 ONE_MORE_BYTE (c2);
065e3595
KH		 1755 if (c2 < 0)
1756 {
1757 *charbuf++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
1758 *charbuf++ = -c2;
1759 continue;
1760 }
df7492f9 1761 c = (endian == utf_16_big_endian
e19c3639 1762 ? ((c1 << 8) | c2) : ((c2 << 8) | c1));
119852e7 1763
df7492f9 1764 if (surrogate)
fd3ae0b9 1765 {
df7492f9 1766 if (! UTF_16_LOW_SURROGATE_P (c))
fd3ae0b9 1767 {
df7492f9
KH		 1768 if (endian == utf_16_big_endian)
1769 c1 = surrogate >> 8, c2 = surrogate & 0xFF;
1770 else
1771 c1 = surrogate & 0xFF, c2 = surrogate >> 8;
1772 *charbuf++ = c1;
1773 *charbuf++ = c2;
1774 coding->errors++;
1775 if (UTF_16_HIGH_SURROGATE_P (c))
1776 CODING_UTF_16_SURROGATE (coding) = surrogate = c;
fd3ae0b9 1777 else
df7492f9 1778 *charbuf++ = c;
fd3ae0b9
KH		 1779 }
1780 else
df7492f9
KH		 1781 {
1782 c = ((surrogate - 0xD800) << 10) | (c - 0xDC00);
1783 CODING_UTF_16_SURROGATE (coding) = surrogate = 0;
29f7ffd0 1784 *charbuf++ = 0x10000 + c;
df7492f9 1785 }
fd3ae0b9 1786 }
aa72b389 1787 else
df7492f9
KH		 1788 {
1789 if (UTF_16_HIGH_SURROGATE_P (c))
1790 CODING_UTF_16_SURROGATE (coding) = surrogate = c;
1791 else
119852e7
KH		 1792 {
1793 if (eol_crlf && c == '\r')
1794 {
1795 ONE_MORE_BYTE (byte_after_cr1);
1796 ONE_MORE_BYTE (byte_after_cr2);
1797 }
1798 *charbuf++ = c;
1799 }
8f924df7 1800 }
aa72b389 1801 }
df7492f9
KH		 1802
1803 no_more_source:
1804 coding->consumed_char += consumed_chars_base;
1805 coding->consumed = src_base - coding->source;
1806 coding->charbuf_used = charbuf - coding->charbuf;
aa72b389 1807}
b73bfc1c 1808
df7492f9
KH		 1809static int
1810encode_coding_utf_16 (coding)
1811 struct coding_system *coding;
1812{
1813 int multibytep = coding->dst_multibyte;
1814 int *charbuf = coding->charbuf;
1815 int *charbuf_end = charbuf + coding->charbuf_used;
1816 unsigned char *dst = coding->destination + coding->produced;
1817 unsigned char *dst_end = coding->destination + coding->dst_bytes;
1818 int safe_room = 8;
a470d443 1819 enum utf_bom_type bom = CODING_UTF_16_BOM (coding);
df7492f9
KH		 1820 int big_endian = CODING_UTF_16_ENDIAN (coding) == utf_16_big_endian;
1821 int produced_chars = 0;
24a73b0a 1822 Lisp_Object attrs, charset_list;
df7492f9 1823 int c;
4ed46869 1824
24a73b0a 1825 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9 1826
a470d443 1827 if (bom != utf_without_bom)
df7492f9
KH		 1828 {
1829 ASSURE_DESTINATION (safe_room);
1830 if (big_endian)
df7492f9 1831 EMIT_TWO_BYTES (0xFE, 0xFF);
880cf180
KH		 1832 else
1833 EMIT_TWO_BYTES (0xFF, 0xFE);
a470d443 1834 CODING_UTF_16_BOM (coding) = utf_without_bom;
df7492f9
KH		 1835 }
1836
1837 while (charbuf < charbuf_end)
1838 {
1839 ASSURE_DESTINATION (safe_room);
1840 c = *charbuf++;
e19c3639
KH		 1841 if (c >= MAX_UNICODE_CHAR)
1842 c = coding->default_char;
df7492f9
KH		 1843
1844 if (c < 0x10000)
1845 {
1846 if (big_endian)
1847 EMIT_TWO_BYTES (c >> 8, c & 0xFF);
1848 else
1849 EMIT_TWO_BYTES (c & 0xFF, c >> 8);
1850 }
1851 else
1852 {
1853 int c1, c2;
1854
1855 c -= 0x10000;
1856 c1 = (c >> 10) + 0xD800;
1857 c2 = (c & 0x3FF) + 0xDC00;
1858 if (big_endian)
1859 EMIT_FOUR_BYTES (c1 >> 8, c1 & 0xFF, c2 >> 8, c2 & 0xFF);
1860 else
1861 EMIT_FOUR_BYTES (c1 & 0xFF, c1 >> 8, c2 & 0xFF, c2 >> 8);
1862 }
1863 }
065e3595 1864 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 1865 coding->produced = dst - coding->destination;
1866 coding->produced_char += produced_chars;
1867 return 0;
1868}
1869
1870\f
1871/*** 6. Old Emacs' internal format (emacs-mule) ***/
1872
1873/* Emacs' internal format for representation of multiple character
1874 sets is a kind of multi-byte encoding, i.e. characters are
1875 represented by variable-length sequences of one-byte codes.
1876
1877 ASCII characters and control characters (e.g. `tab', `newline') are
1878 represented by one-byte sequences which are their ASCII codes, in
1879 the range 0x00 through 0x7F.
1880
1881 8-bit characters of the range 0x80..0x9F are represented by
1882 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1883 code + 0x20).
1884
1885 8-bit characters of the range 0xA0..0xFF are represented by
1886 one-byte sequences which are their 8-bit code.
1887
1888 The other characters are represented by a sequence of `base
1889 leading-code', optional `extended leading-code', and one or two
1890 `position-code's. The length of the sequence is determined by the
1891 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1892 whereas extended leading-code and position-code take the range 0xA0
1893 through 0xFF. See `charset.h' for more details about leading-code
1894 and position-code.
1895
1896 --- CODE RANGE of Emacs' internal format ---
1897 character set range
1898 ------------- -----
1899 ascii 0x00..0x7F
1900 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1901 eight-bit-graphic 0xA0..0xBF
1902 ELSE 0x81..0x9D + [0xA0..0xFF]+
1903 ---------------------------------------------
1904
1905 As this is the internal character representation, the format is
1906 usually not used externally (i.e. in a file or in a data sent to a
1907 process). But, it is possible to have a text externally in this
1908 format (i.e. by encoding by the coding system `emacs-mule').
1909
1910 In that case, a sequence of one-byte codes has a slightly different
1911 form.
1912
1913 At first, all characters in eight-bit-control are represented by
1914 one-byte sequences which are their 8-bit code.
1915
1916 Next, character composition data are represented by the byte
1917 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1918 where,
1919 METHOD is 0xF0 plus one of composition method (enum
1920 composition_method),
1921
1922 BYTES is 0xA0 plus a byte length of this composition data,
1923
1924 CHARS is 0x20 plus a number of characters composed by this
1925 data,
1926
1927 COMPONENTs are characters of multibye form or composition
1928 rules encoded by two-byte of ASCII codes.
1929
1930 In addition, for backward compatibility, the following formats are
1931 also recognized as composition data on decoding.
1932
1933 0x80 MSEQ ...
1934 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1935
1936 Here,
1937 MSEQ is a multibyte form but in these special format:
1938 ASCII: 0xA0 ASCII_CODE+0x80,
1939 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1940 RULE is a one byte code of the range 0xA0..0xF0 that
1941 represents a composition rule.
1942 */
1943
1944char emacs_mule_bytes[256];
1945
df7492f9 1946int
ff0dacd7 1947emacs_mule_char (coding, src, nbytes, nchars, id)
df7492f9 1948 struct coding_system *coding;
065e3595 1949 const unsigned char *src;
ff0dacd7 1950 int *nbytes, *nchars, *id;
df7492f9 1951{
8f924df7
KH		 1952 const unsigned char *src_end = coding->source + coding->src_bytes;
1953 const unsigned char *src_base = src;
df7492f9 1954 int multibytep = coding->src_multibyte;
df7492f9
KH		 1955 struct charset *charset;
1956 unsigned code;
1957 int c;
1958 int consumed_chars = 0;
1959
1960 ONE_MORE_BYTE (c);
065e3595 1961 if (c < 0)
df7492f9 1962 {
065e3595
KH		 1963 c = -c;
1964 charset = emacs_mule_charset[0];
1965 }
1966 else
1967 {
4d41e8b7
KH		 1968 if (c >= 0xA0)
1969 {
b3af4b28 1970 /* Old style component character of a composition. */
4d41e8b7
KH		 1971 if (c == 0xA0)
1972 {
1973 ONE_MORE_BYTE (c);
1974 c -= 0x80;
1975 }
1976 else
1977 c -= 0x20;
1978 }
1979
065e3595 1980 switch (emacs_mule_bytes[c])
b73bfc1c 1981 {
065e3595 1982 case 2:
df7492f9
KH		 1983 if (! (charset = emacs_mule_charset[c]))
1984 goto invalid_code;
1985 ONE_MORE_BYTE (c);
9ffd559c 1986 if (c < 0xA0)
065e3595 1987 goto invalid_code;
df7492f9 1988 code = c & 0x7F;
065e3595
KH		 1989 break;
1990
1991 case 3:
1992 if (c == EMACS_MULE_LEADING_CODE_PRIVATE_11
1993 || c == EMACS_MULE_LEADING_CODE_PRIVATE_12)
1994 {
1995 ONE_MORE_BYTE (c);
9ffd559c 1996 if (c < 0xA0 || ! (charset = emacs_mule_charset[c]))
065e3595
KH		 1997 goto invalid_code;
1998 ONE_MORE_BYTE (c);
9ffd559c 1999 if (c < 0xA0)
065e3595
KH		 2000 goto invalid_code;
2001 code = c & 0x7F;
2002 }
2003 else
2004 {
2005 if (! (charset = emacs_mule_charset[c]))
2006 goto invalid_code;
2007 ONE_MORE_BYTE (c);
9ffd559c 2008 if (c < 0xA0)
065e3595
KH		 2009 goto invalid_code;
2010 code = (c & 0x7F) << 8;
2011 ONE_MORE_BYTE (c);
9ffd559c 2012 if (c < 0xA0)
065e3595
KH		 2013 goto invalid_code;
2014 code |= c & 0x7F;
2015 }
2016 break;
2017
2018 case 4:
2019 ONE_MORE_BYTE (c);
2020 if (c < 0 || ! (charset = emacs_mule_charset[c]))
df7492f9
KH		 2021 goto invalid_code;
2022 ONE_MORE_BYTE (c);
9ffd559c 2023 if (c < 0xA0)
065e3595 2024 goto invalid_code;
781d7a48 2025 code = (c & 0x7F) << 8;
df7492f9 2026 ONE_MORE_BYTE (c);
9ffd559c 2027 if (c < 0xA0)
065e3595 2028 goto invalid_code;
df7492f9 2029 code |= c & 0x7F;
065e3595 2030 break;
df7492f9 2031
065e3595
KH		 2032 case 1:
2033 code = c;
2034 charset = CHARSET_FROM_ID (ASCII_BYTE_P (code)
2035 ? charset_ascii : charset_eight_bit);
2036 break;
df7492f9 2037
065e3595
KH		 2038 default:
2039 abort ();
2040 }
2041 c = DECODE_CHAR (charset, code);
2042 if (c < 0)
2043 goto invalid_code;
df7492f9 2044 }
df7492f9
KH		 2045 *nbytes = src - src_base;
2046 *nchars = consumed_chars;
ff0dacd7
KH		 2047 if (id)
2048 *id = charset->id;
df7492f9
KH		 2049 return c;
2050
2051 no_more_source:
2052 return -2;
2053
2054 invalid_code:
2055 return -1;
2056}
2057
2058
2059/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
ff0dacd7
KH		 2060 Check if a text is encoded in `emacs-mule'. If it is, return 1,
2061 else return 0. */
df7492f9
KH		 2062
2063static int
ff0dacd7 2064detect_coding_emacs_mule (coding, detect_info)
df7492f9 2065 struct coding_system *coding;
ff0dacd7 2066 struct coding_detection_info *detect_info;
df7492f9 2067{
065e3595 2068 const unsigned char *src = coding->source, *src_base;
8f924df7 2069 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 2070 int multibytep = coding->src_multibyte;
2071 int consumed_chars = 0;
2072 int c;
2073 int found = 0;
2074
ff0dacd7 2075 detect_info->checked |= CATEGORY_MASK_EMACS_MULE;
df7492f9
KH		 2076 /* A coding system of this category is always ASCII compatible. */
2077 src += coding->head_ascii;
2078
2079 while (1)
2080 {
065e3595 2081 src_base = src;
df7492f9 2082 ONE_MORE_BYTE (c);
065e3595
KH		 2083 if (c < 0)
2084 continue;
df7492f9
KH		 2085 if (c == 0x80)
2086 {
2087 /* Perhaps the start of composite character. We simple skip
2088 it because analyzing it is too heavy for detecting. But,
2089 at least, we check that the composite character
3ed051d4 2090 constitutes of more than 4 bytes. */
8f924df7 2091 const unsigned char *src_base;
df7492f9
KH		 2092
2093 repeat:
2094 src_base = src;
2095 do
2096 {
2097 ONE_MORE_BYTE (c);
2098 }
2099 while (c >= 0xA0);
2100
2101 if (src - src_base <= 4)
2102 break;
ff0dacd7 2103 found = CATEGORY_MASK_EMACS_MULE;
df7492f9
KH		 2104 if (c == 0x80)
2105 goto repeat;
b73bfc1c 2106 }
df7492f9
KH		 2107
2108 if (c < 0x80)
b73bfc1c 2109 {
df7492f9
KH		 2110 if (c < 0x20
2111 && (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO))
2112 break;
2113 }
2114 else
2115 {
0e219d54 2116 int more_bytes = emacs_mule_bytes[*src_base] - 1;
df7492f9 2117
0e219d54 2118 while (more_bytes > 0)
df7492f9
KH		 2119 {
2120 ONE_MORE_BYTE (c);
0e219d54
KH		 2121 if (c < 0xA0)
2122 {
2123 src--; /* Unread the last byte. */
2124 break;
2125 }
2126 more_bytes--;
df7492f9 2127 }
0e219d54 2128 if (more_bytes != 0)
df7492f9 2129 break;
ff0dacd7 2130 found = CATEGORY_MASK_EMACS_MULE;
4ed46869
KH		 2131 }
2132 }
ff0dacd7 2133 detect_info->rejected |= CATEGORY_MASK_EMACS_MULE;
df7492f9
KH		 2134 return 0;
2135
2136 no_more_source:
065e3595 2137 if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
89528eb3 2138 {
ff0dacd7 2139 detect_info->rejected |= CATEGORY_MASK_EMACS_MULE;
89528eb3
KH		 2140 return 0;
2141 }
ff0dacd7
KH		 2142 detect_info->found |= found;
2143 return 1;
4ed46869
KH		 2144}
2145
b73bfc1c 2146
df7492f9
KH		 2147/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2148
2149/* Decode a character represented as a component of composition
2150 sequence of Emacs 20/21 style at SRC. Set C to that character and
2151 update SRC to the head of next character (or an encoded composition
2152 rule). If SRC doesn't points a composition component, set C to -1.
2153 If SRC points an invalid byte sequence, global exit by a return
2154 value 0. */
2155
2156#define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
f937a7db 2157 do \
df7492f9
KH		 2158 { \
2159 int c; \
2160 int nbytes, nchars; \
2161 \
2162 if (src == src_end) \
2163 break; \
ff0dacd7 2164 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
df7492f9
KH		 2165 if (c < 0) \
2166 { \
2167 if (c == -2) \
2168 break; \
2169 goto invalid_code; \
2170 } \
2171 *buf++ = c; \
2172 src += nbytes; \
2173 consumed_chars += nchars; \
2174 } \
f937a7db 2175 while (0)
df7492f9
KH		 2176
2177
2178/* Decode a composition rule represented as a component of composition
781d7a48
KH		 2179 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
2180 and increment BUF. If SRC points an invalid byte sequence, set C
2181 to -1. */
df7492f9 2182
781d7a48 2183#define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
df7492f9
KH		 2184 do { \
2185 int c, gref, nref; \
2186 \
781d7a48 2187 if (src >= src_end) \
df7492f9
KH		 2188 goto invalid_code; \
2189 ONE_MORE_BYTE_NO_CHECK (c); \
4d41e8b7 2190 c -= 0xA0; \
df7492f9
KH		 2191 if (c < 0 || c >= 81) \
2192 goto invalid_code; \
2193 \
2194 gref = c / 9, nref = c % 9; \
2195 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
2196 } while (0)
2197
2198
781d7a48
KH		 2199/* Decode a composition rule represented as a component of composition
2200 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
2201 and increment BUF. If SRC points an invalid byte sequence, set C
2202 to -1. */
2203
2204#define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
2205 do { \
2206 int gref, nref; \
2207 \
2208 if (src + 1>= src_end) \
2209 goto invalid_code; \
2210 ONE_MORE_BYTE_NO_CHECK (gref); \
2211 gref -= 0x20; \
2212 ONE_MORE_BYTE_NO_CHECK (nref); \
2213 nref -= 0x20; \
2214 if (gref < 0 || gref >= 81 \
2215 || nref < 0 || nref >= 81) \
2216 goto invalid_code; \
2217 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
2218 } while (0)
2219
2220
df7492f9 2221#define DECODE_EMACS_MULE_21_COMPOSITION(c) \
aa72b389 2222 do { \
df7492f9 2223 /* Emacs 21 style format. The first three bytes at SRC are \
781d7a48 2224 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
df7492f9
KH		 2225 the byte length of this composition information, CHARS is the \
2226 number of characters composed by this composition. */ \
781d7a48
KH		 2227 enum composition_method method = c - 0xF2; \
2228 int *charbuf_base = charbuf; \
df7492f9
KH		 2229 int consumed_chars_limit; \
2230 int nbytes, nchars; \
2231 \
2232 ONE_MORE_BYTE (c); \
065e3595
KH		 2233 if (c < 0) \
2234 goto invalid_code; \
df7492f9
KH		 2235 nbytes = c - 0xA0; \
2236 if (nbytes < 3) \
2237 goto invalid_code; \
2238 ONE_MORE_BYTE (c); \
065e3595
KH		 2239 if (c < 0) \
2240 goto invalid_code; \
df7492f9 2241 nchars = c - 0xA0; \
69a80ea3 2242 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
df7492f9
KH		 2243 consumed_chars_limit = consumed_chars_base + nbytes; \
2244 if (method != COMPOSITION_RELATIVE) \
aa72b389 2245 { \
df7492f9
KH		 2246 int i = 0; \
2247 while (consumed_chars < consumed_chars_limit) \
aa72b389 2248 { \
df7492f9 2249 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
781d7a48 2250 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
df7492f9
KH		 2251 else \
2252 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
781d7a48 2253 i++; \
aa72b389 2254 } \
df7492f9
KH		 2255 if (consumed_chars < consumed_chars_limit) \
2256 goto invalid_code; \
781d7a48 2257 charbuf_base[0] -= i; \
aa72b389
KH		 2258 } \
2259 } while (0)
93dec019 2260
aa72b389 2261
d959f512
KH		 2262#define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
2263 do { \
2264 /* Emacs 20 style format for relative composition. */ \
2265 /* Store multibyte form of characters to be composed. */ \
2266 enum composition_method method = COMPOSITION_RELATIVE; \
2267 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2268 int *buf = components; \
2269 int i, j; \
2270 \
2271 src = src_base; \
2272 ONE_MORE_BYTE (c); /* skip 0x80 */ \
2273 for (i = 0; *src >= 0xA0 && i < MAX_COMPOSITION_COMPONENTS; i++) \
2274 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2275 if (i < 2) \
2276 goto invalid_code; \
2277 ADD_COMPOSITION_DATA (charbuf, i, method); \
2278 for (j = 0; j < i; j++) \
2279 *charbuf++ = components[j]; \
df7492f9
KH		 2280 } while (0)
2281
2282
2283#define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
2284 do { \
2285 /* Emacs 20 style format for rule-base composition. */ \
2286 /* Store multibyte form of characters to be composed. */ \
ff0dacd7 2287 enum composition_method method = COMPOSITION_WITH_RULE; \
4d41e8b7 2288 int *charbuf_base = charbuf; \
df7492f9
KH		 2289 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2290 int *buf = components; \
2291 int i, j; \
4d41e8b7 2292 \
df7492f9 2293 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
4d41e8b7 2294 for (i = 1; i < MAX_COMPOSITION_COMPONENTS; i++) \
df7492f9 2295 { \
4d41e8b7
KH		 2296 if (*src < 0xA0) \
2297 break; \
781d7a48 2298 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
df7492f9
KH		 2299 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2300 } \
4d41e8b7 2301 if (i <= 1 || (buf - components) % 2 == 0) \
df7492f9 2302 goto invalid_code; \
4d41e8b7 2303 if (charbuf + i + (i / 2) + 1 >= charbuf_end) \
df7492f9 2304 goto no_more_source; \
4d41e8b7
KH		 2305 ADD_COMPOSITION_DATA (charbuf, i, method); \
2306 i = i * 2 - 1; \
df7492f9
KH		 2307 for (j = 0; j < i; j++) \
2308 *charbuf++ = components[j]; \
4d41e8b7 2309 charbuf_base[0] -= i; \
df7492f9
KH		 2310 for (j = 0; j < i; j += 2) \
2311 *charbuf++ = components[j]; \
2312 } while (0)
2313
aa72b389
KH		 2314
2315static void
df7492f9 2316decode_coding_emacs_mule (coding)
aa72b389 2317 struct coding_system *coding;
aa72b389 2318{
8f924df7
KH		 2319 const unsigned char *src = coding->source + coding->consumed;
2320 const unsigned char *src_end = coding->source + coding->src_bytes;
2321 const unsigned char *src_base;
69a80ea3
KH		 2322 int *charbuf = coding->charbuf + coding->charbuf_used;
2323 int *charbuf_end
2324 = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
df7492f9 2325 int consumed_chars = 0, consumed_chars_base;
df7492f9 2326 int multibytep = coding->src_multibyte;
24a73b0a 2327 Lisp_Object attrs, charset_list;
ff0dacd7
KH		 2328 int char_offset = coding->produced_char;
2329 int last_offset = char_offset;
2330 int last_id = charset_ascii;
119852e7
KH		 2331 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
2332 int byte_after_cr = -1;
aa72b389 2333
24a73b0a 2334 CODING_GET_INFO (coding, attrs, charset_list);
aa72b389 2335
aa72b389
KH		 2336 while (1)
2337 {
df7492f9
KH		 2338 int c;
2339
aa72b389 2340 src_base = src;
df7492f9
KH		 2341 consumed_chars_base = consumed_chars;
2342
2343 if (charbuf >= charbuf_end)
b71f6f73
KH		 2344 {
2345 if (byte_after_cr >= 0)
2346 src_base--;
2347 break;
2348 }
aa72b389 2349
119852e7
KH		 2350 if (byte_after_cr >= 0)
2351 c = byte_after_cr, byte_after_cr = -1;
2352 else
2353 ONE_MORE_BYTE (c);
065e3595
KH		 2354 if (c < 0)
2355 {
2356 *charbuf++ = -c;
2357 char_offset++;
2358 }
2359 else if (c < 0x80)
aa72b389 2360 {
119852e7
KH		 2361 if (eol_crlf && c == '\r')
2362 ONE_MORE_BYTE (byte_after_cr);
df7492f9
KH		 2363 *charbuf++ = c;
2364 char_offset++;
aa72b389 2365 }
df7492f9
KH		 2366 else if (c == 0x80)
2367 {
df7492f9 2368 ONE_MORE_BYTE (c);
065e3595
KH		 2369 if (c < 0)
2370 goto invalid_code;
781d7a48
KH		 2371 if (c - 0xF2 >= COMPOSITION_RELATIVE
2372 && c - 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS)
df7492f9
KH		 2373 DECODE_EMACS_MULE_21_COMPOSITION (c);
2374 else if (c < 0xC0)
2375 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c);
2376 else if (c == 0xFF)
2377 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c);
2378 else
2379 goto invalid_code;
2380 }
2381 else if (c < 0xA0 && emacs_mule_bytes[c] > 1)
2382 {
2383 int nbytes, nchars;
ff0dacd7
KH		 2384 int id;
2385
781d7a48
KH		 2386 src = src_base;
2387 consumed_chars = consumed_chars_base;
ff0dacd7 2388 c = emacs_mule_char (coding, src, &nbytes, &nchars, &id);
df7492f9
KH		 2389 if (c < 0)
2390 {
2391 if (c == -2)
2392 break;
2393 goto invalid_code;
2394 }
ff0dacd7
KH		 2395 if (last_id != id)
2396 {
2397 if (last_id != charset_ascii)
69a80ea3 2398 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
ff0dacd7
KH		 2399 last_id = id;
2400 last_offset = char_offset;
2401 }
df7492f9 2402 *charbuf++ = c;
781d7a48
KH		 2403 src += nbytes;
2404 consumed_chars += nchars;
df7492f9
KH		 2405 char_offset++;
2406 }
4d41e8b7
KH		 2407 else
2408 goto invalid_code;
df7492f9
KH		 2409 continue;
2410
2411 invalid_code:
2412 src = src_base;
2413 consumed_chars = consumed_chars_base;
2414 ONE_MORE_BYTE (c);
2415 *charbuf++ = ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
ff0dacd7 2416 char_offset++;
df7492f9
KH		 2417 coding->errors++;
2418 }
2419
2420 no_more_source:
ff0dacd7 2421 if (last_id != charset_ascii)
69a80ea3 2422 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
df7492f9
KH		 2423 coding->consumed_char += consumed_chars_base;
2424 coding->consumed = src_base - coding->source;
2425 coding->charbuf_used = charbuf - coding->charbuf;
2426}
2427
2428
2429#define EMACS_MULE_LEADING_CODES(id, codes) \
2430 do { \
2431 if (id < 0xA0) \
2432 codes[0] = id, codes[1] = 0; \
2433 else if (id < 0xE0) \
2434 codes[0] = 0x9A, codes[1] = id; \
2435 else if (id < 0xF0) \
2436 codes[0] = 0x9B, codes[1] = id; \
2437 else if (id < 0xF5) \
2438 codes[0] = 0x9C, codes[1] = id; \
2439 else \
2440 codes[0] = 0x9D, codes[1] = id; \
2441 } while (0);
2442
aa72b389 2443
df7492f9
KH		 2444static int
2445encode_coding_emacs_mule (coding)
2446 struct coding_system *coding;
2447{
2448 int multibytep = coding->dst_multibyte;
2449 int *charbuf = coding->charbuf;
2450 int *charbuf_end = charbuf + coding->charbuf_used;
2451 unsigned char *dst = coding->destination + coding->produced;
2452 unsigned char *dst_end = coding->destination + coding->dst_bytes;
2453 int safe_room = 8;
df7492f9 2454 int produced_chars = 0;
24a73b0a 2455 Lisp_Object attrs, charset_list;
df7492f9 2456 int c;
ff0dacd7 2457 int preferred_charset_id = -1;
df7492f9 2458
24a73b0a 2459 CODING_GET_INFO (coding, attrs, charset_list);
eccb6815
KH		 2460 if (! EQ (charset_list, Vemacs_mule_charset_list))
2461 {
2462 CODING_ATTR_CHARSET_LIST (attrs)
2463 = charset_list = Vemacs_mule_charset_list;
2464 }
df7492f9
KH		 2465
2466 while (charbuf < charbuf_end)
2467 {
2468 ASSURE_DESTINATION (safe_room);
2469 c = *charbuf++;
ff0dacd7
KH		 2470
2471 if (c < 0)
2472 {
2473 /* Handle an annotation. */
2474 switch (*charbuf)
2475 {
2476 case CODING_ANNOTATE_COMPOSITION_MASK:
2477 /* Not yet implemented. */
2478 break;
2479 case CODING_ANNOTATE_CHARSET_MASK:
2480 preferred_charset_id = charbuf[3];
2481 if (preferred_charset_id >= 0
2482 && NILP (Fmemq (make_number (preferred_charset_id),
2483 charset_list)))
2484 preferred_charset_id = -1;
2485 break;
2486 default:
2487 abort ();
2488 }
2489 charbuf += -c - 1;
2490 continue;
2491 }
2492
df7492f9
KH		 2493 if (ASCII_CHAR_P (c))
2494 EMIT_ONE_ASCII_BYTE (c);
16eafb5d
KH		 2495 else if (CHAR_BYTE8_P (c))
2496 {
2497 c = CHAR_TO_BYTE8 (c);
2498 EMIT_ONE_BYTE (c);
2499 }
df7492f9 2500 else
aa72b389 2501 {
df7492f9
KH		 2502 struct charset *charset;
2503 unsigned code;
2504 int dimension;
2505 int emacs_mule_id;
2506 unsigned char leading_codes[2];
2507
ff0dacd7
KH		 2508 if (preferred_charset_id >= 0)
2509 {
2510 charset = CHARSET_FROM_ID (preferred_charset_id);
905ca9d2
KH		 2511 if (CHAR_CHARSET_P (c, charset))
2512 code = ENCODE_CHAR (charset, c);
2513 else
2514 charset = char_charset (c, charset_list, &code);
ff0dacd7
KH		 2515 }
2516 else
2517 charset = char_charset (c, charset_list, &code);
df7492f9
KH		 2518 if (! charset)
2519 {
2520 c = coding->default_char;
2521 if (ASCII_CHAR_P (c))
2522 {
2523 EMIT_ONE_ASCII_BYTE (c);
2524 continue;
2525 }
2526 charset = char_charset (c, charset_list, &code);
2527 }
2528 dimension = CHARSET_DIMENSION (charset);
2529 emacs_mule_id = CHARSET_EMACS_MULE_ID (charset);
2530 EMACS_MULE_LEADING_CODES (emacs_mule_id, leading_codes);
2531 EMIT_ONE_BYTE (leading_codes[0]);
2532 if (leading_codes[1])
2533 EMIT_ONE_BYTE (leading_codes[1]);
2534 if (dimension == 1)
1fa663f9 2535 EMIT_ONE_BYTE (code | 0x80);
aa72b389 2536 else
df7492f9 2537 {
1fa663f9 2538 code |= 0x8080;
df7492f9
KH		 2539 EMIT_ONE_BYTE (code >> 8);
2540 EMIT_ONE_BYTE (code & 0xFF);
2541 }
aa72b389 2542 }
aa72b389 2543 }
065e3595 2544 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 2545 coding->produced_char += produced_chars;
2546 coding->produced = dst - coding->destination;
2547 return 0;
aa72b389 2548}
b73bfc1c 2549
4ed46869 2550\f
df7492f9 2551/*** 7. ISO2022 handlers ***/
4ed46869
KH		 2552
2553/* The following note describes the coding system ISO2022 briefly.
39787efd 2554 Since the intention of this note is to help understand the
5a936b46 2555 functions in this file, some parts are NOT ACCURATE or are OVERLY
39787efd 2556 SIMPLIFIED. For thorough understanding, please refer to the
5a936b46 2557 original document of ISO2022. This is equivalent to the standard
cfb43547 2558 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
4ed46869
KH		 2559
2560 ISO2022 provides many mechanisms to encode several character sets
cfb43547 2561 in 7-bit and 8-bit environments. For 7-bit environments, all text
39787efd
KH		 2562 is encoded using bytes less than 128. This may make the encoded
2563 text a little bit longer, but the text passes more easily through
cfb43547 2564 several types of gateway, some of which strip off the MSB (Most
8ca3766a 2565 Significant Bit).
b73bfc1c 2566
cfb43547
DL		 2567 There are two kinds of character sets: control character sets and
2568 graphic character sets. The former contain control characters such
4ed46869 2569 as `newline' and `escape' to provide control functions (control
39787efd 2570 functions are also provided by escape sequences). The latter
cfb43547 2571 contain graphic characters such as 'A' and '-'. Emacs recognizes
4ed46869
KH		 2572 two control character sets and many graphic character sets.
2573
2574 Graphic character sets are classified into one of the following
39787efd
KH		 2575 four classes, according to the number of bytes (DIMENSION) and
2576 number of characters in one dimension (CHARS) of the set:
2577 - DIMENSION1_CHARS94
2578 - DIMENSION1_CHARS96
2579 - DIMENSION2_CHARS94
2580 - DIMENSION2_CHARS96
2581
2582 In addition, each character set is assigned an identification tag,
cfb43547 2583 unique for each set, called the "final character" (denoted as <F>
39787efd
KH		 2584 hereafter). The <F> of each character set is decided by ECMA(*)
2585 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2586 (0x30..0x3F are for private use only).
4ed46869
KH		 2587
2588 Note (*): ECMA = European Computer Manufacturers Association
2589
cfb43547 2590 Here are examples of graphic character sets [NAME(<F>)]:
4ed46869
KH		 2591 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2592 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2593 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2594 o DIMENSION2_CHARS96 -- none for the moment
2595
39787efd 2596 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
4ed46869
KH		 2597 C0 [0x00..0x1F] -- control character plane 0
2598 GL [0x20..0x7F] -- graphic character plane 0
2599 C1 [0x80..0x9F] -- control character plane 1
2600 GR [0xA0..0xFF] -- graphic character plane 1
2601
2602 A control character set is directly designated and invoked to C0 or
39787efd
KH		 2603 C1 by an escape sequence. The most common case is that:
2604 - ISO646's control character set is designated/invoked to C0, and
2605 - ISO6429's control character set is designated/invoked to C1,
2606 and usually these designations/invocations are omitted in encoded
2607 text. In a 7-bit environment, only C0 can be used, and a control
2608 character for C1 is encoded by an appropriate escape sequence to
2609 fit into the environment. All control characters for C1 are
2610 defined to have corresponding escape sequences.
4ed46869
KH		 2611
2612 A graphic character set is at first designated to one of four
2613 graphic registers (G0 through G3), then these graphic registers are
2614 invoked to GL or GR. These designations and invocations can be
2615 done independently. The most common case is that G0 is invoked to
39787efd
KH		 2616 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2617 these invocations and designations are omitted in encoded text.
2618 In a 7-bit environment, only GL can be used.
4ed46869 2619
39787efd
KH		 2620 When a graphic character set of CHARS94 is invoked to GL, codes
2621 0x20 and 0x7F of the GL area work as control characters SPACE and
2622 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2623 be used.
4ed46869
KH		 2624
2625 There are two ways of invocation: locking-shift and single-shift.
2626 With locking-shift, the invocation lasts until the next different
39787efd
KH		 2627 invocation, whereas with single-shift, the invocation affects the
2628 following character only and doesn't affect the locking-shift
2629 state. Invocations are done by the following control characters or
2630 escape sequences:
4ed46869
KH		 2631
2632 ----------------------------------------------------------------------
39787efd 2633 abbrev function cntrl escape seq description
4ed46869 2634 ----------------------------------------------------------------------
39787efd
KH		 2635 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2636 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2637 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2638 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2639 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2640 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2641 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2642 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2643 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
4ed46869 2644 ----------------------------------------------------------------------
39787efd
KH		 2645 (*) These are not used by any known coding system.
2646
2647 Control characters for these functions are defined by macros
2648 ISO_CODE_XXX in `coding.h'.
4ed46869 2649
39787efd 2650 Designations are done by the following escape sequences:
4ed46869
KH		 2651 ----------------------------------------------------------------------
2652 escape sequence description
2653 ----------------------------------------------------------------------
2654 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2655 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2656 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2657 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2658 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2659 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2660 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2661 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2662 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2663 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2664 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2665 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2666 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2667 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2668 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2669 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2670 ----------------------------------------------------------------------
2671
2672 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
39787efd 2673 of dimension 1, chars 94, and final character <F>, etc...
4ed46869
KH		 2674
2675 Note (*): Although these designations are not allowed in ISO2022,
2676 Emacs accepts them on decoding, and produces them on encoding
39787efd 2677 CHARS96 character sets in a coding system which is characterized as
4ed46869
KH		 2678 7-bit environment, non-locking-shift, and non-single-shift.
2679
2680 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
df7492f9 2681 '(' must be omitted. We refer to this as "short-form" hereafter.
4ed46869 2682
cfb43547 2683 Now you may notice that there are a lot of ways of encoding the
39787efd
KH		 2684 same multilingual text in ISO2022. Actually, there exist many
2685 coding systems such as Compound Text (used in X11's inter client
8ca3766a
DL		 2686 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2687 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
4ed46869
KH		 2688 localized platforms), and all of these are variants of ISO2022.
2689
2690 In addition to the above, Emacs handles two more kinds of escape
2691 sequences: ISO6429's direction specification and Emacs' private
2692 sequence for specifying character composition.
2693
39787efd 2694 ISO6429's direction specification takes the following form:
4ed46869
KH		 2695 o CSI ']' -- end of the current direction
2696 o CSI '0' ']' -- end of the current direction
2697 o CSI '1' ']' -- start of left-to-right text
2698 o CSI '2' ']' -- start of right-to-left text
2699 The control character CSI (0x9B: control sequence introducer) is
39787efd
KH		 2700 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2701
2702 Character composition specification takes the following form:
ec6d2bb8
KH		 2703 o ESC '0' -- start relative composition
2704 o ESC '1' -- end composition
2705 o ESC '2' -- start rule-base composition (*)
2706 o ESC '3' -- start relative composition with alternate chars (**)
2707 o ESC '4' -- start rule-base composition with alternate chars (**)
b73bfc1c 2708 Since these are not standard escape sequences of any ISO standard,
cfb43547 2709 the use of them with these meanings is restricted to Emacs only.
ec6d2bb8 2710
5a936b46
DL		 2711 (*) This form is used only in Emacs 20.7 and older versions,
2712 but newer versions can safely decode it.
cfb43547 2713 (**) This form is used only in Emacs 21.1 and newer versions,
5a936b46 2714 and older versions can't decode it.
ec6d2bb8 2715
cfb43547 2716 Here's a list of example usages of these composition escape
b73bfc1c 2717 sequences (categorized by `enum composition_method').
ec6d2bb8 2718
b73bfc1c 2719 COMPOSITION_RELATIVE:
ec6d2bb8 2720 ESC 0 CHAR [ CHAR ] ESC 1
8ca3766a 2721 COMPOSITION_WITH_RULE:
ec6d2bb8 2722 ESC 2 CHAR [ RULE CHAR ] ESC 1
b73bfc1c 2723 COMPOSITION_WITH_ALTCHARS:
ec6d2bb8 2724 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
b73bfc1c 2725 COMPOSITION_WITH_RULE_ALTCHARS:
ec6d2bb8 2726 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
4ed46869
KH		 2727
2728enum iso_code_class_type iso_code_class[256];
2729
df7492f9
KH		 2730#define SAFE_CHARSET_P(coding, id) \
2731 ((id) <= (coding)->max_charset_id \
2732 && (coding)->safe_charsets[id] >= 0)
2733
2734
2735#define SHIFT_OUT_OK(category) \
2736 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2737
2738static void
f0064e1f
DL		 2739setup_iso_safe_charsets (attrs)
2740 Lisp_Object attrs;
df7492f9
KH		 2741{
2742 Lisp_Object charset_list, safe_charsets;
2743 Lisp_Object request;
2744 Lisp_Object reg_usage;
2745 Lisp_Object tail;
2746 int reg94, reg96;
2747 int flags = XINT (AREF (attrs, coding_attr_iso_flags));
2748 int max_charset_id;
2749
2750 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
2751 if ((flags & CODING_ISO_FLAG_FULL_SUPPORT)
2752 && ! EQ (charset_list, Viso_2022_charset_list))
2753 {
2754 CODING_ATTR_CHARSET_LIST (attrs)
2755 = charset_list = Viso_2022_charset_list;
2756 ASET (attrs, coding_attr_safe_charsets, Qnil);
2757 }
2758
2759 if (STRINGP (AREF (attrs, coding_attr_safe_charsets)))
2760 return;
2761
2762 max_charset_id = 0;
2763 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
2764 {
2765 int id = XINT (XCAR (tail));
2766 if (max_charset_id < id)
2767 max_charset_id = id;
2768 }
d46c5b12 2769
df7492f9
KH		 2770 safe_charsets = Fmake_string (make_number (max_charset_id + 1),
2771 make_number (255));
2772 request = AREF (attrs, coding_attr_iso_request);
2773 reg_usage = AREF (attrs, coding_attr_iso_usage);
2774 reg94 = XINT (XCAR (reg_usage));
2775 reg96 = XINT (XCDR (reg_usage));
2776
2777 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
2778 {
2779 Lisp_Object id;
2780 Lisp_Object reg;
2781 struct charset *charset;
2782
2783 id = XCAR (tail);
2784 charset = CHARSET_FROM_ID (XINT (id));
bf16eb23 2785 reg = Fcdr (Fassq (id, request));
df7492f9 2786 if (! NILP (reg))
8f924df7 2787 SSET (safe_charsets, XINT (id), XINT (reg));
df7492f9
KH		 2788 else if (charset->iso_chars_96)
2789 {
2790 if (reg96 < 4)
8f924df7 2791 SSET (safe_charsets, XINT (id), reg96);
df7492f9
KH		 2792 }
2793 else
2794 {
2795 if (reg94 < 4)
8f924df7 2796 SSET (safe_charsets, XINT (id), reg94);
df7492f9
KH		 2797 }
2798 }
2799 ASET (attrs, coding_attr_safe_charsets, safe_charsets);
2800}
d46c5b12 2801
b6871cc7 2802
4ed46869 2803/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
ff0dacd7
KH		 2804 Check if a text is encoded in one of ISO-2022 based codig systems.
2805 If it is, return 1, else return 0. */
4ed46869 2806
0a28aafb 2807static int
ff0dacd7 2808detect_coding_iso_2022 (coding, detect_info)
df7492f9 2809 struct coding_system *coding;
ff0dacd7 2810 struct coding_detection_info *detect_info;
4ed46869 2811{
8f924df7
KH		 2812 const unsigned char *src = coding->source, *src_base = src;
2813 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9 2814 int multibytep = coding->src_multibyte;
ff0dacd7 2815 int single_shifting = 0;
df7492f9
KH		 2816 int id;
2817 int c, c1;
2818 int consumed_chars = 0;
2819 int i;
ff0dacd7
KH		 2820 int rejected = 0;
2821 int found = 0;
cee53ed4 2822 int composition_count = -1;
ff0dacd7
KH		 2823
2824 detect_info->checked |= CATEGORY_MASK_ISO;
df7492f9
KH		 2825
2826 for (i = coding_category_iso_7; i <= coding_category_iso_8_else; i++)
2827 {
2828 struct coding_system *this = &(coding_categories[i]);
2829 Lisp_Object attrs, val;
2830
c6b278e7
KH		 2831 if (this->id < 0)
2832 continue;
df7492f9
KH		 2833 attrs = CODING_ID_ATTRS (this->id);
2834 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2835 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs), Viso_2022_charset_list))
2836 setup_iso_safe_charsets (attrs);
2837 val = CODING_ATTR_SAFE_CHARSETS (attrs);
8f924df7
KH		 2838 this->max_charset_id = SCHARS (val) - 1;
2839 this->safe_charsets = (char *) SDATA (val);
df7492f9
KH		 2840 }
2841
2842 /* A coding system of this category is always ASCII compatible. */
2843 src += coding->head_ascii;
3f003981 2844
ff0dacd7 2845 while (rejected != CATEGORY_MASK_ISO)
4ed46869 2846 {
065e3595 2847 src_base = src;
df7492f9 2848 ONE_MORE_BYTE (c);
4ed46869
KH		 2849 switch (c)
2850 {
2851 case ISO_CODE_ESC:
74383408
KH		 2852 if (inhibit_iso_escape_detection)
2853 break;
f46869e4 2854 single_shifting = 0;
df7492f9 2855 ONE_MORE_BYTE (c);
d46c5b12 2856 if (c >= '(' && c <= '/')
4ed46869 2857 {
bf9cdd4e 2858 /* Designation sequence for a charset of dimension 1. */
df7492f9 2859 ONE_MORE_BYTE (c1);
d46c5b12 2860 if (c1 < ' ' || c1 >= 0x80
df7492f9 2861 || (id = iso_charset_table[0][c >= ','][c1]) < 0)
d46c5b12
KH		 2862 /* Invalid designation sequence. Just ignore. */
2863 break;
bf9cdd4e
KH		 2864 }
2865 else if (c == '$')
2866 {
2867 /* Designation sequence for a charset of dimension 2. */
df7492f9 2868 ONE_MORE_BYTE (c);
bf9cdd4e
KH		 2869 if (c >= '@' && c <= 'B')
2870 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
ff0dacd7 2871 id = iso_charset_table[1][0][c];
bf9cdd4e 2872 else if (c >= '(' && c <= '/')
bcf26d6a 2873 {
df7492f9 2874 ONE_MORE_BYTE (c1);
d46c5b12 2875 if (c1 < ' ' || c1 >= 0x80
df7492f9 2876 || (id = iso_charset_table[1][c >= ','][c1]) < 0)
d46c5b12
KH		 2877 /* Invalid designation sequence. Just ignore. */
2878 break;
bcf26d6a 2879 }
bf9cdd4e 2880 else
ff0dacd7 2881 /* Invalid designation sequence. Just ignore it. */
d46c5b12
KH		 2882 break;
2883 }
ae9ff118 2884 else if (c == 'N' || c == 'O')
d46c5b12 2885 {
ae9ff118 2886 /* ESC <Fe> for SS2 or SS3. */
ff0dacd7
KH		 2887 single_shifting = 1;
2888 rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_8BIT;
d46c5b12 2889 break;
4ed46869 2890 }
cee53ed4
KH		 2891 else if (c == '1')
2892 {
2893 /* End of composition. */
2894 if (composition_count < 0
2895 || composition_count > MAX_COMPOSITION_COMPONENTS)
2896 /* Invalid */
2897 break;
2898 composition_count = -1;
2899 found |= CATEGORY_MASK_ISO;
2900 }
ec6d2bb8
KH		 2901 else if (c >= '0' && c <= '4')
2902 {
2903 /* ESC <Fp> for start/end composition. */
cee53ed4 2904 composition_count = 0;
ec6d2bb8
KH		 2905 break;
2906 }
bf9cdd4e 2907 else
df7492f9 2908 {
ff0dacd7 2909 /* Invalid escape sequence. Just ignore it. */
df7492f9
KH		 2910 break;
2911 }
d46c5b12
KH		 2912
2913 /* We found a valid designation sequence for CHARSET. */
ff0dacd7 2914 rejected |= CATEGORY_MASK_ISO_8BIT;
df7492f9
KH		 2915 if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7],
2916 id))
ff0dacd7 2917 found |= CATEGORY_MASK_ISO_7;
d46c5b12 2918 else
ff0dacd7 2919 rejected |= CATEGORY_MASK_ISO_7;
df7492f9
KH		 2920 if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7_tight],
2921 id))
ff0dacd7 2922 found |= CATEGORY_MASK_ISO_7_TIGHT;
d46c5b12 2923 else
ff0dacd7 2924 rejected |= CATEGORY_MASK_ISO_7_TIGHT;
df7492f9
KH		 2925 if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_7_else],
2926 id))
ff0dacd7 2927 found |= CATEGORY_MASK_ISO_7_ELSE;
ae9ff118 2928 else
ff0dacd7 2929 rejected |= CATEGORY_MASK_ISO_7_ELSE;
df7492f9
KH		 2930 if (SAFE_CHARSET_P (&coding_categories[coding_category_iso_8_else],
2931 id))
ff0dacd7 2932 found |= CATEGORY_MASK_ISO_8_ELSE;
ae9ff118 2933 else
ff0dacd7 2934 rejected |= CATEGORY_MASK_ISO_8_ELSE;
4ed46869
KH		 2935 break;
2936
4ed46869 2937 case ISO_CODE_SO:
d46c5b12 2938 case ISO_CODE_SI:
ff0dacd7 2939 /* Locking shift out/in. */
74383408
KH		 2940 if (inhibit_iso_escape_detection)
2941 break;
f46869e4 2942 single_shifting = 0;
ff0dacd7 2943 rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_8BIT;
d46c5b12
KH		 2944 break;
2945
4ed46869 2946 case ISO_CODE_CSI:
ff0dacd7 2947 /* Control sequence introducer. */
f46869e4 2948 single_shifting = 0;
ff0dacd7
KH		 2949 rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
2950 found |= CATEGORY_MASK_ISO_8_ELSE;
2951 goto check_extra_latin;
2952
4ed46869
KH		 2953 case ISO_CODE_SS2:
2954 case ISO_CODE_SS3:
ff0dacd7
KH		 2955 /* Single shift. */
2956 if (inhibit_iso_escape_detection)
2957 break;
75e2a253 2958 single_shifting = 0;
ff0dacd7
KH		 2959 rejected |= CATEGORY_MASK_ISO_7BIT;
2960 if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
2961 & CODING_ISO_FLAG_SINGLE_SHIFT)
75e2a253 2962 found |= CATEGORY_MASK_ISO_8_1, single_shifting = 1;
ff0dacd7
KH		 2963 if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_2])
2964 & CODING_ISO_FLAG_SINGLE_SHIFT)
75e2a253
KH		 2965 found |= CATEGORY_MASK_ISO_8_2, single_shifting = 1;
2966 if (single_shifting)
2967 break;
ff0dacd7 2968 goto check_extra_latin;
4ed46869
KH		 2969
2970 default:
065e3595
KH		 2971 if (c < 0)
2972 continue;
4ed46869 2973 if (c < 0x80)
f46869e4 2974 {
cee53ed4
KH		 2975 if (composition_count >= 0)
2976 composition_count++;
f46869e4
KH		 2977 single_shifting = 0;
2978 break;
2979 }
ff0dacd7 2980 if (c >= 0xA0)
c4825358 2981 {
ff0dacd7
KH		 2982 rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
2983 found |= CATEGORY_MASK_ISO_8_1;
f46869e4 2984 /* Check the length of succeeding codes of the range
ff0dacd7
KH		 2985 0xA0..0FF. If the byte length is even, we include
2986 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2987 only when we are not single shifting. */
2988 if (! single_shifting
2989 && ! (rejected & CATEGORY_MASK_ISO_8_2))
f46869e4 2990 {
e17de821 2991 int i = 1;
b73bfc1c
KH		 2992 while (src < src_end)
2993 {
df7492f9 2994 ONE_MORE_BYTE (c);
b73bfc1c
KH		 2995 if (c < 0xA0)
2996 break;
2997 i++;
2998 }
2999
3000 if (i & 1 && src < src_end)
cee53ed4
KH		 3001 {
3002 rejected |= CATEGORY_MASK_ISO_8_2;
3003 if (composition_count >= 0)
3004 composition_count += i;
3005 }
f46869e4 3006 else
cee53ed4
KH		 3007 {
3008 found |= CATEGORY_MASK_ISO_8_2;
3009 if (composition_count >= 0)
3010 composition_count += i / 2;
3011 }
f46869e4 3012 }
ff0dacd7 3013 break;
4ed46869 3014 }
ff0dacd7
KH		 3015 check_extra_latin:
3016 single_shifting = 0;
3017 if (! VECTORP (Vlatin_extra_code_table)
3018 || NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
3019 {
3020 rejected = CATEGORY_MASK_ISO;
3021 break;
3022 }
3023 if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
3024 & CODING_ISO_FLAG_LATIN_EXTRA)
3025 found |= CATEGORY_MASK_ISO_8_1;
3026 else
3027 rejected |= CATEGORY_MASK_ISO_8_1;
75e2a253 3028 rejected |= CATEGORY_MASK_ISO_8_2;
4ed46869
KH		 3029 }
3030 }
ff0dacd7
KH		 3031 detect_info->rejected |= CATEGORY_MASK_ISO;
3032 return 0;
4ed46869 3033
df7492f9 3034 no_more_source:
ff0dacd7
KH		 3035 detect_info->rejected |= rejected;
3036 detect_info->found |= (found & ~rejected);
df7492f9 3037 return 1;
4ed46869 3038}
ec6d2bb8 3039
4ed46869 3040
134b9549
KH		 3041/* Set designation state into CODING. Set CHARS_96 to -1 if the
3042 escape sequence should be kept. */
df7492f9
KH		 3043#define DECODE_DESIGNATION(reg, dim, chars_96, final) \
3044 do { \
3045 int id, prev; \
3046 \
3047 if (final < '0' || final >= 128 \
3048 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
3049 || !SAFE_CHARSET_P (coding, id)) \
3050 { \
3051 CODING_ISO_DESIGNATION (coding, reg) = -2; \
134b9549
KH		 3052 chars_96 = -1; \
3053 break; \
df7492f9
KH		 3054 } \
3055 prev = CODING_ISO_DESIGNATION (coding, reg); \
bf16eb23
KH		 3056 if (id == charset_jisx0201_roman) \
3057 { \
3058 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3059 id = charset_ascii; \
3060 } \
3061 else if (id == charset_jisx0208_1978) \
3062 { \
3063 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3064 id = charset_jisx0208; \
3065 } \
df7492f9
KH		 3066 CODING_ISO_DESIGNATION (coding, reg) = id; \
3067 /* If there was an invalid designation to REG previously, and this \
3068 designation is ASCII to REG, we should keep this designation \
3069 sequence. */ \
3070 if (prev == -2 && id == charset_ascii) \
134b9549 3071 chars_96 = -1; \
4ed46869
KH		 3072 } while (0)
3073
d46c5b12 3074
df7492f9
KH		 3075#define MAYBE_FINISH_COMPOSITION() \
3076 do { \
3077 int i; \
3078 if (composition_state == COMPOSING_NO) \
3079 break; \
3080 /* It is assured that we have enough room for producing \
3081 characters stored in the table `components'. */ \
3082 if (charbuf + component_idx > charbuf_end) \
3083 goto no_more_source; \
3084 composition_state = COMPOSING_NO; \
3085 if (method == COMPOSITION_RELATIVE \
3086 || method == COMPOSITION_WITH_ALTCHARS) \
3087 { \
3088 for (i = 0; i < component_idx; i++) \
3089 *charbuf++ = components[i]; \
3090 char_offset += component_idx; \
3091 } \
3092 else \
3093 { \
3094 for (i = 0; i < component_idx; i += 2) \
3095 *charbuf++ = components[i]; \
3096 char_offset += (component_idx / 2) + 1; \
3097 } \
3098 } while (0)
3099
d46c5b12 3100
aa72b389
KH		 3101/* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
3102 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
3103 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
df7492f9
KH		 3104 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
3105 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
aa72b389 3106 */
ec6d2bb8 3107
df7492f9
KH		 3108#define DECODE_COMPOSITION_START(c1) \
3109 do { \
3110 if (c1 == '0' \
781d7a48 3111 && composition_state == COMPOSING_COMPONENT_RULE) \
df7492f9
KH		 3112 { \
3113 component_len = component_idx; \
3114 composition_state = COMPOSING_CHAR; \
3115 } \
3116 else \
3117 { \
8f924df7 3118 const unsigned char *p; \
df7492f9
KH		 3119 \
3120 MAYBE_FINISH_COMPOSITION (); \
3121 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
3122 goto no_more_source; \
3123 for (p = src; p < src_end - 1; p++) \
3124 if (*p == ISO_CODE_ESC && p[1] == '1') \
3125 break; \
3126 if (p == src_end - 1) \
3127 { \
cee53ed4
KH		 3128 if (coding->mode & CODING_MODE_LAST_BLOCK) \
3129 goto invalid_code; \
9286b333
KH		 3130 /* The current composition doesn't end in the current \
3131 source. */ \
3132 record_conversion_result \
3133 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
df7492f9
KH		 3134 goto no_more_source; \
3135 } \
3136 \
3137 /* This is surely the start of a composition. */ \
3138 method = (c1 == '0' ? COMPOSITION_RELATIVE \
3139 : c1 == '2' ? COMPOSITION_WITH_RULE \
3140 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
3141 : COMPOSITION_WITH_RULE_ALTCHARS); \
3142 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
3143 : COMPOSING_COMPONENT_CHAR); \
3144 component_idx = component_len = 0; \
3145 } \
ec6d2bb8
KH		 3146 } while (0)
3147
ec6d2bb8 3148
df7492f9
KH		 3149/* Handle compositoin end sequence ESC 1. */
3150
3151#define DECODE_COMPOSITION_END() \
ec6d2bb8 3152 do { \
df7492f9
KH		 3153 int nchars = (component_len > 0 ? component_idx - component_len \
3154 : method == COMPOSITION_RELATIVE ? component_idx \
3155 : (component_idx + 1) / 2); \
3156 int i; \
3157 int *saved_charbuf = charbuf; \
3158 \
69a80ea3 3159 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
df7492f9 3160 if (method != COMPOSITION_RELATIVE) \
ec6d2bb8 3161 { \
df7492f9
KH		 3162 if (component_len == 0) \
3163 for (i = 0; i < component_idx; i++) \
3164 *charbuf++ = components[i]; \
3165 else \
3166 for (i = 0; i < component_len; i++) \
3167 *charbuf++ = components[i]; \
3168 *saved_charbuf = saved_charbuf - charbuf; \
ec6d2bb8 3169 } \
df7492f9
KH		 3170 if (method == COMPOSITION_WITH_RULE) \
3171 for (i = 0; i < component_idx; i += 2, char_offset++) \
3172 *charbuf++ = components[i]; \
ec6d2bb8 3173 else \
df7492f9
KH		 3174 for (i = component_len; i < component_idx; i++, char_offset++) \
3175 *charbuf++ = components[i]; \
3176 coding->annotated = 1; \
3177 composition_state = COMPOSING_NO; \
ec6d2bb8
KH		 3178 } while (0)
3179
df7492f9 3180
ec6d2bb8
KH		 3181/* Decode a composition rule from the byte C1 (and maybe one more byte
3182 from SRC) and store one encoded composition rule in
3183 coding->cmp_data. */
3184
3185#define DECODE_COMPOSITION_RULE(c1) \
3186 do { \
ec6d2bb8
KH		 3187 (c1) -= 32; \
3188 if (c1 < 81) /* old format (before ver.21) */ \
3189 { \
3190 int gref = (c1) / 9; \
3191 int nref = (c1) % 9; \
3192 if (gref == 4) gref = 10; \
3193 if (nref == 4) nref = 10; \
df7492f9 3194 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
ec6d2bb8 3195 } \
b73bfc1c 3196 else if (c1 < 93) /* new format (after ver.21) */ \
ec6d2bb8
KH		 3197 { \
3198 ONE_MORE_BYTE (c2); \
df7492f9 3199 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
ec6d2bb8 3200 } \
df7492f9
KH		 3201 else \
3202 c1 = 0; \
ec6d2bb8 3203 } while (0)
88993dfd 3204
d46c5b12 3205
4ed46869
KH		 3206/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
3207
b73bfc1c 3208static void
df7492f9 3209decode_coding_iso_2022 (coding)
4ed46869 3210 struct coding_system *coding;
4ed46869 3211{
8f924df7
KH		 3212 const unsigned char *src = coding->source + coding->consumed;
3213 const unsigned char *src_end = coding->source + coding->src_bytes;
3214 const unsigned char *src_base;
69a80ea3 3215 int *charbuf = coding->charbuf + coding->charbuf_used;
ff0dacd7 3216 int *charbuf_end
69a80ea3 3217 = coding->charbuf + coding->charbuf_size - 4 - MAX_ANNOTATION_LENGTH;
df7492f9 3218 int consumed_chars = 0, consumed_chars_base;
df7492f9 3219 int multibytep = coding->src_multibyte;
4ed46869 3220 /* Charsets invoked to graphic plane 0 and 1 respectively. */
df7492f9
KH		 3221 int charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
3222 int charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
134b9549 3223 int charset_id_2, charset_id_3;
df7492f9
KH		 3224 struct charset *charset;
3225 int c;
3226 /* For handling composition sequence. */
3227#define COMPOSING_NO 0
3228#define COMPOSING_CHAR 1
3229#define COMPOSING_RULE 2
3230#define COMPOSING_COMPONENT_CHAR 3
3231#define COMPOSING_COMPONENT_RULE 4
3232
3233 int composition_state = COMPOSING_NO;
3234 enum composition_method method;
3235 int components[MAX_COMPOSITION_COMPONENTS * 2 + 1];
3236 int component_idx;
3237 int component_len;
24a73b0a 3238 Lisp_Object attrs, charset_list;
ff0dacd7
KH		 3239 int char_offset = coding->produced_char;
3240 int last_offset = char_offset;
3241 int last_id = charset_ascii;
119852e7
KH		 3242 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
3243 int byte_after_cr = -1;
df7492f9 3244
24a73b0a 3245 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9 3246 setup_iso_safe_charsets (attrs);
287c57d7
KH		 3247 /* Charset list may have been changed. */
3248 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
3249 coding->safe_charsets = (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs));
b73bfc1c
KH		 3250
3251 while (1)
4ed46869 3252 {
463f5630 3253 int c1, c2;
b73bfc1c
KH		 3254
3255 src_base = src;
df7492f9
KH		 3256 consumed_chars_base = consumed_chars;
3257
3258 if (charbuf >= charbuf_end)
b71f6f73
KH		 3259 {
3260 if (byte_after_cr >= 0)
3261 src_base--;
3262 break;
3263 }
df7492f9 3264
119852e7
KH		 3265 if (byte_after_cr >= 0)
3266 c1 = byte_after_cr, byte_after_cr = -1;
3267 else
3268 ONE_MORE_BYTE (c1);
065e3595
KH		 3269 if (c1 < 0)
3270 goto invalid_code;
4ed46869 3271
98725083 3272 /* We produce at most one character. */
4ed46869
KH		 3273 switch (iso_code_class [c1])
3274 {
3275 case ISO_0x20_or_0x7F:
df7492f9 3276 if (composition_state != COMPOSING_NO)
ec6d2bb8 3277 {
df7492f9
KH		 3278 if (composition_state == COMPOSING_RULE
3279 || composition_state == COMPOSING_COMPONENT_RULE)
3280 {
cee53ed4
KH		 3281 if (component_idx < MAX_COMPOSITION_COMPONENTS * 2 + 1)
3282 {
3283 DECODE_COMPOSITION_RULE (c1);
3284 components[component_idx++] = c1;
3285 composition_state--;
3286 continue;
3287 }
3288 /* Too long composition. */
3289 MAYBE_FINISH_COMPOSITION ();
df7492f9 3290 }
4ed46869 3291 }
df7492f9
KH		 3292 if (charset_id_0 < 0
3293 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0)))
781d7a48
KH		 3294 /* This is SPACE or DEL. */
3295 charset = CHARSET_FROM_ID (charset_ascii);
3296 else
3297 charset = CHARSET_FROM_ID (charset_id_0);
3298 break;
4ed46869
KH		 3299
3300 case ISO_graphic_plane_0:
781d7a48 3301 if (composition_state != COMPOSING_NO)
b73bfc1c 3302 {
781d7a48
KH		 3303 if (composition_state == COMPOSING_RULE
3304 || composition_state == COMPOSING_COMPONENT_RULE)
3305 {
cee53ed4
KH		 3306 if (component_idx < MAX_COMPOSITION_COMPONENTS * 2 + 1)
3307 {
3308 DECODE_COMPOSITION_RULE (c1);
3309 components[component_idx++] = c1;
3310 composition_state--;
3311 continue;
3312 }
3313 MAYBE_FINISH_COMPOSITION ();
781d7a48 3314 }
b73bfc1c 3315 }
134b9549
KH		 3316 if (charset_id_0 < 0)
3317 charset = CHARSET_FROM_ID (charset_ascii);
3318 else
3319 charset = CHARSET_FROM_ID (charset_id_0);
4ed46869
KH		 3320 break;
3321
3322 case ISO_0xA0_or_0xFF:
df7492f9
KH		 3323 if (charset_id_1 < 0
3324 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1))
3325 || CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)
3326 goto invalid_code;
4ed46869
KH		 3327 /* This is a graphic character, we fall down ... */
3328
3329 case ISO_graphic_plane_1:
df7492f9
KH		 3330 if (charset_id_1 < 0)
3331 goto invalid_code;
3332 charset = CHARSET_FROM_ID (charset_id_1);
4ed46869
KH		 3333 break;
3334
df7492f9 3335 case ISO_control_0:
119852e7
KH		 3336 if (eol_crlf && c1 == '\r')
3337 ONE_MORE_BYTE (byte_after_cr);
df7492f9
KH		 3338 MAYBE_FINISH_COMPOSITION ();
3339 charset = CHARSET_FROM_ID (charset_ascii);
4ed46869
KH		 3340 break;
3341
df7492f9
KH		 3342 case ISO_control_1:
3343 MAYBE_FINISH_COMPOSITION ();
3344 goto invalid_code;
3345
4ed46869 3346 case ISO_shift_out:
df7492f9
KH		 3347 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
3348 || CODING_ISO_DESIGNATION (coding, 1) < 0)
3349 goto invalid_code;
3350 CODING_ISO_INVOCATION (coding, 0) = 1;
3351 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
b73bfc1c 3352 continue;
4ed46869
KH		 3353
3354 case ISO_shift_in:
df7492f9
KH		 3355 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT))
3356 goto invalid_code;
3357 CODING_ISO_INVOCATION (coding, 0) = 0;
3358 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
b73bfc1c 3359 continue;
4ed46869
KH		 3360
3361 case ISO_single_shift_2_7:
3362 case ISO_single_shift_2:
df7492f9
KH		 3363 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT))
3364 goto invalid_code;
4ed46869
KH		 3365 /* SS2 is handled as an escape sequence of ESC 'N' */
3366 c1 = 'N';
3367 goto label_escape_sequence;
3368
3369 case ISO_single_shift_3:
df7492f9
KH		 3370 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT))
3371 goto invalid_code;
4ed46869
KH		 3372 /* SS2 is handled as an escape sequence of ESC 'O' */
3373 c1 = 'O';
3374 goto label_escape_sequence;
3375
3376 case ISO_control_sequence_introducer:
3377 /* CSI is handled as an escape sequence of ESC '[' ... */
3378 c1 = '[';
3379 goto label_escape_sequence;
3380
3381 case ISO_escape:
3382 ONE_MORE_BYTE (c1);
3383 label_escape_sequence:
df7492f9 3384 /* Escape sequences handled here are invocation,
4ed46869
KH		 3385 designation, direction specification, and character
3386 composition specification. */
3387 switch (c1)
3388 {
3389 case '&': /* revision of following character set */
3390 ONE_MORE_BYTE (c1);
3391 if (!(c1 >= '@' && c1 <= '~'))
df7492f9 3392 goto invalid_code;
4ed46869
KH		 3393 ONE_MORE_BYTE (c1);
3394 if (c1 != ISO_CODE_ESC)
df7492f9 3395 goto invalid_code;
4ed46869
KH		 3396 ONE_MORE_BYTE (c1);
3397 goto label_escape_sequence;
3398
3399 case '$': /* designation of 2-byte character set */
df7492f9
KH		 3400 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATION))
3401 goto invalid_code;
134b9549
KH		 3402 {
3403 int reg, chars96;
3404
3405 ONE_MORE_BYTE (c1);
3406 if (c1 >= '@' && c1 <= 'B')
3407 { /* designation of JISX0208.1978, GB2312.1980,
88993dfd 3408 or JISX0208.1980 */
134b9549
KH		 3409 reg = 0, chars96 = 0;
3410 }
3411 else if (c1 >= 0x28 && c1 <= 0x2B)
3412 { /* designation of DIMENSION2_CHARS94 character set */
3413 reg = c1 - 0x28, chars96 = 0;
3414 ONE_MORE_BYTE (c1);
3415 }
3416 else if (c1 >= 0x2C && c1 <= 0x2F)
3417 { /* designation of DIMENSION2_CHARS96 character set */
3418 reg = c1 - 0x2C, chars96 = 1;
3419 ONE_MORE_BYTE (c1);
3420 }
3421 else
3422 goto invalid_code;
3423 DECODE_DESIGNATION (reg, 2, chars96, c1);
3424 /* We must update these variables now. */
3425 if (reg == 0)
3426 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
3427 else if (reg == 1)
3428 charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
3429 if (chars96 < 0)
3430 goto invalid_code;
3431 }
b73bfc1c 3432 continue;
4ed46869
KH		 3433
3434 case 'n': /* invocation of locking-shift-2 */
df7492f9
KH		 3435 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
3436 || CODING_ISO_DESIGNATION (coding, 2) < 0)
3437 goto invalid_code;
3438 CODING_ISO_INVOCATION (coding, 0) = 2;
3439 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
b73bfc1c 3440 continue;
4ed46869
KH		 3441
3442 case 'o': /* invocation of locking-shift-3 */
df7492f9
KH		 3443 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LOCKING_SHIFT)
3444 || CODING_ISO_DESIGNATION (coding, 3) < 0)
3445 goto invalid_code;
3446 CODING_ISO_INVOCATION (coding, 0) = 3;
3447 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
b73bfc1c 3448 continue;
4ed46869
KH		 3449
3450 case 'N': /* invocation of single-shift-2 */
df7492f9
KH		 3451 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
3452 || CODING_ISO_DESIGNATION (coding, 2) < 0)
3453 goto invalid_code;
134b9549
KH		 3454 charset_id_2 = CODING_ISO_DESIGNATION (coding, 2);
3455 if (charset_id_2 < 0)
3456 charset = CHARSET_FROM_ID (charset_ascii);
3457 else
3458 charset = CHARSET_FROM_ID (charset_id_2);
b73bfc1c 3459 ONE_MORE_BYTE (c1);
e7046a18 3460 if (c1 < 0x20 || (c1 >= 0x80 && c1 < 0xA0))
df7492f9 3461 goto invalid_code;
4ed46869
KH		 3462 break;
3463
3464 case 'O': /* invocation of single-shift-3 */
df7492f9
KH		 3465 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
3466 || CODING_ISO_DESIGNATION (coding, 3) < 0)
3467 goto invalid_code;
134b9549
KH		 3468 charset_id_3 = CODING_ISO_DESIGNATION (coding, 3);
3469 if (charset_id_3 < 0)
3470 charset = CHARSET_FROM_ID (charset_ascii);
3471 else
3472 charset = CHARSET_FROM_ID (charset_id_3);
b73bfc1c 3473 ONE_MORE_BYTE (c1);
e7046a18 3474 if (c1 < 0x20 || (c1 >= 0x80 && c1 < 0xA0))
df7492f9 3475 goto invalid_code;
4ed46869
KH		 3476 break;
3477
ec6d2bb8 3478 case '0': case '2': case '3': case '4': /* start composition */
df7492f9
KH		 3479 if (! (coding->common_flags & CODING_ANNOTATE_COMPOSITION_MASK))
3480 goto invalid_code;
ec6d2bb8 3481 DECODE_COMPOSITION_START (c1);
b73bfc1c 3482 continue;
4ed46869 3483
ec6d2bb8 3484 case '1': /* end composition */
df7492f9
KH		 3485 if (composition_state == COMPOSING_NO)
3486 goto invalid_code;
3487 DECODE_COMPOSITION_END ();
b73bfc1c 3488 continue;
4ed46869
KH		 3489
3490 case '[': /* specification of direction */
df7492f9
KH		 3491 if (! CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DIRECTION)
3492 goto invalid_code;
4ed46869 3493 /* For the moment, nested direction is not supported.
d46c5b12 3494 So, `coding->mode & CODING_MODE_DIRECTION' zero means
df7492f9 3495 left-to-right, and nozero means right-to-left. */
4ed46869
KH		 3496 ONE_MORE_BYTE (c1);
3497 switch (c1)
3498 {
3499 case ']': /* end of the current direction */
d46c5b12 3500 coding->mode &= ~CODING_MODE_DIRECTION;
4ed46869
KH		 3501
3502 case '0': /* end of the current direction */
3503 case '1': /* start of left-to-right direction */
3504 ONE_MORE_BYTE (c1);
3505 if (c1 == ']')
d46c5b12 3506 coding->mode &= ~CODING_MODE_DIRECTION;
4ed46869 3507 else
df7492f9 3508 goto invalid_code;
4ed46869
KH		 3509 break;
3510
3511 case '2': /* start of right-to-left direction */
3512 ONE_MORE_BYTE (c1);
3513 if (c1 == ']')
d46c5b12 3514 coding->mode |= CODING_MODE_DIRECTION;
4ed46869 3515 else
df7492f9 3516 goto invalid_code;
4ed46869
KH		 3517 break;
3518
3519 default:
df7492f9 3520 goto invalid_code;
4ed46869 3521 }
b73bfc1c 3522 continue;
4ed46869 3523
103e0180 3524 case '%':
103e0180
KH		 3525 ONE_MORE_BYTE (c1);
3526 if (c1 == '/')
3527 {
3528 /* CTEXT extended segment:
3529 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3530 We keep these bytes as is for the moment.
3531 They may be decoded by post-read-conversion. */
3532 int dim, M, L;
4776e638 3533 int size;
8f924df7 3534
103e0180
KH		 3535 ONE_MORE_BYTE (dim);
3536 ONE_MORE_BYTE (M);
3537 ONE_MORE_BYTE (L);
3538 size = ((M - 128) * 128) + (L - 128);
4776e638
KH		 3539 if (charbuf + 8 + size > charbuf_end)
3540 goto break_loop;
3541 *charbuf++ = ISO_CODE_ESC;
3542 *charbuf++ = '%';
3543 *charbuf++ = '/';
3544 *charbuf++ = dim;
3545 *charbuf++ = BYTE8_TO_CHAR (M);
3546 *charbuf++ = BYTE8_TO_CHAR (L);
103e0180
KH		 3547 while (size-- > 0)
3548 {
3549 ONE_MORE_BYTE (c1);
4776e638 3550 *charbuf++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
103e0180 3551 }
103e0180
KH		 3552 }
3553 else if (c1 == 'G')
3554 {
103e0180
KH		 3555 /* XFree86 extension for embedding UTF-8 in CTEXT:
3556 ESC % G --UTF-8-BYTES-- ESC % @
3557 We keep these bytes as is for the moment.
3558 They may be decoded by post-read-conversion. */
4776e638
KH		 3559 int *p = charbuf;
3560
3561 if (p + 6 > charbuf_end)
3562 goto break_loop;
3563 *p++ = ISO_CODE_ESC;
3564 *p++ = '%';
3565 *p++ = 'G';
3566 while (p < charbuf_end)
103e0180
KH		 3567 {
3568 ONE_MORE_BYTE (c1);
3569 if (c1 == ISO_CODE_ESC
3570 && src + 1 < src_end
3571 && src[0] == '%'
3572 && src[1] == '@')
9ffd559c
KH		 3573 {
3574 src += 2;
3575 break;
3576 }
4776e638 3577 *p++ = ASCII_BYTE_P (c1) ? c1 : BYTE8_TO_CHAR (c1);
103e0180 3578 }
4776e638
KH		 3579 if (p + 3 > charbuf_end)
3580 goto break_loop;
3581 *p++ = ISO_CODE_ESC;
3582 *p++ = '%';
3583 *p++ = '@';
3584 charbuf = p;
103e0180
KH		 3585 }
3586 else
4776e638 3587 goto invalid_code;
103e0180 3588 continue;
4776e638 3589 break;
103e0180 3590
4ed46869 3591 default:
df7492f9
KH		 3592 if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATION))
3593 goto invalid_code;
134b9549
KH		 3594 {
3595 int reg, chars96;
3596
3597 if (c1 >= 0x28 && c1 <= 0x2B)
3598 { /* designation of DIMENSION1_CHARS94 character set */
3599 reg = c1 - 0x28, chars96 = 0;
3600 ONE_MORE_BYTE (c1);
3601 }
3602 else if (c1 >= 0x2C && c1 <= 0x2F)
3603 { /* designation of DIMENSION1_CHARS96 character set */
3604 reg = c1 - 0x2C, chars96 = 1;
3605 ONE_MORE_BYTE (c1);
3606 }
3607 else
3608 goto invalid_code;
3609 DECODE_DESIGNATION (reg, 1, chars96, c1);
3610 /* We must update these variables now. */
3611 if (reg == 0)
3612 charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0);
3613 else if (reg == 1)
3614 charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1);
3615 if (chars96 < 0)
3616 goto invalid_code;
3617 }
b73bfc1c 3618 continue;
4ed46869 3619 }
b73bfc1c 3620 }
4ed46869 3621
ff0dacd7
KH		 3622 if (charset->id != charset_ascii
3623 && last_id != charset->id)
3624 {
3625 if (last_id != charset_ascii)
69a80ea3 3626 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
ff0dacd7
KH		 3627 last_id = charset->id;
3628 last_offset = char_offset;
3629 }
3630
b73bfc1c 3631 /* Now we know CHARSET and 1st position code C1 of a character.
df7492f9
KH		 3632 Produce a decoded character while getting 2nd position code
3633 C2 if necessary. */
3634 c1 &= 0x7F;
3635 if (CHARSET_DIMENSION (charset) > 1)
b73bfc1c
KH		 3636 {
3637 ONE_MORE_BYTE (c2);
df7492f9 3638 if (c2 < 0x20 || (c2 >= 0x80 && c2 < 0xA0))
b73bfc1c 3639 /* C2 is not in a valid range. */
df7492f9
KH		 3640 goto invalid_code;
3641 c1 = (c1 << 8) | (c2 & 0x7F);
3642 if (CHARSET_DIMENSION (charset) > 2)
3643 {
3644 ONE_MORE_BYTE (c2);
3645 if (c2 < 0x20 || (c2 >= 0x80 && c2 < 0xA0))
3646 /* C2 is not in a valid range. */
3647 goto invalid_code;
3648 c1 = (c1 << 8) | (c2 & 0x7F);
3649 }
3650 }
3651
3652 CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c1, c);
3653 if (c < 0)
3654 {
3655 MAYBE_FINISH_COMPOSITION ();
3656 for (; src_base < src; src_base++, char_offset++)
3657 {
3658 if (ASCII_BYTE_P (*src_base))
3659 *charbuf++ = *src_base;
3660 else
3661 *charbuf++ = BYTE8_TO_CHAR (*src_base);
3662 }
3663 }
3664 else if (composition_state == COMPOSING_NO)
3665 {
3666 *charbuf++ = c;
3667 char_offset++;
4ed46869 3668 }
df7492f9 3669 else
781d7a48 3670 {
cee53ed4
KH		 3671 if (component_idx < MAX_COMPOSITION_COMPONENTS * 2 + 1)
3672 {
3673 components[component_idx++] = c;
3674 if (method == COMPOSITION_WITH_RULE
3675 || (method == COMPOSITION_WITH_RULE_ALTCHARS
3676 && composition_state == COMPOSING_COMPONENT_CHAR))
3677 composition_state++;
3678 }
3679 else
3680 {
3681 MAYBE_FINISH_COMPOSITION ();
3682 *charbuf++ = c;
3683 char_offset++;
3684 }
4ed46869
KH		 3685 }
3686 continue;
3687
df7492f9
KH		 3688 invalid_code:
3689 MAYBE_FINISH_COMPOSITION ();
4ed46869 3690 src = src_base;
df7492f9
KH		 3691 consumed_chars = consumed_chars_base;
3692 ONE_MORE_BYTE (c);
065e3595 3693 *charbuf++ = c < 0 ? -c : ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
ff0dacd7 3694 char_offset++;
df7492f9 3695 coding->errors++;
4776e638
KH		 3696 continue;
3697
3698 break_loop:
3699 break;
4ed46869 3700 }
fb88bf2d 3701
df7492f9 3702 no_more_source:
ff0dacd7 3703 if (last_id != charset_ascii)
69a80ea3 3704 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
df7492f9
KH		 3705 coding->consumed_char += consumed_chars_base;
3706 coding->consumed = src_base - coding->source;
3707 coding->charbuf_used = charbuf - coding->charbuf;
4ed46869
KH		 3708}
3709
b73bfc1c 3710
f4dee582 3711/* ISO2022 encoding stuff. */
4ed46869
KH		 3712
3713/*
f4dee582 3714 It is not enough to say just "ISO2022" on encoding, we have to
df7492f9 3715 specify more details. In Emacs, each coding system of ISO2022
4ed46869 3716 variant has the following specifications:
df7492f9 3717 1. Initial designation to G0 thru G3.
4ed46869
KH		 3718 2. Allows short-form designation?
3719 3. ASCII should be designated to G0 before control characters?
3720 4. ASCII should be designated to G0 at end of line?
3721 5. 7-bit environment or 8-bit environment?
3722 6. Use locking-shift?
3723 7. Use Single-shift?
3724 And the following two are only for Japanese:
3725 8. Use ASCII in place of JIS0201-1976-Roman?
3726 9. Use JISX0208-1983 in place of JISX0208-1978?
df7492f9
KH		 3727 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3728 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
f4dee582 3729 details.
4ed46869
KH		 3730*/
3731
3732/* Produce codes (escape sequence) for designating CHARSET to graphic
b73bfc1c
KH		 3733 register REG at DST, and increment DST. If <final-char> of CHARSET is
3734 '@', 'A', or 'B' and the coding system CODING allows, produce
3735 designation sequence of short-form. */
4ed46869
KH		 3736
3737#define ENCODE_DESIGNATION(charset, reg, coding) \
3738 do { \
df7492f9 3739 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
4ed46869
KH		 3740 char *intermediate_char_94 = "()*+"; \
3741 char *intermediate_char_96 = ",-./"; \
df7492f9
KH		 3742 int revision = -1; \
3743 int c; \
3744 \
3745 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
c197f191 3746 revision = CHARSET_ISO_REVISION (charset); \
df7492f9
KH		 3747 \
3748 if (revision >= 0) \
70c22245 3749 { \
df7492f9
KH		 3750 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3751 EMIT_ONE_BYTE ('@' + revision); \
4ed46869 3752 } \
df7492f9 3753 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
4ed46869
KH		 3754 if (CHARSET_DIMENSION (charset) == 1) \
3755 { \
df7492f9
KH		 3756 if (! CHARSET_ISO_CHARS_96 (charset)) \
3757 c = intermediate_char_94[reg]; \
4ed46869 3758 else \
df7492f9
KH		 3759 c = intermediate_char_96[reg]; \
3760 EMIT_ONE_ASCII_BYTE (c); \
4ed46869
KH		 3761 } \
3762 else \
3763 { \
df7492f9
KH		 3764 EMIT_ONE_ASCII_BYTE ('$'); \
3765 if (! CHARSET_ISO_CHARS_96 (charset)) \
4ed46869 3766 { \
df7492f9 3767 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
b73bfc1c
KH		 3768 || reg != 0 \
3769 || final_char < '@' || final_char > 'B') \
df7492f9 3770 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
4ed46869
KH		 3771 } \
3772 else \
df7492f9 3773 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
4ed46869 3774 } \
df7492f9
KH		 3775 EMIT_ONE_ASCII_BYTE (final_char); \
3776 \
3777 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
4ed46869
KH		 3778 } while (0)
3779
df7492f9 3780
4ed46869
KH		 3781/* The following two macros produce codes (control character or escape
3782 sequence) for ISO2022 single-shift functions (single-shift-2 and
3783 single-shift-3). */
3784
df7492f9
KH		 3785#define ENCODE_SINGLE_SHIFT_2 \
3786 do { \
3787 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3788 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3789 else \
3790 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3791 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4ed46869
KH		 3792 } while (0)
3793
df7492f9
KH		 3794
3795#define ENCODE_SINGLE_SHIFT_3 \
3796 do { \
3797 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3798 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3799 else \
3800 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3801 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4ed46869
KH		 3802 } while (0)
3803
df7492f9 3804
4ed46869
KH		 3805/* The following four macros produce codes (control character or
3806 escape sequence) for ISO2022 locking-shift functions (shift-in,
3807 shift-out, locking-shift-2, and locking-shift-3). */
3808
df7492f9
KH		 3809#define ENCODE_SHIFT_IN \
3810 do { \
3811 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3812 CODING_ISO_INVOCATION (coding, 0) = 0; \
4ed46869
KH		 3813 } while (0)
3814
df7492f9
KH		 3815
3816#define ENCODE_SHIFT_OUT \
3817 do { \
3818 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3819 CODING_ISO_INVOCATION (coding, 0) = 1; \
4ed46869
KH		 3820 } while (0)
3821
df7492f9
KH		 3822
3823#define ENCODE_LOCKING_SHIFT_2 \
3824 do { \
3825 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3826 CODING_ISO_INVOCATION (coding, 0) = 2; \
4ed46869
KH		 3827 } while (0)
3828
df7492f9
KH		 3829
3830#define ENCODE_LOCKING_SHIFT_3 \
3831 do { \
3832 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3833 CODING_ISO_INVOCATION (coding, 0) = 3; \
4ed46869
KH		 3834 } while (0)
3835
df7492f9 3836
f4dee582
RS		 3837/* Produce codes for a DIMENSION1 character whose character set is
3838 CHARSET and whose position-code is C1. Designation and invocation
4ed46869
KH		 3839 sequences are also produced in advance if necessary. */
3840
6e85d753
KH		 3841#define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3842 do { \
df7492f9 3843 int id = CHARSET_ID (charset); \
bf16eb23
KH		 3844 \
3845 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3846 && id == charset_ascii) \
3847 { \
3848 id = charset_jisx0201_roman; \
3849 charset = CHARSET_FROM_ID (id); \
3850 } \
3851 \
df7492f9 3852 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
6e85d753 3853 { \
df7492f9
KH		 3854 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3855 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
6e85d753 3856 else \
df7492f9
KH		 3857 EMIT_ONE_BYTE (c1 | 0x80); \
3858 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
6e85d753
KH		 3859 break; \
3860 } \
df7492f9 3861 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
6e85d753 3862 { \
df7492f9 3863 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
6e85d753
KH		 3864 break; \
3865 } \
df7492f9 3866 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
6e85d753 3867 { \
df7492f9 3868 EMIT_ONE_BYTE (c1 | 0x80); \
6e85d753
KH		 3869 break; \
3870 } \
6e85d753
KH		 3871 else \
3872 /* Since CHARSET is not yet invoked to any graphic planes, we \
3873 must invoke it, or, at first, designate it to some graphic \
3874 register. Then repeat the loop to actually produce the \
3875 character. */ \
df7492f9
KH		 3876 dst = encode_invocation_designation (charset, coding, dst, \
3877 &produced_chars); \
4ed46869
KH		 3878 } while (1)
3879
df7492f9 3880
f4dee582
RS		 3881/* Produce codes for a DIMENSION2 character whose character set is
3882 CHARSET and whose position-codes are C1 and C2. Designation and
4ed46869
KH		 3883 invocation codes are also produced in advance if necessary. */
3884
6e85d753
KH		 3885#define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3886 do { \
df7492f9 3887 int id = CHARSET_ID (charset); \
bf16eb23
KH		 3888 \
3889 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3890 && id == charset_jisx0208) \
3891 { \
3892 id = charset_jisx0208_1978; \
3893 charset = CHARSET_FROM_ID (id); \
3894 } \
3895 \
df7492f9 3896 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
6e85d753 3897 { \
df7492f9
KH		 3898 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3899 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
6e85d753 3900 else \
df7492f9
KH		 3901 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3902 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
6e85d753
KH		 3903 break; \
3904 } \
df7492f9 3905 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
6e85d753 3906 { \
df7492f9 3907 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
6e85d753
KH		 3908 break; \
3909 } \
df7492f9 3910 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
6e85d753 3911 { \
df7492f9 3912 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
6e85d753
KH		 3913 break; \
3914 } \
6e85d753
KH		 3915 else \
3916 /* Since CHARSET is not yet invoked to any graphic planes, we \
3917 must invoke it, or, at first, designate it to some graphic \
3918 register. Then repeat the loop to actually produce the \
3919 character. */ \
df7492f9
KH		 3920 dst = encode_invocation_designation (charset, coding, dst, \
3921 &produced_chars); \
4ed46869
KH		 3922 } while (1)
3923
05e6f5dc 3924
df7492f9
KH		 3925#define ENCODE_ISO_CHARACTER(charset, c) \
3926 do { \
3927 int code = ENCODE_CHAR ((charset),(c)); \
3928 \
3929 if (CHARSET_DIMENSION (charset) == 1) \
3930 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3931 else \
3932 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
84fbb8a0 3933 } while (0)
bdd9fb48 3934
05e6f5dc 3935
4ed46869 3936/* Produce designation and invocation codes at a place pointed by DST
df7492f9 3937 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
4ed46869
KH		 3938 Return new DST. */
3939
3940unsigned char *
df7492f9
KH		 3941encode_invocation_designation (charset, coding, dst, p_nchars)
3942 struct charset *charset;
4ed46869
KH		 3943 struct coding_system *coding;
3944 unsigned char *dst;
df7492f9 3945 int *p_nchars;
4ed46869 3946{
df7492f9
KH		 3947 int multibytep = coding->dst_multibyte;
3948 int produced_chars = *p_nchars;
4ed46869 3949 int reg; /* graphic register number */
df7492f9 3950 int id = CHARSET_ID (charset);
4ed46869
KH		 3951
3952 /* At first, check designations. */
3953 for (reg = 0; reg < 4; reg++)
df7492f9 3954 if (id == CODING_ISO_DESIGNATION (coding, reg))
4ed46869
KH		 3955 break;
3956
3957 if (reg >= 4)
3958 {
3959 /* CHARSET is not yet designated to any graphic registers. */
3960 /* At first check the requested designation. */
df7492f9
KH		 3961 reg = CODING_ISO_REQUEST (coding, id);
3962 if (reg < 0)
1ba9e4ab
KH		 3963 /* Since CHARSET requests no special designation, designate it
3964 to graphic register 0. */
4ed46869
KH		 3965 reg = 0;
3966
3967 ENCODE_DESIGNATION (charset, reg, coding);
3968 }
3969
df7492f9
KH		 3970 if (CODING_ISO_INVOCATION (coding, 0) != reg
3971 && CODING_ISO_INVOCATION (coding, 1) != reg)
4ed46869
KH		 3972 {
3973 /* Since the graphic register REG is not invoked to any graphic
3974 planes, invoke it to graphic plane 0. */
3975 switch (reg)
3976 {
3977 case 0: /* graphic register 0 */
3978 ENCODE_SHIFT_IN;
3979 break;
3980
3981 case 1: /* graphic register 1 */
3982 ENCODE_SHIFT_OUT;
3983 break;
3984
3985 case 2: /* graphic register 2 */
df7492f9 3986 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
4ed46869
KH		 3987 ENCODE_SINGLE_SHIFT_2;
3988 else
3989 ENCODE_LOCKING_SHIFT_2;
3990 break;
3991
3992 case 3: /* graphic register 3 */
df7492f9 3993 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT)
4ed46869
KH		 3994 ENCODE_SINGLE_SHIFT_3;
3995 else
3996 ENCODE_LOCKING_SHIFT_3;
3997 break;
3998 }
3999 }
b73bfc1c 4000
df7492f9 4001 *p_nchars = produced_chars;
4ed46869
KH		 4002 return dst;
4003}
4004
df7492f9
KH		 4005/* The following three macros produce codes for indicating direction
4006 of text. */
4007#define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
ec6d2bb8 4008 do { \
df7492f9
KH		 4009 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
4010 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
ec6d2bb8 4011 else \
df7492f9 4012 EMIT_ONE_BYTE (ISO_CODE_CSI); \
ec6d2bb8
KH		 4013 } while (0)
4014
ec6d2bb8 4015
df7492f9
KH		 4016#define ENCODE_DIRECTION_R2L() \
4017 do { \
4018 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
4019 EMIT_TWO_ASCII_BYTES ('2', ']'); \
ec6d2bb8
KH		 4020 } while (0)
4021
ec6d2bb8 4022
df7492f9 4023#define ENCODE_DIRECTION_L2R() \
ec6d2bb8 4024 do { \
df7492f9
KH		 4025 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
4026 EMIT_TWO_ASCII_BYTES ('0', ']'); \
ec6d2bb8 4027 } while (0)
4ed46869 4028
4ed46869
KH		 4029
4030/* Produce codes for designation and invocation to reset the graphic
4031 planes and registers to initial state. */
df7492f9
KH		 4032#define ENCODE_RESET_PLANE_AND_REGISTER() \
4033 do { \
4034 int reg; \
4035 struct charset *charset; \
4036 \
4037 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
4038 ENCODE_SHIFT_IN; \
4039 for (reg = 0; reg < 4; reg++) \
4040 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
4041 && (CODING_ISO_DESIGNATION (coding, reg) \
4042 != CODING_ISO_INITIAL (coding, reg))) \
4043 { \
4044 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
4045 ENCODE_DESIGNATION (charset, reg, coding); \
4046 } \
4ed46869
KH		 4047 } while (0)
4048
df7492f9 4049
bdd9fb48 4050/* Produce designation sequences of charsets in the line started from
b73bfc1c 4051 SRC to a place pointed by DST, and return updated DST.
bdd9fb48
KH		 4052
4053 If the current block ends before any end-of-line, we may fail to
d46c5b12
KH		 4054 find all the necessary designations. */
4055
b73bfc1c 4056static unsigned char *
df7492f9 4057encode_designation_at_bol (coding, charbuf, charbuf_end, dst)
e0e989f6 4058 struct coding_system *coding;
df7492f9
KH		 4059 int *charbuf, *charbuf_end;
4060 unsigned char *dst;
e0e989f6 4061{
df7492f9 4062 struct charset *charset;
bdd9fb48
KH		 4063 /* Table of charsets to be designated to each graphic register. */
4064 int r[4];
df7492f9
KH		 4065 int c, found = 0, reg;
4066 int produced_chars = 0;
4067 int multibytep = coding->dst_multibyte;
4068 Lisp_Object attrs;
4069 Lisp_Object charset_list;
4070
4071 attrs = CODING_ID_ATTRS (coding->id);
4072 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
4073 if (EQ (charset_list, Qiso_2022))
4074 charset_list = Viso_2022_charset_list;
bdd9fb48
KH		 4075
4076 for (reg = 0; reg < 4; reg++)
4077 r[reg] = -1;
4078
b73bfc1c 4079 while (found < 4)
e0e989f6 4080 {
df7492f9
KH		 4081 int id;
4082
4083 c = *charbuf++;
b73bfc1c
KH		 4084 if (c == '\n')
4085 break;
df7492f9
KH		 4086 charset = char_charset (c, charset_list, NULL);
4087 id = CHARSET_ID (charset);
4088 reg = CODING_ISO_REQUEST (coding, id);
4089 if (reg >= 0 && r[reg] < 0)
bdd9fb48
KH		 4090 {
4091 found++;
df7492f9 4092 r[reg] = id;
bdd9fb48 4093 }
bdd9fb48
KH		 4094 }
4095
4096 if (found)
4097 {
4098 for (reg = 0; reg < 4; reg++)
4099 if (r[reg] >= 0
df7492f9
KH		 4100 && CODING_ISO_DESIGNATION (coding, reg) != r[reg])
4101 ENCODE_DESIGNATION (CHARSET_FROM_ID (r[reg]), reg, coding);
e0e989f6 4102 }
b73bfc1c
KH		 4103
4104 return dst;
e0e989f6
KH		 4105}
4106
4ed46869
KH		 4107/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
4108
df7492f9
KH		 4109static int
4110encode_coding_iso_2022 (coding)
4ed46869 4111 struct coding_system *coding;
4ed46869 4112{
df7492f9
KH		 4113 int multibytep = coding->dst_multibyte;
4114 int *charbuf = coding->charbuf;
4115 int *charbuf_end = charbuf + coding->charbuf_used;
4116 unsigned char *dst = coding->destination + coding->produced;
4117 unsigned char *dst_end = coding->destination + coding->dst_bytes;
4118 int safe_room = 16;
4119 int bol_designation
4120 = (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
4121 && CODING_ISO_BOL (coding));
4122 int produced_chars = 0;
4123 Lisp_Object attrs, eol_type, charset_list;
4124 int ascii_compatible;
b73bfc1c 4125 int c;
ff0dacd7 4126 int preferred_charset_id = -1;
05e6f5dc 4127
24a73b0a
KH		 4128 CODING_GET_INFO (coding, attrs, charset_list);
4129 eol_type = CODING_ID_EOL_TYPE (coding->id);
4130 if (VECTORP (eol_type))
4131 eol_type = Qunix;
4132
004068e4 4133 setup_iso_safe_charsets (attrs);
ff0dacd7 4134 /* Charset list may have been changed. */
287c57d7 4135 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
8f924df7 4136 coding->safe_charsets = (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs));
0eecad43 4137
df7492f9 4138 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
bdd9fb48 4139
df7492f9 4140 while (charbuf < charbuf_end)
4ed46869 4141 {
df7492f9 4142 ASSURE_DESTINATION (safe_room);
b73bfc1c 4143
df7492f9 4144 if (bol_designation)
b73bfc1c 4145 {
df7492f9 4146 unsigned char *dst_prev = dst;
4ed46869 4147
bdd9fb48 4148 /* We have to produce designation sequences if any now. */
df7492f9
KH		 4149 dst = encode_designation_at_bol (coding, charbuf, charbuf_end, dst);
4150 bol_designation = 0;
4151 /* We are sure that designation sequences are all ASCII bytes. */
4152 produced_chars += dst - dst_prev;
e0e989f6
KH		 4153 }
4154
df7492f9 4155 c = *charbuf++;
ec6d2bb8 4156
ff0dacd7
KH		 4157 if (c < 0)
4158 {
4159 /* Handle an annotation. */
4160 switch (*charbuf)
ec6d2bb8 4161 {
ff0dacd7
KH		 4162 case CODING_ANNOTATE_COMPOSITION_MASK:
4163 /* Not yet implemented. */
4164 break;
4165 case CODING_ANNOTATE_CHARSET_MASK:
cf7dfdf5 4166 preferred_charset_id = charbuf[2];
ff0dacd7
KH		 4167 if (preferred_charset_id >= 0
4168 && NILP (Fmemq (make_number (preferred_charset_id),
4169 charset_list)))
4170 preferred_charset_id = -1;
4171 break;
4172 default:
4173 abort ();
4ed46869 4174 }
ff0dacd7
KH		 4175 charbuf += -c - 1;
4176 continue;
4ed46869 4177 }
ec6d2bb8 4178
b73bfc1c
KH		 4179 /* Now encode the character C. */
4180 if (c < 0x20 || c == 0x7F)
4181 {
df7492f9
KH		 4182 if (c == '\n'
4183 || (c == '\r' && EQ (eol_type, Qmac)))
19a8d9e0 4184 {
df7492f9
KH		 4185 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_EOL)
4186 ENCODE_RESET_PLANE_AND_REGISTER ();
4187 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_INIT_AT_BOL)
b73bfc1c 4188 {
df7492f9
KH		 4189 int i;
4190
4191 for (i = 0; i < 4; i++)
4192 CODING_ISO_DESIGNATION (coding, i)
4193 = CODING_ISO_INITIAL (coding, i);
b73bfc1c 4194 }
df7492f9
KH		 4195 bol_designation
4196 = CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL;
19a8d9e0 4197 }
df7492f9
KH		 4198 else if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_CNTL)
4199 ENCODE_RESET_PLANE_AND_REGISTER ();
4200 EMIT_ONE_ASCII_BYTE (c);
4ed46869 4201 }
df7492f9 4202 else if (ASCII_CHAR_P (c))
88993dfd 4203 {
df7492f9
KH		 4204 if (ascii_compatible)
4205 EMIT_ONE_ASCII_BYTE (c);
93dec019 4206 else
19a8d9e0 4207 {
bf16eb23
KH		 4208 struct charset *charset = CHARSET_FROM_ID (charset_ascii);
4209 ENCODE_ISO_CHARACTER (charset, c);
19a8d9e0 4210 }
4ed46869 4211 }
16eafb5d 4212 else if (CHAR_BYTE8_P (c))
88993dfd 4213 {
16eafb5d
KH		 4214 c = CHAR_TO_BYTE8 (c);
4215 EMIT_ONE_BYTE (c);
88993dfd 4216 }
b73bfc1c 4217 else
df7492f9 4218 {
ff0dacd7 4219 struct charset *charset;
b73bfc1c 4220
ff0dacd7
KH		 4221 if (preferred_charset_id >= 0)
4222 {
4223 charset = CHARSET_FROM_ID (preferred_charset_id);
4224 if (! CHAR_CHARSET_P (c, charset))
4225 charset = char_charset (c, charset_list, NULL);
4226 }
4227 else
4228 charset = char_charset (c, charset_list, NULL);
df7492f9
KH		 4229 if (!charset)
4230 {
41cbe562
KH		 4231 if (coding->mode & CODING_MODE_SAFE_ENCODING)
4232 {
4233 c = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
4234 charset = CHARSET_FROM_ID (charset_ascii);
4235 }
4236 else
4237 {
4238 c = coding->default_char;
4239 charset = char_charset (c, charset_list, NULL);
4240 }
df7492f9
KH		 4241 }
4242 ENCODE_ISO_CHARACTER (charset, c);
4243 }
84fbb8a0 4244 }
b73bfc1c 4245
df7492f9
KH		 4246 if (coding->mode & CODING_MODE_LAST_BLOCK
4247 && CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_EOL)
4248 {
4249 ASSURE_DESTINATION (safe_room);
4250 ENCODE_RESET_PLANE_AND_REGISTER ();
4251 }
065e3595 4252 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 4253 CODING_ISO_BOL (coding) = bol_designation;
4254 coding->produced_char += produced_chars;
4255 coding->produced = dst - coding->destination;
4256 return 0;
4ed46869
KH		 4257}
4258
4259\f
df7492f9 4260/*** 8,9. SJIS and BIG5 handlers ***/
4ed46869 4261
df7492f9 4262/* Although SJIS and BIG5 are not ISO's coding system, they are used
4ed46869
KH		 4263 quite widely. So, for the moment, Emacs supports them in the bare
4264 C code. But, in the future, they may be supported only by CCL. */
4265
4266/* SJIS is a coding system encoding three character sets: ASCII, right
4267 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
4268 as is. A character of charset katakana-jisx0201 is encoded by
4269 "position-code + 0x80". A character of charset japanese-jisx0208
4270 is encoded in 2-byte but two position-codes are divided and shifted
df7492f9 4271 so that it fit in the range below.
4ed46869
KH		 4272
4273 --- CODE RANGE of SJIS ---
4274 (character set) (range)
4275 ASCII 0x00 .. 0x7F
df7492f9 4276 KATAKANA-JISX0201 0xA0 .. 0xDF
c28a9453 4277 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
d14d03ac 4278 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
4ed46869
KH		 4279 -------------------------------
4280
4281*/
4282
4283/* BIG5 is a coding system encoding two character sets: ASCII and
4284 Big5. An ASCII character is encoded as is. Big5 is a two-byte
df7492f9 4285 character set and is encoded in two-byte.
4ed46869
KH		 4286
4287 --- CODE RANGE of BIG5 ---
4288 (character set) (range)
4289 ASCII 0x00 .. 0x7F
4290 Big5 (1st byte) 0xA1 .. 0xFE
4291 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
4292 --------------------------
4293
df7492f9 4294 */
4ed46869
KH		 4295
4296/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4297 Check if a text is encoded in SJIS. If it is, return
df7492f9 4298 CATEGORY_MASK_SJIS, else return 0. */
4ed46869 4299
0a28aafb 4300static int
ff0dacd7 4301detect_coding_sjis (coding, detect_info)
df7492f9 4302 struct coding_system *coding;
ff0dacd7 4303 struct coding_detection_info *detect_info;
4ed46869 4304{
065e3595 4305 const unsigned char *src = coding->source, *src_base;
8f924df7 4306 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 4307 int multibytep = coding->src_multibyte;
4308 int consumed_chars = 0;
4309 int found = 0;
b73bfc1c 4310 int c;
df7492f9 4311
ff0dacd7 4312 detect_info->checked |= CATEGORY_MASK_SJIS;
df7492f9
KH		 4313 /* A coding system of this category is always ASCII compatible. */
4314 src += coding->head_ascii;
4ed46869 4315
b73bfc1c 4316 while (1)
4ed46869 4317 {
065e3595 4318 src_base = src;
df7492f9 4319 ONE_MORE_BYTE (c);
682169fe
KH		 4320 if (c < 0x80)
4321 continue;
df7492f9 4322 if ((c >= 0x81 && c <= 0x9F) || (c >= 0xE0 && c <= 0xEF))
4ed46869 4323 {
df7492f9 4324 ONE_MORE_BYTE (c);
682169fe 4325 if (c < 0x40 || c == 0x7F || c > 0xFC)
df7492f9 4326 break;
ff0dacd7 4327 found = CATEGORY_MASK_SJIS;
4ed46869 4328 }
df7492f9 4329 else if (c >= 0xA0 && c < 0xE0)
ff0dacd7 4330 found = CATEGORY_MASK_SJIS;
df7492f9
KH		 4331 else
4332 break;
4ed46869 4333 }
ff0dacd7 4334 detect_info->rejected |= CATEGORY_MASK_SJIS;
df7492f9
KH		 4335 return 0;
4336
4337 no_more_source:
065e3595 4338 if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
89528eb3 4339 {
ff0dacd7 4340 detect_info->rejected |= CATEGORY_MASK_SJIS;
89528eb3 4341 return 0;
4ed46869 4342 }
ff0dacd7
KH		 4343 detect_info->found |= found;
4344 return 1;
4ed46869
KH		 4345}
4346
4347/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4348 Check if a text is encoded in BIG5. If it is, return
df7492f9 4349 CATEGORY_MASK_BIG5, else return 0. */
4ed46869 4350
0a28aafb 4351static int
ff0dacd7 4352detect_coding_big5 (coding, detect_info)
df7492f9 4353 struct coding_system *coding;
ff0dacd7 4354 struct coding_detection_info *detect_info;
4ed46869 4355{
065e3595 4356 const unsigned char *src = coding->source, *src_base;
8f924df7 4357 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 4358 int multibytep = coding->src_multibyte;
4359 int consumed_chars = 0;
4360 int found = 0;
b73bfc1c 4361 int c;
fa42c37f 4362
ff0dacd7 4363 detect_info->checked |= CATEGORY_MASK_BIG5;
df7492f9
KH		 4364 /* A coding system of this category is always ASCII compatible. */
4365 src += coding->head_ascii;
fa42c37f 4366
b73bfc1c 4367 while (1)
fa42c37f 4368 {
065e3595 4369 src_base = src;
df7492f9
KH		 4370 ONE_MORE_BYTE (c);
4371 if (c < 0x80)
fa42c37f 4372 continue;
df7492f9 4373 if (c >= 0xA1)
fa42c37f 4374 {
df7492f9
KH		 4375 ONE_MORE_BYTE (c);
4376 if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
fa42c37f 4377 return 0;
ff0dacd7 4378 found = CATEGORY_MASK_BIG5;
fa42c37f 4379 }
df7492f9
KH		 4380 else
4381 break;
fa42c37f 4382 }
ff0dacd7 4383 detect_info->rejected |= CATEGORY_MASK_BIG5;
fa42c37f 4384 return 0;
fa42c37f 4385
df7492f9 4386 no_more_source:
065e3595 4387 if (src_base < src && coding->mode & CODING_MODE_LAST_BLOCK)
89528eb3 4388 {
ff0dacd7 4389 detect_info->rejected |= CATEGORY_MASK_BIG5;
89528eb3
KH		 4390 return 0;
4391 }
ff0dacd7
KH		 4392 detect_info->found |= found;
4393 return 1;
fa42c37f
KH		 4394}
4395
4ed46869
KH		 4396/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4397 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
fa42c37f 4398
b73bfc1c 4399static void
df7492f9 4400decode_coding_sjis (coding)
4ed46869 4401 struct coding_system *coding;
4ed46869 4402{
8f924df7
KH		 4403 const unsigned char *src = coding->source + coding->consumed;
4404 const unsigned char *src_end = coding->source + coding->src_bytes;
4405 const unsigned char *src_base;
69a80ea3
KH		 4406 int *charbuf = coding->charbuf + coding->charbuf_used;
4407 int *charbuf_end
4408 = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
df7492f9
KH		 4409 int consumed_chars = 0, consumed_chars_base;
4410 int multibytep = coding->src_multibyte;
4411 struct charset *charset_roman, *charset_kanji, *charset_kana;
57a47f8a 4412 struct charset *charset_kanji2;
24a73b0a 4413 Lisp_Object attrs, charset_list, val;
ff0dacd7
KH		 4414 int char_offset = coding->produced_char;
4415 int last_offset = char_offset;
4416 int last_id = charset_ascii;
119852e7
KH		 4417 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
4418 int byte_after_cr = -1;
a5d301df 4419
24a73b0a 4420 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4421
4422 val = charset_list;
4423 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
89528eb3 4424 charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
57a47f8a
KH		 4425 charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
4426 charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
fa42c37f 4427
b73bfc1c 4428 while (1)
4ed46869 4429 {
df7492f9 4430 int c, c1;
24a73b0a 4431 struct charset *charset;
fa42c37f 4432
b73bfc1c 4433 src_base = src;
df7492f9 4434 consumed_chars_base = consumed_chars;
fa42c37f 4435
df7492f9 4436 if (charbuf >= charbuf_end)
b71f6f73
KH		 4437 {
4438 if (byte_after_cr >= 0)
4439 src_base--;
4440 break;
4441 }
df7492f9 4442
119852e7
KH		 4443 if (byte_after_cr >= 0)
4444 c = byte_after_cr, byte_after_cr = -1;
4445 else
4446 ONE_MORE_BYTE (c);
065e3595
KH		 4447 if (c < 0)
4448 goto invalid_code;
24a73b0a 4449 if (c < 0x80)
119852e7
KH		 4450 {
4451 if (eol_crlf && c == '\r')
4452 ONE_MORE_BYTE (byte_after_cr);
4453 charset = charset_roman;
4454 }
57a47f8a 4455 else if (c == 0x80 || c == 0xA0)
8e921c4b 4456 goto invalid_code;
57a47f8a
KH		 4457 else if (c >= 0xA1 && c <= 0xDF)
4458 {
4459 /* SJIS -> JISX0201-Kana */
4460 c &= 0x7F;
4461 charset = charset_kana;
4462 }
4463 else if (c <= 0xEF)
df7492f9 4464 {
57a47f8a
KH		 4465 /* SJIS -> JISX0208 */
4466 ONE_MORE_BYTE (c1);
4467 if (c1 < 0x40 || c1 == 0x7F || c1 > 0xFC)
24a73b0a 4468 goto invalid_code;
57a47f8a
KH		 4469 c = (c << 8) | c1;
4470 SJIS_TO_JIS (c);
4471 charset = charset_kanji;
4472 }
4473 else if (c <= 0xFC && charset_kanji2)
4474 {
c6876370 4475 /* SJIS -> JISX0213-2 */
57a47f8a
KH		 4476 ONE_MORE_BYTE (c1);
4477 if (c1 < 0x40 || c1 == 0x7F || c1 > 0xFC)
24a73b0a 4478 goto invalid_code;
57a47f8a
KH		 4479 c = (c << 8) | c1;
4480 SJIS_TO_JIS2 (c);
4481 charset = charset_kanji2;
df7492f9 4482 }
57a47f8a
KH		 4483 else
4484 goto invalid_code;
24a73b0a
KH		 4485 if (charset->id != charset_ascii
4486 && last_id != charset->id)
4487 {
4488 if (last_id != charset_ascii)
69a80ea3 4489 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
24a73b0a
KH		 4490 last_id = charset->id;
4491 last_offset = char_offset;
4492 }
4493 CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c, c);
df7492f9 4494 *charbuf++ = c;
ff0dacd7 4495 char_offset++;
df7492f9 4496 continue;
b73bfc1c 4497
df7492f9
KH		 4498 invalid_code:
4499 src = src_base;
4500 consumed_chars = consumed_chars_base;
4501 ONE_MORE_BYTE (c);
065e3595 4502 *charbuf++ = c < 0 ? -c : BYTE8_TO_CHAR (c);
ff0dacd7 4503 char_offset++;
df7492f9
KH		 4504 coding->errors++;
4505 }
fa42c37f 4506
df7492f9 4507 no_more_source:
ff0dacd7 4508 if (last_id != charset_ascii)
69a80ea3 4509 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
df7492f9
KH		 4510 coding->consumed_char += consumed_chars_base;
4511 coding->consumed = src_base - coding->source;
4512 coding->charbuf_used = charbuf - coding->charbuf;
fa42c37f
KH		 4513}
4514
b73bfc1c 4515static void
df7492f9 4516decode_coding_big5 (coding)
4ed46869 4517 struct coding_system *coding;
4ed46869 4518{
8f924df7
KH		 4519 const unsigned char *src = coding->source + coding->consumed;
4520 const unsigned char *src_end = coding->source + coding->src_bytes;
4521 const unsigned char *src_base;
69a80ea3
KH		 4522 int *charbuf = coding->charbuf + coding->charbuf_used;
4523 int *charbuf_end
4524 = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
df7492f9
KH		 4525 int consumed_chars = 0, consumed_chars_base;
4526 int multibytep = coding->src_multibyte;
4527 struct charset *charset_roman, *charset_big5;
24a73b0a 4528 Lisp_Object attrs, charset_list, val;
ff0dacd7
KH		 4529 int char_offset = coding->produced_char;
4530 int last_offset = char_offset;
4531 int last_id = charset_ascii;
119852e7
KH		 4532 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
4533 int byte_after_cr = -1;
df7492f9 4534
24a73b0a 4535 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4536 val = charset_list;
4537 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
4538 charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
4ed46869 4539
b73bfc1c 4540 while (1)
4ed46869 4541 {
df7492f9 4542 int c, c1;
24a73b0a 4543 struct charset *charset;
b73bfc1c
KH		 4544
4545 src_base = src;
df7492f9
KH		 4546 consumed_chars_base = consumed_chars;
4547
4548 if (charbuf >= charbuf_end)
b71f6f73
KH		 4549 {
4550 if (byte_after_cr >= 0)
4551 src_base--;
4552 break;
4553 }
df7492f9 4554
119852e7 4555 if (byte_after_cr >= 0)
14daee73 4556 c = byte_after_cr, byte_after_cr = -1;
119852e7
KH		 4557 else
4558 ONE_MORE_BYTE (c);
b73bfc1c 4559
065e3595
KH		 4560 if (c < 0)
4561 goto invalid_code;
24a73b0a 4562 if (c < 0x80)
119852e7 4563 {
14daee73 4564 if (eol_crlf && c == '\r')
119852e7
KH		 4565 ONE_MORE_BYTE (byte_after_cr);
4566 charset = charset_roman;
4567 }
24a73b0a 4568 else
4ed46869 4569 {
24a73b0a
KH		 4570 /* BIG5 -> Big5 */
4571 if (c < 0xA1 || c > 0xFE)
4572 goto invalid_code;
4573 ONE_MORE_BYTE (c1);
4574 if (c1 < 0x40 || (c1 > 0x7E && c1 < 0xA1) || c1 > 0xFE)
4575 goto invalid_code;
4576 c = c << 8 | c1;
4577 charset = charset_big5;
4ed46869 4578 }
24a73b0a
KH		 4579 if (charset->id != charset_ascii
4580 && last_id != charset->id)
df7492f9 4581 {
24a73b0a 4582 if (last_id != charset_ascii)
69a80ea3 4583 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
24a73b0a
KH		 4584 last_id = charset->id;
4585 last_offset = char_offset;
4ed46869 4586 }
24a73b0a 4587 CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, c, c);
df7492f9 4588 *charbuf++ = c;
ff0dacd7 4589 char_offset++;
fb88bf2d
KH		 4590 continue;
4591
df7492f9 4592 invalid_code:
4ed46869 4593 src = src_base;
df7492f9
KH		 4594 consumed_chars = consumed_chars_base;
4595 ONE_MORE_BYTE (c);
065e3595 4596 *charbuf++ = c < 0 ? -c : BYTE8_TO_CHAR (c);
ff0dacd7 4597 char_offset++;
df7492f9 4598 coding->errors++;
fb88bf2d 4599 }
d46c5b12 4600
df7492f9 4601 no_more_source:
ff0dacd7 4602 if (last_id != charset_ascii)
69a80ea3 4603 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
df7492f9
KH		 4604 coding->consumed_char += consumed_chars_base;
4605 coding->consumed = src_base - coding->source;
4606 coding->charbuf_used = charbuf - coding->charbuf;
4ed46869
KH		 4607}
4608
4609/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
b73bfc1c
KH		 4610 This function can encode charsets `ascii', `katakana-jisx0201',
4611 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4612 are sure that all these charsets are registered as official charset
4ed46869
KH		 4613 (i.e. do not have extended leading-codes). Characters of other
4614 charsets are produced without any encoding. If SJIS_P is 1, encode
4615 SJIS text, else encode BIG5 text. */
4616
df7492f9
KH		 4617static int
4618encode_coding_sjis (coding)
4ed46869 4619 struct coding_system *coding;
4ed46869 4620{
df7492f9
KH		 4621 int multibytep = coding->dst_multibyte;
4622 int *charbuf = coding->charbuf;
4623 int *charbuf_end = charbuf + coding->charbuf_used;
4624 unsigned char *dst = coding->destination + coding->produced;
4625 unsigned char *dst_end = coding->destination + coding->dst_bytes;
4626 int safe_room = 4;
4627 int produced_chars = 0;
24a73b0a 4628 Lisp_Object attrs, charset_list, val;
df7492f9
KH		 4629 int ascii_compatible;
4630 struct charset *charset_roman, *charset_kanji, *charset_kana;
57a47f8a 4631 struct charset *charset_kanji2;
df7492f9 4632 int c;
a5d301df 4633
24a73b0a 4634 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4635 val = charset_list;
4636 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
4637 charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
57a47f8a
KH		 4638 charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
4639 charset_kanji2 = NILP (val) ? NULL : CHARSET_FROM_ID (XINT (XCAR (val)));
4ed46869 4640
df7492f9 4641 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
93dec019 4642
df7492f9
KH		 4643 while (charbuf < charbuf_end)
4644 {
4645 ASSURE_DESTINATION (safe_room);
4646 c = *charbuf++;
b73bfc1c 4647 /* Now encode the character C. */
df7492f9
KH		 4648 if (ASCII_CHAR_P (c) && ascii_compatible)
4649 EMIT_ONE_ASCII_BYTE (c);
16eafb5d
KH		 4650 else if (CHAR_BYTE8_P (c))
4651 {
4652 c = CHAR_TO_BYTE8 (c);
4653 EMIT_ONE_BYTE (c);
4654 }
df7492f9 4655 else
b73bfc1c 4656 {
df7492f9
KH		 4657 unsigned code;
4658 struct charset *charset = char_charset (c, charset_list, &code);
4659
4660 if (!charset)
4ed46869 4661 {
41cbe562 4662 if (coding->mode & CODING_MODE_SAFE_ENCODING)
b73bfc1c 4663 {
41cbe562
KH		 4664 code = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
4665 charset = CHARSET_FROM_ID (charset_ascii);
b73bfc1c 4666 }
41cbe562 4667 else
b73bfc1c 4668 {
41cbe562
KH		 4669 c = coding->default_char;
4670 charset = char_charset (c, charset_list, &code);
b73bfc1c 4671 }
b73bfc1c 4672 }
df7492f9
KH		 4673 if (code == CHARSET_INVALID_CODE (charset))
4674 abort ();
4675 if (charset == charset_kanji)
4676 {
4677 int c1, c2;
4678 JIS_TO_SJIS (code);
4679 c1 = code >> 8, c2 = code & 0xFF;
4680 EMIT_TWO_BYTES (c1, c2);
4681 }
4682 else if (charset == charset_kana)
4683 EMIT_ONE_BYTE (code | 0x80);
57a47f8a
KH		 4684 else if (charset_kanji2 && charset == charset_kanji2)
4685 {
4686 int c1, c2;
4687
4688 c1 = code >> 8;
4689 if (c1 == 0x21 || (c1 >= 0x23 && c1 < 0x25)
4690 || (c1 >= 0x2C && c1 <= 0x2F) || c1 >= 0x6E)
4691 {
4692 JIS_TO_SJIS2 (code);
4693 c1 = code >> 8, c2 = code & 0xFF;
4694 EMIT_TWO_BYTES (c1, c2);
4695 }
4696 else
4697 EMIT_ONE_ASCII_BYTE (code & 0x7F);
4698 }
df7492f9
KH		 4699 else
4700 EMIT_ONE_ASCII_BYTE (code & 0x7F);
4701 }
4702 }
065e3595 4703 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 4704 coding->produced_char += produced_chars;
4705 coding->produced = dst - coding->destination;
4706 return 0;
4707}
4708
4709static int
4710encode_coding_big5 (coding)
4711 struct coding_system *coding;
4712{
4713 int multibytep = coding->dst_multibyte;
4714 int *charbuf = coding->charbuf;
4715 int *charbuf_end = charbuf + coding->charbuf_used;
4716 unsigned char *dst = coding->destination + coding->produced;
4717 unsigned char *dst_end = coding->destination + coding->dst_bytes;
4718 int safe_room = 4;
4719 int produced_chars = 0;
24a73b0a 4720 Lisp_Object attrs, charset_list, val;
df7492f9
KH		 4721 int ascii_compatible;
4722 struct charset *charset_roman, *charset_big5;
4723 int c;
4724
24a73b0a 4725 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4726 val = charset_list;
4727 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
4728 charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
4729 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
4730
4731 while (charbuf < charbuf_end)
4732 {
4733 ASSURE_DESTINATION (safe_room);
4734 c = *charbuf++;
4735 /* Now encode the character C. */
4736 if (ASCII_CHAR_P (c) && ascii_compatible)
4737 EMIT_ONE_ASCII_BYTE (c);
16eafb5d
KH		 4738 else if (CHAR_BYTE8_P (c))
4739 {
4740 c = CHAR_TO_BYTE8 (c);
4741 EMIT_ONE_BYTE (c);
b73bfc1c
KH		 4742 }
4743 else
4744 {
df7492f9
KH		 4745 unsigned code;
4746 struct charset *charset = char_charset (c, charset_list, &code);
4747
4748 if (! charset)
b73bfc1c 4749 {
41cbe562 4750 if (coding->mode & CODING_MODE_SAFE_ENCODING)
b73bfc1c 4751 {
41cbe562
KH		 4752 code = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
4753 charset = CHARSET_FROM_ID (charset_ascii);
b73bfc1c 4754 }
41cbe562 4755 else
0eecad43 4756 {
41cbe562
KH		 4757 c = coding->default_char;
4758 charset = char_charset (c, charset_list, &code);
0eecad43 4759 }
4ed46869 4760 }
df7492f9
KH		 4761 if (code == CHARSET_INVALID_CODE (charset))
4762 abort ();
4763 if (charset == charset_big5)
b73bfc1c 4764 {
df7492f9
KH		 4765 int c1, c2;
4766
4767 c1 = code >> 8, c2 = code & 0xFF;
4768 EMIT_TWO_BYTES (c1, c2);
b73bfc1c 4769 }
df7492f9
KH		 4770 else
4771 EMIT_ONE_ASCII_BYTE (code & 0x7F);
4ed46869 4772 }
4ed46869 4773 }
065e3595 4774 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 4775 coding->produced_char += produced_chars;
4776 coding->produced = dst - coding->destination;
4777 return 0;
4ed46869
KH		 4778}
4779
4780\f
df7492f9 4781/*** 10. CCL handlers ***/
1397dc18
KH		 4782
4783/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4784 Check if a text is encoded in a coding system of which
4785 encoder/decoder are written in CCL program. If it is, return
df7492f9 4786 CATEGORY_MASK_CCL, else return 0. */
1397dc18 4787
0a28aafb 4788static int
ff0dacd7 4789detect_coding_ccl (coding, detect_info)
df7492f9 4790 struct coding_system *coding;
ff0dacd7 4791 struct coding_detection_info *detect_info;
1397dc18 4792{
065e3595 4793 const unsigned char *src = coding->source, *src_base;
8f924df7 4794 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 4795 int multibytep = coding->src_multibyte;
4796 int consumed_chars = 0;
4797 int found = 0;
0e219d54 4798 unsigned char *valids;
df7492f9
KH		 4799 int head_ascii = coding->head_ascii;
4800 Lisp_Object attrs;
4801
ff0dacd7
KH		 4802 detect_info->checked |= CATEGORY_MASK_CCL;
4803
df7492f9 4804 coding = &coding_categories[coding_category_ccl];
0e219d54 4805 valids = CODING_CCL_VALIDS (coding);
df7492f9
KH		 4806 attrs = CODING_ID_ATTRS (coding->id);
4807 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
4808 src += head_ascii;
1397dc18 4809
b73bfc1c 4810 while (1)
1397dc18 4811 {
df7492f9 4812 int c;
065e3595
KH		 4813
4814 src_base = src;
df7492f9 4815 ONE_MORE_BYTE (c);
065e3595 4816 if (c < 0 || ! valids[c])
df7492f9 4817 break;
ff0dacd7
KH		 4818 if ((valids[c] > 1))
4819 found = CATEGORY_MASK_CCL;
df7492f9 4820 }
ff0dacd7 4821 detect_info->rejected |= CATEGORY_MASK_CCL;
df7492f9
KH		 4822 return 0;
4823
4824 no_more_source:
ff0dacd7
KH		 4825 detect_info->found |= found;
4826 return 1;
df7492f9
KH		 4827}
4828
4829static void
4830decode_coding_ccl (coding)
4831 struct coding_system *coding;
4832{
7c78e542 4833 const unsigned char *src = coding->source + coding->consumed;
8f924df7 4834 const unsigned char *src_end = coding->source + coding->src_bytes;
69a80ea3
KH		 4835 int *charbuf = coding->charbuf + coding->charbuf_used;
4836 int *charbuf_end = coding->charbuf + coding->charbuf_size;
df7492f9
KH		 4837 int consumed_chars = 0;
4838 int multibytep = coding->src_multibyte;
4839 struct ccl_program ccl;
4840 int source_charbuf[1024];
4841 int source_byteidx[1024];
24a73b0a 4842 Lisp_Object attrs, charset_list;
df7492f9 4843
24a73b0a 4844 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4845 setup_ccl_program (&ccl, CODING_CCL_DECODER (coding));
4846
4847 while (src < src_end)
4848 {
7c78e542 4849 const unsigned char *p = src;
df7492f9
KH		 4850 int *source, *source_end;
4851 int i = 0;
4852
4853 if (multibytep)
4854 while (i < 1024 && p < src_end)
4855 {
4856 source_byteidx[i] = p - src;
4857 source_charbuf[i++] = STRING_CHAR_ADVANCE (p);
4858 }
4859 else
4860 while (i < 1024 && p < src_end)
4861 source_charbuf[i++] = *p++;
8f924df7 4862
df7492f9
KH		 4863 if (p == src_end && coding->mode & CODING_MODE_LAST_BLOCK)
4864 ccl.last_block = 1;
4865
4866 source = source_charbuf;
4867 source_end = source + i;
4868 while (source < source_end)
4869 {
4870 ccl_driver (&ccl, source, charbuf,
8dcbea82
KH		 4871 source_end - source, charbuf_end - charbuf,
4872 charset_list);
df7492f9
KH		 4873 source += ccl.consumed;
4874 charbuf += ccl.produced;
4875 if (ccl.status != CCL_STAT_SUSPEND_BY_DST)
4876 break;
4877 }
4878 if (source < source_end)
4879 src += source_byteidx[source - source_charbuf];
4880 else
4881 src = p;
4882 consumed_chars += source - source_charbuf;
4883
4884 if (ccl.status != CCL_STAT_SUSPEND_BY_SRC
4885 && ccl.status != CODING_RESULT_INSUFFICIENT_SRC)
4886 break;
4887 }
4888
4889 switch (ccl.status)
4890 {
4891 case CCL_STAT_SUSPEND_BY_SRC:
065e3595 4892 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
df7492f9
KH		 4893 break;
4894 case CCL_STAT_SUSPEND_BY_DST:
4895 break;
4896 case CCL_STAT_QUIT:
4897 case CCL_STAT_INVALID_CMD:
065e3595 4898 record_conversion_result (coding, CODING_RESULT_INTERRUPT);
df7492f9
KH		 4899 break;
4900 default:
065e3595 4901 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 4902 break;
4903 }
4904 coding->consumed_char += consumed_chars;
4905 coding->consumed = src - coding->source;
4906 coding->charbuf_used = charbuf - coding->charbuf;
4907}
4908
4909static int
4910encode_coding_ccl (coding)
4911 struct coding_system *coding;
4912{
4913 struct ccl_program ccl;
4914 int multibytep = coding->dst_multibyte;
4915 int *charbuf = coding->charbuf;
4916 int *charbuf_end = charbuf + coding->charbuf_used;
4917 unsigned char *dst = coding->destination + coding->produced;
4918 unsigned char *dst_end = coding->destination + coding->dst_bytes;
df7492f9
KH		 4919 int destination_charbuf[1024];
4920 int i, produced_chars = 0;
24a73b0a 4921 Lisp_Object attrs, charset_list;
df7492f9 4922
24a73b0a 4923 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9
KH		 4924 setup_ccl_program (&ccl, CODING_CCL_ENCODER (coding));
4925
4926 ccl.last_block = coding->mode & CODING_MODE_LAST_BLOCK;
4927 ccl.dst_multibyte = coding->dst_multibyte;
4928
8cffd3e7 4929 while (charbuf < charbuf_end)
df7492f9 4930 {
df7492f9 4931 ccl_driver (&ccl, charbuf, destination_charbuf,
8cffd3e7 4932 charbuf_end - charbuf, 1024, charset_list);
df7492f9 4933 if (multibytep)
8cffd3e7
KH		 4934 {
4935 ASSURE_DESTINATION (ccl.produced * 2);
4936 for (i = 0; i < ccl.produced; i++)
4937 EMIT_ONE_BYTE (destination_charbuf[i] & 0xFF);
4938 }
df7492f9
KH		 4939 else
4940 {
8cffd3e7 4941 ASSURE_DESTINATION (ccl.produced);
3ed051d4 4942 for (i = 0; i < ccl.produced; i++)
df7492f9
KH		 4943 *dst++ = destination_charbuf[i] & 0xFF;
4944 produced_chars += ccl.produced;
4945 }
8cffd3e7
KH		 4946 charbuf += ccl.consumed;
4947 if (ccl.status == CCL_STAT_QUIT
4948 || ccl.status == CCL_STAT_INVALID_CMD)
4949 break;
df7492f9
KH		 4950 }
4951
4952 switch (ccl.status)
4953 {
4954 case CCL_STAT_SUSPEND_BY_SRC:
065e3595 4955 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
df7492f9
KH		 4956 break;
4957 case CCL_STAT_SUSPEND_BY_DST:
065e3595 4958 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_DST);
df7492f9
KH		 4959 break;
4960 case CCL_STAT_QUIT:
4961 case CCL_STAT_INVALID_CMD:
065e3595 4962 record_conversion_result (coding, CODING_RESULT_INTERRUPT);
df7492f9
KH		 4963 break;
4964 default:
065e3595 4965 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9 4966 break;
1397dc18 4967 }
df7492f9
KH		 4968
4969 coding->produced_char += produced_chars;
4970 coding->produced = dst - coding->destination;
4971 return 0;
1397dc18
KH		 4972}
4973
df7492f9 4974
1397dc18 4975\f
df7492f9 4976/*** 10, 11. no-conversion handlers ***/
4ed46869 4977
b73bfc1c 4978/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4ed46869 4979
b73bfc1c 4980static void
df7492f9 4981decode_coding_raw_text (coding)
4ed46869 4982 struct coding_system *coding;
4ed46869 4983{
119852e7
KH		 4984 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
4985
df7492f9 4986 coding->chars_at_source = 1;
119852e7
KH		 4987 coding->consumed_char = coding->src_chars;
4988 coding->consumed = coding->src_bytes;
4989 if (eol_crlf && coding->source[coding->src_bytes - 1] == '\r')
4990 {
4991 coding->consumed_char--;
4992 coding->consumed--;
4993 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
4994 }
4995 else
4996 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9 4997}
4ed46869 4998
df7492f9
KH		 4999static int
5000encode_coding_raw_text (coding)
5001 struct coding_system *coding;
5002{
5003 int multibytep = coding->dst_multibyte;
5004 int *charbuf = coding->charbuf;
5005 int *charbuf_end = coding->charbuf + coding->charbuf_used;
5006 unsigned char *dst = coding->destination + coding->produced;
5007 unsigned char *dst_end = coding->destination + coding->dst_bytes;
a0ed9b27 5008 int produced_chars = 0;
b73bfc1c
KH		 5009 int c;
5010
df7492f9 5011 if (multibytep)
b73bfc1c 5012 {
df7492f9 5013 int safe_room = MAX_MULTIBYTE_LENGTH * 2;
4ed46869 5014
df7492f9
KH		 5015 if (coding->src_multibyte)
5016 while (charbuf < charbuf_end)
5017 {
5018 ASSURE_DESTINATION (safe_room);
5019 c = *charbuf++;
5020 if (ASCII_CHAR_P (c))
5021 EMIT_ONE_ASCII_BYTE (c);
5022 else if (CHAR_BYTE8_P (c))
5023 {
5024 c = CHAR_TO_BYTE8 (c);
5025 EMIT_ONE_BYTE (c);
5026 }
5027 else
5028 {
5029 unsigned char str[MAX_MULTIBYTE_LENGTH], *p0 = str, *p1 = str;
93dec019 5030
df7492f9
KH		 5031 CHAR_STRING_ADVANCE (c, p1);
5032 while (p0 < p1)
9d123124
KH		 5033 {
5034 EMIT_ONE_BYTE (*p0);
5035 p0++;
5036 }
df7492f9
KH		 5037 }
5038 }
b73bfc1c 5039 else
df7492f9
KH		 5040 while (charbuf < charbuf_end)
5041 {
5042 ASSURE_DESTINATION (safe_room);
5043 c = *charbuf++;
5044 EMIT_ONE_BYTE (c);
5045 }
5046 }
5047 else
4ed46869 5048 {
df7492f9 5049 if (coding->src_multibyte)
d46c5b12 5050 {
df7492f9
KH		 5051 int safe_room = MAX_MULTIBYTE_LENGTH;
5052
5053 while (charbuf < charbuf_end)
d46c5b12 5054 {
df7492f9
KH		 5055 ASSURE_DESTINATION (safe_room);
5056 c = *charbuf++;
5057 if (ASCII_CHAR_P (c))
5058 *dst++ = c;
5059 else if (CHAR_BYTE8_P (c))
5060 *dst++ = CHAR_TO_BYTE8 (c);
b73bfc1c 5061 else
df7492f9 5062 CHAR_STRING_ADVANCE (c, dst);
d46c5b12
KH		 5063 }
5064 }
df7492f9
KH		 5065 else
5066 {
5067 ASSURE_DESTINATION (charbuf_end - charbuf);
5068 while (charbuf < charbuf_end && dst < dst_end)
5069 *dst++ = *charbuf++;
8f924df7 5070 }
319a3947 5071 produced_chars = dst - (coding->destination + coding->produced);
4ed46869 5072 }
065e3595 5073 record_conversion_result (coding, CODING_RESULT_SUCCESS);
a0ed9b27 5074 coding->produced_char += produced_chars;
df7492f9
KH		 5075 coding->produced = dst - coding->destination;
5076 return 0;
4ed46869
KH		 5077}
5078
ff0dacd7
KH		 5079/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5080 Check if a text is encoded in a charset-based coding system. If it
5081 is, return 1, else return 0. */
5082
0a28aafb 5083static int
ff0dacd7 5084detect_coding_charset (coding, detect_info)
df7492f9 5085 struct coding_system *coding;
ff0dacd7 5086 struct coding_detection_info *detect_info;
1397dc18 5087{
065e3595 5088 const unsigned char *src = coding->source, *src_base;
8f924df7 5089 const unsigned char *src_end = coding->source + coding->src_bytes;
df7492f9
KH		 5090 int multibytep = coding->src_multibyte;
5091 int consumed_chars = 0;
07295713 5092 Lisp_Object attrs, valids, name;
584948ac 5093 int found = 0;
716b3fa0 5094 int head_ascii = coding->head_ascii;
07295713 5095 int check_latin_extra = 0;
1397dc18 5096
ff0dacd7
KH		 5097 detect_info->checked |= CATEGORY_MASK_CHARSET;
5098
df7492f9
KH		 5099 coding = &coding_categories[coding_category_charset];
5100 attrs = CODING_ID_ATTRS (coding->id);
5101 valids = AREF (attrs, coding_attr_charset_valids);
07295713
KH		 5102 name = CODING_ID_NAME (coding->id);
5103 if (VECTORP (Vlatin_extra_code_table)
5104 && strcmp ((char *) SDATA (SYMBOL_NAME (name)), "iso-8859-"))
5105 check_latin_extra = 1;
df7492f9 5106 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
716b3fa0 5107 src += head_ascii;
1397dc18 5108
b73bfc1c 5109 while (1)
1397dc18 5110 {
df7492f9 5111 int c;
716b3fa0
KH		 5112 Lisp_Object val;
5113 struct charset *charset;
5114 int dim, idx;
1397dc18 5115
065e3595 5116 src_base = src;
df7492f9 5117 ONE_MORE_BYTE (c);
065e3595
KH		 5118 if (c < 0)
5119 continue;
716b3fa0
KH		 5120 val = AREF (valids, c);
5121 if (NILP (val))
df7492f9 5122 break;
584948ac 5123 if (c >= 0x80)
07295713
KH		 5124 {
5125 if (c < 0xA0
5126 && check_latin_extra
5127 && NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
5128 break;
5129 found = CATEGORY_MASK_CHARSET;
5130 }
716b3fa0
KH		 5131 if (INTEGERP (val))
5132 {
5133 charset = CHARSET_FROM_ID (XFASTINT (val));
5134 dim = CHARSET_DIMENSION (charset);
5135 for (idx = 1; idx < dim; idx++)
5136 {
5137 if (src == src_end)
5138 goto too_short;
5139 ONE_MORE_BYTE (c);
3ed051d4 5140 if (c < charset->code_space[(dim - 1 - idx) * 2]
716b3fa0
KH		 5141 || c > charset->code_space[(dim - 1 - idx) * 2 + 1])
5142 break;
5143 }
5144 if (idx < dim)
5145 break;
5146 }
5147 else
5148 {
5149 idx = 1;
5150 for (; CONSP (val); val = XCDR (val))
5151 {
5152 charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
5153 dim = CHARSET_DIMENSION (charset);
5154 while (idx < dim)
5155 {
5156 if (src == src_end)
5157 goto too_short;
5158 ONE_MORE_BYTE (c);
5159 if (c < charset->code_space[(dim - 1 - idx) * 4]
5160 || c > charset->code_space[(dim - 1 - idx) * 4 + 1])
5161 break;
5162 idx++;
5163 }
5164 if (idx == dim)
5165 {
5166 val = Qnil;
5167 break;
5168 }
5169 }
5170 if (CONSP (val))
5171 break;
5172 }
df7492f9 5173 }
716b3fa0 5174 too_short:
ff0dacd7 5175 detect_info->rejected |= CATEGORY_MASK_CHARSET;
df7492f9 5176 return 0;
4ed46869 5177
df7492f9 5178 no_more_source:
ff0dacd7
KH		 5179 detect_info->found |= found;
5180 return 1;
df7492f9 5181}
b73bfc1c 5182
b73bfc1c 5183static void
df7492f9 5184decode_coding_charset (coding)
4ed46869 5185 struct coding_system *coding;
4ed46869 5186{
8f924df7
KH		 5187 const unsigned char *src = coding->source + coding->consumed;
5188 const unsigned char *src_end = coding->source + coding->src_bytes;
5189 const unsigned char *src_base;
69a80ea3
KH		 5190 int *charbuf = coding->charbuf + coding->charbuf_used;
5191 int *charbuf_end
5192 = coding->charbuf + coding->charbuf_size - MAX_ANNOTATION_LENGTH;
df7492f9
KH		 5193 int consumed_chars = 0, consumed_chars_base;
5194 int multibytep = coding->src_multibyte;
24a73b0a 5195 Lisp_Object attrs, charset_list, valids;
ff0dacd7
KH		 5196 int char_offset = coding->produced_char;
5197 int last_offset = char_offset;
5198 int last_id = charset_ascii;
119852e7
KH		 5199 int eol_crlf = EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
5200 int byte_after_cr = -1;
df7492f9 5201
24a73b0a 5202 CODING_GET_INFO (coding, attrs, charset_list);
4eb6d3f1 5203 valids = AREF (attrs, coding_attr_charset_valids);
b73bfc1c 5204
df7492f9 5205 while (1)
4ed46869 5206 {
4eb6d3f1 5207 int c;
24a73b0a
KH		 5208 Lisp_Object val;
5209 struct charset *charset;
5210 int dim;
5211 int len = 1;
5212 unsigned code;
df7492f9
KH		 5213
5214 src_base = src;
5215 consumed_chars_base = consumed_chars;
b73bfc1c 5216
df7492f9 5217 if (charbuf >= charbuf_end)
b71f6f73
KH		 5218 {
5219 if (byte_after_cr >= 0)
5220 src_base--;
5221 break;
5222 }
df7492f9 5223
119852e7
KH		 5224 if (byte_after_cr >= 0)
5225 {
5226 c = byte_after_cr;
5227 byte_after_cr = -1;
5228 }
5229 else
5230 {
5231 ONE_MORE_BYTE (c);
5232 if (eol_crlf && c == '\r')
5233 ONE_MORE_BYTE (byte_after_cr);
5234 }
065e3595
KH		 5235 if (c < 0)
5236 goto invalid_code;
24a73b0a
KH		 5237 code = c;
5238
5239 val = AREF (valids, c);
1b17adfd 5240 if (! INTEGERP (val) && ! CONSP (val))
24a73b0a
KH		 5241 goto invalid_code;
5242 if (INTEGERP (val))
d46c5b12 5243 {
24a73b0a
KH		 5244 charset = CHARSET_FROM_ID (XFASTINT (val));
5245 dim = CHARSET_DIMENSION (charset);
5246 while (len < dim)
b73bfc1c 5247 {
24a73b0a
KH		 5248 ONE_MORE_BYTE (c);
5249 code = (code << 8) | c;
5250 len++;
b73bfc1c 5251 }
24a73b0a
KH		 5252 CODING_DECODE_CHAR (coding, src, src_base, src_end,
5253 charset, code, c);
d46c5b12 5254 }
df7492f9 5255 else
d46c5b12 5256 {
24a73b0a
KH		 5257 /* VAL is a list of charset IDs. It is assured that the
5258 list is sorted by charset dimensions (smaller one
5259 comes first). */
5260 while (CONSP (val))
4eb6d3f1 5261 {
24a73b0a 5262 charset = CHARSET_FROM_ID (XFASTINT (XCAR (val)));
c7c66a95 5263 dim = CHARSET_DIMENSION (charset);
f9d71dcd 5264 while (len < dim)
4eb6d3f1 5265 {
acb2a965
KH		 5266 ONE_MORE_BYTE (c);
5267 code = (code << 8) | c;
f9d71dcd 5268 len++;
4eb6d3f1 5269 }
24a73b0a
KH		 5270 CODING_DECODE_CHAR (coding, src, src_base,
5271 src_end, charset, code, c);
5272 if (c >= 0)
5273 break;
5274 val = XCDR (val);
ff0dacd7 5275 }
d46c5b12 5276 }
24a73b0a
KH		 5277 if (c < 0)
5278 goto invalid_code;
5279 if (charset->id != charset_ascii
5280 && last_id != charset->id)
5281 {
5282 if (last_id != charset_ascii)
69a80ea3 5283 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
24a73b0a
KH		 5284 last_id = charset->id;
5285 last_offset = char_offset;
5286 }
5287
df7492f9 5288 *charbuf++ = c;
ff0dacd7 5289 char_offset++;
df7492f9
KH		 5290 continue;
5291
5292 invalid_code:
5293 src = src_base;
5294 consumed_chars = consumed_chars_base;
5295 ONE_MORE_BYTE (c);
065e3595 5296 *charbuf++ = c < 0 ? -c : ASCII_BYTE_P (c) ? c : BYTE8_TO_CHAR (c);
ff0dacd7 5297 char_offset++;
df7492f9 5298 coding->errors++;
4ed46869
KH		 5299 }
5300
df7492f9 5301 no_more_source:
ff0dacd7 5302 if (last_id != charset_ascii)
69a80ea3 5303 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id);
df7492f9
KH		 5304 coding->consumed_char += consumed_chars_base;
5305 coding->consumed = src_base - coding->source;
5306 coding->charbuf_used = charbuf - coding->charbuf;
4ed46869
KH		 5307}
5308
df7492f9
KH		 5309static int
5310encode_coding_charset (coding)
4ed46869 5311 struct coding_system *coding;
4ed46869 5312{
df7492f9
KH		 5313 int multibytep = coding->dst_multibyte;
5314 int *charbuf = coding->charbuf;
5315 int *charbuf_end = charbuf + coding->charbuf_used;
5316 unsigned char *dst = coding->destination + coding->produced;
5317 unsigned char *dst_end = coding->destination + coding->dst_bytes;
5318 int safe_room = MAX_MULTIBYTE_LENGTH;
5319 int produced_chars = 0;
24a73b0a 5320 Lisp_Object attrs, charset_list;
df7492f9 5321 int ascii_compatible;
b73bfc1c 5322 int c;
b73bfc1c 5323
24a73b0a 5324 CODING_GET_INFO (coding, attrs, charset_list);
df7492f9 5325 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
fb88bf2d 5326
df7492f9 5327 while (charbuf < charbuf_end)
4ed46869 5328 {
4eb6d3f1 5329 struct charset *charset;
df7492f9 5330 unsigned code;
8f924df7 5331
df7492f9
KH		 5332 ASSURE_DESTINATION (safe_room);
5333 c = *charbuf++;
5334 if (ascii_compatible && ASCII_CHAR_P (c))
5335 EMIT_ONE_ASCII_BYTE (c);
16eafb5d 5336 else if (CHAR_BYTE8_P (c))
4ed46869 5337 {
16eafb5d
KH		 5338 c = CHAR_TO_BYTE8 (c);
5339 EMIT_ONE_BYTE (c);
d46c5b12 5340 }
d46c5b12 5341 else
b73bfc1c 5342 {
4eb6d3f1
KH		 5343 charset = char_charset (c, charset_list, &code);
5344 if (charset)
5345 {
5346 if (CHARSET_DIMENSION (charset) == 1)
5347 EMIT_ONE_BYTE (code);
5348 else if (CHARSET_DIMENSION (charset) == 2)
5349 EMIT_TWO_BYTES (code >> 8, code & 0xFF);
5350 else if (CHARSET_DIMENSION (charset) == 3)
5351 EMIT_THREE_BYTES (code >> 16, (code >> 8) & 0xFF, code & 0xFF);
5352 else
5353 EMIT_FOUR_BYTES (code >> 24, (code >> 16) & 0xFF,
5354 (code >> 8) & 0xFF, code & 0xFF);
5355 }
5356 else
41cbe562
KH		 5357 {
5358 if (coding->mode & CODING_MODE_SAFE_ENCODING)
5359 c = CODING_INHIBIT_CHARACTER_SUBSTITUTION;
5360 else
5361 c = coding->default_char;
5362 EMIT_ONE_BYTE (c);
5363 }
4ed46869 5364 }
4ed46869
KH		 5365 }
5366
065e3595 5367 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9
KH		 5368 coding->produced_char += produced_chars;
5369 coding->produced = dst - coding->destination;
5370 return 0;
4ed46869
KH		 5371}
5372
5373\f
1397dc18 5374/*** 7. C library functions ***/
4ed46869 5375
df7492f9
KH		 5376/* Setup coding context CODING from information about CODING_SYSTEM.
5377 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
5378 CODING_SYSTEM is invalid, signal an error. */
4ed46869 5379
ec6d2bb8 5380void
e0e989f6
KH		 5381setup_coding_system (coding_system, coding)
5382 Lisp_Object coding_system;
4ed46869
KH		 5383 struct coding_system *coding;
5384{
df7492f9
KH		 5385 Lisp_Object attrs;
5386 Lisp_Object eol_type;
5387 Lisp_Object coding_type;
4608c386 5388 Lisp_Object val;
4ed46869 5389
df7492f9 5390 if (NILP (coding_system))
ae6f73fa 5391 coding_system = Qundecided;
c07c8e12 5392
df7492f9 5393 CHECK_CODING_SYSTEM_GET_ID (coding_system, coding->id);
1f5dbf34 5394
df7492f9
KH		 5395 attrs = CODING_ID_ATTRS (coding->id);
5396 eol_type = CODING_ID_EOL_TYPE (coding->id);
1f5dbf34 5397
df7492f9
KH		 5398 coding->mode = 0;
5399 coding->head_ascii = -1;
4a015c45
KH		 5400 if (VECTORP (eol_type))
5401 coding->common_flags = (CODING_REQUIRE_DECODING_MASK
5402 | CODING_REQUIRE_DETECTION_MASK);
5403 else if (! EQ (eol_type, Qunix))
5404 coding->common_flags = (CODING_REQUIRE_DECODING_MASK
5405 | CODING_REQUIRE_ENCODING_MASK);
5406 else
5407 coding->common_flags = 0;
5e5c78be
KH		 5408 if (! NILP (CODING_ATTR_POST_READ (attrs)))
5409 coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
5410 if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
5411 coding->common_flags |= CODING_REQUIRE_ENCODING_MASK;
8f924df7
KH		 5412 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs)))
5413 coding->common_flags |= CODING_FOR_UNIBYTE_MASK;
1f5dbf34 5414
df7492f9 5415 val = CODING_ATTR_SAFE_CHARSETS (attrs);
8f924df7
KH		 5416 coding->max_charset_id = SCHARS (val) - 1;
5417 coding->safe_charsets = (char *) SDATA (val);
df7492f9 5418 coding->default_char = XINT (CODING_ATTR_DEFAULT_CHAR (attrs));
4608c386 5419
df7492f9
KH		 5420 coding_type = CODING_ATTR_TYPE (attrs);
5421 if (EQ (coding_type, Qundecided))
d46c5b12 5422 {
df7492f9
KH		 5423 coding->detector = NULL;
5424 coding->decoder = decode_coding_raw_text;
5425 coding->encoder = encode_coding_raw_text;
5426 coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
d46c5b12 5427 }
df7492f9 5428 else if (EQ (coding_type, Qiso_2022))
d46c5b12 5429 {
df7492f9
KH		 5430 int i;
5431 int flags = XINT (AREF (attrs, coding_attr_iso_flags));
5432
5433 /* Invoke graphic register 0 to plane 0. */
5434 CODING_ISO_INVOCATION (coding, 0) = 0;
5435 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
5436 CODING_ISO_INVOCATION (coding, 1)
5437 = (flags & CODING_ISO_FLAG_SEVEN_BITS ? -1 : 1);
5438 /* Setup the initial status of designation. */
5439 for (i = 0; i < 4; i++)
5440 CODING_ISO_DESIGNATION (coding, i) = CODING_ISO_INITIAL (coding, i);
5441 /* Not single shifting initially. */
5442 CODING_ISO_SINGLE_SHIFTING (coding) = 0;
5443 /* Beginning of buffer should also be regarded as bol. */
5444 CODING_ISO_BOL (coding) = 1;
5445 coding->detector = detect_coding_iso_2022;
5446 coding->decoder = decode_coding_iso_2022;
5447 coding->encoder = encode_coding_iso_2022;
5448 if (flags & CODING_ISO_FLAG_SAFE)
5449 coding->mode |= CODING_MODE_SAFE_ENCODING;
d46c5b12 5450 coding->common_flags
df7492f9
KH		 5451 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK
5452 | CODING_REQUIRE_FLUSHING_MASK);
5453 if (flags & CODING_ISO_FLAG_COMPOSITION)
5454 coding->common_flags |= CODING_ANNOTATE_COMPOSITION_MASK;
ff0dacd7
KH		 5455 if (flags & CODING_ISO_FLAG_DESIGNATION)
5456 coding->common_flags |= CODING_ANNOTATE_CHARSET_MASK;
df7492f9
KH		 5457 if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
5458 {
5459 setup_iso_safe_charsets (attrs);
5460 val = CODING_ATTR_SAFE_CHARSETS (attrs);
8f924df7
KH		 5461 coding->max_charset_id = SCHARS (val) - 1;
5462 coding->safe_charsets = (char *) SDATA (val);
df7492f9
KH		 5463 }
5464 CODING_ISO_FLAGS (coding) = flags;
d46c5b12 5465 }
df7492f9 5466 else if (EQ (coding_type, Qcharset))
d46c5b12 5467 {
df7492f9
KH		 5468 coding->detector = detect_coding_charset;
5469 coding->decoder = decode_coding_charset;
5470 coding->encoder = encode_coding_charset;
d46c5b12 5471 coding->common_flags
df7492f9 5472 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
d46c5b12 5473 }
df7492f9 5474 else if (EQ (coding_type, Qutf_8))
d46c5b12 5475 {
a470d443
KH		 5476 val = AREF (attrs, coding_attr_utf_bom);
5477 CODING_UTF_8_BOM (coding) = (CONSP (val) ? utf_detect_bom
5478 : EQ (val, Qt) ? utf_with_bom
5479 : utf_without_bom);
df7492f9
KH		 5480 coding->detector = detect_coding_utf_8;
5481 coding->decoder = decode_coding_utf_8;
5482 coding->encoder = encode_coding_utf_8;
5483 coding->common_flags
5484 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
a470d443
KH		 5485 if (CODING_UTF_8_BOM (coding) == utf_detect_bom)
5486 coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
df7492f9
KH		 5487 }
5488 else if (EQ (coding_type, Qutf_16))
5489 {
a470d443
KH		 5490 val = AREF (attrs, coding_attr_utf_bom);
5491 CODING_UTF_16_BOM (coding) = (CONSP (val) ? utf_detect_bom
5492 : EQ (val, Qt) ? utf_with_bom
5493 : utf_without_bom);
df7492f9 5494 val = AREF (attrs, coding_attr_utf_16_endian);
b49a1807 5495 CODING_UTF_16_ENDIAN (coding) = (EQ (val, Qbig) ? utf_16_big_endian
df7492f9 5496 : utf_16_little_endian);
e19c3639 5497 CODING_UTF_16_SURROGATE (coding) = 0;
df7492f9
KH		 5498 coding->detector = detect_coding_utf_16;
5499 coding->decoder = decode_coding_utf_16;
5500 coding->encoder = encode_coding_utf_16;
5501 coding->common_flags
5502 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
a470d443 5503 if (CODING_UTF_16_BOM (coding) == utf_detect_bom)
b49a1807 5504 coding->common_flags |= CODING_REQUIRE_DETECTION_MASK;
d46c5b12 5505 }
df7492f9 5506 else if (EQ (coding_type, Qccl))
4ed46869 5507 {
df7492f9
KH		 5508 coding->detector = detect_coding_ccl;
5509 coding->decoder = decode_coding_ccl;
5510 coding->encoder = encode_coding_ccl;
c952af22 5511 coding->common_flags
df7492f9
KH		 5512 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK
5513 | CODING_REQUIRE_FLUSHING_MASK);
5514 }
5515 else if (EQ (coding_type, Qemacs_mule))
5516 {
5517 coding->detector = detect_coding_emacs_mule;
5518 coding->decoder = decode_coding_emacs_mule;
5519 coding->encoder = encode_coding_emacs_mule;
c952af22 5520 coding->common_flags
df7492f9
KH		 5521 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
5522 if (! NILP (AREF (attrs, coding_attr_emacs_mule_full))
5523 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs), Vemacs_mule_charset_list))
5524 {
5525 Lisp_Object tail, safe_charsets;
5526 int max_charset_id = 0;
5527
5528 for (tail = Vemacs_mule_charset_list; CONSP (tail);
5529 tail = XCDR (tail))
5530 if (max_charset_id < XFASTINT (XCAR (tail)))
5531 max_charset_id = XFASTINT (XCAR (tail));
5532 safe_charsets = Fmake_string (make_number (max_charset_id + 1),
5533 make_number (255));
5534 for (tail = Vemacs_mule_charset_list; CONSP (tail);
5535 tail = XCDR (tail))
8f924df7 5536 SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
df7492f9 5537 coding->max_charset_id = max_charset_id;
8f924df7 5538 coding->safe_charsets = (char *) SDATA (safe_charsets);
df7492f9
KH		 5539 }
5540 }
5541 else if (EQ (coding_type, Qshift_jis))
5542 {
5543 coding->detector = detect_coding_sjis;
5544 coding->decoder = decode_coding_sjis;
5545 coding->encoder = encode_coding_sjis;
c952af22 5546 coding->common_flags
df7492f9
KH		 5547 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
5548 }
5549 else if (EQ (coding_type, Qbig5))
5550 {
5551 coding->detector = detect_coding_big5;
5552 coding->decoder = decode_coding_big5;
5553 coding->encoder = encode_coding_big5;
c952af22 5554 coding->common_flags
df7492f9
KH		 5555 |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK);
5556 }
5557 else /* EQ (coding_type, Qraw_text) */
ec6d2bb8 5558 {
df7492f9
KH		 5559 coding->detector = NULL;
5560 coding->decoder = decode_coding_raw_text;
5561 coding->encoder = encode_coding_raw_text;
ea29edf2
KH		 5562 if (! EQ (eol_type, Qunix))
5563 {
5564 coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
5565 if (! VECTORP (eol_type))
5566 coding->common_flags |= CODING_REQUIRE_ENCODING_MASK;
5567 }
5568
4ed46869 5569 }
4ed46869 5570
df7492f9 5571 return;
4ed46869
KH		 5572}
5573
0ff61e78
KH		 5574/* Return a list of charsets supported by CODING. */
5575
5576Lisp_Object
5577coding_charset_list (coding)
5578 struct coding_system *coding;
5579{
35befdaa 5580 Lisp_Object attrs, charset_list;
0ff61e78
KH		 5581
5582 CODING_GET_INFO (coding, attrs, charset_list);
5583 if (EQ (CODING_ATTR_TYPE (attrs), Qiso_2022))
5584 {
5585 int flags = XINT (AREF (attrs, coding_attr_iso_flags));
5586
5587 if (flags & CODING_ISO_FLAG_FULL_SUPPORT)
5588 charset_list = Viso_2022_charset_list;
5589 }
5590 else if (EQ (CODING_ATTR_TYPE (attrs), Qemacs_mule))
5591 {
5592 charset_list = Vemacs_mule_charset_list;
5593 }
5594 return charset_list;
5595}
5596
5597
df7492f9
KH		 5598/* Return raw-text or one of its subsidiaries that has the same
5599 eol_type as CODING-SYSTEM. */
ec6d2bb8 5600
df7492f9
KH		 5601Lisp_Object
5602raw_text_coding_system (coding_system)
5603 Lisp_Object coding_system;
ec6d2bb8 5604{
0be8721c 5605 Lisp_Object spec, attrs;
df7492f9 5606 Lisp_Object eol_type, raw_text_eol_type;
ec6d2bb8 5607
d3e4cb56
KH		 5608 if (NILP (coding_system))
5609 return Qraw_text;
df7492f9
KH		 5610 spec = CODING_SYSTEM_SPEC (coding_system);
5611 attrs = AREF (spec, 0);
ec6d2bb8 5612
df7492f9
KH		 5613 if (EQ (CODING_ATTR_TYPE (attrs), Qraw_text))
5614 return coding_system;
ec6d2bb8 5615
df7492f9
KH		 5616 eol_type = AREF (spec, 2);
5617 if (VECTORP (eol_type))
5618 return Qraw_text;
5619 spec = CODING_SYSTEM_SPEC (Qraw_text);
5620 raw_text_eol_type = AREF (spec, 2);
5621 return (EQ (eol_type, Qunix) ? AREF (raw_text_eol_type, 0)
5622 : EQ (eol_type, Qdos) ? AREF (raw_text_eol_type, 1)
5623 : AREF (raw_text_eol_type, 2));
ec6d2bb8
KH		 5624}
5625
54f78171 5626
df7492f9
KH		 5627/* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5628 does, return one of the subsidiary that has the same eol-spec as
fcbcfb64
KH		 5629 PARENT. Otherwise, return CODING_SYSTEM. If PARENT is nil,
5630 inherit end-of-line format from the system's setting
5631 (system_eol_type). */
df7492f9
KH		 5632
5633Lisp_Object
5634coding_inherit_eol_type (coding_system, parent)
b74e4686 5635 Lisp_Object coding_system, parent;
54f78171 5636{
3e139625 5637 Lisp_Object spec, eol_type;
54f78171 5638
d3e4cb56
KH		 5639 if (NILP (coding_system))
5640 coding_system = Qraw_text;
df7492f9 5641 spec = CODING_SYSTEM_SPEC (coding_system);
df7492f9 5642 eol_type = AREF (spec, 2);
fcbcfb64 5643 if (VECTORP (eol_type))
df7492f9 5644 {
df7492f9
KH		 5645 Lisp_Object parent_eol_type;
5646
fcbcfb64
KH		 5647 if (! NILP (parent))
5648 {
5649 Lisp_Object parent_spec;
5650
4a015c45 5651 parent_spec = CODING_SYSTEM_SPEC (parent);
fcbcfb64
KH		 5652 parent_eol_type = AREF (parent_spec, 2);
5653 }
5654 else
5655 parent_eol_type = system_eol_type;
df7492f9
KH		 5656 if (EQ (parent_eol_type, Qunix))
5657 coding_system = AREF (eol_type, 0);
5658 else if (EQ (parent_eol_type, Qdos))
5659 coding_system = AREF (eol_type, 1);
5660 else if (EQ (parent_eol_type, Qmac))
5661 coding_system = AREF (eol_type, 2);
54f78171 5662 }
df7492f9 5663 return coding_system;
54f78171
KH		 5664}
5665
4ed46869
KH		 5666/* Emacs has a mechanism to automatically detect a coding system if it
5667 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5668 it's impossible to distinguish some coding systems accurately
5669 because they use the same range of codes. So, at first, coding
5670 systems are categorized into 7, those are:
5671
0ef69138 5672 o coding-category-emacs-mule
4ed46869
KH		 5673
5674 The category for a coding system which has the same code range
5675 as Emacs' internal format. Assigned the coding-system (Lisp
0ef69138 5676 symbol) `emacs-mule' by default.
4ed46869
KH		 5677
5678 o coding-category-sjis
5679
5680 The category for a coding system which has the same code range
5681 as SJIS. Assigned the coding-system (Lisp
7717c392 5682 symbol) `japanese-shift-jis' by default.
4ed46869
KH		 5683
5684 o coding-category-iso-7
5685
5686 The category for a coding system which has the same code range
7717c392 5687 as ISO2022 of 7-bit environment. This doesn't use any locking
d46c5b12
KH		 5688 shift and single shift functions. This can encode/decode all
5689 charsets. Assigned the coding-system (Lisp symbol)
5690 `iso-2022-7bit' by default.
5691
5692 o coding-category-iso-7-tight
5693
5694 Same as coding-category-iso-7 except that this can
5695 encode/decode only the specified charsets.
4ed46869
KH		 5696
5697 o coding-category-iso-8-1
5698
5699 The category for a coding system which has the same code range
5700 as ISO2022 of 8-bit environment and graphic plane 1 used only
7717c392
KH		 5701 for DIMENSION1 charset. This doesn't use any locking shift
5702 and single shift functions. Assigned the coding-system (Lisp
5703 symbol) `iso-latin-1' by default.
4ed46869
KH		 5704
5705 o coding-category-iso-8-2
5706
5707 The category for a coding system which has the same code range
5708 as ISO2022 of 8-bit environment and graphic plane 1 used only
7717c392
KH		 5709 for DIMENSION2 charset. This doesn't use any locking shift
5710 and single shift functions. Assigned the coding-system (Lisp
5711 symbol) `japanese-iso-8bit' by default.
4ed46869 5712
7717c392 5713 o coding-category-iso-7-else
4ed46869
KH		 5714
5715 The category for a coding system which has the same code range
df7492f9 5716 as ISO2022 of 7-bit environemnt but uses locking shift or
7717c392
KH		 5717 single shift functions. Assigned the coding-system (Lisp
5718 symbol) `iso-2022-7bit-lock' by default.
5719
5720 o coding-category-iso-8-else
5721
5722 The category for a coding system which has the same code range
df7492f9 5723 as ISO2022 of 8-bit environemnt but uses locking shift or
7717c392
KH		 5724 single shift functions. Assigned the coding-system (Lisp
5725 symbol) `iso-2022-8bit-ss2' by default.
4ed46869
KH		 5726
5727 o coding-category-big5
5728
5729 The category for a coding system which has the same code range
5730 as BIG5. Assigned the coding-system (Lisp symbol)
e0e989f6 5731 `cn-big5' by default.
4ed46869 5732
fa42c37f
KH		 5733 o coding-category-utf-8
5734
5735 The category for a coding system which has the same code range
6e76ae91 5736 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
fa42c37f
KH		 5737 symbol) `utf-8' by default.
5738
5739 o coding-category-utf-16-be
5740
5741 The category for a coding system in which a text has an
5742 Unicode signature (cf. Unicode Standard) in the order of BIG
5743 endian at the head. Assigned the coding-system (Lisp symbol)
5744 `utf-16-be' by default.
5745
5746 o coding-category-utf-16-le
5747
5748 The category for a coding system in which a text has an
5749 Unicode signature (cf. Unicode Standard) in the order of
5750 LITTLE endian at the head. Assigned the coding-system (Lisp
5751 symbol) `utf-16-le' by default.
5752
1397dc18
KH		 5753 o coding-category-ccl
5754
5755 The category for a coding system of which encoder/decoder is
5756 written in CCL programs. The default value is nil, i.e., no
5757 coding system is assigned.
5758
4ed46869
KH		 5759 o coding-category-binary
5760
5761 The category for a coding system not categorized in any of the
5762 above. Assigned the coding-system (Lisp symbol)
e0e989f6 5763 `no-conversion' by default.
4ed46869
KH		 5764
5765 Each of them is a Lisp symbol and the value is an actual
df7492f9 5766 `coding-system's (this is also a Lisp symbol) assigned by a user.
4ed46869
KH		 5767 What Emacs does actually is to detect a category of coding system.
5768 Then, it uses a `coding-system' assigned to it. If Emacs can't
df7492f9 5769 decide only one possible category, it selects a category of the
4ed46869
KH		 5770 highest priority. Priorities of categories are also specified by a
5771 user in a Lisp variable `coding-category-list'.
5772
5773*/
5774
df7492f9
KH		 5775#define EOL_SEEN_NONE 0
5776#define EOL_SEEN_LF 1
5777#define EOL_SEEN_CR 2
5778#define EOL_SEEN_CRLF 4
66cfb530 5779
ff0dacd7
KH		 5780/* Detect how end-of-line of a text of length SRC_BYTES pointed by
5781 SOURCE is encoded. If CATEGORY is one of
5782 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5783 two-byte, else they are encoded by one-byte.
5784
5785 Return one of EOL_SEEN_XXX. */
4ed46869 5786
bc4bc72a 5787#define MAX_EOL_CHECK_COUNT 3
d46c5b12
KH		 5788
5789static int
89528eb3 5790detect_eol (source, src_bytes, category)
f6cbaf43 5791 const unsigned char *source;
df7492f9 5792 EMACS_INT src_bytes;
89528eb3 5793 enum coding_category category;
4ed46869 5794{
f6cbaf43 5795 const unsigned char *src = source, *src_end = src + src_bytes;
4ed46869 5796 unsigned char c;
df7492f9
KH		 5797 int total = 0;
5798 int eol_seen = EOL_SEEN_NONE;
4ed46869 5799
89528eb3 5800 if ((1 << category) & CATEGORY_MASK_UTF_16)
4ed46869 5801 {
df7492f9 5802 int msb, lsb;
fa42c37f 5803
89528eb3
KH		 5804 msb = category == (coding_category_utf_16_le
5805 | coding_category_utf_16_le_nosig);
df7492f9 5806 lsb = 1 - msb;
fa42c37f 5807
df7492f9 5808 while (src + 1 < src_end)
fa42c37f 5809 {
df7492f9
KH		 5810 c = src[lsb];
5811 if (src[msb] == 0 && (c == '\n' || c == '\r'))
fa42c37f 5812 {
df7492f9
KH		 5813 int this_eol;
5814
5815 if (c == '\n')
5816 this_eol = EOL_SEEN_LF;
5817 else if (src + 3 >= src_end
5818 || src[msb + 2] != 0
5819 || src[lsb + 2] != '\n')
5820 this_eol = EOL_SEEN_CR;
fa42c37f 5821 else
75f4f1ac
EZ		 5822 {
5823 this_eol = EOL_SEEN_CRLF;
5824 src += 2;
5825 }
df7492f9
KH		 5826
5827 if (eol_seen == EOL_SEEN_NONE)
5828 /* This is the first end-of-line. */
5829 eol_seen = this_eol;
5830 else if (eol_seen != this_eol)
fa42c37f 5831 {
75f4f1ac
EZ		 5832 /* The found type is different from what found before.
5833 Allow for stray ^M characters in DOS EOL files. */
5834 if (eol_seen == EOL_SEEN_CR && this_eol == EOL_SEEN_CRLF
5835 || eol_seen == EOL_SEEN_CRLF && this_eol == EOL_SEEN_CR)
5836 eol_seen = EOL_SEEN_CRLF;
5837 else
5838 {
5839 eol_seen = EOL_SEEN_LF;
5840 break;
5841 }
fa42c37f 5842 }
df7492f9
KH		 5843 if (++total == MAX_EOL_CHECK_COUNT)
5844 break;
fa42c37f 5845 }
df7492f9 5846 src += 2;
fa42c37f 5847 }
bcf26d6a 5848 }
d46c5b12 5849 else
c4825358 5850 {
df7492f9 5851 while (src < src_end)
27901516 5852 {
df7492f9
KH		 5853 c = *src++;
5854 if (c == '\n' || c == '\r')
5855 {
5856 int this_eol;
d46c5b12 5857
df7492f9
KH		 5858 if (c == '\n')
5859 this_eol = EOL_SEEN_LF;
5860 else if (src >= src_end || *src != '\n')
5861 this_eol = EOL_SEEN_CR;
5862 else
5863 this_eol = EOL_SEEN_CRLF, src++;
d46c5b12 5864
df7492f9
KH		 5865 if (eol_seen == EOL_SEEN_NONE)
5866 /* This is the first end-of-line. */
5867 eol_seen = this_eol;
5868 else if (eol_seen != this_eol)
5869 {
75f4f1ac
EZ		 5870 /* The found type is different from what found before.
5871 Allow for stray ^M characters in DOS EOL files. */
5872 if (eol_seen == EOL_SEEN_CR && this_eol == EOL_SEEN_CRLF
5873 || eol_seen == EOL_SEEN_CRLF && this_eol == EOL_SEEN_CR)
5874 eol_seen = EOL_SEEN_CRLF;
5875 else
5876 {
5877 eol_seen = EOL_SEEN_LF;
5878 break;
5879 }
df7492f9
KH		 5880 }
5881 if (++total == MAX_EOL_CHECK_COUNT)
5882 break;
5883 }
5884 }
73be902c 5885 }
df7492f9 5886 return eol_seen;
73be902c
KH		 5887}
5888
df7492f9 5889
24a73b0a 5890static Lisp_Object
df7492f9
KH		 5891adjust_coding_eol_type (coding, eol_seen)
5892 struct coding_system *coding;
5893 int eol_seen;
73be902c 5894{
0be8721c 5895 Lisp_Object eol_type;
8f924df7 5896
df7492f9
KH		 5897 eol_type = CODING_ID_EOL_TYPE (coding->id);
5898 if (eol_seen & EOL_SEEN_LF)
24a73b0a
KH		 5899 {
5900 coding->id = CODING_SYSTEM_ID (AREF (eol_type, 0));
5901 eol_type = Qunix;
5902 }
6f197c07 5903 else if (eol_seen & EOL_SEEN_CRLF)
24a73b0a
KH		 5904 {
5905 coding->id = CODING_SYSTEM_ID (AREF (eol_type, 1));
5906 eol_type = Qdos;
5907 }
6f197c07 5908 else if (eol_seen & EOL_SEEN_CR)
24a73b0a
KH		 5909 {
5910 coding->id = CODING_SYSTEM_ID (AREF (eol_type, 2));
5911 eol_type = Qmac;
5912 }
5913 return eol_type;
d46c5b12 5914}
4ed46869 5915
df7492f9
KH		 5916/* Detect how a text specified in CODING is encoded. If a coding
5917 system is detected, update fields of CODING by the detected coding
5918 system. */
0a28aafb 5919
df7492f9
KH		 5920void
5921detect_coding (coding)
d46c5b12 5922 struct coding_system *coding;
d46c5b12 5923{
8f924df7 5924 const unsigned char *src, *src_end;
d46c5b12 5925
df7492f9
KH		 5926 coding->consumed = coding->consumed_char = 0;
5927 coding->produced = coding->produced_char = 0;
5928 coding_set_source (coding);
1c3478b0 5929
df7492f9 5930 src_end = coding->source + coding->src_bytes;
c0e16b14 5931 coding->head_ascii = 0;
1c3478b0 5932
df7492f9
KH		 5933 /* If we have not yet decided the text encoding type, detect it
5934 now. */
5935 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding->id)), Qundecided))
b73bfc1c 5936 {
df7492f9 5937 int c, i;
6cb21a4f 5938 struct coding_detection_info detect_info;
2f3cbb32 5939 int null_byte_found = 0, eight_bit_found = 0;
df7492f9 5940
6cb21a4f 5941 detect_info.checked = detect_info.found = detect_info.rejected = 0;
2f3cbb32 5942 for (src = coding->source; src < src_end; src++)
d46c5b12 5943 {
df7492f9 5944 c = *src;
6cb21a4f 5945 if (c & 0x80)
6cb21a4f 5946 {
2f3cbb32 5947 eight_bit_found = 1;
2f3cbb32
KH		 5948 if (null_byte_found)
5949 break;
5950 }
5951 else if (c < 0x20)
5952 {
5953 if ((c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
5954 && ! inhibit_iso_escape_detection
5955 && ! detect_info.checked)
6cb21a4f 5956 {
2f3cbb32
KH		 5957 if (detect_coding_iso_2022 (coding, &detect_info))
5958 {
5959 /* We have scanned the whole data. */
5960 if (! (detect_info.rejected & CATEGORY_MASK_ISO_7_ELSE))
c0e16b14
KH		 5961 {
5962 /* We didn't find an 8-bit code. We may
5963 have found a null-byte, but it's very
5964 rare that a binary file confirm to
5965 ISO-2022. */
5966 src = src_end;
5967 coding->head_ascii = src - coding->source;
5968 }
5969 detect_info.rejected |= ~CATEGORY_MASK_ISO_ESCAPE;
2f3cbb32
KH		 5970 break;
5971 }
5972 }
97b1b294 5973 else if (! c && !inhibit_null_byte_detection)
2f3cbb32
KH		 5974 {
5975 null_byte_found = 1;
5976 if (eight_bit_found)
5977 break;
6cb21a4f 5978 }
c006c0c8
KH		 5979 if (! eight_bit_found)
5980 coding->head_ascii++;
6cb21a4f 5981 }
c006c0c8 5982 else if (! eight_bit_found)
c0e16b14 5983 coding->head_ascii++;
d46c5b12 5984 }
df7492f9 5985
2f3cbb32
KH		 5986 if (null_byte_found || eight_bit_found
5987 || coding->head_ascii < coding->src_bytes
6cb21a4f 5988 || detect_info.found)
d46c5b12 5989 {
ff0dacd7
KH		 5990 enum coding_category category;
5991 struct coding_system *this;
df7492f9 5992
6cb21a4f
KH		 5993 if (coding->head_ascii == coding->src_bytes)
5994 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
5995 for (i = 0; i < coding_category_raw_text; i++)
5996 {
5997 category = coding_priorities[i];
5998 this = coding_categories + category;
5999 if (detect_info.found & (1 << category))
24a73b0a 6000 break;
6cb21a4f
KH		 6001 }
6002 else
2f3cbb32
KH		 6003 {
6004 if (null_byte_found)
ff0dacd7 6005 {
2f3cbb32
KH		 6006 detect_info.checked |= ~CATEGORY_MASK_UTF_16;
6007 detect_info.rejected |= ~CATEGORY_MASK_UTF_16;
ff0dacd7 6008 }
2f3cbb32
KH		 6009 for (i = 0; i < coding_category_raw_text; i++)
6010 {
6011 category = coding_priorities[i];
6012 this = coding_categories + category;
6013 if (this->id < 0)
6014 {
6015 /* No coding system of this category is defined. */
6016 detect_info.rejected |= (1 << category);
6017 }
6018 else if (category >= coding_category_raw_text)
6019 continue;
6020 else if (detect_info.checked & (1 << category))
6021 {
6022 if (detect_info.found & (1 << category))
6023 break;
6024 }
6025 else if ((*(this->detector)) (coding, &detect_info)
6026 && detect_info.found & (1 << category))
6027 {
6028 if (category == coding_category_utf_16_auto)
6029 {
6030 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
6031 category = coding_category_utf_16_le;
6032 else
6033 category = coding_category_utf_16_be;
6034 }
6035 break;
6036 }
6037 }
2f3cbb32 6038 }
c0e16b14
KH		 6039
6040 if (i < coding_category_raw_text)
6041 setup_coding_system (CODING_ID_NAME (this->id), coding);
6042 else if (null_byte_found)
6043 setup_coding_system (Qno_conversion, coding);
6044 else if ((detect_info.rejected & CATEGORY_MASK_ANY)
6045 == CATEGORY_MASK_ANY)
6046 setup_coding_system (Qraw_text, coding);
6047 else if (detect_info.rejected)
6048 for (i = 0; i < coding_category_raw_text; i++)
6049 if (! (detect_info.rejected & (1 << coding_priorities[i])))
6050 {
6051 this = coding_categories + coding_priorities[i];
6052 setup_coding_system (CODING_ID_NAME (this->id), coding);
6053 break;
6054 }
d46c5b12 6055 }
b73bfc1c 6056 }
a470d443
KH		 6057 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
6058 == coding_category_utf_8_auto)
6059 {
6060 Lisp_Object coding_systems;
6061 struct coding_detection_info detect_info;
6062
6063 coding_systems
6064 = AREF (CODING_ID_ATTRS (coding->id), coding_attr_utf_bom);
6065 detect_info.found = detect_info.rejected = 0;
6066 coding->head_ascii = 0;
6067 if (CONSP (coding_systems)
6068 && detect_coding_utf_8 (coding, &detect_info))
6069 {
6070 if (detect_info.found & CATEGORY_MASK_UTF_8_SIG)
6071 setup_coding_system (XCAR (coding_systems), coding);
6072 else
6073 setup_coding_system (XCDR (coding_systems), coding);
6074 }
6075 }
24a73b0a
KH		 6076 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding->id)))
6077 == coding_category_utf_16_auto)
b49a1807
KH		 6078 {
6079 Lisp_Object coding_systems;
6080 struct coding_detection_info detect_info;
6081
6082 coding_systems
a470d443 6083 = AREF (CODING_ID_ATTRS (coding->id), coding_attr_utf_bom);
b49a1807 6084 detect_info.found = detect_info.rejected = 0;
a470d443 6085 coding->head_ascii = 0;
b49a1807 6086 if (CONSP (coding_systems)
24a73b0a 6087 && detect_coding_utf_16 (coding, &detect_info))
b49a1807
KH		 6088 {
6089 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
6090 setup_coding_system (XCAR (coding_systems), coding);
24a73b0a 6091 else if (detect_info.found & CATEGORY_MASK_UTF_16_BE)
b49a1807
KH		 6092 setup_coding_system (XCDR (coding_systems), coding);
6093 }
6094 }
4ed46869 6095}
4ed46869 6096
d46c5b12 6097
aaaf0b1e 6098static void
df7492f9 6099decode_eol (coding)
aaaf0b1e 6100 struct coding_system *coding;
aaaf0b1e 6101{
24a73b0a
KH		 6102 Lisp_Object eol_type;
6103 unsigned char *p, *pbeg, *pend;
3ed051d4 6104
24a73b0a
KH		 6105 eol_type = CODING_ID_EOL_TYPE (coding->id);
6106 if (EQ (eol_type, Qunix))
6107 return;
6108
6109 if (NILP (coding->dst_object))
6110 pbeg = coding->destination;
6111 else
6112 pbeg = BYTE_POS_ADDR (coding->dst_pos_byte);
6113 pend = pbeg + coding->produced;
6114
6115 if (VECTORP (eol_type))
aaaf0b1e 6116 {
df7492f9 6117 int eol_seen = EOL_SEEN_NONE;
4ed46869 6118
24a73b0a 6119 for (p = pbeg; p < pend; p++)
aaaf0b1e 6120 {
df7492f9
KH		 6121 if (*p == '\n')
6122 eol_seen |= EOL_SEEN_LF;
6123 else if (*p == '\r')
aaaf0b1e 6124 {
df7492f9 6125 if (p + 1 < pend && *(p + 1) == '\n')
aaaf0b1e 6126 {
df7492f9
KH		 6127 eol_seen |= EOL_SEEN_CRLF;
6128 p++;
aaaf0b1e 6129 }
aaaf0b1e 6130 else
df7492f9 6131 eol_seen |= EOL_SEEN_CR;
aaaf0b1e 6132 }
aaaf0b1e 6133 }
75f4f1ac
EZ		 6134 /* Handle DOS-style EOLs in a file with stray ^M characters. */
6135 if ((eol_seen & EOL_SEEN_CRLF) != 0
6136 && (eol_seen & EOL_SEEN_CR) != 0
6137 && (eol_seen & EOL_SEEN_LF) == 0)
6138 eol_seen = EOL_SEEN_CRLF;
6139 else if (eol_seen != EOL_SEEN_NONE
24a73b0a
KH		 6140 && eol_seen != EOL_SEEN_LF
6141 && eol_seen != EOL_SEEN_CRLF
6142 && eol_seen != EOL_SEEN_CR)
6143 eol_seen = EOL_SEEN_LF;
df7492f9 6144 if (eol_seen != EOL_SEEN_NONE)
24a73b0a 6145 eol_type = adjust_coding_eol_type (coding, eol_seen);
aaaf0b1e 6146 }
d46c5b12 6147
24a73b0a 6148 if (EQ (eol_type, Qmac))
27901516 6149 {
24a73b0a 6150 for (p = pbeg; p < pend; p++)
df7492f9
KH		 6151 if (*p == '\r')
6152 *p = '\n';
4ed46869 6153 }
24a73b0a 6154 else if (EQ (eol_type, Qdos))
df7492f9 6155 {
24a73b0a 6156 int n = 0;
b73bfc1c 6157
24a73b0a
KH		 6158 if (NILP (coding->dst_object))
6159 {
4347441b
KH		 6160 /* Start deleting '\r' from the tail to minimize the memory
6161 movement. */
24a73b0a
KH		 6162 for (p = pend - 2; p >= pbeg; p--)
6163 if (*p == '\r')
6164 {
6165 safe_bcopy ((char *) (p + 1), (char *) p, pend-- - p - 1);
6166 n++;
6167 }
6168 }
6169 else
6170 {
4347441b
KH		 6171 int pos_byte = coding->dst_pos_byte;
6172 int pos = coding->dst_pos;
6173 int pos_end = pos + coding->produced_char - 1;
6174
6175 while (pos < pos_end)
6176 {
6177 p = BYTE_POS_ADDR (pos_byte);
6178 if (*p == '\r' && p[1] == '\n')
6179 {
6180 del_range_2 (pos, pos_byte, pos + 1, pos_byte + 1, 0);
6181 n++;
6182 pos_end--;
6183 }
6184 pos++;
69b8522d
KH		 6185 if (coding->dst_multibyte)
6186 pos_byte += BYTES_BY_CHAR_HEAD (*p);
6187 else
6188 pos_byte++;
4347441b 6189 }
24a73b0a
KH		 6190 }
6191 coding->produced -= n;
6192 coding->produced_char -= n;
aaaf0b1e 6193 }
4ed46869
KH		 6194}
6195
7d64c6ad 6196
a6f87d34
KH		 6197/* Return a translation table (or list of them) from coding system
6198 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
6199 decoding (ENCODEP is zero). */
7d64c6ad 6200
e6a54062 6201static Lisp_Object
09ee6fdd
KH		 6202get_translation_table (attrs, encodep, max_lookup)
6203 Lisp_Object attrs;
6204 int encodep, *max_lookup;
7d64c6ad
KH		 6205{
6206 Lisp_Object standard, translation_table;
09ee6fdd 6207 Lisp_Object val;
7d64c6ad
KH		 6208
6209 if (encodep)
6210 translation_table = CODING_ATTR_ENCODE_TBL (attrs),
6211 standard = Vstandard_translation_table_for_encode;
6212 else
6213 translation_table = CODING_ATTR_DECODE_TBL (attrs),
6214 standard = Vstandard_translation_table_for_decode;
7d64c6ad 6215 if (NILP (translation_table))
09ee6fdd
KH		 6216 translation_table = standard;
6217 else
a6f87d34 6218 {
09ee6fdd
KH		 6219 if (SYMBOLP (translation_table))
6220 translation_table = Fget (translation_table, Qtranslation_table);
6221 else if (CONSP (translation_table))
6222 {
6223 translation_table = Fcopy_sequence (translation_table);
6224 for (val = translation_table; CONSP (val); val = XCDR (val))
6225 if (SYMBOLP (XCAR (val)))
6226 XSETCAR (val, Fget (XCAR (val), Qtranslation_table));
6227 }
6228 if (CHAR_TABLE_P (standard))
6229 {
6230 if (CONSP (translation_table))
6231 translation_table = nconc2 (translation_table,
6232 Fcons (standard, Qnil));
6233 else
6234 translation_table = Fcons (translation_table,
6235 Fcons (standard, Qnil));
6236 }
a6f87d34 6237 }
2170c8f0
KH		 6238
6239 if (max_lookup)
09ee6fdd 6240 {
2170c8f0
KH		 6241 *max_lookup = 1;
6242 if (CHAR_TABLE_P (translation_table)
6243 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table)) > 1)
6244 {
6245 val = XCHAR_TABLE (translation_table)->extras[1];
6246 if (NATNUMP (val) && *max_lookup < XFASTINT (val))
6247 *max_lookup = XFASTINT (val);
6248 }
6249 else if (CONSP (translation_table))
6250 {
6251 Lisp_Object tail, val;
09ee6fdd 6252
2170c8f0
KH		 6253 for (tail = translation_table; CONSP (tail); tail = XCDR (tail))
6254 if (CHAR_TABLE_P (XCAR (tail))
6255 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail))) > 1)
6256 {
6257 val = XCHAR_TABLE (XCAR (tail))->extras[1];
6258 if (NATNUMP (val) && *max_lookup < XFASTINT (val))
6259 *max_lookup = XFASTINT (val);
6260 }
6261 }
a6f87d34 6262 }
7d64c6ad
KH		 6263 return translation_table;
6264}
6265
09ee6fdd
KH		 6266#define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
6267 do { \
6268 trans = Qnil; \
6269 if (CHAR_TABLE_P (table)) \
6270 { \
6271 trans = CHAR_TABLE_REF (table, c); \
6272 if (CHARACTERP (trans)) \
6273 c = XFASTINT (trans), trans = Qnil; \
6274 } \
6275 else if (CONSP (table)) \
6276 { \
6277 Lisp_Object tail; \
6278 \
6279 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
6280 if (CHAR_TABLE_P (XCAR (tail))) \
6281 { \
6282 trans = CHAR_TABLE_REF (XCAR (tail), c); \
6283 if (CHARACTERP (trans)) \
6284 c = XFASTINT (trans), trans = Qnil; \
6285 else if (! NILP (trans)) \
6286 break; \
6287 } \
6288 } \
e6a54062
KH		 6289 } while (0)
6290
7d64c6ad 6291
69a80ea3
KH		 6292static Lisp_Object
6293get_translation (val, buf, buf_end, last_block, from_nchars, to_nchars)
6294 Lisp_Object val;
6295 int *buf, *buf_end;
6296 int last_block;
6297 int *from_nchars, *to_nchars;
6298{
433f7f87
KH		 6299 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
6300 [TO-CHAR ...]. */
69a80ea3
KH		 6301 if (CONSP (val))
6302 {
433f7f87 6303 Lisp_Object from, tail;
69a80ea3
KH		 6304 int i, len;
6305
433f7f87 6306 for (tail = val; CONSP (tail); tail = XCDR (tail))
69a80ea3 6307 {
433f7f87
KH		 6308 val = XCAR (tail);
6309 from = XCAR (val);
6310 len = ASIZE (from);
6311 for (i = 0; i < len; i++)
6312 {
6313 if (buf + i == buf_end)
6314 {
6315 if (! last_block)
6316 return Qt;
6317 break;
6318 }
6319 if (XINT (AREF (from, i)) != buf[i])
6320 break;
6321 }
6322 if (i == len)
6323 {
6324 val = XCDR (val);
6325 *from_nchars = len;
6326 break;
6327 }
69a80ea3 6328 }
433f7f87
KH		 6329 if (! CONSP (tail))
6330 return Qnil;
69a80ea3
KH		 6331 }
6332 if (VECTORP (val))
6333 *buf = XINT (AREF (val, 0)), *to_nchars = ASIZE (val);
6334 else
6335 *buf = XINT (val);
6336 return val;
6337}
6338
6339
d46c5b12 6340static int
69a80ea3 6341produce_chars (coding, translation_table, last_block)
df7492f9 6342 struct coding_system *coding;
69a80ea3
KH		 6343 Lisp_Object translation_table;
6344 int last_block;
4ed46869 6345{
df7492f9
KH		 6346 unsigned char *dst = coding->destination + coding->produced;
6347 unsigned char *dst_end = coding->destination + coding->dst_bytes;
119852e7
KH		 6348 EMACS_INT produced;
6349 EMACS_INT produced_chars = 0;
69a80ea3 6350 int carryover = 0;
4ed46869 6351
df7492f9 6352 if (! coding->chars_at_source)
4ed46869 6353 {
119852e7 6354 /* Source characters are in coding->charbuf. */
fba4576f
AS		 6355 int *buf = coding->charbuf;
6356 int *buf_end = buf + coding->charbuf_used;
4ed46869 6357
db274c7a
KH		 6358 if (EQ (coding->src_object, coding->dst_object))
6359 {
6360 coding_set_source (coding);
6361 dst_end = ((unsigned char *) coding->source) + coding->consumed;
6362 }
4ed46869 6363
df7492f9 6364 while (buf < buf_end)
4ed46869 6365 {
69a80ea3 6366 int c = *buf, i;
bc4bc72a 6367
df7492f9
KH		 6368 if (c >= 0)
6369 {
69a80ea3
KH		 6370 int from_nchars = 1, to_nchars = 1;
6371 Lisp_Object trans = Qnil;
6372
09ee6fdd 6373 LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
e6a54062 6374 if (! NILP (trans))
69a80ea3
KH		 6375 {
6376 trans = get_translation (trans, buf, buf_end, last_block,
6377 &from_nchars, &to_nchars);
6378 if (EQ (trans, Qt))
6379 break;
6380 c = *buf;
6381 }
6382
6383 if (dst + MAX_MULTIBYTE_LENGTH * to_nchars > dst_end)
6384 {
6385 dst = alloc_destination (coding,
6386 buf_end - buf
6387 + MAX_MULTIBYTE_LENGTH * to_nchars,
6388 dst);
db274c7a
KH		 6389 if (EQ (coding->src_object, coding->dst_object))
6390 {
6391 coding_set_source (coding);
6392 dst_end = ((unsigned char *) coding->source) + coding->consumed;
6393 }
6394 else
6395 dst_end = coding->destination + coding->dst_bytes;
69a80ea3
KH		 6396 }
6397
433f7f87 6398 for (i = 0; i < to_nchars; i++)
69a80ea3 6399 {
433f7f87
KH		 6400 if (i > 0)
6401 c = XINT (AREF (trans, i));
69a80ea3
KH		 6402 if (coding->dst_multibyte
6403 || ! CHAR_BYTE8_P (c))
db274c7a 6404 CHAR_STRING_ADVANCE_NO_UNIFY (c, dst);
69a80ea3
KH		 6405 else
6406 *dst++ = CHAR_TO_BYTE8 (c);
6407 }
6408 produced_chars += to_nchars;
6409 *buf++ = to_nchars;
6410 while (--from_nchars > 0)
6411 *buf++ = 0;
d46c5b12 6412 }
df7492f9 6413 else
69a80ea3
KH		 6414 /* This is an annotation datum. (-C) is the length. */
6415 buf += -c;
4ed46869 6416 }
69a80ea3 6417 carryover = buf_end - buf;
4ed46869 6418 }
fa42c37f 6419 else
fa42c37f 6420 {
119852e7 6421 /* Source characters are at coding->source. */
8f924df7 6422 const unsigned char *src = coding->source;
119852e7 6423 const unsigned char *src_end = src + coding->consumed;
4ed46869 6424
db274c7a
KH		 6425 if (EQ (coding->dst_object, coding->src_object))
6426 dst_end = (unsigned char *) src;
df7492f9 6427 if (coding->src_multibyte != coding->dst_multibyte)
fa42c37f 6428 {
df7492f9 6429 if (coding->src_multibyte)
fa42c37f 6430 {
71c81426 6431 int multibytep = 1;
4533845d 6432 EMACS_INT consumed_chars = 0;
d46c5b12 6433
df7492f9
KH		 6434 while (1)
6435 {
8f924df7 6436 const unsigned char *src_base = src;
df7492f9 6437 int c;
b73bfc1c 6438
df7492f9 6439 ONE_MORE_BYTE (c);
119852e7 6440 if (dst == dst_end)
df7492f9 6441 {
119852e7
KH		 6442 if (EQ (coding->src_object, coding->dst_object))
6443 dst_end = (unsigned char *) src;
6444 if (dst == dst_end)
df7492f9 6445 {
119852e7
KH		 6446 EMACS_INT offset = src - coding->source;
6447
6448 dst = alloc_destination (coding, src_end - src + 1,
6449 dst);
6450 dst_end = coding->destination + coding->dst_bytes;
6451 coding_set_source (coding);
6452 src = coding->source + offset;
6453 src_end = coding->source + coding->src_bytes;
db274c7a
KH		 6454 if (EQ (coding->src_object, coding->dst_object))
6455 dst_end = (unsigned char *) src;
df7492f9 6456 }
df7492f9
KH		 6457 }
6458 *dst++ = c;
6459 produced_chars++;
6460 }
6461 no_more_source:
6462 ;
fa42c37f
KH		 6463 }
6464 else
df7492f9
KH		 6465 while (src < src_end)
6466 {
71c81426 6467 int multibytep = 1;
df7492f9 6468 int c = *src++;
b73bfc1c 6469
df7492f9
KH		 6470 if (dst >= dst_end - 1)
6471 {
2c78b7e1 6472 if (EQ (coding->src_object, coding->dst_object))
8f924df7 6473 dst_end = (unsigned char *) src;
2c78b7e1
KH		 6474 if (dst >= dst_end - 1)
6475 {
119852e7 6476 EMACS_INT offset = src - coding->source;
db274c7a 6477 EMACS_INT more_bytes;
119852e7 6478
db274c7a
KH		 6479 if (EQ (coding->src_object, coding->dst_object))
6480 more_bytes = ((src_end - src) / 2) + 2;
6481 else
6482 more_bytes = src_end - src + 2;
6483 dst = alloc_destination (coding, more_bytes, dst);
2c78b7e1
KH		 6484 dst_end = coding->destination + coding->dst_bytes;
6485 coding_set_source (coding);
119852e7 6486 src = coding->source + offset;
2c78b7e1 6487 src_end = coding->source + coding->src_bytes;
db274c7a
KH		 6488 if (EQ (coding->src_object, coding->dst_object))
6489 dst_end = (unsigned char *) src;
2c78b7e1 6490 }
df7492f9
KH		 6491 }
6492 EMIT_ONE_BYTE (c);
6493 }
d46c5b12 6494 }
df7492f9
KH		 6495 else
6496 {
6497 if (!EQ (coding->src_object, coding->dst_object))
fa42c37f 6498 {
119852e7 6499 EMACS_INT require = coding->src_bytes - coding->dst_bytes;
4ed46869 6500
df7492f9 6501 if (require > 0)
fa42c37f 6502 {
df7492f9
KH		 6503 EMACS_INT offset = src - coding->source;
6504
6505 dst = alloc_destination (coding, require, dst);
6506 coding_set_source (coding);
6507 src = coding->source + offset;
6508 src_end = coding->source + coding->src_bytes;
fa42c37f
KH		 6509 }
6510 }
119852e7 6511 produced_chars = coding->consumed_char;
df7492f9 6512 while (src < src_end)
14daee73 6513 *dst++ = *src++;
fa42c37f
KH		 6514 }
6515 }
6516
df7492f9 6517 produced = dst - (coding->destination + coding->produced);
284201e4 6518 if (BUFFERP (coding->dst_object) && produced_chars > 0)
df7492f9
KH		 6519 insert_from_gap (produced_chars, produced);
6520 coding->produced += produced;
6521 coding->produced_char += produced_chars;
69a80ea3 6522 return carryover;
fa42c37f
KH		 6523}
6524
ff0dacd7
KH		 6525/* Compose text in CODING->object according to the annotation data at
6526 CHARBUF. CHARBUF is an array:
6527 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
df7492f9 6528 */
4ed46869 6529
df7492f9 6530static INLINE void
69a80ea3 6531produce_composition (coding, charbuf, pos)
4ed46869 6532 struct coding_system *coding;
df7492f9 6533 int *charbuf;
69a80ea3 6534 EMACS_INT pos;
4ed46869 6535{
df7492f9 6536 int len;
69a80ea3 6537 EMACS_INT to;
df7492f9 6538 enum composition_method method;
df7492f9 6539 Lisp_Object components;
fa42c37f 6540
df7492f9 6541 len = -charbuf[0];
69a80ea3 6542 to = pos + charbuf[2];
9ffd559c
KH		 6543 if (to <= pos)
6544 return;
69a80ea3 6545 method = (enum composition_method) (charbuf[3]);
d46c5b12 6546
df7492f9
KH		 6547 if (method == COMPOSITION_RELATIVE)
6548 components = Qnil;
9ffd559c
KH		 6549 else if (method >= COMPOSITION_WITH_RULE
6550 && method <= COMPOSITION_WITH_RULE_ALTCHARS)
d46c5b12 6551 {
df7492f9
KH		 6552 Lisp_Object args[MAX_COMPOSITION_COMPONENTS * 2 - 1];
6553 int i;
b73bfc1c 6554
69a80ea3
KH		 6555 len -= 4;
6556 charbuf += 4;
df7492f9 6557 for (i = 0; i < len; i++)
9ffd559c
KH		 6558 {
6559 args[i] = make_number (charbuf[i]);
f75c90a9 6560 if (charbuf[i] < 0)
9ffd559c
KH		 6561 return;
6562 }
df7492f9
KH		 6563 components = (method == COMPOSITION_WITH_ALTCHARS
6564 ? Fstring (len, args) : Fvector (len, args));
d46c5b12 6565 }
9ffd559c
KH		 6566 else
6567 return;
69a80ea3 6568 compose_text (pos, to, components, Qnil, coding->dst_object);
d46c5b12
KH		 6569}
6570
d46c5b12 6571
ff0dacd7
KH		 6572/* Put `charset' property on text in CODING->object according to
6573 the annotation data at CHARBUF. CHARBUF is an array:
69a80ea3 6574 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
ff0dacd7 6575 */
d46c5b12 6576
ff0dacd7 6577static INLINE void
69a80ea3 6578produce_charset (coding, charbuf, pos)
d46c5b12 6579 struct coding_system *coding;
ff0dacd7 6580 int *charbuf;
69a80ea3 6581 EMACS_INT pos;
d46c5b12 6582{
69a80ea3
KH		 6583 EMACS_INT from = pos - charbuf[2];
6584 struct charset *charset = CHARSET_FROM_ID (charbuf[3]);
b73bfc1c 6585
69a80ea3 6586 Fput_text_property (make_number (from), make_number (pos),
ff0dacd7
KH		 6587 Qcharset, CHARSET_NAME (charset),
6588 coding->dst_object);
d46c5b12
KH		 6589}
6590
d46c5b12 6591
df7492f9
KH		 6592#define CHARBUF_SIZE 0x4000
6593
6594#define ALLOC_CONVERSION_WORK_AREA(coding) \
6595 do { \
6596 int size = CHARBUF_SIZE;; \
6597 \
6598 coding->charbuf = NULL; \
6599 while (size > 1024) \
6600 { \
6601 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6602 if (coding->charbuf) \
6603 break; \
6604 size >>= 1; \
6605 } \
6606 if (! coding->charbuf) \
6607 { \
065e3595 6608 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
df7492f9
KH		 6609 return coding->result; \
6610 } \
6611 coding->charbuf_size = size; \
6612 } while (0)
4ed46869 6613
d46c5b12
KH		 6614
6615static void
69a80ea3 6616produce_annotation (coding, pos)
d46c5b12 6617 struct coding_system *coding;
69a80ea3 6618 EMACS_INT pos;
d46c5b12 6619{
df7492f9
KH		 6620 int *charbuf = coding->charbuf;
6621 int *charbuf_end = charbuf + coding->charbuf_used;
d46c5b12 6622
ff0dacd7
KH		 6623 if (NILP (coding->dst_object))
6624 return;
d46c5b12 6625
df7492f9 6626 while (charbuf < charbuf_end)
a84f1519 6627 {
df7492f9 6628 if (*charbuf >= 0)
69a80ea3 6629 pos += *charbuf++;
d46c5b12 6630 else
d46c5b12 6631 {
df7492f9 6632 int len = -*charbuf;
ff0dacd7 6633 switch (charbuf[1])
df7492f9
KH		 6634 {
6635 case CODING_ANNOTATE_COMPOSITION_MASK:
69a80ea3 6636 produce_composition (coding, charbuf, pos);
df7492f9 6637 break;
ff0dacd7 6638 case CODING_ANNOTATE_CHARSET_MASK:
69a80ea3 6639 produce_charset (coding, charbuf, pos);
ff0dacd7 6640 break;
df7492f9
KH		 6641 default:
6642 abort ();
6643 }
6644 charbuf += len;
d46c5b12 6645 }
a84f1519 6646 }
d46c5b12
KH		 6647}
6648
df7492f9
KH		 6649/* Decode the data at CODING->src_object into CODING->dst_object.
6650 CODING->src_object is a buffer, a string, or nil.
6651 CODING->dst_object is a buffer.
d46c5b12 6652
df7492f9
KH		 6653 If CODING->src_object is a buffer, it must be the current buffer.
6654 In this case, if CODING->src_pos is positive, it is a position of
6655 the source text in the buffer, otherwise, the source text is in the
6656 gap area of the buffer, and CODING->src_pos specifies the offset of
6657 the text from GPT (which must be the same as PT). If this is the
6658 same buffer as CODING->dst_object, CODING->src_pos must be
6659 negative.
d46c5b12 6660
b6828792 6661 If CODING->src_object is a string, CODING->src_pos is an index to
df7492f9 6662 that string.
d46c5b12 6663
df7492f9
KH		 6664 If CODING->src_object is nil, CODING->source must already point to
6665 the non-relocatable memory area. In this case, CODING->src_pos is
6666 an offset from CODING->source.
73be902c 6667
df7492f9
KH		 6668 The decoded data is inserted at the current point of the buffer
6669 CODING->dst_object.
6670*/
d46c5b12 6671
df7492f9
KH		 6672static int
6673decode_coding (coding)
d46c5b12 6674 struct coding_system *coding;
d46c5b12 6675{
df7492f9 6676 Lisp_Object attrs;
24a73b0a 6677 Lisp_Object undo_list;
7d64c6ad 6678 Lisp_Object translation_table;
69a80ea3
KH		 6679 int carryover;
6680 int i;
d46c5b12 6681
df7492f9
KH		 6682 if (BUFFERP (coding->src_object)
6683 && coding->src_pos > 0
6684 && coding->src_pos < GPT
6685 && coding->src_pos + coding->src_chars > GPT)
6686 move_gap_both (coding->src_pos, coding->src_pos_byte);
d46c5b12 6687
24a73b0a 6688 undo_list = Qt;
df7492f9 6689 if (BUFFERP (coding->dst_object))
1c3478b0 6690 {
df7492f9
KH		 6691 if (current_buffer != XBUFFER (coding->dst_object))
6692 set_buffer_internal (XBUFFER (coding->dst_object));
6693 if (GPT != PT)
6694 move_gap_both (PT, PT_BYTE);
24a73b0a
KH		 6695 undo_list = current_buffer->undo_list;
6696 current_buffer->undo_list = Qt;
1c3478b0
KH		 6697 }
6698
df7492f9
KH		 6699 coding->consumed = coding->consumed_char = 0;
6700 coding->produced = coding->produced_char = 0;
6701 coding->chars_at_source = 0;
065e3595 6702 record_conversion_result (coding, CODING_RESULT_SUCCESS);
df7492f9 6703 coding->errors = 0;
1c3478b0 6704
df7492f9
KH		 6705 ALLOC_CONVERSION_WORK_AREA (coding);
6706
6707 attrs = CODING_ID_ATTRS (coding->id);
2170c8f0 6708 translation_table = get_translation_table (attrs, 0, NULL);
df7492f9 6709
69a80ea3 6710 carryover = 0;
df7492f9 6711 do
b73bfc1c 6712 {
69a80ea3
KH		 6713 EMACS_INT pos = coding->dst_pos + coding->produced_char;
6714
df7492f9
KH		 6715 coding_set_source (coding);
6716 coding->annotated = 0;
69a80ea3 6717 coding->charbuf_used = carryover;
df7492f9 6718 (*(coding->decoder)) (coding);
df7492f9 6719 coding_set_destination (coding);
69a80ea3 6720 carryover = produce_chars (coding, translation_table, 0);
df7492f9 6721 if (coding->annotated)
69a80ea3
KH		 6722 produce_annotation (coding, pos);
6723 for (i = 0; i < carryover; i++)
6724 coding->charbuf[i]
6725 = coding->charbuf[coding->charbuf_used - carryover + i];
d46c5b12 6726 }
df7492f9 6727 while (coding->consumed < coding->src_bytes
54b367bb
KH		 6728 && (coding->result == CODING_RESULT_SUCCESS
6729 || coding->result == CODING_RESULT_INVALID_SRC));
d46c5b12 6730
69a80ea3
KH		 6731 if (carryover > 0)
6732 {
6733 coding_set_destination (coding);
6734 coding->charbuf_used = carryover;
6735 produce_chars (coding, translation_table, 1);
6736 }
6737
df7492f9
KH		 6738 coding->carryover_bytes = 0;
6739 if (coding->consumed < coding->src_bytes)
d46c5b12 6740 {
df7492f9 6741 int nbytes = coding->src_bytes - coding->consumed;
8f924df7 6742 const unsigned char *src;
df7492f9
KH		 6743
6744 coding_set_source (coding);
6745 coding_set_destination (coding);
6746 src = coding->source + coding->consumed;
6747
6748 if (coding->mode & CODING_MODE_LAST_BLOCK)
1c3478b0 6749 {
df7492f9
KH		 6750 /* Flush out unprocessed data as binary chars. We are sure
6751 that the number of data is less than the size of
6752 coding->charbuf. */
065e3595 6753 coding->charbuf_used = 0;
b2dab6c8
JR		 6754 coding->chars_at_source = 0;
6755
df7492f9 6756 while (nbytes-- > 0)
1c3478b0 6757 {
df7492f9 6758 int c = *src++;
98725083 6759
1c91457d
KH		 6760 if (c & 0x80)
6761 c = BYTE8_TO_CHAR (c);
6762 coding->charbuf[coding->charbuf_used++] = c;
1c3478b0 6763 }
f6cbaf43 6764 produce_chars (coding, Qnil, 1);
d46c5b12 6765 }
d46c5b12 6766 else
df7492f9
KH		 6767 {
6768 /* Record unprocessed bytes in coding->carryover. We are
6769 sure that the number of data is less than the size of
6770 coding->carryover. */
6771 unsigned char *p = coding->carryover;
6772
6773 coding->carryover_bytes = nbytes;
6774 while (nbytes-- > 0)
6775 *p++ = *src++;
1c3478b0 6776 }
df7492f9 6777 coding->consumed = coding->src_bytes;
b73bfc1c 6778 }
69f76525 6779
4347441b
KH		 6780 if (! EQ (CODING_ID_EOL_TYPE (coding->id), Qunix))
6781 decode_eol (coding);
24a73b0a
KH		 6782 if (BUFFERP (coding->dst_object))
6783 {
6784 current_buffer->undo_list = undo_list;
6785 record_insert (coding->dst_pos, coding->produced_char);
6786 }
73be902c 6787 return coding->result;
4ed46869
KH		 6788}
6789
aaaf0b1e 6790
e1c23804 6791/* Extract an annotation datum from a composition starting at POS and
ff0dacd7
KH		 6792 ending before LIMIT of CODING->src_object (buffer or string), store
6793 the data in BUF, set *STOP to a starting position of the next
6794 composition (if any) or to LIMIT, and return the address of the
6795 next element of BUF.
6796
6797 If such an annotation is not found, set *STOP to a starting
6798 position of a composition after POS (if any) or to LIMIT, and
6799 return BUF. */
6800
6801static INLINE int *
6802handle_composition_annotation (pos, limit, coding, buf, stop)
6803 EMACS_INT pos, limit;
aaaf0b1e 6804 struct coding_system *coding;
ff0dacd7
KH		 6805 int *buf;
6806 EMACS_INT *stop;
aaaf0b1e 6807{
ff0dacd7
KH		 6808 EMACS_INT start, end;
6809 Lisp_Object prop;
aaaf0b1e 6810
ff0dacd7
KH		 6811 if (! find_composition (pos, limit, &start, &end, &prop, coding->src_object)
6812 || end > limit)
6813 *stop = limit;
6814 else if (start > pos)
6815 *stop = start;
6816 else
aaaf0b1e 6817 {
ff0dacd7 6818 if (start == pos)
aaaf0b1e 6819 {
ff0dacd7
KH		 6820 /* We found a composition. Store the corresponding
6821 annotation data in BUF. */
6822 int *head = buf;
6823 enum composition_method method = COMPOSITION_METHOD (prop);
6824 int nchars = COMPOSITION_LENGTH (prop);
6825
69a80ea3 6826 ADD_COMPOSITION_DATA (buf, nchars, method);
ff0dacd7 6827 if (method != COMPOSITION_RELATIVE)
aaaf0b1e 6828 {
ff0dacd7
KH		 6829 Lisp_Object components;
6830 int len, i, i_byte;
6831
6832 components = COMPOSITION_COMPONENTS (prop);
6833 if (VECTORP (components))
aaaf0b1e 6834 {
ff0dacd7
KH		 6835 len = XVECTOR (components)->size;
6836 for (i = 0; i < len; i++)
6837 *buf++ = XINT (AREF (components, i));
aaaf0b1e 6838 }
ff0dacd7 6839 else if (STRINGP (components))
aaaf0b1e 6840 {
8f924df7 6841 len = SCHARS (components);
ff0dacd7
KH		 6842 i = i_byte = 0;
6843 while (i < len)
6844 {
6845 FETCH_STRING_CHAR_ADVANCE (*buf, components, i, i_byte);
6846 buf++;
6847 }
6848 }
6849 else if (INTEGERP (components))
6850 {
6851 len = 1;
6852 *buf++ = XINT (components);
6853 }
6854 else if (CONSP (components))
6855 {
6856 for (len = 0; CONSP (components);
6857 len++, components = XCDR (components))
6858 *buf++ = XINT (XCAR (components));
aaaf0b1e 6859 }
aaaf0b1e 6860 else
ff0dacd7
KH		 6861 abort ();
6862 *head -= len;
aaaf0b1e 6863 }
aaaf0b1e 6864 }
ff0dacd7
KH		 6865
6866 if (find_composition (end, limit, &start, &end, &prop,
6867 coding->src_object)
6868 && end <= limit)
6869 *stop = start;
6870 else
6871 *stop = limit;
aaaf0b1e 6872 }
ff0dacd7
KH		 6873 return buf;
6874}
6875
6876
e1c23804 6877/* Extract an annotation datum from a text property `charset' at POS of
ff0dacd7
KH		 6878 CODING->src_object (buffer of string), store the data in BUF, set
6879 *STOP to the position where the value of `charset' property changes
6880 (limiting by LIMIT), and return the address of the next element of
6881 BUF.
6882
6883 If the property value is nil, set *STOP to the position where the
6884 property value is non-nil (limiting by LIMIT), and return BUF. */
6885
6886static INLINE int *
6887handle_charset_annotation (pos, limit, coding, buf, stop)
6888 EMACS_INT pos, limit;
6889 struct coding_system *coding;
6890 int *buf;
6891 EMACS_INT *stop;
6892{
6893 Lisp_Object val, next;
6894 int id;
6895
6896 val = Fget_text_property (make_number (pos), Qcharset, coding->src_object);
6897 if (! NILP (val) && CHARSETP (val))
6898 id = XINT (CHARSET_SYMBOL_ID (val));
6899 else
6900 id = -1;
69a80ea3 6901 ADD_CHARSET_DATA (buf, 0, id);
ff0dacd7
KH		 6902 next = Fnext_single_property_change (make_number (pos), Qcharset,
6903 coding->src_object,
6904 make_number (limit));
6905 *stop = XINT (next);
6906 return buf;
6907}
6908
6909
df7492f9 6910static void
09ee6fdd 6911consume_chars (coding, translation_table, max_lookup)
df7492f9 6912 struct coding_system *coding;
433f7f87 6913 Lisp_Object translation_table;
09ee6fdd 6914 int max_lookup;
df7492f9
KH		 6915{
6916 int *buf = coding->charbuf;
ff0dacd7 6917 int *buf_end = coding->charbuf + coding->charbuf_size;
7c78e542 6918 const unsigned char *src = coding->source + coding->consumed;
4776e638 6919 const unsigned char *src_end = coding->source + coding->src_bytes;
ff0dacd7
KH		 6920 EMACS_INT pos = coding->src_pos + coding->consumed_char;
6921 EMACS_INT end_pos = coding->src_pos + coding->src_chars;
df7492f9
KH		 6922 int multibytep = coding->src_multibyte;
6923 Lisp_Object eol_type;
6924 int c;
ff0dacd7 6925 EMACS_INT stop, stop_composition, stop_charset;
09ee6fdd 6926 int *lookup_buf = NULL;
433f7f87
KH		 6927
6928 if (! NILP (translation_table))
09ee6fdd 6929 lookup_buf = alloca (sizeof (int) * max_lookup);
88993dfd 6930
df7492f9
KH		 6931 eol_type = CODING_ID_EOL_TYPE (coding->id);
6932 if (VECTORP (eol_type))
6933 eol_type = Qunix;
88993dfd 6934
df7492f9
KH		 6935 /* Note: composition handling is not yet implemented. */
6936 coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
ec6d2bb8 6937
0b5670c9
KH		 6938 if (NILP (coding->src_object))
6939 stop = stop_composition = stop_charset = end_pos;
ff0dacd7 6940 else
0b5670c9
KH		 6941 {
6942 if (coding->common_flags & CODING_ANNOTATE_COMPOSITION_MASK)
6943 stop = stop_composition = pos;
6944 else
6945 stop = stop_composition = end_pos;
6946 if (coding->common_flags & CODING_ANNOTATE_CHARSET_MASK)
6947 stop = stop_charset = pos;
6948 else
6949 stop_charset = end_pos;
6950 }
ec6d2bb8 6951
24a73b0a 6952 /* Compensate for CRLF and conversion. */
ff0dacd7 6953 buf_end -= 1 + MAX_ANNOTATION_LENGTH;
df7492f9 6954 while (buf < buf_end)
aaaf0b1e 6955 {
433f7f87
KH		 6956 Lisp_Object trans;
6957
df7492f9 6958 if (pos == stop)
ec6d2bb8 6959 {
df7492f9
KH		 6960 if (pos == end_pos)
6961 break;
ff0dacd7
KH		 6962 if (pos == stop_composition)
6963 buf = handle_composition_annotation (pos, end_pos, coding,
6964 buf, &stop_composition);
6965 if (pos == stop_charset)
6966 buf = handle_charset_annotation (pos, end_pos, coding,
6967 buf, &stop_charset);
6968 stop = (stop_composition < stop_charset
6969 ? stop_composition : stop_charset);
df7492f9
KH		 6970 }
6971
6972 if (! multibytep)
4776e638 6973 {
d3e4cb56 6974 EMACS_INT bytes;
aaaf0b1e 6975
ea29edf2
KH		 6976 if (coding->encoder == encode_coding_raw_text)
6977 c = *src++, pos++;
6978 else if ((bytes = MULTIBYTE_LENGTH (src, src_end)) > 0)
db274c7a 6979 c = STRING_CHAR_ADVANCE_NO_UNIFY (src), pos += bytes;
4776e638 6980 else
f03caae0 6981 c = BYTE8_TO_CHAR (*src), src++, pos++;
4776e638 6982 }
df7492f9 6983 else
db274c7a 6984 c = STRING_CHAR_ADVANCE_NO_UNIFY (src), pos++;
df7492f9
KH		 6985 if ((c == '\r') && (coding->mode & CODING_MODE_SELECTIVE_DISPLAY))
6986 c = '\n';
6987 if (! EQ (eol_type, Qunix))
aaaf0b1e 6988 {
df7492f9 6989 if (c == '\n')
aaaf0b1e 6990 {
df7492f9
KH		 6991 if (EQ (eol_type, Qdos))
6992 *buf++ = '\r';
6993 else
6994 c = '\r';
aaaf0b1e
KH		 6995 }
6996 }
433f7f87 6997
e6a54062 6998 trans = Qnil;
09ee6fdd 6999 LOOKUP_TRANSLATION_TABLE (translation_table, c, trans);
e6a54062 7000 if (NILP (trans))
433f7f87
KH		 7001 *buf++ = c;
7002 else
7003 {
7004 int from_nchars = 1, to_nchars = 1;
7005 int *lookup_buf_end;
7006 const unsigned char *p = src;
7007 int i;
7008
7009 lookup_buf[0] = c;
7010 for (i = 1; i < max_lookup && p < src_end; i++)
7011 lookup_buf[i] = STRING_CHAR_ADVANCE (p);
7012 lookup_buf_end = lookup_buf + i;
7013 trans = get_translation (trans, lookup_buf, lookup_buf_end, 1,
7014 &from_nchars, &to_nchars);
7015 if (EQ (trans, Qt)
7016 || buf + to_nchars > buf_end)
7017 break;
7018 *buf++ = *lookup_buf;
7019 for (i = 1; i < to_nchars; i++)
7020 *buf++ = XINT (AREF (trans, i));
7021 for (i = 1; i < from_nchars; i++, pos++)
7022 src += MULTIBYTE_LENGTH_NO_CHECK (src);
7023 }
aaaf0b1e 7024 }
ec6d2bb8 7025
df7492f9
KH		 7026 coding->consumed = src - coding->source;
7027 coding->consumed_char = pos - coding->src_pos;
7028 coding->charbuf_used = buf - coding->charbuf;
7029 coding->chars_at_source = 0;
aaaf0b1e
KH		 7030}
7031
4ed46869 7032
df7492f9
KH		 7033/* Encode the text at CODING->src_object into CODING->dst_object.
7034 CODING->src_object is a buffer or a string.
7035 CODING->dst_object is a buffer or nil.
7036
7037 If CODING->src_object is a buffer, it must be the current buffer.
7038 In this case, if CODING->src_pos is positive, it is a position of
7039 the source text in the buffer, otherwise. the source text is in the
7040 gap area of the buffer, and coding->src_pos specifies the offset of
7041 the text from GPT (which must be the same as PT). If this is the
7042 same buffer as CODING->dst_object, CODING->src_pos must be
7043 negative and CODING should not have `pre-write-conversion'.
7044
7045 If CODING->src_object is a string, CODING should not have
7046 `pre-write-conversion'.
7047
7048 If CODING->dst_object is a buffer, the encoded data is inserted at
7049 the current point of that buffer.
7050
7051 If CODING->dst_object is nil, the encoded data is placed at the
7052 memory area specified by CODING->destination. */
7053
7054static int
7055encode_coding (coding)
4ed46869 7056 struct coding_system *coding;
4ed46869 7057{
df7492f9 7058 Lisp_Object attrs;
7d64c6ad 7059 Lisp_Object translation_table;
09ee6fdd 7060 int max_lookup;
9861e777 7061
df7492f9 7062 attrs = CODING_ID_ATTRS (coding->id);
ea29edf2
KH		 7063 if (coding->encoder == encode_coding_raw_text)
7064 translation_table = Qnil, max_lookup = 0;
7065 else
7066 translation_table = get_translation_table (attrs, 1, &max_lookup);
4ed46869 7067
df7492f9 7068 if (BUFFERP (coding->dst_object))
8844fa83 7069 {
df7492f9
KH		 7070 set_buffer_internal (XBUFFER (coding->dst_object));
7071 coding->dst_multibyte
7072 = ! NILP (current_buffer->enable_multibyte_characters);
8844fa83 7073 }
4ed46869 7074
b73bfc1c 7075 coding->consumed = coding->consumed_char = 0;
df7492f9 7076 coding->produced = coding->produced_char = 0;
065e3595 7077 record_conversion_result (coding, CODING_RESULT_SUCCESS);
b73bfc1c 7078 coding->errors = 0;
b73bfc1c 7079
df7492f9 7080 ALLOC_CONVERSION_WORK_AREA (coding);
4ed46869 7081
df7492f9
KH		 7082 do {
7083 coding_set_source (coding);
09ee6fdd 7084 consume_chars (coding, translation_table, max_lookup);
df7492f9
KH		 7085 coding_set_destination (coding);
7086 (*(coding->encoder)) (coding);
7087 } while (coding->consumed_char < coding->src_chars);
7088
284201e4 7089 if (BUFFERP (coding->dst_object) && coding->produced_char > 0)
df7492f9
KH		 7090 insert_from_gap (coding->produced_char, coding->produced);
7091
7092 return (coding->result);
ec6d2bb8
KH		 7093}
7094
fb88bf2d 7095
24a73b0a
KH		 7096/* Name (or base name) of work buffer for code conversion. */
7097static Lisp_Object Vcode_conversion_workbuf_name;
d46c5b12 7098
24a73b0a
KH		 7099/* A working buffer used by the top level conversion. Once it is
7100 created, it is never destroyed. It has the name
7101 Vcode_conversion_workbuf_name. The other working buffers are
7102 destroyed after the use is finished, and their names are modified
7103 versions of Vcode_conversion_workbuf_name. */
7104static Lisp_Object Vcode_conversion_reused_workbuf;
b73bfc1c 7105
24a73b0a
KH		 7106/* 1 iff Vcode_conversion_reused_workbuf is already in use. */
7107static int reused_workbuf_in_use;
4ed46869 7108
24a73b0a
KH		 7109
7110/* Return a working buffer of code convesion. MULTIBYTE specifies the
7111 multibyteness of returning buffer. */
b73bfc1c 7112
f6cbaf43 7113static Lisp_Object
24a73b0a 7114make_conversion_work_buffer (multibyte)
f6cbaf43 7115 int multibyte;
df7492f9 7116{
24a73b0a
KH		 7117 Lisp_Object name, workbuf;
7118 struct buffer *current;
4ed46869 7119
24a73b0a 7120 if (reused_workbuf_in_use++)
065e3595
KH		 7121 {
7122 name = Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name, Qnil);
7123 workbuf = Fget_buffer_create (name);
7124 }
df7492f9 7125 else
065e3595 7126 {
159bd5a2 7127 if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf)))
a993c7a1
KH		 7128 Vcode_conversion_reused_workbuf
7129 = Fget_buffer_create (Vcode_conversion_workbuf_name);
7130 workbuf = Vcode_conversion_reused_workbuf;
065e3595 7131 }
24a73b0a
KH		 7132 current = current_buffer;
7133 set_buffer_internal (XBUFFER (workbuf));
df36ff1f
CY		 7134 /* We can't allow modification hooks to run in the work buffer. For
7135 instance, directory_files_internal assumes that file decoding
7136 doesn't compile new regexps. */
7137 Fset (Fmake_local_variable (Qinhibit_modification_hooks), Qt);
3ed051d4 7138 Ferase_buffer ();
df7492f9 7139 current_buffer->undo_list = Qt;
24a73b0a 7140 current_buffer->enable_multibyte_characters = multibyte ? Qt : Qnil;
df7492f9 7141 set_buffer_internal (current);
24a73b0a 7142 return workbuf;
df7492f9 7143}
d46c5b12 7144
24a73b0a 7145
4776e638 7146static Lisp_Object
24a73b0a
KH		 7147code_conversion_restore (arg)
7148 Lisp_Object arg;
4776e638 7149{
24a73b0a 7150 Lisp_Object current, workbuf;
948bdcf3 7151 struct gcpro gcpro1;
24a73b0a 7152
948bdcf3 7153 GCPRO1 (arg);
24a73b0a
KH		 7154 current = XCAR (arg);
7155 workbuf = XCDR (arg);
7156 if (! NILP (workbuf))
7157 {
7158 if (EQ (workbuf, Vcode_conversion_reused_workbuf))
7159 reused_workbuf_in_use = 0;
7160 else if (! NILP (Fbuffer_live_p (workbuf)))
7161 Fkill_buffer (workbuf);
7162 }
7163 set_buffer_internal (XBUFFER (current));
948bdcf3 7164 UNGCPRO;
4776e638
KH		 7165 return Qnil;
7166}
b73bfc1c 7167
24a73b0a
KH		 7168Lisp_Object
7169code_conversion_save (with_work_buf, multibyte)
4776e638 7170 int with_work_buf, multibyte;
df7492f9 7171{
24a73b0a 7172 Lisp_Object workbuf = Qnil;
b73bfc1c 7173
4776e638 7174 if (with_work_buf)
24a73b0a
KH		 7175 workbuf = make_conversion_work_buffer (multibyte);
7176 record_unwind_protect (code_conversion_restore,
7177 Fcons (Fcurrent_buffer (), workbuf));
4776e638 7178 return workbuf;
df7492f9 7179}
d46c5b12 7180
df7492f9
KH		 7181int
7182decode_coding_gap (coding, chars, bytes)
7183 struct coding_system *coding;
7184 EMACS_INT chars, bytes;
7185{
7186 int count = specpdl_ptr - specpdl;
5e5c78be 7187 Lisp_Object attrs;
fb88bf2d 7188
24a73b0a 7189 code_conversion_save (0, 0);
ec6d2bb8 7190
24a73b0a 7191 coding->src_object = Fcurrent_buffer ();
df7492f9
KH		 7192 coding->src_chars = chars;
7193 coding->src_bytes = bytes;
7194 coding->src_pos = -chars;
7195 coding->src_pos_byte = -bytes;
7196 coding->src_multibyte = chars < bytes;
24a73b0a 7197 coding->dst_object = coding->src_object;
df7492f9
KH		 7198 coding->dst_pos = PT;
7199 coding->dst_pos_byte = PT_BYTE;
71c81426 7200 coding->dst_multibyte = ! NILP (current_buffer->enable_multibyte_characters);
4ed46869 7201
df7492f9
KH		 7202 if (CODING_REQUIRE_DETECTION (coding))
7203 detect_coding (coding);
8f924df7 7204
9286b333 7205 coding->mode |= CODING_MODE_LAST_BLOCK;
287c57d7 7206 current_buffer->text->inhibit_shrinking = 1;
df7492f9 7207 decode_coding (coding);
287c57d7 7208 current_buffer->text->inhibit_shrinking = 0;
d46c5b12 7209
5e5c78be
KH		 7210 attrs = CODING_ID_ATTRS (coding->id);
7211 if (! NILP (CODING_ATTR_POST_READ (attrs)))
b73bfc1c 7212 {
5e5c78be
KH		 7213 EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE;
7214 Lisp_Object val;
7215
7216 TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
5e5c78be
KH		 7217 val = call1 (CODING_ATTR_POST_READ (attrs),
7218 make_number (coding->produced_char));
5e5c78be
KH		 7219 CHECK_NATNUM (val);
7220 coding->produced_char += Z - prev_Z;
7221 coding->produced += Z_BYTE - prev_Z_BYTE;
b73bfc1c 7222 }
4ed46869 7223
df7492f9 7224 unbind_to (count, Qnil);
b73bfc1c
KH		 7225 return coding->result;
7226}
52d41803 7227
4ed46869 7228int
df7492f9 7229encode_coding_gap (coding, chars, bytes)
4ed46869 7230 struct coding_system *coding;
df7492f9 7231 EMACS_INT chars, bytes;
4ed46869 7232{
df7492f9 7233 int count = specpdl_ptr - specpdl;
4ed46869 7234
24a73b0a 7235 code_conversion_save (0, 0);
4ed46869 7236
24a73b0a 7237 coding->src_object = Fcurrent_buffer ();
df7492f9
KH		 7238 coding->src_chars = chars;
7239 coding->src_bytes = bytes;
7240 coding->src_pos = -chars;
7241 coding->src_pos_byte = -bytes;
7242 coding->src_multibyte = chars < bytes;
7243 coding->dst_object = coding->src_object;
7244 coding->dst_pos = PT;
7245 coding->dst_pos_byte = PT_BYTE;
4ed46869 7246
df7492f9 7247 encode_coding (coding);
b73bfc1c 7248
df7492f9
KH		 7249 unbind_to (count, Qnil);
7250 return coding->result;
7251}
4ed46869 7252
d46c5b12 7253
df7492f9
KH		 7254/* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
7255 SRC_OBJECT into DST_OBJECT by coding context CODING.
b73bfc1c 7256
df7492f9 7257 SRC_OBJECT is a buffer, a string, or Qnil.
b73bfc1c 7258
df7492f9
KH		 7259 If it is a buffer, the text is at point of the buffer. FROM and TO
7260 are positions in the buffer.
b73bfc1c 7261
df7492f9
KH		 7262 If it is a string, the text is at the beginning of the string.
7263 FROM and TO are indices to the string.
4ed46869 7264
df7492f9
KH		 7265 If it is nil, the text is at coding->source. FROM and TO are
7266 indices to coding->source.
bb10be8b 7267
df7492f9 7268 DST_OBJECT is a buffer, Qt, or Qnil.
4ed46869 7269
df7492f9
KH		 7270 If it is a buffer, the decoded text is inserted at point of the
7271 buffer. If the buffer is the same as SRC_OBJECT, the source text
7272 is deleted.
4ed46869 7273
df7492f9
KH		 7274 If it is Qt, a string is made from the decoded text, and
7275 set in CODING->dst_object.
d46c5b12 7276
df7492f9 7277 If it is Qnil, the decoded text is stored at CODING->destination.
2cb26057 7278 The caller must allocate CODING->dst_bytes bytes at
df7492f9
KH		 7279 CODING->destination by xmalloc. If the decoded text is longer than
7280 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
7281 */
d46c5b12 7282
df7492f9
KH		 7283void
7284decode_coding_object (coding, src_object, from, from_byte, to, to_byte,
7285 dst_object)
d46c5b12 7286 struct coding_system *coding;
df7492f9
KH		 7287 Lisp_Object src_object;
7288 EMACS_INT from, from_byte, to, to_byte;
7289 Lisp_Object dst_object;
d46c5b12 7290{
df7492f9
KH		 7291 int count = specpdl_ptr - specpdl;
7292 unsigned char *destination;
7293 EMACS_INT dst_bytes;
7294 EMACS_INT chars = to - from;
7295 EMACS_INT bytes = to_byte - from_byte;
7296 Lisp_Object attrs;
4776e638 7297 int saved_pt = -1, saved_pt_byte;
64cedb0c 7298 int need_marker_adjustment = 0;
b3bfad50 7299 Lisp_Object old_deactivate_mark;
d46c5b12 7300
b3bfad50 7301 old_deactivate_mark = Vdeactivate_mark;
93dec019 7302
df7492f9 7303 if (NILP (dst_object))
d46c5b12 7304 {
df7492f9
KH		 7305 destination = coding->destination;
7306 dst_bytes = coding->dst_bytes;
d46c5b12 7307 }
93dec019 7308
df7492f9
KH		 7309 coding->src_object = src_object;
7310 coding->src_chars = chars;
7311 coding->src_bytes = bytes;
7312 coding->src_multibyte = chars < bytes;
70ad9fc4 7313
df7492f9 7314 if (STRINGP (src_object))
d46c5b12 7315 {
df7492f9
KH		 7316 coding->src_pos = from;
7317 coding->src_pos_byte = from_byte;
d46c5b12 7318 }
df7492f9 7319 else if (BUFFERP (src_object))
88993dfd 7320 {
df7492f9
KH		 7321 set_buffer_internal (XBUFFER (src_object));
7322 if (from != GPT)
7323 move_gap_both (from, from_byte);
7324 if (EQ (src_object, dst_object))
fb88bf2d 7325 {
64cedb0c
KH		 7326 struct Lisp_Marker *tail;
7327
7328 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7329 {
7330 tail->need_adjustment
7331 = tail->charpos == (tail->insertion_type ? from : to);
7332 need_marker_adjustment |= tail->need_adjustment;
7333 }
4776e638 7334 saved_pt = PT, saved_pt_byte = PT_BYTE;
df7492f9 7335 TEMP_SET_PT_BOTH (from, from_byte);
f4a3cc44 7336 current_buffer->text->inhibit_shrinking = 1;
df7492f9
KH		 7337 del_range_both (from, from_byte, to, to_byte, 1);
7338 coding->src_pos = -chars;
7339 coding->src_pos_byte = -bytes;
fb88bf2d 7340 }
df7492f9 7341 else
fb88bf2d 7342 {
df7492f9
KH		 7343 coding->src_pos = from;
7344 coding->src_pos_byte = from_byte;
fb88bf2d 7345 }
88993dfd
KH		 7346 }
7347
df7492f9
KH		 7348 if (CODING_REQUIRE_DETECTION (coding))
7349 detect_coding (coding);
7350 attrs = CODING_ID_ATTRS (coding->id);
d46c5b12 7351
2cb26057
KH		 7352 if (EQ (dst_object, Qt)
7353 || (! NILP (CODING_ATTR_POST_READ (attrs))
7354 && NILP (dst_object)))
b73bfc1c 7355 {
a1567c45
SM		 7356 coding->dst_multibyte = !CODING_FOR_UNIBYTE (coding);
7357 coding->dst_object = code_conversion_save (1, coding->dst_multibyte);
df7492f9
KH		 7358 coding->dst_pos = BEG;
7359 coding->dst_pos_byte = BEG_BYTE;
b73bfc1c 7360 }
df7492f9 7361 else if (BUFFERP (dst_object))
d46c5b12 7362 {
24a73b0a 7363 code_conversion_save (0, 0);
df7492f9
KH		 7364 coding->dst_object = dst_object;
7365 coding->dst_pos = BUF_PT (XBUFFER (dst_object));
7366 coding->dst_pos_byte = BUF_PT_BYTE (XBUFFER (dst_object));
7367 coding->dst_multibyte
7368 = ! NILP (XBUFFER (dst_object)->enable_multibyte_characters);
d46c5b12
KH		 7369 }
7370 else
7371 {
24a73b0a 7372 code_conversion_save (0, 0);
df7492f9 7373 coding->dst_object = Qnil;
0154725e
SM		 7374 /* Most callers presume this will return a multibyte result, and they
7375 won't use `binary' or `raw-text' anyway, so let's not worry about
7376 CODING_FOR_UNIBYTE. */
bb555731 7377 coding->dst_multibyte = 1;
d46c5b12
KH		 7378 }
7379
df7492f9 7380 decode_coding (coding);
fa46990e 7381
df7492f9
KH		 7382 if (BUFFERP (coding->dst_object))
7383 set_buffer_internal (XBUFFER (coding->dst_object));
d46c5b12 7384
df7492f9 7385 if (! NILP (CODING_ATTR_POST_READ (attrs)))
d46c5b12 7386 {
b3bfad50 7387 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
df7492f9 7388 EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE;
2b4f9037 7389 Lisp_Object val;
d46c5b12 7390
c0cc7f7f 7391 TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte);
b3bfad50
KH		 7392 GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
7393 old_deactivate_mark);
d4850d67
KH		 7394 val = safe_call1 (CODING_ATTR_POST_READ (attrs),
7395 make_number (coding->produced_char));
df7492f9
KH		 7396 UNGCPRO;
7397 CHECK_NATNUM (val);
7398 coding->produced_char += Z - prev_Z;
7399 coding->produced += Z_BYTE - prev_Z_BYTE;
d46c5b12 7400 }
de79a6a5 7401
df7492f9 7402 if (EQ (dst_object, Qt))
ec6d2bb8 7403 {
df7492f9
KH		 7404 coding->dst_object = Fbuffer_string ();
7405 }
7406 else if (NILP (dst_object) && BUFFERP (coding->dst_object))
7407 {
7408 set_buffer_internal (XBUFFER (coding->dst_object));
7409 if (dst_bytes < coding->produced)
7410 {
b3bfad50 7411 destination = xrealloc (destination, coding->produced);
df7492f9
KH		 7412 if (! destination)
7413 {
065e3595
KH		 7414 record_conversion_result (coding,
7415 CODING_RESULT_INSUFFICIENT_DST);
df7492f9
KH		 7416 unbind_to (count, Qnil);
7417 return;
7418 }
7419 if (BEGV < GPT && GPT < BEGV + coding->produced_char)
7420 move_gap_both (BEGV, BEGV_BYTE);
7421 bcopy (BEGV_ADDR, destination, coding->produced);
7422 coding->destination = destination;
d46c5b12 7423 }
ec6d2bb8 7424 }
b73bfc1c 7425
4776e638
KH		 7426 if (saved_pt >= 0)
7427 {
7428 /* This is the case of:
7429 (BUFFERP (src_object) && EQ (src_object, dst_object))
7430 As we have moved PT while replacing the original buffer
7431 contents, we must recover it now. */
7432 set_buffer_internal (XBUFFER (src_object));
f4a3cc44 7433 current_buffer->text->inhibit_shrinking = 0;
4776e638
KH		 7434 if (saved_pt < from)
7435 TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte);
7436 else if (saved_pt < from + chars)
7437 TEMP_SET_PT_BOTH (from, from_byte);
7438 else if (! NILP (current_buffer->enable_multibyte_characters))
7439 TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars),
7440 saved_pt_byte + (coding->produced - bytes));
7441 else
7442 TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes),
7443 saved_pt_byte + (coding->produced - bytes));
64cedb0c
KH		 7444
7445 if (need_marker_adjustment)
7446 {
7447 struct Lisp_Marker *tail;
7448
7449 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7450 if (tail->need_adjustment)
7451 {
7452 tail->need_adjustment = 0;
7453 if (tail->insertion_type)
7454 {
7455 tail->bytepos = from_byte;
7456 tail->charpos = from;
7457 }
7458 else
7459 {
7460 tail->bytepos = from_byte + coding->produced;
7461 tail->charpos
7462 = (NILP (current_buffer->enable_multibyte_characters)
7463 ? tail->bytepos : from + coding->produced_char);
7464 }
7465 }
7466 }
d46c5b12 7467 }
4776e638 7468
b3bfad50 7469 Vdeactivate_mark = old_deactivate_mark;
065e3595 7470 unbind_to (count, coding->dst_object);
d46c5b12
KH		 7471}
7472
d46c5b12 7473
df7492f9
KH		 7474void
7475encode_coding_object (coding, src_object, from, from_byte, to, to_byte,
7476 dst_object)
d46c5b12 7477 struct coding_system *coding;
df7492f9
KH		 7478 Lisp_Object src_object;
7479 EMACS_INT from, from_byte, to, to_byte;
7480 Lisp_Object dst_object;
d46c5b12 7481{
b73bfc1c 7482 int count = specpdl_ptr - specpdl;
df7492f9
KH		 7483 EMACS_INT chars = to - from;
7484 EMACS_INT bytes = to_byte - from_byte;
7485 Lisp_Object attrs;
4776e638 7486 int saved_pt = -1, saved_pt_byte;
64cedb0c 7487 int need_marker_adjustment = 0;
c02d943b 7488 int kill_src_buffer = 0;
b3bfad50 7489 Lisp_Object old_deactivate_mark;
df7492f9 7490
b3bfad50 7491 old_deactivate_mark = Vdeactivate_mark;
df7492f9
KH		 7492
7493 coding->src_object = src_object;
7494 coding->src_chars = chars;
7495 coding->src_bytes = bytes;
7496 coding->src_multibyte = chars < bytes;
7497
7498 attrs = CODING_ID_ATTRS (coding->id);
7499
64cedb0c
KH		 7500 if (EQ (src_object, dst_object))
7501 {
7502 struct Lisp_Marker *tail;
7503
7504 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7505 {
7506 tail->need_adjustment
7507 = tail->charpos == (tail->insertion_type ? from : to);
7508 need_marker_adjustment |= tail->need_adjustment;
7509 }
7510 }
7511
df7492f9 7512 if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
6bac5b12 7513 {
24a73b0a 7514 coding->src_object = code_conversion_save (1, coding->src_multibyte);
df7492f9
KH		 7515 set_buffer_internal (XBUFFER (coding->src_object));
7516 if (STRINGP (src_object))
7517 insert_from_string (src_object, from, from_byte, chars, bytes, 0);
7518 else if (BUFFERP (src_object))
7519 insert_from_buffer (XBUFFER (src_object), from, chars, 0);
7520 else
7521 insert_1_both (coding->source + from, chars, bytes, 0, 0, 0);
d46c5b12 7522
df7492f9
KH		 7523 if (EQ (src_object, dst_object))
7524 {
7525 set_buffer_internal (XBUFFER (src_object));
4776e638 7526 saved_pt = PT, saved_pt_byte = PT_BYTE;
df7492f9
KH		 7527 del_range_both (from, from_byte, to, to_byte, 1);
7528 set_buffer_internal (XBUFFER (coding->src_object));
7529 }
7530
d4850d67
KH		 7531 {
7532 Lisp_Object args[3];
b3bfad50 7533 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
d4850d67 7534
b3bfad50
KH		 7535 GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
7536 old_deactivate_mark);
d4850d67
KH		 7537 args[0] = CODING_ATTR_PRE_WRITE (attrs);
7538 args[1] = make_number (BEG);
7539 args[2] = make_number (Z);
7540 safe_call (3, args);
b3bfad50 7541 UNGCPRO;
d4850d67 7542 }
c02d943b
KH		 7543 if (XBUFFER (coding->src_object) != current_buffer)
7544 kill_src_buffer = 1;
ac87bbef 7545 coding->src_object = Fcurrent_buffer ();
df7492f9
KH		 7546 if (BEG != GPT)
7547 move_gap_both (BEG, BEG_BYTE);
7548 coding->src_chars = Z - BEG;
7549 coding->src_bytes = Z_BYTE - BEG_BYTE;
7550 coding->src_pos = BEG;
7551 coding->src_pos_byte = BEG_BYTE;
7552 coding->src_multibyte = Z < Z_BYTE;
7553 }
7554 else if (STRINGP (src_object))
d46c5b12 7555 {
24a73b0a 7556 code_conversion_save (0, 0);
df7492f9
KH		 7557 coding->src_pos = from;
7558 coding->src_pos_byte = from_byte;
b73bfc1c 7559 }
df7492f9 7560 else if (BUFFERP (src_object))
b73bfc1c 7561 {
24a73b0a 7562 code_conversion_save (0, 0);
df7492f9 7563 set_buffer_internal (XBUFFER (src_object));
df7492f9 7564 if (EQ (src_object, dst_object))
d46c5b12 7565 {
4776e638 7566 saved_pt = PT, saved_pt_byte = PT_BYTE;
ff0dacd7
KH		 7567 coding->src_object = del_range_1 (from, to, 1, 1);
7568 coding->src_pos = 0;
7569 coding->src_pos_byte = 0;
d46c5b12 7570 }
df7492f9 7571 else
d46c5b12 7572 {
ff0dacd7
KH		 7573 if (from < GPT && to >= GPT)
7574 move_gap_both (from, from_byte);
df7492f9
KH		 7575 coding->src_pos = from;
7576 coding->src_pos_byte = from_byte;
d46c5b12 7577 }
d46c5b12 7578 }
4776e638 7579 else
24a73b0a 7580 code_conversion_save (0, 0);
d46c5b12 7581
df7492f9 7582 if (BUFFERP (dst_object))
88993dfd 7583 {
df7492f9 7584 coding->dst_object = dst_object;
28f67a95
KH		 7585 if (EQ (src_object, dst_object))
7586 {
7587 coding->dst_pos = from;
7588 coding->dst_pos_byte = from_byte;
7589 }
7590 else
7591 {
319a3947
KH		 7592 struct buffer *current = current_buffer;
7593
7594 set_buffer_temp (XBUFFER (dst_object));
7595 coding->dst_pos = PT;
7596 coding->dst_pos_byte = PT_BYTE;
7597 move_gap_both (coding->dst_pos, coding->dst_pos_byte);
7598 set_buffer_temp (current);
28f67a95 7599 }
df7492f9
KH		 7600 coding->dst_multibyte
7601 = ! NILP (XBUFFER (dst_object)->enable_multibyte_characters);
88993dfd 7602 }
df7492f9 7603 else if (EQ (dst_object, Qt))
d46c5b12 7604 {
df7492f9 7605 coding->dst_object = Qnil;
df7492f9 7606 coding->dst_bytes = coding->src_chars;
ac87bbef
KH		 7607 if (coding->dst_bytes == 0)
7608 coding->dst_bytes = 1;
7609 coding->destination = (unsigned char *) xmalloc (coding->dst_bytes);
df7492f9 7610 coding->dst_multibyte = 0;
d46c5b12
KH		 7611 }
7612 else
7613 {
df7492f9
KH		 7614 coding->dst_object = Qnil;
7615 coding->dst_multibyte = 0;
d46c5b12
KH		 7616 }
7617
df7492f9 7618 encode_coding (coding);
d46c5b12 7619
df7492f9 7620 if (EQ (dst_object, Qt))
d46c5b12 7621 {
df7492f9
KH		 7622 if (BUFFERP (coding->dst_object))
7623 coding->dst_object = Fbuffer_string ();
7624 else
d46c5b12 7625 {
df7492f9
KH		 7626 coding->dst_object
7627 = make_unibyte_string ((char *) coding->destination,
7628 coding->produced);
7629 xfree (coding->destination);
d46c5b12 7630 }
4ed46869 7631 }
d46c5b12 7632
4776e638
KH		 7633 if (saved_pt >= 0)
7634 {
7635 /* This is the case of:
7636 (BUFFERP (src_object) && EQ (src_object, dst_object))
7637 As we have moved PT while replacing the original buffer
7638 contents, we must recover it now. */
7639 set_buffer_internal (XBUFFER (src_object));
7640 if (saved_pt < from)
7641 TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte);
7642 else if (saved_pt < from + chars)
7643 TEMP_SET_PT_BOTH (from, from_byte);
7644 else if (! NILP (current_buffer->enable_multibyte_characters))
7645 TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars),
7646 saved_pt_byte + (coding->produced - bytes));
d46c5b12 7647 else
4776e638
KH		 7648 TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes),
7649 saved_pt_byte + (coding->produced - bytes));
64cedb0c
KH		 7650
7651 if (need_marker_adjustment)
7652 {
7653 struct Lisp_Marker *tail;
7654
7655 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7656 if (tail->need_adjustment)
7657 {
7658 tail->need_adjustment = 0;
7659 if (tail->insertion_type)
7660 {
7661 tail->bytepos = from_byte;
7662 tail->charpos = from;
7663 }
7664 else
7665 {
7666 tail->bytepos = from_byte + coding->produced;
7667 tail->charpos
7668 = (NILP (current_buffer->enable_multibyte_characters)
7669 ? tail->bytepos : from + coding->produced_char);
7670 }
7671 }
7672 }
4776e638
KH		 7673 }
7674
c02d943b
KH		 7675 if (kill_src_buffer)
7676 Fkill_buffer (coding->src_object);
b3bfad50
KH		 7677
7678 Vdeactivate_mark = old_deactivate_mark;
df7492f9 7679 unbind_to (count, Qnil);
b73bfc1c
KH		 7680}
7681
df7492f9 7682
b73bfc1c 7683Lisp_Object
df7492f9 7684preferred_coding_system ()
b73bfc1c 7685{
df7492f9 7686 int id = coding_categories[coding_priorities[0]].id;
2391eaa4 7687
df7492f9 7688 return CODING_ID_NAME (id);
4ed46869
KH		 7689}
7690
7691\f
7692#ifdef emacs
1397dc18 7693/*** 8. Emacs Lisp library functions ***/
4ed46869 7694
4ed46869 7695DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
48b0f3ae 7696 doc: /* Return t if OBJECT is nil or a coding-system.
df7492f9 7697See the documentation of `define-coding-system' for information
48b0f3ae 7698about coding-system objects. */)
d4a1d553
JB		 7699 (object)
7700 Lisp_Object object;
4ed46869 7701{
d4a1d553
JB		 7702 if (NILP (object)
7703 || CODING_SYSTEM_ID (object) >= 0)
44e8490d 7704 return Qt;
d4a1d553
JB		 7705 if (! SYMBOLP (object)
7706 || NILP (Fget (object, Qcoding_system_define_form)))
44e8490d
KH		 7707 return Qnil;
7708 return Qt;
4ed46869
KH		 7709}
7710
9d991de8
RS		 7711DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
7712 Sread_non_nil_coding_system, 1, 1, 0,
48b0f3ae
PJ		 7713 doc: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7714 (prompt)
4ed46869
KH		 7715 Lisp_Object prompt;
7716{
e0e989f6 7717 Lisp_Object val;
9d991de8
RS		 7718 do
7719 {
4608c386
KH		 7720 val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
7721 Qt, Qnil, Qcoding_system_history, Qnil, Qnil);
9d991de8 7722 }
8f924df7 7723 while (SCHARS (val) == 0);
e0e989f6 7724 return (Fintern (val, Qnil));
4ed46869
KH		 7725}
7726
9b787f3e 7727DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
48b0f3ae 7728 doc: /* Read a coding system from the minibuffer, prompting with string PROMPT.
c7183fb8
GM		 7729If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
7730Ignores case when completing coding systems (all Emacs coding systems
7731are lower-case). */)
48b0f3ae 7732 (prompt, default_coding_system)
9b787f3e 7733 Lisp_Object prompt, default_coding_system;
4ed46869 7734{
f44d27ce 7735 Lisp_Object val;
c7183fb8
GM		 7736 int count = SPECPDL_INDEX ();
7737
9b787f3e 7738 if (SYMBOLP (default_coding_system))
57d25e6f 7739 default_coding_system = SYMBOL_NAME (default_coding_system);
c7183fb8 7740 specbind (Qcompletion_ignore_case, Qt);
4608c386 7741 val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
9b787f3e
RS		 7742 Qt, Qnil, Qcoding_system_history,
7743 default_coding_system, Qnil);
c7183fb8 7744 unbind_to (count, Qnil);
8f924df7 7745 return (SCHARS (val) == 0 ? Qnil : Fintern (val, Qnil));
4ed46869
KH		 7746}
7747
7748DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
7749 1, 1, 0,
48b0f3ae 7750 doc: /* Check validity of CODING-SYSTEM.
9ffd559c
KH		 7751If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7752It is valid if it is nil or a symbol defined as a coding system by the
7753function `define-coding-system'. */)
df7492f9 7754 (coding_system)
4ed46869
KH		 7755 Lisp_Object coding_system;
7756{
44e8490d
KH		 7757 Lisp_Object define_form;
7758
7759 define_form = Fget (coding_system, Qcoding_system_define_form);
7760 if (! NILP (define_form))
7761 {
7762 Fput (coding_system, Qcoding_system_define_form, Qnil);
7763 safe_eval (define_form);
7764 }
4ed46869
KH		 7765 if (!NILP (Fcoding_system_p (coding_system)))
7766 return coding_system;
fcad4ec4 7767 xsignal1 (Qcoding_system_error, coding_system);
4ed46869 7768}
df7492f9 7769
3a73fa5d 7770\f
89528eb3
KH		 7771/* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7772 HIGHEST is nonzero, return the coding system of the highest
7773 priority among the detected coding systems. Otherwize return a
7774 list of detected coding systems sorted by their priorities. If
7775 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7776 multibyte form but contains only ASCII and eight-bit chars.
7777 Otherwise, the bytes are raw bytes.
7778
7779 CODING-SYSTEM controls the detection as below:
7780
7781 If it is nil, detect both text-format and eol-format. If the
7782 text-format part of CODING-SYSTEM is already specified
7783 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7784 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7785 detect only text-format. */
7786
d46c5b12 7787Lisp_Object
24a73b0a
KH		 7788detect_coding_system (src, src_chars, src_bytes, highest, multibytep,
7789 coding_system)
8f924df7 7790 const unsigned char *src;
13818c30
SM		 7791 EMACS_INT src_chars, src_bytes;
7792 int highest;
0a28aafb 7793 int multibytep;
df7492f9 7794 Lisp_Object coding_system;
4ed46869 7795{
8f924df7 7796 const unsigned char *src_end = src + src_bytes;
df7492f9 7797 Lisp_Object attrs, eol_type;
4533845d 7798 Lisp_Object val = Qnil;
df7492f9 7799 struct coding_system coding;
89528eb3 7800 int id;
ff0dacd7 7801 struct coding_detection_info detect_info;
24a73b0a 7802 enum coding_category base_category;
2f3cbb32 7803 int null_byte_found = 0, eight_bit_found = 0;
b73bfc1c 7804
df7492f9
KH		 7805 if (NILP (coding_system))
7806 coding_system = Qundecided;
7807 setup_coding_system (coding_system, &coding);
7808 attrs = CODING_ID_ATTRS (coding.id);
7809 eol_type = CODING_ID_EOL_TYPE (coding.id);
89528eb3 7810 coding_system = CODING_ATTR_BASE_NAME (attrs);
4ed46869 7811
df7492f9 7812 coding.source = src;
24a73b0a 7813 coding.src_chars = src_chars;
df7492f9
KH		 7814 coding.src_bytes = src_bytes;
7815 coding.src_multibyte = multibytep;
7816 coding.consumed = 0;
89528eb3 7817 coding.mode |= CODING_MODE_LAST_BLOCK;
c0e16b14 7818 coding.head_ascii = 0;
d46c5b12 7819
ff0dacd7 7820 detect_info.checked = detect_info.found = detect_info.rejected = 0;
d46c5b12 7821
89528eb3 7822 /* At first, detect text-format if necessary. */
24a73b0a
KH		 7823 base_category = XINT (CODING_ATTR_CATEGORY (attrs));
7824 if (base_category == coding_category_undecided)
4ed46869 7825 {
ff0dacd7
KH		 7826 enum coding_category category;
7827 struct coding_system *this;
7828 int c, i;
88993dfd 7829
24a73b0a 7830 /* Skip all ASCII bytes except for a few ISO2022 controls. */
2f3cbb32 7831 for (; src < src_end; src++)
4ed46869 7832 {
df7492f9 7833 c = *src;
6cb21a4f 7834 if (c & 0x80)
6cb21a4f 7835 {
2f3cbb32 7836 eight_bit_found = 1;
2f3cbb32
KH		 7837 if (null_byte_found)
7838 break;
7839 }
c0e16b14 7840 else if (c < 0x20)
2f3cbb32
KH		 7841 {
7842 if ((c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
7843 && ! inhibit_iso_escape_detection
7844 && ! detect_info.checked)
6cb21a4f 7845 {
2f3cbb32
KH		 7846 if (detect_coding_iso_2022 (&coding, &detect_info))
7847 {
7848 /* We have scanned the whole data. */
7849 if (! (detect_info.rejected & CATEGORY_MASK_ISO_7_ELSE))
c0e16b14
KH		 7850 {
7851 /* We didn't find an 8-bit code. We may
7852 have found a null-byte, but it's very
7853 rare that a binary file confirm to
7854 ISO-2022. */
7855 src = src_end;
7856 coding.head_ascii = src - coding.source;
7857 }
7858 detect_info.rejected |= ~CATEGORY_MASK_ISO_ESCAPE;
2f3cbb32
KH		 7859 break;
7860 }
7861 }
97b1b294 7862 else if (! c && !inhibit_null_byte_detection)
2f3cbb32
KH		 7863 {
7864 null_byte_found = 1;
7865 if (eight_bit_found)
7866 break;
6cb21a4f 7867 }
c006c0c8
KH		 7868 if (! eight_bit_found)
7869 coding.head_ascii++;
6cb21a4f 7870 }
c006c0c8 7871 else if (! eight_bit_found)
c0e16b14 7872 coding.head_ascii++;
4ed46869 7873 }
88993dfd 7874
2f3cbb32
KH		 7875 if (null_byte_found || eight_bit_found
7876 || coding.head_ascii < coding.src_bytes
6cb21a4f
KH		 7877 || detect_info.found)
7878 {
2f3cbb32 7879 if (coding.head_ascii == coding.src_bytes)
6cb21a4f
KH		 7880 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7881 for (i = 0; i < coding_category_raw_text; i++)
ff0dacd7 7882 {
6cb21a4f 7883 category = coding_priorities[i];
c7266f4a 7884 this = coding_categories + category;
6cb21a4f 7885 if (detect_info.found & (1 << category))
ff0dacd7
KH		 7886 break;
7887 }
6cb21a4f 7888 else
2f3cbb32
KH		 7889 {
7890 if (null_byte_found)
7891 {
7892 detect_info.checked |= ~CATEGORY_MASK_UTF_16;
7893 detect_info.rejected |= ~CATEGORY_MASK_UTF_16;
7894 }
7895 for (i = 0; i < coding_category_raw_text; i++)
7896 {
7897 category = coding_priorities[i];
7898 this = coding_categories + category;
6cb21a4f 7899
2f3cbb32
KH		 7900 if (this->id < 0)
7901 {
7902 /* No coding system of this category is defined. */
7903 detect_info.rejected |= (1 << category);
7904 }
7905 else if (category >= coding_category_raw_text)
7906 continue;
7907 else if (detect_info.checked & (1 << category))
7908 {
7909 if (highest
7910 && (detect_info.found & (1 << category)))
6cb21a4f 7911 break;
2f3cbb32
KH		 7912 }
7913 else if ((*(this->detector)) (&coding, &detect_info)
7914 && highest
7915 && (detect_info.found & (1 << category)))
7916 {
7917 if (category == coding_category_utf_16_auto)
7918 {
7919 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
7920 category = coding_category_utf_16_le;
7921 else
7922 category = coding_category_utf_16_be;
7923 }
7924 break;
7925 }
7926 }
7927 }
6cb21a4f 7928 }
ec6d2bb8 7929
4cddb209
KH		 7930 if ((detect_info.rejected & CATEGORY_MASK_ANY) == CATEGORY_MASK_ANY
7931 || null_byte_found)
ec6d2bb8 7932 {
ff0dacd7 7933 detect_info.found = CATEGORY_MASK_RAW_TEXT;
4cddb209 7934 id = CODING_SYSTEM_ID (Qno_conversion);
89528eb3
KH		 7935 val = Fcons (make_number (id), Qnil);
7936 }
ff0dacd7 7937 else if (! detect_info.rejected && ! detect_info.found)
89528eb3 7938 {
ff0dacd7 7939 detect_info.found = CATEGORY_MASK_ANY;
89528eb3
KH		 7940 id = coding_categories[coding_category_undecided].id;
7941 val = Fcons (make_number (id), Qnil);
7942 }
7943 else if (highest)
7944 {
ff0dacd7 7945 if (detect_info.found)
ec6d2bb8 7946 {
ff0dacd7
KH		 7947 detect_info.found = 1 << category;
7948 val = Fcons (make_number (this->id), Qnil);
7949 }
7950 else
7951 for (i = 0; i < coding_category_raw_text; i++)
7952 if (! (detect_info.rejected & (1 << coding_priorities[i])))
7953 {
7954 detect_info.found = 1 << coding_priorities[i];
7955 id = coding_categories[coding_priorities[i]].id;
7956 val = Fcons (make_number (id), Qnil);
7957 break;
7958 }
7959 }
89528eb3
KH		 7960 else
7961 {
ff0dacd7
KH		 7962 int mask = detect_info.rejected | detect_info.found;
7963 int found = 0;
ec6d2bb8 7964
89528eb3 7965 for (i = coding_category_raw_text - 1; i >= 0; i--)
ff0dacd7
KH		 7966 {
7967 category = coding_priorities[i];
7968 if (! (mask & (1 << category)))
ec6d2bb8 7969 {
ff0dacd7
KH		 7970 found |= 1 << category;
7971 id = coding_categories[category].id;
c7266f4a
KH		 7972 if (id >= 0)
7973 val = Fcons (make_number (id), val);
ff0dacd7
KH		 7974 }
7975 }
7976 for (i = coding_category_raw_text - 1; i >= 0; i--)
7977 {
7978 category = coding_priorities[i];
7979 if (detect_info.found & (1 << category))
7980 {
7981 id = coding_categories[category].id;
7982 val = Fcons (make_number (id), val);
ec6d2bb8 7983 }
ec6d2bb8 7984 }
ff0dacd7 7985 detect_info.found |= found;
ec6d2bb8 7986 }
ec6d2bb8 7987 }
a470d443
KH		 7988 else if (base_category == coding_category_utf_8_auto)
7989 {
7990 if (detect_coding_utf_8 (&coding, &detect_info))
7991 {
7992 struct coding_system *this;
7993
7994 if (detect_info.found & CATEGORY_MASK_UTF_8_SIG)
7995 this = coding_categories + coding_category_utf_8_sig;
7996 else
7997 this = coding_categories + coding_category_utf_8_nosig;
7998 val = Fcons (make_number (this->id), Qnil);
7999 }
8000 }
24a73b0a
KH		 8001 else if (base_category == coding_category_utf_16_auto)
8002 {
8003 if (detect_coding_utf_16 (&coding, &detect_info))
8004 {
24a73b0a
KH		 8005 struct coding_system *this;
8006
8007 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
8008 this = coding_categories + coding_category_utf_16_le;
8009 else if (detect_info.found & CATEGORY_MASK_UTF_16_BE)
8010 this = coding_categories + coding_category_utf_16_be;
8011 else if (detect_info.rejected & CATEGORY_MASK_UTF_16_LE_NOSIG)
8012 this = coding_categories + coding_category_utf_16_be_nosig;
8013 else
8014 this = coding_categories + coding_category_utf_16_le_nosig;
8015 val = Fcons (make_number (this->id), Qnil);
8016 }
8017 }
df7492f9
KH		 8018 else
8019 {
ff0dacd7 8020 detect_info.found = 1 << XINT (CODING_ATTR_CATEGORY (attrs));
89528eb3 8021 val = Fcons (make_number (coding.id), Qnil);
4ed46869 8022 }
df7492f9 8023
89528eb3 8024 /* Then, detect eol-format if necessary. */
df7492f9 8025 {
4533845d 8026 int normal_eol = -1, utf_16_be_eol = -1, utf_16_le_eol = -1;
df7492f9
KH		 8027 Lisp_Object tail;
8028
89528eb3
KH		 8029 if (VECTORP (eol_type))
8030 {
ff0dacd7 8031 if (detect_info.found & ~CATEGORY_MASK_UTF_16)
2f3cbb32
KH		 8032 {
8033 if (null_byte_found)
8034 normal_eol = EOL_SEEN_LF;
8035 else
8036 normal_eol = detect_eol (coding.source, src_bytes,
8037 coding_category_raw_text);
8038 }
ff0dacd7
KH		 8039 if (detect_info.found & (CATEGORY_MASK_UTF_16_BE
8040 | CATEGORY_MASK_UTF_16_BE_NOSIG))
89528eb3
KH		 8041 utf_16_be_eol = detect_eol (coding.source, src_bytes,
8042 coding_category_utf_16_be);
ff0dacd7
KH		 8043 if (detect_info.found & (CATEGORY_MASK_UTF_16_LE
8044 | CATEGORY_MASK_UTF_16_LE_NOSIG))
89528eb3
KH		 8045 utf_16_le_eol = detect_eol (coding.source, src_bytes,
8046 coding_category_utf_16_le);
8047 }
8048 else
8049 {
8050 if (EQ (eol_type, Qunix))
8051 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_LF;
8052 else if (EQ (eol_type, Qdos))
8053 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CRLF;
8054 else
8055 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CR;
8056 }
8057
df7492f9
KH		 8058 for (tail = val; CONSP (tail); tail = XCDR (tail))
8059 {
89528eb3 8060 enum coding_category category;
df7492f9 8061 int this_eol;
89528eb3
KH		 8062
8063 id = XINT (XCAR (tail));
8064 attrs = CODING_ID_ATTRS (id);
8065 category = XINT (CODING_ATTR_CATEGORY (attrs));
8066 eol_type = CODING_ID_EOL_TYPE (id);
df7492f9
KH		 8067 if (VECTORP (eol_type))
8068 {
89528eb3
KH		 8069 if (category == coding_category_utf_16_be
8070 || category == coding_category_utf_16_be_nosig)
8071 this_eol = utf_16_be_eol;
8072 else if (category == coding_category_utf_16_le
8073 || category == coding_category_utf_16_le_nosig)
8074 this_eol = utf_16_le_eol;
df7492f9 8075 else
89528eb3
KH		 8076 this_eol = normal_eol;
8077
df7492f9
KH		 8078 if (this_eol == EOL_SEEN_LF)
8079 XSETCAR (tail, AREF (eol_type, 0));
8080 else if (this_eol == EOL_SEEN_CRLF)
8081 XSETCAR (tail, AREF (eol_type, 1));
8082 else if (this_eol == EOL_SEEN_CR)
8083 XSETCAR (tail, AREF (eol_type, 2));
89528eb3
KH		 8084 else
8085 XSETCAR (tail, CODING_ID_NAME (id));
df7492f9 8086 }
89528eb3
KH		 8087 else
8088 XSETCAR (tail, CODING_ID_NAME (id));
df7492f9
KH		 8089 }
8090 }
ec6d2bb8 8091
4533845d 8092 return (highest ? (CONSP (val) ? XCAR (val) : Qnil) : val);
ec6d2bb8
KH		 8093}
8094
ec6d2bb8 8095
d46c5b12
KH		 8096DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
8097 2, 3, 0,
48b0f3ae
PJ		 8098 doc: /* Detect coding system of the text in the region between START and END.
8099Return a list of possible coding systems ordered by priority.
ec6d2bb8 8100
12e0131a 8101If only ASCII characters are found (except for such ISO-2022 control
d4a1d553
JB		 8102characters as ESC), it returns a list of single element `undecided'
8103or its subsidiary coding system according to a detected end-of-line
8104format.
ec6d2bb8 8105
48b0f3ae
PJ		 8106If optional argument HIGHEST is non-nil, return the coding system of
8107highest priority. */)
8108 (start, end, highest)
d46c5b12
KH		 8109 Lisp_Object start, end, highest;
8110{
8111 int from, to;
8112 int from_byte, to_byte;
ec6d2bb8 8113
b7826503
PJ		 8114 CHECK_NUMBER_COERCE_MARKER (start);
8115 CHECK_NUMBER_COERCE_MARKER (end);
ec6d2bb8 8116
d46c5b12
KH		 8117 validate_region (&start, &end);
8118 from = XINT (start), to = XINT (end);
8119 from_byte = CHAR_TO_BYTE (from);
8120 to_byte = CHAR_TO_BYTE (to);
ec6d2bb8 8121
d46c5b12
KH		 8122 if (from < GPT && to >= GPT)
8123 move_gap_both (to, to_byte);
c210f766 8124
d46c5b12 8125 return detect_coding_system (BYTE_POS_ADDR (from_byte),
24a73b0a 8126 to - from, to_byte - from_byte,
0a28aafb
KH		 8127 !NILP (highest),
8128 !NILP (current_buffer
df7492f9
KH		 8129 ->enable_multibyte_characters),
8130 Qnil);
ec6d2bb8
KH		 8131}
8132
d46c5b12
KH		 8133DEFUN ("detect-coding-string", Fdetect_coding_string, Sdetect_coding_string,
8134 1, 2, 0,
48b0f3ae
PJ		 8135 doc: /* Detect coding system of the text in STRING.
8136Return a list of possible coding systems ordered by priority.
fb88bf2d 8137
12e0131a 8138If only ASCII characters are found (except for such ISO-2022 control
d4a1d553
JB		 8139characters as ESC), it returns a list of single element `undecided'
8140or its subsidiary coding system according to a detected end-of-line
8141format.
d46c5b12 8142
48b0f3ae
PJ		 8143If optional argument HIGHEST is non-nil, return the coding system of
8144highest priority. */)
8145 (string, highest)
d46c5b12
KH		 8146 Lisp_Object string, highest;
8147{
b7826503 8148 CHECK_STRING (string);
b73bfc1c 8149
24a73b0a
KH		 8150 return detect_coding_system (SDATA (string),
8151 SCHARS (string), SBYTES (string),
8f924df7 8152 !NILP (highest), STRING_MULTIBYTE (string),
df7492f9 8153 Qnil);
4ed46869 8154}
4ed46869 8155
b73bfc1c 8156
df7492f9
KH		 8157static INLINE int
8158char_encodable_p (c, attrs)
8159 int c;
8160 Lisp_Object attrs;
05e6f5dc 8161{
df7492f9 8162 Lisp_Object tail;
df7492f9 8163 struct charset *charset;
7d64c6ad 8164 Lisp_Object translation_table;
d46c5b12 8165
7d64c6ad 8166 translation_table = CODING_ATTR_TRANS_TBL (attrs);
a6f87d34 8167 if (! NILP (translation_table))
7d64c6ad 8168 c = translate_char (translation_table, c);
df7492f9
KH		 8169 for (tail = CODING_ATTR_CHARSET_LIST (attrs);
8170 CONSP (tail); tail = XCDR (tail))
e133c8fa 8171 {
df7492f9
KH		 8172 charset = CHARSET_FROM_ID (XINT (XCAR (tail)));
8173 if (CHAR_CHARSET_P (c, charset))
8174 break;
e133c8fa 8175 }
df7492f9 8176 return (! NILP (tail));
05e6f5dc 8177}
83fa074f 8178
fb88bf2d 8179
df7492f9
KH		 8180/* Return a list of coding systems that safely encode the text between
8181 START and END. If EXCLUDE is non-nil, it is a list of coding
8182 systems not to check. The returned list doesn't contain any such
48468dac 8183 coding systems. In any case, if the text contains only ASCII or is
df7492f9 8184 unibyte, return t. */
e077cc80 8185
df7492f9
KH		 8186DEFUN ("find-coding-systems-region-internal",
8187 Ffind_coding_systems_region_internal,
8188 Sfind_coding_systems_region_internal, 2, 3, 0,
8189 doc: /* Internal use only. */)
8190 (start, end, exclude)
8191 Lisp_Object start, end, exclude;
8192{
8193 Lisp_Object coding_attrs_list, safe_codings;
8194 EMACS_INT start_byte, end_byte;
7c78e542 8195 const unsigned char *p, *pbeg, *pend;
df7492f9
KH		 8196 int c;
8197 Lisp_Object tail, elt;
d46c5b12 8198
df7492f9
KH		 8199 if (STRINGP (start))
8200 {
8201 if (!STRING_MULTIBYTE (start)
8f924df7 8202 || SCHARS (start) == SBYTES (start))
df7492f9
KH		 8203 return Qt;
8204 start_byte = 0;
8f924df7 8205 end_byte = SBYTES (start);
df7492f9
KH		 8206 }
8207 else
d46c5b12 8208 {
df7492f9
KH		 8209 CHECK_NUMBER_COERCE_MARKER (start);
8210 CHECK_NUMBER_COERCE_MARKER (end);
8211 if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
8212 args_out_of_range (start, end);
8213 if (NILP (current_buffer->enable_multibyte_characters))
8214 return Qt;
8215 start_byte = CHAR_TO_BYTE (XINT (start));
8216 end_byte = CHAR_TO_BYTE (XINT (end));
8217 if (XINT (end) - XINT (start) == end_byte - start_byte)
8218 return Qt;
d46c5b12 8219
e1c23804 8220 if (XINT (start) < GPT && XINT (end) > GPT)
d46c5b12 8221 {
e1c23804
DL		 8222 if ((GPT - XINT (start)) < (XINT (end) - GPT))
8223 move_gap_both (XINT (start), start_byte);
df7492f9 8224 else
e1c23804 8225 move_gap_both (XINT (end), end_byte);
d46c5b12
KH		 8226 }
8227 }
8228
df7492f9
KH		 8229 coding_attrs_list = Qnil;
8230 for (tail = Vcoding_system_list; CONSP (tail); tail = XCDR (tail))
8231 if (NILP (exclude)
8232 || NILP (Fmemq (XCAR (tail), exclude)))
8233 {
8234 Lisp_Object attrs;
d46c5b12 8235
df7492f9
KH		 8236 attrs = AREF (CODING_SYSTEM_SPEC (XCAR (tail)), 0);
8237 if (EQ (XCAR (tail), CODING_ATTR_BASE_NAME (attrs))
8238 && ! EQ (CODING_ATTR_TYPE (attrs), Qundecided))
7d64c6ad
KH		 8239 {
8240 ASET (attrs, coding_attr_trans_tbl,
2170c8f0 8241 get_translation_table (attrs, 1, NULL));
7d64c6ad
KH		 8242 coding_attrs_list = Fcons (attrs, coding_attrs_list);
8243 }
df7492f9 8244 }
d46c5b12 8245
df7492f9 8246 if (STRINGP (start))
8f924df7 8247 p = pbeg = SDATA (start);
df7492f9
KH		 8248 else
8249 p = pbeg = BYTE_POS_ADDR (start_byte);
8250 pend = p + (end_byte - start_byte);
b843d1ae 8251
df7492f9
KH		 8252 while (p < pend && ASCII_BYTE_P (*p)) p++;
8253 while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
d46c5b12 8254
05e6f5dc 8255 while (p < pend)
72d1a715 8256 {
df7492f9
KH		 8257 if (ASCII_BYTE_P (*p))
8258 p++;
72d1a715
RS		 8259 else
8260 {
df7492f9 8261 c = STRING_CHAR_ADVANCE (p);
12410ef1 8262
df7492f9
KH		 8263 charset_map_loaded = 0;
8264 for (tail = coding_attrs_list; CONSP (tail);)
8265 {
8266 elt = XCAR (tail);
8267 if (NILP (elt))
8268 tail = XCDR (tail);
8269 else if (char_encodable_p (c, elt))
8270 tail = XCDR (tail);
8271 else if (CONSP (XCDR (tail)))
8272 {
8273 XSETCAR (tail, XCAR (XCDR (tail)));
8274 XSETCDR (tail, XCDR (XCDR (tail)));
8275 }
8276 else
8277 {
8278 XSETCAR (tail, Qnil);
8279 tail = XCDR (tail);
8280 }
8281 }
8282 if (charset_map_loaded)
8283 {
8284 EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
05e6f5dc 8285
df7492f9 8286 if (STRINGP (start))
8f924df7 8287 pbeg = SDATA (start);
df7492f9
KH		 8288 else
8289 pbeg = BYTE_POS_ADDR (start_byte);
8290 p = pbeg + p_offset;
8291 pend = pbeg + pend_offset;
8292 }
8293 }
ec6d2bb8 8294 }
fb88bf2d 8295
988b3759 8296 safe_codings = list2 (Qraw_text, Qno_conversion);
df7492f9
KH		 8297 for (tail = coding_attrs_list; CONSP (tail); tail = XCDR (tail))
8298 if (! NILP (XCAR (tail)))
8299 safe_codings = Fcons (CODING_ATTR_BASE_NAME (XCAR (tail)), safe_codings);
ec6d2bb8 8300
05e6f5dc
KH		 8301 return safe_codings;
8302}
4956c225 8303
d46c5b12 8304
8f924df7
KH		 8305DEFUN ("unencodable-char-position", Funencodable_char_position,
8306 Sunencodable_char_position, 3, 5, 0,
8307 doc: /*
8308Return position of first un-encodable character in a region.
d4a1d553 8309START and END specify the region and CODING-SYSTEM specifies the
8f924df7 8310encoding to check. Return nil if CODING-SYSTEM does encode the region.
d46c5b12 8311
8f924df7
KH		 8312If optional 4th argument COUNT is non-nil, it specifies at most how
8313many un-encodable characters to search. In this case, the value is a
8314list of positions.
d46c5b12 8315
8f924df7
KH		 8316If optional 5th argument STRING is non-nil, it is a string to search
8317for un-encodable characters. In that case, START and END are indexes
8318to the string. */)
8319 (start, end, coding_system, count, string)
8320 Lisp_Object start, end, coding_system, count, string;
8321{
8322 int n;
8323 struct coding_system coding;
7d64c6ad 8324 Lisp_Object attrs, charset_list, translation_table;
8f924df7
KH		 8325 Lisp_Object positions;
8326 int from, to;
8327 const unsigned char *p, *stop, *pend;
8328 int ascii_compatible;
fb88bf2d 8329
8f924df7
KH		 8330 setup_coding_system (Fcheck_coding_system (coding_system), &coding);
8331 attrs = CODING_ID_ATTRS (coding.id);
8332 if (EQ (CODING_ATTR_TYPE (attrs), Qraw_text))
8333 return Qnil;
8334 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
8335 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
2170c8f0 8336 translation_table = get_translation_table (attrs, 1, NULL);
fb88bf2d 8337
8f924df7
KH		 8338 if (NILP (string))
8339 {
8340 validate_region (&start, &end);
8341 from = XINT (start);
8342 to = XINT (end);
8343 if (NILP (current_buffer->enable_multibyte_characters)
8344 || (ascii_compatible
8345 && (to - from) == (CHAR_TO_BYTE (to) - (CHAR_TO_BYTE (from)))))
8346 return Qnil;
8347 p = CHAR_POS_ADDR (from);
8348 pend = CHAR_POS_ADDR (to);
8349 if (from < GPT && to >= GPT)
8350 stop = GPT_ADDR;
8351 else
8352 stop = pend;
8353 }
8354 else
8355 {
8356 CHECK_STRING (string);
8357 CHECK_NATNUM (start);
8358 CHECK_NATNUM (end);
8359 from = XINT (start);
8360 to = XINT (end);
8361 if (from > to
8362 || to > SCHARS (string))
8363 args_out_of_range_3 (string, start, end);
8364 if (! STRING_MULTIBYTE (string))
8365 return Qnil;
8366 p = SDATA (string) + string_char_to_byte (string, from);
8367 stop = pend = SDATA (string) + string_char_to_byte (string, to);
8368 if (ascii_compatible && (to - from) == (pend - p))
8369 return Qnil;
8370 }
f2558efd 8371
8f924df7
KH		 8372 if (NILP (count))
8373 n = 1;
8374 else
b73bfc1c 8375 {
8f924df7
KH		 8376 CHECK_NATNUM (count);
8377 n = XINT (count);
b73bfc1c
KH		 8378 }
8379
8f924df7
KH		 8380 positions = Qnil;
8381 while (1)
d46c5b12 8382 {
8f924df7 8383 int c;
ec6d2bb8 8384
8f924df7
KH		 8385 if (ascii_compatible)
8386 while (p < stop && ASCII_BYTE_P (*p))
8387 p++, from++;
8388 if (p >= stop)
0e79d667 8389 {
8f924df7
KH		 8390 if (p >= pend)
8391 break;
8392 stop = pend;
8393 p = GAP_END_ADDR;
0e79d667 8394 }
ec6d2bb8 8395
8f924df7
KH		 8396 c = STRING_CHAR_ADVANCE (p);
8397 if (! (ASCII_CHAR_P (c) && ascii_compatible)
7d64c6ad
KH		 8398 && ! char_charset (translate_char (translation_table, c),
8399 charset_list, NULL))
ec6d2bb8 8400 {
8f924df7
KH		 8401 positions = Fcons (make_number (from), positions);
8402 n--;
8403 if (n == 0)
8404 break;
ec6d2bb8
KH		 8405 }
8406
8f924df7
KH		 8407 from++;
8408 }
d46c5b12 8409
8f924df7
KH		 8410 return (NILP (count) ? Fcar (positions) : Fnreverse (positions));
8411}
d46c5b12 8412
d46c5b12 8413
df7492f9
KH		 8414DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region,
8415 Scheck_coding_systems_region, 3, 3, 0,
8416 doc: /* Check if the region is encodable by coding systems.
d46c5b12 8417
df7492f9
KH		 8418START and END are buffer positions specifying the region.
8419CODING-SYSTEM-LIST is a list of coding systems to check.
d46c5b12 8420
df7492f9 8421The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
d4a1d553 8422CODING-SYSTEM is a member of CODING-SYSTEM-LIST and can't encode the
df7492f9
KH		 8423whole region, POS0, POS1, ... are buffer positions where non-encodable
8424characters are found.
93dec019 8425
df7492f9
KH		 8426If all coding systems in CODING-SYSTEM-LIST can encode the region, the
8427value is nil.
93dec019 8428
df7492f9
KH		 8429START may be a string. In that case, check if the string is
8430encodable, and the value contains indices to the string instead of
8431buffer positions. END is ignored. */)
8432 (start, end, coding_system_list)
8433 Lisp_Object start, end, coding_system_list;
05e6f5dc 8434{
df7492f9
KH		 8435 Lisp_Object list;
8436 EMACS_INT start_byte, end_byte;
8437 int pos;
7c78e542 8438 const unsigned char *p, *pbeg, *pend;
df7492f9 8439 int c;
7d64c6ad 8440 Lisp_Object tail, elt, attrs;
70ad9fc4 8441
05e6f5dc
KH		 8442 if (STRINGP (start))
8443 {
df7492f9 8444 if (!STRING_MULTIBYTE (start)
8f924df7 8445 && SCHARS (start) != SBYTES (start))
df7492f9
KH		 8446 return Qnil;
8447 start_byte = 0;
8f924df7 8448 end_byte = SBYTES (start);
df7492f9 8449 pos = 0;
d46c5b12 8450 }
05e6f5dc 8451 else
b73bfc1c 8452 {
b7826503
PJ		 8453 CHECK_NUMBER_COERCE_MARKER (start);
8454 CHECK_NUMBER_COERCE_MARKER (end);
05e6f5dc
KH		 8455 if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
8456 args_out_of_range (start, end);
8457 if (NILP (current_buffer->enable_multibyte_characters))
df7492f9
KH		 8458 return Qnil;
8459 start_byte = CHAR_TO_BYTE (XINT (start));
8460 end_byte = CHAR_TO_BYTE (XINT (end));
8461 if (XINT (end) - XINT (start) == end_byte - start_byte)
05e6f5dc 8462 return Qt;
df7492f9 8463
e1c23804 8464 if (XINT (start) < GPT && XINT (end) > GPT)
b73bfc1c 8465 {
e1c23804
DL		 8466 if ((GPT - XINT (start)) < (XINT (end) - GPT))
8467 move_gap_both (XINT (start), start_byte);
df7492f9 8468 else
e1c23804 8469 move_gap_both (XINT (end), end_byte);
b73bfc1c 8470 }
e1c23804 8471 pos = XINT (start);
b73bfc1c 8472 }
7553d0e1 8473
df7492f9
KH		 8474 list = Qnil;
8475 for (tail = coding_system_list; CONSP (tail); tail = XCDR (tail))
12410ef1 8476 {
df7492f9 8477 elt = XCAR (tail);
7d64c6ad 8478 attrs = AREF (CODING_SYSTEM_SPEC (elt), 0);
2170c8f0
KH		 8479 ASET (attrs, coding_attr_trans_tbl,
8480 get_translation_table (attrs, 1, NULL));
7d64c6ad 8481 list = Fcons (Fcons (elt, Fcons (attrs, Qnil)), list);
12410ef1
KH		 8482 }
8483
df7492f9 8484 if (STRINGP (start))
8f924df7 8485 p = pbeg = SDATA (start);
72d1a715 8486 else
df7492f9
KH		 8487 p = pbeg = BYTE_POS_ADDR (start_byte);
8488 pend = p + (end_byte - start_byte);
4ed46869 8489
df7492f9
KH		 8490 while (p < pend && ASCII_BYTE_P (*p)) p++, pos++;
8491 while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
ec6d2bb8 8492
df7492f9 8493 while (p < pend)
d46c5b12 8494 {
df7492f9
KH		 8495 if (ASCII_BYTE_P (*p))
8496 p++;
e133c8fa 8497 else
05e6f5dc 8498 {
df7492f9
KH		 8499 c = STRING_CHAR_ADVANCE (p);
8500
8501 charset_map_loaded = 0;
8502 for (tail = list; CONSP (tail); tail = XCDR (tail))
8503 {
8504 elt = XCDR (XCAR (tail));
8505 if (! char_encodable_p (c, XCAR (elt)))
8506 XSETCDR (elt, Fcons (make_number (pos), XCDR (elt)));
8507 }
8508 if (charset_map_loaded)
8509 {
8510 EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
8511
8512 if (STRINGP (start))
8f924df7 8513 pbeg = SDATA (start);
df7492f9
KH		 8514 else
8515 pbeg = BYTE_POS_ADDR (start_byte);
8516 p = pbeg + p_offset;
8517 pend = pbeg + pend_offset;
8518 }
05e6f5dc 8519 }
df7492f9 8520 pos++;
d46c5b12 8521 }
4ed46869 8522
df7492f9
KH		 8523 tail = list;
8524 list = Qnil;
8525 for (; CONSP (tail); tail = XCDR (tail))
ec6d2bb8 8526 {
df7492f9
KH		 8527 elt = XCAR (tail);
8528 if (CONSP (XCDR (XCDR (elt))))
8529 list = Fcons (Fcons (XCAR (elt), Fnreverse (XCDR (XCDR (elt)))),
8530 list);
ec6d2bb8 8531 }
2b4f9037 8532
df7492f9 8533 return list;
d46c5b12
KH		 8534}
8535
3fd9494b 8536
b73bfc1c 8537Lisp_Object
df7492f9
KH		 8538code_convert_region (start, end, coding_system, dst_object, encodep, norecord)
8539 Lisp_Object start, end, coding_system, dst_object;
8540 int encodep, norecord;
4ed46869 8541{
3a73fa5d 8542 struct coding_system coding;
df7492f9
KH		 8543 EMACS_INT from, from_byte, to, to_byte;
8544 Lisp_Object src_object;
4ed46869 8545
b7826503
PJ		 8546 CHECK_NUMBER_COERCE_MARKER (start);
8547 CHECK_NUMBER_COERCE_MARKER (end);
df7492f9
KH		 8548 if (NILP (coding_system))
8549 coding_system = Qno_conversion;
8550 else
8551 CHECK_CODING_SYSTEM (coding_system);
8552 src_object = Fcurrent_buffer ();
8553 if (NILP (dst_object))
8554 dst_object = src_object;
8555 else if (! EQ (dst_object, Qt))
8556 CHECK_BUFFER (dst_object);
3a73fa5d 8557
d46c5b12
KH		 8558 validate_region (&start, &end);
8559 from = XFASTINT (start);
df7492f9 8560 from_byte = CHAR_TO_BYTE (from);
d46c5b12 8561 to = XFASTINT (end);
df7492f9 8562 to_byte = CHAR_TO_BYTE (to);
764ca8da 8563
df7492f9
KH		 8564 setup_coding_system (coding_system, &coding);
8565 coding.mode |= CODING_MODE_LAST_BLOCK;
ec6d2bb8 8566
df7492f9
KH		 8567 if (encodep)
8568 encode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
8569 dst_object);
8570 else
8571 decode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
8572 dst_object);
8573 if (! norecord)
8574 Vlast_coding_system_used = CODING_ID_NAME (coding.id);
ec6d2bb8 8575
df7492f9
KH		 8576 return (BUFFERP (dst_object)
8577 ? make_number (coding.produced_char)
8578 : coding.dst_object);
4031e2bf 8579}
78108bcd 8580
4ed46869 8581
4031e2bf 8582DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
df7492f9 8583 3, 4, "r\nzCoding system: ",
48b0f3ae 8584 doc: /* Decode the current region from the specified coding system.
df7492f9
KH		 8585When called from a program, takes four arguments:
8586 START, END, CODING-SYSTEM, and DESTINATION.
8587START and END are buffer positions.
8844fa83 8588
df7492f9 8589Optional 4th arguments DESTINATION specifies where the decoded text goes.
2354b80b 8590If nil, the region between START and END is replaced by the decoded text.
1560f91a
EZ		 8591If buffer, the decoded text is inserted in that buffer after point (point
8592does not move).
446dcd75 8593In those cases, the length of the decoded text is returned.
319a3947 8594If DESTINATION is t, the decoded text is returned.
8844fa83 8595
48b0f3ae
PJ		 8596This function sets `last-coding-system-used' to the precise coding system
8597used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
319a3947 8598not fully specified.) */)
df7492f9
KH		 8599 (start, end, coding_system, destination)
8600 Lisp_Object start, end, coding_system, destination;
4031e2bf 8601{
df7492f9 8602 return code_convert_region (start, end, coding_system, destination, 0, 0);
3a73fa5d 8603}
8844fa83 8604
3a73fa5d 8605DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
df7492f9
KH		 8606 3, 4, "r\nzCoding system: ",
8607 doc: /* Encode the current region by specified coding system.
d4a1d553
JB		 8608When called from a program, takes four arguments:
8609 START, END, CODING-SYSTEM and DESTINATION.
8610START and END are buffer positions.
d46c5b12 8611
df7492f9
KH		 8612Optional 4th arguments DESTINATION specifies where the encoded text goes.
8613If nil, the region between START and END is replace by the encoded text.
1560f91a
EZ		 8614If buffer, the encoded text is inserted in that buffer after point (point
8615does not move).
446dcd75 8616In those cases, the length of the encoded text is returned.
319a3947 8617If DESTINATION is t, the encoded text is returned.
2391eaa4 8618
48b0f3ae
PJ		 8619This function sets `last-coding-system-used' to the precise coding system
8620used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
319a3947 8621not fully specified.) */)
df7492f9
KH		 8622 (start, end, coding_system, destination)
8623 Lisp_Object start, end, coding_system, destination;
3a73fa5d 8624{
df7492f9 8625 return code_convert_region (start, end, coding_system, destination, 1, 0);
b73bfc1c
KH		 8626}
8627
8628Lisp_Object
df7492f9
KH		 8629code_convert_string (string, coding_system, dst_object,
8630 encodep, nocopy, norecord)
8631 Lisp_Object string, coding_system, dst_object;
8632 int encodep, nocopy, norecord;
b73bfc1c 8633{
4031e2bf 8634 struct coding_system coding;
df7492f9 8635 EMACS_INT chars, bytes;
ec6d2bb8 8636
b7826503 8637 CHECK_STRING (string);
d46c5b12 8638 if (NILP (coding_system))
4956c225 8639 {
df7492f9
KH		 8640 if (! norecord)
8641 Vlast_coding_system_used = Qno_conversion;
8642 if (NILP (dst_object))
8643 return (nocopy ? Fcopy_sequence (string) : string);
4956c225 8644 }
b73bfc1c 8645
df7492f9
KH		 8646 if (NILP (coding_system))
8647 coding_system = Qno_conversion;
8648 else
8649 CHECK_CODING_SYSTEM (coding_system);
8650 if (NILP (dst_object))
8651 dst_object = Qt;
8652 else if (! EQ (dst_object, Qt))
8653 CHECK_BUFFER (dst_object);
73be902c 8654
df7492f9 8655 setup_coding_system (coding_system, &coding);
d46c5b12 8656 coding.mode |= CODING_MODE_LAST_BLOCK;
8f924df7
KH		 8657 chars = SCHARS (string);
8658 bytes = SBYTES (string);
df7492f9
KH		 8659 if (encodep)
8660 encode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
8661 else
8662 decode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
8663 if (! norecord)
8664 Vlast_coding_system_used = CODING_ID_NAME (coding.id);
73be902c 8665
df7492f9
KH		 8666 return (BUFFERP (dst_object)
8667 ? make_number (coding.produced_char)
8668 : coding.dst_object);
4ed46869 8669}
73be902c 8670
b73bfc1c 8671
ecec61c1 8672/* Encode or decode STRING according to CODING_SYSTEM.
ec6d2bb8 8673 Do not set Vlast_coding_system_used.
4ed46869 8674
ec6d2bb8
KH		 8675 This function is called only from macros DECODE_FILE and
8676 ENCODE_FILE, thus we ignore character composition. */
4ed46869 8677
ecec61c1
KH		 8678Lisp_Object
8679code_convert_string_norecord (string, coding_system, encodep)
8680 Lisp_Object string, coding_system;
8681 int encodep;
4ed46869 8682{
0be8721c 8683 return code_convert_string (string, coding_system, Qt, encodep, 0, 1);
4ed46869
KH		 8684}
8685
4ed46869 8686
df7492f9
KH		 8687DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
8688 2, 4, 0,
8689 doc: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8690
8691Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8692if the decoding operation is trivial.
ecec61c1 8693
d4a1d553 8694Optional fourth arg BUFFER non-nil means that the decoded text is
1560f91a
EZ		 8695inserted in that buffer after point (point does not move). In this
8696case, the return value is the length of the decoded text.
ecec61c1 8697
df7492f9
KH		 8698This function sets `last-coding-system-used' to the precise coding system
8699used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
d4a1d553 8700not fully specified.) */)
df7492f9
KH		 8701 (string, coding_system, nocopy, buffer)
8702 Lisp_Object string, coding_system, nocopy, buffer;
4ed46869 8703{
df7492f9
KH		 8704 return code_convert_string (string, coding_system, buffer,
8705 0, ! NILP (nocopy), 0);
4ed46869
KH		 8706}
8707
df7492f9
KH		 8708DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
8709 2, 4, 0,
8710 doc: /* Encode STRING to CODING-SYSTEM, and return the result.
8711
8712Optional third arg NOCOPY non-nil means it is OK to return STRING
8713itself if the encoding operation is trivial.
8714
d4a1d553 8715Optional fourth arg BUFFER non-nil means that the encoded text is
1560f91a
EZ		 8716inserted in that buffer after point (point does not move). In this
8717case, the return value is the length of the encoded text.
df7492f9
KH		 8718
8719This function sets `last-coding-system-used' to the precise coding system
8720used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8721not fully specified.) */)
8722 (string, coding_system, nocopy, buffer)
8723 Lisp_Object string, coding_system, nocopy, buffer;
4ed46869 8724{
df7492f9 8725 return code_convert_string (string, coding_system, buffer,
c197f191 8726 1, ! NILP (nocopy), 1);
4ed46869 8727}
df7492f9 8728
3a73fa5d 8729\f
4ed46869 8730DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
48b0f3ae
PJ		 8731 doc: /* Decode a Japanese character which has CODE in shift_jis encoding.
8732Return the corresponding character. */)
8733 (code)
4ed46869 8734 Lisp_Object code;
4ed46869 8735{
df7492f9
KH		 8736 Lisp_Object spec, attrs, val;
8737 struct charset *charset_roman, *charset_kanji, *charset_kana, *charset;
8738 int c;
4ed46869 8739
df7492f9
KH		 8740 CHECK_NATNUM (code);
8741 c = XFASTINT (code);
8742 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
8743 attrs = AREF (spec, 0);
4ed46869 8744
df7492f9
KH		 8745 if (ASCII_BYTE_P (c)
8746 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8747 return code;
4ed46869 8748
df7492f9
KH		 8749 val = CODING_ATTR_CHARSET_LIST (attrs);
8750 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
004068e4
KH		 8751 charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
8752 charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val)));
fa42c37f 8753
df7492f9
KH		 8754 if (c <= 0x7F)
8755 charset = charset_roman;
8756 else if (c >= 0xA0 && c < 0xDF)
55ab7be3 8757 {
df7492f9
KH		 8758 charset = charset_kana;
8759 c -= 0x80;
4ed46869 8760 }
55ab7be3 8761 else
4ed46869 8762 {
004068e4 8763 int s1 = c >> 8, s2 = c & 0xFF;
df7492f9
KH		 8764
8765 if (s1 < 0x81 || (s1 > 0x9F && s1 < 0xE0) || s1 > 0xEF
8766 || s2 < 0x40 || s2 == 0x7F || s2 > 0xFC)
8767 error ("Invalid code: %d", code);
8768 SJIS_TO_JIS (c);
8769 charset = charset_kanji;
4ed46869 8770 }
df7492f9
KH		 8771 c = DECODE_CHAR (charset, c);
8772 if (c < 0)
8773 error ("Invalid code: %d", code);
8774 return make_number (c);
93dec019 8775}
4ed46869 8776
48b0f3ae 8777
4ed46869 8778DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
8acf0c0e 8779 doc: /* Encode a Japanese character CH to shift_jis encoding.
48b0f3ae
PJ		 8780Return the corresponding code in SJIS. */)
8781 (ch)
df7492f9 8782 Lisp_Object ch;
4ed46869 8783{
df7492f9
KH		 8784 Lisp_Object spec, attrs, charset_list;
8785 int c;
8786 struct charset *charset;
8787 unsigned code;
48b0f3ae 8788
df7492f9
KH		 8789 CHECK_CHARACTER (ch);
8790 c = XFASTINT (ch);
8791 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
8792 attrs = AREF (spec, 0);
8793
8794 if (ASCII_CHAR_P (c)
8795 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8796 return ch;
8797
8798 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
8799 charset = char_charset (c, charset_list, &code);
8800 if (code == CHARSET_INVALID_CODE (charset))
8801 error ("Can't encode by shift_jis encoding: %d", c);
8802 JIS_TO_SJIS (code);
8803
8804 return make_number (code);
4ed46869
KH		 8805}
8806
8807DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
48b0f3ae
PJ		 8808 doc: /* Decode a Big5 character which has CODE in BIG5 coding system.
8809Return the corresponding character. */)
8810 (code)
4ed46869 8811 Lisp_Object code;
d46c5b12 8812{
df7492f9
KH		 8813 Lisp_Object spec, attrs, val;
8814 struct charset *charset_roman, *charset_big5, *charset;
8815 int c;
6289dd10 8816
df7492f9
KH		 8817 CHECK_NATNUM (code);
8818 c = XFASTINT (code);
8819 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
8820 attrs = AREF (spec, 0);
4ed46869 8821
df7492f9
KH		 8822 if (ASCII_BYTE_P (c)
8823 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8824 return code;
6289dd10 8825
df7492f9
KH		 8826 val = CODING_ATTR_CHARSET_LIST (attrs);
8827 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
8828 charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
c210f766 8829
df7492f9
KH		 8830 if (c <= 0x7F)
8831 charset = charset_roman;
c28a9453
KH		 8832 else
8833 {
df7492f9
KH		 8834 int b1 = c >> 8, b2 = c & 0x7F;
8835 if (b1 < 0xA1 || b1 > 0xFE
8836 || b2 < 0x40 || (b2 > 0x7E && b2 < 0xA1) || b2 > 0xFE)
8837 error ("Invalid code: %d", code);
8838 charset = charset_big5;
c28a9453 8839 }
df7492f9
KH		 8840 c = DECODE_CHAR (charset, (unsigned )c);
8841 if (c < 0)
8842 error ("Invalid code: %d", code);
8843 return make_number (c);
d46c5b12 8844}
6289dd10 8845
4ed46869 8846DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
8acf0c0e 8847 doc: /* Encode the Big5 character CH to BIG5 coding system.
48b0f3ae
PJ		 8848Return the corresponding character code in Big5. */)
8849 (ch)
4ed46869
KH		 8850 Lisp_Object ch;
8851{
df7492f9
KH		 8852 Lisp_Object spec, attrs, charset_list;
8853 struct charset *charset;
8854 int c;
8855 unsigned code;
8856
8857 CHECK_CHARACTER (ch);
8858 c = XFASTINT (ch);
8859 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
8860 attrs = AREF (spec, 0);
8861 if (ASCII_CHAR_P (c)
8862 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8863 return ch;
8864
8865 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
8866 charset = char_charset (c, charset_list, &code);
8867 if (code == CHARSET_INVALID_CODE (charset))
8868 error ("Can't encode by Big5 encoding: %d", c);
8869
8870 return make_number (code);
4ed46869 8871}
48b0f3ae 8872
3a73fa5d 8873\f
002fdb44 8874DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal,
68bba4e4 8875 Sset_terminal_coding_system_internal, 1, 2, 0,
48b0f3ae 8876 doc: /* Internal use only. */)
6ed8eeff 8877 (coding_system, terminal)
b74e4686 8878 Lisp_Object coding_system;
6ed8eeff 8879 Lisp_Object terminal;
4ed46869 8880{
6ed8eeff 8881 struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
b7826503 8882 CHECK_SYMBOL (coding_system);
b8299c66 8883 setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
70c22245 8884 /* We had better not send unsafe characters to terminal. */
c73bd236 8885 terminal_coding->mode |= CODING_MODE_SAFE_ENCODING;
df7492f9 8886 /* Characer composition should be disabled. */
c73bd236 8887 terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
b8299c66
KL		 8888 terminal_coding->src_multibyte = 1;
8889 terminal_coding->dst_multibyte = 0;
4ed46869
KH		 8890 return Qnil;
8891}
8892
c4825358
KH		 8893DEFUN ("set-safe-terminal-coding-system-internal",
8894 Fset_safe_terminal_coding_system_internal,
48b0f3ae 8895 Sset_safe_terminal_coding_system_internal, 1, 1, 0,
ddb67bdc 8896 doc: /* Internal use only. */)
48b0f3ae 8897 (coding_system)
b74e4686 8898 Lisp_Object coding_system;
d46c5b12 8899{
b7826503 8900 CHECK_SYMBOL (coding_system);
c4825358
KH		 8901 setup_coding_system (Fcheck_coding_system (coding_system),
8902 &safe_terminal_coding);
df7492f9
KH		 8903 /* Characer composition should be disabled. */
8904 safe_terminal_coding.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
b73bfc1c
KH		 8905 safe_terminal_coding.src_multibyte = 1;
8906 safe_terminal_coding.dst_multibyte = 0;
c4825358
KH		 8907 return Qnil;
8908}
4ed46869 8909
002fdb44 8910DEFUN ("terminal-coding-system", Fterminal_coding_system,
68bba4e4 8911 Sterminal_coding_system, 0, 1, 0,
6ed8eeff
KL		 8912 doc: /* Return coding system specified for terminal output on the given terminal.
8913TERMINAL may be a terminal id, a frame, or nil for the selected
8914frame's terminal device. */)
8915 (terminal)
8916 Lisp_Object terminal;
4ed46869 8917{
985773c9
MB		 8918 struct coding_system *terminal_coding
8919 = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
8920 Lisp_Object coding_system = CODING_ID_NAME (terminal_coding->id);
ae6f73fa 8921
ae6f73fa 8922 /* For backward compatibility, return nil if it is `undecided'. */
f75c90a9 8923 return (! EQ (coding_system, Qundecided) ? coding_system : Qnil);
4ed46869
KH		 8924}
8925
002fdb44 8926DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
68bba4e4 8927 Sset_keyboard_coding_system_internal, 1, 2, 0,
48b0f3ae 8928 doc: /* Internal use only. */)
6ed8eeff 8929 (coding_system, terminal)
4ed46869 8930 Lisp_Object coding_system;
6ed8eeff 8931 Lisp_Object terminal;
4ed46869 8932{
6ed8eeff 8933 struct terminal *t = get_terminal (terminal, 1);
b7826503 8934 CHECK_SYMBOL (coding_system);
df7492f9 8935 setup_coding_system (Fcheck_coding_system (coding_system),
c73bd236 8936 TERMINAL_KEYBOARD_CODING (t));
df7492f9 8937 /* Characer composition should be disabled. */
c73bd236
MB		 8938 TERMINAL_KEYBOARD_CODING (t)->common_flags
8939 &= ~CODING_ANNOTATE_COMPOSITION_MASK;
4ed46869
KH		 8940 return Qnil;
8941}
8942
8943DEFUN ("keyboard-coding-system",
985773c9 8944 Fkeyboard_coding_system, Skeyboard_coding_system, 0, 1, 0,
48b0f3ae 8945 doc: /* Return coding system specified for decoding keyboard input. */)
985773c9
MB		 8946 (terminal)
8947 Lisp_Object terminal;
4ed46869 8948{
985773c9
MB		 8949 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
8950 (get_terminal (terminal, 1))->id);
4ed46869
KH		 8951}
8952
4ed46869 8953\f
a5d301df
KH		 8954DEFUN ("find-operation-coding-system", Ffind_operation_coding_system,
8955 Sfind_operation_coding_system, 1, MANY, 0,
48b0f3ae
PJ		 8956 doc: /* Choose a coding system for an operation based on the target name.
8957The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8958DECODING-SYSTEM is the coding system to use for decoding
8959\(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8960for encoding (in case OPERATION does encoding).
05e6f5dc 8961
48b0f3ae
PJ		 8962The first argument OPERATION specifies an I/O primitive:
8963 For file I/O, `insert-file-contents' or `write-region'.
8964 For process I/O, `call-process', `call-process-region', or `start-process'.
8965 For network I/O, `open-network-stream'.
05e6f5dc 8966
48b0f3ae
PJ		 8967The remaining arguments should be the same arguments that were passed
8968to the primitive. Depending on which primitive, one of those arguments
8969is selected as the TARGET. For example, if OPERATION does file I/O,
8970whichever argument specifies the file name is TARGET.
05e6f5dc 8971
48b0f3ae 8972TARGET has a meaning which depends on OPERATION:
b883cdb2 8973 For file I/O, TARGET is a file name (except for the special case below).
48b0f3ae 8974 For process I/O, TARGET is a process name.
d4a1d553 8975 For network I/O, TARGET is a service name or a port number.
05e6f5dc 8976
d4a1d553 8977This function looks up what is specified for TARGET in
48b0f3ae
PJ		 8978`file-coding-system-alist', `process-coding-system-alist',
8979or `network-coding-system-alist' depending on OPERATION.
8980They may specify a coding system, a cons of coding systems,
8981or a function symbol to call.
8982In the last case, we call the function with one argument,
8983which is a list of all the arguments given to this function.
1011c487
MB		 8984If the function can't decide a coding system, it can return
8985`undecided' so that the normal code-detection is performed.
48b0f3ae 8986
b883cdb2
MB		 8987If OPERATION is `insert-file-contents', the argument corresponding to
8988TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
8989file name to look up, and BUFFER is a buffer that contains the file's
8990contents (not yet decoded). If `file-coding-system-alist' specifies a
8991function to call for FILENAME, that function should examine the
8992contents of BUFFER instead of reading the file.
8993
d918f936 8994usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
48b0f3ae 8995 (nargs, args)
4ed46869
KH		 8996 int nargs;
8997 Lisp_Object *args;
6b89e3aa 8998{
4ed46869
KH		 8999 Lisp_Object operation, target_idx, target, val;
9000 register Lisp_Object chain;
177c0ea7 9001
4ed46869
KH		 9002 if (nargs < 2)
9003 error ("Too few arguments");
9004 operation = args[0];
9005 if (!SYMBOLP (operation)
9006 || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
3ed051d4 9007 error ("Invalid first argument");
4ed46869
KH		 9008 if (nargs < 1 + XINT (target_idx))
9009 error ("Too few arguments for operation: %s",
8f924df7 9010 SDATA (SYMBOL_NAME (operation)));
4ed46869
KH		 9011 target = args[XINT (target_idx) + 1];
9012 if (!(STRINGP (target)
091a0ff0
KH		 9013 || (EQ (operation, Qinsert_file_contents) && CONSP (target)
9014 && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
4ed46869 9015 || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
df7492f9 9016 error ("Invalid %dth argument", XINT (target_idx) + 1);
091a0ff0
KH		 9017 if (CONSP (target))
9018 target = XCAR (target);
4ed46869 9019
2e34157c
RS		 9020 chain = ((EQ (operation, Qinsert_file_contents)
9021 || EQ (operation, Qwrite_region))
02ba4723 9022 ? Vfile_coding_system_alist
2e34157c 9023 : (EQ (operation, Qopen_network_stream)
02ba4723
KH		 9024 ? Vnetwork_coding_system_alist
9025 : Vprocess_coding_system_alist));
4ed46869
KH		 9026 if (NILP (chain))
9027 return Qnil;
9028
03699b14 9029 for (; CONSP (chain); chain = XCDR (chain))
6b89e3aa 9030 {
f44d27ce 9031 Lisp_Object elt;
6b89e3aa 9032
df7492f9 9033 elt = XCAR (chain);
4ed46869
KH		 9034 if (CONSP (elt)
9035 && ((STRINGP (target)
03699b14
KR		 9036 && STRINGP (XCAR (elt))
9037 && fast_string_match (XCAR (elt), target) >= 0)
9038 || (INTEGERP (target) && EQ (target, XCAR (elt)))))
6b89e3aa 9039 {
03699b14 9040 val = XCDR (elt);
b19fd4c5
KH		 9041 /* Here, if VAL is both a valid coding system and a valid
9042 function symbol, we return VAL as a coding system. */
02ba4723
KH		 9043 if (CONSP (val))
9044 return val;
9045 if (! SYMBOLP (val))
9046 return Qnil;
9047 if (! NILP (Fcoding_system_p (val)))
9048 return Fcons (val, val);
b19fd4c5 9049 if (! NILP (Ffboundp (val)))
6b89e3aa 9050 {
e2b97060
MB		 9051 /* We use call1 rather than safe_call1
9052 so as to get bug reports about functions called here
9053 which don't handle the current interface. */
9054 val = call1 (val, Flist (nargs, args));
b19fd4c5
KH		 9055 if (CONSP (val))
9056 return val;
9057 if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
9058 return Fcons (val, val);
6b89e3aa 9059 }
02ba4723 9060 return Qnil;
6b89e3aa
KH		 9061 }
9062 }
4ed46869 9063 return Qnil;
6b89e3aa
KH		 9064}
9065
df7492f9 9066DEFUN ("set-coding-system-priority", Fset_coding_system_priority,
a3f6ee6d 9067 Sset_coding_system_priority, 0, MANY, 0,
da7db224 9068 doc: /* Assign higher priority to the coding systems given as arguments.
d4a1d553 9069If multiple coding systems belong to the same category,
a3181084
DL		 9070all but the first one are ignored.
9071
d4a1d553 9072usage: (set-coding-system-priority &rest coding-systems) */)
df7492f9
KH		 9073 (nargs, args)
9074 int nargs;
9075 Lisp_Object *args;
9076{
9077 int i, j;
9078 int changed[coding_category_max];
9079 enum coding_category priorities[coding_category_max];
9080
9081 bzero (changed, sizeof changed);
6b89e3aa 9082
df7492f9 9083 for (i = j = 0; i < nargs; i++)
6b89e3aa 9084 {
df7492f9
KH		 9085 enum coding_category category;
9086 Lisp_Object spec, attrs;
6b89e3aa 9087
df7492f9
KH		 9088 CHECK_CODING_SYSTEM_GET_SPEC (args[i], spec);
9089 attrs = AREF (spec, 0);
9090 category = XINT (CODING_ATTR_CATEGORY (attrs));
9091 if (changed[category])
9092 /* Ignore this coding system because a coding system of the
9093 same category already had a higher priority. */
9094 continue;
9095 changed[category] = 1;
9096 priorities[j++] = category;
9097 if (coding_categories[category].id >= 0
9098 && ! EQ (args[i], CODING_ID_NAME (coding_categories[category].id)))
9099 setup_coding_system (args[i], &coding_categories[category]);
ff563fce 9100 Fset (AREF (Vcoding_category_table, category), args[i]);
df7492f9 9101 }
6b89e3aa 9102
df7492f9
KH		 9103 /* Now we have decided top J priorities. Reflect the order of the
9104 original priorities to the remaining priorities. */
6b89e3aa 9105
df7492f9 9106 for (i = j, j = 0; i < coding_category_max; i++, j++)
6b89e3aa 9107 {
df7492f9
KH		 9108 while (j < coding_category_max
9109 && changed[coding_priorities[j]])
9110 j++;
9111 if (j == coding_category_max)
9112 abort ();
9113 priorities[i] = coding_priorities[j];
9114 }
6b89e3aa 9115
df7492f9 9116 bcopy (priorities, coding_priorities, sizeof priorities);
177c0ea7 9117
ff563fce
KH		 9118 /* Update `coding-category-list'. */
9119 Vcoding_category_list = Qnil;
9120 for (i = coding_category_max - 1; i >= 0; i--)
9121 Vcoding_category_list
9122 = Fcons (AREF (Vcoding_category_table, priorities[i]),
9123 Vcoding_category_list);
6b89e3aa 9124
df7492f9 9125 return Qnil;
6b89e3aa
KH		 9126}
9127
df7492f9
KH		 9128DEFUN ("coding-system-priority-list", Fcoding_system_priority_list,
9129 Scoding_system_priority_list, 0, 1, 0,
da7db224
DL		 9130 doc: /* Return a list of coding systems ordered by their priorities.
9131HIGHESTP non-nil means just return the highest priority one. */)
df7492f9
KH		 9132 (highestp)
9133 Lisp_Object highestp;
d46c5b12
KH		 9134{
9135 int i;
df7492f9 9136 Lisp_Object val;
6b89e3aa 9137
df7492f9 9138 for (i = 0, val = Qnil; i < coding_category_max; i++)
d46c5b12 9139 {
df7492f9
KH		 9140 enum coding_category category = coding_priorities[i];
9141 int id = coding_categories[category].id;
9142 Lisp_Object attrs;
068a9dbd 9143
df7492f9
KH		 9144 if (id < 0)
9145 continue;
9146 attrs = CODING_ID_ATTRS (id);
9147 if (! NILP (highestp))
9148 return CODING_ATTR_BASE_NAME (attrs);
9149 val = Fcons (CODING_ATTR_BASE_NAME (attrs), val);
9150 }
9151 return Fnreverse (val);
9152}
068a9dbd 9153
f0064e1f 9154static char *suffixes[] = { "-unix", "-dos", "-mac" };
068a9dbd
KH		 9155
9156static Lisp_Object
df7492f9
KH		 9157make_subsidiaries (base)
9158 Lisp_Object base;
068a9dbd 9159{
df7492f9 9160 Lisp_Object subsidiaries;
8f924df7 9161 int base_name_len = SBYTES (SYMBOL_NAME (base));
df7492f9
KH		 9162 char *buf = (char *) alloca (base_name_len + 6);
9163 int i;
068a9dbd 9164
8f924df7 9165 bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
df7492f9
KH		 9166 subsidiaries = Fmake_vector (make_number (3), Qnil);
9167 for (i = 0; i < 3; i++)
068a9dbd 9168 {
df7492f9
KH		 9169 bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
9170 ASET (subsidiaries, i, intern (buf));
068a9dbd 9171 }
df7492f9 9172 return subsidiaries;
068a9dbd
KH		 9173}
9174
9175
df7492f9
KH		 9176DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal,
9177 Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
1fcd6c8b
DL		 9178 doc: /* For internal use only.
9179usage: (define-coding-system-internal ...) */)
df7492f9
KH		 9180 (nargs, args)
9181 int nargs;
9182 Lisp_Object *args;
068a9dbd 9183{
df7492f9
KH		 9184 Lisp_Object name;
9185 Lisp_Object spec_vec; /* [ ATTRS ALIASE EOL_TYPE ] */
9186 Lisp_Object attrs; /* Vector of attributes. */
9187 Lisp_Object eol_type;
9188 Lisp_Object aliases;
9189 Lisp_Object coding_type, charset_list, safe_charsets;
9190 enum coding_category category;
9191 Lisp_Object tail, val;
9192 int max_charset_id = 0;
9193 int i;
068a9dbd 9194
df7492f9
KH		 9195 if (nargs < coding_arg_max)
9196 goto short_args;
068a9dbd 9197
df7492f9 9198 attrs = Fmake_vector (make_number (coding_attr_last_index), Qnil);
068a9dbd 9199
df7492f9
KH		 9200 name = args[coding_arg_name];
9201 CHECK_SYMBOL (name);
9202 CODING_ATTR_BASE_NAME (attrs) = name;
068a9dbd 9203
df7492f9
KH		 9204 val = args[coding_arg_mnemonic];
9205 if (! STRINGP (val))
9206 CHECK_CHARACTER (val);
9207 CODING_ATTR_MNEMONIC (attrs) = val;
068a9dbd 9208
df7492f9
KH		 9209 coding_type = args[coding_arg_coding_type];
9210 CHECK_SYMBOL (coding_type);
9211 CODING_ATTR_TYPE (attrs) = coding_type;
068a9dbd 9212
df7492f9
KH		 9213 charset_list = args[coding_arg_charset_list];
9214 if (SYMBOLP (charset_list))
9215 {
9216 if (EQ (charset_list, Qiso_2022))
9217 {
9218 if (! EQ (coding_type, Qiso_2022))
9219 error ("Invalid charset-list");
9220 charset_list = Viso_2022_charset_list;
9221 }
9222 else if (EQ (charset_list, Qemacs_mule))
9223 {
9224 if (! EQ (coding_type, Qemacs_mule))
9225 error ("Invalid charset-list");
9226 charset_list = Vemacs_mule_charset_list;
9227 }
9228 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
9229 if (max_charset_id < XFASTINT (XCAR (tail)))
9230 max_charset_id = XFASTINT (XCAR (tail));
9231 }
068a9dbd
KH		 9232 else
9233 {
df7492f9 9234 charset_list = Fcopy_sequence (charset_list);
985773c9 9235 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
068a9dbd 9236 {
df7492f9
KH		 9237 struct charset *charset;
9238
985773c9 9239 val = XCAR (tail);
df7492f9
KH		 9240 CHECK_CHARSET_GET_CHARSET (val, charset);
9241 if (EQ (coding_type, Qiso_2022)
9242 ? CHARSET_ISO_FINAL (charset) < 0
9243 : EQ (coding_type, Qemacs_mule)
9244 ? CHARSET_EMACS_MULE_ID (charset) < 0
9245 : 0)
9246 error ("Can't handle charset `%s'",
8f924df7 9247 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
df7492f9 9248
8f924df7 9249 XSETCAR (tail, make_number (charset->id));
df7492f9
KH		 9250 if (max_charset_id < charset->id)
9251 max_charset_id = charset->id;
068a9dbd
KH		 9252 }
9253 }
df7492f9 9254 CODING_ATTR_CHARSET_LIST (attrs) = charset_list;
068a9dbd 9255
df7492f9
KH		 9256 safe_charsets = Fmake_string (make_number (max_charset_id + 1),
9257 make_number (255));
9258 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
8f924df7 9259 SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
df7492f9 9260 CODING_ATTR_SAFE_CHARSETS (attrs) = safe_charsets;
068a9dbd 9261
584948ac 9262 CODING_ATTR_ASCII_COMPAT (attrs) = args[coding_arg_ascii_compatible_p];
3a73fa5d 9263
df7492f9 9264 val = args[coding_arg_decode_translation_table];
a6f87d34 9265 if (! CHAR_TABLE_P (val) && ! CONSP (val))
7d64c6ad 9266 CHECK_SYMBOL (val);
df7492f9 9267 CODING_ATTR_DECODE_TBL (attrs) = val;
3a73fa5d 9268
df7492f9 9269 val = args[coding_arg_encode_translation_table];
a6f87d34 9270 if (! CHAR_TABLE_P (val) && ! CONSP (val))
7d64c6ad 9271 CHECK_SYMBOL (val);
df7492f9 9272 CODING_ATTR_ENCODE_TBL (attrs) = val;
d46c5b12 9273
df7492f9
KH		 9274 val = args[coding_arg_post_read_conversion];
9275 CHECK_SYMBOL (val);
9276 CODING_ATTR_POST_READ (attrs) = val;
d46c5b12 9277
df7492f9
KH		 9278 val = args[coding_arg_pre_write_conversion];
9279 CHECK_SYMBOL (val);
9280 CODING_ATTR_PRE_WRITE (attrs) = val;
3a73fa5d 9281
df7492f9
KH		 9282 val = args[coding_arg_default_char];
9283 if (NILP (val))
9284 CODING_ATTR_DEFAULT_CHAR (attrs) = make_number (' ');
9285 else
9286 {
8f924df7 9287 CHECK_CHARACTER (val);
df7492f9
KH		 9288 CODING_ATTR_DEFAULT_CHAR (attrs) = val;
9289 }
4031e2bf 9290
8f924df7
KH		 9291 val = args[coding_arg_for_unibyte];
9292 CODING_ATTR_FOR_UNIBYTE (attrs) = NILP (val) ? Qnil : Qt;
3a73fa5d 9293
df7492f9
KH		 9294 val = args[coding_arg_plist];
9295 CHECK_LIST (val);
9296 CODING_ATTR_PLIST (attrs) = val;
3a73fa5d 9297
df7492f9
KH		 9298 if (EQ (coding_type, Qcharset))
9299 {
c7c66a95
KH		 9300 /* Generate a lisp vector of 256 elements. Each element is nil,
9301 integer, or a list of charset IDs.
3a73fa5d 9302
c7c66a95
KH		 9303 If Nth element is nil, the byte code N is invalid in this
9304 coding system.
4ed46869 9305
c7c66a95
KH		 9306 If Nth element is a number NUM, N is the first byte of a
9307 charset whose ID is NUM.
4ed46869 9308
c7c66a95
KH		 9309 If Nth element is a list of charset IDs, N is the first byte
9310 of one of them. The list is sorted by dimensions of the
2bc515e4 9311 charsets. A charset of smaller dimension comes firtst. */
df7492f9 9312 val = Fmake_vector (make_number (256), Qnil);
4ed46869 9313
5c99c2e6 9314 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
df7492f9 9315 {
c7c66a95
KH		 9316 struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));
9317 int dim = CHARSET_DIMENSION (charset);
9318 int idx = (dim - 1) * 4;
4ed46869 9319
5c99c2e6 9320 if (CHARSET_ASCII_COMPATIBLE_P (charset))
584948ac 9321 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
4031e2bf 9322
15d143f7
KH		 9323 for (i = charset->code_space[idx];
9324 i <= charset->code_space[idx + 1]; i++)
9325 {
c7c66a95
KH		 9326 Lisp_Object tmp, tmp2;
9327 int dim2;
ec6d2bb8 9328
c7c66a95
KH		 9329 tmp = AREF (val, i);
9330 if (NILP (tmp))
9331 tmp = XCAR (tail);
9332 else if (NUMBERP (tmp))
9333 {
9334 dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp)));
9335 if (dim < dim2)
c7c66a95 9336 tmp = Fcons (XCAR (tail), Fcons (tmp, Qnil));
f9d71dcd
KH		 9337 else
9338 tmp = Fcons (tmp, Fcons (XCAR (tail), Qnil));
c7c66a95 9339 }
15d143f7 9340 else
c7c66a95
KH		 9341 {
9342 for (tmp2 = tmp; CONSP (tmp2); tmp2 = XCDR (tmp2))
9343 {
9344 dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2))));
9345 if (dim < dim2)
9346 break;
9347 }
9348 if (NILP (tmp2))
9349 tmp = nconc2 (tmp, Fcons (XCAR (tail), Qnil));
9350 else
9351 {
9352 XSETCDR (tmp2, Fcons (XCAR (tmp2), XCDR (tmp2)));
9353 XSETCAR (tmp2, XCAR (tail));
9354 }
9355 }
9356 ASET (val, i, tmp);
15d143f7 9357 }
df7492f9
KH		 9358 }
9359 ASET (attrs, coding_attr_charset_valids, val);
9360 category = coding_category_charset;
9361 }
9362 else if (EQ (coding_type, Qccl))
9363 {
9364 Lisp_Object valids;
ecec61c1 9365
df7492f9
KH		 9366 if (nargs < coding_arg_ccl_max)
9367 goto short_args;
ecec61c1 9368
df7492f9
KH		 9369 val = args[coding_arg_ccl_decoder];
9370 CHECK_CCL_PROGRAM (val);
9371 if (VECTORP (val))
9372 val = Fcopy_sequence (val);
9373 ASET (attrs, coding_attr_ccl_decoder, val);
ecec61c1 9374
df7492f9
KH		 9375 val = args[coding_arg_ccl_encoder];
9376 CHECK_CCL_PROGRAM (val);
9377 if (VECTORP (val))
9378 val = Fcopy_sequence (val);
9379 ASET (attrs, coding_attr_ccl_encoder, val);
ecec61c1 9380
df7492f9
KH		 9381 val = args[coding_arg_ccl_valids];
9382 valids = Fmake_string (make_number (256), make_number (0));
9383 for (tail = val; !NILP (tail); tail = Fcdr (tail))
9384 {
8dcbea82 9385 int from, to;
ecec61c1 9386
df7492f9
KH		 9387 val = Fcar (tail);
9388 if (INTEGERP (val))
8dcbea82
KH		 9389 {
9390 from = to = XINT (val);
9391 if (from < 0 || from > 255)
9392 args_out_of_range_3 (val, make_number (0), make_number (255));
9393 }
df7492f9
KH		 9394 else
9395 {
df7492f9 9396 CHECK_CONS (val);
8f924df7
KH		 9397 CHECK_NATNUM_CAR (val);
9398 CHECK_NATNUM_CDR (val);
df7492f9 9399 from = XINT (XCAR (val));
8f924df7 9400 if (from > 255)
8dcbea82
KH		 9401 args_out_of_range_3 (XCAR (val),
9402 make_number (0), make_number (255));
df7492f9 9403 to = XINT (XCDR (val));
8dcbea82
KH		 9404 if (to < from || to > 255)
9405 args_out_of_range_3 (XCDR (val),
9406 XCAR (val), make_number (255));
df7492f9 9407 }
8dcbea82 9408 for (i = from; i <= to; i++)
8f924df7 9409 SSET (valids, i, 1);
df7492f9
KH		 9410 }
9411 ASET (attrs, coding_attr_ccl_valids, valids);
4ed46869 9412
df7492f9 9413 category = coding_category_ccl;
55ab7be3 9414 }
df7492f9 9415 else if (EQ (coding_type, Qutf_16))
55ab7be3 9416 {
df7492f9 9417 Lisp_Object bom, endian;
4ed46869 9418
584948ac 9419 CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
4ed46869 9420
df7492f9
KH		 9421 if (nargs < coding_arg_utf16_max)
9422 goto short_args;
4ed46869 9423
df7492f9
KH		 9424 bom = args[coding_arg_utf16_bom];
9425 if (! NILP (bom) && ! EQ (bom, Qt))
9426 {
9427 CHECK_CONS (bom);
8f924df7
KH		 9428 val = XCAR (bom);
9429 CHECK_CODING_SYSTEM (val);
9430 val = XCDR (bom);
9431 CHECK_CODING_SYSTEM (val);
df7492f9 9432 }
a470d443 9433 ASET (attrs, coding_attr_utf_bom, bom);
df7492f9
KH		 9434
9435 endian = args[coding_arg_utf16_endian];
b49a1807
KH		 9436 CHECK_SYMBOL (endian);
9437 if (NILP (endian))
9438 endian = Qbig;
9439 else if (! EQ (endian, Qbig) && ! EQ (endian, Qlittle))
8f924df7 9440 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian)));
df7492f9
KH		 9441 ASET (attrs, coding_attr_utf_16_endian, endian);
9442
9443 category = (CONSP (bom)
9444 ? coding_category_utf_16_auto
9445 : NILP (bom)
b49a1807 9446 ? (EQ (endian, Qbig)
df7492f9
KH		 9447 ? coding_category_utf_16_be_nosig
9448 : coding_category_utf_16_le_nosig)
b49a1807 9449 : (EQ (endian, Qbig)
df7492f9
KH		 9450 ? coding_category_utf_16_be
9451 : coding_category_utf_16_le));
9452 }
9453 else if (EQ (coding_type, Qiso_2022))
9454 {
9455 Lisp_Object initial, reg_usage, request, flags;
4776e638 9456 int i;
1397dc18 9457
df7492f9
KH		 9458 if (nargs < coding_arg_iso2022_max)
9459 goto short_args;
9460
9461 initial = Fcopy_sequence (args[coding_arg_iso2022_initial]);
9462 CHECK_VECTOR (initial);
9463 for (i = 0; i < 4; i++)
9464 {
9465 val = Faref (initial, make_number (i));
9466 if (! NILP (val))
9467 {
584948ac
KH		 9468 struct charset *charset;
9469
9470 CHECK_CHARSET_GET_CHARSET (val, charset);
9471 ASET (initial, i, make_number (CHARSET_ID (charset)));
9472 if (i == 0 && CHARSET_ASCII_COMPATIBLE_P (charset))
9473 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 9474 }
9475 else
9476 ASET (initial, i, make_number (-1));
9477 }
9478
9479 reg_usage = args[coding_arg_iso2022_reg_usage];
9480 CHECK_CONS (reg_usage);
8f924df7
KH		 9481 CHECK_NUMBER_CAR (reg_usage);
9482 CHECK_NUMBER_CDR (reg_usage);
df7492f9
KH		 9483
9484 request = Fcopy_sequence (args[coding_arg_iso2022_request]);
9485 for (tail = request; ! NILP (tail); tail = Fcdr (tail))
1397dc18 9486 {
df7492f9 9487 int id;
8f924df7 9488 Lisp_Object tmp;
df7492f9
KH		 9489
9490 val = Fcar (tail);
9491 CHECK_CONS (val);
8f924df7
KH		 9492 tmp = XCAR (val);
9493 CHECK_CHARSET_GET_ID (tmp, id);
9494 CHECK_NATNUM_CDR (val);
df7492f9
KH		 9495 if (XINT (XCDR (val)) >= 4)
9496 error ("Invalid graphic register number: %d", XINT (XCDR (val)));
8f924df7 9497 XSETCAR (val, make_number (id));
1397dc18 9498 }
4ed46869 9499
df7492f9
KH		 9500 flags = args[coding_arg_iso2022_flags];
9501 CHECK_NATNUM (flags);
9502 i = XINT (flags);
9503 if (EQ (args[coding_arg_charset_list], Qiso_2022))
9504 flags = make_number (i | CODING_ISO_FLAG_FULL_SUPPORT);
9505
9506 ASET (attrs, coding_attr_iso_initial, initial);
9507 ASET (attrs, coding_attr_iso_usage, reg_usage);
9508 ASET (attrs, coding_attr_iso_request, request);
9509 ASET (attrs, coding_attr_iso_flags, flags);
9510 setup_iso_safe_charsets (attrs);
9511
9512 if (i & CODING_ISO_FLAG_SEVEN_BITS)
9513 category = ((i & (CODING_ISO_FLAG_LOCKING_SHIFT
9514 | CODING_ISO_FLAG_SINGLE_SHIFT))
9515 ? coding_category_iso_7_else
9516 : EQ (args[coding_arg_charset_list], Qiso_2022)
9517 ? coding_category_iso_7
9518 : coding_category_iso_7_tight);
9519 else
9520 {
9521 int id = XINT (AREF (initial, 1));
9522
c6fb6e98 9523 category = (((i & CODING_ISO_FLAG_LOCKING_SHIFT)
df7492f9
KH		 9524 || EQ (args[coding_arg_charset_list], Qiso_2022)
9525 || id < 0)
9526 ? coding_category_iso_8_else
9527 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id)) == 1)
9528 ? coding_category_iso_8_1
9529 : coding_category_iso_8_2);
9530 }
0ce7886f
KH		 9531 if (category != coding_category_iso_8_1
9532 && category != coding_category_iso_8_2)
9533 CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
df7492f9
KH		 9534 }
9535 else if (EQ (coding_type, Qemacs_mule))
c28a9453 9536 {
df7492f9
KH		 9537 if (EQ (args[coding_arg_charset_list], Qemacs_mule))
9538 ASET (attrs, coding_attr_emacs_mule_full, Qt);
584948ac 9539 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9 9540 category = coding_category_emacs_mule;
c28a9453 9541 }
df7492f9 9542 else if (EQ (coding_type, Qshift_jis))
c28a9453 9543 {
df7492f9
KH		 9544
9545 struct charset *charset;
9546
7d64c6ad 9547 if (XINT (Flength (charset_list)) != 3
6e07c25f 9548 && XINT (Flength (charset_list)) != 4)
7d64c6ad 9549 error ("There should be three or four charsets");
df7492f9
KH		 9550
9551 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9552 if (CHARSET_DIMENSION (charset) != 1)
9553 error ("Dimension of charset %s is not one",
8f924df7 9554 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
584948ac
KH		 9555 if (CHARSET_ASCII_COMPATIBLE_P (charset))
9556 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 9557
9558 charset_list = XCDR (charset_list);
9559 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9560 if (CHARSET_DIMENSION (charset) != 1)
9561 error ("Dimension of charset %s is not one",
8f924df7 9562 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
df7492f9
KH		 9563
9564 charset_list = XCDR (charset_list);
9565 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9566 if (CHARSET_DIMENSION (charset) != 2)
7d64c6ad
KH		 9567 error ("Dimension of charset %s is not two",
9568 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
9569
9570 charset_list = XCDR (charset_list);
2b917a06
KH		 9571 if (! NILP (charset_list))
9572 {
9573 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9574 if (CHARSET_DIMENSION (charset) != 2)
9575 error ("Dimension of charset %s is not two",
9576 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
9577 }
df7492f9
KH		 9578
9579 category = coding_category_sjis;
9580 Vsjis_coding_system = name;
c28a9453 9581 }
df7492f9
KH		 9582 else if (EQ (coding_type, Qbig5))
9583 {
9584 struct charset *charset;
4ed46869 9585
df7492f9
KH		 9586 if (XINT (Flength (charset_list)) != 2)
9587 error ("There should be just two charsets");
9588
9589 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9590 if (CHARSET_DIMENSION (charset) != 1)
9591 error ("Dimension of charset %s is not one",
8f924df7 9592 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
584948ac
KH		 9593 if (CHARSET_ASCII_COMPATIBLE_P (charset))
9594 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 9595
9596 charset_list = XCDR (charset_list);
9597 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9598 if (CHARSET_DIMENSION (charset) != 2)
9599 error ("Dimension of charset %s is not two",
8f924df7 9600 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
4ed46869 9601
df7492f9
KH		 9602 category = coding_category_big5;
9603 Vbig5_coding_system = name;
9604 }
9605 else if (EQ (coding_type, Qraw_text))
c28a9453 9606 {
584948ac
KH		 9607 category = coding_category_raw_text;
9608 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
c28a9453 9609 }
df7492f9 9610 else if (EQ (coding_type, Qutf_8))
4ed46869 9611 {
a470d443
KH		 9612 Lisp_Object bom;
9613
584948ac 9614 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
a470d443
KH		 9615
9616 if (nargs < coding_arg_utf8_max)
9617 goto short_args;
9618
9619 bom = args[coding_arg_utf8_bom];
9620 if (! NILP (bom) && ! EQ (bom, Qt))
9621 {
9622 CHECK_CONS (bom);
9623 val = XCAR (bom);
9624 CHECK_CODING_SYSTEM (val);
9625 val = XCDR (bom);
9626 CHECK_CODING_SYSTEM (val);
9627 }
9628 ASET (attrs, coding_attr_utf_bom, bom);
9629
9630 category = (CONSP (bom) ? coding_category_utf_8_auto
9631 : NILP (bom) ? coding_category_utf_8_nosig
9632 : coding_category_utf_8_sig);
4ed46869 9633 }
df7492f9
KH		 9634 else if (EQ (coding_type, Qundecided))
9635 category = coding_category_undecided;
4ed46869 9636 else
df7492f9 9637 error ("Invalid coding system type: %s",
8f924df7 9638 SDATA (SYMBOL_NAME (coding_type)));
4ed46869 9639
df7492f9 9640 CODING_ATTR_CATEGORY (attrs) = make_number (category);
01378f49
KH		 9641 CODING_ATTR_PLIST (attrs)
9642 = Fcons (QCcategory, Fcons (AREF (Vcoding_category_table, category),
9643 CODING_ATTR_PLIST (attrs)));
35befdaa 9644 CODING_ATTR_PLIST (attrs)
3ed051d4 9645 = Fcons (QCascii_compatible_p,
35befdaa
KH		 9646 Fcons (CODING_ATTR_ASCII_COMPAT (attrs),
9647 CODING_ATTR_PLIST (attrs)));
c4825358 9648
df7492f9
KH		 9649 eol_type = args[coding_arg_eol_type];
9650 if (! NILP (eol_type)
9651 && ! EQ (eol_type, Qunix)
9652 && ! EQ (eol_type, Qdos)
9653 && ! EQ (eol_type, Qmac))
9654 error ("Invalid eol-type");
4ed46869 9655
df7492f9 9656 aliases = Fcons (name, Qnil);
4ed46869 9657
df7492f9
KH		 9658 if (NILP (eol_type))
9659 {
9660 eol_type = make_subsidiaries (name);
9661 for (i = 0; i < 3; i++)
1397dc18 9662 {
df7492f9
KH		 9663 Lisp_Object this_spec, this_name, this_aliases, this_eol_type;
9664
9665 this_name = AREF (eol_type, i);
9666 this_aliases = Fcons (this_name, Qnil);
9667 this_eol_type = (i == 0 ? Qunix : i == 1 ? Qdos : Qmac);
9668 this_spec = Fmake_vector (make_number (3), attrs);
9669 ASET (this_spec, 1, this_aliases);
9670 ASET (this_spec, 2, this_eol_type);
9671 Fputhash (this_name, this_spec, Vcoding_system_hash_table);
9672 Vcoding_system_list = Fcons (this_name, Vcoding_system_list);
583f71ca
KH		 9673 val = Fassoc (Fsymbol_name (this_name), Vcoding_system_alist);
9674 if (NILP (val))
9675 Vcoding_system_alist
9676 = Fcons (Fcons (Fsymbol_name (this_name), Qnil),
9677 Vcoding_system_alist);
1397dc18 9678 }
d46c5b12 9679 }
4ed46869 9680
df7492f9
KH		 9681 spec_vec = Fmake_vector (make_number (3), attrs);
9682 ASET (spec_vec, 1, aliases);
9683 ASET (spec_vec, 2, eol_type);
48b0f3ae 9684
df7492f9
KH		 9685 Fputhash (name, spec_vec, Vcoding_system_hash_table);
9686 Vcoding_system_list = Fcons (name, Vcoding_system_list);
583f71ca
KH		 9687 val = Fassoc (Fsymbol_name (name), Vcoding_system_alist);
9688 if (NILP (val))
9689 Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (name), Qnil),
9690 Vcoding_system_alist);
48b0f3ae 9691
df7492f9
KH		 9692 {
9693 int id = coding_categories[category].id;
48b0f3ae 9694
df7492f9
KH		 9695 if (id < 0 || EQ (name, CODING_ID_NAME (id)))
9696 setup_coding_system (name, &coding_categories[category]);
9697 }
48b0f3ae 9698
d46c5b12 9699 return Qnil;
48b0f3ae 9700
df7492f9
KH		 9701 short_args:
9702 return Fsignal (Qwrong_number_of_arguments,
9703 Fcons (intern ("define-coding-system-internal"),
9704 make_number (nargs)));
d46c5b12 9705}
4ed46869 9706
d6925f38 9707
a6f87d34
KH		 9708DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
9709 3, 3, 0,
9710 doc: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
9711 (coding_system, prop, val)
9712 Lisp_Object coding_system, prop, val;
9713{
3dbe7859 9714 Lisp_Object spec, attrs;
a6f87d34
KH		 9715
9716 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9717 attrs = AREF (spec, 0);
9718 if (EQ (prop, QCmnemonic))
9719 {
9720 if (! STRINGP (val))
9721 CHECK_CHARACTER (val);
9722 CODING_ATTR_MNEMONIC (attrs) = val;
9723 }
2133e2d1 9724 else if (EQ (prop, QCdefault_char))
a6f87d34
KH		 9725 {
9726 if (NILP (val))
9727 val = make_number (' ');
9728 else
9729 CHECK_CHARACTER (val);
9730 CODING_ATTR_DEFAULT_CHAR (attrs) = val;
9731 }
9732 else if (EQ (prop, QCdecode_translation_table))
9733 {
9734 if (! CHAR_TABLE_P (val) && ! CONSP (val))
9735 CHECK_SYMBOL (val);
9736 CODING_ATTR_DECODE_TBL (attrs) = val;
9737 }
9738 else if (EQ (prop, QCencode_translation_table))
9739 {
9740 if (! CHAR_TABLE_P (val) && ! CONSP (val))
9741 CHECK_SYMBOL (val);
9742 CODING_ATTR_ENCODE_TBL (attrs) = val;
9743 }
9744 else if (EQ (prop, QCpost_read_conversion))
9745 {
9746 CHECK_SYMBOL (val);
9747 CODING_ATTR_POST_READ (attrs) = val;
9748 }
9749 else if (EQ (prop, QCpre_write_conversion))
9750 {
9751 CHECK_SYMBOL (val);
9752 CODING_ATTR_PRE_WRITE (attrs) = val;
9753 }
35befdaa
KH		 9754 else if (EQ (prop, QCascii_compatible_p))
9755 {
9756 CODING_ATTR_ASCII_COMPAT (attrs) = val;
9757 }
a6f87d34
KH		 9758
9759 CODING_ATTR_PLIST (attrs)
9760 = Fplist_put (CODING_ATTR_PLIST (attrs), prop, val);
9761 return val;
9762}
9763
9764
df7492f9
KH		 9765DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias,
9766 Sdefine_coding_system_alias, 2, 2, 0,
9767 doc: /* Define ALIAS as an alias for CODING-SYSTEM. */)
9768 (alias, coding_system)
9769 Lisp_Object alias, coding_system;
66cfb530 9770{
583f71ca 9771 Lisp_Object spec, aliases, eol_type, val;
4ed46869 9772
df7492f9
KH		 9773 CHECK_SYMBOL (alias);
9774 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9775 aliases = AREF (spec, 1);
d4a1d553 9776 /* ALIASES should be a list of length more than zero, and the first
d6925f38
KH		 9777 element is a base coding system. Append ALIAS at the tail of the
9778 list. */
df7492f9
KH		 9779 while (!NILP (XCDR (aliases)))
9780 aliases = XCDR (aliases);
8f924df7 9781 XSETCDR (aliases, Fcons (alias, Qnil));
4ed46869 9782
df7492f9
KH		 9783 eol_type = AREF (spec, 2);
9784 if (VECTORP (eol_type))
4ed46869 9785 {
df7492f9
KH		 9786 Lisp_Object subsidiaries;
9787 int i;
4ed46869 9788
df7492f9
KH		 9789 subsidiaries = make_subsidiaries (alias);
9790 for (i = 0; i < 3; i++)
9791 Fdefine_coding_system_alias (AREF (subsidiaries, i),
9792 AREF (eol_type, i));
4ed46869 9793 }
df7492f9
KH		 9794
9795 Fputhash (alias, spec, Vcoding_system_hash_table);
d6925f38 9796 Vcoding_system_list = Fcons (alias, Vcoding_system_list);
583f71ca
KH		 9797 val = Fassoc (Fsymbol_name (alias), Vcoding_system_alist);
9798 if (NILP (val))
9799 Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (alias), Qnil),
9800 Vcoding_system_alist);
66cfb530 9801
4ed46869
KH		 9802 return Qnil;
9803}
9804
df7492f9
KH		 9805DEFUN ("coding-system-base", Fcoding_system_base, Scoding_system_base,
9806 1, 1, 0,
9807 doc: /* Return the base of CODING-SYSTEM.
da7db224 9808Any alias or subsidiary coding system is not a base coding system. */)
df7492f9
KH		 9809 (coding_system)
9810 Lisp_Object coding_system;
d46c5b12 9811{
df7492f9 9812 Lisp_Object spec, attrs;
d46c5b12 9813
df7492f9
KH		 9814 if (NILP (coding_system))
9815 return (Qno_conversion);
9816 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9817 attrs = AREF (spec, 0);
9818 return CODING_ATTR_BASE_NAME (attrs);
9819}
1397dc18 9820
df7492f9
KH		 9821DEFUN ("coding-system-plist", Fcoding_system_plist, Scoding_system_plist,
9822 1, 1, 0,
9823 doc: "Return the property list of CODING-SYSTEM.")
9824 (coding_system)
9825 Lisp_Object coding_system;
9826{
9827 Lisp_Object spec, attrs;
1397dc18 9828
df7492f9
KH		 9829 if (NILP (coding_system))
9830 coding_system = Qno_conversion;
9831 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9832 attrs = AREF (spec, 0);
9833 return CODING_ATTR_PLIST (attrs);
d46c5b12
KH		 9834}
9835
df7492f9
KH		 9836
9837DEFUN ("coding-system-aliases", Fcoding_system_aliases, Scoding_system_aliases,
9838 1, 1, 0,
da7db224 9839 doc: /* Return the list of aliases of CODING-SYSTEM. */)
df7492f9
KH		 9840 (coding_system)
9841 Lisp_Object coding_system;
66cfb530 9842{
df7492f9 9843 Lisp_Object spec;
84d60297 9844
df7492f9
KH		 9845 if (NILP (coding_system))
9846 coding_system = Qno_conversion;
9847 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
da7db224 9848 return AREF (spec, 1);
df7492f9 9849}
66cfb530 9850
df7492f9
KH		 9851DEFUN ("coding-system-eol-type", Fcoding_system_eol_type,
9852 Scoding_system_eol_type, 1, 1, 0,
9853 doc: /* Return eol-type of CODING-SYSTEM.
d4a1d553 9854An eol-type is an integer 0, 1, 2, or a vector of coding systems.
66cfb530 9855
df7492f9
KH		 9856Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9857and CR respectively.
66cfb530 9858
df7492f9
KH		 9859A vector value indicates that a format of end-of-line should be
9860detected automatically. Nth element of the vector is the subsidiary
9861coding system whose eol-type is N. */)
6b89e3aa
KH		 9862 (coding_system)
9863 Lisp_Object coding_system;
9864{
df7492f9
KH		 9865 Lisp_Object spec, eol_type;
9866 int n;
6b89e3aa 9867
df7492f9
KH		 9868 if (NILP (coding_system))
9869 coding_system = Qno_conversion;
9870 if (! CODING_SYSTEM_P (coding_system))
9871 return Qnil;
9872 spec = CODING_SYSTEM_SPEC (coding_system);
9873 eol_type = AREF (spec, 2);
9874 if (VECTORP (eol_type))
9875 return Fcopy_sequence (eol_type);
9876 n = EQ (eol_type, Qunix) ? 0 : EQ (eol_type, Qdos) ? 1 : 2;
9877 return make_number (n);
6b89e3aa
KH		 9878}
9879
4ed46869
KH		 9880#endif /* emacs */
9881
9882\f
1397dc18 9883/*** 9. Post-amble ***/
4ed46869 9884
dfcf069d 9885void
4ed46869
KH		 9886init_coding_once ()
9887{
9888 int i;
9889
df7492f9
KH		 9890 for (i = 0; i < coding_category_max; i++)
9891 {
9892 coding_categories[i].id = -1;
9893 coding_priorities[i] = i;
9894 }
4ed46869
KH		 9895
9896 /* ISO2022 specific initialize routine. */
9897 for (i = 0; i < 0x20; i++)
b73bfc1c 9898 iso_code_class[i] = ISO_control_0;
4ed46869
KH		 9899 for (i = 0x21; i < 0x7F; i++)
9900 iso_code_class[i] = ISO_graphic_plane_0;
9901 for (i = 0x80; i < 0xA0; i++)
b73bfc1c 9902 iso_code_class[i] = ISO_control_1;
4ed46869
KH		 9903 for (i = 0xA1; i < 0xFF; i++)
9904 iso_code_class[i] = ISO_graphic_plane_1;
9905 iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
9906 iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
4ed46869
KH		 9907 iso_code_class[ISO_CODE_SO] = ISO_shift_out;
9908 iso_code_class[ISO_CODE_SI] = ISO_shift_in;
9909 iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
9910 iso_code_class[ISO_CODE_ESC] = ISO_escape;
9911 iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
9912 iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
9913 iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
9914
df7492f9
KH		 9915 for (i = 0; i < 256; i++)
9916 {
9917 emacs_mule_bytes[i] = 1;
9918 }
7c78e542
KH		 9919 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_11] = 3;
9920 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_12] = 3;
9921 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_21] = 4;
9922 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_22] = 4;
e0e989f6
KH		 9923}
9924
9925#ifdef emacs
9926
dfcf069d 9927void
e0e989f6
KH		 9928syms_of_coding ()
9929{
df7492f9 9930 staticpro (&Vcoding_system_hash_table);
8f924df7
KH		 9931 {
9932 Lisp_Object args[2];
9933 args[0] = QCtest;
9934 args[1] = Qeq;
9935 Vcoding_system_hash_table = Fmake_hash_table (2, args);
9936 }
df7492f9
KH		 9937
9938 staticpro (&Vsjis_coding_system);
9939 Vsjis_coding_system = Qnil;
e0e989f6 9940
df7492f9
KH		 9941 staticpro (&Vbig5_coding_system);
9942 Vbig5_coding_system = Qnil;
9943
24a73b0a
KH		 9944 staticpro (&Vcode_conversion_reused_workbuf);
9945 Vcode_conversion_reused_workbuf = Qnil;
9946
9947 staticpro (&Vcode_conversion_workbuf_name);
9948 Vcode_conversion_workbuf_name = build_string (" *code-conversion-work*");
e0e989f6 9949
24a73b0a 9950 reused_workbuf_in_use = 0;
df7492f9
KH		 9951
9952 DEFSYM (Qcharset, "charset");
9953 DEFSYM (Qtarget_idx, "target-idx");
9954 DEFSYM (Qcoding_system_history, "coding-system-history");
bb0115a2
RS		 9955 Fset (Qcoding_system_history, Qnil);
9956
9ce27fde 9957 /* Target FILENAME is the first argument. */
e0e989f6 9958 Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
9ce27fde 9959 /* Target FILENAME is the third argument. */
e0e989f6
KH		 9960 Fput (Qwrite_region, Qtarget_idx, make_number (2));
9961
df7492f9 9962 DEFSYM (Qcall_process, "call-process");
9ce27fde 9963 /* Target PROGRAM is the first argument. */
e0e989f6
KH		 9964 Fput (Qcall_process, Qtarget_idx, make_number (0));
9965
df7492f9 9966 DEFSYM (Qcall_process_region, "call-process-region");
9ce27fde 9967 /* Target PROGRAM is the third argument. */
e0e989f6
KH		 9968 Fput (Qcall_process_region, Qtarget_idx, make_number (2));
9969
df7492f9 9970 DEFSYM (Qstart_process, "start-process");
9ce27fde 9971 /* Target PROGRAM is the third argument. */
e0e989f6
KH		 9972 Fput (Qstart_process, Qtarget_idx, make_number (2));
9973
df7492f9 9974 DEFSYM (Qopen_network_stream, "open-network-stream");
9ce27fde 9975 /* Target SERVICE is the fourth argument. */
e0e989f6
KH		 9976 Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
9977
df7492f9
KH		 9978 DEFSYM (Qcoding_system, "coding-system");
9979 DEFSYM (Qcoding_aliases, "coding-aliases");
4ed46869 9980
df7492f9
KH		 9981 DEFSYM (Qeol_type, "eol-type");
9982 DEFSYM (Qunix, "unix");
9983 DEFSYM (Qdos, "dos");
4ed46869 9984
df7492f9
KH		 9985 DEFSYM (Qbuffer_file_coding_system, "buffer-file-coding-system");
9986 DEFSYM (Qpost_read_conversion, "post-read-conversion");
9987 DEFSYM (Qpre_write_conversion, "pre-write-conversion");
9988 DEFSYM (Qdefault_char, "default-char");
9989 DEFSYM (Qundecided, "undecided");
9990 DEFSYM (Qno_conversion, "no-conversion");
9991 DEFSYM (Qraw_text, "raw-text");
4ed46869 9992
df7492f9 9993 DEFSYM (Qiso_2022, "iso-2022");
4ed46869 9994
df7492f9 9995 DEFSYM (Qutf_8, "utf-8");
8f924df7 9996 DEFSYM (Qutf_8_emacs, "utf-8-emacs");
27901516 9997
df7492f9 9998 DEFSYM (Qutf_16, "utf-16");
df7492f9
KH		 9999 DEFSYM (Qbig, "big");
10000 DEFSYM (Qlittle, "little");
27901516 10001
df7492f9
KH		 10002 DEFSYM (Qshift_jis, "shift-jis");
10003 DEFSYM (Qbig5, "big5");
4ed46869 10004
df7492f9 10005 DEFSYM (Qcoding_system_p, "coding-system-p");
4ed46869 10006
df7492f9 10007 DEFSYM (Qcoding_system_error, "coding-system-error");
4ed46869
KH		 10008 Fput (Qcoding_system_error, Qerror_conditions,
10009 Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
10010 Fput (Qcoding_system_error, Qerror_message,
9ce27fde 10011 build_string ("Invalid coding system"));
4ed46869 10012
05e6f5dc
KH		 10013 /* Intern this now in case it isn't already done.
10014 Setting this variable twice is harmless.
10015 But don't staticpro it here--that is done in alloc.c. */
10016 Qchar_table_extra_slots = intern ("char-table-extra-slots");
70c22245 10017
df7492f9 10018 DEFSYM (Qtranslation_table, "translation-table");
433f7f87 10019 Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
df7492f9
KH		 10020 DEFSYM (Qtranslation_table_id, "translation-table-id");
10021 DEFSYM (Qtranslation_table_for_decode, "translation-table-for-decode");
10022 DEFSYM (Qtranslation_table_for_encode, "translation-table-for-encode");
1397dc18 10023
df7492f9 10024 DEFSYM (Qvalid_codes, "valid-codes");
9ce27fde 10025
df7492f9 10026 DEFSYM (Qemacs_mule, "emacs-mule");
d46c5b12 10027
01378f49 10028 DEFSYM (QCcategory, ":category");
a6f87d34 10029 DEFSYM (QCmnemonic, ":mnemonic");
2133e2d1 10030 DEFSYM (QCdefault_char, ":default-char");
a6f87d34
KH		 10031 DEFSYM (QCdecode_translation_table, ":decode-translation-table");
10032 DEFSYM (QCencode_translation_table, ":encode-translation-table");
10033 DEFSYM (QCpost_read_conversion, ":post-read-conversion");
10034 DEFSYM (QCpre_write_conversion, ":pre-write-conversion");
35befdaa 10035 DEFSYM (QCascii_compatible_p, ":ascii-compatible-p");
01378f49 10036
df7492f9
KH		 10037 Vcoding_category_table
10038 = Fmake_vector (make_number (coding_category_max), Qnil);
10039 staticpro (&Vcoding_category_table);
10040 /* Followings are target of code detection. */
10041 ASET (Vcoding_category_table, coding_category_iso_7,
10042 intern ("coding-category-iso-7"));
10043 ASET (Vcoding_category_table, coding_category_iso_7_tight,
10044 intern ("coding-category-iso-7-tight"));
10045 ASET (Vcoding_category_table, coding_category_iso_8_1,
10046 intern ("coding-category-iso-8-1"));
10047 ASET (Vcoding_category_table, coding_category_iso_8_2,
10048 intern ("coding-category-iso-8-2"));
10049 ASET (Vcoding_category_table, coding_category_iso_7_else,
10050 intern ("coding-category-iso-7-else"));
10051 ASET (Vcoding_category_table, coding_category_iso_8_else,
10052 intern ("coding-category-iso-8-else"));
a470d443
KH		 10053 ASET (Vcoding_category_table, coding_category_utf_8_auto,
10054 intern ("coding-category-utf-8-auto"));
10055 ASET (Vcoding_category_table, coding_category_utf_8_nosig,
df7492f9 10056 intern ("coding-category-utf-8"));
a470d443
KH		 10057 ASET (Vcoding_category_table, coding_category_utf_8_sig,
10058 intern ("coding-category-utf-8-sig"));
df7492f9
KH		 10059 ASET (Vcoding_category_table, coding_category_utf_16_be,
10060 intern ("coding-category-utf-16-be"));
ff563fce
KH		 10061 ASET (Vcoding_category_table, coding_category_utf_16_auto,
10062 intern ("coding-category-utf-16-auto"));
df7492f9
KH		 10063 ASET (Vcoding_category_table, coding_category_utf_16_le,
10064 intern ("coding-category-utf-16-le"));
10065 ASET (Vcoding_category_table, coding_category_utf_16_be_nosig,
10066 intern ("coding-category-utf-16-be-nosig"));
10067 ASET (Vcoding_category_table, coding_category_utf_16_le_nosig,
10068 intern ("coding-category-utf-16-le-nosig"));
10069 ASET (Vcoding_category_table, coding_category_charset,
10070 intern ("coding-category-charset"));
10071 ASET (Vcoding_category_table, coding_category_sjis,
10072 intern ("coding-category-sjis"));
10073 ASET (Vcoding_category_table, coding_category_big5,
10074 intern ("coding-category-big5"));
10075 ASET (Vcoding_category_table, coding_category_ccl,
10076 intern ("coding-category-ccl"));
10077 ASET (Vcoding_category_table, coding_category_emacs_mule,
10078 intern ("coding-category-emacs-mule"));
10079 /* Followings are NOT target of code detection. */
10080 ASET (Vcoding_category_table, coding_category_raw_text,
10081 intern ("coding-category-raw-text"));
10082 ASET (Vcoding_category_table, coding_category_undecided,
10083 intern ("coding-category-undecided"));
ecf488bc 10084
065e3595
KH		 10085 DEFSYM (Qinsufficient_source, "insufficient-source");
10086 DEFSYM (Qinconsistent_eol, "inconsistent-eol");
10087 DEFSYM (Qinvalid_source, "invalid-source");
10088 DEFSYM (Qinterrupted, "interrupted");
10089 DEFSYM (Qinsufficient_memory, "insufficient-memory");
44e8490d 10090 DEFSYM (Qcoding_system_define_form, "coding-system-define-form");
065e3595 10091
4ed46869
KH		 10092 defsubr (&Scoding_system_p);
10093 defsubr (&Sread_coding_system);
10094 defsubr (&Sread_non_nil_coding_system);
10095 defsubr (&Scheck_coding_system);
10096 defsubr (&Sdetect_coding_region);
d46c5b12 10097 defsubr (&Sdetect_coding_string);
05e6f5dc 10098 defsubr (&Sfind_coding_systems_region_internal);
068a9dbd 10099 defsubr (&Sunencodable_char_position);
df7492f9 10100 defsubr (&Scheck_coding_systems_region);
4ed46869
KH		 10101 defsubr (&Sdecode_coding_region);
10102 defsubr (&Sencode_coding_region);
10103 defsubr (&Sdecode_coding_string);
10104 defsubr (&Sencode_coding_string);
10105 defsubr (&Sdecode_sjis_char);
10106 defsubr (&Sencode_sjis_char);
10107 defsubr (&Sdecode_big5_char);
10108 defsubr (&Sencode_big5_char);
1ba9e4ab 10109 defsubr (&Sset_terminal_coding_system_internal);
c4825358 10110 defsubr (&Sset_safe_terminal_coding_system_internal);
4ed46869 10111 defsubr (&Sterminal_coding_system);
1ba9e4ab 10112 defsubr (&Sset_keyboard_coding_system_internal);
4ed46869 10113 defsubr (&Skeyboard_coding_system);
a5d301df 10114 defsubr (&Sfind_operation_coding_system);
df7492f9 10115 defsubr (&Sset_coding_system_priority);
6b89e3aa 10116 defsubr (&Sdefine_coding_system_internal);
df7492f9 10117 defsubr (&Sdefine_coding_system_alias);
a6f87d34 10118 defsubr (&Scoding_system_put);
df7492f9
KH		 10119 defsubr (&Scoding_system_base);
10120 defsubr (&Scoding_system_plist);
10121 defsubr (&Scoding_system_aliases);
10122 defsubr (&Scoding_system_eol_type);
10123 defsubr (&Scoding_system_priority_list);
4ed46869 10124
4608c386 10125 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
48b0f3ae
PJ		 10126 doc: /* List of coding systems.
10127
10128Do not alter the value of this variable manually. This variable should be
df7492f9 10129updated by the functions `define-coding-system' and
48b0f3ae 10130`define-coding-system-alias'. */);
4608c386
KH		 10131 Vcoding_system_list = Qnil;
10132
10133 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
48b0f3ae
PJ		 10134 doc: /* Alist of coding system names.
10135Each element is one element list of coding system name.
446dcd75 10136This variable is given to `completing-read' as COLLECTION argument.
48b0f3ae
PJ		 10137
10138Do not alter the value of this variable manually. This variable should be
10139updated by the functions `make-coding-system' and
10140`define-coding-system-alias'. */);
4608c386
KH		 10141 Vcoding_system_alist = Qnil;
10142
4ed46869 10143 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
48b0f3ae
PJ		 10144 doc: /* List of coding-categories (symbols) ordered by priority.
10145
10146On detecting a coding system, Emacs tries code detection algorithms
10147associated with each coding-category one by one in this order. When
10148one algorithm agrees with a byte sequence of source text, the coding
0ec31faf
KH		 10149system bound to the corresponding coding-category is selected.
10150
42205607 10151Don't modify this variable directly, but use `set-coding-priority'. */);
4ed46869
KH		 10152 {
10153 int i;
10154
10155 Vcoding_category_list = Qnil;
df7492f9 10156 for (i = coding_category_max - 1; i >= 0; i--)
4ed46869 10157 Vcoding_category_list
d46c5b12
KH		 10158 = Fcons (XVECTOR (Vcoding_category_table)->contents[i],
10159 Vcoding_category_list);
4ed46869
KH		 10160 }
10161
10162 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
48b0f3ae
PJ		 10163 doc: /* Specify the coding system for read operations.
10164It is useful to bind this variable with `let', but do not set it globally.
10165If the value is a coding system, it is used for decoding on read operation.
446dcd75
JB		 10166If not, an appropriate element is used from one of the coding system alists.
10167There are three such tables: `file-coding-system-alist',
48b0f3ae 10168`process-coding-system-alist', and `network-coding-system-alist'. */);
4ed46869
KH		 10169 Vcoding_system_for_read = Qnil;
10170
10171 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
48b0f3ae
PJ		 10172 doc: /* Specify the coding system for write operations.
10173Programs bind this variable with `let', but you should not set it globally.
10174If the value is a coding system, it is used for encoding of output,
10175when writing it to a file and when sending it to a file or subprocess.
10176
10177If this does not specify a coding system, an appropriate element
446dcd75
JB		 10178is used from one of the coding system alists.
10179There are three such tables: `file-coding-system-alist',
48b0f3ae
PJ		 10180`process-coding-system-alist', and `network-coding-system-alist'.
10181For output to files, if the above procedure does not specify a coding system,
10182the value of `buffer-file-coding-system' is used. */);
4ed46869
KH		 10183 Vcoding_system_for_write = Qnil;
10184
10185 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
df7492f9
KH		 10186 doc: /*
10187Coding system used in the latest file or process I/O. */);
4ed46869
KH		 10188 Vlast_coding_system_used = Qnil;
10189
065e3595
KH		 10190 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error,
10191 doc: /*
10192Error status of the last code conversion.
10193
10194When an error was detected in the last code conversion, this variable
10195is set to one of the following symbols.
10196 `insufficient-source'
10197 `inconsistent-eol'
10198 `invalid-source'
10199 `interrupted'
10200 `insufficient-memory'
10201When no error was detected, the value doesn't change. So, to check
10202the error status of a code conversion by this variable, you must
10203explicitly set this variable to nil before performing code
10204conversion. */);
10205 Vlast_code_conversion_error = Qnil;
10206
9ce27fde 10207 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
df7492f9
KH		 10208 doc: /*
10209*Non-nil means always inhibit code conversion of end-of-line format.
48b0f3ae
PJ		 10210See info node `Coding Systems' and info node `Text and Binary' concerning
10211such conversion. */);
9ce27fde
KH		 10212 inhibit_eol_conversion = 0;
10213
ed29121d 10214 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system,
df7492f9
KH		 10215 doc: /*
10216Non-nil means process buffer inherits coding system of process output.
48b0f3ae
PJ		 10217Bind it to t if the process output is to be treated as if it were a file
10218read from some filesystem. */);
ed29121d
EZ		 10219 inherit_process_coding_system = 0;
10220
02ba4723 10221 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist,
df7492f9
KH		 10222 doc: /*
10223Alist to decide a coding system to use for a file I/O operation.
48b0f3ae
PJ		 10224The format is ((PATTERN . VAL) ...),
10225where PATTERN is a regular expression matching a file name,
10226VAL is a coding system, a cons of coding systems, or a function symbol.
10227If VAL is a coding system, it is used for both decoding and encoding
10228the file contents.
10229If VAL is a cons of coding systems, the car part is used for decoding,
10230and the cdr part is used for encoding.
10231If VAL is a function symbol, the function must return a coding system
2c53e699
KH		 10232or a cons of coding systems which are used as above. The function is
10233called with an argument that is a list of the arguments with which
5a0bbd9a
KH		 10234`find-operation-coding-system' was called. If the function can't decide
10235a coding system, it can return `undecided' so that the normal
10236code-detection is performed.
48b0f3ae
PJ		 10237
10238See also the function `find-operation-coding-system'
10239and the variable `auto-coding-alist'. */);
02ba4723
KH		 10240 Vfile_coding_system_alist = Qnil;
10241
10242 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
df7492f9
KH		 10243 doc: /*
10244Alist to decide a coding system to use for a process I/O operation.
48b0f3ae
PJ		 10245The format is ((PATTERN . VAL) ...),
10246where PATTERN is a regular expression matching a program name,
10247VAL is a coding system, a cons of coding systems, or a function symbol.
10248If VAL is a coding system, it is used for both decoding what received
10249from the program and encoding what sent to the program.
10250If VAL is a cons of coding systems, the car part is used for decoding,
10251and the cdr part is used for encoding.
10252If VAL is a function symbol, the function must return a coding system
10253or a cons of coding systems which are used as above.
10254
10255See also the function `find-operation-coding-system'. */);
02ba4723
KH		 10256 Vprocess_coding_system_alist = Qnil;
10257
10258 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist,
df7492f9
KH		 10259 doc: /*
10260Alist to decide a coding system to use for a network I/O operation.
48b0f3ae
PJ		 10261The format is ((PATTERN . VAL) ...),
10262where PATTERN is a regular expression matching a network service name
10263or is a port number to connect to,
10264VAL is a coding system, a cons of coding systems, or a function symbol.
10265If VAL is a coding system, it is used for both decoding what received
10266from the network stream and encoding what sent to the network stream.
10267If VAL is a cons of coding systems, the car part is used for decoding,
10268and the cdr part is used for encoding.
10269If VAL is a function symbol, the function must return a coding system
10270or a cons of coding systems which are used as above.
10271
10272See also the function `find-operation-coding-system'. */);
02ba4723 10273 Vnetwork_coding_system_alist = Qnil;
4ed46869 10274
68c45bf0 10275 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system,
75205970
RS		 10276 doc: /* Coding system to use with system messages.
10277Also used for decoding keyboard input on X Window system. */);
68c45bf0
PE		 10278 Vlocale_coding_system = Qnil;
10279
005f0d35 10280 /* The eol mnemonics are reset in startup.el system-dependently. */
7722baf9 10281 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
df7492f9
KH		 10282 doc: /*
10283*String displayed in mode line for UNIX-like (LF) end-of-line format. */);
7722baf9 10284 eol_mnemonic_unix = build_string (":");
4ed46869 10285
7722baf9 10286 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
df7492f9
KH		 10287 doc: /*
10288*String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
7722baf9 10289 eol_mnemonic_dos = build_string ("\\");
4ed46869 10290
7722baf9 10291 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
df7492f9
KH		 10292 doc: /*
10293*String displayed in mode line for MAC-like (CR) end-of-line format. */);
7722baf9 10294 eol_mnemonic_mac = build_string ("/");
4ed46869 10295
7722baf9 10296 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
df7492f9
KH		 10297 doc: /*
10298*String displayed in mode line when end-of-line format is not yet determined. */);
7722baf9 10299 eol_mnemonic_undecided = build_string (":");
4ed46869 10300
84fbb8a0 10301 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
df7492f9
KH		 10302 doc: /*
10303*Non-nil enables character translation while encoding and decoding. */);
84fbb8a0 10304 Venable_character_translation = Qt;
bdd9fb48 10305
f967223b 10306 DEFVAR_LISP ("standard-translation-table-for-decode",
48b0f3ae
PJ		 10307 &Vstandard_translation_table_for_decode,
10308 doc: /* Table for translating characters while decoding. */);
f967223b 10309 Vstandard_translation_table_for_decode = Qnil;
bdd9fb48 10310
f967223b 10311 DEFVAR_LISP ("standard-translation-table-for-encode",
48b0f3ae
PJ		 10312 &Vstandard_translation_table_for_encode,
10313 doc: /* Table for translating characters while encoding. */);
f967223b 10314 Vstandard_translation_table_for_encode = Qnil;
4ed46869 10315
df7492f9 10316 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table,
48b0f3ae
PJ		 10317 doc: /* Alist of charsets vs revision numbers.
10318While encoding, if a charset (car part of an element) is found,
df7492f9
KH		 10319designate it with the escape sequence identifying revision (cdr part
10320of the element). */);
10321 Vcharset_revision_table = Qnil;
02ba4723
KH		 10322
10323 DEFVAR_LISP ("default-process-coding-system",
10324 &Vdefault_process_coding_system,
48b0f3ae
PJ		 10325 doc: /* Cons of coding systems used for process I/O by default.
10326The car part is used for decoding a process output,
10327the cdr part is used for encoding a text to be sent to a process. */);
02ba4723 10328 Vdefault_process_coding_system = Qnil;
c4825358 10329
3f003981 10330 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table,
df7492f9
KH		 10331 doc: /*
10332Table of extra Latin codes in the range 128..159 (inclusive).
48b0f3ae
PJ		 10333This is a vector of length 256.
10334If Nth element is non-nil, the existence of code N in a file
10335\(or output of subprocess) doesn't prevent it to be detected as
10336a coding system of ISO 2022 variant which has a flag
10337`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
10338or reading output of a subprocess.
446dcd75 10339Only 128th through 159th elements have a meaning. */);
3f003981 10340 Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
d46c5b12
KH		 10341
10342 DEFVAR_LISP ("select-safe-coding-system-function",
10343 &Vselect_safe_coding_system_function,
df7492f9
KH		 10344 doc: /*
10345Function to call to select safe coding system for encoding a text.
48b0f3ae
PJ		 10346
10347If set, this function is called to force a user to select a proper
10348coding system which can encode the text in the case that a default
fdecf907
GM		 10349coding system used in each operation can't encode the text. The
10350function should take care that the buffer is not modified while
10351the coding system is being selected.
48b0f3ae
PJ		 10352
10353The default value is `select-safe-coding-system' (which see). */);
d46c5b12
KH		 10354 Vselect_safe_coding_system_function = Qnil;
10355
5d5bf4d8
KH		 10356 DEFVAR_BOOL ("coding-system-require-warning",
10357 &coding_system_require_warning,
10358 doc: /* Internal use only.
6b89e3aa
KH		 10359If non-nil, on writing a file, `select-safe-coding-system-function' is
10360called even if `coding-system-for-write' is non-nil. The command
10361`universal-coding-system-argument' binds this variable to t temporarily. */);
5d5bf4d8
KH		 10362 coding_system_require_warning = 0;
10363
10364
22ab2303 10365 DEFVAR_BOOL ("inhibit-iso-escape-detection",
74383408 10366 &inhibit_iso_escape_detection,
df7492f9 10367 doc: /*
97b1b294 10368If non-nil, Emacs ignores ISO-2022 escape sequences during code detection.
48b0f3ae 10369
97b1b294
EZ		 10370When Emacs reads text, it tries to detect how the text is encoded.
10371This code detection is sensitive to escape sequences. If Emacs sees
10372a valid ISO-2022 escape sequence, it assumes the text is encoded in one
10373of the ISO2022 encodings, and decodes text by the corresponding coding
10374system (e.g. `iso-2022-7bit').
48b0f3ae
PJ		 10375
10376However, there may be a case that you want to read escape sequences in
10377a file as is. In such a case, you can set this variable to non-nil.
97b1b294
EZ		 10378Then the code detection will ignore any escape sequences, and no text is
10379detected as encoded in some ISO-2022 encoding. The result is that all
48b0f3ae
PJ		 10380escape sequences become visible in a buffer.
10381
10382The default value is nil, and it is strongly recommended not to change
10383it. That is because many Emacs Lisp source files that contain
10384non-ASCII characters are encoded by the coding system `iso-2022-7bit'
10385in Emacs's distribution, and they won't be decoded correctly on
10386reading if you suppress escape sequence detection.
10387
10388The other way to read escape sequences in a file without decoding is
97b1b294 10389to explicitly specify some coding system that doesn't use ISO-2022
48b0f3ae 10390escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
74383408 10391 inhibit_iso_escape_detection = 0;
002fdb44 10392
97b1b294
EZ		 10393 DEFVAR_BOOL ("inhibit-null-byte-detection",
10394 &inhibit_null_byte_detection,
10395 doc: /* If non-nil, Emacs ignores null bytes on code detection.
10396By default, Emacs treats it as binary data, and does not attempt to
10397decode it. The effect is as if you specified `no-conversion' for
10398reading that text.
10399
10400Set this to non-nil when a regular text happens to include null bytes.
10401Examples are Index nodes of Info files and null-byte delimited output
10402from GNU Find and GNU Grep. Emacs will then ignore the null bytes and
10403decode text as usual. */);
10404 inhibit_null_byte_detection = 0;
10405
002fdb44 10406 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input,
15c8f9d1 10407 doc: /* Char table for translating self-inserting characters.
446dcd75
JB		 10408This is applied to the result of input methods, not their input.
10409See also `keyboard-translate-table'. */);
002fdb44 10410 Vtranslation_table_for_input = Qnil;
8f924df7 10411
2c78b7e1
KH		 10412 {
10413 Lisp_Object args[coding_arg_max];
8f924df7 10414 Lisp_Object plist[16];
2c78b7e1
KH		 10415 int i;
10416
10417 for (i = 0; i < coding_arg_max; i++)
10418 args[i] = Qnil;
10419
10420 plist[0] = intern (":name");
10421 plist[1] = args[coding_arg_name] = Qno_conversion;
10422 plist[2] = intern (":mnemonic");
10423 plist[3] = args[coding_arg_mnemonic] = make_number ('=');
10424 plist[4] = intern (":coding-type");
10425 plist[5] = args[coding_arg_coding_type] = Qraw_text;
10426 plist[6] = intern (":ascii-compatible-p");
10427 plist[7] = args[coding_arg_ascii_compatible_p] = Qt;
10428 plist[8] = intern (":default-char");
10429 plist[9] = args[coding_arg_default_char] = make_number (0);
8f924df7
KH		 10430 plist[10] = intern (":for-unibyte");
10431 plist[11] = args[coding_arg_for_unibyte] = Qt;
10432 plist[12] = intern (":docstring");
10433 plist[13] = build_string ("Do no conversion.\n\
2c78b7e1
KH		 10434\n\
10435When you visit a file with this coding, the file is read into a\n\
10436unibyte buffer as is, thus each byte of a file is treated as a\n\
10437character.");
8f924df7
KH		 10438 plist[14] = intern (":eol-type");
10439 plist[15] = args[coding_arg_eol_type] = Qunix;
10440 args[coding_arg_plist] = Flist (16, plist);
2c78b7e1 10441 Fdefine_coding_system_internal (coding_arg_max, args);
ae6f73fa
KH		 10442
10443 plist[1] = args[coding_arg_name] = Qundecided;
10444 plist[3] = args[coding_arg_mnemonic] = make_number ('-');
10445 plist[5] = args[coding_arg_coding_type] = Qundecided;
10446 /* This is already set.
35befdaa 10447 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
ae6f73fa
KH		 10448 plist[8] = intern (":charset-list");
10449 plist[9] = args[coding_arg_charset_list] = Fcons (Qascii, Qnil);
10450 plist[11] = args[coding_arg_for_unibyte] = Qnil;
10451 plist[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
10452 plist[15] = args[coding_arg_eol_type] = Qnil;
10453 args[coding_arg_plist] = Flist (16, plist);
10454 Fdefine_coding_system_internal (coding_arg_max, args);
2c78b7e1
KH		 10455 }
10456
2c78b7e1 10457 setup_coding_system (Qno_conversion, &safe_terminal_coding);
ff563fce
KH		 10458
10459 {
10460 int i;
10461
10462 for (i = 0; i < coding_category_max; i++)
10463 Fset (AREF (Vcoding_category_table, i), Qno_conversion);
10464 }
fcbcfb64
KH		 10465#if defined (MSDOS) || defined (WINDOWSNT)
10466 system_eol_type = Qdos;
10467#else
10468 system_eol_type = Qunix;
10469#endif
10470 staticpro (&system_eol_type);
4ed46869
KH		 10471}
10472
68c45bf0
PE		 10473char *
10474emacs_strerror (error_number)
10475 int error_number;
10476{
10477 char *str;
10478
ca9c0567 10479 synchronize_system_messages_locale ();
68c45bf0
PE		 10480 str = strerror (error_number);
10481
10482 if (! NILP (Vlocale_coding_system))
10483 {
10484 Lisp_Object dec = code_convert_string_norecord (build_string (str),
10485 Vlocale_coding_system,
10486 0);
d5db4077 10487 str = (char *) SDATA (dec);
68c45bf0
PE		 10488 }
10489
10490 return str;
10491}
10492
4ed46869 10493#endif /* emacs */
9ffd559c
KH		 10494
10495/* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
10496 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.