| blob | d02c27dc478214bd46416cff9247e5ed40e0136f |
1 /* Coding system handler (conversion, detection, and etc).
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /*** TABLE OF CONTENTS ***
24 0. General comments
25 1. Preamble
26 2. Emacs' internal format (emacs-mule) handlers
27 3. ISO2022 handlers
28 4. Shift-JIS and BIG5 handlers
29 5. CCL handlers
30 6. End-of-line handlers
31 7. C library functions
32 8. Emacs Lisp library functions
33 9. Post-amble
35 */
37 /*** 0. General comments ***/
40 /*** GENERAL NOTE on CODING SYSTEM ***
42 Coding system is an encoding mechanism of one or more character
43 sets. Here's a list of coding systems which Emacs can handle. When
44 we say "decode", it means converting some other coding system to
45 Emacs' internal format (emacs-internal), and when we say "encode",
46 it means converting the coding system emacs-mule to some other
47 coding system.
49 0. Emacs' internal format (emacs-mule)
51 Emacs itself holds a multi-lingual character in a buffer and a string
52 in a special format. Details are described in section 2.
54 1. ISO2022
56 The most famous coding system for multiple character sets. X's
57 Compound Text, various EUCs (Extended Unix Code), and coding
58 systems used in Internet communication such as ISO-2022-JP are
59 all variants of ISO2022. Details are described in section 3.
61 2. SJIS (or Shift-JIS or MS-Kanji-Code)
63 A coding system to encode character sets: ASCII, JISX0201, and
64 JISX0208. Widely used for PC's in Japan. Details are described in
65 section 4.
67 3. BIG5
69 A coding system to encode character sets: ASCII and Big5. Widely
70 used by Chinese (mainly in Taiwan and Hong Kong). Details are
71 described in section 4. In this file, when we write "BIG5"
72 (all uppercase), we mean the coding system, and when we write
73 "Big5" (capitalized), we mean the character set.
75 4. Raw text
77 A coding system for a text containing random 8-bit code. Emacs does
78 no code conversion on such a text except for end-of-line format.
80 5. Other
82 If a user wants to read/write a text encoded in a coding system not
83 listed above, he can supply a decoder and an encoder for it in CCL
84 (Code Conversion Language) programs. Emacs executes the CCL program
85 while reading/writing.
87 Emacs represents a coding system by a Lisp symbol that has a property
88 `coding-system'. But, before actually using the coding system, the
89 information about it is set in a structure of type `struct
90 coding_system' for rapid processing. See section 6 for more details.
92 */
94 /*** GENERAL NOTES on END-OF-LINE FORMAT ***
96 How end-of-line of a text is encoded depends on a system. For
97 instance, Unix's format is just one byte of `line-feed' code,
98 whereas DOS's format is two-byte sequence of `carriage-return' and
99 `line-feed' codes. MacOS's format is usually one byte of
100 `carriage-return'.
102 Since text characters encoding and end-of-line encoding are
103 independent, any coding system described above can take
104 any format of end-of-line. So, Emacs has information of format of
105 end-of-line in each coding-system. See section 6 for more details.
107 */
109 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
111 These functions check if a text between SRC and SRC_END is encoded
112 in the coding system category XXX. Each returns an integer value in
113 which appropriate flag bits for the category XXX is set. The flag
114 bits are defined in macros CODING_CATEGORY_MASK_XXX. Below is the
115 template of these functions. */
116 #if 0
117 int
120 {
121 ...
122 }
123 #endif
125 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
127 These functions decode SRC_BYTES length of unibyte text at SOURCE
128 encoded in CODING to Emacs' internal format. The resulting
129 multibyte text goes to a place pointed to by DESTINATION, the length
130 of which should not exceed DST_BYTES.
132 These functions set the information of original and decoded texts in
133 the members produced, produced_char, consumed, and consumed_char of
134 the structure *CODING. They also set the member result to one of
135 CODING_FINISH_XXX indicating how the decoding finished.
137 DST_BYTES zero means that source area and destination area are
138 overlapped, which means that we can produce a decoded text until it
139 reaches at the head of not-yet-decoded source text.
141 Below is a template of these functions. */
142 #if 0
143 static void
148 {
149 ...
150 }
151 #endif
153 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
155 These functions encode SRC_BYTES length text at SOURCE of Emacs'
156 internal multibyte format to CODING. The resulting unibyte text
157 goes to a place pointed to by DESTINATION, the length of which
158 should not exceed DST_BYTES.
160 These functions set the information of original and encoded texts in
161 the members produced, produced_char, consumed, and consumed_char of
162 the structure *CODING. They also set the member result to one of
163 CODING_FINISH_XXX indicating how the encoding finished.
165 DST_BYTES zero means that source area and destination area are
166 overlapped, which means that we can produce a encoded text until it
167 reaches at the head of not-yet-encoded source text.
169 Below is a template of these functions. */
170 #if 0
171 static void
176 {
177 ...
178 }
179 #endif
181 /*** COMMONLY USED MACROS ***/
183 /* The following two macros ONE_MORE_BYTE and TWO_MORE_BYTES safely
184 get one, two, and three bytes from the source text respectively.
185 If there are not enough bytes in the source, they jump to
186 `label_end_of_loop'. The caller should set variables `coding',
187 `src' and `src_end' to appropriate pointer in advance. These
188 macros are called from decoding routines `decode_coding_XXX', thus
189 it is assumed that the source text is unibyte. */
191 #define ONE_MORE_BYTE(c1) \
192 do { \
193 if (src >= src_end) \
194 { \
195 coding->result = CODING_FINISH_INSUFFICIENT_SRC; \
196 goto label_end_of_loop; \
197 } \
198 c1 = *src++; \
199 } while (0)
201 #define TWO_MORE_BYTES(c1, c2) \
202 do { \
203 if (src + 1 >= src_end) \
204 { \
205 coding->result = CODING_FINISH_INSUFFICIENT_SRC; \
206 goto label_end_of_loop; \
207 } \
208 c1 = *src++; \
209 c2 = *src++; \
210 } while (0)
213 /* Set C to the next character at the source text pointed by `src'.
214 If there are not enough characters in the source, jump to
215 `label_end_of_loop'. The caller should set variables `coding'
216 `src', `src_end', and `translation_table' to appropriate pointers
217 in advance. This macro is used in encoding routines
218 `encode_coding_XXX', thus it assumes that the source text is in
219 multibyte form except for 8-bit characters. 8-bit characters are
220 in multibyte form if coding->src_multibyte is nonzero, else they
221 are represented by a single byte. */
223 #define ONE_MORE_CHAR(c) \
224 do { \
225 int len = src_end - src; \
226 int bytes; \
227 if (len <= 0) \
228 { \
229 coding->result = CODING_FINISH_INSUFFICIENT_SRC; \
230 goto label_end_of_loop; \
231 } \
232 if (coding->src_multibyte \
233 || UNIBYTE_STR_AS_MULTIBYTE_P (src, len, bytes)) \
234 c = STRING_CHAR_AND_LENGTH (src, len, bytes); \
235 else \
236 c = *src, bytes = 1; \
237 if (!NILP (translation_table)) \
238 c = translate_char (translation_table, c, 0, 0, 0); \
239 src += bytes; \
240 } while (0)
243 /* Produce a multibyte form of characater C to `dst'. Jump to
244 `label_end_of_loop' if there's not enough space at `dst'.
246 If we are now in the middle of composition sequence, the decoded
247 character may be ALTCHAR (for the current composition). In that
248 case, the character goes to coding->cmp_data->data instead of
249 `dst'.
251 This macro is used in decoding routines. */
253 #define EMIT_CHAR(c) \
254 do { \
255 if (! COMPOSING_P (coding) \
256 || coding->composing == COMPOSITION_RELATIVE \
257 || coding->composing == COMPOSITION_WITH_RULE) \
258 { \
259 int bytes = CHAR_BYTES (c); \
260 if ((dst + bytes) > (dst_bytes ? dst_end : src)) \
261 { \
262 coding->result = CODING_FINISH_INSUFFICIENT_DST; \
263 goto label_end_of_loop; \
264 } \
265 dst += CHAR_STRING (c, dst); \
266 coding->produced_char++; \
267 } \
268 \
269 if (COMPOSING_P (coding) \
270 && coding->composing != COMPOSITION_RELATIVE) \
271 { \
272 CODING_ADD_COMPOSITION_COMPONENT (coding, c); \
273 coding->composition_rule_follows \
274 = coding->composing != COMPOSITION_WITH_ALTCHARS; \
275 } \
276 } while (0)
279 #define EMIT_ONE_BYTE(c) \
280 do { \
281 if (dst >= (dst_bytes ? dst_end : src)) \
282 { \
283 coding->result = CODING_FINISH_INSUFFICIENT_DST; \
284 goto label_end_of_loop; \
285 } \
286 *dst++ = c; \
287 } while (0)
289 #define EMIT_TWO_BYTES(c1, c2) \
290 do { \
291 if (dst + 2 > (dst_bytes ? dst_end : src)) \
292 { \
293 coding->result = CODING_FINISH_INSUFFICIENT_DST; \
294 goto label_end_of_loop; \
295 } \
296 *dst++ = c1, *dst++ = c2; \
297 } while (0)
299 #define EMIT_BYTES(from, to) \
300 do { \
301 if (dst + (to - from) > (dst_bytes ? dst_end : src)) \
302 { \
303 coding->result = CODING_FINISH_INSUFFICIENT_DST; \
304 goto label_end_of_loop; \
305 } \
306 while (from < to) \
307 *dst++ = *from++; \
308 } while (0)
310 \f
311 /*** 1. Preamble ***/
313 #ifdef emacs
314 #include <config.h>
315 #endif
317 #include <stdio.h>
319 #ifdef emacs
336 Lisp_Object Qbuffer_file_coding_system;
339 Lisp_Object Qcoding_system_history;
340 Lisp_Object Qsafe_charsets;
341 Lisp_Object Qvalid_codes;
346 Lisp_Object Qtarget_idx;
348 Lisp_Object Vselect_safe_coding_system_function;
350 /* Mnemonic string for each format of end-of-line. */
352 /* Mnemonic string to indicate format of end-of-line is not yet
353 decided. */
354 Lisp_Object eol_mnemonic_undecided;
356 /* Format of end-of-line decided by system. This is CODING_EOL_LF on
357 Unix, CODING_EOL_CRLF on DOS/Windows, and CODING_EOL_CR on Mac. */
360 #ifdef emacs
366 /* Coding system emacs-mule and raw-text are for converting only
367 end-of-line format. */
370 /* Coding-systems are handed between Emacs Lisp programs and C internal
371 routines by the following three variables. */
372 /* Coding-system for reading files and receiving data from process. */
373 Lisp_Object Vcoding_system_for_read;
374 /* Coding-system for writing files and sending data to process. */
375 Lisp_Object Vcoding_system_for_write;
376 /* Coding-system actually used in the latest I/O. */
377 Lisp_Object Vlast_coding_system_used;
379 /* A vector of length 256 which contains information about special
380 Latin codes (especially for dealing with Microsoft codes). */
381 Lisp_Object Vlatin_extra_code_table;
383 /* Flag to inhibit code conversion of end-of-line format. */
386 /* Flag to make buffer-file-coding-system inherit from process-coding. */
389 /* Coding system to be used to encode text for terminal display. */
392 /* Coding system to be used to encode text for terminal display when
393 terminal coding system is nil. */
396 /* Coding system of what is sent from terminal keyboard. */
399 /* Default coding system to be used to write a file. */
402 Lisp_Object Vfile_coding_system_alist;
403 Lisp_Object Vprocess_coding_system_alist;
404 Lisp_Object Vnetwork_coding_system_alist;
406 Lisp_Object Vlocale_coding_system;
412 /* List of symbols `coding-category-xxx' ordered by priority. */
413 Lisp_Object Vcoding_category_list;
415 /* Table of coding categories (Lisp symbols). */
416 Lisp_Object Vcoding_category_table;
418 /* Table of names of symbol for each coding-category. */
434 "coding-category-binary"
435 };
437 /* Table of pointers to coding systems corresponding to each coding
438 categories. */
441 /* Table of coding category masks. Nth element is a mask for a coding
442 cateogry of which priority is Nth. */
443 static
446 /* Flag to tell if we look up translation table on character code
447 conversion. */
448 Lisp_Object Venable_character_translation;
449 /* Standard translation table to look up on decoding (reading). */
450 Lisp_Object Vstandard_translation_table_for_decode;
451 /* Standard translation table to look up on encoding (writing). */
452 Lisp_Object Vstandard_translation_table_for_encode;
454 Lisp_Object Qtranslation_table;
455 Lisp_Object Qtranslation_table_id;
456 Lisp_Object Qtranslation_table_for_decode;
457 Lisp_Object Qtranslation_table_for_encode;
459 /* Alist of charsets vs revision number. */
460 Lisp_Object Vcharset_revision_alist;
462 /* Default coding systems used for process I/O. */
463 Lisp_Object Vdefault_process_coding_system;
465 /* Global flag to tell that we can't call post-read-conversion and
466 pre-write-conversion functions. Usually the value is zero, but it
467 is set to 1 temporarily while such functions are running. This is
468 to avoid infinite recursive call. */
471 \f
472 /*** 2. Emacs internal format (emacs-mule) handlers ***/
474 /* Emacs' internal format for encoding multiple character sets is a
475 kind of multi-byte encoding, i.e. characters are encoded by
476 variable-length sequences of one-byte codes.
478 ASCII characters and control characters (e.g. `tab', `newline') are
479 represented by one-byte sequences which are their ASCII codes, in
480 the range 0x00 through 0x7F.
482 8-bit characters of the range 0x80..0x9F are represented by
483 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
484 code + 0x20).
486 8-bit characters of the range 0xA0..0xFF are represented by
487 one-byte sequences which are their 8-bit code.
489 The other characters are represented by a sequence of `base
490 leading-code', optional `extended leading-code', and one or two
491 `position-code's. The length of the sequence is determined by the
492 base leading-code. Leading-code takes the range 0x80 through 0x9F,
493 whereas extended leading-code and position-code take the range 0xA0
494 through 0xFF. See `charset.h' for more details about leading-code
495 and position-code.
497 --- CODE RANGE of Emacs' internal format ---
498 character set range
499 ------------- -----
500 ascii 0x00..0x7F
501 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
502 eight-bit-graphic 0xA0..0xBF
503 ELSE 0x81..0x9F + [0xA0..0xFF]+
504 ---------------------------------------------
506 */
510 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
511 Check if a text is encoded in Emacs' internal format. If it is,
512 return CODING_CATEGORY_MASK_EMACS_MULE, else return 0. */
514 int
517 {
520 /* Dummy for ONE_MORE_BYTE. */
525 {
529 {
533 {
536 }
537 else
539 }
542 {
545 }
547 {
549 /* Old leading code for a composite character. */
551 else
552 {
557 bytes))
560 }
561 }
562 }
563 label_end_of_loop:
565 }
568 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
570 static void
575 {
580 /* SRC_BASE remembers the start position in source in each loop.
581 The loop will be exited when there's not enough source code, or
582 when there's not enough destination area to produce a
583 character. */
588 {
593 {
596 }
597 else
598 {
601 src++;
602 }
604 {
607 }
610 }
613 }
615 #define encode_coding_emacs_mule(coding, source, destination, src_bytes, dst_bytes) \
616 encode_eol (coding, source, destination, src_bytes, dst_bytes)
619 \f
620 /*** 3. ISO2022 handlers ***/
622 /* The following note describes the coding system ISO2022 briefly.
623 Since the intention of this note is to help understand the
624 functions in this file, some parts are NOT ACCURATE or OVERLY
625 SIMPLIFIED. For thorough understanding, please refer to the
626 original document of ISO2022.
628 ISO2022 provides many mechanisms to encode several character sets
629 in 7-bit and 8-bit environments. For 7-bite environments, all text
630 is encoded using bytes less than 128. This may make the encoded
631 text a little bit longer, but the text passes more easily through
632 several gateways, some of which strip off MSB (Most Signigant Bit).
634 There are two kinds of character sets: control character set and
635 graphic character set. The former contains control characters such
636 as `newline' and `escape' to provide control functions (control
637 functions are also provided by escape sequences). The latter
638 contains graphic characters such as 'A' and '-'. Emacs recognizes
639 two control character sets and many graphic character sets.
641 Graphic character sets are classified into one of the following
642 four classes, according to the number of bytes (DIMENSION) and
643 number of characters in one dimension (CHARS) of the set:
644 - DIMENSION1_CHARS94
645 - DIMENSION1_CHARS96
646 - DIMENSION2_CHARS94
647 - DIMENSION2_CHARS96
649 In addition, each character set is assigned an identification tag,
650 unique for each set, called "final character" (denoted as <F>
651 hereafter). The <F> of each character set is decided by ECMA(*)
652 when it is registered in ISO. The code range of <F> is 0x30..0x7F
653 (0x30..0x3F are for private use only).
655 Note (*): ECMA = European Computer Manufacturers Association
657 Here are examples of graphic character set [NAME(<F>)]:
658 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
659 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
660 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
661 o DIMENSION2_CHARS96 -- none for the moment
663 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
664 C0 [0x00..0x1F] -- control character plane 0
665 GL [0x20..0x7F] -- graphic character plane 0
666 C1 [0x80..0x9F] -- control character plane 1
667 GR [0xA0..0xFF] -- graphic character plane 1
669 A control character set is directly designated and invoked to C0 or
670 C1 by an escape sequence. The most common case is that:
671 - ISO646's control character set is designated/invoked to C0, and
672 - ISO6429's control character set is designated/invoked to C1,
673 and usually these designations/invocations are omitted in encoded
674 text. In a 7-bit environment, only C0 can be used, and a control
675 character for C1 is encoded by an appropriate escape sequence to
676 fit into the environment. All control characters for C1 are
677 defined to have corresponding escape sequences.
679 A graphic character set is at first designated to one of four
680 graphic registers (G0 through G3), then these graphic registers are
681 invoked to GL or GR. These designations and invocations can be
682 done independently. The most common case is that G0 is invoked to
683 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
684 these invocations and designations are omitted in encoded text.
685 In a 7-bit environment, only GL can be used.
687 When a graphic character set of CHARS94 is invoked to GL, codes
688 0x20 and 0x7F of the GL area work as control characters SPACE and
689 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
690 be used.
692 There are two ways of invocation: locking-shift and single-shift.
693 With locking-shift, the invocation lasts until the next different
694 invocation, whereas with single-shift, the invocation affects the
695 following character only and doesn't affect the locking-shift
696 state. Invocations are done by the following control characters or
697 escape sequences:
699 ----------------------------------------------------------------------
700 abbrev function cntrl escape seq description
701 ----------------------------------------------------------------------
702 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
703 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
704 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
705 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
706 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
707 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
708 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
709 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
710 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
711 ----------------------------------------------------------------------
712 (*) These are not used by any known coding system.
714 Control characters for these functions are defined by macros
715 ISO_CODE_XXX in `coding.h'.
717 Designations are done by the following escape sequences:
718 ----------------------------------------------------------------------
719 escape sequence description
720 ----------------------------------------------------------------------
721 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
722 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
723 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
724 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
725 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
726 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
727 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
728 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
729 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
730 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
731 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
732 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
733 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
734 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
735 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
736 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
737 ----------------------------------------------------------------------
739 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
740 of dimension 1, chars 94, and final character <F>, etc...
742 Note (*): Although these designations are not allowed in ISO2022,
743 Emacs accepts them on decoding, and produces them on encoding
744 CHARS96 character sets in a coding system which is characterized as
745 7-bit environment, non-locking-shift, and non-single-shift.
747 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
748 '(' can be omitted. We refer to this as "short-form" hereafter.
750 Now you may notice that there are a lot of ways for encoding the
751 same multilingual text in ISO2022. Actually, there exist many
752 coding systems such as Compound Text (used in X11's inter client
753 communication, ISO-2022-JP (used in Japanese internet), ISO-2022-KR
754 (used in Korean internet), EUC (Extended UNIX Code, used in Asian
755 localized platforms), and all of these are variants of ISO2022.
757 In addition to the above, Emacs handles two more kinds of escape
758 sequences: ISO6429's direction specification and Emacs' private
759 sequence for specifying character composition.
761 ISO6429's direction specification takes the following form:
762 o CSI ']' -- end of the current direction
763 o CSI '0' ']' -- end of the current direction
764 o CSI '1' ']' -- start of left-to-right text
765 o CSI '2' ']' -- start of right-to-left text
766 The control character CSI (0x9B: control sequence introducer) is
767 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
769 Character composition specification takes the following form:
770 o ESC '0' -- start relative composition
771 o ESC '1' -- end composition
772 o ESC '2' -- start rule-base composition (*)
773 o ESC '3' -- start relative composition with alternate chars (**)
774 o ESC '4' -- start rule-base composition with alternate chars (**)
775 Since these are not standard escape sequences of any ISO standard,
776 the use of them for these meaning is restricted to Emacs only.
778 (*) This form is used only in Emacs 20.5 and the older versions,
779 but the newer versions can safely decode it.
780 (**) This form is used only in Emacs 21.1 and the newer versions,
781 and the older versions can't decode it.
783 Here's a list of examples usages of these composition escape
784 sequences (categorized by `enum composition_method').
786 COMPOSITION_RELATIVE:
787 ESC 0 CHAR [ CHAR ] ESC 1
788 COMPOSITOIN_WITH_RULE:
789 ESC 2 CHAR [ RULE CHAR ] ESC 1
790 COMPOSITION_WITH_ALTCHARS:
791 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
792 COMPOSITION_WITH_RULE_ALTCHARS:
793 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
797 #define CHARSET_OK(idx, charset) \
798 (coding_system_table[idx] \
799 && (coding_system_table[idx]->safe_charsets[charset] \
800 || (CODING_SPEC_ISO_REQUESTED_DESIGNATION \
801 (coding_system_table[idx], charset) \
802 != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)))
804 #define SHIFT_OUT_OK(idx) \
805 (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
807 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
808 Check if a text is encoded in ISO2022. If it is, returns an
809 integer in which appropriate flag bits any of:
810 CODING_CATEGORY_MASK_ISO_7
811 CODING_CATEGORY_MASK_ISO_7_TIGHT
812 CODING_CATEGORY_MASK_ISO_8_1
813 CODING_CATEGORY_MASK_ISO_8_2
814 CODING_CATEGORY_MASK_ISO_7_ELSE
815 CODING_CATEGORY_MASK_ISO_8_ELSE
816 are set. If a code which should never appear in ISO2022 is found,
817 returns 0. */
819 int
822 {
827 /* Dummy for ONE_MORE_BYTE. */
833 {
836 {
841 {
842 /* Designation sequence for a charset of dimension 1. */
846 /* Invalid designation sequence. Just ignore. */
849 }
851 {
852 /* Designation sequence for a charset of dimension 2. */
855 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
858 {
862 /* Invalid designation sequence. Just ignore. */
865 }
866 else
867 /* Invalid designation sequence. Just ignore. */
869 }
871 {
872 /* ESC <Fe> for SS2 or SS3. */
875 }
877 {
878 /* ESC <Fp> for start/end composition. */
881 }
882 else
883 /* Invalid escape sequence. Just ignore. */
886 /* We found a valid designation sequence for CHARSET. */
890 else
894 else
898 else
902 else
912 {
913 /* Locking shift out. */
916 }
922 {
923 /* Locking shift in. */
926 }
933 {
937 {
945 }
948 {
955 }
958 }
963 {
966 }
968 {
972 {
983 }
984 else
986 }
987 else
988 {
989 mask &= ~(CODING_CATEGORY_MASK_ISO_7BIT
992 /* Check the length of succeeding codes of the range
993 0xA0..0FF. If the byte length is odd, we exclude
994 CODING_CATEGORY_MASK_ISO_8_2. We can check this only
995 when we are not single shifting. */
998 {
1001 {
1005 i++;
1006 }
1010 else
1012 }
1013 }
1015 }
1016 }
1017 label_end_of_loop:
1019 }
1021 /* Decode a character of which charset is CHARSET, the 1st position
1022 code is C1, the 2nd position code is C2, and return the decoded
1023 character code. If the variable `translation_table' is non-nil,
1024 returned the translated code. */
1026 #define DECODE_ISO_CHARACTER(charset, c1, c2) \
1027 (NILP (translation_table) \
1028 ? MAKE_CHAR (charset, c1, c2) \
1029 : translate_char (translation_table, -1, charset, c1, c2))
1031 /* Set designation state into CODING. */
1032 #define DECODE_DESIGNATION(reg, dimension, chars, final_char) \
1033 do { \
1034 int charset; \
1035 \
1037 goto label_invalid_code; \
1038 charset = ISO_CHARSET_TABLE (make_number (dimension), \
1039 make_number (chars), \
1040 make_number (final_char)); \
1041 if (charset >= 0 \
1042 && (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg \
1043 || coding->safe_charsets[charset])) \
1044 { \
1045 if (coding->spec.iso2022.last_invalid_designation_register == 0 \
1046 && reg == 0 \
1047 && charset == CHARSET_ASCII) \
1048 { \
1049 /* We should insert this designation sequence as is so \
1051 coding->spec.iso2022.last_invalid_designation_register = -1; \
1052 goto label_invalid_code; \
1053 } \
1054 coding->spec.iso2022.last_invalid_designation_register = -1; \
1055 if ((coding->mode & CODING_MODE_DIRECTION) \
1056 && CHARSET_REVERSE_CHARSET (charset) >= 0) \
1057 charset = CHARSET_REVERSE_CHARSET (charset); \
1058 CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset; \
1059 } \
1060 else \
1061 { \
1062 coding->spec.iso2022.last_invalid_designation_register = reg; \
1063 goto label_invalid_code; \
1064 } \
1065 } while (0)
1067 /* Allocate a memory block for storing information about compositions.
1068 The block is chained to the already allocated blocks. */
1070 void
1074 {
1086 }
1088 /* Record the starting position START and METHOD of one composition. */
1090 #define CODING_ADD_COMPOSITION_START(coding, start, method) \
1091 do { \
1092 struct composition_data *cmp_data = coding->cmp_data; \
1093 int *data = cmp_data->data + cmp_data->used; \
1094 coding->cmp_data_start = cmp_data->used; \
1095 data[0] = -1; \
1096 data[1] = cmp_data->char_offset + start; \
1097 data[3] = (int) method; \
1098 cmp_data->used += 4; \
1099 } while (0)
1101 /* Record the ending position END of the current composition. */
1103 #define CODING_ADD_COMPOSITION_END(coding, end) \
1104 do { \
1105 struct composition_data *cmp_data = coding->cmp_data; \
1106 int *data = cmp_data->data + coding->cmp_data_start; \
1107 data[0] = cmp_data->used - coding->cmp_data_start; \
1108 data[2] = cmp_data->char_offset + end; \
1109 } while (0)
1111 /* Record one COMPONENT (alternate character or composition rule). */
1113 #define CODING_ADD_COMPOSITION_COMPONENT(coding, component) \
1114 (coding->cmp_data->data[coding->cmp_data->used++] = component)
1116 /* Handle compositoin start sequence ESC 0, ESC 2, ESC 3, or ESC 4. */
1118 #define DECODE_COMPOSITION_START(c1) \
1119 do { \
1120 if (coding->composing == COMPOSITION_DISABLED) \
1121 { \
1122 *dst++ = ISO_CODE_ESC; \
1123 *dst++ = c1 & 0x7f; \
1124 coding->produced_char += 2; \
1125 } \
1126 else if (!COMPOSING_P (coding)) \
1127 { \
1128 /* This is surely the start of a composition. We must be sure \
1129 that coding->cmp_data has enough space to store the \
1130 information about the composition. If not, terminate the \
1131 current decoding loop, allocate one more memory block for \
1132 coding->cmp_data in the calller, then start the decoding \
1133 loop again. We can't allocate memory here directly because \
1135 if (!coding->cmp_data \
1136 || (coding->cmp_data->used + COMPOSITION_DATA_MAX_BUNCH_LENGTH \
1137 >= COMPOSITION_DATA_SIZE)) \
1138 { \
1139 coding->result = CODING_FINISH_INSUFFICIENT_CMP; \
1140 goto label_end_of_loop; \
1141 } \
1145 : COMPOSITION_WITH_RULE_ALTCHARS); \
1146 CODING_ADD_COMPOSITION_START (coding, coding->produced_char, \
1147 coding->composing); \
1148 coding->composition_rule_follows = 0; \
1149 } \
1150 else \
1151 { \
1152 /* We are already handling a composition. If the method is \
1153 the following two, the codes following the current escape \
1155 if (coding->composing == COMPOSITION_WITH_ALTCHARS \
1156 || coding->composing == COMPOSITION_WITH_RULE_ALTCHARS) \
1157 { \
1158 coding->composing = COMPOSITION_RELATIVE; \
1159 coding->composition_rule_follows = 0; \
1160 } \
1161 } \
1162 } while (0)
1164 /* Handle compositoin end sequence ESC 1. */
1166 #define DECODE_COMPOSITION_END(c1) \
1167 do { \
1168 if (coding->composing == COMPOSITION_DISABLED) \
1169 { \
1170 *dst++ = ISO_CODE_ESC; \
1171 *dst++ = c1; \
1172 coding->produced_char += 2; \
1173 } \
1174 else \
1175 { \
1176 CODING_ADD_COMPOSITION_END (coding, coding->produced_char); \
1177 coding->composing = COMPOSITION_NO; \
1178 } \
1179 } while (0)
1181 /* Decode a composition rule from the byte C1 (and maybe one more byte
1182 from SRC) and store one encoded composition rule in
1183 coding->cmp_data. */
1185 #define DECODE_COMPOSITION_RULE(c1) \
1186 do { \
1187 int rule = 0; \
1188 (c1) -= 32; \
1190 { \
1191 int gref = (c1) / 9; \
1192 int nref = (c1) % 9; \
1193 if (gref == 4) gref = 10; \
1194 if (nref == 4) nref = 10; \
1195 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
1196 } \
1198 { \
1199 ONE_MORE_BYTE (c2); \
1200 rule = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
1201 } \
1202 CODING_ADD_COMPOSITION_COMPONENT (coding, rule); \
1203 coding->composition_rule_follows = 0; \
1204 } while (0)
1207 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
1209 static void
1214 {
1219 /* Charsets invoked to graphic plane 0 and 1 respectively. */
1222 /* SRC_BASE remembers the start position in source in each loop.
1223 The loop will be exited when there's not enough source code
1224 (within macro ONE_MORE_BYTE), or when there's not enough
1225 destination area to produce a character (within macro
1226 EMIT_CHAR). */
1229 Lisp_Object translation_table;
1233 else
1234 {
1238 }
1243 {
1249 /* We produce no character or one character. */
1251 {
1254 {
1257 }
1259 {
1260 /* This is SPACE or DEL. */
1263 }
1264 /* This is a graphic character, we fall down ... */
1268 {
1271 }
1279 /* This is a graphic character, we fall down ... */
1291 /* All ISO2022 control characters in this class have the
1292 same representation in Emacs internal format. */
1297 {
1300 }
1316 {
1319 {
1321 {
1324 }
1325 src--;
1327 }
1328 }
1351 /* SS2 is handled as an escape sequence of ESC 'N' */
1358 /* SS2 is handled as an escape sequence of ESC 'O' */
1363 /* CSI is handled as an escape sequence of ESC '[' ... */
1369 label_escape_sequence:
1370 /* Escape sequences handled by Emacs are invocation,
1371 designation, direction specification, and character
1372 composition specification. */
1374 {
1391 or JISX0208.1980 */
1393 }
1398 }
1403 }
1404 else
1406 /* We must update these variables now. */
1454 /* For the moment, nested direction is not supported.
1455 So, `coding->mode & CODING_MODE_DIRECTION' zero means
1456 left-to-right, and nozero means right-to-left. */
1459 {
1468 else
1476 else
1482 }
1492 }
1497 }
1498 else
1500 /* We must update these variables now. */
1504 }
1505 }
1507 /* Now we know CHARSET and 1st position code C1 of a character.
1508 Produce a multibyte sequence for that character while getting
1509 2nd position code C2 if necessary. */
1511 {
1514 /* C2 is not in a valid range. */
1516 }
1521 label_invalid_code:
1528 }
1530 label_end_of_loop:
1534 }
1537 /* ISO2022 encoding stuff. */
1539 /*
1540 It is not enough to say just "ISO2022" on encoding, we have to
1541 specify more details. In Emacs, each coding system of ISO2022
1542 variant has the following specifications:
1543 1. Initial designation to G0 thru G3.
1544 2. Allows short-form designation?
1545 3. ASCII should be designated to G0 before control characters?
1546 4. ASCII should be designated to G0 at end of line?
1547 5. 7-bit environment or 8-bit environment?
1548 6. Use locking-shift?
1549 7. Use Single-shift?
1550 And the following two are only for Japanese:
1551 8. Use ASCII in place of JIS0201-1976-Roman?
1552 9. Use JISX0208-1983 in place of JISX0208-1978?
1553 These specifications are encoded in `coding->flags' as flag bits
1554 defined by macros CODING_FLAG_ISO_XXX. See `coding.h' for more
1555 details.
1556 */
1558 /* Produce codes (escape sequence) for designating CHARSET to graphic
1559 register REG at DST, and increment DST. If <final-char> of CHARSET is
1560 '@', 'A', or 'B' and the coding system CODING allows, produce
1561 designation sequence of short-form. */
1563 #define ENCODE_DESIGNATION(charset, reg, coding) \
1564 do { \
1565 unsigned char final_char = CHARSET_ISO_FINAL_CHAR (charset); \
1568 int revision = CODING_SPEC_ISO_REVISION_NUMBER(coding, charset); \
1569 \
1570 if (revision < 255) \
1571 { \
1572 *dst++ = ISO_CODE_ESC; \
1575 } \
1576 *dst++ = ISO_CODE_ESC; \
1577 if (CHARSET_DIMENSION (charset) == 1) \
1578 { \
1579 if (CHARSET_CHARS (charset) == 94) \
1580 *dst++ = (unsigned char) (intermediate_char_94[reg]); \
1581 else \
1582 *dst++ = (unsigned char) (intermediate_char_96[reg]); \
1583 } \
1584 else \
1585 { \
1587 if (CHARSET_CHARS (charset) == 94) \
1588 { \
1589 if (! (coding->flags & CODING_FLAG_ISO_SHORT_FORM) \
1590 || reg != 0 \
1592 *dst++ = (unsigned char) (intermediate_char_94[reg]); \
1593 } \
1594 else \
1595 *dst++ = (unsigned char) (intermediate_char_96[reg]); \
1596 } \
1597 *dst++ = final_char; \
1598 CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset; \
1599 } while (0)
1601 /* The following two macros produce codes (control character or escape
1602 sequence) for ISO2022 single-shift functions (single-shift-2 and
1603 single-shift-3). */
1605 #define ENCODE_SINGLE_SHIFT_2 \
1606 do { \
1607 if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
1609 else \
1610 *dst++ = ISO_CODE_SS2; \
1611 CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1; \
1612 } while (0)
1614 #define ENCODE_SINGLE_SHIFT_3 \
1615 do { \
1616 if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
1618 else \
1619 *dst++ = ISO_CODE_SS3; \
1620 CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1; \
1621 } while (0)
1623 /* The following four macros produce codes (control character or
1624 escape sequence) for ISO2022 locking-shift functions (shift-in,
1625 shift-out, locking-shift-2, and locking-shift-3). */
1627 #define ENCODE_SHIFT_IN \
1628 do { \
1629 *dst++ = ISO_CODE_SI; \
1630 CODING_SPEC_ISO_INVOCATION (coding, 0) = 0; \
1631 } while (0)
1633 #define ENCODE_SHIFT_OUT \
1634 do { \
1635 *dst++ = ISO_CODE_SO; \
1636 CODING_SPEC_ISO_INVOCATION (coding, 0) = 1; \
1637 } while (0)
1639 #define ENCODE_LOCKING_SHIFT_2 \
1640 do { \
1642 CODING_SPEC_ISO_INVOCATION (coding, 0) = 2; \
1643 } while (0)
1645 #define ENCODE_LOCKING_SHIFT_3 \
1646 do { \
1648 CODING_SPEC_ISO_INVOCATION (coding, 0) = 3; \
1649 } while (0)
1651 /* Produce codes for a DIMENSION1 character whose character set is
1652 CHARSET and whose position-code is C1. Designation and invocation
1653 sequences are also produced in advance if necessary. */
1655 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
1656 do { \
1657 if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding)) \
1658 { \
1659 if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
1660 *dst++ = c1 & 0x7F; \
1661 else \
1662 *dst++ = c1 | 0x80; \
1663 CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0; \
1664 break; \
1665 } \
1666 else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0)) \
1667 { \
1668 *dst++ = c1 & 0x7F; \
1669 break; \
1670 } \
1671 else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1)) \
1672 { \
1673 *dst++ = c1 | 0x80; \
1674 break; \
1675 } \
1676 else if (coding->flags & CODING_FLAG_ISO_SAFE \
1677 && !coding->safe_charsets[charset]) \
1678 { \
1679 /* We should not encode this character, instead produce one or \
1681 *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION; \
1682 if (CHARSET_WIDTH (charset) == 2) \
1683 *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION; \
1684 break; \
1685 } \
1686 else \
1687 /* Since CHARSET is not yet invoked to any graphic planes, we \
1688 must invoke it, or, at first, designate it to some graphic \
1689 register. Then repeat the loop to actually produce the \
1691 dst = encode_invocation_designation (charset, coding, dst); \
1692 } while (1)
1694 /* Produce codes for a DIMENSION2 character whose character set is
1695 CHARSET and whose position-codes are C1 and C2. Designation and
1696 invocation codes are also produced in advance if necessary. */
1698 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
1699 do { \
1700 if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding)) \
1701 { \
1702 if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
1703 *dst++ = c1 & 0x7F, *dst++ = c2 & 0x7F; \
1704 else \
1705 *dst++ = c1 | 0x80, *dst++ = c2 | 0x80; \
1706 CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0; \
1707 break; \
1708 } \
1709 else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0)) \
1710 { \
1711 *dst++ = c1 & 0x7F, *dst++= c2 & 0x7F; \
1712 break; \
1713 } \
1714 else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1)) \
1715 { \
1716 *dst++ = c1 | 0x80, *dst++= c2 | 0x80; \
1717 break; \
1718 } \
1719 else if (coding->flags & CODING_FLAG_ISO_SAFE \
1720 && !coding->safe_charsets[charset]) \
1721 { \
1722 /* We should not encode this character, instead produce one or \
1724 *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION; \
1725 if (CHARSET_WIDTH (charset) == 2) \
1726 *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION; \
1727 break; \
1728 } \
1729 else \
1730 /* Since CHARSET is not yet invoked to any graphic planes, we \
1731 must invoke it, or, at first, designate it to some graphic \
1732 register. Then repeat the loop to actually produce the \
1734 dst = encode_invocation_designation (charset, coding, dst); \
1735 } while (1)
1737 #define ENCODE_ISO_CHARACTER(charset, c1, c2) \
1738 do { \
1739 int alt_charset = charset; \
1740 \
1741 if (CHARSET_DEFINED_P (charset)) \
1742 { \
1743 if (CHARSET_DIMENSION (charset) == 1) \
1744 { \
1745 if (charset == CHARSET_ASCII \
1746 && coding->flags & CODING_FLAG_ISO_USE_ROMAN) \
1747 alt_charset = charset_latin_jisx0201; \
1748 ENCODE_ISO_CHARACTER_DIMENSION1 (alt_charset, c1); \
1749 } \
1750 else \
1751 { \
1752 if (charset == charset_jisx0208 \
1753 && coding->flags & CODING_FLAG_ISO_USE_OLDJIS) \
1754 alt_charset = charset_jisx0208_1978; \
1755 ENCODE_ISO_CHARACTER_DIMENSION2 (alt_charset, c1, c2); \
1756 } \
1757 } \
1758 else \
1759 { \
1760 *dst++ = c1; \
1761 if (c2 >= 0) \
1762 *dst++ = c2; \
1763 } \
1764 } while (0)
1766 /* Produce designation and invocation codes at a place pointed by DST
1767 to use CHARSET. The element `spec.iso2022' of *CODING is updated.
1768 Return new DST. */
1775 {
1778 /* At first, check designations. */
1784 {
1785 /* CHARSET is not yet designated to any graphic registers. */
1786 /* At first check the requested designation. */
1789 /* Since CHARSET requests no special designation, designate it
1790 to graphic register 0. */
1794 }
1798 {
1799 /* Since the graphic register REG is not invoked to any graphic
1800 planes, invoke it to graphic plane 0. */
1802 {
1804 ENCODE_SHIFT_IN;
1808 ENCODE_SHIFT_OUT;
1813 ENCODE_SINGLE_SHIFT_2;
1814 else
1815 ENCODE_LOCKING_SHIFT_2;
1820 ENCODE_SINGLE_SHIFT_3;
1821 else
1822 ENCODE_LOCKING_SHIFT_3;
1824 }
1825 }
1828 }
1830 /* Produce 2-byte codes for encoded composition rule RULE. */
1832 #define ENCODE_COMPOSITION_RULE(rule) \
1833 do { \
1834 int gref, nref; \
1835 COMPOSITION_DECODE_RULE (rule, gref, nref); \
1836 *dst++ = 32 + 81 + gref; \
1837 *dst++ = 32 + nref; \
1838 } while (0)
1840 /* Produce codes for indicating the start of a composition sequence
1841 (ESC 0, ESC 3, or ESC 4). DATA points to an array of integers
1842 which specify information about the composition. See the comment
1843 in coding.h for the format of DATA. */
1845 #define ENCODE_COMPOSITION_START(coding, data) \
1846 do { \
1847 coding->composing = data[3]; \
1848 *dst++ = ISO_CODE_ESC; \
1849 if (coding->composing == COMPOSITION_RELATIVE) \
1851 else \
1852 { \
1853 *dst++ = (coding->composing == COMPOSITION_WITH_ALTCHARS \
1855 coding->cmp_data_index = coding->cmp_data_start + 4; \
1856 coding->composition_rule_follows = 0; \
1857 } \
1858 } while (0)
1860 /* Produce codes for indicating the end of the current composition. */
1862 #define ENCODE_COMPOSITION_END(coding, data) \
1863 do { \
1864 *dst++ = ISO_CODE_ESC; \
1866 coding->cmp_data_start += data[0]; \
1867 coding->composing = COMPOSITION_NO; \
1868 if (coding->cmp_data_start == coding->cmp_data->used \
1869 && coding->cmp_data->next) \
1870 { \
1871 coding->cmp_data = coding->cmp_data->next; \
1872 coding->cmp_data_start = 0; \
1873 } \
1874 } while (0)
1876 /* Produce composition start sequence ESC 0. Here, this sequence
1877 doesn't mean the start of a new composition but means that we have
1878 just produced components (alternate chars and composition rules) of
1879 the composition and the actual text follows in SRC. */
1881 #define ENCODE_COMPOSITION_FAKE_START(coding) \
1882 do { \
1883 *dst++ = ISO_CODE_ESC; \
1885 coding->composing = COMPOSITION_RELATIVE; \
1886 } while (0)
1888 /* The following three macros produce codes for indicating direction
1889 of text. */
1890 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
1891 do { \
1892 if (coding->flags == CODING_FLAG_ISO_SEVEN_BITS) \
1894 else \
1895 *dst++ = ISO_CODE_CSI; \
1896 } while (0)
1898 #define ENCODE_DIRECTION_R2L \
1901 #define ENCODE_DIRECTION_L2R \
1904 /* Produce codes for designation and invocation to reset the graphic
1905 planes and registers to initial state. */
1906 #define ENCODE_RESET_PLANE_AND_REGISTER \
1907 do { \
1908 int reg; \
1909 if (CODING_SPEC_ISO_INVOCATION (coding, 0) != 0) \
1910 ENCODE_SHIFT_IN; \
1911 for (reg = 0; reg < 4; reg++) \
1912 if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg) >= 0 \
1913 && (CODING_SPEC_ISO_DESIGNATION (coding, reg) \
1914 != CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg))) \
1915 ENCODE_DESIGNATION \
1916 (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg), reg, coding); \
1917 } while (0)
1919 /* Produce designation sequences of charsets in the line started from
1920 SRC to a place pointed by DST, and return updated DST.
1922 If the current block ends before any end-of-line, we may fail to
1923 find all the necessary designations. */
1928 Lisp_Object translation_table;
1930 {
1932 /* Table of charsets to be designated to each graphic register. */
1939 {
1947 {
1948 found++;
1950 }
1951 }
1953 label_end_of_loop:
1955 {
1960 }
1963 }
1965 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
1967 static void
1972 {
1977 /* Since the maximum bytes produced by each loop is 20, we subtract 19
1978 from DST_END to assure overflow checking is necessary only at the
1979 head of loop. */
1981 /* SRC_BASE remembers the start position in source in each loop.
1982 The loop will be exited when there's not enough source text to
1983 analyze multi-byte codes (within macro ONE_MORE_CHAR), or when
1984 there's not enough destination area to produce encoded codes
1985 (within macro EMIT_BYTES). */
1988 Lisp_Object translation_table;
1992 else
1993 {
1997 }
2002 {
2008 {
2011 }
2015 {
2016 /* We have to produce designation sequences if any now. */
2020 }
2022 /* Check composition start and end. */
2025 {
2031 {
2033 {
2037 }
2038 }
2040 {
2041 /* COMPOSITION_WITH_ALTCHARS or COMPOSITION_WITH_RULE_ALTCHAR */
2043 /* We have consumed components of the composition.
2044 What follows in SRC is the compositions's base
2045 text. */
2047 else
2048 {
2051 {
2054 }
2055 else
2056 {
2061 }
2063 }
2064 }
2066 {
2068 {
2071 }
2072 }
2073 }
2077 /* Now encode the character C. */
2079 {
2081 {
2083 {
2085 ENCODE_RESET_PLANE_AND_REGISTER;
2088 }
2089 /* fall down to treat '\r' as '\n' ... */
2091 }
2093 {
2095 ENCODE_RESET_PLANE_AND_REGISTER;
2105 else
2108 }
2109 else
2110 {
2112 ENCODE_RESET_PLANE_AND_REGISTER;
2114 }
2115 }
2119 {
2122 }
2123 else
2124 {
2127 }
2130 }
2132 label_end_of_loop:
2135 }
2137 \f
2138 /*** 4. SJIS and BIG5 handlers ***/
2140 /* Although SJIS and BIG5 are not ISO's coding system, they are used
2141 quite widely. So, for the moment, Emacs supports them in the bare
2142 C code. But, in the future, they may be supported only by CCL. */
2144 /* SJIS is a coding system encoding three character sets: ASCII, right
2145 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
2146 as is. A character of charset katakana-jisx0201 is encoded by
2147 "position-code + 0x80". A character of charset japanese-jisx0208
2148 is encoded in 2-byte but two position-codes are divided and shifted
2149 so that it fit in the range below.
2151 --- CODE RANGE of SJIS ---
2152 (character set) (range)
2153 ASCII 0x00 .. 0x7F
2154 KATAKANA-JISX0201 0xA0 .. 0xDF
2155 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
2156 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
2157 -------------------------------
2159 */
2161 /* BIG5 is a coding system encoding two character sets: ASCII and
2162 Big5. An ASCII character is encoded as is. Big5 is a two-byte
2163 character set and is encoded in two-byte.
2165 --- CODE RANGE of BIG5 ---
2166 (character set) (range)
2167 ASCII 0x00 .. 0x7F
2168 Big5 (1st byte) 0xA1 .. 0xFE
2169 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
2170 --------------------------
2172 Since the number of characters in Big5 is larger than maximum
2173 characters in Emacs' charset (96x96), it can't be handled as one
2174 charset. So, in Emacs, Big5 is divided into two: `charset-big5-1'
2175 and `charset-big5-2'. Both are DIMENSION2 and CHARS94. The former
2176 contains frequently used characters and the latter contains less
2177 frequently used characters. */
2179 /* Macros to decode or encode a character of Big5 in BIG5. B1 and B2
2180 are the 1st and 2nd position-codes of Big5 in BIG5 coding system.
2181 C1 and C2 are the 1st and 2nd position-codes of of Emacs' internal
2182 format. CHARSET is `charset_big5_1' or `charset_big5_2'. */
2184 /* Number of Big5 characters which have the same code in 1st byte. */
2185 #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
2187 #define DECODE_BIG5(b1, b2, charset, c1, c2) \
2188 do { \
2189 unsigned int temp \
2190 = (b1 - 0xA1) * BIG5_SAME_ROW + b2 - (b2 < 0x7F ? 0x40 : 0x62); \
2191 if (b1 < 0xC9) \
2192 charset = charset_big5_1; \
2193 else \
2194 { \
2195 charset = charset_big5_2; \
2196 temp -= (0xC9 - 0xA1) * BIG5_SAME_ROW; \
2197 } \
2198 c1 = temp / (0xFF - 0xA1) + 0x21; \
2199 c2 = temp % (0xFF - 0xA1) + 0x21; \
2200 } while (0)
2202 #define ENCODE_BIG5(charset, c1, c2, b1, b2) \
2203 do { \
2204 unsigned int temp = (c1 - 0x21) * (0xFF - 0xA1) + (c2 - 0x21); \
2205 if (charset == charset_big5_2) \
2206 temp += BIG5_SAME_ROW * (0xC9 - 0xA1); \
2207 b1 = temp / BIG5_SAME_ROW + 0xA1; \
2208 b2 = temp % BIG5_SAME_ROW; \
2209 b2 += b2 < 0x3F ? 0x40 : 0x62; \
2210 } while (0)
2212 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2213 Check if a text is encoded in SJIS. If it is, return
2214 CODING_CATEGORY_MASK_SJIS, else return 0. */
2216 int
2219 {
2221 /* Dummy for ONE_MORE_BYTE. */
2226 {
2229 {
2233 }
2234 }
2235 label_end_of_loop:
2237 }
2239 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2240 Check if a text is encoded in BIG5. If it is, return
2241 CODING_CATEGORY_MASK_BIG5, else return 0. */
2243 int
2246 {
2248 /* Dummy for ONE_MORE_BYTE. */
2253 {
2256 {
2260 }
2261 }
2262 label_end_of_loop:
2264 }
2266 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2267 Check if a text is encoded in UTF-8. If it is, return
2268 CODING_CATEGORY_MASK_UTF_8, else return 0. */
2270 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
2271 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
2272 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
2273 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
2274 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
2275 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
2276 #define UTF_8_6_OCTET_LEADING_P(c) (((c) & 0xFE) == 0xFC)
2278 int
2281 {
2284 /* Dummy for ONE_MORE_BYTE. */
2289 {
2303 else
2306 do
2307 {
2311 seq_maybe_bytes--;
2312 }
2314 }
2316 label_end_of_loop:
2318 }
2320 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2321 Check if a text is encoded in UTF-16 Big Endian (endian == 1) or
2322 Little Endian (otherwise). If it is, return
2323 CODING_CATEGORY_MASK_UTF_16_BE or CODING_CATEGORY_MASK_UTF_16_LE,
2324 else return 0. */
2326 #define UTF_16_INVALID_P(val) \
2327 (((val) == 0xFFFE) \
2328 || ((val) == 0xFFFF))
2330 #define UTF_16_HIGH_SURROGATE_P(val) \
2331 (((val) & 0xD800) == 0xD800)
2333 #define UTF_16_LOW_SURROGATE_P(val) \
2334 (((val) & 0xDC00) == 0xDC00)
2336 int
2339 {
2341 /* Dummy for TWO_MORE_BYTES. */
2352 label_end_of_loop:
2354 }
2356 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
2357 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
2359 static void
2366 {
2371 /* SRC_BASE remembers the start position in source in each loop.
2372 The loop will be exited when there's not enough source code
2373 (within macro ONE_MORE_BYTE), or when there's not enough
2374 destination area to produce a character (within macro
2375 EMIT_CHAR). */
2377 Lisp_Object translation_table;
2381 else
2382 {
2386 }
2390 {
2397 {
2400 {
2402 {
2404 {
2410 {
2413 }
2414 else
2415 /* To process C2 again, SRC is subtracted by 1. */
2416 src--;
2417 }
2420 }
2425 {
2428 }
2429 }
2430 }
2431 else
2432 {
2434 {
2438 {
2439 /* SJIS -> JISX0208 */
2445 }
2446 else
2447 /* SJIS -> JISX0201-Kana */
2449 }
2450 else
2451 {
2452 /* BIG5 -> Big5 */
2459 }
2460 }
2466 label_invalid_code:
2471 }
2473 label_end_of_loop:
2477 }
2479 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
2480 This function can encode charsets `ascii', `katakana-jisx0201',
2481 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
2482 are sure that all these charsets are registered as official charset
2483 (i.e. do not have extended leading-codes). Characters of other
2484 charsets are produced without any encoding. If SJIS_P is 1, encode
2485 SJIS text, else encode BIG5 text. */
2487 static void
2494 {
2499 /* SRC_BASE remembers the start position in source in each loop.
2500 The loop will be exited when there's not enough source text to
2501 analyze multi-byte codes (within macro ONE_MORE_CHAR), or when
2502 there's not enough destination area to produce encoded codes
2503 (within macro EMIT_BYTES). */
2505 Lisp_Object translation_table;
2509 else
2510 {
2514 }
2517 {
2523 /* Now encode the character C. */
2525 {
2527 {
2530 {
2533 }
2537 {
2540 }
2545 }
2546 }
2547 else
2548 {
2551 {
2554 {
2557 }
2560 else
2561 /* There's no way other than producing the internal
2562 codes as is. */
2564 }
2565 else
2566 {
2568 {
2571 }
2572 else
2573 /* There's no way other than producing the internal
2574 codes as is. */
2576 }
2577 }
2579 }
2581 label_end_of_loop:
2584 }
2586 \f
2587 /*** 5. CCL handlers ***/
2589 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2590 Check if a text is encoded in a coding system of which
2591 encoder/decoder are written in CCL program. If it is, return
2592 CODING_CATEGORY_MASK_CCL, else return 0. */
2594 int
2597 {
2600 /* Dummy for ONE_MORE_BYTE. */
2604 /* No coding system is assigned to coding-category-ccl. */
2610 {
2614 }
2615 label_end_of_loop:
2617 }
2619 \f
2620 /*** 6. End-of-line handlers ***/
2622 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2624 static void
2629 {
2634 Lisp_Object translation_table;
2635 /* SRC_BASE remembers the start position in source in each loop.
2636 The loop will be exited when there's not enough source code
2637 (within macro ONE_MORE_BYTE), or when there's not enough
2638 destination area to produce a character (within macro
2639 EMIT_CHAR). */
2645 {
2648 {
2652 {
2655 {
2657 {
2660 }
2661 src--;
2663 }
2664 }
2667 {
2670 }
2672 }
2677 {
2681 {
2683 {
2686 }
2687 }
2691 }
2696 {
2700 }
2701 }
2703 label_end_of_loop:
2707 }
2709 /* See "GENERAL NOTES about `encode_coding_XXX ()' functions". Encode
2710 format of end-of-line according to `coding->eol_type'. It also
2711 convert multibyte form 8-bit characers to unibyte if
2712 CODING->src_multibyte is nonzero. If `coding->mode &
2713 CODING_MODE_SELECTIVE_DISPLAY' is nonzero, code '\r' in source text
2714 also means end-of-line. */
2716 static void
2721 {
2726 Lisp_Object translation_table;
2727 /* SRC_BASE remembers the start position in source in each loop.
2728 The loop will be exited when there's not enough source text to
2729 analyze multi-byte codes (within macro ONE_MORE_CHAR), or when
2730 there's not enough destination area to produce encoded codes
2731 (within macro EMIT_BYTES). */
2739 {
2740 src_end--;
2741 src_bytes--;
2743 }
2746 {
2748 {
2755 else
2757 }
2759 label_end_of_loop:
2760 ;
2761 }
2762 else
2763 {
2765 {
2769 }
2770 else
2771 {
2774 dst_bytes--;
2779 }
2781 {
2784 }
2786 {
2789 }
2790 }
2796 }
2798 \f
2799 /*** 7. C library functions ***/
2801 /* In Emacs Lisp, coding system is represented by a Lisp symbol which
2802 has a property `coding-system'. The value of this property is a
2803 vector of length 5 (called as coding-vector). Among elements of
2804 this vector, the first (element[0]) and the fifth (element[4])
2805 carry important information for decoding/encoding. Before
2806 decoding/encoding, this information should be set in fields of a
2807 structure of type `coding_system'.
2809 A value of property `coding-system' can be a symbol of another
2810 subsidiary coding-system. In that case, Emacs gets coding-vector
2811 from that symbol.
2813 `element[0]' contains information to be set in `coding->type'. The
2814 value and its meaning is as follows:
2816 0 -- coding_type_emacs_mule
2817 1 -- coding_type_sjis
2818 2 -- coding_type_iso2022
2819 3 -- coding_type_big5
2820 4 -- coding_type_ccl encoder/decoder written in CCL
2821 nil -- coding_type_no_conversion
2822 t -- coding_type_undecided (automatic conversion on decoding,
2823 no-conversion on encoding)
2825 `element[4]' contains information to be set in `coding->flags' and
2826 `coding->spec'. The meaning varies by `coding->type'.
2828 If `coding->type' is `coding_type_iso2022', element[4] is a vector
2829 of length 32 (of which the first 13 sub-elements are used now).
2830 Meanings of these sub-elements are:
2832 sub-element[N] where N is 0 through 3: to be set in `coding->spec.iso2022'
2833 If the value is an integer of valid charset, the charset is
2834 assumed to be designated to graphic register N initially.
2836 If the value is minus, it is a minus value of charset which
2837 reserves graphic register N, which means that the charset is
2838 not designated initially but should be designated to graphic
2839 register N just before encoding a character in that charset.
2841 If the value is nil, graphic register N is never used on
2842 encoding.
2844 sub-element[N] where N is 4 through 11: to be set in `coding->flags'
2845 Each value takes t or nil. See the section ISO2022 of
2846 `coding.h' for more information.
2848 If `coding->type' is `coding_type_big5', element[4] is t to denote
2849 BIG5-ETen or nil to denote BIG5-HKU.
2851 If `coding->type' takes the other value, element[4] is ignored.
2853 Emacs Lisp's coding system also carries information about format of
2854 end-of-line in a value of property `eol-type'. If the value is
2855 integer, 0 means CODING_EOL_LF, 1 means CODING_EOL_CRLF, and 2
2856 means CODING_EOL_CR. If it is not integer, it should be a vector
2857 of subsidiary coding systems of which property `eol-type' has one
2858 of above values.
2860 */
2862 /* Extract information for decoding/encoding from CODING_SYSTEM_SYMBOL
2863 and set it in CODING. If CODING_SYSTEM_SYMBOL is invalid, CODING
2864 is setup so that no conversion is necessary and return -1, else
2865 return 0. */
2867 int
2869 Lisp_Object coding_system;
2871 {
2873 Lisp_Object val;
2876 /* Initialize some fields required for all kinds of coding systems. */
2897 {
2900 }
2902 {
2904 coding->common_flags
2906 }
2908 {
2910 coding->common_flags
2912 }
2913 else
2917 /* Try short cut. */
2919 {
2921 {
2924 }
2925 else
2928 }
2930 /* Get values of coding system properties:
2931 `post-read-conversion', `pre-write-conversion',
2932 `translation-table-for-decode', `translation-table-for-encode'. */
2934 /* Pre & post conversion functions should be disabled if
2935 inhibit_eol_conversion is nozero. This is the case that a code
2936 conversion function is called while those functions are running. */
2938 {
2941 }
2952 {
2956 else
2958 }
2959 else
2964 {
2967 }
2968 else
2969 {
2972 {
2976 }
2977 }
2979 /* If the coding system has non-nil `composition' property, enable
2980 composition handling. */
2986 {
2997 coding->common_flags
3003 coding->common_flags
3005 {
3016 coding->flags
3030 );
3032 /* Invoke graphic register 0 to plane 0. */
3034 /* Invoke graphic register 1 to plane 1 if we can use full 8-bit. */
3037 /* Not single shifting at first. */
3039 /* Beginning of buffer should also be regarded as bol. */
3046 {
3053 }
3055 /* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
3056 FLAGS[REG] can be one of below:
3057 integer CHARSET: CHARSET occupies register I,
3058 t: designate nothing to REG initially, but can be used
3059 by any charsets,
3060 list of integer, nil, or t: designate the first
3061 element (if integer) to REG initially, the remaining
3062 elements (if integer) is designated to REG on request,
3063 if an element is t, REG can be used by any charsets,
3064 nil: REG is never used. */
3069 {
3073 {
3076 }
3078 {
3082 }
3084 {
3085 Lisp_Object tail;
3093 {
3096 }
3097 else
3101 {
3111 }
3112 }
3113 else
3118 }
3121 {
3122 /* REG 1 can be used only by locking shift in 7-bit env. */
3126 /* Without any shifting, only REG 0 and 1 can be used. */
3128 }
3132 {
3134 {
3135 /* There exist some default graphic registers to be
3136 used CHARSET. */
3138 /* We had better avoid designating a charset of
3139 CHARS96 to REG 0 as far as possible. */
3144 else
3148 }
3149 }
3150 }
3157 coding->common_flags
3159 coding->flags
3161 ? CODING_FLAG_BIG5_HKU
3167 coding->common_flags
3169 {
3181 {
3185 {
3193 {
3200 }
3201 }
3202 }
3203 }
3214 }
3217 label_invalid_coding_system:
3224 }
3226 /* Free memory blocks allocated for storing composition information. */
3228 void
3231 {
3236 /* Memory blocks are chained. At first, rewind to the first, then,
3237 free blocks one by one. */
3241 {
3245 }
3247 }
3249 /* Set `char_offset' member of all memory blocks pointed by
3250 coding->cmp_data to POS. */
3252 void
3256 {
3261 }
3263 /* Setup raw-text or one of its subsidiaries in the structure
3264 coding_system CODING according to the already setup value eol_type
3265 in CODING. CODING should be setup for some coding system in
3266 advance. */
3268 void
3271 {
3273 {
3277 {
3278 Lisp_Object subsidiaries;
3283 coding->symbol
3285 }
3287 }
3289 }
3291 /* Emacs has a mechanism to automatically detect a coding system if it
3292 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
3293 it's impossible to distinguish some coding systems accurately
3294 because they use the same range of codes. So, at first, coding
3295 systems are categorized into 7, those are:
3297 o coding-category-emacs-mule
3299 The category for a coding system which has the same code range
3300 as Emacs' internal format. Assigned the coding-system (Lisp
3301 symbol) `emacs-mule' by default.
3303 o coding-category-sjis
3305 The category for a coding system which has the same code range
3306 as SJIS. Assigned the coding-system (Lisp
3307 symbol) `japanese-shift-jis' by default.
3309 o coding-category-iso-7
3311 The category for a coding system which has the same code range
3312 as ISO2022 of 7-bit environment. This doesn't use any locking
3313 shift and single shift functions. This can encode/decode all
3314 charsets. Assigned the coding-system (Lisp symbol)
3315 `iso-2022-7bit' by default.
3317 o coding-category-iso-7-tight
3319 Same as coding-category-iso-7 except that this can
3320 encode/decode only the specified charsets.
3322 o coding-category-iso-8-1
3324 The category for a coding system which has the same code range
3325 as ISO2022 of 8-bit environment and graphic plane 1 used only
3326 for DIMENSION1 charset. This doesn't use any locking shift
3327 and single shift functions. Assigned the coding-system (Lisp
3328 symbol) `iso-latin-1' by default.
3330 o coding-category-iso-8-2
3332 The category for a coding system which has the same code range
3333 as ISO2022 of 8-bit environment and graphic plane 1 used only
3334 for DIMENSION2 charset. This doesn't use any locking shift
3335 and single shift functions. Assigned the coding-system (Lisp
3336 symbol) `japanese-iso-8bit' by default.
3338 o coding-category-iso-7-else
3340 The category for a coding system which has the same code range
3341 as ISO2022 of 7-bit environemnt but uses locking shift or
3342 single shift functions. Assigned the coding-system (Lisp
3343 symbol) `iso-2022-7bit-lock' by default.
3345 o coding-category-iso-8-else
3347 The category for a coding system which has the same code range
3348 as ISO2022 of 8-bit environemnt but uses locking shift or
3349 single shift functions. Assigned the coding-system (Lisp
3350 symbol) `iso-2022-8bit-ss2' by default.
3352 o coding-category-big5
3354 The category for a coding system which has the same code range
3355 as BIG5. Assigned the coding-system (Lisp symbol)
3356 `cn-big5' by default.
3358 o coding-category-utf-8
3360 The category for a coding system which has the same code range
3361 as UTF-8 (cf. RFC2279). Assigned the coding-system (Lisp
3362 symbol) `utf-8' by default.
3364 o coding-category-utf-16-be
3366 The category for a coding system in which a text has an
3367 Unicode signature (cf. Unicode Standard) in the order of BIG
3368 endian at the head. Assigned the coding-system (Lisp symbol)
3369 `utf-16-be' by default.
3371 o coding-category-utf-16-le
3373 The category for a coding system in which a text has an
3374 Unicode signature (cf. Unicode Standard) in the order of
3375 LITTLE endian at the head. Assigned the coding-system (Lisp
3376 symbol) `utf-16-le' by default.
3378 o coding-category-ccl
3380 The category for a coding system of which encoder/decoder is
3381 written in CCL programs. The default value is nil, i.e., no
3382 coding system is assigned.
3384 o coding-category-binary
3386 The category for a coding system not categorized in any of the
3387 above. Assigned the coding-system (Lisp symbol)
3388 `no-conversion' by default.
3390 Each of them is a Lisp symbol and the value is an actual
3391 `coding-system's (this is also a Lisp symbol) assigned by a user.
3392 What Emacs does actually is to detect a category of coding system.
3393 Then, it uses a `coding-system' assigned to it. If Emacs can't
3394 decide only one possible category, it selects a category of the
3395 highest priority. Priorities of categories are also specified by a
3396 user in a Lisp variable `coding-category-list'.
3398 */
3400 static
3403 /* Detect how a text of length SRC_BYTES pointed by SOURCE is encoded.
3404 If it detects possible coding systems, return an integer in which
3405 appropriate flag bits are set. Flag bits are defined by macros
3406 CODING_CATEGORY_MASK_XXX in `coding.h'. If PRIORITIES is non-NULL,
3407 it should point the table `coding_priorities'. In that case, only
3408 the flag bit for a coding system of the highest priority is set in
3409 the returned value.
3411 How many ASCII characters are at the head is returned as *SKIP. */
3413 static int
3417 {
3423 /* At first, skip all ASCII characters and control characters except
3424 for three ISO2022 specific control characters. */
3429 label_loop_detect_coding:
3434 /* We found nothing other than ASCII. There's nothing to do. */
3438 /* The text seems to be encoded in some multilingual coding system.
3439 Now, try to find in which coding system the text is encoded. */
3441 {
3442 /* i.e. (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) */
3443 /* C is an ISO2022 specific control code of C0. */
3446 {
3447 /* No valid ISO2022 code follows C. Try again. */
3448 src++;
3451 else
3454 }
3456 {
3458 {
3461 }
3463 }
3464 }
3465 else
3466 {
3470 {
3471 /* C is the first byte of SJIS character code,
3472 or a leading-code of Emacs' internal format (emacs-mule),
3473 or the first byte of UTF-16. */
3475 | CODING_CATEGORY_MASK_EMACS_MULE
3476 | CODING_CATEGORY_MASK_UTF_16_BE
3479 /* Or, if C is a special latin extra code,
3480 or is an ISO2022 specific control code of C1 (SS2 or SS3),
3481 or is an ISO2022 control-sequence-introducer (CSI),
3482 we should also consider the possibility of ISO2022 codings. */
3494 }
3495 else
3496 /* C is a character of ISO2022 in graphic plane right,
3497 or a SJIS's 1-byte character code (i.e. JISX0201),
3498 or the first byte of BIG5's 2-byte code,
3499 or the first byte of UTF-8/16. */
3501 | CODING_CATEGORY_MASK_ISO_8BIT
3502 | CODING_CATEGORY_MASK_SJIS
3503 | CODING_CATEGORY_MASK_BIG5
3504 | CODING_CATEGORY_MASK_UTF_8
3505 | CODING_CATEGORY_MASK_UTF_16_BE
3508 /* Or, we may have to consider the possibility of CCL. */
3517 {
3519 {
3522 {
3525 }
3532 CODING_CATEGORY_MASK_UTF_16_BE_LE))
3533 {
3536 }
3549 }
3551 }
3566 }
3568 }
3570 /* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
3571 The information of the detected coding system is set in CODING. */
3573 void
3578 {
3581 Lisp_Object val;
3589 /* We found a single coding system of the highest priority in MASK. */
3598 {
3599 Lisp_Object tmp;
3604 }
3606 /* Setup this new coding system while preserving some slots. */
3607 {
3615 }
3616 }
3618 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
3619 SOURCE is encoded. Return one of CODING_EOL_LF, CODING_EOL_CRLF,
3620 CODING_EOL_CR, and CODING_EOL_UNDECIDED.
3622 How many non-eol characters are at the head is returned as *SKIP. */
3624 #define MAX_EOL_CHECK_COUNT 3
3626 static int
3630 {
3640 {
3643 {
3646 total++;
3651 else
3655 /* This is the first end-of-line. */
3658 {
3659 /* The found type is different from what found before. */
3662 }
3663 }
3664 }
3669 }
3671 /* Like detect_eol_type, but detect EOL type in 2-octet
3672 big-endian/little-endian format for coding systems utf-16-be and
3673 utf-16-le. */
3675 static int
3679 {
3689 else
3695 {
3700 {
3703 total++;
3705 {
3707 }
3708 else
3709 {
3711 {
3713 }
3714 else
3715 {
3719 else
3721 }
3722 }
3725 /* This is the first end-of-line. */
3728 {
3729 /* The found type is different from what found before. */
3732 }
3733 }
3734 }
3739 }
3741 /* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
3742 is encoded. If it detects an appropriate format of end-of-line, it
3743 sets the information in *CODING. */
3745 void
3750 {
3751 Lisp_Object val;
3756 {
3766 }
3770 else
3776 {
3777 #if 0
3778 /* This code is suppressed until we find a better way to
3779 distinguish raw text file and binary file. */
3781 /* If we have already detected that the coding is raw-text, the
3782 coding should actually be no-conversion. */
3784 {
3787 }
3788 /* Else, let's decode only text code anyway. */
3791 }
3795 {
3803 }
3804 }
3806 #define CONVERSION_BUFFER_EXTRA_ROOM 256
3808 #define DECODING_BUFFER_MAG(coding) \
3809 (coding->type == coding_type_iso2022 \
3810 ? 3 \
3811 : (coding->type == coding_type_ccl \
3812 ? coding->spec.ccl.decoder.buf_magnification \
3813 : 2))
3815 /* Return maximum size (bytes) of a buffer enough for decoding
3816 SRC_BYTES of text encoded in CODING. */
3818 int
3822 {
3825 }
3827 /* Return maximum size (bytes) of a buffer enough for encoding
3828 SRC_BYTES of text to CODING. */
3830 int
3834 {
3841 else
3845 }
3847 #ifndef MINIMUM_CONVERSION_BUFFER_SIZE
3848 #define MINIMUM_CONVERSION_BUFFER_SIZE 1024
3849 #endif
3854 /* Return a pointer to a SIZE bytes of buffer to be used for encoding
3855 or decoding. Sufficient memory is allocated automatically. If we
3856 run out of memory, return NULL. */
3861 {
3863 {
3872 }
3874 }
3876 int
3881 {
3893 else
3894 {
3895 int bytes
3900 }
3903 {
3917 }
3919 }
3921 /* Decode EOL format of the text at PTR of BYTES length destructively
3922 according to CODING->eol_type. This is called after the CCL
3923 program produced a decoded text at PTR. If we do CRLF->LF
3924 conversion, update CODING->produced and CODING->produced_char. */
3926 static void
3931 {
3936 /* Remember the current coding system symbol. We set it back when
3937 an inconsistent EOL is found so that `last-coding-system-used' is
3938 set to the coding system that doesn't specify EOL conversion. */
3943 {
3944 /* Here, to avoid the call of setup_coding_system, we directly
3945 call detect_eol_type. */
3951 }
3954 {
3955 /* We have nothing to do. */
3957 }
3959 {
3964 {
3965 /* If the last character is CR, we can't handle it here
3966 because LF will be in the not-yet-decoded source text.
3967 Recorded that the CR is not yet processed. */
3971 pend--;
3972 }
3974 {
3976 {
3978 {
3981 }
3982 else
3983 {
3987 }
3988 }
3992 else
3996 undo_eol_conversion:
3997 /* We have faced with inconsistent EOL format at PTR.
3998 Convert all LFs before PTR back to CRLFs. */
4000 {
4003 else
4005 }
4006 /* If carryover is recorded, cancel it because we don't
4007 convert CRLF anymore. */
4009 {
4013 pend++;
4014 }
4018 }
4020 {
4021 /* As each two-byte sequence CRLF was converted to LF, (PEND
4022 - P) is the number of deleted characters. */
4025 }
4026 }
4028 {
4032 {
4037 {
4039 {
4042 }
4046 }
4047 }
4048 }
4049 }
4051 /* See "GENERAL NOTES about `decode_coding_XXX ()' functions". Before
4052 decoding, it may detect coding system and format of end-of-line if
4053 those are not yet decided. The source should be unibyte, the
4054 result is multibyte if CODING->dst_multibyte is nonzero, else
4055 unibyte. */
4057 int
4062 {
4076 {
4099 {
4100 /* Set the CR which is not processed by the previous call of
4101 decode_eol_post_ccl in DESTINATION. */
4105 dst_bytes--;
4106 }
4116 }
4124 {
4133 {
4137 }
4140 }
4143 {
4146 }
4149 }
4151 /* See "GENERAL NOTES about `encode_coding_XXX ()' functions". The
4152 multibyteness of the source is CODING->src_multibyte, the
4153 multibyteness of the result is always unibyte. */
4155 int
4160 {
4167 {
4195 }
4202 {
4208 ENCODE_RESET_PLANE_AND_REGISTER;
4212 {
4220 }
4222 }
4225 }
4227 /* Scan text in the region between *BEG and *END (byte positions),
4228 skip characters which we don't have to decode by coding system
4229 CODING at the head and tail, then set *BEG and *END to the region
4230 of the text we actually have to convert. The caller should move
4231 the gap out of the region in advance if the region is from a
4232 buffer.
4234 If STR is not NULL, *BEG and *END are indices into STR. */
4236 static void
4241 {
4244 Lisp_Object translation_table;
4251 {
4252 /* We can't skip any data. */
4254 }
4258 {
4259 /* We need no conversion, but don't have to skip any data here.
4260 Decoding routine handles them effectively anyway. */
4262 }
4268 {
4274 /* Some ASCII character should be translated. We give up
4275 shrinking. */
4277 }
4280 /* Detection routine has already found how much we can skip at the
4281 head. */
4285 {
4288 }
4289 else
4290 {
4293 }
4299 {
4302 /* We can skip all ASCII characters at the head. */
4304 {
4307 else
4309 }
4310 /* We can skip all ASCII characters at the tail except for the
4311 second byte of SJIS or BIG5 code. */
4314 else
4316 /* Do not consider LF as ascii if preceded by CR, since that
4317 confuses eol decoding. */
4319 endp++;
4321 endp++;
4326 /* We can't skip any data. */
4329 {
4330 /* We can skip all ASCII characters at the head except for a
4331 few control codes. */
4336 begp++;
4337 }
4339 {
4342 /* We can skip all ASCII characters at the tail. */
4345 else
4347 /* Do not consider LF as ascii if preceded by CR, since that
4348 confuses eol decoding. */
4350 endp++;
4355 {
4356 /* We can skip all charactes at the tail except for 8-bit
4357 codes and ESC and the following 2-byte at the tail. */
4363 {
4365 endp--;
4366 }
4367 else
4370 {
4372 endp--;
4373 }
4374 /* Do not consider LF as ascii if preceded by CR, since that
4375 confuses eol decoding. */
4378 endp++;
4380 {
4382 /* This is an ASCII designation sequence. We can
4383 surely skip the tail. But, if we have
4384 encountered an 8-bit code, skip only the codes
4385 after that. */
4387 else
4388 /* Hmmm, we can't skip the tail. */
4390 }
4393 }
4394 }
4399 }
4403 }
4405 /* Like shrink_decoding_region but for encoding. */
4407 static void
4412 {
4415 Lisp_Object translation_table;
4421 {
4422 /* We can't skip any data. */
4424 }
4429 {
4430 /* We need no conversion, but don't have to skip any data here.
4431 Encoding routine handles them effectively anyway. */
4433 }
4439 {
4445 /* Some ASCII character should be tranlsated. We give up
4446 shrinking. */
4448 }
4451 {
4454 }
4455 else
4456 {
4459 }
4464 /* Here, we don't have to check coding->pre_write_conversion because
4465 the caller is expected to have handled it already. */
4467 {
4470 /* We can't skip any data. */
4473 {
4476 {
4477 begp++;
4480 }
4483 }
4484 /* fall down ... */
4488 /* We can skip all ASCII characters at the head and tail. */
4491 else
4493 label_skip_tail:
4496 else
4502 }
4507 }
4509 /* As shrinking conversion region requires some overhead, we don't try
4510 shrinking if the length of conversion region is less than this
4511 value. */
4514 #define SHRINK_CONVERSION_REGION(beg, end, coding, str, encodep) \
4515 do { \
4516 if (*(end) - *(beg) > shrink_conversion_region_threshhold) \
4517 { \
4518 if (encodep) shrink_encoding_region (beg, end, coding, str); \
4519 else shrink_decoding_region (beg, end, coding, str); \
4520 } \
4521 } while (0)
4523 static Lisp_Object
4525 Lisp_Object dummy;
4526 {
4529 }
4531 /* Store information about all compositions in the range FROM and TO
4532 of OBJ in memory blocks pointed by CODING->cmp_data. OBJ is a
4533 buffer or a string, defaults to the current buffer. */
4535 void
4539 Lisp_Object obj;
4540 {
4541 Lisp_Object prop;
4556 do
4557 {
4559 {
4564 /* For relative composition, we remember start and end
4565 positions, for the other compositions, we also remember
4566 components. */
4569 {
4570 /* We must store a*/
4576 {
4579 }
4581 {
4586 {
4591 }
4592 }
4595 }
4597 }
4599 }
4604 /* Make coding->cmp_data point to the first memory block. */
4608 }
4610 /* Reflect the saved information about compositions to OBJ.
4611 CODING->cmp_data points to a memory block for the informaiton. OBJ
4612 is a buffer or a string, defaults to the current buffer. */
4614 void
4617 Lisp_Object obj;
4618 {
4628 {
4632 {
4635 Lisp_Object components;
4639 else
4640 {
4648 }
4650 }
4652 }
4653 }
4655 /* Decode (if ENCODEP is zero) or encode (if ENCODEP is nonzero) the
4656 text from FROM to TO (byte positions are FROM_BYTE and TO_BYTE) by
4657 coding system CODING, and return the status code of code conversion
4658 (currently, this value has no meaning).
4660 How many characters (and bytes) are converted to how many
4661 characters (and bytes) are recorded in members of the structure
4662 CODING.
4664 If REPLACE is nonzero, we do various things as if the original text
4665 is deleted and a new text is inserted. See the comments in
4666 replace_range (insdel.c) to know what we are doing.
4668 If REPLACE is zero, it is assumed that the source text is unibyte.
4669 Otherwize, it is assumed that the source text is multibyte. */
4671 int
4675 {
4679 Lisp_Object saved_coding_symbol;
4682 Lisp_Object deletion;
4694 {
4697 }
4700 {
4705 {
4709 }
4710 }
4713 {
4714 /* We must detect encoding of text and eol format. */
4719 {
4722 /* It seems that the text contains only ASCII, but we
4723 should not left it undecided because the deeper
4724 decoding routine (decode_coding) tries to detect the
4725 encodings again in vain. */
4727 }
4730 {
4735 /* We had better recover the original eol format if we
4736 encounter an inconsitent eol format while decoding. */
4738 }
4739 }
4741 /* Now we convert the text. */
4743 /* For encoding, we must process pre-write-conversion in advance. */
4745 && encodep
4748 {
4749 /* The function in pre-write-conversion may put a new text in a
4750 new buffer. */
4756 /* We should not call any more pre-write/post-read-conversion
4757 functions while this pre-write-conversion is running. */
4762 /* Discard the unwind protect. */
4763 specpdl_ptr--;
4766 {
4784 }
4785 }
4791 {
4794 else
4796 }
4798 /* Try to skip the heading and tailing ASCIIs. */
4799 {
4808 {
4812 /* We must record and adjust for this new text now. */
4815 }
4823 }
4825 /* The code conversion routine can not preserve text properties for
4826 now. So, we must remove all text properties in the region.
4827 Here, we must suppress all modification hooks. */
4829 {
4834 }
4836 /* For converion, we must put the gap before the text in addition to
4837 making the gap larger for efficient decoding. The required gap
4838 size starts from 2000 which is the magic number used in make_gap.
4839 But, after one batch of conversion, it will be incremented if we
4840 find that it is not enough . */
4861 {
4862 /* Decoding routines expects that the source text is unibyte.
4863 We must convert 8-bit characters of multibyte form to
4864 unibyte. */
4869 len_byte);
4871 }
4874 {
4877 /* The buffer memory is now:
4878 +--------+converted-text+---------+-------original-text-------+---+
4879 |<-from->|<--inserted-->|---------|<--------len_byte--------->|---|
4880 |<---------------------- GAP ----------------------->| */
4886 else
4889 /* The buffer memory is now:
4890 +--------+-------converted-text----+--+------original-text----+---+
4891 |<-from->|<-inserted->|<-produced->|--|<-(len_byte-consumed)->|---|
4892 |<---------------------- GAP ----------------------->| */
4899 {
4902 }
4908 {
4911 }
4913 {
4915 Lisp_Object eol_type;
4917 /* Encode LFs back to the original eol format (CR or CRLF). */
4919 {
4921 }
4922 else
4923 {
4928 {
4929 /* We don't have sufficient room for encoding LFs
4930 back to CRLF. We must record converted and
4931 not-yet-converted text back to the buffer
4932 content, enlarge the gap, then record them out of
4933 the buffer contents again. */
4943 /* Don't forget to update SRC, DST, and PEND. */
4947 }
4953 {
4956 }
4957 }
4959 /* Suppress eol-format conversion in the further conversion. */
4962 /* Set the coding system symbol to that for Unix-like EOL. */
4968 else
4972 }
4974 {
4980 }
4982 {
4983 /* The source text ends in invalid codes. Let's just
4984 make them valid buffer contents, and finish conversion. */
4990 }
4992 {
4993 /* The conversion procedure was interrupted by a user. */
4995 }
4996 /* Now RESULT == CODING_FINISH_INSUFFICIENT_DST */
4998 {
4999 /* It's quite strange to require more memory without
5000 consuming any bytes. Perhaps CCL program bug. */
5002 }
5004 {
5005 /* We have just done the first batch of conversion which was
5006 stoped because of insufficient gap. Let's reconsider the
5007 required gap size (i.e. SRT - DST) now.
5009 We have converted ORIG bytes (== coding->consumed) into
5010 NEW bytes (coding->produced). To convert the remaining
5011 LEN bytes, we may need REQUIRE bytes of gap, where:
5012 REQUIRE + LEN_BYTE = LEN_BYTE * (NEW / ORIG)
5013 REQUIRE = LEN_BYTE * (NEW - ORIG) / ORIG
5014 Here, we are sure that NEW >= ORIG. */
5019 }
5021 {
5022 /* See the comment above the previous call of make_gap. */
5032 }
5033 }
5037 {
5038 /* The output is unibyte. We must convert 8-bit characters to
5039 multibyte form. */
5041 {
5051 }
5053 }
5055 /* If we have shrinked the conversion area, adjust it now. */
5057 {
5067 }
5079 {
5080 Lisp_Object val;
5087 /* We should not call any more pre-write/post-read-conversion
5088 functions while this post-read-conversion is running. */
5092 /* Discard the unwind protect. */
5093 specpdl_ptr--;
5096 }
5099 {
5102 else
5105 }
5108 {
5111 }
5113 {
5118 }
5121 }
5123 Lisp_Object
5125 Lisp_Object str;
5128 {
5139 /* We must insert the contents of STR as is without
5140 unibyte<->multibyte conversion. For that, we adjust the
5141 multibyteness of the working buffer to that of STR. */
5146 UNGCPRO;
5150 else
5151 {
5154 }
5158 }
5160 Lisp_Object
5162 Lisp_Object str;
5165 {
5170 Lisp_Object saved_coding_symbol;
5179 {
5180 /* See the comments in code_convert_region. */
5182 {
5186 }
5189 {
5194 /* We had better recover the original eol format if we
5195 encounter an inconsitent eol format while decoding. */
5197 }
5198 }
5201 {
5203 {
5206 }
5208 }
5211 {
5212 /* Decoding routines expect the source text to be unibyte. */
5216 }
5222 /* Try to skip the heading and tailing ASCIIs. */
5223 {
5230 }
5236 UNGCPRO;
5243 {
5244 /* We simply try to decode the whole string again but without
5245 eol-conversion this time. */
5250 }
5268 }
5270 Lisp_Object
5272 Lisp_Object str;
5275 {
5280 Lisp_Object saved_coding_symbol;
5293 {
5295 {
5298 }
5300 }
5302 /* Encoding routines determine the multibyteness of the source text
5303 by coding->src_multibyte. */
5310 /* Try to skip the heading and tailing ASCIIs. */
5311 {
5318 }
5324 UNGCPRO;
5338 }
5340 \f
5341 #ifdef emacs
5342 /*** 8. Emacs Lisp library functions ***/
5349 Lisp_Object obj;
5350 {
5355 /* Get coding-spec vector for OBJ. */
5359 }
5365 Lisp_Object prompt;
5366 {
5367 Lisp_Object val;
5368 do
5369 {
5372 }
5375 }
5382 {
5383 Lisp_Object val;
5390 }
5399 Lisp_Object coding_system;
5400 {
5406 }
5407 \f
5408 Lisp_Object
5412 {
5423 {
5426 {
5427 Lisp_Object val2;
5431 }
5433 }
5435 /* At first, gather possible coding systems in VAL. */
5438 {
5446 {
5450 }
5451 }
5455 /* Then, replace the elements with subsidiary coding systems. */
5457 {
5460 {
5461 Lisp_Object eol;
5465 }
5466 }
5468 }
5483 {
5501 }
5516 {
5522 }
5524 Lisp_Object
5528 {
5553 }
5566 {
5568 }
5581 {
5583 }
5585 Lisp_Object
5589 {
5602 string = (encodep
5608 }
5620 {
5622 }
5634 {
5636 }
5638 /* Encode or decode STRING according to CODING_SYSTEM.
5639 Do not set Vlast_coding_system_used.
5641 This function is called only from macros DECODE_FILE and
5642 ENCODE_FILE, thus we ignore character composition. */
5644 Lisp_Object
5648 {
5665 }
5666 \f
5671 Lisp_Object code;
5672 {
5674 Lisp_Object val;
5679 {
5684 else
5686 }
5687 else
5688 {
5694 }
5696 }
5702 Lisp_Object ch;
5703 {
5705 Lisp_Object val;
5710 {
5712 }
5715 {
5718 }
5721 {
5723 }
5724 else
5727 }
5733 Lisp_Object code;
5734 {
5737 Lisp_Object val;
5742 {
5746 }
5747 else
5748 {
5754 }
5756 }
5762 Lisp_Object ch;
5763 {
5765 Lisp_Object val;
5770 {
5772 }
5777 {
5780 }
5781 else
5784 }
5785 \f
5787 Fset_terminal_coding_system_internal,
5790 Lisp_Object coding_system;
5791 {
5794 /* We had better not send unsafe characters to terminal. */
5796 /* Characer composition should be disabled. */
5801 }
5804 Fset_safe_terminal_coding_system_internal,
5807 Lisp_Object coding_system;
5808 {
5812 /* Characer composition should be disabled. */
5817 }
5822 ()
5823 {
5825 }
5828 Fset_keyboard_coding_system_internal,
5831 Lisp_Object coding_system;
5832 {
5835 /* Characer composition should be disabled. */
5838 }
5843 ()
5844 {
5846 }
5848 \f
5882 {
5902 ? Vfile_coding_system_alist
5904 ? Vnetwork_coding_system_alist
5910 {
5911 Lisp_Object elt;
5919 {
5921 /* Here, if VAL is both a valid coding system and a valid
5922 function symbol, we return VAL as a coding system. */
5930 {
5936 }
5938 }
5939 }
5941 }
5948 ()
5949 {
5953 {
5954 Lisp_Object val;
5958 {
5963 }
5965 {
5968 }
5969 }
5972 }
5978 ()
5979 {
5981 Lisp_Object val;
5986 {
5994 }
5995 /* If coding-category-list is valid and contains all coding
5996 categories, `i' should be CODING_CATEGORY_IDX_MAX now. If not,
5997 the following code saves Emacs from crashing. */
6002 }
6006 \f
6007 /*** 9. Post-amble ***/
6009 void
6011 {
6013 }
6015 void
6017 {
6020 /* Emacs' internal format specific initialize routine. */
6035 /* ISO2022 specific initialize routine. */
6068 #if defined (MSDOS) || defined (WINDOWSNT)
6070 #else
6072 #endif
6075 }
6077 #ifdef emacs
6079 void
6081 {
6089 /* Target FILENAME is the first argument. */
6091 /* Target FILENAME is the third argument. */
6096 /* Target PROGRAM is the first argument. */
6101 /* Target PROGRAM is the third argument. */
6106 /* Target PROGRAM is the third argument. */
6111 /* Target SERVICE is the fourth argument. */
6151 Vcoding_category_table
6154 {
6157 {
6162 }
6163 }
6233 {
6238 Vcoding_category_list
6240 Vcoding_category_list);
6241 }
6333 /* The eol mnemonics are reset in startup.el system-dependently. */
6399 }
6404 {
6411 {
6413 Vlocale_coding_system,
6416 }
6419 }