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