HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
(decode_coding_object, encode_coding_object): Preserve
[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 {
13818c30 1002 coding->destination = BEG_ADDR + coding->dst_pos_byte - BEG_BYTE;
28f67a95
KH		 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))
13818c30 1012 + coding->dst_pos_byte - BEG_BYTE);
28f67a95
KH		 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 6855 int saved_pt = -1, saved_pt_byte;
64cedb0c 6856 int need_marker_adjustment = 0;
b3bfad50 6857 Lisp_Object old_deactivate_mark;
d46c5b12 6858
b3bfad50 6859 old_deactivate_mark = Vdeactivate_mark;
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 {
b3bfad50 6941 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
df7492f9 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);
b3bfad50
KH		 6946 GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
6947 old_deactivate_mark);
d4850d67
KH		 6948 val = safe_call1 (CODING_ATTR_POST_READ (attrs),
6949 make_number (coding->produced_char));
df7492f9
KH		 6950 UNGCPRO;
6951 CHECK_NATNUM (val);
6952 coding->produced_char += Z - prev_Z;
6953 coding->produced += Z_BYTE - prev_Z_BYTE;
d46c5b12 6954 }
de79a6a5 6955
df7492f9 6956 if (EQ (dst_object, Qt))
ec6d2bb8 6957 {
df7492f9
KH		 6958 coding->dst_object = Fbuffer_string ();
6959 }
6960 else if (NILP (dst_object) && BUFFERP (coding->dst_object))
6961 {
6962 set_buffer_internal (XBUFFER (coding->dst_object));
6963 if (dst_bytes < coding->produced)
6964 {
b3bfad50 6965 destination = xrealloc (destination, coding->produced);
df7492f9
KH		 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
b3bfad50 7022 Vdeactivate_mark = old_deactivate_mark;
065e3595 7023 unbind_to (count, coding->dst_object);
d46c5b12
KH		 7024}
7025
d46c5b12 7026
df7492f9
KH		 7027void
7028encode_coding_object (coding, src_object, from, from_byte, to, to_byte,
7029 dst_object)
d46c5b12 7030 struct coding_system *coding;
df7492f9
KH		 7031 Lisp_Object src_object;
7032 EMACS_INT from, from_byte, to, to_byte;
7033 Lisp_Object dst_object;
d46c5b12 7034{
b73bfc1c 7035 int count = specpdl_ptr - specpdl;
df7492f9
KH		 7036 EMACS_INT chars = to - from;
7037 EMACS_INT bytes = to_byte - from_byte;
7038 Lisp_Object attrs;
4776e638 7039 int saved_pt = -1, saved_pt_byte;
64cedb0c 7040 int need_marker_adjustment = 0;
c02d943b 7041 int kill_src_buffer = 0;
b3bfad50 7042 Lisp_Object old_deactivate_mark;
df7492f9 7043
b3bfad50 7044 old_deactivate_mark = Vdeactivate_mark;
df7492f9
KH		 7045
7046 coding->src_object = src_object;
7047 coding->src_chars = chars;
7048 coding->src_bytes = bytes;
7049 coding->src_multibyte = chars < bytes;
7050
7051 attrs = CODING_ID_ATTRS (coding->id);
7052
64cedb0c
KH		 7053 if (EQ (src_object, dst_object))
7054 {
7055 struct Lisp_Marker *tail;
7056
7057 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7058 {
7059 tail->need_adjustment
7060 = tail->charpos == (tail->insertion_type ? from : to);
7061 need_marker_adjustment |= tail->need_adjustment;
7062 }
7063 }
7064
df7492f9 7065 if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
6bac5b12 7066 {
24a73b0a 7067 coding->src_object = code_conversion_save (1, coding->src_multibyte);
df7492f9
KH		 7068 set_buffer_internal (XBUFFER (coding->src_object));
7069 if (STRINGP (src_object))
7070 insert_from_string (src_object, from, from_byte, chars, bytes, 0);
7071 else if (BUFFERP (src_object))
7072 insert_from_buffer (XBUFFER (src_object), from, chars, 0);
7073 else
7074 insert_1_both (coding->source + from, chars, bytes, 0, 0, 0);
d46c5b12 7075
df7492f9
KH		 7076 if (EQ (src_object, dst_object))
7077 {
7078 set_buffer_internal (XBUFFER (src_object));
4776e638 7079 saved_pt = PT, saved_pt_byte = PT_BYTE;
df7492f9
KH		 7080 del_range_both (from, from_byte, to, to_byte, 1);
7081 set_buffer_internal (XBUFFER (coding->src_object));
7082 }
7083
d4850d67
KH		 7084 {
7085 Lisp_Object args[3];
b3bfad50 7086 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
d4850d67 7087
b3bfad50
KH		 7088 GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object,
7089 old_deactivate_mark);
d4850d67
KH		 7090 args[0] = CODING_ATTR_PRE_WRITE (attrs);
7091 args[1] = make_number (BEG);
7092 args[2] = make_number (Z);
7093 safe_call (3, args);
b3bfad50 7094 UNGCPRO;
d4850d67 7095 }
c02d943b
KH		 7096 if (XBUFFER (coding->src_object) != current_buffer)
7097 kill_src_buffer = 1;
ac87bbef 7098 coding->src_object = Fcurrent_buffer ();
df7492f9
KH		 7099 if (BEG != GPT)
7100 move_gap_both (BEG, BEG_BYTE);
7101 coding->src_chars = Z - BEG;
7102 coding->src_bytes = Z_BYTE - BEG_BYTE;
7103 coding->src_pos = BEG;
7104 coding->src_pos_byte = BEG_BYTE;
7105 coding->src_multibyte = Z < Z_BYTE;
7106 }
7107 else if (STRINGP (src_object))
d46c5b12 7108 {
24a73b0a 7109 code_conversion_save (0, 0);
df7492f9
KH		 7110 coding->src_pos = from;
7111 coding->src_pos_byte = from_byte;
b73bfc1c 7112 }
df7492f9 7113 else if (BUFFERP (src_object))
b73bfc1c 7114 {
24a73b0a 7115 code_conversion_save (0, 0);
df7492f9 7116 set_buffer_internal (XBUFFER (src_object));
df7492f9 7117 if (EQ (src_object, dst_object))
d46c5b12 7118 {
4776e638 7119 saved_pt = PT, saved_pt_byte = PT_BYTE;
ff0dacd7
KH		 7120 coding->src_object = del_range_1 (from, to, 1, 1);
7121 coding->src_pos = 0;
7122 coding->src_pos_byte = 0;
d46c5b12 7123 }
df7492f9 7124 else
d46c5b12 7125 {
ff0dacd7
KH		 7126 if (from < GPT && to >= GPT)
7127 move_gap_both (from, from_byte);
df7492f9
KH		 7128 coding->src_pos = from;
7129 coding->src_pos_byte = from_byte;
d46c5b12 7130 }
d46c5b12 7131 }
4776e638 7132 else
24a73b0a 7133 code_conversion_save (0, 0);
d46c5b12 7134
df7492f9 7135 if (BUFFERP (dst_object))
88993dfd 7136 {
df7492f9 7137 coding->dst_object = dst_object;
28f67a95
KH		 7138 if (EQ (src_object, dst_object))
7139 {
7140 coding->dst_pos = from;
7141 coding->dst_pos_byte = from_byte;
7142 }
7143 else
7144 {
7145 coding->dst_pos = BUF_PT (XBUFFER (dst_object));
7146 coding->dst_pos_byte = BUF_PT_BYTE (XBUFFER (dst_object));
7147 }
df7492f9
KH		 7148 coding->dst_multibyte
7149 = ! NILP (XBUFFER (dst_object)->enable_multibyte_characters);
88993dfd 7150 }
df7492f9 7151 else if (EQ (dst_object, Qt))
d46c5b12 7152 {
df7492f9 7153 coding->dst_object = Qnil;
df7492f9 7154 coding->dst_bytes = coding->src_chars;
ac87bbef
KH		 7155 if (coding->dst_bytes == 0)
7156 coding->dst_bytes = 1;
7157 coding->destination = (unsigned char *) xmalloc (coding->dst_bytes);
df7492f9 7158 coding->dst_multibyte = 0;
d46c5b12
KH		 7159 }
7160 else
7161 {
df7492f9
KH		 7162 coding->dst_object = Qnil;
7163 coding->dst_multibyte = 0;
d46c5b12
KH		 7164 }
7165
df7492f9 7166 encode_coding (coding);
d46c5b12 7167
df7492f9 7168 if (EQ (dst_object, Qt))
d46c5b12 7169 {
df7492f9
KH		 7170 if (BUFFERP (coding->dst_object))
7171 coding->dst_object = Fbuffer_string ();
7172 else
d46c5b12 7173 {
df7492f9
KH		 7174 coding->dst_object
7175 = make_unibyte_string ((char *) coding->destination,
7176 coding->produced);
7177 xfree (coding->destination);
d46c5b12 7178 }
4ed46869 7179 }
d46c5b12 7180
4776e638
KH		 7181 if (saved_pt >= 0)
7182 {
7183 /* This is the case of:
7184 (BUFFERP (src_object) && EQ (src_object, dst_object))
7185 As we have moved PT while replacing the original buffer
7186 contents, we must recover it now. */
7187 set_buffer_internal (XBUFFER (src_object));
7188 if (saved_pt < from)
7189 TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte);
7190 else if (saved_pt < from + chars)
7191 TEMP_SET_PT_BOTH (from, from_byte);
7192 else if (! NILP (current_buffer->enable_multibyte_characters))
7193 TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars),
7194 saved_pt_byte + (coding->produced - bytes));
d46c5b12 7195 else
4776e638
KH		 7196 TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes),
7197 saved_pt_byte + (coding->produced - bytes));
64cedb0c
KH		 7198
7199 if (need_marker_adjustment)
7200 {
7201 struct Lisp_Marker *tail;
7202
7203 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
7204 if (tail->need_adjustment)
7205 {
7206 tail->need_adjustment = 0;
7207 if (tail->insertion_type)
7208 {
7209 tail->bytepos = from_byte;
7210 tail->charpos = from;
7211 }
7212 else
7213 {
7214 tail->bytepos = from_byte + coding->produced;
7215 tail->charpos
7216 = (NILP (current_buffer->enable_multibyte_characters)
7217 ? tail->bytepos : from + coding->produced_char);
7218 }
7219 }
7220 }
4776e638
KH		 7221 }
7222
c02d943b
KH		 7223 if (kill_src_buffer)
7224 Fkill_buffer (coding->src_object);
b3bfad50
KH		 7225
7226 Vdeactivate_mark = old_deactivate_mark;
df7492f9 7227 unbind_to (count, Qnil);
b73bfc1c
KH		 7228}
7229
df7492f9 7230
b73bfc1c 7231Lisp_Object
df7492f9 7232preferred_coding_system ()
b73bfc1c 7233{
df7492f9 7234 int id = coding_categories[coding_priorities[0]].id;
2391eaa4 7235
df7492f9 7236 return CODING_ID_NAME (id);
4ed46869
KH		 7237}
7238
7239\f
7240#ifdef emacs
1397dc18 7241/*** 8. Emacs Lisp library functions ***/
4ed46869 7242
4ed46869 7243DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
48b0f3ae 7244 doc: /* Return t if OBJECT is nil or a coding-system.
df7492f9 7245See the documentation of `define-coding-system' for information
48b0f3ae
PJ		 7246about coding-system objects. */)
7247 (obj)
4ed46869
KH		 7248 Lisp_Object obj;
7249{
44e8490d
KH		 7250 if (NILP (obj)
7251 || CODING_SYSTEM_ID (obj) >= 0)
7252 return Qt;
7253 if (! SYMBOLP (obj)
7254 || NILP (Fget (obj, Qcoding_system_define_form)))
7255 return Qnil;
7256 return Qt;
4ed46869
KH		 7257}
7258
9d991de8
RS		 7259DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
7260 Sread_non_nil_coding_system, 1, 1, 0,
48b0f3ae
PJ		 7261 doc: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7262 (prompt)
4ed46869
KH		 7263 Lisp_Object prompt;
7264{
e0e989f6 7265 Lisp_Object val;
9d991de8
RS		 7266 do
7267 {
4608c386
KH		 7268 val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
7269 Qt, Qnil, Qcoding_system_history, Qnil, Qnil);
9d991de8 7270 }
8f924df7 7271 while (SCHARS (val) == 0);
e0e989f6 7272 return (Fintern (val, Qnil));
4ed46869
KH		 7273}
7274
9b787f3e 7275DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
48b0f3ae 7276 doc: /* Read a coding system from the minibuffer, prompting with string PROMPT.
c7183fb8
GM		 7277If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
7278Ignores case when completing coding systems (all Emacs coding systems
7279are lower-case). */)
48b0f3ae 7280 (prompt, default_coding_system)
9b787f3e 7281 Lisp_Object prompt, default_coding_system;
4ed46869 7282{
f44d27ce 7283 Lisp_Object val;
c7183fb8
GM		 7284 int count = SPECPDL_INDEX ();
7285
9b787f3e 7286 if (SYMBOLP (default_coding_system))
57d25e6f 7287 default_coding_system = SYMBOL_NAME (default_coding_system);
c7183fb8 7288 specbind (Qcompletion_ignore_case, Qt);
4608c386 7289 val = Fcompleting_read (prompt, Vcoding_system_alist, Qnil,
9b787f3e
RS		 7290 Qt, Qnil, Qcoding_system_history,
7291 default_coding_system, Qnil);
c7183fb8 7292 unbind_to (count, Qnil);
8f924df7 7293 return (SCHARS (val) == 0 ? Qnil : Fintern (val, Qnil));
4ed46869
KH		 7294}
7295
7296DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
7297 1, 1, 0,
48b0f3ae 7298 doc: /* Check validity of CODING-SYSTEM.
9ffd559c
KH		 7299If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7300It is valid if it is nil or a symbol defined as a coding system by the
7301function `define-coding-system'. */)
df7492f9 7302 (coding_system)
4ed46869
KH		 7303 Lisp_Object coding_system;
7304{
44e8490d
KH		 7305 Lisp_Object define_form;
7306
7307 define_form = Fget (coding_system, Qcoding_system_define_form);
7308 if (! NILP (define_form))
7309 {
7310 Fput (coding_system, Qcoding_system_define_form, Qnil);
7311 safe_eval (define_form);
7312 }
4ed46869
KH		 7313 if (!NILP (Fcoding_system_p (coding_system)))
7314 return coding_system;
fcad4ec4 7315 xsignal1 (Qcoding_system_error, coding_system);
4ed46869 7316}
df7492f9 7317
3a73fa5d 7318\f
89528eb3
KH		 7319/* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7320 HIGHEST is nonzero, return the coding system of the highest
7321 priority among the detected coding systems. Otherwize return a
7322 list of detected coding systems sorted by their priorities. If
7323 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7324 multibyte form but contains only ASCII and eight-bit chars.
7325 Otherwise, the bytes are raw bytes.
7326
7327 CODING-SYSTEM controls the detection as below:
7328
7329 If it is nil, detect both text-format and eol-format. If the
7330 text-format part of CODING-SYSTEM is already specified
7331 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7332 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7333 detect only text-format. */
7334
d46c5b12 7335Lisp_Object
24a73b0a
KH		 7336detect_coding_system (src, src_chars, src_bytes, highest, multibytep,
7337 coding_system)
8f924df7 7338 const unsigned char *src;
13818c30
SM		 7339 EMACS_INT src_chars, src_bytes;
7340 int highest;
0a28aafb 7341 int multibytep;
df7492f9 7342 Lisp_Object coding_system;
4ed46869 7343{
8f924df7 7344 const unsigned char *src_end = src + src_bytes;
df7492f9
KH		 7345 Lisp_Object attrs, eol_type;
7346 Lisp_Object val;
7347 struct coding_system coding;
89528eb3 7348 int id;
ff0dacd7 7349 struct coding_detection_info detect_info;
24a73b0a 7350 enum coding_category base_category;
b73bfc1c 7351
df7492f9
KH		 7352 if (NILP (coding_system))
7353 coding_system = Qundecided;
7354 setup_coding_system (coding_system, &coding);
7355 attrs = CODING_ID_ATTRS (coding.id);
7356 eol_type = CODING_ID_EOL_TYPE (coding.id);
89528eb3 7357 coding_system = CODING_ATTR_BASE_NAME (attrs);
4ed46869 7358
df7492f9 7359 coding.source = src;
24a73b0a 7360 coding.src_chars = src_chars;
df7492f9
KH		 7361 coding.src_bytes = src_bytes;
7362 coding.src_multibyte = multibytep;
7363 coding.consumed = 0;
89528eb3 7364 coding.mode |= CODING_MODE_LAST_BLOCK;
d46c5b12 7365
ff0dacd7 7366 detect_info.checked = detect_info.found = detect_info.rejected = 0;
d46c5b12 7367
89528eb3 7368 /* At first, detect text-format if necessary. */
24a73b0a
KH		 7369 base_category = XINT (CODING_ATTR_CATEGORY (attrs));
7370 if (base_category == coding_category_undecided)
4ed46869 7371 {
ff0dacd7
KH		 7372 enum coding_category category;
7373 struct coding_system *this;
7374 int c, i;
88993dfd 7375
24a73b0a
KH		 7376 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7377 for (i = 0; src < src_end; i++, src++)
4ed46869 7378 {
df7492f9 7379 c = *src;
6cb21a4f 7380 if (c & 0x80)
d46c5b12 7381 break;
6cb21a4f
KH		 7382 if (c < 0x20
7383 && (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
c7266f4a 7384 && ! inhibit_iso_escape_detection)
6cb21a4f
KH		 7385 {
7386 coding.head_ascii = src - coding.source;
7387 if (detect_coding_iso_2022 (&coding, &detect_info))
7388 {
7389 /* We have scanned the whole data. */
7390 if (! (detect_info.rejected & CATEGORY_MASK_ISO_7_ELSE))
7391 /* We didn't find an 8-bit code. */
7392 src = src_end;
7393 break;
7394 }
7395 }
4ed46869 7396 }
df7492f9 7397 coding.head_ascii = src - coding.source;
88993dfd 7398
6cb21a4f
KH		 7399 if (src < src_end
7400 || detect_info.found)
7401 {
7402 if (src == src_end)
7403 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7404 for (i = 0; i < coding_category_raw_text; i++)
ff0dacd7 7405 {
6cb21a4f 7406 category = coding_priorities[i];
c7266f4a 7407 this = coding_categories + category;
6cb21a4f 7408 if (detect_info.found & (1 << category))
ff0dacd7
KH		 7409 break;
7410 }
6cb21a4f
KH		 7411 else
7412 for (i = 0; i < coding_category_raw_text; i++)
df7492f9 7413 {
6cb21a4f
KH		 7414 category = coding_priorities[i];
7415 this = coding_categories + category;
7416
7417 if (this->id < 0)
24a73b0a 7418 {
6cb21a4f
KH		 7419 /* No coding system of this category is defined. */
7420 detect_info.rejected |= (1 << category);
7421 }
7422 else if (category >= coding_category_raw_text)
7423 continue;
7424 else if (detect_info.checked & (1 << category))
7425 {
7426 if (highest
7427 && (detect_info.found & (1 << category)))
7428 break;
7429 }
7430 else
7431 {
7432 if ((*(this->detector)) (&coding, &detect_info)
7433 && highest
7434 && (detect_info.found & (1 << category)))
24a73b0a 7435 {
6cb21a4f
KH		 7436 if (category == coding_category_utf_16_auto)
7437 {
7438 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
7439 category = coding_category_utf_16_le;
7440 else
7441 category = coding_category_utf_16_be;
7442 }
7443 break;
24a73b0a 7444 }
24a73b0a 7445 }
df7492f9 7446 }
6cb21a4f 7447 }
ec6d2bb8 7448
ff0dacd7 7449 if (detect_info.rejected == CATEGORY_MASK_ANY)
ec6d2bb8 7450 {
ff0dacd7 7451 detect_info.found = CATEGORY_MASK_RAW_TEXT;
89528eb3
KH		 7452 id = coding_categories[coding_category_raw_text].id;
7453 val = Fcons (make_number (id), Qnil);
7454 }
ff0dacd7 7455 else if (! detect_info.rejected && ! detect_info.found)
89528eb3 7456 {
ff0dacd7 7457 detect_info.found = CATEGORY_MASK_ANY;
89528eb3
KH		 7458 id = coding_categories[coding_category_undecided].id;
7459 val = Fcons (make_number (id), Qnil);
7460 }
7461 else if (highest)
7462 {
ff0dacd7 7463 if (detect_info.found)
ec6d2bb8 7464 {
ff0dacd7
KH		 7465 detect_info.found = 1 << category;
7466 val = Fcons (make_number (this->id), Qnil);
7467 }
7468 else
7469 for (i = 0; i < coding_category_raw_text; i++)
7470 if (! (detect_info.rejected & (1 << coding_priorities[i])))
7471 {
7472 detect_info.found = 1 << coding_priorities[i];
7473 id = coding_categories[coding_priorities[i]].id;
7474 val = Fcons (make_number (id), Qnil);
7475 break;
7476 }
7477 }
89528eb3
KH		 7478 else
7479 {
ff0dacd7
KH		 7480 int mask = detect_info.rejected | detect_info.found;
7481 int found = 0;
89528eb3 7482 val = Qnil;
ec6d2bb8 7483
89528eb3 7484 for (i = coding_category_raw_text - 1; i >= 0; i--)
ff0dacd7
KH		 7485 {
7486 category = coding_priorities[i];
7487 if (! (mask & (1 << category)))
ec6d2bb8 7488 {
ff0dacd7
KH		 7489 found |= 1 << category;
7490 id = coding_categories[category].id;
c7266f4a
KH		 7491 if (id >= 0)
7492 val = Fcons (make_number (id), val);
ff0dacd7
KH		 7493 }
7494 }
7495 for (i = coding_category_raw_text - 1; i >= 0; i--)
7496 {
7497 category = coding_priorities[i];
7498 if (detect_info.found & (1 << category))
7499 {
7500 id = coding_categories[category].id;
7501 val = Fcons (make_number (id), val);
ec6d2bb8 7502 }
ec6d2bb8 7503 }
ff0dacd7 7504 detect_info.found |= found;
ec6d2bb8 7505 }
ec6d2bb8 7506 }
24a73b0a
KH		 7507 else if (base_category == coding_category_utf_16_auto)
7508 {
7509 if (detect_coding_utf_16 (&coding, &detect_info))
7510 {
24a73b0a
KH		 7511 struct coding_system *this;
7512
7513 if (detect_info.found & CATEGORY_MASK_UTF_16_LE)
7514 this = coding_categories + coding_category_utf_16_le;
7515 else if (detect_info.found & CATEGORY_MASK_UTF_16_BE)
7516 this = coding_categories + coding_category_utf_16_be;
7517 else if (detect_info.rejected & CATEGORY_MASK_UTF_16_LE_NOSIG)
7518 this = coding_categories + coding_category_utf_16_be_nosig;
7519 else
7520 this = coding_categories + coding_category_utf_16_le_nosig;
7521 val = Fcons (make_number (this->id), Qnil);
7522 }
7523 }
df7492f9
KH		 7524 else
7525 {
ff0dacd7 7526 detect_info.found = 1 << XINT (CODING_ATTR_CATEGORY (attrs));
89528eb3 7527 val = Fcons (make_number (coding.id), Qnil);
4ed46869 7528 }
df7492f9 7529
89528eb3 7530 /* Then, detect eol-format if necessary. */
df7492f9 7531 {
89528eb3 7532 int normal_eol = -1, utf_16_be_eol = -1, utf_16_le_eol;
df7492f9
KH		 7533 Lisp_Object tail;
7534
89528eb3
KH		 7535 if (VECTORP (eol_type))
7536 {
ff0dacd7 7537 if (detect_info.found & ~CATEGORY_MASK_UTF_16)
89528eb3
KH		 7538 normal_eol = detect_eol (coding.source, src_bytes,
7539 coding_category_raw_text);
ff0dacd7
KH		 7540 if (detect_info.found & (CATEGORY_MASK_UTF_16_BE
7541 | CATEGORY_MASK_UTF_16_BE_NOSIG))
89528eb3
KH		 7542 utf_16_be_eol = detect_eol (coding.source, src_bytes,
7543 coding_category_utf_16_be);
ff0dacd7
KH		 7544 if (detect_info.found & (CATEGORY_MASK_UTF_16_LE
7545 | CATEGORY_MASK_UTF_16_LE_NOSIG))
89528eb3
KH		 7546 utf_16_le_eol = detect_eol (coding.source, src_bytes,
7547 coding_category_utf_16_le);
7548 }
7549 else
7550 {
7551 if (EQ (eol_type, Qunix))
7552 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_LF;
7553 else if (EQ (eol_type, Qdos))
7554 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CRLF;
7555 else
7556 normal_eol = utf_16_be_eol = utf_16_le_eol = EOL_SEEN_CR;
7557 }
7558
df7492f9
KH		 7559 for (tail = val; CONSP (tail); tail = XCDR (tail))
7560 {
89528eb3 7561 enum coding_category category;
df7492f9 7562 int this_eol;
89528eb3
KH		 7563
7564 id = XINT (XCAR (tail));
7565 attrs = CODING_ID_ATTRS (id);
7566 category = XINT (CODING_ATTR_CATEGORY (attrs));
7567 eol_type = CODING_ID_EOL_TYPE (id);
df7492f9
KH		 7568 if (VECTORP (eol_type))
7569 {
89528eb3
KH		 7570 if (category == coding_category_utf_16_be
7571 || category == coding_category_utf_16_be_nosig)
7572 this_eol = utf_16_be_eol;
7573 else if (category == coding_category_utf_16_le
7574 || category == coding_category_utf_16_le_nosig)
7575 this_eol = utf_16_le_eol;
df7492f9 7576 else
89528eb3
KH		 7577 this_eol = normal_eol;
7578
df7492f9
KH		 7579 if (this_eol == EOL_SEEN_LF)
7580 XSETCAR (tail, AREF (eol_type, 0));
7581 else if (this_eol == EOL_SEEN_CRLF)
7582 XSETCAR (tail, AREF (eol_type, 1));
7583 else if (this_eol == EOL_SEEN_CR)
7584 XSETCAR (tail, AREF (eol_type, 2));
89528eb3
KH		 7585 else
7586 XSETCAR (tail, CODING_ID_NAME (id));
df7492f9 7587 }
89528eb3
KH		 7588 else
7589 XSETCAR (tail, CODING_ID_NAME (id));
df7492f9
KH		 7590 }
7591 }
ec6d2bb8 7592
03699b14 7593 return (highest ? XCAR (val) : val);
ec6d2bb8
KH		 7594}
7595
ec6d2bb8 7596
d46c5b12
KH		 7597DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
7598 2, 3, 0,
48b0f3ae
PJ		 7599 doc: /* Detect coding system of the text in the region between START and END.
7600Return a list of possible coding systems ordered by priority.
ec6d2bb8 7601
12e0131a
KH		 7602If only ASCII characters are found (except for such ISO-2022 control
7603characters ISO-2022 as ESC), it returns a list of single element
48b0f3ae
PJ		 7604`undecided' or its subsidiary coding system according to a detected
7605end-of-line format.
ec6d2bb8 7606
48b0f3ae
PJ		 7607If optional argument HIGHEST is non-nil, return the coding system of
7608highest priority. */)
7609 (start, end, highest)
d46c5b12
KH		 7610 Lisp_Object start, end, highest;
7611{
7612 int from, to;
7613 int from_byte, to_byte;
ec6d2bb8 7614
b7826503
PJ		 7615 CHECK_NUMBER_COERCE_MARKER (start);
7616 CHECK_NUMBER_COERCE_MARKER (end);
ec6d2bb8 7617
d46c5b12
KH		 7618 validate_region (&start, &end);
7619 from = XINT (start), to = XINT (end);
7620 from_byte = CHAR_TO_BYTE (from);
7621 to_byte = CHAR_TO_BYTE (to);
ec6d2bb8 7622
d46c5b12
KH		 7623 if (from < GPT && to >= GPT)
7624 move_gap_both (to, to_byte);
c210f766 7625
d46c5b12 7626 return detect_coding_system (BYTE_POS_ADDR (from_byte),
24a73b0a 7627 to - from, to_byte - from_byte,
0a28aafb
KH		 7628 !NILP (highest),
7629 !NILP (current_buffer
df7492f9
KH		 7630 ->enable_multibyte_characters),
7631 Qnil);
ec6d2bb8
KH		 7632}
7633
d46c5b12
KH		 7634DEFUN ("detect-coding-string", Fdetect_coding_string, Sdetect_coding_string,
7635 1, 2, 0,
48b0f3ae
PJ		 7636 doc: /* Detect coding system of the text in STRING.
7637Return a list of possible coding systems ordered by priority.
fb88bf2d 7638
12e0131a
KH		 7639If only ASCII characters are found (except for such ISO-2022 control
7640characters ISO-2022 as ESC), it returns a list of single element
48b0f3ae
PJ		 7641`undecided' or its subsidiary coding system according to a detected
7642end-of-line format.
d46c5b12 7643
48b0f3ae
PJ		 7644If optional argument HIGHEST is non-nil, return the coding system of
7645highest priority. */)
7646 (string, highest)
d46c5b12
KH		 7647 Lisp_Object string, highest;
7648{
b7826503 7649 CHECK_STRING (string);
b73bfc1c 7650
24a73b0a
KH		 7651 return detect_coding_system (SDATA (string),
7652 SCHARS (string), SBYTES (string),
8f924df7 7653 !NILP (highest), STRING_MULTIBYTE (string),
df7492f9 7654 Qnil);
4ed46869 7655}
4ed46869 7656
b73bfc1c 7657
df7492f9
KH		 7658static INLINE int
7659char_encodable_p (c, attrs)
7660 int c;
7661 Lisp_Object attrs;
05e6f5dc 7662{
df7492f9 7663 Lisp_Object tail;
df7492f9 7664 struct charset *charset;
7d64c6ad 7665 Lisp_Object translation_table;
d46c5b12 7666
7d64c6ad 7667 translation_table = CODING_ATTR_TRANS_TBL (attrs);
a6f87d34 7668 if (! NILP (translation_table))
7d64c6ad 7669 c = translate_char (translation_table, c);
df7492f9
KH		 7670 for (tail = CODING_ATTR_CHARSET_LIST (attrs);
7671 CONSP (tail); tail = XCDR (tail))
e133c8fa 7672 {
df7492f9
KH		 7673 charset = CHARSET_FROM_ID (XINT (XCAR (tail)));
7674 if (CHAR_CHARSET_P (c, charset))
7675 break;
e133c8fa 7676 }
df7492f9 7677 return (! NILP (tail));
05e6f5dc 7678}
83fa074f 7679
fb88bf2d 7680
df7492f9
KH		 7681/* Return a list of coding systems that safely encode the text between
7682 START and END. If EXCLUDE is non-nil, it is a list of coding
7683 systems not to check. The returned list doesn't contain any such
48468dac 7684 coding systems. In any case, if the text contains only ASCII or is
df7492f9 7685 unibyte, return t. */
e077cc80 7686
df7492f9
KH		 7687DEFUN ("find-coding-systems-region-internal",
7688 Ffind_coding_systems_region_internal,
7689 Sfind_coding_systems_region_internal, 2, 3, 0,
7690 doc: /* Internal use only. */)
7691 (start, end, exclude)
7692 Lisp_Object start, end, exclude;
7693{
7694 Lisp_Object coding_attrs_list, safe_codings;
7695 EMACS_INT start_byte, end_byte;
7c78e542 7696 const unsigned char *p, *pbeg, *pend;
df7492f9
KH		 7697 int c;
7698 Lisp_Object tail, elt;
d46c5b12 7699
df7492f9
KH		 7700 if (STRINGP (start))
7701 {
7702 if (!STRING_MULTIBYTE (start)
8f924df7 7703 || SCHARS (start) == SBYTES (start))
df7492f9
KH		 7704 return Qt;
7705 start_byte = 0;
8f924df7 7706 end_byte = SBYTES (start);
df7492f9
KH		 7707 }
7708 else
d46c5b12 7709 {
df7492f9
KH		 7710 CHECK_NUMBER_COERCE_MARKER (start);
7711 CHECK_NUMBER_COERCE_MARKER (end);
7712 if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
7713 args_out_of_range (start, end);
7714 if (NILP (current_buffer->enable_multibyte_characters))
7715 return Qt;
7716 start_byte = CHAR_TO_BYTE (XINT (start));
7717 end_byte = CHAR_TO_BYTE (XINT (end));
7718 if (XINT (end) - XINT (start) == end_byte - start_byte)
7719 return Qt;
d46c5b12 7720
e1c23804 7721 if (XINT (start) < GPT && XINT (end) > GPT)
d46c5b12 7722 {
e1c23804
DL		 7723 if ((GPT - XINT (start)) < (XINT (end) - GPT))
7724 move_gap_both (XINT (start), start_byte);
df7492f9 7725 else
e1c23804 7726 move_gap_both (XINT (end), end_byte);
d46c5b12
KH		 7727 }
7728 }
7729
df7492f9
KH		 7730 coding_attrs_list = Qnil;
7731 for (tail = Vcoding_system_list; CONSP (tail); tail = XCDR (tail))
7732 if (NILP (exclude)
7733 || NILP (Fmemq (XCAR (tail), exclude)))
7734 {
7735 Lisp_Object attrs;
d46c5b12 7736
df7492f9
KH		 7737 attrs = AREF (CODING_SYSTEM_SPEC (XCAR (tail)), 0);
7738 if (EQ (XCAR (tail), CODING_ATTR_BASE_NAME (attrs))
7739 && ! EQ (CODING_ATTR_TYPE (attrs), Qundecided))
7d64c6ad
KH		 7740 {
7741 ASET (attrs, coding_attr_trans_tbl,
2170c8f0 7742 get_translation_table (attrs, 1, NULL));
7d64c6ad
KH		 7743 coding_attrs_list = Fcons (attrs, coding_attrs_list);
7744 }
df7492f9 7745 }
d46c5b12 7746
df7492f9 7747 if (STRINGP (start))
8f924df7 7748 p = pbeg = SDATA (start);
df7492f9
KH		 7749 else
7750 p = pbeg = BYTE_POS_ADDR (start_byte);
7751 pend = p + (end_byte - start_byte);
b843d1ae 7752
df7492f9
KH		 7753 while (p < pend && ASCII_BYTE_P (*p)) p++;
7754 while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
d46c5b12 7755
05e6f5dc 7756 while (p < pend)
72d1a715 7757 {
df7492f9
KH		 7758 if (ASCII_BYTE_P (*p))
7759 p++;
72d1a715
RS		 7760 else
7761 {
df7492f9 7762 c = STRING_CHAR_ADVANCE (p);
12410ef1 7763
df7492f9
KH		 7764 charset_map_loaded = 0;
7765 for (tail = coding_attrs_list; CONSP (tail);)
7766 {
7767 elt = XCAR (tail);
7768 if (NILP (elt))
7769 tail = XCDR (tail);
7770 else if (char_encodable_p (c, elt))
7771 tail = XCDR (tail);
7772 else if (CONSP (XCDR (tail)))
7773 {
7774 XSETCAR (tail, XCAR (XCDR (tail)));
7775 XSETCDR (tail, XCDR (XCDR (tail)));
7776 }
7777 else
7778 {
7779 XSETCAR (tail, Qnil);
7780 tail = XCDR (tail);
7781 }
7782 }
7783 if (charset_map_loaded)
7784 {
7785 EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
05e6f5dc 7786
df7492f9 7787 if (STRINGP (start))
8f924df7 7788 pbeg = SDATA (start);
df7492f9
KH		 7789 else
7790 pbeg = BYTE_POS_ADDR (start_byte);
7791 p = pbeg + p_offset;
7792 pend = pbeg + pend_offset;
7793 }
7794 }
ec6d2bb8 7795 }
fb88bf2d 7796
988b3759 7797 safe_codings = list2 (Qraw_text, Qno_conversion);
df7492f9
KH		 7798 for (tail = coding_attrs_list; CONSP (tail); tail = XCDR (tail))
7799 if (! NILP (XCAR (tail)))
7800 safe_codings = Fcons (CODING_ATTR_BASE_NAME (XCAR (tail)), safe_codings);
ec6d2bb8 7801
05e6f5dc
KH		 7802 return safe_codings;
7803}
4956c225 7804
d46c5b12 7805
8f924df7
KH		 7806DEFUN ("unencodable-char-position", Funencodable_char_position,
7807 Sunencodable_char_position, 3, 5, 0,
7808 doc: /*
7809Return position of first un-encodable character in a region.
7810START and END specfiy the region and CODING-SYSTEM specifies the
7811encoding to check. Return nil if CODING-SYSTEM does encode the region.
d46c5b12 7812
8f924df7
KH		 7813If optional 4th argument COUNT is non-nil, it specifies at most how
7814many un-encodable characters to search. In this case, the value is a
7815list of positions.
d46c5b12 7816
8f924df7
KH		 7817If optional 5th argument STRING is non-nil, it is a string to search
7818for un-encodable characters. In that case, START and END are indexes
7819to the string. */)
7820 (start, end, coding_system, count, string)
7821 Lisp_Object start, end, coding_system, count, string;
7822{
7823 int n;
7824 struct coding_system coding;
7d64c6ad 7825 Lisp_Object attrs, charset_list, translation_table;
8f924df7
KH		 7826 Lisp_Object positions;
7827 int from, to;
7828 const unsigned char *p, *stop, *pend;
7829 int ascii_compatible;
fb88bf2d 7830
8f924df7
KH		 7831 setup_coding_system (Fcheck_coding_system (coding_system), &coding);
7832 attrs = CODING_ID_ATTRS (coding.id);
7833 if (EQ (CODING_ATTR_TYPE (attrs), Qraw_text))
7834 return Qnil;
7835 ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
7836 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
2170c8f0 7837 translation_table = get_translation_table (attrs, 1, NULL);
fb88bf2d 7838
8f924df7
KH		 7839 if (NILP (string))
7840 {
7841 validate_region (&start, &end);
7842 from = XINT (start);
7843 to = XINT (end);
7844 if (NILP (current_buffer->enable_multibyte_characters)
7845 || (ascii_compatible
7846 && (to - from) == (CHAR_TO_BYTE (to) - (CHAR_TO_BYTE (from)))))
7847 return Qnil;
7848 p = CHAR_POS_ADDR (from);
7849 pend = CHAR_POS_ADDR (to);
7850 if (from < GPT && to >= GPT)
7851 stop = GPT_ADDR;
7852 else
7853 stop = pend;
7854 }
7855 else
7856 {
7857 CHECK_STRING (string);
7858 CHECK_NATNUM (start);
7859 CHECK_NATNUM (end);
7860 from = XINT (start);
7861 to = XINT (end);
7862 if (from > to
7863 || to > SCHARS (string))
7864 args_out_of_range_3 (string, start, end);
7865 if (! STRING_MULTIBYTE (string))
7866 return Qnil;
7867 p = SDATA (string) + string_char_to_byte (string, from);
7868 stop = pend = SDATA (string) + string_char_to_byte (string, to);
7869 if (ascii_compatible && (to - from) == (pend - p))
7870 return Qnil;
7871 }
f2558efd 7872
8f924df7
KH		 7873 if (NILP (count))
7874 n = 1;
7875 else
b73bfc1c 7876 {
8f924df7
KH		 7877 CHECK_NATNUM (count);
7878 n = XINT (count);
b73bfc1c
KH		 7879 }
7880
8f924df7
KH		 7881 positions = Qnil;
7882 while (1)
d46c5b12 7883 {
8f924df7 7884 int c;
ec6d2bb8 7885
8f924df7
KH		 7886 if (ascii_compatible)
7887 while (p < stop && ASCII_BYTE_P (*p))
7888 p++, from++;
7889 if (p >= stop)
0e79d667 7890 {
8f924df7
KH		 7891 if (p >= pend)
7892 break;
7893 stop = pend;
7894 p = GAP_END_ADDR;
0e79d667 7895 }
ec6d2bb8 7896
8f924df7
KH		 7897 c = STRING_CHAR_ADVANCE (p);
7898 if (! (ASCII_CHAR_P (c) && ascii_compatible)
7d64c6ad
KH		 7899 && ! char_charset (translate_char (translation_table, c),
7900 charset_list, NULL))
ec6d2bb8 7901 {
8f924df7
KH		 7902 positions = Fcons (make_number (from), positions);
7903 n--;
7904 if (n == 0)
7905 break;
ec6d2bb8
KH		 7906 }
7907
8f924df7
KH		 7908 from++;
7909 }
d46c5b12 7910
8f924df7
KH		 7911 return (NILP (count) ? Fcar (positions) : Fnreverse (positions));
7912}
d46c5b12 7913
d46c5b12 7914
df7492f9
KH		 7915DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region,
7916 Scheck_coding_systems_region, 3, 3, 0,
7917 doc: /* Check if the region is encodable by coding systems.
d46c5b12 7918
df7492f9
KH		 7919START and END are buffer positions specifying the region.
7920CODING-SYSTEM-LIST is a list of coding systems to check.
d46c5b12 7921
df7492f9
KH		 7922The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
7923CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
7924whole region, POS0, POS1, ... are buffer positions where non-encodable
7925characters are found.
93dec019 7926
df7492f9
KH		 7927If all coding systems in CODING-SYSTEM-LIST can encode the region, the
7928value is nil.
93dec019 7929
df7492f9
KH		 7930START may be a string. In that case, check if the string is
7931encodable, and the value contains indices to the string instead of
7932buffer positions. END is ignored. */)
7933 (start, end, coding_system_list)
7934 Lisp_Object start, end, coding_system_list;
05e6f5dc 7935{
df7492f9
KH		 7936 Lisp_Object list;
7937 EMACS_INT start_byte, end_byte;
7938 int pos;
7c78e542 7939 const unsigned char *p, *pbeg, *pend;
df7492f9 7940 int c;
7d64c6ad 7941 Lisp_Object tail, elt, attrs;
70ad9fc4 7942
05e6f5dc
KH		 7943 if (STRINGP (start))
7944 {
df7492f9 7945 if (!STRING_MULTIBYTE (start)
8f924df7 7946 && SCHARS (start) != SBYTES (start))
df7492f9
KH		 7947 return Qnil;
7948 start_byte = 0;
8f924df7 7949 end_byte = SBYTES (start);
df7492f9 7950 pos = 0;
d46c5b12 7951 }
05e6f5dc 7952 else
b73bfc1c 7953 {
b7826503
PJ		 7954 CHECK_NUMBER_COERCE_MARKER (start);
7955 CHECK_NUMBER_COERCE_MARKER (end);
05e6f5dc
KH		 7956 if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
7957 args_out_of_range (start, end);
7958 if (NILP (current_buffer->enable_multibyte_characters))
df7492f9
KH		 7959 return Qnil;
7960 start_byte = CHAR_TO_BYTE (XINT (start));
7961 end_byte = CHAR_TO_BYTE (XINT (end));
7962 if (XINT (end) - XINT (start) == end_byte - start_byte)
05e6f5dc 7963 return Qt;
df7492f9 7964
e1c23804 7965 if (XINT (start) < GPT && XINT (end) > GPT)
b73bfc1c 7966 {
e1c23804
DL		 7967 if ((GPT - XINT (start)) < (XINT (end) - GPT))
7968 move_gap_both (XINT (start), start_byte);
df7492f9 7969 else
e1c23804 7970 move_gap_both (XINT (end), end_byte);
b73bfc1c 7971 }
e1c23804 7972 pos = XINT (start);
b73bfc1c 7973 }
7553d0e1 7974
df7492f9
KH		 7975 list = Qnil;
7976 for (tail = coding_system_list; CONSP (tail); tail = XCDR (tail))
12410ef1 7977 {
df7492f9 7978 elt = XCAR (tail);
7d64c6ad 7979 attrs = AREF (CODING_SYSTEM_SPEC (elt), 0);
2170c8f0
KH		 7980 ASET (attrs, coding_attr_trans_tbl,
7981 get_translation_table (attrs, 1, NULL));
7d64c6ad 7982 list = Fcons (Fcons (elt, Fcons (attrs, Qnil)), list);
12410ef1
KH		 7983 }
7984
df7492f9 7985 if (STRINGP (start))
8f924df7 7986 p = pbeg = SDATA (start);
72d1a715 7987 else
df7492f9
KH		 7988 p = pbeg = BYTE_POS_ADDR (start_byte);
7989 pend = p + (end_byte - start_byte);
4ed46869 7990
df7492f9
KH		 7991 while (p < pend && ASCII_BYTE_P (*p)) p++, pos++;
7992 while (p < pend && ASCII_BYTE_P (*(pend - 1))) pend--;
ec6d2bb8 7993
df7492f9 7994 while (p < pend)
d46c5b12 7995 {
df7492f9
KH		 7996 if (ASCII_BYTE_P (*p))
7997 p++;
e133c8fa 7998 else
05e6f5dc 7999 {
df7492f9
KH		 8000 c = STRING_CHAR_ADVANCE (p);
8001
8002 charset_map_loaded = 0;
8003 for (tail = list; CONSP (tail); tail = XCDR (tail))
8004 {
8005 elt = XCDR (XCAR (tail));
8006 if (! char_encodable_p (c, XCAR (elt)))
8007 XSETCDR (elt, Fcons (make_number (pos), XCDR (elt)));
8008 }
8009 if (charset_map_loaded)
8010 {
8011 EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg;
8012
8013 if (STRINGP (start))
8f924df7 8014 pbeg = SDATA (start);
df7492f9
KH		 8015 else
8016 pbeg = BYTE_POS_ADDR (start_byte);
8017 p = pbeg + p_offset;
8018 pend = pbeg + pend_offset;
8019 }
05e6f5dc 8020 }
df7492f9 8021 pos++;
d46c5b12 8022 }
4ed46869 8023
df7492f9
KH		 8024 tail = list;
8025 list = Qnil;
8026 for (; CONSP (tail); tail = XCDR (tail))
ec6d2bb8 8027 {
df7492f9
KH		 8028 elt = XCAR (tail);
8029 if (CONSP (XCDR (XCDR (elt))))
8030 list = Fcons (Fcons (XCAR (elt), Fnreverse (XCDR (XCDR (elt)))),
8031 list);
ec6d2bb8 8032 }
2b4f9037 8033
df7492f9 8034 return list;
d46c5b12
KH		 8035}
8036
3fd9494b 8037
b73bfc1c 8038Lisp_Object
df7492f9
KH		 8039code_convert_region (start, end, coding_system, dst_object, encodep, norecord)
8040 Lisp_Object start, end, coding_system, dst_object;
8041 int encodep, norecord;
4ed46869 8042{
3a73fa5d 8043 struct coding_system coding;
df7492f9
KH		 8044 EMACS_INT from, from_byte, to, to_byte;
8045 Lisp_Object src_object;
4ed46869 8046
b7826503
PJ		 8047 CHECK_NUMBER_COERCE_MARKER (start);
8048 CHECK_NUMBER_COERCE_MARKER (end);
df7492f9
KH		 8049 if (NILP (coding_system))
8050 coding_system = Qno_conversion;
8051 else
8052 CHECK_CODING_SYSTEM (coding_system);
8053 src_object = Fcurrent_buffer ();
8054 if (NILP (dst_object))
8055 dst_object = src_object;
8056 else if (! EQ (dst_object, Qt))
8057 CHECK_BUFFER (dst_object);
3a73fa5d 8058
d46c5b12
KH		 8059 validate_region (&start, &end);
8060 from = XFASTINT (start);
df7492f9 8061 from_byte = CHAR_TO_BYTE (from);
d46c5b12 8062 to = XFASTINT (end);
df7492f9 8063 to_byte = CHAR_TO_BYTE (to);
764ca8da 8064
df7492f9
KH		 8065 setup_coding_system (coding_system, &coding);
8066 coding.mode |= CODING_MODE_LAST_BLOCK;
ec6d2bb8 8067
df7492f9
KH		 8068 if (encodep)
8069 encode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
8070 dst_object);
8071 else
8072 decode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
8073 dst_object);
8074 if (! norecord)
8075 Vlast_coding_system_used = CODING_ID_NAME (coding.id);
ec6d2bb8 8076
df7492f9
KH		 8077 return (BUFFERP (dst_object)
8078 ? make_number (coding.produced_char)
8079 : coding.dst_object);
4031e2bf 8080}
78108bcd 8081
4ed46869 8082
4031e2bf 8083DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
df7492f9 8084 3, 4, "r\nzCoding system: ",
48b0f3ae 8085 doc: /* Decode the current region from the specified coding system.
df7492f9
KH		 8086When called from a program, takes four arguments:
8087 START, END, CODING-SYSTEM, and DESTINATION.
8088START and END are buffer positions.
8844fa83 8089
df7492f9 8090Optional 4th arguments DESTINATION specifies where the decoded text goes.
2354b80b 8091If nil, the region between START and END is replaced by the decoded text.
df7492f9
KH		 8092If buffer, the decoded text is inserted in the buffer.
8093If t, the decoded text is returned.
8844fa83 8094
48b0f3ae
PJ		 8095This function sets `last-coding-system-used' to the precise coding system
8096used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8097not fully specified.)
8098It returns the length of the decoded text. */)
df7492f9
KH		 8099 (start, end, coding_system, destination)
8100 Lisp_Object start, end, coding_system, destination;
4031e2bf 8101{
df7492f9 8102 return code_convert_region (start, end, coding_system, destination, 0, 0);
3a73fa5d 8103}
8844fa83 8104
3a73fa5d 8105DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
df7492f9
KH		 8106 3, 4, "r\nzCoding system: ",
8107 doc: /* Encode the current region by specified coding system.
48b0f3ae
PJ		 8108When called from a program, takes three arguments:
8109START, END, and CODING-SYSTEM. START and END are buffer positions.
d46c5b12 8110
df7492f9
KH		 8111Optional 4th arguments DESTINATION specifies where the encoded text goes.
8112If nil, the region between START and END is replace by the encoded text.
8113If buffer, the encoded text is inserted in the buffer.
8114If t, the encoded text is returned.
2391eaa4 8115
48b0f3ae
PJ		 8116This function sets `last-coding-system-used' to the precise coding system
8117used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8118not fully specified.)
8119It returns the length of the encoded text. */)
df7492f9
KH		 8120 (start, end, coding_system, destination)
8121 Lisp_Object start, end, coding_system, destination;
3a73fa5d 8122{
df7492f9 8123 return code_convert_region (start, end, coding_system, destination, 1, 0);
b73bfc1c
KH		 8124}
8125
8126Lisp_Object
df7492f9
KH		 8127code_convert_string (string, coding_system, dst_object,
8128 encodep, nocopy, norecord)
8129 Lisp_Object string, coding_system, dst_object;
8130 int encodep, nocopy, norecord;
b73bfc1c 8131{
4031e2bf 8132 struct coding_system coding;
df7492f9 8133 EMACS_INT chars, bytes;
ec6d2bb8 8134
b7826503 8135 CHECK_STRING (string);
d46c5b12 8136 if (NILP (coding_system))
4956c225 8137 {
df7492f9
KH		 8138 if (! norecord)
8139 Vlast_coding_system_used = Qno_conversion;
8140 if (NILP (dst_object))
8141 return (nocopy ? Fcopy_sequence (string) : string);
4956c225 8142 }
b73bfc1c 8143
df7492f9
KH		 8144 if (NILP (coding_system))
8145 coding_system = Qno_conversion;
8146 else
8147 CHECK_CODING_SYSTEM (coding_system);
8148 if (NILP (dst_object))
8149 dst_object = Qt;
8150 else if (! EQ (dst_object, Qt))
8151 CHECK_BUFFER (dst_object);
73be902c 8152
df7492f9 8153 setup_coding_system (coding_system, &coding);
d46c5b12 8154 coding.mode |= CODING_MODE_LAST_BLOCK;
8f924df7
KH		 8155 chars = SCHARS (string);
8156 bytes = SBYTES (string);
df7492f9
KH		 8157 if (encodep)
8158 encode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
8159 else
8160 decode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
8161 if (! norecord)
8162 Vlast_coding_system_used = CODING_ID_NAME (coding.id);
73be902c 8163
df7492f9
KH		 8164 return (BUFFERP (dst_object)
8165 ? make_number (coding.produced_char)
8166 : coding.dst_object);
4ed46869 8167}
73be902c 8168
b73bfc1c 8169
ecec61c1 8170/* Encode or decode STRING according to CODING_SYSTEM.
ec6d2bb8 8171 Do not set Vlast_coding_system_used.
4ed46869 8172
ec6d2bb8
KH		 8173 This function is called only from macros DECODE_FILE and
8174 ENCODE_FILE, thus we ignore character composition. */
4ed46869 8175
ecec61c1
KH		 8176Lisp_Object
8177code_convert_string_norecord (string, coding_system, encodep)
8178 Lisp_Object string, coding_system;
8179 int encodep;
4ed46869 8180{
0be8721c 8181 return code_convert_string (string, coding_system, Qt, encodep, 0, 1);
4ed46869
KH		 8182}
8183
4ed46869 8184
df7492f9
KH		 8185DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
8186 2, 4, 0,
8187 doc: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8188
8189Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8190if the decoding operation is trivial.
ecec61c1 8191
df7492f9 8192Optional fourth arg BUFFER non-nil meant that the decoded text is
a3f6ee6d 8193inserted in BUFFER instead of returned as a string. In this case,
df7492f9 8194the return value is BUFFER.
ecec61c1 8195
df7492f9
KH		 8196This function sets `last-coding-system-used' to the precise coding system
8197used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8198not fully specified. */)
8199 (string, coding_system, nocopy, buffer)
8200 Lisp_Object string, coding_system, nocopy, buffer;
4ed46869 8201{
df7492f9
KH		 8202 return code_convert_string (string, coding_system, buffer,
8203 0, ! NILP (nocopy), 0);
4ed46869
KH		 8204}
8205
df7492f9
KH		 8206DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
8207 2, 4, 0,
8208 doc: /* Encode STRING to CODING-SYSTEM, and return the result.
8209
8210Optional third arg NOCOPY non-nil means it is OK to return STRING
8211itself if the encoding operation is trivial.
8212
8213Optional fourth arg BUFFER non-nil meant that the encoded text is
a3f6ee6d 8214inserted in BUFFER instead of returned as a string. In this case,
df7492f9
KH		 8215the return value is BUFFER.
8216
8217This function sets `last-coding-system-used' to the precise coding system
8218used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8219not fully specified.) */)
8220 (string, coding_system, nocopy, buffer)
8221 Lisp_Object string, coding_system, nocopy, buffer;
4ed46869 8222{
df7492f9 8223 return code_convert_string (string, coding_system, buffer,
c197f191 8224 1, ! NILP (nocopy), 1);
4ed46869 8225}
df7492f9 8226
3a73fa5d 8227\f
4ed46869 8228DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
48b0f3ae
PJ		 8229 doc: /* Decode a Japanese character which has CODE in shift_jis encoding.
8230Return the corresponding character. */)
8231 (code)
4ed46869 8232 Lisp_Object code;
4ed46869 8233{
df7492f9
KH		 8234 Lisp_Object spec, attrs, val;
8235 struct charset *charset_roman, *charset_kanji, *charset_kana, *charset;
8236 int c;
4ed46869 8237
df7492f9
KH		 8238 CHECK_NATNUM (code);
8239 c = XFASTINT (code);
8240 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
8241 attrs = AREF (spec, 0);
4ed46869 8242
df7492f9
KH		 8243 if (ASCII_BYTE_P (c)
8244 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8245 return code;
4ed46869 8246
df7492f9
KH		 8247 val = CODING_ATTR_CHARSET_LIST (attrs);
8248 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
004068e4
KH		 8249 charset_kana = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
8250 charset_kanji = CHARSET_FROM_ID (XINT (XCAR (val)));
fa42c37f 8251
df7492f9
KH		 8252 if (c <= 0x7F)
8253 charset = charset_roman;
8254 else if (c >= 0xA0 && c < 0xDF)
55ab7be3 8255 {
df7492f9
KH		 8256 charset = charset_kana;
8257 c -= 0x80;
4ed46869 8258 }
55ab7be3 8259 else
4ed46869 8260 {
004068e4 8261 int s1 = c >> 8, s2 = c & 0xFF;
df7492f9
KH		 8262
8263 if (s1 < 0x81 || (s1 > 0x9F && s1 < 0xE0) || s1 > 0xEF
8264 || s2 < 0x40 || s2 == 0x7F || s2 > 0xFC)
8265 error ("Invalid code: %d", code);
8266 SJIS_TO_JIS (c);
8267 charset = charset_kanji;
4ed46869 8268 }
df7492f9
KH		 8269 c = DECODE_CHAR (charset, c);
8270 if (c < 0)
8271 error ("Invalid code: %d", code);
8272 return make_number (c);
93dec019 8273}
4ed46869 8274
48b0f3ae 8275
4ed46869 8276DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
8acf0c0e 8277 doc: /* Encode a Japanese character CH to shift_jis encoding.
48b0f3ae
PJ		 8278Return the corresponding code in SJIS. */)
8279 (ch)
df7492f9 8280 Lisp_Object ch;
4ed46869 8281{
df7492f9
KH		 8282 Lisp_Object spec, attrs, charset_list;
8283 int c;
8284 struct charset *charset;
8285 unsigned code;
48b0f3ae 8286
df7492f9
KH		 8287 CHECK_CHARACTER (ch);
8288 c = XFASTINT (ch);
8289 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system, spec);
8290 attrs = AREF (spec, 0);
8291
8292 if (ASCII_CHAR_P (c)
8293 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8294 return ch;
8295
8296 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
8297 charset = char_charset (c, charset_list, &code);
8298 if (code == CHARSET_INVALID_CODE (charset))
8299 error ("Can't encode by shift_jis encoding: %d", c);
8300 JIS_TO_SJIS (code);
8301
8302 return make_number (code);
4ed46869
KH		 8303}
8304
8305DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
48b0f3ae
PJ		 8306 doc: /* Decode a Big5 character which has CODE in BIG5 coding system.
8307Return the corresponding character. */)
8308 (code)
4ed46869 8309 Lisp_Object code;
d46c5b12 8310{
df7492f9
KH		 8311 Lisp_Object spec, attrs, val;
8312 struct charset *charset_roman, *charset_big5, *charset;
8313 int c;
6289dd10 8314
df7492f9
KH		 8315 CHECK_NATNUM (code);
8316 c = XFASTINT (code);
8317 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
8318 attrs = AREF (spec, 0);
4ed46869 8319
df7492f9
KH		 8320 if (ASCII_BYTE_P (c)
8321 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8322 return code;
6289dd10 8323
df7492f9
KH		 8324 val = CODING_ATTR_CHARSET_LIST (attrs);
8325 charset_roman = CHARSET_FROM_ID (XINT (XCAR (val))), val = XCDR (val);
8326 charset_big5 = CHARSET_FROM_ID (XINT (XCAR (val)));
c210f766 8327
df7492f9
KH		 8328 if (c <= 0x7F)
8329 charset = charset_roman;
c28a9453
KH		 8330 else
8331 {
df7492f9
KH		 8332 int b1 = c >> 8, b2 = c & 0x7F;
8333 if (b1 < 0xA1 || b1 > 0xFE
8334 || b2 < 0x40 || (b2 > 0x7E && b2 < 0xA1) || b2 > 0xFE)
8335 error ("Invalid code: %d", code);
8336 charset = charset_big5;
c28a9453 8337 }
df7492f9
KH		 8338 c = DECODE_CHAR (charset, (unsigned )c);
8339 if (c < 0)
8340 error ("Invalid code: %d", code);
8341 return make_number (c);
d46c5b12 8342}
6289dd10 8343
4ed46869 8344DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
8acf0c0e 8345 doc: /* Encode the Big5 character CH to BIG5 coding system.
48b0f3ae
PJ		 8346Return the corresponding character code in Big5. */)
8347 (ch)
4ed46869
KH		 8348 Lisp_Object ch;
8349{
df7492f9
KH		 8350 Lisp_Object spec, attrs, charset_list;
8351 struct charset *charset;
8352 int c;
8353 unsigned code;
8354
8355 CHECK_CHARACTER (ch);
8356 c = XFASTINT (ch);
8357 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system, spec);
8358 attrs = AREF (spec, 0);
8359 if (ASCII_CHAR_P (c)
8360 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs)))
8361 return ch;
8362
8363 charset_list = CODING_ATTR_CHARSET_LIST (attrs);
8364 charset = char_charset (c, charset_list, &code);
8365 if (code == CHARSET_INVALID_CODE (charset))
8366 error ("Can't encode by Big5 encoding: %d", c);
8367
8368 return make_number (code);
4ed46869 8369}
48b0f3ae 8370
3a73fa5d 8371\f
002fdb44 8372DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal,
68bba4e4 8373 Sset_terminal_coding_system_internal, 1, 2, 0,
48b0f3ae 8374 doc: /* Internal use only. */)
6ed8eeff 8375 (coding_system, terminal)
b74e4686 8376 Lisp_Object coding_system;
6ed8eeff 8377 Lisp_Object terminal;
4ed46869 8378{
6ed8eeff 8379 struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
b7826503 8380 CHECK_SYMBOL (coding_system);
b8299c66 8381 setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
70c22245 8382 /* We had better not send unsafe characters to terminal. */
c73bd236 8383 terminal_coding->mode |= CODING_MODE_SAFE_ENCODING;
df7492f9 8384 /* Characer composition should be disabled. */
c73bd236 8385 terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
b8299c66
KL		 8386 terminal_coding->src_multibyte = 1;
8387 terminal_coding->dst_multibyte = 0;
4ed46869
KH		 8388 return Qnil;
8389}
8390
c4825358
KH		 8391DEFUN ("set-safe-terminal-coding-system-internal",
8392 Fset_safe_terminal_coding_system_internal,
48b0f3ae 8393 Sset_safe_terminal_coding_system_internal, 1, 1, 0,
ddb67bdc 8394 doc: /* Internal use only. */)
48b0f3ae 8395 (coding_system)
b74e4686 8396 Lisp_Object coding_system;
d46c5b12 8397{
b7826503 8398 CHECK_SYMBOL (coding_system);
c4825358
KH		 8399 setup_coding_system (Fcheck_coding_system (coding_system),
8400 &safe_terminal_coding);
df7492f9
KH		 8401 /* Characer composition should be disabled. */
8402 safe_terminal_coding.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
b73bfc1c
KH		 8403 safe_terminal_coding.src_multibyte = 1;
8404 safe_terminal_coding.dst_multibyte = 0;
c4825358
KH		 8405 return Qnil;
8406}
4ed46869 8407
002fdb44 8408DEFUN ("terminal-coding-system", Fterminal_coding_system,
68bba4e4 8409 Sterminal_coding_system, 0, 1, 0,
6ed8eeff
KL		 8410 doc: /* Return coding system specified for terminal output on the given terminal.
8411TERMINAL may be a terminal id, a frame, or nil for the selected
8412frame's terminal device. */)
8413 (terminal)
8414 Lisp_Object terminal;
4ed46869 8415{
985773c9
MB		 8416 struct coding_system *terminal_coding
8417 = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
8418 Lisp_Object coding_system = CODING_ID_NAME (terminal_coding->id);
ae6f73fa 8419
ae6f73fa 8420 /* For backward compatibility, return nil if it is `undecided'. */
f75c90a9 8421 return (! EQ (coding_system, Qundecided) ? coding_system : Qnil);
4ed46869
KH		 8422}
8423
002fdb44 8424DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
68bba4e4 8425 Sset_keyboard_coding_system_internal, 1, 2, 0,
48b0f3ae 8426 doc: /* Internal use only. */)
6ed8eeff 8427 (coding_system, terminal)
4ed46869 8428 Lisp_Object coding_system;
6ed8eeff 8429 Lisp_Object terminal;
4ed46869 8430{
6ed8eeff 8431 struct terminal *t = get_terminal (terminal, 1);
b7826503 8432 CHECK_SYMBOL (coding_system);
df7492f9 8433 setup_coding_system (Fcheck_coding_system (coding_system),
c73bd236 8434 TERMINAL_KEYBOARD_CODING (t));
df7492f9 8435 /* Characer composition should be disabled. */
c73bd236
MB		 8436 TERMINAL_KEYBOARD_CODING (t)->common_flags
8437 &= ~CODING_ANNOTATE_COMPOSITION_MASK;
4ed46869
KH		 8438 return Qnil;
8439}
8440
8441DEFUN ("keyboard-coding-system",
985773c9 8442 Fkeyboard_coding_system, Skeyboard_coding_system, 0, 1, 0,
48b0f3ae 8443 doc: /* Return coding system specified for decoding keyboard input. */)
985773c9
MB		 8444 (terminal)
8445 Lisp_Object terminal;
4ed46869 8446{
985773c9
MB		 8447 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
8448 (get_terminal (terminal, 1))->id);
4ed46869
KH		 8449}
8450
4ed46869 8451\f
a5d301df
KH		 8452DEFUN ("find-operation-coding-system", Ffind_operation_coding_system,
8453 Sfind_operation_coding_system, 1, MANY, 0,
48b0f3ae
PJ		 8454 doc: /* Choose a coding system for an operation based on the target name.
8455The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8456DECODING-SYSTEM is the coding system to use for decoding
8457\(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8458for encoding (in case OPERATION does encoding).
05e6f5dc 8459
48b0f3ae
PJ		 8460The first argument OPERATION specifies an I/O primitive:
8461 For file I/O, `insert-file-contents' or `write-region'.
8462 For process I/O, `call-process', `call-process-region', or `start-process'.
8463 For network I/O, `open-network-stream'.
05e6f5dc 8464
48b0f3ae
PJ		 8465The remaining arguments should be the same arguments that were passed
8466to the primitive. Depending on which primitive, one of those arguments
8467is selected as the TARGET. For example, if OPERATION does file I/O,
8468whichever argument specifies the file name is TARGET.
05e6f5dc 8469
48b0f3ae 8470TARGET has a meaning which depends on OPERATION:
b883cdb2 8471 For file I/O, TARGET is a file name (except for the special case below).
48b0f3ae
PJ		 8472 For process I/O, TARGET is a process name.
8473 For network I/O, TARGET is a service name or a port number
05e6f5dc 8474
48b0f3ae
PJ		 8475This function looks up what specified for TARGET in,
8476`file-coding-system-alist', `process-coding-system-alist',
8477or `network-coding-system-alist' depending on OPERATION.
8478They may specify a coding system, a cons of coding systems,
8479or a function symbol to call.
8480In the last case, we call the function with one argument,
8481which is a list of all the arguments given to this function.
1011c487
MB		 8482If the function can't decide a coding system, it can return
8483`undecided' so that the normal code-detection is performed.
48b0f3ae 8484
b883cdb2
MB		 8485If OPERATION is `insert-file-contents', the argument corresponding to
8486TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
8487file name to look up, and BUFFER is a buffer that contains the file's
8488contents (not yet decoded). If `file-coding-system-alist' specifies a
8489function to call for FILENAME, that function should examine the
8490contents of BUFFER instead of reading the file.
8491
d918f936 8492usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
48b0f3ae 8493 (nargs, args)
4ed46869
KH		 8494 int nargs;
8495 Lisp_Object *args;
6b89e3aa 8496{
4ed46869
KH		 8497 Lisp_Object operation, target_idx, target, val;
8498 register Lisp_Object chain;
177c0ea7 8499
4ed46869
KH		 8500 if (nargs < 2)
8501 error ("Too few arguments");
8502 operation = args[0];
8503 if (!SYMBOLP (operation)
8504 || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
df7492f9 8505 error ("Invalid first arguement");
4ed46869
KH		 8506 if (nargs < 1 + XINT (target_idx))
8507 error ("Too few arguments for operation: %s",
8f924df7 8508 SDATA (SYMBOL_NAME (operation)));
4ed46869
KH		 8509 target = args[XINT (target_idx) + 1];
8510 if (!(STRINGP (target)
091a0ff0
KH		 8511 || (EQ (operation, Qinsert_file_contents) && CONSP (target)
8512 && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
4ed46869 8513 || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
df7492f9 8514 error ("Invalid %dth argument", XINT (target_idx) + 1);
091a0ff0
KH		 8515 if (CONSP (target))
8516 target = XCAR (target);
4ed46869 8517
2e34157c
RS		 8518 chain = ((EQ (operation, Qinsert_file_contents)
8519 || EQ (operation, Qwrite_region))
02ba4723 8520 ? Vfile_coding_system_alist
2e34157c 8521 : (EQ (operation, Qopen_network_stream)
02ba4723
KH		 8522 ? Vnetwork_coding_system_alist
8523 : Vprocess_coding_system_alist));
4ed46869
KH		 8524 if (NILP (chain))
8525 return Qnil;
8526
03699b14 8527 for (; CONSP (chain); chain = XCDR (chain))
6b89e3aa 8528 {
f44d27ce 8529 Lisp_Object elt;
6b89e3aa 8530
df7492f9 8531 elt = XCAR (chain);
4ed46869
KH		 8532 if (CONSP (elt)
8533 && ((STRINGP (target)
03699b14
KR		 8534 && STRINGP (XCAR (elt))
8535 && fast_string_match (XCAR (elt), target) >= 0)
8536 || (INTEGERP (target) && EQ (target, XCAR (elt)))))
6b89e3aa 8537 {
03699b14 8538 val = XCDR (elt);
b19fd4c5
KH		 8539 /* Here, if VAL is both a valid coding system and a valid
8540 function symbol, we return VAL as a coding system. */
02ba4723
KH		 8541 if (CONSP (val))
8542 return val;
8543 if (! SYMBOLP (val))
8544 return Qnil;
8545 if (! NILP (Fcoding_system_p (val)))
8546 return Fcons (val, val);
b19fd4c5 8547 if (! NILP (Ffboundp (val)))
6b89e3aa 8548 {
e2b97060
MB		 8549 /* We use call1 rather than safe_call1
8550 so as to get bug reports about functions called here
8551 which don't handle the current interface. */
8552 val = call1 (val, Flist (nargs, args));
b19fd4c5
KH		 8553 if (CONSP (val))
8554 return val;
8555 if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
8556 return Fcons (val, val);
6b89e3aa 8557 }
02ba4723 8558 return Qnil;
6b89e3aa
KH		 8559 }
8560 }
4ed46869 8561 return Qnil;
6b89e3aa
KH		 8562}
8563
df7492f9 8564DEFUN ("set-coding-system-priority", Fset_coding_system_priority,
a3f6ee6d 8565 Sset_coding_system_priority, 0, MANY, 0,
da7db224 8566 doc: /* Assign higher priority to the coding systems given as arguments.
ff563fce 8567If multiple coding systems belongs to the same category,
a3181084
DL		 8568all but the first one are ignored.
8569
8570usage: (set-coding-system-priority ...) */)
df7492f9
KH		 8571 (nargs, args)
8572 int nargs;
8573 Lisp_Object *args;
8574{
8575 int i, j;
8576 int changed[coding_category_max];
8577 enum coding_category priorities[coding_category_max];
8578
8579 bzero (changed, sizeof changed);
6b89e3aa 8580
df7492f9 8581 for (i = j = 0; i < nargs; i++)
6b89e3aa 8582 {
df7492f9
KH		 8583 enum coding_category category;
8584 Lisp_Object spec, attrs;
6b89e3aa 8585
df7492f9
KH		 8586 CHECK_CODING_SYSTEM_GET_SPEC (args[i], spec);
8587 attrs = AREF (spec, 0);
8588 category = XINT (CODING_ATTR_CATEGORY (attrs));
8589 if (changed[category])
8590 /* Ignore this coding system because a coding system of the
8591 same category already had a higher priority. */
8592 continue;
8593 changed[category] = 1;
8594 priorities[j++] = category;
8595 if (coding_categories[category].id >= 0
8596 && ! EQ (args[i], CODING_ID_NAME (coding_categories[category].id)))
8597 setup_coding_system (args[i], &coding_categories[category]);
ff563fce 8598 Fset (AREF (Vcoding_category_table, category), args[i]);
df7492f9 8599 }
6b89e3aa 8600
df7492f9
KH		 8601 /* Now we have decided top J priorities. Reflect the order of the
8602 original priorities to the remaining priorities. */
6b89e3aa 8603
df7492f9 8604 for (i = j, j = 0; i < coding_category_max; i++, j++)
6b89e3aa 8605 {
df7492f9
KH		 8606 while (j < coding_category_max
8607 && changed[coding_priorities[j]])
8608 j++;
8609 if (j == coding_category_max)
8610 abort ();
8611 priorities[i] = coding_priorities[j];
8612 }
6b89e3aa 8613
df7492f9 8614 bcopy (priorities, coding_priorities, sizeof priorities);
177c0ea7 8615
ff563fce
KH		 8616 /* Update `coding-category-list'. */
8617 Vcoding_category_list = Qnil;
8618 for (i = coding_category_max - 1; i >= 0; i--)
8619 Vcoding_category_list
8620 = Fcons (AREF (Vcoding_category_table, priorities[i]),
8621 Vcoding_category_list);
6b89e3aa 8622
df7492f9 8623 return Qnil;
6b89e3aa
KH		 8624}
8625
df7492f9
KH		 8626DEFUN ("coding-system-priority-list", Fcoding_system_priority_list,
8627 Scoding_system_priority_list, 0, 1, 0,
da7db224
DL		 8628 doc: /* Return a list of coding systems ordered by their priorities.
8629HIGHESTP non-nil means just return the highest priority one. */)
df7492f9
KH		 8630 (highestp)
8631 Lisp_Object highestp;
d46c5b12
KH		 8632{
8633 int i;
df7492f9 8634 Lisp_Object val;
6b89e3aa 8635
df7492f9 8636 for (i = 0, val = Qnil; i < coding_category_max; i++)
d46c5b12 8637 {
df7492f9
KH		 8638 enum coding_category category = coding_priorities[i];
8639 int id = coding_categories[category].id;
8640 Lisp_Object attrs;
068a9dbd 8641
df7492f9
KH		 8642 if (id < 0)
8643 continue;
8644 attrs = CODING_ID_ATTRS (id);
8645 if (! NILP (highestp))
8646 return CODING_ATTR_BASE_NAME (attrs);
8647 val = Fcons (CODING_ATTR_BASE_NAME (attrs), val);
8648 }
8649 return Fnreverse (val);
8650}
068a9dbd 8651
f0064e1f 8652static char *suffixes[] = { "-unix", "-dos", "-mac" };
068a9dbd
KH		 8653
8654static Lisp_Object
df7492f9
KH		 8655make_subsidiaries (base)
8656 Lisp_Object base;
068a9dbd 8657{
df7492f9 8658 Lisp_Object subsidiaries;
8f924df7 8659 int base_name_len = SBYTES (SYMBOL_NAME (base));
df7492f9
KH		 8660 char *buf = (char *) alloca (base_name_len + 6);
8661 int i;
068a9dbd 8662
8f924df7 8663 bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
df7492f9
KH		 8664 subsidiaries = Fmake_vector (make_number (3), Qnil);
8665 for (i = 0; i < 3; i++)
068a9dbd 8666 {
df7492f9
KH		 8667 bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
8668 ASET (subsidiaries, i, intern (buf));
068a9dbd 8669 }
df7492f9 8670 return subsidiaries;
068a9dbd
KH		 8671}
8672
8673
df7492f9
KH		 8674DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal,
8675 Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
1fcd6c8b
DL		 8676 doc: /* For internal use only.
8677usage: (define-coding-system-internal ...) */)
df7492f9
KH		 8678 (nargs, args)
8679 int nargs;
8680 Lisp_Object *args;
068a9dbd 8681{
df7492f9
KH		 8682 Lisp_Object name;
8683 Lisp_Object spec_vec; /* [ ATTRS ALIASE EOL_TYPE ] */
8684 Lisp_Object attrs; /* Vector of attributes. */
8685 Lisp_Object eol_type;
8686 Lisp_Object aliases;
8687 Lisp_Object coding_type, charset_list, safe_charsets;
8688 enum coding_category category;
8689 Lisp_Object tail, val;
8690 int max_charset_id = 0;
8691 int i;
068a9dbd 8692
df7492f9
KH		 8693 if (nargs < coding_arg_max)
8694 goto short_args;
068a9dbd 8695
df7492f9 8696 attrs = Fmake_vector (make_number (coding_attr_last_index), Qnil);
068a9dbd 8697
df7492f9
KH		 8698 name = args[coding_arg_name];
8699 CHECK_SYMBOL (name);
8700 CODING_ATTR_BASE_NAME (attrs) = name;
068a9dbd 8701
df7492f9
KH		 8702 val = args[coding_arg_mnemonic];
8703 if (! STRINGP (val))
8704 CHECK_CHARACTER (val);
8705 CODING_ATTR_MNEMONIC (attrs) = val;
068a9dbd 8706
df7492f9
KH		 8707 coding_type = args[coding_arg_coding_type];
8708 CHECK_SYMBOL (coding_type);
8709 CODING_ATTR_TYPE (attrs) = coding_type;
068a9dbd 8710
df7492f9
KH		 8711 charset_list = args[coding_arg_charset_list];
8712 if (SYMBOLP (charset_list))
8713 {
8714 if (EQ (charset_list, Qiso_2022))
8715 {
8716 if (! EQ (coding_type, Qiso_2022))
8717 error ("Invalid charset-list");
8718 charset_list = Viso_2022_charset_list;
8719 }
8720 else if (EQ (charset_list, Qemacs_mule))
8721 {
8722 if (! EQ (coding_type, Qemacs_mule))
8723 error ("Invalid charset-list");
8724 charset_list = Vemacs_mule_charset_list;
8725 }
8726 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
8727 if (max_charset_id < XFASTINT (XCAR (tail)))
8728 max_charset_id = XFASTINT (XCAR (tail));
8729 }
068a9dbd
KH		 8730 else
8731 {
df7492f9 8732 charset_list = Fcopy_sequence (charset_list);
985773c9 8733 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
068a9dbd 8734 {
df7492f9
KH		 8735 struct charset *charset;
8736
985773c9 8737 val = XCAR (tail);
df7492f9
KH		 8738 CHECK_CHARSET_GET_CHARSET (val, charset);
8739 if (EQ (coding_type, Qiso_2022)
8740 ? CHARSET_ISO_FINAL (charset) < 0
8741 : EQ (coding_type, Qemacs_mule)
8742 ? CHARSET_EMACS_MULE_ID (charset) < 0
8743 : 0)
8744 error ("Can't handle charset `%s'",
8f924df7 8745 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
df7492f9 8746
8f924df7 8747 XSETCAR (tail, make_number (charset->id));
df7492f9
KH		 8748 if (max_charset_id < charset->id)
8749 max_charset_id = charset->id;
068a9dbd
KH		 8750 }
8751 }
df7492f9 8752 CODING_ATTR_CHARSET_LIST (attrs) = charset_list;
068a9dbd 8753
df7492f9
KH		 8754 safe_charsets = Fmake_string (make_number (max_charset_id + 1),
8755 make_number (255));
8756 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
8f924df7 8757 SSET (safe_charsets, XFASTINT (XCAR (tail)), 0);
df7492f9 8758 CODING_ATTR_SAFE_CHARSETS (attrs) = safe_charsets;
068a9dbd 8759
584948ac 8760 CODING_ATTR_ASCII_COMPAT (attrs) = args[coding_arg_ascii_compatible_p];
3a73fa5d 8761
df7492f9 8762 val = args[coding_arg_decode_translation_table];
a6f87d34 8763 if (! CHAR_TABLE_P (val) && ! CONSP (val))
7d64c6ad 8764 CHECK_SYMBOL (val);
df7492f9 8765 CODING_ATTR_DECODE_TBL (attrs) = val;
3a73fa5d 8766
df7492f9 8767 val = args[coding_arg_encode_translation_table];
a6f87d34 8768 if (! CHAR_TABLE_P (val) && ! CONSP (val))
7d64c6ad 8769 CHECK_SYMBOL (val);
df7492f9 8770 CODING_ATTR_ENCODE_TBL (attrs) = val;
d46c5b12 8771
df7492f9
KH		 8772 val = args[coding_arg_post_read_conversion];
8773 CHECK_SYMBOL (val);
8774 CODING_ATTR_POST_READ (attrs) = val;
d46c5b12 8775
df7492f9
KH		 8776 val = args[coding_arg_pre_write_conversion];
8777 CHECK_SYMBOL (val);
8778 CODING_ATTR_PRE_WRITE (attrs) = val;
3a73fa5d 8779
df7492f9
KH		 8780 val = args[coding_arg_default_char];
8781 if (NILP (val))
8782 CODING_ATTR_DEFAULT_CHAR (attrs) = make_number (' ');
8783 else
8784 {
8f924df7 8785 CHECK_CHARACTER (val);
df7492f9
KH		 8786 CODING_ATTR_DEFAULT_CHAR (attrs) = val;
8787 }
4031e2bf 8788
8f924df7
KH		 8789 val = args[coding_arg_for_unibyte];
8790 CODING_ATTR_FOR_UNIBYTE (attrs) = NILP (val) ? Qnil : Qt;
3a73fa5d 8791
df7492f9
KH		 8792 val = args[coding_arg_plist];
8793 CHECK_LIST (val);
8794 CODING_ATTR_PLIST (attrs) = val;
3a73fa5d 8795
df7492f9
KH		 8796 if (EQ (coding_type, Qcharset))
8797 {
c7c66a95
KH		 8798 /* Generate a lisp vector of 256 elements. Each element is nil,
8799 integer, or a list of charset IDs.
3a73fa5d 8800
c7c66a95
KH		 8801 If Nth element is nil, the byte code N is invalid in this
8802 coding system.
4ed46869 8803
c7c66a95
KH		 8804 If Nth element is a number NUM, N is the first byte of a
8805 charset whose ID is NUM.
4ed46869 8806
c7c66a95
KH		 8807 If Nth element is a list of charset IDs, N is the first byte
8808 of one of them. The list is sorted by dimensions of the
2bc515e4 8809 charsets. A charset of smaller dimension comes firtst. */
df7492f9 8810 val = Fmake_vector (make_number (256), Qnil);
4ed46869 8811
5c99c2e6 8812 for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
df7492f9 8813 {
c7c66a95
KH		 8814 struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));
8815 int dim = CHARSET_DIMENSION (charset);
8816 int idx = (dim - 1) * 4;
4ed46869 8817
5c99c2e6 8818 if (CHARSET_ASCII_COMPATIBLE_P (charset))
584948ac 8819 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
4031e2bf 8820
15d143f7
KH		 8821 for (i = charset->code_space[idx];
8822 i <= charset->code_space[idx + 1]; i++)
8823 {
c7c66a95
KH		 8824 Lisp_Object tmp, tmp2;
8825 int dim2;
ec6d2bb8 8826
c7c66a95
KH		 8827 tmp = AREF (val, i);
8828 if (NILP (tmp))
8829 tmp = XCAR (tail);
8830 else if (NUMBERP (tmp))
8831 {
8832 dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp)));
8833 if (dim < dim2)
c7c66a95 8834 tmp = Fcons (XCAR (tail), Fcons (tmp, Qnil));
f9d71dcd
KH		 8835 else
8836 tmp = Fcons (tmp, Fcons (XCAR (tail), Qnil));
c7c66a95 8837 }
15d143f7 8838 else
c7c66a95
KH		 8839 {
8840 for (tmp2 = tmp; CONSP (tmp2); tmp2 = XCDR (tmp2))
8841 {
8842 dim2 = CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2))));
8843 if (dim < dim2)
8844 break;
8845 }
8846 if (NILP (tmp2))
8847 tmp = nconc2 (tmp, Fcons (XCAR (tail), Qnil));
8848 else
8849 {
8850 XSETCDR (tmp2, Fcons (XCAR (tmp2), XCDR (tmp2)));
8851 XSETCAR (tmp2, XCAR (tail));
8852 }
8853 }
8854 ASET (val, i, tmp);
15d143f7 8855 }
df7492f9
KH		 8856 }
8857 ASET (attrs, coding_attr_charset_valids, val);
8858 category = coding_category_charset;
8859 }
8860 else if (EQ (coding_type, Qccl))
8861 {
8862 Lisp_Object valids;
ecec61c1 8863
df7492f9
KH		 8864 if (nargs < coding_arg_ccl_max)
8865 goto short_args;
ecec61c1 8866
df7492f9
KH		 8867 val = args[coding_arg_ccl_decoder];
8868 CHECK_CCL_PROGRAM (val);
8869 if (VECTORP (val))
8870 val = Fcopy_sequence (val);
8871 ASET (attrs, coding_attr_ccl_decoder, val);
ecec61c1 8872
df7492f9
KH		 8873 val = args[coding_arg_ccl_encoder];
8874 CHECK_CCL_PROGRAM (val);
8875 if (VECTORP (val))
8876 val = Fcopy_sequence (val);
8877 ASET (attrs, coding_attr_ccl_encoder, val);
ecec61c1 8878
df7492f9
KH		 8879 val = args[coding_arg_ccl_valids];
8880 valids = Fmake_string (make_number (256), make_number (0));
8881 for (tail = val; !NILP (tail); tail = Fcdr (tail))
8882 {
8dcbea82 8883 int from, to;
ecec61c1 8884
df7492f9
KH		 8885 val = Fcar (tail);
8886 if (INTEGERP (val))
8dcbea82
KH		 8887 {
8888 from = to = XINT (val);
8889 if (from < 0 || from > 255)
8890 args_out_of_range_3 (val, make_number (0), make_number (255));
8891 }
df7492f9
KH		 8892 else
8893 {
df7492f9 8894 CHECK_CONS (val);
8f924df7
KH		 8895 CHECK_NATNUM_CAR (val);
8896 CHECK_NATNUM_CDR (val);
df7492f9 8897 from = XINT (XCAR (val));
8f924df7 8898 if (from > 255)
8dcbea82
KH		 8899 args_out_of_range_3 (XCAR (val),
8900 make_number (0), make_number (255));
df7492f9 8901 to = XINT (XCDR (val));
8dcbea82
KH		 8902 if (to < from || to > 255)
8903 args_out_of_range_3 (XCDR (val),
8904 XCAR (val), make_number (255));
df7492f9 8905 }
8dcbea82 8906 for (i = from; i <= to; i++)
8f924df7 8907 SSET (valids, i, 1);
df7492f9
KH		 8908 }
8909 ASET (attrs, coding_attr_ccl_valids, valids);
4ed46869 8910
df7492f9 8911 category = coding_category_ccl;
55ab7be3 8912 }
df7492f9 8913 else if (EQ (coding_type, Qutf_16))
55ab7be3 8914 {
df7492f9 8915 Lisp_Object bom, endian;
4ed46869 8916
584948ac 8917 CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
4ed46869 8918
df7492f9
KH		 8919 if (nargs < coding_arg_utf16_max)
8920 goto short_args;
4ed46869 8921
df7492f9
KH		 8922 bom = args[coding_arg_utf16_bom];
8923 if (! NILP (bom) && ! EQ (bom, Qt))
8924 {
8925 CHECK_CONS (bom);
8f924df7
KH		 8926 val = XCAR (bom);
8927 CHECK_CODING_SYSTEM (val);
8928 val = XCDR (bom);
8929 CHECK_CODING_SYSTEM (val);
df7492f9
KH		 8930 }
8931 ASET (attrs, coding_attr_utf_16_bom, bom);
8932
8933 endian = args[coding_arg_utf16_endian];
b49a1807
KH		 8934 CHECK_SYMBOL (endian);
8935 if (NILP (endian))
8936 endian = Qbig;
8937 else if (! EQ (endian, Qbig) && ! EQ (endian, Qlittle))
8f924df7 8938 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian)));
df7492f9
KH		 8939 ASET (attrs, coding_attr_utf_16_endian, endian);
8940
8941 category = (CONSP (bom)
8942 ? coding_category_utf_16_auto
8943 : NILP (bom)
b49a1807 8944 ? (EQ (endian, Qbig)
df7492f9
KH		 8945 ? coding_category_utf_16_be_nosig
8946 : coding_category_utf_16_le_nosig)
b49a1807 8947 : (EQ (endian, Qbig)
df7492f9
KH		 8948 ? coding_category_utf_16_be
8949 : coding_category_utf_16_le));
8950 }
8951 else if (EQ (coding_type, Qiso_2022))
8952 {
8953 Lisp_Object initial, reg_usage, request, flags;
4776e638 8954 int i;
1397dc18 8955
df7492f9
KH		 8956 if (nargs < coding_arg_iso2022_max)
8957 goto short_args;
8958
8959 initial = Fcopy_sequence (args[coding_arg_iso2022_initial]);
8960 CHECK_VECTOR (initial);
8961 for (i = 0; i < 4; i++)
8962 {
8963 val = Faref (initial, make_number (i));
8964 if (! NILP (val))
8965 {
584948ac
KH		 8966 struct charset *charset;
8967
8968 CHECK_CHARSET_GET_CHARSET (val, charset);
8969 ASET (initial, i, make_number (CHARSET_ID (charset)));
8970 if (i == 0 && CHARSET_ASCII_COMPATIBLE_P (charset))
8971 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 8972 }
8973 else
8974 ASET (initial, i, make_number (-1));
8975 }
8976
8977 reg_usage = args[coding_arg_iso2022_reg_usage];
8978 CHECK_CONS (reg_usage);
8f924df7
KH		 8979 CHECK_NUMBER_CAR (reg_usage);
8980 CHECK_NUMBER_CDR (reg_usage);
df7492f9
KH		 8981
8982 request = Fcopy_sequence (args[coding_arg_iso2022_request]);
8983 for (tail = request; ! NILP (tail); tail = Fcdr (tail))
1397dc18 8984 {
df7492f9 8985 int id;
8f924df7 8986 Lisp_Object tmp;
df7492f9
KH		 8987
8988 val = Fcar (tail);
8989 CHECK_CONS (val);
8f924df7
KH		 8990 tmp = XCAR (val);
8991 CHECK_CHARSET_GET_ID (tmp, id);
8992 CHECK_NATNUM_CDR (val);
df7492f9
KH		 8993 if (XINT (XCDR (val)) >= 4)
8994 error ("Invalid graphic register number: %d", XINT (XCDR (val)));
8f924df7 8995 XSETCAR (val, make_number (id));
1397dc18 8996 }
4ed46869 8997
df7492f9
KH		 8998 flags = args[coding_arg_iso2022_flags];
8999 CHECK_NATNUM (flags);
9000 i = XINT (flags);
9001 if (EQ (args[coding_arg_charset_list], Qiso_2022))
9002 flags = make_number (i | CODING_ISO_FLAG_FULL_SUPPORT);
9003
9004 ASET (attrs, coding_attr_iso_initial, initial);
9005 ASET (attrs, coding_attr_iso_usage, reg_usage);
9006 ASET (attrs, coding_attr_iso_request, request);
9007 ASET (attrs, coding_attr_iso_flags, flags);
9008 setup_iso_safe_charsets (attrs);
9009
9010 if (i & CODING_ISO_FLAG_SEVEN_BITS)
9011 category = ((i & (CODING_ISO_FLAG_LOCKING_SHIFT
9012 | CODING_ISO_FLAG_SINGLE_SHIFT))
9013 ? coding_category_iso_7_else
9014 : EQ (args[coding_arg_charset_list], Qiso_2022)
9015 ? coding_category_iso_7
9016 : coding_category_iso_7_tight);
9017 else
9018 {
9019 int id = XINT (AREF (initial, 1));
9020
c6fb6e98 9021 category = (((i & CODING_ISO_FLAG_LOCKING_SHIFT)
df7492f9
KH		 9022 || EQ (args[coding_arg_charset_list], Qiso_2022)
9023 || id < 0)
9024 ? coding_category_iso_8_else
9025 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id)) == 1)
9026 ? coding_category_iso_8_1
9027 : coding_category_iso_8_2);
9028 }
0ce7886f
KH		 9029 if (category != coding_category_iso_8_1
9030 && category != coding_category_iso_8_2)
9031 CODING_ATTR_ASCII_COMPAT (attrs) = Qnil;
df7492f9
KH		 9032 }
9033 else if (EQ (coding_type, Qemacs_mule))
c28a9453 9034 {
df7492f9
KH		 9035 if (EQ (args[coding_arg_charset_list], Qemacs_mule))
9036 ASET (attrs, coding_attr_emacs_mule_full, Qt);
584948ac 9037 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9 9038 category = coding_category_emacs_mule;
c28a9453 9039 }
df7492f9 9040 else if (EQ (coding_type, Qshift_jis))
c28a9453 9041 {
df7492f9
KH		 9042
9043 struct charset *charset;
9044
7d64c6ad 9045 if (XINT (Flength (charset_list)) != 3
6e07c25f 9046 && XINT (Flength (charset_list)) != 4)
7d64c6ad 9047 error ("There should be three or four charsets");
df7492f9
KH		 9048
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))));
584948ac
KH		 9053 if (CHARSET_ASCII_COMPATIBLE_P (charset))
9054 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 9055
9056 charset_list = XCDR (charset_list);
9057 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9058 if (CHARSET_DIMENSION (charset) != 1)
9059 error ("Dimension of charset %s is not one",
8f924df7 9060 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
df7492f9
KH		 9061
9062 charset_list = XCDR (charset_list);
9063 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9064 if (CHARSET_DIMENSION (charset) != 2)
7d64c6ad
KH		 9065 error ("Dimension of charset %s is not two",
9066 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
9067
9068 charset_list = XCDR (charset_list);
2b917a06
KH		 9069 if (! NILP (charset_list))
9070 {
9071 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9072 if (CHARSET_DIMENSION (charset) != 2)
9073 error ("Dimension of charset %s is not two",
9074 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
9075 }
df7492f9
KH		 9076
9077 category = coding_category_sjis;
9078 Vsjis_coding_system = name;
c28a9453 9079 }
df7492f9
KH		 9080 else if (EQ (coding_type, Qbig5))
9081 {
9082 struct charset *charset;
4ed46869 9083
df7492f9
KH		 9084 if (XINT (Flength (charset_list)) != 2)
9085 error ("There should be just two charsets");
9086
9087 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9088 if (CHARSET_DIMENSION (charset) != 1)
9089 error ("Dimension of charset %s is not one",
8f924df7 9090 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
584948ac
KH		 9091 if (CHARSET_ASCII_COMPATIBLE_P (charset))
9092 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
df7492f9
KH		 9093
9094 charset_list = XCDR (charset_list);
9095 charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
9096 if (CHARSET_DIMENSION (charset) != 2)
9097 error ("Dimension of charset %s is not two",
8f924df7 9098 SDATA (SYMBOL_NAME (CHARSET_NAME (charset))));
4ed46869 9099
df7492f9
KH		 9100 category = coding_category_big5;
9101 Vbig5_coding_system = name;
9102 }
9103 else if (EQ (coding_type, Qraw_text))
c28a9453 9104 {
584948ac
KH		 9105 category = coding_category_raw_text;
9106 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
c28a9453 9107 }
df7492f9 9108 else if (EQ (coding_type, Qutf_8))
4ed46869 9109 {
584948ac
KH		 9110 category = coding_category_utf_8;
9111 CODING_ATTR_ASCII_COMPAT (attrs) = Qt;
4ed46869 9112 }
df7492f9
KH		 9113 else if (EQ (coding_type, Qundecided))
9114 category = coding_category_undecided;
4ed46869 9115 else
df7492f9 9116 error ("Invalid coding system type: %s",
8f924df7 9117 SDATA (SYMBOL_NAME (coding_type)));
4ed46869 9118
df7492f9 9119 CODING_ATTR_CATEGORY (attrs) = make_number (category);
01378f49
KH		 9120 CODING_ATTR_PLIST (attrs)
9121 = Fcons (QCcategory, Fcons (AREF (Vcoding_category_table, category),
9122 CODING_ATTR_PLIST (attrs)));
35befdaa
KH		 9123 CODING_ATTR_PLIST (attrs)
9124 = Fcons (QCascii_compatible_p,
9125 Fcons (CODING_ATTR_ASCII_COMPAT (attrs),
9126 CODING_ATTR_PLIST (attrs)));
c4825358 9127
df7492f9
KH		 9128 eol_type = args[coding_arg_eol_type];
9129 if (! NILP (eol_type)
9130 && ! EQ (eol_type, Qunix)
9131 && ! EQ (eol_type, Qdos)
9132 && ! EQ (eol_type, Qmac))
9133 error ("Invalid eol-type");
4ed46869 9134
df7492f9 9135 aliases = Fcons (name, Qnil);
4ed46869 9136
df7492f9
KH		 9137 if (NILP (eol_type))
9138 {
9139 eol_type = make_subsidiaries (name);
9140 for (i = 0; i < 3; i++)
1397dc18 9141 {
df7492f9
KH		 9142 Lisp_Object this_spec, this_name, this_aliases, this_eol_type;
9143
9144 this_name = AREF (eol_type, i);
9145 this_aliases = Fcons (this_name, Qnil);
9146 this_eol_type = (i == 0 ? Qunix : i == 1 ? Qdos : Qmac);
9147 this_spec = Fmake_vector (make_number (3), attrs);
9148 ASET (this_spec, 1, this_aliases);
9149 ASET (this_spec, 2, this_eol_type);
9150 Fputhash (this_name, this_spec, Vcoding_system_hash_table);
9151 Vcoding_system_list = Fcons (this_name, Vcoding_system_list);
583f71ca
KH		 9152 val = Fassoc (Fsymbol_name (this_name), Vcoding_system_alist);
9153 if (NILP (val))
9154 Vcoding_system_alist
9155 = Fcons (Fcons (Fsymbol_name (this_name), Qnil),
9156 Vcoding_system_alist);
1397dc18 9157 }
d46c5b12 9158 }
4ed46869 9159
df7492f9
KH		 9160 spec_vec = Fmake_vector (make_number (3), attrs);
9161 ASET (spec_vec, 1, aliases);
9162 ASET (spec_vec, 2, eol_type);
48b0f3ae 9163
df7492f9
KH		 9164 Fputhash (name, spec_vec, Vcoding_system_hash_table);
9165 Vcoding_system_list = Fcons (name, Vcoding_system_list);
583f71ca
KH		 9166 val = Fassoc (Fsymbol_name (name), Vcoding_system_alist);
9167 if (NILP (val))
9168 Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (name), Qnil),
9169 Vcoding_system_alist);
48b0f3ae 9170
df7492f9
KH		 9171 {
9172 int id = coding_categories[category].id;
48b0f3ae 9173
df7492f9
KH		 9174 if (id < 0 || EQ (name, CODING_ID_NAME (id)))
9175 setup_coding_system (name, &coding_categories[category]);
9176 }
48b0f3ae 9177
d46c5b12 9178 return Qnil;
48b0f3ae 9179
df7492f9
KH		 9180 short_args:
9181 return Fsignal (Qwrong_number_of_arguments,
9182 Fcons (intern ("define-coding-system-internal"),
9183 make_number (nargs)));
d46c5b12 9184}
4ed46869 9185
d6925f38 9186
a6f87d34
KH		 9187DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
9188 3, 3, 0,
9189 doc: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
9190 (coding_system, prop, val)
9191 Lisp_Object coding_system, prop, val;
9192{
3dbe7859 9193 Lisp_Object spec, attrs;
a6f87d34
KH		 9194
9195 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9196 attrs = AREF (spec, 0);
9197 if (EQ (prop, QCmnemonic))
9198 {
9199 if (! STRINGP (val))
9200 CHECK_CHARACTER (val);
9201 CODING_ATTR_MNEMONIC (attrs) = val;
9202 }
9203 else if (EQ (prop, QCdefalut_char))
9204 {
9205 if (NILP (val))
9206 val = make_number (' ');
9207 else
9208 CHECK_CHARACTER (val);
9209 CODING_ATTR_DEFAULT_CHAR (attrs) = val;
9210 }
9211 else if (EQ (prop, QCdecode_translation_table))
9212 {
9213 if (! CHAR_TABLE_P (val) && ! CONSP (val))
9214 CHECK_SYMBOL (val);
9215 CODING_ATTR_DECODE_TBL (attrs) = val;
9216 }
9217 else if (EQ (prop, QCencode_translation_table))
9218 {
9219 if (! CHAR_TABLE_P (val) && ! CONSP (val))
9220 CHECK_SYMBOL (val);
9221 CODING_ATTR_ENCODE_TBL (attrs) = val;
9222 }
9223 else if (EQ (prop, QCpost_read_conversion))
9224 {
9225 CHECK_SYMBOL (val);
9226 CODING_ATTR_POST_READ (attrs) = val;
9227 }
9228 else if (EQ (prop, QCpre_write_conversion))
9229 {
9230 CHECK_SYMBOL (val);
9231 CODING_ATTR_PRE_WRITE (attrs) = val;
9232 }
35befdaa
KH		 9233 else if (EQ (prop, QCascii_compatible_p))
9234 {
9235 CODING_ATTR_ASCII_COMPAT (attrs) = val;
9236 }
a6f87d34
KH		 9237
9238 CODING_ATTR_PLIST (attrs)
9239 = Fplist_put (CODING_ATTR_PLIST (attrs), prop, val);
9240 return val;
9241}
9242
9243
df7492f9
KH		 9244DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias,
9245 Sdefine_coding_system_alias, 2, 2, 0,
9246 doc: /* Define ALIAS as an alias for CODING-SYSTEM. */)
9247 (alias, coding_system)
9248 Lisp_Object alias, coding_system;
66cfb530 9249{
583f71ca 9250 Lisp_Object spec, aliases, eol_type, val;
4ed46869 9251
df7492f9
KH		 9252 CHECK_SYMBOL (alias);
9253 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9254 aliases = AREF (spec, 1);
d6925f38
KH		 9255 /* ALISES should be a list of length more than zero, and the first
9256 element is a base coding system. Append ALIAS at the tail of the
9257 list. */
df7492f9
KH		 9258 while (!NILP (XCDR (aliases)))
9259 aliases = XCDR (aliases);
8f924df7 9260 XSETCDR (aliases, Fcons (alias, Qnil));
4ed46869 9261
df7492f9
KH		 9262 eol_type = AREF (spec, 2);
9263 if (VECTORP (eol_type))
4ed46869 9264 {
df7492f9
KH		 9265 Lisp_Object subsidiaries;
9266 int i;
4ed46869 9267
df7492f9
KH		 9268 subsidiaries = make_subsidiaries (alias);
9269 for (i = 0; i < 3; i++)
9270 Fdefine_coding_system_alias (AREF (subsidiaries, i),
9271 AREF (eol_type, i));
4ed46869 9272 }
df7492f9
KH		 9273
9274 Fputhash (alias, spec, Vcoding_system_hash_table);
d6925f38 9275 Vcoding_system_list = Fcons (alias, Vcoding_system_list);
583f71ca
KH		 9276 val = Fassoc (Fsymbol_name (alias), Vcoding_system_alist);
9277 if (NILP (val))
9278 Vcoding_system_alist = Fcons (Fcons (Fsymbol_name (alias), Qnil),
9279 Vcoding_system_alist);
66cfb530 9280
4ed46869
KH		 9281 return Qnil;
9282}
9283
df7492f9
KH		 9284DEFUN ("coding-system-base", Fcoding_system_base, Scoding_system_base,
9285 1, 1, 0,
9286 doc: /* Return the base of CODING-SYSTEM.
da7db224 9287Any alias or subsidiary coding system is not a base coding system. */)
df7492f9
KH		 9288 (coding_system)
9289 Lisp_Object coding_system;
d46c5b12 9290{
df7492f9 9291 Lisp_Object spec, attrs;
d46c5b12 9292
df7492f9
KH		 9293 if (NILP (coding_system))
9294 return (Qno_conversion);
9295 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9296 attrs = AREF (spec, 0);
9297 return CODING_ATTR_BASE_NAME (attrs);
9298}
1397dc18 9299
df7492f9
KH		 9300DEFUN ("coding-system-plist", Fcoding_system_plist, Scoding_system_plist,
9301 1, 1, 0,
9302 doc: "Return the property list of CODING-SYSTEM.")
9303 (coding_system)
9304 Lisp_Object coding_system;
9305{
9306 Lisp_Object spec, attrs;
1397dc18 9307
df7492f9
KH		 9308 if (NILP (coding_system))
9309 coding_system = Qno_conversion;
9310 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
9311 attrs = AREF (spec, 0);
9312 return CODING_ATTR_PLIST (attrs);
d46c5b12
KH		 9313}
9314
df7492f9
KH		 9315
9316DEFUN ("coding-system-aliases", Fcoding_system_aliases, Scoding_system_aliases,
9317 1, 1, 0,
da7db224 9318 doc: /* Return the list of aliases of CODING-SYSTEM. */)
df7492f9
KH		 9319 (coding_system)
9320 Lisp_Object coding_system;
66cfb530 9321{
df7492f9 9322 Lisp_Object spec;
84d60297 9323
df7492f9
KH		 9324 if (NILP (coding_system))
9325 coding_system = Qno_conversion;
9326 CHECK_CODING_SYSTEM_GET_SPEC (coding_system, spec);
da7db224 9327 return AREF (spec, 1);
df7492f9 9328}
66cfb530 9329
df7492f9
KH		 9330DEFUN ("coding-system-eol-type", Fcoding_system_eol_type,
9331 Scoding_system_eol_type, 1, 1, 0,
9332 doc: /* Return eol-type of CODING-SYSTEM.
9333An eol-type is integer 0, 1, 2, or a vector of coding systems.
66cfb530 9334
df7492f9
KH		 9335Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9336and CR respectively.
66cfb530 9337
df7492f9
KH		 9338A vector value indicates that a format of end-of-line should be
9339detected automatically. Nth element of the vector is the subsidiary
9340coding system whose eol-type is N. */)
6b89e3aa
KH		 9341 (coding_system)
9342 Lisp_Object coding_system;
9343{
df7492f9
KH		 9344 Lisp_Object spec, eol_type;
9345 int n;
6b89e3aa 9346
df7492f9
KH		 9347 if (NILP (coding_system))
9348 coding_system = Qno_conversion;
9349 if (! CODING_SYSTEM_P (coding_system))
9350 return Qnil;
9351 spec = CODING_SYSTEM_SPEC (coding_system);
9352 eol_type = AREF (spec, 2);
9353 if (VECTORP (eol_type))
9354 return Fcopy_sequence (eol_type);
9355 n = EQ (eol_type, Qunix) ? 0 : EQ (eol_type, Qdos) ? 1 : 2;
9356 return make_number (n);
6b89e3aa
KH		 9357}
9358
4ed46869
KH		 9359#endif /* emacs */
9360
9361\f
1397dc18 9362/*** 9. Post-amble ***/
4ed46869 9363
dfcf069d 9364void
4ed46869
KH		 9365init_coding_once ()
9366{
9367 int i;
9368
df7492f9
KH		 9369 for (i = 0; i < coding_category_max; i++)
9370 {
9371 coding_categories[i].id = -1;
9372 coding_priorities[i] = i;
9373 }
4ed46869
KH		 9374
9375 /* ISO2022 specific initialize routine. */
9376 for (i = 0; i < 0x20; i++)
b73bfc1c 9377 iso_code_class[i] = ISO_control_0;
4ed46869
KH		 9378 for (i = 0x21; i < 0x7F; i++)
9379 iso_code_class[i] = ISO_graphic_plane_0;
9380 for (i = 0x80; i < 0xA0; i++)
b73bfc1c 9381 iso_code_class[i] = ISO_control_1;
4ed46869
KH		 9382 for (i = 0xA1; i < 0xFF; i++)
9383 iso_code_class[i] = ISO_graphic_plane_1;
9384 iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
9385 iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
4ed46869
KH		 9386 iso_code_class[ISO_CODE_SO] = ISO_shift_out;
9387 iso_code_class[ISO_CODE_SI] = ISO_shift_in;
9388 iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
9389 iso_code_class[ISO_CODE_ESC] = ISO_escape;
9390 iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
9391 iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
9392 iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
9393
df7492f9
KH		 9394 for (i = 0; i < 256; i++)
9395 {
9396 emacs_mule_bytes[i] = 1;
9397 }
7c78e542
KH		 9398 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_11] = 3;
9399 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_12] = 3;
9400 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_21] = 4;
9401 emacs_mule_bytes[EMACS_MULE_LEADING_CODE_PRIVATE_22] = 4;
e0e989f6
KH		 9402}
9403
9404#ifdef emacs
9405
dfcf069d 9406void
e0e989f6
KH		 9407syms_of_coding ()
9408{
df7492f9 9409 staticpro (&Vcoding_system_hash_table);
8f924df7
KH		 9410 {
9411 Lisp_Object args[2];
9412 args[0] = QCtest;
9413 args[1] = Qeq;
9414 Vcoding_system_hash_table = Fmake_hash_table (2, args);
9415 }
df7492f9
KH		 9416
9417 staticpro (&Vsjis_coding_system);
9418 Vsjis_coding_system = Qnil;
e0e989f6 9419
df7492f9
KH		 9420 staticpro (&Vbig5_coding_system);
9421 Vbig5_coding_system = Qnil;
9422
24a73b0a
KH		 9423 staticpro (&Vcode_conversion_reused_workbuf);
9424 Vcode_conversion_reused_workbuf = Qnil;
9425
9426 staticpro (&Vcode_conversion_workbuf_name);
9427 Vcode_conversion_workbuf_name = build_string (" *code-conversion-work*");
e0e989f6 9428
24a73b0a 9429 reused_workbuf_in_use = 0;
df7492f9
KH		 9430
9431 DEFSYM (Qcharset, "charset");
9432 DEFSYM (Qtarget_idx, "target-idx");
9433 DEFSYM (Qcoding_system_history, "coding-system-history");
bb0115a2
RS		 9434 Fset (Qcoding_system_history, Qnil);
9435
9ce27fde 9436 /* Target FILENAME is the first argument. */
e0e989f6 9437 Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
9ce27fde 9438 /* Target FILENAME is the third argument. */
e0e989f6
KH		 9439 Fput (Qwrite_region, Qtarget_idx, make_number (2));
9440
df7492f9 9441 DEFSYM (Qcall_process, "call-process");
9ce27fde 9442 /* Target PROGRAM is the first argument. */
e0e989f6
KH		 9443 Fput (Qcall_process, Qtarget_idx, make_number (0));
9444
df7492f9 9445 DEFSYM (Qcall_process_region, "call-process-region");
9ce27fde 9446 /* Target PROGRAM is the third argument. */
e0e989f6
KH		 9447 Fput (Qcall_process_region, Qtarget_idx, make_number (2));
9448
df7492f9 9449 DEFSYM (Qstart_process, "start-process");
9ce27fde 9450 /* Target PROGRAM is the third argument. */
e0e989f6
KH		 9451 Fput (Qstart_process, Qtarget_idx, make_number (2));
9452
df7492f9 9453 DEFSYM (Qopen_network_stream, "open-network-stream");
9ce27fde 9454 /* Target SERVICE is the fourth argument. */
e0e989f6
KH		 9455 Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
9456
df7492f9
KH		 9457 DEFSYM (Qcoding_system, "coding-system");
9458 DEFSYM (Qcoding_aliases, "coding-aliases");
4ed46869 9459
df7492f9
KH		 9460 DEFSYM (Qeol_type, "eol-type");
9461 DEFSYM (Qunix, "unix");
9462 DEFSYM (Qdos, "dos");
4ed46869 9463
df7492f9
KH		 9464 DEFSYM (Qbuffer_file_coding_system, "buffer-file-coding-system");
9465 DEFSYM (Qpost_read_conversion, "post-read-conversion");
9466 DEFSYM (Qpre_write_conversion, "pre-write-conversion");
9467 DEFSYM (Qdefault_char, "default-char");
9468 DEFSYM (Qundecided, "undecided");
9469 DEFSYM (Qno_conversion, "no-conversion");
9470 DEFSYM (Qraw_text, "raw-text");
4ed46869 9471
df7492f9 9472 DEFSYM (Qiso_2022, "iso-2022");
4ed46869 9473
df7492f9 9474 DEFSYM (Qutf_8, "utf-8");
8f924df7 9475 DEFSYM (Qutf_8_emacs, "utf-8-emacs");
27901516 9476
df7492f9 9477 DEFSYM (Qutf_16, "utf-16");
df7492f9
KH		 9478 DEFSYM (Qbig, "big");
9479 DEFSYM (Qlittle, "little");
27901516 9480
df7492f9
KH		 9481 DEFSYM (Qshift_jis, "shift-jis");
9482 DEFSYM (Qbig5, "big5");
4ed46869 9483
df7492f9 9484 DEFSYM (Qcoding_system_p, "coding-system-p");
4ed46869 9485
df7492f9 9486 DEFSYM (Qcoding_system_error, "coding-system-error");
4ed46869
KH		 9487 Fput (Qcoding_system_error, Qerror_conditions,
9488 Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
9489 Fput (Qcoding_system_error, Qerror_message,
9ce27fde 9490 build_string ("Invalid coding system"));
4ed46869 9491
05e6f5dc
KH		 9492 /* Intern this now in case it isn't already done.
9493 Setting this variable twice is harmless.
9494 But don't staticpro it here--that is done in alloc.c. */
9495 Qchar_table_extra_slots = intern ("char-table-extra-slots");
70c22245 9496
df7492f9 9497 DEFSYM (Qtranslation_table, "translation-table");
433f7f87 9498 Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
df7492f9
KH		 9499 DEFSYM (Qtranslation_table_id, "translation-table-id");
9500 DEFSYM (Qtranslation_table_for_decode, "translation-table-for-decode");
9501 DEFSYM (Qtranslation_table_for_encode, "translation-table-for-encode");
1397dc18 9502
df7492f9 9503 DEFSYM (Qvalid_codes, "valid-codes");
9ce27fde 9504
df7492f9 9505 DEFSYM (Qemacs_mule, "emacs-mule");
d46c5b12 9506
01378f49 9507 DEFSYM (QCcategory, ":category");
a6f87d34
KH		 9508 DEFSYM (QCmnemonic, ":mnemonic");
9509 DEFSYM (QCdefalut_char, ":default-char");
9510 DEFSYM (QCdecode_translation_table, ":decode-translation-table");
9511 DEFSYM (QCencode_translation_table, ":encode-translation-table");
9512 DEFSYM (QCpost_read_conversion, ":post-read-conversion");
9513 DEFSYM (QCpre_write_conversion, ":pre-write-conversion");
35befdaa 9514 DEFSYM (QCascii_compatible_p, ":ascii-compatible-p");
01378f49 9515
df7492f9
KH		 9516 Vcoding_category_table
9517 = Fmake_vector (make_number (coding_category_max), Qnil);
9518 staticpro (&Vcoding_category_table);
9519 /* Followings are target of code detection. */
9520 ASET (Vcoding_category_table, coding_category_iso_7,
9521 intern ("coding-category-iso-7"));
9522 ASET (Vcoding_category_table, coding_category_iso_7_tight,
9523 intern ("coding-category-iso-7-tight"));
9524 ASET (Vcoding_category_table, coding_category_iso_8_1,
9525 intern ("coding-category-iso-8-1"));
9526 ASET (Vcoding_category_table, coding_category_iso_8_2,
9527 intern ("coding-category-iso-8-2"));
9528 ASET (Vcoding_category_table, coding_category_iso_7_else,
9529 intern ("coding-category-iso-7-else"));
9530 ASET (Vcoding_category_table, coding_category_iso_8_else,
9531 intern ("coding-category-iso-8-else"));
9532 ASET (Vcoding_category_table, coding_category_utf_8,
9533 intern ("coding-category-utf-8"));
9534 ASET (Vcoding_category_table, coding_category_utf_16_be,
9535 intern ("coding-category-utf-16-be"));
ff563fce
KH		 9536 ASET (Vcoding_category_table, coding_category_utf_16_auto,
9537 intern ("coding-category-utf-16-auto"));
df7492f9
KH		 9538 ASET (Vcoding_category_table, coding_category_utf_16_le,
9539 intern ("coding-category-utf-16-le"));
9540 ASET (Vcoding_category_table, coding_category_utf_16_be_nosig,
9541 intern ("coding-category-utf-16-be-nosig"));
9542 ASET (Vcoding_category_table, coding_category_utf_16_le_nosig,
9543 intern ("coding-category-utf-16-le-nosig"));
9544 ASET (Vcoding_category_table, coding_category_charset,
9545 intern ("coding-category-charset"));
9546 ASET (Vcoding_category_table, coding_category_sjis,
9547 intern ("coding-category-sjis"));
9548 ASET (Vcoding_category_table, coding_category_big5,
9549 intern ("coding-category-big5"));
9550 ASET (Vcoding_category_table, coding_category_ccl,
9551 intern ("coding-category-ccl"));
9552 ASET (Vcoding_category_table, coding_category_emacs_mule,
9553 intern ("coding-category-emacs-mule"));
9554 /* Followings are NOT target of code detection. */
9555 ASET (Vcoding_category_table, coding_category_raw_text,
9556 intern ("coding-category-raw-text"));
9557 ASET (Vcoding_category_table, coding_category_undecided,
9558 intern ("coding-category-undecided"));
ecf488bc 9559
065e3595
KH		 9560 DEFSYM (Qinsufficient_source, "insufficient-source");
9561 DEFSYM (Qinconsistent_eol, "inconsistent-eol");
9562 DEFSYM (Qinvalid_source, "invalid-source");
9563 DEFSYM (Qinterrupted, "interrupted");
9564 DEFSYM (Qinsufficient_memory, "insufficient-memory");
44e8490d 9565 DEFSYM (Qcoding_system_define_form, "coding-system-define-form");
065e3595 9566
4ed46869
KH		 9567 defsubr (&Scoding_system_p);
9568 defsubr (&Sread_coding_system);
9569 defsubr (&Sread_non_nil_coding_system);
9570 defsubr (&Scheck_coding_system);
9571 defsubr (&Sdetect_coding_region);
d46c5b12 9572 defsubr (&Sdetect_coding_string);
05e6f5dc 9573 defsubr (&Sfind_coding_systems_region_internal);
068a9dbd 9574 defsubr (&Sunencodable_char_position);
df7492f9 9575 defsubr (&Scheck_coding_systems_region);
4ed46869
KH		 9576 defsubr (&Sdecode_coding_region);
9577 defsubr (&Sencode_coding_region);
9578 defsubr (&Sdecode_coding_string);
9579 defsubr (&Sencode_coding_string);
9580 defsubr (&Sdecode_sjis_char);
9581 defsubr (&Sencode_sjis_char);
9582 defsubr (&Sdecode_big5_char);
9583 defsubr (&Sencode_big5_char);
1ba9e4ab 9584 defsubr (&Sset_terminal_coding_system_internal);
c4825358 9585 defsubr (&Sset_safe_terminal_coding_system_internal);
4ed46869 9586 defsubr (&Sterminal_coding_system);
1ba9e4ab 9587 defsubr (&Sset_keyboard_coding_system_internal);
4ed46869 9588 defsubr (&Skeyboard_coding_system);
a5d301df 9589 defsubr (&Sfind_operation_coding_system);
df7492f9 9590 defsubr (&Sset_coding_system_priority);
6b89e3aa 9591 defsubr (&Sdefine_coding_system_internal);
df7492f9 9592 defsubr (&Sdefine_coding_system_alias);
a6f87d34 9593 defsubr (&Scoding_system_put);
df7492f9
KH		 9594 defsubr (&Scoding_system_base);
9595 defsubr (&Scoding_system_plist);
9596 defsubr (&Scoding_system_aliases);
9597 defsubr (&Scoding_system_eol_type);
9598 defsubr (&Scoding_system_priority_list);
4ed46869 9599
4608c386 9600 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
48b0f3ae
PJ		 9601 doc: /* List of coding systems.
9602
9603Do not alter the value of this variable manually. This variable should be
df7492f9 9604updated by the functions `define-coding-system' and
48b0f3ae 9605`define-coding-system-alias'. */);
4608c386
KH		 9606 Vcoding_system_list = Qnil;
9607
9608 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
48b0f3ae
PJ		 9609 doc: /* Alist of coding system names.
9610Each element is one element list of coding system name.
9611This variable is given to `completing-read' as TABLE argument.
9612
9613Do not alter the value of this variable manually. This variable should be
9614updated by the functions `make-coding-system' and
9615`define-coding-system-alias'. */);
4608c386
KH		 9616 Vcoding_system_alist = Qnil;
9617
4ed46869 9618 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
48b0f3ae
PJ		 9619 doc: /* List of coding-categories (symbols) ordered by priority.
9620
9621On detecting a coding system, Emacs tries code detection algorithms
9622associated with each coding-category one by one in this order. When
9623one algorithm agrees with a byte sequence of source text, the coding
0ec31faf
KH		 9624system bound to the corresponding coding-category is selected.
9625
42205607 9626Don't modify this variable directly, but use `set-coding-priority'. */);
4ed46869
KH		 9627 {
9628 int i;
9629
9630 Vcoding_category_list = Qnil;
df7492f9 9631 for (i = coding_category_max - 1; i >= 0; i--)
4ed46869 9632 Vcoding_category_list
d46c5b12
KH		 9633 = Fcons (XVECTOR (Vcoding_category_table)->contents[i],
9634 Vcoding_category_list);
4ed46869
KH		 9635 }
9636
9637 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
48b0f3ae
PJ		 9638 doc: /* Specify the coding system for read operations.
9639It is useful to bind this variable with `let', but do not set it globally.
9640If the value is a coding system, it is used for decoding on read operation.
9641If not, an appropriate element is used from one of the coding system alists:
9642There are three such tables, `file-coding-system-alist',
9643`process-coding-system-alist', and `network-coding-system-alist'. */);
4ed46869
KH		 9644 Vcoding_system_for_read = Qnil;
9645
9646 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
48b0f3ae
PJ		 9647 doc: /* Specify the coding system for write operations.
9648Programs bind this variable with `let', but you should not set it globally.
9649If the value is a coding system, it is used for encoding of output,
9650when writing it to a file and when sending it to a file or subprocess.
9651
9652If this does not specify a coding system, an appropriate element
9653is used from one of the coding system alists:
9654There are three such tables, `file-coding-system-alist',
9655`process-coding-system-alist', and `network-coding-system-alist'.
9656For output to files, if the above procedure does not specify a coding system,
9657the value of `buffer-file-coding-system' is used. */);
4ed46869
KH		 9658 Vcoding_system_for_write = Qnil;
9659
9660 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
df7492f9
KH		 9661 doc: /*
9662Coding system used in the latest file or process I/O. */);
4ed46869
KH		 9663 Vlast_coding_system_used = Qnil;
9664
065e3595
KH		 9665 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error,
9666 doc: /*
9667Error status of the last code conversion.
9668
9669When an error was detected in the last code conversion, this variable
9670is set to one of the following symbols.
9671 `insufficient-source'
9672 `inconsistent-eol'
9673 `invalid-source'
9674 `interrupted'
9675 `insufficient-memory'
9676When no error was detected, the value doesn't change. So, to check
9677the error status of a code conversion by this variable, you must
9678explicitly set this variable to nil before performing code
9679conversion. */);
9680 Vlast_code_conversion_error = Qnil;
9681
9ce27fde 9682 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
df7492f9
KH		 9683 doc: /*
9684*Non-nil means always inhibit code conversion of end-of-line format.
48b0f3ae
PJ		 9685See info node `Coding Systems' and info node `Text and Binary' concerning
9686such conversion. */);
9ce27fde
KH		 9687 inhibit_eol_conversion = 0;
9688
ed29121d 9689 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system,
df7492f9
KH		 9690 doc: /*
9691Non-nil means process buffer inherits coding system of process output.
48b0f3ae
PJ		 9692Bind it to t if the process output is to be treated as if it were a file
9693read from some filesystem. */);
ed29121d
EZ		 9694 inherit_process_coding_system = 0;
9695
02ba4723 9696 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist,
df7492f9
KH		 9697 doc: /*
9698Alist to decide a coding system to use for a file I/O operation.
48b0f3ae
PJ		 9699The format is ((PATTERN . VAL) ...),
9700where PATTERN is a regular expression matching a file name,
9701VAL is a coding system, a cons of coding systems, or a function symbol.
9702If VAL is a coding system, it is used for both decoding and encoding
9703the file contents.
9704If VAL is a cons of coding systems, the car part is used for decoding,
9705and the cdr part is used for encoding.
9706If VAL is a function symbol, the function must return a coding system
2c53e699
KH		 9707or a cons of coding systems which are used as above. The function is
9708called with an argument that is a list of the arguments with which
5a0bbd9a
KH		 9709`find-operation-coding-system' was called. If the function can't decide
9710a coding system, it can return `undecided' so that the normal
9711code-detection is performed.
48b0f3ae
PJ		 9712
9713See also the function `find-operation-coding-system'
9714and the variable `auto-coding-alist'. */);
02ba4723
KH		 9715 Vfile_coding_system_alist = Qnil;
9716
9717 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
df7492f9
KH		 9718 doc: /*
9719Alist to decide a coding system to use for a process I/O operation.
48b0f3ae
PJ		 9720The format is ((PATTERN . VAL) ...),
9721where PATTERN is a regular expression matching a program name,
9722VAL is a coding system, a cons of coding systems, or a function symbol.
9723If VAL is a coding system, it is used for both decoding what received
9724from the program and encoding what sent to the program.
9725If VAL is a cons of coding systems, the car part is used for decoding,
9726and the cdr part is used for encoding.
9727If VAL is a function symbol, the function must return a coding system
9728or a cons of coding systems which are used as above.
9729
9730See also the function `find-operation-coding-system'. */);
02ba4723
KH		 9731 Vprocess_coding_system_alist = Qnil;
9732
9733 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist,
df7492f9
KH		 9734 doc: /*
9735Alist to decide a coding system to use for a network I/O operation.
48b0f3ae
PJ		 9736The format is ((PATTERN . VAL) ...),
9737where PATTERN is a regular expression matching a network service name
9738or is a port number to connect to,
9739VAL is a coding system, a cons of coding systems, or a function symbol.
9740If VAL is a coding system, it is used for both decoding what received
9741from the network stream and encoding what sent to the network stream.
9742If VAL is a cons of coding systems, the car part is used for decoding,
9743and the cdr part is used for encoding.
9744If VAL is a function symbol, the function must return a coding system
9745or a cons of coding systems which are used as above.
9746
9747See also the function `find-operation-coding-system'. */);
02ba4723 9748 Vnetwork_coding_system_alist = Qnil;
4ed46869 9749
68c45bf0 9750 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system,
75205970
RS		 9751 doc: /* Coding system to use with system messages.
9752Also used for decoding keyboard input on X Window system. */);
68c45bf0
PE		 9753 Vlocale_coding_system = Qnil;
9754
005f0d35 9755 /* The eol mnemonics are reset in startup.el system-dependently. */
7722baf9 9756 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
df7492f9
KH		 9757 doc: /*
9758*String displayed in mode line for UNIX-like (LF) end-of-line format. */);
7722baf9 9759 eol_mnemonic_unix = build_string (":");
4ed46869 9760
7722baf9 9761 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
df7492f9
KH		 9762 doc: /*
9763*String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
7722baf9 9764 eol_mnemonic_dos = build_string ("\\");
4ed46869 9765
7722baf9 9766 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
df7492f9
KH		 9767 doc: /*
9768*String displayed in mode line for MAC-like (CR) end-of-line format. */);
7722baf9 9769 eol_mnemonic_mac = build_string ("/");
4ed46869 9770
7722baf9 9771 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
df7492f9
KH		 9772 doc: /*
9773*String displayed in mode line when end-of-line format is not yet determined. */);
7722baf9 9774 eol_mnemonic_undecided = build_string (":");
4ed46869 9775
84fbb8a0 9776 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
df7492f9
KH		 9777 doc: /*
9778*Non-nil enables character translation while encoding and decoding. */);
84fbb8a0 9779 Venable_character_translation = Qt;
bdd9fb48 9780
f967223b 9781 DEFVAR_LISP ("standard-translation-table-for-decode",
48b0f3ae
PJ		 9782 &Vstandard_translation_table_for_decode,
9783 doc: /* Table for translating characters while decoding. */);
f967223b 9784 Vstandard_translation_table_for_decode = Qnil;
bdd9fb48 9785
f967223b 9786 DEFVAR_LISP ("standard-translation-table-for-encode",
48b0f3ae
PJ		 9787 &Vstandard_translation_table_for_encode,
9788 doc: /* Table for translating characters while encoding. */);
f967223b 9789 Vstandard_translation_table_for_encode = Qnil;
4ed46869 9790
df7492f9 9791 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table,
48b0f3ae
PJ		 9792 doc: /* Alist of charsets vs revision numbers.
9793While encoding, if a charset (car part of an element) is found,
df7492f9
KH		 9794designate it with the escape sequence identifying revision (cdr part
9795of the element). */);
9796 Vcharset_revision_table = Qnil;
02ba4723
KH		 9797
9798 DEFVAR_LISP ("default-process-coding-system",
9799 &Vdefault_process_coding_system,
48b0f3ae
PJ		 9800 doc: /* Cons of coding systems used for process I/O by default.
9801The car part is used for decoding a process output,
9802the cdr part is used for encoding a text to be sent to a process. */);
02ba4723 9803 Vdefault_process_coding_system = Qnil;
c4825358 9804
3f003981 9805 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table,
df7492f9
KH		 9806 doc: /*
9807Table of extra Latin codes in the range 128..159 (inclusive).
48b0f3ae
PJ		 9808This is a vector of length 256.
9809If Nth element is non-nil, the existence of code N in a file
9810\(or output of subprocess) doesn't prevent it to be detected as
9811a coding system of ISO 2022 variant which has a flag
9812`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
9813or reading output of a subprocess.
9814Only 128th through 159th elements has a meaning. */);
3f003981 9815 Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
d46c5b12
KH		 9816
9817 DEFVAR_LISP ("select-safe-coding-system-function",
9818 &Vselect_safe_coding_system_function,
df7492f9
KH		 9819 doc: /*
9820Function to call to select safe coding system for encoding a text.
48b0f3ae
PJ		 9821
9822If set, this function is called to force a user to select a proper
9823coding system which can encode the text in the case that a default
fdecf907
GM		 9824coding system used in each operation can't encode the text. The
9825function should take care that the buffer is not modified while
9826the coding system is being selected.
48b0f3ae
PJ		 9827
9828The default value is `select-safe-coding-system' (which see). */);
d46c5b12
KH		 9829 Vselect_safe_coding_system_function = Qnil;
9830
5d5bf4d8
KH		 9831 DEFVAR_BOOL ("coding-system-require-warning",
9832 &coding_system_require_warning,
9833 doc: /* Internal use only.
6b89e3aa
KH		 9834If non-nil, on writing a file, `select-safe-coding-system-function' is
9835called even if `coding-system-for-write' is non-nil. The command
9836`universal-coding-system-argument' binds this variable to t temporarily. */);
5d5bf4d8
KH		 9837 coding_system_require_warning = 0;
9838
9839
22ab2303 9840 DEFVAR_BOOL ("inhibit-iso-escape-detection",
74383408 9841 &inhibit_iso_escape_detection,
df7492f9
KH		 9842 doc: /*
9843If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
48b0f3ae
PJ		 9844
9845By default, on reading a file, Emacs tries to detect how the text is
9846encoded. This code detection is sensitive to escape sequences. If
9847the sequence is valid as ISO2022, the code is determined as one of
9848the ISO2022 encodings, and the file is decoded by the corresponding
9849coding system (e.g. `iso-2022-7bit').
9850
9851However, there may be a case that you want to read escape sequences in
9852a file as is. In such a case, you can set this variable to non-nil.
9853Then, as the code detection ignores any escape sequences, no file is
9854detected as encoded in some ISO2022 encoding. The result is that all
9855escape sequences become visible in a buffer.
9856
9857The default value is nil, and it is strongly recommended not to change
9858it. That is because many Emacs Lisp source files that contain
9859non-ASCII characters are encoded by the coding system `iso-2022-7bit'
9860in Emacs's distribution, and they won't be decoded correctly on
9861reading if you suppress escape sequence detection.
9862
9863The other way to read escape sequences in a file without decoding is
9864to explicitly specify some coding system that doesn't use ISO2022's
9865escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
74383408 9866 inhibit_iso_escape_detection = 0;
002fdb44
DL		 9867
9868 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input,
15c8f9d1
DL		 9869 doc: /* Char table for translating self-inserting characters.
9870This is applied to the result of input methods, not their input. See also
9871`keyboard-translate-table'. */);
002fdb44 9872 Vtranslation_table_for_input = Qnil;
8f924df7 9873
2c78b7e1
KH		 9874 {
9875 Lisp_Object args[coding_arg_max];
8f924df7 9876 Lisp_Object plist[16];
2c78b7e1
KH		 9877 int i;
9878
9879 for (i = 0; i < coding_arg_max; i++)
9880 args[i] = Qnil;
9881
9882 plist[0] = intern (":name");
9883 plist[1] = args[coding_arg_name] = Qno_conversion;
9884 plist[2] = intern (":mnemonic");
9885 plist[3] = args[coding_arg_mnemonic] = make_number ('=');
9886 plist[4] = intern (":coding-type");
9887 plist[5] = args[coding_arg_coding_type] = Qraw_text;
9888 plist[6] = intern (":ascii-compatible-p");
9889 plist[7] = args[coding_arg_ascii_compatible_p] = Qt;
9890 plist[8] = intern (":default-char");
9891 plist[9] = args[coding_arg_default_char] = make_number (0);
8f924df7
KH		 9892 plist[10] = intern (":for-unibyte");
9893 plist[11] = args[coding_arg_for_unibyte] = Qt;
9894 plist[12] = intern (":docstring");
9895 plist[13] = build_string ("Do no conversion.\n\
2c78b7e1
KH		 9896\n\
9897When you visit a file with this coding, the file is read into a\n\
9898unibyte buffer as is, thus each byte of a file is treated as a\n\
9899character.");
8f924df7
KH		 9900 plist[14] = intern (":eol-type");
9901 plist[15] = args[coding_arg_eol_type] = Qunix;
9902 args[coding_arg_plist] = Flist (16, plist);
2c78b7e1 9903 Fdefine_coding_system_internal (coding_arg_max, args);
ae6f73fa
KH		 9904
9905 plist[1] = args[coding_arg_name] = Qundecided;
9906 plist[3] = args[coding_arg_mnemonic] = make_number ('-');
9907 plist[5] = args[coding_arg_coding_type] = Qundecided;
9908 /* This is already set.
35befdaa 9909 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
ae6f73fa
KH		 9910 plist[8] = intern (":charset-list");
9911 plist[9] = args[coding_arg_charset_list] = Fcons (Qascii, Qnil);
9912 plist[11] = args[coding_arg_for_unibyte] = Qnil;
9913 plist[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
9914 plist[15] = args[coding_arg_eol_type] = Qnil;
9915 args[coding_arg_plist] = Flist (16, plist);
9916 Fdefine_coding_system_internal (coding_arg_max, args);
2c78b7e1
KH		 9917 }
9918
2c78b7e1 9919 setup_coding_system (Qno_conversion, &safe_terminal_coding);
ff563fce
KH		 9920
9921 {
9922 int i;
9923
9924 for (i = 0; i < coding_category_max; i++)
9925 Fset (AREF (Vcoding_category_table, i), Qno_conversion);
9926 }
fcbcfb64
KH		 9927#if defined (MSDOS) || defined (WINDOWSNT)
9928 system_eol_type = Qdos;
9929#else
9930 system_eol_type = Qunix;
9931#endif
9932 staticpro (&system_eol_type);
4ed46869
KH		 9933}
9934
68c45bf0
PE		 9935char *
9936emacs_strerror (error_number)
9937 int error_number;
9938{
9939 char *str;
9940
ca9c0567 9941 synchronize_system_messages_locale ();
68c45bf0
PE		 9942 str = strerror (error_number);
9943
9944 if (! NILP (Vlocale_coding_system))
9945 {
9946 Lisp_Object dec = code_convert_string_norecord (build_string (str),
9947 Vlocale_coding_system,
9948 0);
d5db4077 9949 str = (char *) SDATA (dec);
68c45bf0
PE		 9950 }
9951
9952 return str;
9953}
9954
4ed46869 9955#endif /* emacs */
9ffd559c
KH		 9956
9957/* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
9958 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.