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