1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 2001-2012 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
8 National Institute of Advanced Industrial Science and Technology (AIST)
9 Registration Number H13PRO009
11 This file is part of GNU Emacs.
13 GNU Emacs is free software: you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
18 GNU Emacs is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 /*** TABLE OF CONTENTS ***
30 2. Emacs' internal format (emacs-utf-8) handlers
33 5. Charset-base coding systems handlers
34 6. emacs-mule (old Emacs' internal format) handlers
36 8. Shift-JIS and BIG5 handlers
38 10. C library functions
39 11. Emacs Lisp library functions
44 /*** 0. General comments ***
49 A coding system is an object for an encoding mechanism that contains
50 information about how to convert byte sequences to character
51 sequences and vice versa. When we say "decode", it means converting
52 a byte sequence of a specific coding system into a character
53 sequence that is represented by Emacs' internal coding system
54 `emacs-utf-8', and when we say "encode", it means converting a
55 character sequence of emacs-utf-8 to a byte sequence of a specific
58 In Emacs Lisp, a coding system is represented by a Lisp symbol. On
59 the C level, a coding system is represented by a vector of attributes
60 stored in the hash table Vcharset_hash_table. The conversion from
61 coding system symbol to attributes vector is done by looking up
62 Vcharset_hash_table by the symbol.
64 Coding systems are classified into the following types depending on
65 the encoding mechanism. Here's a brief description of the types.
71 o Charset-base coding system
73 A coding system defined by one or more (coded) character sets.
74 Decoding and encoding are done by a code converter defined for each
77 o Old Emacs internal format (emacs-mule)
79 The coding system adopted by old versions of Emacs (20 and 21).
81 o ISO2022-base coding system
83 The most famous coding system for multiple character sets. X's
84 Compound Text, various EUCs (Extended Unix Code), and coding systems
85 used in the Internet communication such as ISO-2022-JP are all
88 o SJIS (or Shift-JIS or MS-Kanji-Code)
90 A coding system to encode character sets: ASCII, JISX0201, and
91 JISX0208. Widely used for PC's in Japan. Details are described in
96 A coding system to encode character sets: ASCII and Big5. Widely
97 used for Chinese (mainly in Taiwan and Hong Kong). Details are
98 described in section 8. In this file, when we write "big5" (all
99 lowercase), we mean the coding system, and when we write "Big5"
100 (capitalized), we mean the character set.
104 If a user wants to decode/encode text encoded in a coding system
105 not listed above, he can supply a decoder and an encoder for it in
106 CCL (Code Conversion Language) programs. Emacs executes the CCL
107 program while decoding/encoding.
111 A coding system for text containing raw eight-bit data. Emacs
112 treats each byte of source text as a character (except for
113 end-of-line conversion).
117 Like raw text, but don't do end-of-line conversion.
122 How text end-of-line is encoded depends on operating system. For
123 instance, Unix's format is just one byte of LF (line-feed) code,
124 whereas DOS's format is two-byte sequence of `carriage-return' and
125 `line-feed' codes. MacOS's format is usually one byte of
128 Since text character encoding and end-of-line encoding are
129 independent, any coding system described above can take any format
130 of end-of-line (except for no-conversion).
134 Before using a coding system for code conversion (i.e. decoding and
135 encoding), we setup a structure of type `struct coding_system'.
136 This structure keeps various information about a specific code
137 conversion (e.g. the location of source and destination data).
144 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
146 These functions check if a byte sequence specified as a source in
147 CODING conforms to the format of XXX, and update the members of
150 Return true if the byte sequence conforms to XXX.
152 Below is the template of these functions. */
156 detect_coding_XXX (struct coding_system
*coding
,
157 struct coding_detection_info
*detect_info
)
159 const unsigned char *src
= coding
->source
;
160 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
161 bool multibytep
= coding
->src_multibyte
;
162 ptrdiff_t consumed_chars
= 0;
168 /* Get one byte from the source. If the source is exhausted, jump
169 to no_more_source:. */
172 if (! __C_conforms_to_XXX___ (c
))
174 if (! __C_strongly_suggests_XXX__ (c
))
175 found
= CATEGORY_MASK_XXX
;
177 /* The byte sequence is invalid for XXX. */
178 detect_info
->rejected
|= CATEGORY_MASK_XXX
;
182 /* The source exhausted successfully. */
183 detect_info
->found
|= found
;
188 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
190 These functions decode a byte sequence specified as a source by
191 CODING. The resulting multibyte text goes to a place pointed to by
192 CODING->charbuf, the length of which should not exceed
193 CODING->charbuf_size;
195 These functions set the information of original and decoded texts in
196 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
197 They also set CODING->result to one of CODING_RESULT_XXX indicating
198 how the decoding is finished.
200 Below is the template of these functions. */
204 decode_coding_XXXX (struct coding_system
*coding
)
206 const unsigned char *src
= coding
->source
+ coding
->consumed
;
207 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
208 /* SRC_BASE remembers the start position in source in each loop.
209 The loop will be exited when there's not enough source code, or
210 when there's no room in CHARBUF for a decoded character. */
211 const unsigned char *src_base
;
212 /* A buffer to produce decoded characters. */
213 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
214 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
215 bool multibytep
= coding
->src_multibyte
;
220 if (charbuf
< charbuf_end
)
221 /* No more room to produce a decoded character. */
228 if (src_base
< src_end
229 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
230 /* If the source ends by partial bytes to construct a character,
231 treat them as eight-bit raw data. */
232 while (src_base
< src_end
&& charbuf
< charbuf_end
)
233 *charbuf
++ = *src_base
++;
234 /* Remember how many bytes and characters we consumed. If the
235 source is multibyte, the bytes and chars are not identical. */
236 coding
->consumed
= coding
->consumed_char
= src_base
- coding
->source
;
237 /* Remember how many characters we produced. */
238 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
242 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
244 These functions encode SRC_BYTES length text at SOURCE of Emacs'
245 internal multibyte format by CODING. The resulting byte sequence
246 goes to a place pointed to by DESTINATION, the length of which
247 should not exceed DST_BYTES.
249 These functions set the information of original and encoded texts in
250 the members produced, produced_char, consumed, and consumed_char of
251 the structure *CODING. They also set the member result to one of
252 CODING_RESULT_XXX indicating how the encoding finished.
254 DST_BYTES zero means that source area and destination area are
255 overlapped, which means that we can produce a encoded text until it
256 reaches at the head of not-yet-encoded source text.
258 Below is a template of these functions. */
261 encode_coding_XXX (struct coding_system
*coding
)
263 bool multibytep
= coding
->dst_multibyte
;
264 int *charbuf
= coding
->charbuf
;
265 int *charbuf_end
= charbuf
->charbuf
+ coding
->charbuf_used
;
266 unsigned char *dst
= coding
->destination
+ coding
->produced
;
267 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
268 unsigned char *adjusted_dst_end
= dst_end
- _MAX_BYTES_PRODUCED_IN_LOOP_
;
269 ptrdiff_t produced_chars
= 0;
271 for (; charbuf
< charbuf_end
&& dst
< adjusted_dst_end
; charbuf
++)
274 /* Encode C into DST, and increment DST. */
276 label_no_more_destination
:
277 /* How many chars and bytes we produced. */
278 coding
->produced_char
+= produced_chars
;
279 coding
->produced
= dst
- coding
->destination
;
284 /*** 1. Preamble ***/
290 #include "character.h"
294 #include "composite.h"
298 #include "termhooks.h"
300 Lisp_Object Vcoding_system_hash_table
;
302 static Lisp_Object Qcoding_system
, Qeol_type
;
303 static Lisp_Object Qcoding_aliases
;
304 Lisp_Object Qunix
, Qdos
;
305 Lisp_Object Qbuffer_file_coding_system
;
306 static Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
307 static Lisp_Object Qdefault_char
;
308 Lisp_Object Qno_conversion
, Qundecided
;
309 Lisp_Object Qcharset
, Qutf_8
;
310 static Lisp_Object Qiso_2022
;
311 static Lisp_Object Qutf_16
, Qshift_jis
, Qbig5
;
312 static Lisp_Object Qbig
, Qlittle
;
313 static Lisp_Object Qcoding_system_history
;
314 static Lisp_Object Qvalid_codes
;
315 static Lisp_Object QCcategory
, QCmnemonic
, QCdefault_char
;
316 static Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
317 static Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
318 static Lisp_Object QCascii_compatible_p
;
320 Lisp_Object Qcall_process
, Qcall_process_region
;
321 Lisp_Object Qstart_process
, Qopen_network_stream
;
322 static Lisp_Object Qtarget_idx
;
324 static Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
325 static Lisp_Object Qinterrupted
, Qinsufficient_memory
;
327 /* If a symbol has this property, evaluate the value to define the
328 symbol as a coding system. */
329 static Lisp_Object Qcoding_system_define_form
;
331 /* Format of end-of-line decided by system. This is Qunix on
332 Unix and Mac, Qdos on DOS/Windows.
333 This has an effect only for external encoding (i.e. for output to
334 file and process), not for in-buffer or Lisp string encoding. */
335 static Lisp_Object system_eol_type
;
339 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
341 /* Coding system emacs-mule and raw-text are for converting only
342 end-of-line format. */
343 Lisp_Object Qemacs_mule
, Qraw_text
;
344 Lisp_Object Qutf_8_emacs
;
346 /* Coding-systems are handed between Emacs Lisp programs and C internal
347 routines by the following three variables. */
348 /* Coding system to be used to encode text for terminal display when
349 terminal coding system is nil. */
350 struct coding_system safe_terminal_coding
;
354 Lisp_Object Qtranslation_table
;
355 Lisp_Object Qtranslation_table_id
;
356 static Lisp_Object Qtranslation_table_for_decode
;
357 static Lisp_Object Qtranslation_table_for_encode
;
359 /* Two special coding systems. */
360 static Lisp_Object Vsjis_coding_system
;
361 static Lisp_Object Vbig5_coding_system
;
363 /* ISO2022 section */
365 #define CODING_ISO_INITIAL(coding, reg) \
366 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
367 coding_attr_iso_initial), \
371 #define CODING_ISO_REQUEST(coding, charset_id) \
372 (((charset_id) <= (coding)->max_charset_id \
373 ? ((coding)->safe_charsets[charset_id] != 255 \
374 ? (coding)->safe_charsets[charset_id] \
379 #define CODING_ISO_FLAGS(coding) \
380 ((coding)->spec.iso_2022.flags)
381 #define CODING_ISO_DESIGNATION(coding, reg) \
382 ((coding)->spec.iso_2022.current_designation[reg])
383 #define CODING_ISO_INVOCATION(coding, plane) \
384 ((coding)->spec.iso_2022.current_invocation[plane])
385 #define CODING_ISO_SINGLE_SHIFTING(coding) \
386 ((coding)->spec.iso_2022.single_shifting)
387 #define CODING_ISO_BOL(coding) \
388 ((coding)->spec.iso_2022.bol)
389 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
390 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
391 #define CODING_ISO_CMP_STATUS(coding) \
392 (&(coding)->spec.iso_2022.cmp_status)
393 #define CODING_ISO_EXTSEGMENT_LEN(coding) \
394 ((coding)->spec.iso_2022.ctext_extended_segment_len)
395 #define CODING_ISO_EMBEDDED_UTF_8(coding) \
396 ((coding)->spec.iso_2022.embedded_utf_8)
398 /* Control characters of ISO2022. */
399 /* code */ /* function */
400 #define ISO_CODE_SO 0x0E /* shift-out */
401 #define ISO_CODE_SI 0x0F /* shift-in */
402 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
403 #define ISO_CODE_ESC 0x1B /* escape */
404 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
405 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
406 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
408 /* All code (1-byte) of ISO2022 is classified into one of the
410 enum iso_code_class_type
412 ISO_control_0
, /* Control codes in the range
413 0x00..0x1F and 0x7F, except for the
414 following 5 codes. */
415 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
416 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
417 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
418 ISO_escape
, /* ISO_CODE_SO (0x1B) */
419 ISO_control_1
, /* Control codes in the range
420 0x80..0x9F, except for the
421 following 3 codes. */
422 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
423 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
424 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
425 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
426 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
427 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
428 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
431 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
432 `iso-flags' attribute of an iso2022 coding system. */
434 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
435 instead of the correct short-form sequence (e.g. ESC $ A). */
436 #define CODING_ISO_FLAG_LONG_FORM 0x0001
438 /* If set, reset graphic planes and registers at end-of-line to the
440 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
442 /* If set, reset graphic planes and registers before any control
443 characters to the initial state. */
444 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
446 /* If set, encode by 7-bit environment. */
447 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
449 /* If set, use locking-shift function. */
450 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
452 /* If set, use single-shift function. Overwrite
453 CODING_ISO_FLAG_LOCKING_SHIFT. */
454 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
456 /* If set, use designation escape sequence. */
457 #define CODING_ISO_FLAG_DESIGNATION 0x0040
459 /* If set, produce revision number sequence. */
460 #define CODING_ISO_FLAG_REVISION 0x0080
462 /* If set, produce ISO6429's direction specifying sequence. */
463 #define CODING_ISO_FLAG_DIRECTION 0x0100
465 /* If set, assume designation states are reset at beginning of line on
467 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
469 /* If set, designation sequence should be placed at beginning of line
471 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
473 /* If set, do not encode unsafe characters on output. */
474 #define CODING_ISO_FLAG_SAFE 0x0800
476 /* If set, extra latin codes (128..159) are accepted as a valid code
478 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
480 #define CODING_ISO_FLAG_COMPOSITION 0x2000
482 /* #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000 */
484 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
486 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
488 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
490 /* A character to be produced on output if encoding of the original
491 character is prohibited by CODING_ISO_FLAG_SAFE. */
492 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
495 #define CODING_UTF_8_BOM(coding) \
496 ((coding)->spec.utf_8_bom)
499 #define CODING_UTF_16_BOM(coding) \
500 ((coding)->spec.utf_16.bom)
502 #define CODING_UTF_16_ENDIAN(coding) \
503 ((coding)->spec.utf_16.endian)
505 #define CODING_UTF_16_SURROGATE(coding) \
506 ((coding)->spec.utf_16.surrogate)
510 #define CODING_CCL_DECODER(coding) \
511 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
512 #define CODING_CCL_ENCODER(coding) \
513 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
514 #define CODING_CCL_VALIDS(coding) \
515 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
517 /* Index for each coding category in `coding_categories' */
521 coding_category_iso_7
,
522 coding_category_iso_7_tight
,
523 coding_category_iso_8_1
,
524 coding_category_iso_8_2
,
525 coding_category_iso_7_else
,
526 coding_category_iso_8_else
,
527 coding_category_utf_8_auto
,
528 coding_category_utf_8_nosig
,
529 coding_category_utf_8_sig
,
530 coding_category_utf_16_auto
,
531 coding_category_utf_16_be
,
532 coding_category_utf_16_le
,
533 coding_category_utf_16_be_nosig
,
534 coding_category_utf_16_le_nosig
,
535 coding_category_charset
,
536 coding_category_sjis
,
537 coding_category_big5
,
539 coding_category_emacs_mule
,
540 /* All above are targets of code detection. */
541 coding_category_raw_text
,
542 coding_category_undecided
,
546 /* Definitions of flag bits used in detect_coding_XXXX. */
547 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
548 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
549 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
550 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
551 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
552 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
553 #define CATEGORY_MASK_UTF_8_AUTO (1 << coding_category_utf_8_auto)
554 #define CATEGORY_MASK_UTF_8_NOSIG (1 << coding_category_utf_8_nosig)
555 #define CATEGORY_MASK_UTF_8_SIG (1 << coding_category_utf_8_sig)
556 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
557 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
558 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
559 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
560 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
561 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
562 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
563 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
564 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
565 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
566 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
568 /* This value is returned if detect_coding_mask () find nothing other
569 than ASCII characters. */
570 #define CATEGORY_MASK_ANY \
571 (CATEGORY_MASK_ISO_7 \
572 | CATEGORY_MASK_ISO_7_TIGHT \
573 | CATEGORY_MASK_ISO_8_1 \
574 | CATEGORY_MASK_ISO_8_2 \
575 | CATEGORY_MASK_ISO_7_ELSE \
576 | CATEGORY_MASK_ISO_8_ELSE \
577 | CATEGORY_MASK_UTF_8_AUTO \
578 | CATEGORY_MASK_UTF_8_NOSIG \
579 | CATEGORY_MASK_UTF_8_SIG \
580 | CATEGORY_MASK_UTF_16_AUTO \
581 | CATEGORY_MASK_UTF_16_BE \
582 | CATEGORY_MASK_UTF_16_LE \
583 | CATEGORY_MASK_UTF_16_BE_NOSIG \
584 | CATEGORY_MASK_UTF_16_LE_NOSIG \
585 | CATEGORY_MASK_CHARSET \
586 | CATEGORY_MASK_SJIS \
587 | CATEGORY_MASK_BIG5 \
588 | CATEGORY_MASK_CCL \
589 | CATEGORY_MASK_EMACS_MULE)
592 #define CATEGORY_MASK_ISO_7BIT \
593 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
595 #define CATEGORY_MASK_ISO_8BIT \
596 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
598 #define CATEGORY_MASK_ISO_ELSE \
599 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
601 #define CATEGORY_MASK_ISO_ESCAPE \
602 (CATEGORY_MASK_ISO_7 \
603 | CATEGORY_MASK_ISO_7_TIGHT \
604 | CATEGORY_MASK_ISO_7_ELSE \
605 | CATEGORY_MASK_ISO_8_ELSE)
607 #define CATEGORY_MASK_ISO \
608 ( CATEGORY_MASK_ISO_7BIT \
609 | CATEGORY_MASK_ISO_8BIT \
610 | CATEGORY_MASK_ISO_ELSE)
612 #define CATEGORY_MASK_UTF_16 \
613 (CATEGORY_MASK_UTF_16_AUTO \
614 | CATEGORY_MASK_UTF_16_BE \
615 | CATEGORY_MASK_UTF_16_LE \
616 | CATEGORY_MASK_UTF_16_BE_NOSIG \
617 | CATEGORY_MASK_UTF_16_LE_NOSIG)
619 #define CATEGORY_MASK_UTF_8 \
620 (CATEGORY_MASK_UTF_8_AUTO \
621 | CATEGORY_MASK_UTF_8_NOSIG \
622 | CATEGORY_MASK_UTF_8_SIG)
624 /* Table of coding categories (Lisp symbols). This variable is for
625 internal use only. */
626 static Lisp_Object Vcoding_category_table
;
628 /* Table of coding-categories ordered by priority. */
629 static enum coding_category coding_priorities
[coding_category_max
];
631 /* Nth element is a coding context for the coding system bound to the
632 Nth coding category. */
633 static struct coding_system coding_categories
[coding_category_max
];
635 /*** Commonly used macros and functions ***/
638 #define min(a, b) ((a) < (b) ? (a) : (b))
641 #define max(a, b) ((a) > (b) ? (a) : (b))
644 #define CODING_GET_INFO(coding, attrs, charset_list) \
646 (attrs) = CODING_ID_ATTRS ((coding)->id); \
647 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
651 /* Safely get one byte from the source text pointed by SRC which ends
652 at SRC_END, and set C to that byte. If there are not enough bytes
653 in the source, it jumps to 'no_more_source'. If MULTIBYTEP,
654 and a multibyte character is found at SRC, set C to the
655 negative value of the character code. The caller should declare
656 and set these variables appropriately in advance:
657 src, src_end, multibytep */
659 #define ONE_MORE_BYTE(c) \
661 if (src == src_end) \
663 if (src_base < src) \
664 record_conversion_result \
665 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
666 goto no_more_source; \
669 if (multibytep && (c & 0x80)) \
671 if ((c & 0xFE) == 0xC0) \
672 c = ((c & 1) << 6) | *src++; \
676 c = - string_char (src, &src, NULL); \
677 record_conversion_result \
678 (coding, CODING_RESULT_INVALID_SRC); \
684 /* Safely get two bytes from the source text pointed by SRC which ends
685 at SRC_END, and set C1 and C2 to those bytes while skipping the
686 heading multibyte characters. If there are not enough bytes in the
687 source, it jumps to 'no_more_source'. If MULTIBYTEP and
688 a multibyte character is found for C2, set C2 to the negative value
689 of the character code. The caller should declare and set these
690 variables appropriately in advance:
691 src, src_end, multibytep
692 It is intended that this macro is used in detect_coding_utf_16. */
694 #define TWO_MORE_BYTES(c1, c2) \
697 if (src == src_end) \
698 goto no_more_source; \
700 if (multibytep && (c1 & 0x80)) \
702 if ((c1 & 0xFE) == 0xC0) \
703 c1 = ((c1 & 1) << 6) | *src++; \
706 src += BYTES_BY_CHAR_HEAD (c1) - 1; \
711 if (src == src_end) \
712 goto no_more_source; \
714 if (multibytep && (c2 & 0x80)) \
716 if ((c2 & 0xFE) == 0xC0) \
717 c2 = ((c2 & 1) << 6) | *src++; \
724 /* Store a byte C in the place pointed by DST and increment DST to the
725 next free point, and increment PRODUCED_CHARS. The caller should
726 assure that C is 0..127, and declare and set the variable `dst'
727 appropriately in advance.
731 #define EMIT_ONE_ASCII_BYTE(c) \
738 /* Like EMIT_ONE_ASCII_BYTE but store two bytes; C1 and C2. */
740 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
742 produced_chars += 2; \
743 *dst++ = (c1), *dst++ = (c2); \
747 /* Store a byte C in the place pointed by DST and increment DST to the
748 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP,
749 store in an appropriate multibyte form. The caller should
750 declare and set the variables `dst' and `multibytep' appropriately
753 #define EMIT_ONE_BYTE(c) \
760 ch = BYTE8_TO_CHAR (ch); \
761 CHAR_STRING_ADVANCE (ch, dst); \
768 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
770 #define EMIT_TWO_BYTES(c1, c2) \
772 produced_chars += 2; \
779 ch = BYTE8_TO_CHAR (ch); \
780 CHAR_STRING_ADVANCE (ch, dst); \
783 ch = BYTE8_TO_CHAR (ch); \
784 CHAR_STRING_ADVANCE (ch, dst); \
794 #define EMIT_THREE_BYTES(c1, c2, c3) \
796 EMIT_ONE_BYTE (c1); \
797 EMIT_TWO_BYTES (c2, c3); \
801 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
803 EMIT_TWO_BYTES (c1, c2); \
804 EMIT_TWO_BYTES (c3, c4); \
809 record_conversion_result (struct coding_system
*coding
,
810 enum coding_result_code result
)
812 coding
->result
= result
;
815 case CODING_RESULT_INSUFFICIENT_SRC
:
816 Vlast_code_conversion_error
= Qinsufficient_source
;
818 case CODING_RESULT_INCONSISTENT_EOL
:
819 Vlast_code_conversion_error
= Qinconsistent_eol
;
821 case CODING_RESULT_INVALID_SRC
:
822 Vlast_code_conversion_error
= Qinvalid_source
;
824 case CODING_RESULT_INTERRUPT
:
825 Vlast_code_conversion_error
= Qinterrupted
;
827 case CODING_RESULT_INSUFFICIENT_MEM
:
828 Vlast_code_conversion_error
= Qinsufficient_memory
;
830 case CODING_RESULT_INSUFFICIENT_DST
:
831 /* Don't record this error in Vlast_code_conversion_error
832 because it happens just temporarily and is resolved when the
833 whole conversion is finished. */
835 case CODING_RESULT_SUCCESS
:
838 Vlast_code_conversion_error
= intern ("Unknown error");
842 /* These wrapper macros are used to preserve validity of pointers into
843 buffer text across calls to decode_char, encode_char, etc, which
844 could cause relocation of buffers if it loads a charset map,
845 because loading a charset map allocates large structures. */
847 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
851 charset_map_loaded = 0; \
852 c = DECODE_CHAR (charset, code); \
853 if (charset_map_loaded \
854 && (offset = coding_change_source (coding))) \
857 src_base += offset; \
862 #define CODING_ENCODE_CHAR(coding, dst, dst_end, charset, c, code) \
866 charset_map_loaded = 0; \
867 code = ENCODE_CHAR (charset, c); \
868 if (charset_map_loaded \
869 && (offset = coding_change_destination (coding))) \
876 #define CODING_CHAR_CHARSET(coding, dst, dst_end, c, charset_list, code_return, charset) \
880 charset_map_loaded = 0; \
881 charset = char_charset (c, charset_list, code_return); \
882 if (charset_map_loaded \
883 && (offset = coding_change_destination (coding))) \
890 #define CODING_CHAR_CHARSET_P(coding, dst, dst_end, c, charset, result) \
894 charset_map_loaded = 0; \
895 result = CHAR_CHARSET_P (c, charset); \
896 if (charset_map_loaded \
897 && (offset = coding_change_destination (coding))) \
905 /* If there are at least BYTES length of room at dst, allocate memory
906 for coding->destination and update dst and dst_end. We don't have
907 to take care of coding->source which will be relocated. It is
908 handled by calling coding_set_source in encode_coding. */
910 #define ASSURE_DESTINATION(bytes) \
912 if (dst + (bytes) >= dst_end) \
914 ptrdiff_t more_bytes = charbuf_end - charbuf + (bytes); \
916 dst = alloc_destination (coding, more_bytes, dst); \
917 dst_end = coding->destination + coding->dst_bytes; \
922 /* Store multibyte form of the character C in P, and advance P to the
923 end of the multibyte form. This used to be like CHAR_STRING_ADVANCE
924 without ever calling MAYBE_UNIFY_CHAR, but nowadays we don't call
925 MAYBE_UNIFY_CHAR in CHAR_STRING_ADVANCE. */
927 #define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) CHAR_STRING_ADVANCE(c, p)
929 /* Return the character code of character whose multibyte form is at
930 P, and advance P to the end of the multibyte form. This used to be
931 like STRING_CHAR_ADVANCE without ever calling MAYBE_UNIFY_CHAR, but
932 nowadays STRING_CHAR_ADVANCE doesn't call MAYBE_UNIFY_CHAR. */
934 #define STRING_CHAR_ADVANCE_NO_UNIFY(p) STRING_CHAR_ADVANCE(p)
936 /* Set coding->source from coding->src_object. */
939 coding_set_source (struct coding_system
*coding
)
941 if (BUFFERP (coding
->src_object
))
943 struct buffer
*buf
= XBUFFER (coding
->src_object
);
945 if (coding
->src_pos
< 0)
946 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
948 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
950 else if (STRINGP (coding
->src_object
))
952 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
956 /* Otherwise, the source is C string and is never relocated
957 automatically. Thus we don't have to update anything. */
962 /* Set coding->source from coding->src_object, and return how many
963 bytes coding->source was changed. */
966 coding_change_source (struct coding_system
*coding
)
968 const unsigned char *orig
= coding
->source
;
969 coding_set_source (coding
);
970 return coding
->source
- orig
;
974 /* Set coding->destination from coding->dst_object. */
977 coding_set_destination (struct coding_system
*coding
)
979 if (BUFFERP (coding
->dst_object
))
981 if (BUFFERP (coding
->src_object
) && coding
->src_pos
< 0)
983 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- BEG_BYTE
;
984 coding
->dst_bytes
= (GAP_END_ADDR
985 - (coding
->src_bytes
- coding
->consumed
)
986 - coding
->destination
);
990 /* We are sure that coding->dst_pos_byte is before the gap
992 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
993 + coding
->dst_pos_byte
- BEG_BYTE
);
994 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
995 - coding
->destination
);
1000 /* Otherwise, the destination is C string and is never relocated
1001 automatically. Thus we don't have to update anything. */
1006 /* Set coding->destination from coding->dst_object, and return how
1007 many bytes coding->destination was changed. */
1010 coding_change_destination (struct coding_system
*coding
)
1012 const unsigned char *orig
= coding
->destination
;
1013 coding_set_destination (coding
);
1014 return coding
->destination
- orig
;
1019 coding_alloc_by_realloc (struct coding_system
*coding
, ptrdiff_t bytes
)
1021 if (STRING_BYTES_BOUND
- coding
->dst_bytes
< bytes
)
1023 coding
->destination
= xrealloc (coding
->destination
,
1024 coding
->dst_bytes
+ bytes
);
1025 coding
->dst_bytes
+= bytes
;
1029 coding_alloc_by_making_gap (struct coding_system
*coding
,
1030 ptrdiff_t gap_head_used
, ptrdiff_t bytes
)
1032 if (EQ (coding
->src_object
, coding
->dst_object
))
1034 /* The gap may contain the produced data at the head and not-yet
1035 consumed data at the tail. To preserve those data, we at
1036 first make the gap size to zero, then increase the gap
1038 ptrdiff_t add
= GAP_SIZE
;
1040 GPT
+= gap_head_used
, GPT_BYTE
+= gap_head_used
;
1041 GAP_SIZE
= 0; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1043 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1044 GPT
-= gap_head_used
, GPT_BYTE
-= gap_head_used
;
1048 Lisp_Object this_buffer
;
1050 this_buffer
= Fcurrent_buffer ();
1051 set_buffer_internal (XBUFFER (coding
->dst_object
));
1053 set_buffer_internal (XBUFFER (this_buffer
));
1058 static unsigned char *
1059 alloc_destination (struct coding_system
*coding
, ptrdiff_t nbytes
,
1062 ptrdiff_t offset
= dst
- coding
->destination
;
1064 if (BUFFERP (coding
->dst_object
))
1066 struct buffer
*buf
= XBUFFER (coding
->dst_object
);
1068 coding_alloc_by_making_gap (coding
, dst
- BUF_GPT_ADDR (buf
), nbytes
);
1071 coding_alloc_by_realloc (coding
, nbytes
);
1072 coding_set_destination (coding
);
1073 dst
= coding
->destination
+ offset
;
1077 /** Macros for annotations. */
1079 /* An annotation data is stored in the array coding->charbuf in this
1081 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1082 LENGTH is the number of elements in the annotation.
1083 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1084 NCHARS is the number of characters in the text annotated.
1086 The format of the following elements depend on ANNOTATION_MASK.
1088 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1090 ... NBYTES METHOD [ COMPOSITION-COMPONENTS ... ]
1092 NBYTES is the number of bytes specified in the header part of
1093 old-style emacs-mule encoding, or 0 for the other kind of
1096 METHOD is one of enum composition_method.
1098 Optional COMPOSITION-COMPONENTS are characters and composition
1101 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1104 If ANNOTATION_MASK is 0, this annotation is just a space holder to
1105 recover from an invalid annotation, and should be skipped by
1106 produce_annotation. */
1108 /* Maximum length of the header of annotation data. */
1109 #define MAX_ANNOTATION_LENGTH 5
1111 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1113 *(buf)++ = -(len); \
1114 *(buf)++ = (mask); \
1115 *(buf)++ = (nchars); \
1116 coding->annotated = 1; \
1119 #define ADD_COMPOSITION_DATA(buf, nchars, nbytes, method) \
1121 ADD_ANNOTATION_DATA (buf, 5, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1127 #define ADD_CHARSET_DATA(buf, nchars, id) \
1129 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1134 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1141 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1142 Return true if a text is encoded in UTF-8. */
1144 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1145 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1146 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1147 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1148 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1149 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1151 #define UTF_8_BOM_1 0xEF
1152 #define UTF_8_BOM_2 0xBB
1153 #define UTF_8_BOM_3 0xBF
1156 detect_coding_utf_8 (struct coding_system
*coding
,
1157 struct coding_detection_info
*detect_info
)
1159 const unsigned char *src
= coding
->source
, *src_base
;
1160 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1161 bool multibytep
= coding
->src_multibyte
;
1162 ptrdiff_t consumed_chars
= 0;
1166 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1167 /* A coding system of this category is always ASCII compatible. */
1168 src
+= coding
->head_ascii
;
1172 int c
, c1
, c2
, c3
, c4
;
1176 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1179 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1181 if (UTF_8_2_OCTET_LEADING_P (c
))
1187 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1189 if (UTF_8_3_OCTET_LEADING_P (c
))
1192 if (src_base
== coding
->source
1193 && c
== UTF_8_BOM_1
&& c1
== UTF_8_BOM_2
&& c2
== UTF_8_BOM_3
)
1198 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1200 if (UTF_8_4_OCTET_LEADING_P (c
))
1206 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1208 if (UTF_8_5_OCTET_LEADING_P (c
))
1215 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1219 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1221 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1226 /* The first character 0xFFFE doesn't necessarily mean a BOM. */
1227 detect_info
->found
|= CATEGORY_MASK_UTF_8_SIG
| CATEGORY_MASK_UTF_8_NOSIG
;
1231 detect_info
->rejected
|= CATEGORY_MASK_UTF_8_SIG
;
1233 detect_info
->found
|= CATEGORY_MASK_UTF_8_NOSIG
;
1240 decode_coding_utf_8 (struct coding_system
*coding
)
1242 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1243 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1244 const unsigned char *src_base
;
1245 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1246 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1247 ptrdiff_t consumed_chars
= 0, consumed_chars_base
= 0;
1248 bool multibytep
= coding
->src_multibyte
;
1249 enum utf_bom_type bom
= CODING_UTF_8_BOM (coding
);
1251 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1252 int byte_after_cr
= -1;
1254 if (bom
!= utf_without_bom
)
1260 if (! UTF_8_3_OCTET_LEADING_P (c1
))
1265 if (! UTF_8_EXTRA_OCTET_P (c2
))
1270 if (! UTF_8_EXTRA_OCTET_P (c3
))
1274 if ((c1
!= UTF_8_BOM_1
)
1275 || (c2
!= UTF_8_BOM_2
) || (c3
!= UTF_8_BOM_3
))
1278 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1283 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1287 int c
, c1
, c2
, c3
, c4
, c5
;
1290 consumed_chars_base
= consumed_chars
;
1292 if (charbuf
>= charbuf_end
)
1294 if (byte_after_cr
>= 0)
1299 if (byte_after_cr
>= 0)
1300 c1
= byte_after_cr
, byte_after_cr
= -1;
1307 else if (UTF_8_1_OCTET_P (c1
))
1309 if (eol_dos
&& c1
== '\r')
1310 ONE_MORE_BYTE (byte_after_cr
);
1316 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1318 if (UTF_8_2_OCTET_LEADING_P (c1
))
1320 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1321 /* Reject overlong sequences here and below. Encoders
1322 producing them are incorrect, they can be misleading,
1323 and they mess up read/write invariance. */
1330 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1332 if (UTF_8_3_OCTET_LEADING_P (c1
))
1334 c
= (((c1
& 0xF) << 12)
1335 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1337 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1343 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1345 if (UTF_8_4_OCTET_LEADING_P (c1
))
1347 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1348 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1355 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1357 if (UTF_8_5_OCTET_LEADING_P (c1
))
1359 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1360 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1362 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1377 consumed_chars
= consumed_chars_base
;
1379 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1384 coding
->consumed_char
+= consumed_chars_base
;
1385 coding
->consumed
= src_base
- coding
->source
;
1386 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1391 encode_coding_utf_8 (struct coding_system
*coding
)
1393 bool multibytep
= coding
->dst_multibyte
;
1394 int *charbuf
= coding
->charbuf
;
1395 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1396 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1397 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1398 ptrdiff_t produced_chars
= 0;
1401 if (CODING_UTF_8_BOM (coding
) == utf_with_bom
)
1403 ASSURE_DESTINATION (3);
1404 EMIT_THREE_BYTES (UTF_8_BOM_1
, UTF_8_BOM_2
, UTF_8_BOM_3
);
1405 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1410 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1412 while (charbuf
< charbuf_end
)
1414 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1416 ASSURE_DESTINATION (safe_room
);
1418 if (CHAR_BYTE8_P (c
))
1420 c
= CHAR_TO_BYTE8 (c
);
1425 CHAR_STRING_ADVANCE_NO_UNIFY (c
, pend
);
1426 for (p
= str
; p
< pend
; p
++)
1433 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1435 while (charbuf
< charbuf_end
)
1437 ASSURE_DESTINATION (safe_room
);
1439 if (CHAR_BYTE8_P (c
))
1440 *dst
++ = CHAR_TO_BYTE8 (c
);
1442 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
1446 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1447 coding
->produced_char
+= produced_chars
;
1448 coding
->produced
= dst
- coding
->destination
;
1453 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1454 Return true if a text is encoded in one of UTF-16 based coding systems. */
1456 #define UTF_16_HIGH_SURROGATE_P(val) \
1457 (((val) & 0xFC00) == 0xD800)
1459 #define UTF_16_LOW_SURROGATE_P(val) \
1460 (((val) & 0xFC00) == 0xDC00)
1464 detect_coding_utf_16 (struct coding_system
*coding
,
1465 struct coding_detection_info
*detect_info
)
1467 const unsigned char *src
= coding
->source
;
1468 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1469 bool multibytep
= coding
->src_multibyte
;
1472 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1473 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1474 && (coding
->src_chars
& 1))
1476 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1480 TWO_MORE_BYTES (c1
, c2
);
1481 if ((c1
== 0xFF) && (c2
== 0xFE))
1483 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1484 | CATEGORY_MASK_UTF_16_AUTO
);
1485 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1486 | CATEGORY_MASK_UTF_16_BE_NOSIG
1487 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1489 else if ((c1
== 0xFE) && (c2
== 0xFF))
1491 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1492 | CATEGORY_MASK_UTF_16_AUTO
);
1493 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1494 | CATEGORY_MASK_UTF_16_BE_NOSIG
1495 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1499 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1504 /* We check the dispersion of Eth and Oth bytes where E is even and
1505 O is odd. If both are high, we assume binary data.*/
1506 unsigned char e
[256], o
[256];
1507 unsigned e_num
= 1, o_num
= 1;
1514 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_AUTO
1515 |CATEGORY_MASK_UTF_16_BE
1516 | CATEGORY_MASK_UTF_16_LE
);
1518 while ((detect_info
->rejected
& CATEGORY_MASK_UTF_16
)
1519 != CATEGORY_MASK_UTF_16
)
1521 TWO_MORE_BYTES (c1
, c2
);
1529 detect_info
->rejected
|= CATEGORY_MASK_UTF_16_BE_NOSIG
;
1536 detect_info
->rejected
|= CATEGORY_MASK_UTF_16_LE_NOSIG
;
1547 decode_coding_utf_16 (struct coding_system
*coding
)
1549 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1550 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1551 const unsigned char *src_base
;
1552 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1553 /* We may produces at most 3 chars in one loop. */
1554 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
- 2;
1555 ptrdiff_t consumed_chars
= 0, consumed_chars_base
= 0;
1556 bool multibytep
= coding
->src_multibyte
;
1557 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1558 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1559 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1561 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1562 int byte_after_cr1
= -1, byte_after_cr2
= -1;
1564 if (bom
== utf_with_bom
)
1573 if (endian
== utf_16_big_endian
1574 ? c
!= 0xFEFF : c
!= 0xFFFE)
1576 /* The first two bytes are not BOM. Treat them as bytes
1577 for a normal character. */
1581 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1583 else if (bom
== utf_detect_bom
)
1585 /* We have already tried to detect BOM and failed in
1587 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1595 consumed_chars_base
= consumed_chars
;
1597 if (charbuf
>= charbuf_end
)
1599 if (byte_after_cr1
>= 0)
1604 if (byte_after_cr1
>= 0)
1605 c1
= byte_after_cr1
, byte_after_cr1
= -1;
1613 if (byte_after_cr2
>= 0)
1614 c2
= byte_after_cr2
, byte_after_cr2
= -1;
1619 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1623 c
= (endian
== utf_16_big_endian
1624 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1628 if (! UTF_16_LOW_SURROGATE_P (c
))
1630 if (endian
== utf_16_big_endian
)
1631 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1633 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1637 if (UTF_16_HIGH_SURROGATE_P (c
))
1638 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1644 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1645 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1646 *charbuf
++ = 0x10000 + c
;
1651 if (UTF_16_HIGH_SURROGATE_P (c
))
1652 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1655 if (eol_dos
&& c
== '\r')
1657 ONE_MORE_BYTE (byte_after_cr1
);
1658 ONE_MORE_BYTE (byte_after_cr2
);
1666 coding
->consumed_char
+= consumed_chars_base
;
1667 coding
->consumed
= src_base
- coding
->source
;
1668 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1672 encode_coding_utf_16 (struct coding_system
*coding
)
1674 bool multibytep
= coding
->dst_multibyte
;
1675 int *charbuf
= coding
->charbuf
;
1676 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1677 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1678 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1680 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1681 bool big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1682 ptrdiff_t produced_chars
= 0;
1685 if (bom
!= utf_without_bom
)
1687 ASSURE_DESTINATION (safe_room
);
1689 EMIT_TWO_BYTES (0xFE, 0xFF);
1691 EMIT_TWO_BYTES (0xFF, 0xFE);
1692 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1695 while (charbuf
< charbuf_end
)
1697 ASSURE_DESTINATION (safe_room
);
1699 if (c
> MAX_UNICODE_CHAR
)
1700 c
= coding
->default_char
;
1705 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1707 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1714 c1
= (c
>> 10) + 0xD800;
1715 c2
= (c
& 0x3FF) + 0xDC00;
1717 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1719 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1722 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1723 coding
->produced
= dst
- coding
->destination
;
1724 coding
->produced_char
+= produced_chars
;
1729 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1731 /* Emacs' internal format for representation of multiple character
1732 sets is a kind of multi-byte encoding, i.e. characters are
1733 represented by variable-length sequences of one-byte codes.
1735 ASCII characters and control characters (e.g. `tab', `newline') are
1736 represented by one-byte sequences which are their ASCII codes, in
1737 the range 0x00 through 0x7F.
1739 8-bit characters of the range 0x80..0x9F are represented by
1740 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1743 8-bit characters of the range 0xA0..0xFF are represented by
1744 one-byte sequences which are their 8-bit code.
1746 The other characters are represented by a sequence of `base
1747 leading-code', optional `extended leading-code', and one or two
1748 `position-code's. The length of the sequence is determined by the
1749 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1750 whereas extended leading-code and position-code take the range 0xA0
1751 through 0xFF. See `charset.h' for more details about leading-code
1754 --- CODE RANGE of Emacs' internal format ---
1758 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1759 eight-bit-graphic 0xA0..0xBF
1760 ELSE 0x81..0x9D + [0xA0..0xFF]+
1761 ---------------------------------------------
1763 As this is the internal character representation, the format is
1764 usually not used externally (i.e. in a file or in a data sent to a
1765 process). But, it is possible to have a text externally in this
1766 format (i.e. by encoding by the coding system `emacs-mule').
1768 In that case, a sequence of one-byte codes has a slightly different
1771 At first, all characters in eight-bit-control are represented by
1772 one-byte sequences which are their 8-bit code.
1774 Next, character composition data are represented by the byte
1775 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1777 METHOD is 0xF2 plus one of composition method (enum
1778 composition_method),
1780 BYTES is 0xA0 plus a byte length of this composition data,
1782 CHARS is 0xA0 plus a number of characters composed by this
1785 COMPONENTs are characters of multibyte form or composition
1786 rules encoded by two-byte of ASCII codes.
1788 In addition, for backward compatibility, the following formats are
1789 also recognized as composition data on decoding.
1792 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1795 MSEQ is a multibyte form but in these special format:
1796 ASCII: 0xA0 ASCII_CODE+0x80,
1797 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1798 RULE is a one byte code of the range 0xA0..0xF0 that
1799 represents a composition rule.
1802 char emacs_mule_bytes
[256];
1805 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1806 Return true if a text is encoded in 'emacs-mule'. */
1809 detect_coding_emacs_mule (struct coding_system
*coding
,
1810 struct coding_detection_info
*detect_info
)
1812 const unsigned char *src
= coding
->source
, *src_base
;
1813 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1814 bool multibytep
= coding
->src_multibyte
;
1815 ptrdiff_t consumed_chars
= 0;
1819 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1820 /* A coding system of this category is always ASCII compatible. */
1821 src
+= coding
->head_ascii
;
1831 /* Perhaps the start of composite character. We simply skip
1832 it because analyzing it is too heavy for detecting. But,
1833 at least, we check that the composite character
1834 constitutes of more than 4 bytes. */
1835 const unsigned char *src_start
;
1845 if (src
- src_start
<= 4)
1847 found
= CATEGORY_MASK_EMACS_MULE
;
1855 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1860 int more_bytes
= emacs_mule_bytes
[c
] - 1;
1862 while (more_bytes
> 0)
1867 src
--; /* Unread the last byte. */
1872 if (more_bytes
!= 0)
1874 found
= CATEGORY_MASK_EMACS_MULE
;
1877 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1881 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1883 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1886 detect_info
->found
|= found
;
1891 /* Parse emacs-mule multibyte sequence at SRC and return the decoded
1892 character. If CMP_STATUS indicates that we must expect MSEQ or
1893 RULE described above, decode it and return the negative value of
1894 the decoded character or rule. If an invalid byte is found, return
1895 -1. If SRC is too short, return -2. */
1898 emacs_mule_char (struct coding_system
*coding
, const unsigned char *src
,
1899 int *nbytes
, int *nchars
, int *id
,
1900 struct composition_status
*cmp_status
)
1902 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1903 const unsigned char *src_base
= src
;
1904 bool multibytep
= coding
->src_multibyte
;
1908 int consumed_chars
= 0;
1909 bool mseq_found
= 0;
1915 charset_ID
= emacs_mule_charset
[0];
1921 if (cmp_status
->state
!= COMPOSING_NO
1922 && cmp_status
->old_form
)
1924 if (cmp_status
->state
== COMPOSING_CHAR
)
1939 *nbytes
= src
- src_base
;
1940 *nchars
= consumed_chars
;
1948 switch (emacs_mule_bytes
[c
])
1951 if ((charset_ID
= emacs_mule_charset
[c
]) < 0)
1960 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1961 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1964 if (c
< 0xA0 || (charset_ID
= emacs_mule_charset
[c
]) < 0)
1973 if ((charset_ID
= emacs_mule_charset
[c
]) < 0)
1978 code
= (c
& 0x7F) << 8;
1988 if (c
< 0 || (charset_ID
= emacs_mule_charset
[c
]) < 0)
1993 code
= (c
& 0x7F) << 8;
2002 charset_ID
= ASCII_BYTE_P (code
) ? charset_ascii
: charset_eight_bit
;
2008 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
2009 CHARSET_FROM_ID (charset_ID
), code
, c
);
2013 *nbytes
= src
- src_base
;
2014 *nchars
= consumed_chars
;
2017 return (mseq_found
? -c
: c
);
2027 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2029 /* Handle these composition sequence ('|': the end of header elements,
2030 BYTES and CHARS >= 0xA0):
2032 (1) relative composition: 0x80 0xF2 BYTES CHARS | CHAR ...
2033 (2) altchar composition: 0x80 0xF4 BYTES CHARS | ALT ... ALT CHAR ...
2034 (3) alt&rule composition: 0x80 0xF5 BYTES CHARS | ALT RULE ... ALT CHAR ...
2038 (4) relative composition: 0x80 | MSEQ ... MSEQ
2039 (5) rulebase composition: 0x80 0xFF | MSEQ MRULE ... MSEQ
2041 When the starter 0x80 and the following header elements are found,
2042 this annotation header is produced.
2044 [ -LENGTH(==-5) CODING_ANNOTATE_COMPOSITION_MASK NCHARS NBYTES METHOD ]
2046 NCHARS is CHARS - 0xA0 for (1), (2), (3), and 0 for (4), (5).
2047 NBYTES is BYTES - 0xA0 for (1), (2), (3), and 0 for (4), (5).
2049 Then, upon reading the following elements, these codes are produced
2050 until the composition end is found:
2053 (2) ALT ... ALT CHAR ... CHAR
2054 (3) ALT -2 DECODED-RULE ALT -2 DECODED-RULE ... ALT CHAR ... CHAR
2056 (5) CHAR -2 DECODED-RULE CHAR -2 DECODED-RULE ... CHAR
2058 When the composition end is found, LENGTH and NCHARS in the
2059 annotation header is updated as below:
2061 (1) LENGTH: unchanged, NCHARS: unchanged
2062 (2) LENGTH: length of the whole sequence minus NCHARS, NCHARS: unchanged
2063 (3) LENGTH: length of the whole sequence minus NCHARS, NCHARS: unchanged
2064 (4) LENGTH: unchanged, NCHARS: number of CHARs
2065 (5) LENGTH: unchanged, NCHARS: number of CHARs
2067 If an error is found while composing, the annotation header is
2068 changed to the original composition header (plus filler -1s) as
2071 (1),(2),(3) [ 0x80 0xF2+METHOD BYTES CHARS -1 ]
2072 (5) [ 0x80 0xFF -1 -1- -1 ]
2074 and the sequence [ -2 DECODED-RULE ] is changed to the original
2075 byte sequence as below:
2076 o the original byte sequence is B: [ B -1 ]
2077 o the original byte sequence is B1 B2: [ B1 B2 ]
2079 Most of the routines are implemented by macros because many
2080 variables and labels in the caller decode_coding_emacs_mule must be
2081 accessible, and they are usually called just once (thus doesn't
2082 increase the size of compiled object). */
2084 /* Decode a composition rule represented by C as a component of
2085 composition sequence of Emacs 20 style. Set RULE to the decoded
2088 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(c, rule) \
2093 if (c < 0 || c >= 81) \
2094 goto invalid_code; \
2095 gref = c / 9, nref = c % 9; \
2096 if (gref == 4) gref = 10; \
2097 if (nref == 4) nref = 10; \
2098 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
2102 /* Decode a composition rule represented by C and the following byte
2103 at SRC as a component of composition sequence of Emacs 21 style.
2104 Set RULE to the decoded rule. */
2106 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(c, rule) \
2111 if (gref < 0 || gref >= 81) \
2112 goto invalid_code; \
2113 ONE_MORE_BYTE (c); \
2115 if (nref < 0 || nref >= 81) \
2116 goto invalid_code; \
2117 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
2121 /* Start of Emacs 21 style format. The first three bytes at SRC are
2122 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is the
2123 byte length of this composition information, CHARS is the number of
2124 characters composed by this composition. */
2126 #define DECODE_EMACS_MULE_21_COMPOSITION() \
2128 enum composition_method method = c - 0xF2; \
2129 int nbytes, nchars; \
2131 ONE_MORE_BYTE (c); \
2133 goto invalid_code; \
2134 nbytes = c - 0xA0; \
2135 if (nbytes < 3 || (method == COMPOSITION_RELATIVE && nbytes != 4)) \
2136 goto invalid_code; \
2137 ONE_MORE_BYTE (c); \
2138 nchars = c - 0xA0; \
2139 if (nchars <= 0 || nchars >= MAX_COMPOSITION_COMPONENTS) \
2140 goto invalid_code; \
2141 cmp_status->old_form = 0; \
2142 cmp_status->method = method; \
2143 if (method == COMPOSITION_RELATIVE) \
2144 cmp_status->state = COMPOSING_CHAR; \
2146 cmp_status->state = COMPOSING_COMPONENT_CHAR; \
2147 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2148 cmp_status->nchars = nchars; \
2149 cmp_status->ncomps = nbytes - 4; \
2150 ADD_COMPOSITION_DATA (charbuf, nchars, nbytes, method); \
2154 /* Start of Emacs 20 style format for relative composition. */
2156 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION() \
2158 cmp_status->old_form = 1; \
2159 cmp_status->method = COMPOSITION_RELATIVE; \
2160 cmp_status->state = COMPOSING_CHAR; \
2161 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2162 cmp_status->nchars = cmp_status->ncomps = 0; \
2163 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
2167 /* Start of Emacs 20 style format for rule-base composition. */
2169 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION() \
2171 cmp_status->old_form = 1; \
2172 cmp_status->method = COMPOSITION_WITH_RULE; \
2173 cmp_status->state = COMPOSING_CHAR; \
2174 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2175 cmp_status->nchars = cmp_status->ncomps = 0; \
2176 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
2180 #define DECODE_EMACS_MULE_COMPOSITION_START() \
2182 const unsigned char *current_src = src; \
2184 ONE_MORE_BYTE (c); \
2186 goto invalid_code; \
2187 if (c - 0xF2 >= COMPOSITION_RELATIVE \
2188 && c - 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS) \
2189 DECODE_EMACS_MULE_21_COMPOSITION (); \
2190 else if (c < 0xA0) \
2191 goto invalid_code; \
2192 else if (c < 0xC0) \
2194 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (); \
2195 /* Re-read C as a composition component. */ \
2196 src = current_src; \
2198 else if (c == 0xFF) \
2199 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (); \
2201 goto invalid_code; \
2204 #define EMACS_MULE_COMPOSITION_END() \
2206 int idx = - cmp_status->length; \
2208 if (cmp_status->old_form) \
2209 charbuf[idx + 2] = cmp_status->nchars; \
2210 else if (cmp_status->method > COMPOSITION_RELATIVE) \
2211 charbuf[idx] = charbuf[idx + 2] - cmp_status->length; \
2212 cmp_status->state = COMPOSING_NO; \
2217 emacs_mule_finish_composition (int *charbuf
,
2218 struct composition_status
*cmp_status
)
2220 int idx
= - cmp_status
->length
;
2223 if (cmp_status
->old_form
&& cmp_status
->nchars
> 0)
2225 charbuf
[idx
+ 2] = cmp_status
->nchars
;
2227 if (cmp_status
->method
== COMPOSITION_WITH_RULE
2228 && cmp_status
->state
== COMPOSING_CHAR
)
2230 /* The last rule was invalid. */
2231 int rule
= charbuf
[-1] + 0xA0;
2233 charbuf
[-2] = BYTE8_TO_CHAR (rule
);
2240 charbuf
[idx
++] = BYTE8_TO_CHAR (0x80);
2242 if (cmp_status
->method
== COMPOSITION_WITH_RULE
)
2244 charbuf
[idx
++] = BYTE8_TO_CHAR (0xFF);
2245 charbuf
[idx
++] = -3;
2251 int nchars
= charbuf
[idx
+ 1] + 0xA0;
2252 int nbytes
= charbuf
[idx
+ 2] + 0xA0;
2254 charbuf
[idx
++] = BYTE8_TO_CHAR (0xF2 + cmp_status
->method
);
2255 charbuf
[idx
++] = BYTE8_TO_CHAR (nbytes
);
2256 charbuf
[idx
++] = BYTE8_TO_CHAR (nchars
);
2257 charbuf
[idx
++] = -1;
2261 cmp_status
->state
= COMPOSING_NO
;
2265 #define EMACS_MULE_MAYBE_FINISH_COMPOSITION() \
2267 if (cmp_status->state != COMPOSING_NO) \
2268 char_offset += emacs_mule_finish_composition (charbuf, cmp_status); \
2273 decode_coding_emacs_mule (struct coding_system
*coding
)
2275 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2276 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2277 const unsigned char *src_base
;
2278 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2279 /* We may produce two annotations (charset and composition) in one
2280 loop and one more charset annotation at the end. */
2282 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 3)
2283 /* We can produce up to 2 characters in a loop. */
2285 ptrdiff_t consumed_chars
= 0, consumed_chars_base
;
2286 bool multibytep
= coding
->src_multibyte
;
2287 ptrdiff_t char_offset
= coding
->produced_char
;
2288 ptrdiff_t last_offset
= char_offset
;
2289 int last_id
= charset_ascii
;
2291 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
2292 int byte_after_cr
= -1;
2293 struct composition_status
*cmp_status
= &coding
->spec
.emacs_mule
.cmp_status
;
2295 if (cmp_status
->state
!= COMPOSING_NO
)
2299 if (charbuf_end
- charbuf
< cmp_status
->length
)
2301 for (i
= 0; i
< cmp_status
->length
; i
++)
2302 *charbuf
++ = cmp_status
->carryover
[i
];
2303 coding
->annotated
= 1;
2308 int c
, id
IF_LINT (= 0);
2311 consumed_chars_base
= consumed_chars
;
2313 if (charbuf
>= charbuf_end
)
2315 if (byte_after_cr
>= 0)
2320 if (byte_after_cr
>= 0)
2321 c
= byte_after_cr
, byte_after_cr
= -1;
2325 if (c
< 0 || c
== 0x80)
2327 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2334 DECODE_EMACS_MULE_COMPOSITION_START ();
2340 if (eol_dos
&& c
== '\r')
2341 ONE_MORE_BYTE (byte_after_cr
);
2343 if (cmp_status
->state
!= COMPOSING_NO
)
2345 if (cmp_status
->old_form
)
2346 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2347 else if (cmp_status
->state
>= COMPOSING_COMPONENT_CHAR
)
2348 cmp_status
->ncomps
--;
2353 int nchars
IF_LINT (= 0), nbytes
IF_LINT (= 0);
2354 /* emacs_mule_char can load a charset map from a file, which
2355 allocates a large structure and might cause buffer text
2356 to be relocated as result. Thus, we need to remember the
2357 original pointer to buffer text, and fix up all related
2358 pointers after the call. */
2359 const unsigned char *orig
= coding
->source
;
2362 c
= emacs_mule_char (coding
, src_base
, &nbytes
, &nchars
, &id
,
2364 offset
= coding
->source
- orig
;
2378 src
= src_base
+ nbytes
;
2379 consumed_chars
= consumed_chars_base
+ nchars
;
2380 if (cmp_status
->state
>= COMPOSING_COMPONENT_CHAR
)
2381 cmp_status
->ncomps
-= nchars
;
2384 /* Now if C >= 0, we found a normally encoded character, if C <
2385 0, we found an old-style composition component character or
2388 if (cmp_status
->state
== COMPOSING_NO
)
2392 if (last_id
!= charset_ascii
)
2393 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
,
2396 last_offset
= char_offset
;
2401 else if (cmp_status
->state
== COMPOSING_CHAR
)
2403 if (cmp_status
->old_form
)
2407 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2414 cmp_status
->nchars
++;
2415 cmp_status
->length
++;
2416 if (cmp_status
->nchars
== MAX_COMPOSITION_COMPONENTS
)
2417 EMACS_MULE_COMPOSITION_END ();
2418 else if (cmp_status
->method
== COMPOSITION_WITH_RULE
)
2419 cmp_status
->state
= COMPOSING_RULE
;
2425 cmp_status
->length
++;
2426 cmp_status
->nchars
--;
2427 if (cmp_status
->nchars
== 0)
2428 EMACS_MULE_COMPOSITION_END ();
2431 else if (cmp_status
->state
== COMPOSING_RULE
)
2437 EMACS_MULE_COMPOSITION_END ();
2444 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (c
, rule
);
2449 cmp_status
->length
+= 2;
2450 cmp_status
->state
= COMPOSING_CHAR
;
2453 else if (cmp_status
->state
== COMPOSING_COMPONENT_CHAR
)
2456 cmp_status
->length
++;
2457 if (cmp_status
->ncomps
== 0)
2458 cmp_status
->state
= COMPOSING_CHAR
;
2459 else if (cmp_status
->ncomps
> 0)
2461 if (cmp_status
->method
== COMPOSITION_WITH_RULE_ALTCHARS
)
2462 cmp_status
->state
= COMPOSING_COMPONENT_RULE
;
2465 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2467 else /* COMPOSING_COMPONENT_RULE */
2471 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (c
, rule
);
2476 cmp_status
->length
+= 2;
2477 cmp_status
->ncomps
--;
2478 if (cmp_status
->ncomps
> 0)
2479 cmp_status
->state
= COMPOSING_COMPONENT_CHAR
;
2481 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2486 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2488 consumed_chars
= consumed_chars_base
;
2490 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2496 if (cmp_status
->state
!= COMPOSING_NO
)
2498 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
2499 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2504 charbuf
-= cmp_status
->length
;
2505 for (i
= 0; i
< cmp_status
->length
; i
++)
2506 cmp_status
->carryover
[i
] = charbuf
[i
];
2509 if (last_id
!= charset_ascii
)
2510 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2511 coding
->consumed_char
+= consumed_chars_base
;
2512 coding
->consumed
= src_base
- coding
->source
;
2513 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2517 #define EMACS_MULE_LEADING_CODES(id, codes) \
2520 codes[0] = id, codes[1] = 0; \
2521 else if (id < 0xE0) \
2522 codes[0] = 0x9A, codes[1] = id; \
2523 else if (id < 0xF0) \
2524 codes[0] = 0x9B, codes[1] = id; \
2525 else if (id < 0xF5) \
2526 codes[0] = 0x9C, codes[1] = id; \
2528 codes[0] = 0x9D, codes[1] = id; \
2533 encode_coding_emacs_mule (struct coding_system
*coding
)
2535 bool multibytep
= coding
->dst_multibyte
;
2536 int *charbuf
= coding
->charbuf
;
2537 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2538 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2539 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2541 ptrdiff_t produced_chars
= 0;
2542 Lisp_Object attrs
, charset_list
;
2544 int preferred_charset_id
= -1;
2546 CODING_GET_INFO (coding
, attrs
, charset_list
);
2547 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2549 charset_list
= Vemacs_mule_charset_list
;
2550 ASET (attrs
, coding_attr_charset_list
, charset_list
);
2553 while (charbuf
< charbuf_end
)
2555 ASSURE_DESTINATION (safe_room
);
2560 /* Handle an annotation. */
2563 case CODING_ANNOTATE_COMPOSITION_MASK
:
2564 /* Not yet implemented. */
2566 case CODING_ANNOTATE_CHARSET_MASK
:
2567 preferred_charset_id
= charbuf
[3];
2568 if (preferred_charset_id
>= 0
2569 && NILP (Fmemq (make_number (preferred_charset_id
),
2571 preferred_charset_id
= -1;
2580 if (ASCII_CHAR_P (c
))
2581 EMIT_ONE_ASCII_BYTE (c
);
2582 else if (CHAR_BYTE8_P (c
))
2584 c
= CHAR_TO_BYTE8 (c
);
2589 struct charset
*charset
;
2593 unsigned char leading_codes
[2];
2595 if (preferred_charset_id
>= 0)
2599 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2600 CODING_CHAR_CHARSET_P (coding
, dst
, dst_end
, c
, charset
, result
);
2602 code
= ENCODE_CHAR (charset
, c
);
2604 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
2608 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
2612 c
= coding
->default_char
;
2613 if (ASCII_CHAR_P (c
))
2615 EMIT_ONE_ASCII_BYTE (c
);
2618 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
2621 dimension
= CHARSET_DIMENSION (charset
);
2622 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2623 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2624 EMIT_ONE_BYTE (leading_codes
[0]);
2625 if (leading_codes
[1])
2626 EMIT_ONE_BYTE (leading_codes
[1]);
2628 EMIT_ONE_BYTE (code
| 0x80);
2632 EMIT_ONE_BYTE (code
>> 8);
2633 EMIT_ONE_BYTE (code
& 0xFF);
2637 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2638 coding
->produced_char
+= produced_chars
;
2639 coding
->produced
= dst
- coding
->destination
;
2644 /*** 7. ISO2022 handlers ***/
2646 /* The following note describes the coding system ISO2022 briefly.
2647 Since the intention of this note is to help understand the
2648 functions in this file, some parts are NOT ACCURATE or are OVERLY
2649 SIMPLIFIED. For thorough understanding, please refer to the
2650 original document of ISO2022. This is equivalent to the standard
2651 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2653 ISO2022 provides many mechanisms to encode several character sets
2654 in 7-bit and 8-bit environments. For 7-bit environments, all text
2655 is encoded using bytes less than 128. This may make the encoded
2656 text a little bit longer, but the text passes more easily through
2657 several types of gateway, some of which strip off the MSB (Most
2660 There are two kinds of character sets: control character sets and
2661 graphic character sets. The former contain control characters such
2662 as `newline' and `escape' to provide control functions (control
2663 functions are also provided by escape sequences). The latter
2664 contain graphic characters such as 'A' and '-'. Emacs recognizes
2665 two control character sets and many graphic character sets.
2667 Graphic character sets are classified into one of the following
2668 four classes, according to the number of bytes (DIMENSION) and
2669 number of characters in one dimension (CHARS) of the set:
2670 - DIMENSION1_CHARS94
2671 - DIMENSION1_CHARS96
2672 - DIMENSION2_CHARS94
2673 - DIMENSION2_CHARS96
2675 In addition, each character set is assigned an identification tag,
2676 unique for each set, called the "final character" (denoted as <F>
2677 hereafter). The <F> of each character set is decided by ECMA(*)
2678 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2679 (0x30..0x3F are for private use only).
2681 Note (*): ECMA = European Computer Manufacturers Association
2683 Here are examples of graphic character sets [NAME(<F>)]:
2684 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2685 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2686 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2687 o DIMENSION2_CHARS96 -- none for the moment
2689 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2690 C0 [0x00..0x1F] -- control character plane 0
2691 GL [0x20..0x7F] -- graphic character plane 0
2692 C1 [0x80..0x9F] -- control character plane 1
2693 GR [0xA0..0xFF] -- graphic character plane 1
2695 A control character set is directly designated and invoked to C0 or
2696 C1 by an escape sequence. The most common case is that:
2697 - ISO646's control character set is designated/invoked to C0, and
2698 - ISO6429's control character set is designated/invoked to C1,
2699 and usually these designations/invocations are omitted in encoded
2700 text. In a 7-bit environment, only C0 can be used, and a control
2701 character for C1 is encoded by an appropriate escape sequence to
2702 fit into the environment. All control characters for C1 are
2703 defined to have corresponding escape sequences.
2705 A graphic character set is at first designated to one of four
2706 graphic registers (G0 through G3), then these graphic registers are
2707 invoked to GL or GR. These designations and invocations can be
2708 done independently. The most common case is that G0 is invoked to
2709 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2710 these invocations and designations are omitted in encoded text.
2711 In a 7-bit environment, only GL can be used.
2713 When a graphic character set of CHARS94 is invoked to GL, codes
2714 0x20 and 0x7F of the GL area work as control characters SPACE and
2715 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2718 There are two ways of invocation: locking-shift and single-shift.
2719 With locking-shift, the invocation lasts until the next different
2720 invocation, whereas with single-shift, the invocation affects the
2721 following character only and doesn't affect the locking-shift
2722 state. Invocations are done by the following control characters or
2725 ----------------------------------------------------------------------
2726 abbrev function cntrl escape seq description
2727 ----------------------------------------------------------------------
2728 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2729 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2730 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2731 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2732 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2733 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2734 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2735 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2736 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2737 ----------------------------------------------------------------------
2738 (*) These are not used by any known coding system.
2740 Control characters for these functions are defined by macros
2741 ISO_CODE_XXX in `coding.h'.
2743 Designations are done by the following escape sequences:
2744 ----------------------------------------------------------------------
2745 escape sequence description
2746 ----------------------------------------------------------------------
2747 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2748 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2749 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2750 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2751 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2752 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2753 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2754 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2755 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2756 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2757 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2758 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2759 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2760 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2761 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2762 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2763 ----------------------------------------------------------------------
2765 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2766 of dimension 1, chars 94, and final character <F>, etc...
2768 Note (*): Although these designations are not allowed in ISO2022,
2769 Emacs accepts them on decoding, and produces them on encoding
2770 CHARS96 character sets in a coding system which is characterized as
2771 7-bit environment, non-locking-shift, and non-single-shift.
2773 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2774 '(' must be omitted. We refer to this as "short-form" hereafter.
2776 Now you may notice that there are a lot of ways of encoding the
2777 same multilingual text in ISO2022. Actually, there exist many
2778 coding systems such as Compound Text (used in X11's inter client
2779 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2780 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2781 localized platforms), and all of these are variants of ISO2022.
2783 In addition to the above, Emacs handles two more kinds of escape
2784 sequences: ISO6429's direction specification and Emacs' private
2785 sequence for specifying character composition.
2787 ISO6429's direction specification takes the following form:
2788 o CSI ']' -- end of the current direction
2789 o CSI '0' ']' -- end of the current direction
2790 o CSI '1' ']' -- start of left-to-right text
2791 o CSI '2' ']' -- start of right-to-left text
2792 The control character CSI (0x9B: control sequence introducer) is
2793 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2795 Character composition specification takes the following form:
2796 o ESC '0' -- start relative composition
2797 o ESC '1' -- end composition
2798 o ESC '2' -- start rule-base composition (*)
2799 o ESC '3' -- start relative composition with alternate chars (**)
2800 o ESC '4' -- start rule-base composition with alternate chars (**)
2801 Since these are not standard escape sequences of any ISO standard,
2802 the use of them with these meanings is restricted to Emacs only.
2804 (*) This form is used only in Emacs 20.7 and older versions,
2805 but newer versions can safely decode it.
2806 (**) This form is used only in Emacs 21.1 and newer versions,
2807 and older versions can't decode it.
2809 Here's a list of example usages of these composition escape
2810 sequences (categorized by `enum composition_method').
2812 COMPOSITION_RELATIVE:
2813 ESC 0 CHAR [ CHAR ] ESC 1
2814 COMPOSITION_WITH_RULE:
2815 ESC 2 CHAR [ RULE CHAR ] ESC 1
2816 COMPOSITION_WITH_ALTCHARS:
2817 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2818 COMPOSITION_WITH_RULE_ALTCHARS:
2819 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2821 static enum iso_code_class_type iso_code_class
[256];
2823 #define SAFE_CHARSET_P(coding, id) \
2824 ((id) <= (coding)->max_charset_id \
2825 && (coding)->safe_charsets[id] != 255)
2828 setup_iso_safe_charsets (Lisp_Object attrs
)
2830 Lisp_Object charset_list
, safe_charsets
;
2831 Lisp_Object request
;
2832 Lisp_Object reg_usage
;
2834 EMACS_INT reg94
, reg96
;
2835 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2838 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2839 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2840 && ! EQ (charset_list
, Viso_2022_charset_list
))
2842 charset_list
= Viso_2022_charset_list
;
2843 ASET (attrs
, coding_attr_charset_list
, charset_list
);
2844 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2847 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2851 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2853 int id
= XINT (XCAR (tail
));
2854 if (max_charset_id
< id
)
2855 max_charset_id
= id
;
2858 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
2859 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
2860 request
= AREF (attrs
, coding_attr_iso_request
);
2861 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2862 reg94
= XINT (XCAR (reg_usage
));
2863 reg96
= XINT (XCDR (reg_usage
));
2865 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2869 struct charset
*charset
;
2872 charset
= CHARSET_FROM_ID (XINT (id
));
2873 reg
= Fcdr (Fassq (id
, request
));
2875 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2876 else if (charset
->iso_chars_96
)
2879 SSET (safe_charsets
, XINT (id
), reg96
);
2884 SSET (safe_charsets
, XINT (id
), reg94
);
2887 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2891 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2892 Return true if a text is encoded in one of ISO-2022 based coding
2896 detect_coding_iso_2022 (struct coding_system
*coding
,
2897 struct coding_detection_info
*detect_info
)
2899 const unsigned char *src
= coding
->source
, *src_base
= src
;
2900 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2901 bool multibytep
= coding
->src_multibyte
;
2902 bool single_shifting
= 0;
2905 ptrdiff_t consumed_chars
= 0;
2909 int composition_count
= -1;
2911 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2913 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2915 struct coding_system
*this = &(coding_categories
[i
]);
2916 Lisp_Object attrs
, val
;
2920 attrs
= CODING_ID_ATTRS (this->id
);
2921 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2922 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Viso_2022_charset_list
))
2923 setup_iso_safe_charsets (attrs
);
2924 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2925 this->max_charset_id
= SCHARS (val
) - 1;
2926 this->safe_charsets
= SDATA (val
);
2929 /* A coding system of this category is always ASCII compatible. */
2930 src
+= coding
->head_ascii
;
2932 while (rejected
!= CATEGORY_MASK_ISO
)
2939 if (inhibit_iso_escape_detection
)
2941 single_shifting
= 0;
2943 if (c
== 'N' || c
== 'O')
2945 /* ESC <Fe> for SS2 or SS3. */
2946 single_shifting
= 1;
2947 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2951 /* End of composition. */
2952 if (composition_count
< 0
2953 || composition_count
> MAX_COMPOSITION_COMPONENTS
)
2956 composition_count
= -1;
2957 found
|= CATEGORY_MASK_ISO
;
2959 else if (c
>= '0' && c
<= '4')
2961 /* ESC <Fp> for start/end composition. */
2962 composition_count
= 0;
2966 if (c
>= '(' && c
<= '/')
2968 /* Designation sequence for a charset of dimension 1. */
2970 if (c1
< ' ' || c1
>= 0x80
2971 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2972 /* Invalid designation sequence. Just ignore. */
2977 /* Designation sequence for a charset of dimension 2. */
2979 if (c
>= '@' && c
<= 'B')
2980 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2981 id
= iso_charset_table
[1][0][c
];
2982 else if (c
>= '(' && c
<= '/')
2985 if (c1
< ' ' || c1
>= 0x80
2986 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2987 /* Invalid designation sequence. Just ignore. */
2991 /* Invalid designation sequence. Just ignore it. */
2996 /* Invalid escape sequence. Just ignore it. */
3000 /* We found a valid designation sequence for CHARSET. */
3001 rejected
|= CATEGORY_MASK_ISO_8BIT
;
3002 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
3004 found
|= CATEGORY_MASK_ISO_7
;
3006 rejected
|= CATEGORY_MASK_ISO_7
;
3007 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
3009 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
3011 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
3012 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
3014 found
|= CATEGORY_MASK_ISO_7_ELSE
;
3016 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
3017 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
3019 found
|= CATEGORY_MASK_ISO_8_ELSE
;
3021 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
3027 /* Locking shift out/in. */
3028 if (inhibit_iso_escape_detection
)
3030 single_shifting
= 0;
3031 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
3035 /* Control sequence introducer. */
3036 single_shifting
= 0;
3037 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
3038 found
|= CATEGORY_MASK_ISO_8_ELSE
;
3039 goto check_extra_latin
;
3044 if (inhibit_iso_escape_detection
)
3046 single_shifting
= 0;
3047 rejected
|= CATEGORY_MASK_ISO_7BIT
;
3048 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
3049 & CODING_ISO_FLAG_SINGLE_SHIFT
)
3051 found
|= CATEGORY_MASK_ISO_8_1
;
3052 single_shifting
= 1;
3054 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
3055 & CODING_ISO_FLAG_SINGLE_SHIFT
)
3057 found
|= CATEGORY_MASK_ISO_8_2
;
3058 single_shifting
= 1;
3060 if (single_shifting
)
3063 if (! VECTORP (Vlatin_extra_code_table
)
3064 || NILP (AREF (Vlatin_extra_code_table
, c
)))
3066 rejected
= CATEGORY_MASK_ISO
;
3069 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
3070 & CODING_ISO_FLAG_LATIN_EXTRA
)
3071 found
|= CATEGORY_MASK_ISO_8_1
;
3073 rejected
|= CATEGORY_MASK_ISO_8_1
;
3074 rejected
|= CATEGORY_MASK_ISO_8_2
;
3082 if (composition_count
>= 0)
3083 composition_count
++;
3084 single_shifting
= 0;
3089 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
3090 found
|= CATEGORY_MASK_ISO_8_1
;
3091 /* Check the length of succeeding codes of the range
3092 0xA0..0FF. If the byte length is even, we include
3093 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
3094 only when we are not single shifting. */
3095 if (! single_shifting
3096 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
3099 while (src
< src_end
)
3111 if (len
& 1 && src
< src_end
)
3113 rejected
|= CATEGORY_MASK_ISO_8_2
;
3114 if (composition_count
>= 0)
3115 composition_count
+= len
;
3119 found
|= CATEGORY_MASK_ISO_8_2
;
3120 if (composition_count
>= 0)
3121 composition_count
+= len
/ 2;
3128 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
3132 detect_info
->rejected
|= rejected
;
3133 detect_info
->found
|= (found
& ~rejected
);
3138 /* Set designation state into CODING. Set CHARS_96 to -1 if the
3139 escape sequence should be kept. */
3140 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
3144 if (final < '0' || final >= 128 \
3145 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
3146 || !SAFE_CHARSET_P (coding, id)) \
3148 CODING_ISO_DESIGNATION (coding, reg) = -2; \
3152 prev = CODING_ISO_DESIGNATION (coding, reg); \
3153 if (id == charset_jisx0201_roman) \
3155 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3156 id = charset_ascii; \
3158 else if (id == charset_jisx0208_1978) \
3160 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3161 id = charset_jisx0208; \
3163 CODING_ISO_DESIGNATION (coding, reg) = id; \
3164 /* If there was an invalid designation to REG previously, and this \
3165 designation is ASCII to REG, we should keep this designation \
3167 if (prev == -2 && id == charset_ascii) \
3172 /* Handle these composition sequence (ALT: alternate char):
3174 (1) relative composition: ESC 0 CHAR ... ESC 1
3175 (2) rulebase composition: ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
3176 (3) altchar composition: ESC 3 ALT ... ALT ESC 0 CHAR ... ESC 1
3177 (4) alt&rule composition: ESC 4 ALT RULE ... ALT ESC 0 CHAR ... ESC 1
3179 When the start sequence (ESC 0/2/3/4) is found, this annotation
3182 [ -LENGTH(==-5) CODING_ANNOTATE_COMPOSITION_MASK NCHARS(==0) 0 METHOD ]
3184 Then, upon reading CHAR or RULE (one or two bytes), these codes are
3185 produced until the end sequence (ESC 1) is found:
3188 (2) CHAR -2 DECODED-RULE CHAR -2 DECODED-RULE ... CHAR
3189 (3) ALT ... ALT -1 -1 CHAR ... CHAR
3190 (4) ALT -2 DECODED-RULE ALT -2 DECODED-RULE ... ALT -1 -1 CHAR ... CHAR
3192 When the end sequence (ESC 1) is found, LENGTH and NCHARS in the
3193 annotation header is updated as below:
3195 (1) LENGTH: unchanged, NCHARS: number of CHARs
3196 (2) LENGTH: unchanged, NCHARS: number of CHARs
3197 (3) LENGTH: += number of ALTs + 2, NCHARS: number of CHARs
3198 (4) LENGTH: += number of ALTs * 3, NCHARS: number of CHARs
3200 If an error is found while composing, the annotation header is
3203 [ ESC '0'/'2'/'3'/'4' -2 0 ]
3205 and the sequence [ -2 DECODED-RULE ] is changed to the original
3206 byte sequence as below:
3207 o the original byte sequence is B: [ B -1 ]
3208 o the original byte sequence is B1 B2: [ B1 B2 ]
3209 and the sequence [ -1 -1 ] is changed to the original byte
3214 /* Decode a composition rule C1 and maybe one more byte from the
3215 source, and set RULE to the encoded composition rule. If the rule
3216 is invalid, goto invalid_code. */
3218 #define DECODE_COMPOSITION_RULE(rule) \
3222 goto invalid_code; \
3223 if (rule < 81) /* old format (before ver.21) */ \
3225 int gref = (rule) / 9; \
3226 int nref = (rule) % 9; \
3227 if (gref == 4) gref = 10; \
3228 if (nref == 4) nref = 10; \
3229 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
3231 else /* new format (after ver.21) */ \
3235 ONE_MORE_BYTE (b); \
3236 if (! COMPOSITION_ENCODE_RULE_VALID (rule - 81, b - 32)) \
3237 goto invalid_code; \
3238 rule = COMPOSITION_ENCODE_RULE (rule - 81, b - 32); \
3239 rule += 0x100; /* Distinguish it from the old format. */ \
3243 #define ENCODE_COMPOSITION_RULE(rule) \
3245 int gref = (rule % 0x100) / 12, nref = (rule % 0x100) % 12; \
3247 if (rule < 0x100) /* old format */ \
3249 if (gref == 10) gref = 4; \
3250 if (nref == 10) nref = 4; \
3251 charbuf[idx] = 32 + gref * 9 + nref; \
3252 charbuf[idx + 1] = -1; \
3255 else /* new format */ \
3257 charbuf[idx] = 32 + 81 + gref; \
3258 charbuf[idx + 1] = 32 + nref; \
3263 /* Finish the current composition as invalid. */
3266 finish_composition (int *charbuf
, struct composition_status
*cmp_status
)
3268 int idx
= - cmp_status
->length
;
3271 /* Recover the original ESC sequence */
3272 charbuf
[idx
++] = ISO_CODE_ESC
;
3273 charbuf
[idx
++] = (cmp_status
->method
== COMPOSITION_RELATIVE
? '0'
3274 : cmp_status
->method
== COMPOSITION_WITH_RULE
? '2'
3275 : cmp_status
->method
== COMPOSITION_WITH_ALTCHARS
? '3'
3276 /* cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS */
3278 charbuf
[idx
++] = -2;
3280 charbuf
[idx
++] = -1;
3281 new_chars
= cmp_status
->nchars
;
3282 if (cmp_status
->method
>= COMPOSITION_WITH_RULE
)
3283 for (; idx
< 0; idx
++)
3285 int elt
= charbuf
[idx
];
3289 ENCODE_COMPOSITION_RULE (charbuf
[idx
+ 1]);
3294 charbuf
[idx
++] = ISO_CODE_ESC
;
3299 cmp_status
->state
= COMPOSING_NO
;
3303 /* If characters are under composition, finish the composition. */
3304 #define MAYBE_FINISH_COMPOSITION() \
3306 if (cmp_status->state != COMPOSING_NO) \
3307 char_offset += finish_composition (charbuf, cmp_status); \
3310 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
3312 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
3313 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
3314 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
3315 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
3317 Produce this annotation sequence now:
3319 [ -LENGTH(==-4) CODING_ANNOTATE_COMPOSITION_MASK NCHARS(==0) METHOD ]
3322 #define DECODE_COMPOSITION_START(c1) \
3325 && ((cmp_status->state == COMPOSING_COMPONENT_CHAR \
3326 && cmp_status->method == COMPOSITION_WITH_ALTCHARS) \
3327 || (cmp_status->state == COMPOSING_COMPONENT_RULE \
3328 && cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS))) \
3332 cmp_status->state = COMPOSING_CHAR; \
3333 cmp_status->length += 2; \
3337 MAYBE_FINISH_COMPOSITION (); \
3338 cmp_status->method = (c1 == '0' ? COMPOSITION_RELATIVE \
3339 : c1 == '2' ? COMPOSITION_WITH_RULE \
3340 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
3341 : COMPOSITION_WITH_RULE_ALTCHARS); \
3343 = (c1 <= '2' ? COMPOSING_CHAR : COMPOSING_COMPONENT_CHAR); \
3344 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
3345 cmp_status->length = MAX_ANNOTATION_LENGTH; \
3346 cmp_status->nchars = cmp_status->ncomps = 0; \
3347 coding->annotated = 1; \
3352 /* Handle composition end sequence ESC 1. */
3354 #define DECODE_COMPOSITION_END() \
3356 if (cmp_status->nchars == 0 \
3357 || ((cmp_status->state == COMPOSING_CHAR) \
3358 == (cmp_status->method == COMPOSITION_WITH_RULE))) \
3360 MAYBE_FINISH_COMPOSITION (); \
3361 goto invalid_code; \
3363 if (cmp_status->method == COMPOSITION_WITH_ALTCHARS) \
3364 charbuf[- cmp_status->length] -= cmp_status->ncomps + 2; \
3365 else if (cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS) \
3366 charbuf[- cmp_status->length] -= cmp_status->ncomps * 3; \
3367 charbuf[- cmp_status->length + 2] = cmp_status->nchars; \
3368 char_offset += cmp_status->nchars; \
3369 cmp_status->state = COMPOSING_NO; \
3372 /* Store a composition rule RULE in charbuf, and update cmp_status. */
3374 #define STORE_COMPOSITION_RULE(rule) \
3377 *charbuf++ = rule; \
3378 cmp_status->length += 2; \
3379 cmp_status->state--; \
3382 /* Store a composed char or a component char C in charbuf, and update
3385 #define STORE_COMPOSITION_CHAR(c) \
3388 cmp_status->length++; \
3389 if (cmp_status->state == COMPOSING_CHAR) \
3390 cmp_status->nchars++; \
3392 cmp_status->ncomps++; \
3393 if (cmp_status->method == COMPOSITION_WITH_RULE \
3394 || (cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS \
3395 && cmp_status->state == COMPOSING_COMPONENT_CHAR)) \
3396 cmp_status->state++; \
3400 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
3403 decode_coding_iso_2022 (struct coding_system
*coding
)
3405 const unsigned char *src
= coding
->source
+ coding
->consumed
;
3406 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3407 const unsigned char *src_base
;
3408 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
3409 /* We may produce two annotations (charset and composition) in one
3410 loop and one more charset annotation at the end. */
3412 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 3);
3413 ptrdiff_t consumed_chars
= 0, consumed_chars_base
;
3414 bool multibytep
= coding
->src_multibyte
;
3415 /* Charsets invoked to graphic plane 0 and 1 respectively. */
3416 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3417 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3418 int charset_id_2
, charset_id_3
;
3419 struct charset
*charset
;
3421 struct composition_status
*cmp_status
= CODING_ISO_CMP_STATUS (coding
);
3422 Lisp_Object attrs
= CODING_ID_ATTRS (coding
->id
);
3423 ptrdiff_t char_offset
= coding
->produced_char
;
3424 ptrdiff_t last_offset
= char_offset
;
3425 int last_id
= charset_ascii
;
3427 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
3428 int byte_after_cr
= -1;
3431 setup_iso_safe_charsets (attrs
);
3432 coding
->safe_charsets
= SDATA (CODING_ATTR_SAFE_CHARSETS (attrs
));
3434 if (cmp_status
->state
!= COMPOSING_NO
)
3436 if (charbuf_end
- charbuf
< cmp_status
->length
)
3438 for (i
= 0; i
< cmp_status
->length
; i
++)
3439 *charbuf
++ = cmp_status
->carryover
[i
];
3440 coding
->annotated
= 1;
3448 consumed_chars_base
= consumed_chars
;
3450 if (charbuf
>= charbuf_end
)
3452 if (byte_after_cr
>= 0)
3457 if (byte_after_cr
>= 0)
3458 c1
= byte_after_cr
, byte_after_cr
= -1;
3464 if (CODING_ISO_EXTSEGMENT_LEN (coding
) > 0)
3466 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3468 CODING_ISO_EXTSEGMENT_LEN (coding
)--;
3472 if (CODING_ISO_EMBEDDED_UTF_8 (coding
))
3474 if (c1
== ISO_CODE_ESC
)
3476 if (src
+ 1 >= src_end
)
3477 goto no_more_source
;
3478 *charbuf
++ = ISO_CODE_ESC
;
3480 if (src
[0] == '%' && src
[1] == '@')
3483 consumed_chars
+= 2;
3485 /* We are sure charbuf can contain two more chars. */
3488 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 0;
3493 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3499 if ((cmp_status
->state
== COMPOSING_RULE
3500 || cmp_status
->state
== COMPOSING_COMPONENT_RULE
)
3501 && c1
!= ISO_CODE_ESC
)
3505 DECODE_COMPOSITION_RULE (rule
);
3506 STORE_COMPOSITION_RULE (rule
);
3510 /* We produce at most one character. */
3511 switch (iso_code_class
[c1
])
3513 case ISO_0x20_or_0x7F
:
3514 if (charset_id_0
< 0
3515 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
3516 /* This is SPACE or DEL. */
3517 charset
= CHARSET_FROM_ID (charset_ascii
);
3519 charset
= CHARSET_FROM_ID (charset_id_0
);
3522 case ISO_graphic_plane_0
:
3523 if (charset_id_0
< 0)
3524 charset
= CHARSET_FROM_ID (charset_ascii
);
3526 charset
= CHARSET_FROM_ID (charset_id_0
);
3529 case ISO_0xA0_or_0xFF
:
3530 if (charset_id_1
< 0
3531 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
3532 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
3534 /* This is a graphic character, we fall down ... */
3536 case ISO_graphic_plane_1
:
3537 if (charset_id_1
< 0)
3539 charset
= CHARSET_FROM_ID (charset_id_1
);
3543 if (eol_dos
&& c1
== '\r')
3544 ONE_MORE_BYTE (byte_after_cr
);
3545 MAYBE_FINISH_COMPOSITION ();
3546 charset
= CHARSET_FROM_ID (charset_ascii
);
3553 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3554 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3556 CODING_ISO_INVOCATION (coding
, 0) = 1;
3557 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3561 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3563 CODING_ISO_INVOCATION (coding
, 0) = 0;
3564 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3567 case ISO_single_shift_2_7
:
3568 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
))
3570 case ISO_single_shift_2
:
3571 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3573 /* SS2 is handled as an escape sequence of ESC 'N' */
3575 goto label_escape_sequence
;
3577 case ISO_single_shift_3
:
3578 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3580 /* SS2 is handled as an escape sequence of ESC 'O' */
3582 goto label_escape_sequence
;
3584 case ISO_control_sequence_introducer
:
3585 /* CSI is handled as an escape sequence of ESC '[' ... */
3587 goto label_escape_sequence
;
3591 label_escape_sequence
:
3592 /* Escape sequences handled here are invocation,
3593 designation, direction specification, and character
3594 composition specification. */
3597 case '&': /* revision of following character set */
3599 if (!(c1
>= '@' && c1
<= '~'))
3602 if (c1
!= ISO_CODE_ESC
)
3605 goto label_escape_sequence
;
3607 case '$': /* designation of 2-byte character set */
3608 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3614 if (c1
>= '@' && c1
<= 'B')
3615 { /* designation of JISX0208.1978, GB2312.1980,
3617 reg
= 0, chars96
= 0;
3619 else if (c1
>= 0x28 && c1
<= 0x2B)
3620 { /* designation of DIMENSION2_CHARS94 character set */
3621 reg
= c1
- 0x28, chars96
= 0;
3624 else if (c1
>= 0x2C && c1
<= 0x2F)
3625 { /* designation of DIMENSION2_CHARS96 character set */
3626 reg
= c1
- 0x2C, chars96
= 1;
3631 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3632 /* We must update these variables now. */
3634 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3636 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3642 case 'n': /* invocation of locking-shift-2 */
3643 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3644 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3646 CODING_ISO_INVOCATION (coding
, 0) = 2;
3647 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3650 case 'o': /* invocation of locking-shift-3 */
3651 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3652 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3654 CODING_ISO_INVOCATION (coding
, 0) = 3;
3655 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3658 case 'N': /* invocation of single-shift-2 */
3659 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3660 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3662 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3663 if (charset_id_2
< 0)
3664 charset
= CHARSET_FROM_ID (charset_ascii
);
3666 charset
= CHARSET_FROM_ID (charset_id_2
);
3668 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3672 case 'O': /* invocation of single-shift-3 */
3673 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3674 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3676 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3677 if (charset_id_3
< 0)
3678 charset
= CHARSET_FROM_ID (charset_ascii
);
3680 charset
= CHARSET_FROM_ID (charset_id_3
);
3682 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3686 case '0': case '2': case '3': case '4': /* start composition */
3687 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3689 if (last_id
!= charset_ascii
)
3691 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3692 last_id
= charset_ascii
;
3693 last_offset
= char_offset
;
3695 DECODE_COMPOSITION_START (c1
);
3698 case '1': /* end composition */
3699 if (cmp_status
->state
== COMPOSING_NO
)
3701 DECODE_COMPOSITION_END ();
3704 case '[': /* specification of direction */
3705 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
))
3707 /* For the moment, nested direction is not supported.
3708 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3709 left-to-right, and nonzero means right-to-left. */
3713 case ']': /* end of the current direction */
3714 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3716 case '0': /* end of the current direction */
3717 case '1': /* start of left-to-right direction */
3720 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3725 case '2': /* start of right-to-left direction */
3728 coding
->mode
|= CODING_MODE_DIRECTION
;
3742 /* CTEXT extended segment:
3743 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3744 We keep these bytes as is for the moment.
3745 They may be decoded by post-read-conversion. */
3749 ONE_MORE_BYTE (dim
);
3750 if (dim
< '0' || dim
> '4')
3758 size
= ((M
- 128) * 128) + (L
- 128);
3759 if (charbuf
+ 6 > charbuf_end
)
3761 *charbuf
++ = ISO_CODE_ESC
;
3765 *charbuf
++ = BYTE8_TO_CHAR (M
);
3766 *charbuf
++ = BYTE8_TO_CHAR (L
);
3767 CODING_ISO_EXTSEGMENT_LEN (coding
) = size
;
3771 /* XFree86 extension for embedding UTF-8 in CTEXT:
3772 ESC % G --UTF-8-BYTES-- ESC % @
3773 We keep these bytes as is for the moment.
3774 They may be decoded by post-read-conversion. */
3775 if (charbuf
+ 3 > charbuf_end
)
3777 *charbuf
++ = ISO_CODE_ESC
;
3780 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 1;
3788 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3793 if (c1
>= 0x28 && c1
<= 0x2B)
3794 { /* designation of DIMENSION1_CHARS94 character set */
3795 reg
= c1
- 0x28, chars96
= 0;
3798 else if (c1
>= 0x2C && c1
<= 0x2F)
3799 { /* designation of DIMENSION1_CHARS96 character set */
3800 reg
= c1
- 0x2C, chars96
= 1;
3805 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3806 /* We must update these variables now. */
3808 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3810 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3822 if (cmp_status
->state
== COMPOSING_NO
3823 && charset
->id
!= charset_ascii
3824 && last_id
!= charset
->id
)
3826 if (last_id
!= charset_ascii
)
3827 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3828 last_id
= charset
->id
;
3829 last_offset
= char_offset
;
3832 /* Now we know CHARSET and 1st position code C1 of a character.
3833 Produce a decoded character while getting 2nd and 3rd
3834 position codes C2, C3 if necessary. */
3835 if (CHARSET_DIMENSION (charset
) > 1)
3838 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0)
3839 || ((c1
& 0x80) != (c2
& 0x80)))
3840 /* C2 is not in a valid range. */
3842 if (CHARSET_DIMENSION (charset
) == 2)
3843 c1
= (c1
<< 8) | c2
;
3847 if (c3
< 0x20 || (c3
>= 0x80 && c3
< 0xA0)
3848 || ((c1
& 0x80) != (c3
& 0x80)))
3849 /* C3 is not in a valid range. */
3851 c1
= (c1
<< 16) | (c2
<< 8) | c2
;
3855 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3858 MAYBE_FINISH_COMPOSITION ();
3859 for (; src_base
< src
; src_base
++, char_offset
++)
3861 if (ASCII_BYTE_P (*src_base
))
3862 *charbuf
++ = *src_base
;
3864 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3867 else if (cmp_status
->state
== COMPOSING_NO
)
3872 else if ((cmp_status
->state
== COMPOSING_CHAR
3873 ? cmp_status
->nchars
3874 : cmp_status
->ncomps
)
3875 >= MAX_COMPOSITION_COMPONENTS
)
3877 /* Too long composition. */
3878 MAYBE_FINISH_COMPOSITION ();
3883 STORE_COMPOSITION_CHAR (c
);
3887 MAYBE_FINISH_COMPOSITION ();
3889 consumed_chars
= consumed_chars_base
;
3891 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3901 if (cmp_status
->state
!= COMPOSING_NO
)
3903 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
3904 MAYBE_FINISH_COMPOSITION ();
3907 charbuf
-= cmp_status
->length
;
3908 for (i
= 0; i
< cmp_status
->length
; i
++)
3909 cmp_status
->carryover
[i
] = charbuf
[i
];
3912 else if (last_id
!= charset_ascii
)
3913 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3914 coding
->consumed_char
+= consumed_chars_base
;
3915 coding
->consumed
= src_base
- coding
->source
;
3916 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3920 /* ISO2022 encoding stuff. */
3923 It is not enough to say just "ISO2022" on encoding, we have to
3924 specify more details. In Emacs, each coding system of ISO2022
3925 variant has the following specifications:
3926 1. Initial designation to G0 thru G3.
3927 2. Allows short-form designation?
3928 3. ASCII should be designated to G0 before control characters?
3929 4. ASCII should be designated to G0 at end of line?
3930 5. 7-bit environment or 8-bit environment?
3931 6. Use locking-shift?
3932 7. Use Single-shift?
3933 And the following two are only for Japanese:
3934 8. Use ASCII in place of JIS0201-1976-Roman?
3935 9. Use JISX0208-1983 in place of JISX0208-1978?
3936 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3937 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3941 /* Produce codes (escape sequence) for designating CHARSET to graphic
3942 register REG at DST, and increment DST. If <final-char> of CHARSET is
3943 '@', 'A', or 'B' and the coding system CODING allows, produce
3944 designation sequence of short-form. */
3946 #define ENCODE_DESIGNATION(charset, reg, coding) \
3948 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3949 const char *intermediate_char_94 = "()*+"; \
3950 const char *intermediate_char_96 = ",-./"; \
3951 int revision = -1; \
3953 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3954 revision = CHARSET_ISO_REVISION (charset); \
3956 if (revision >= 0) \
3958 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3959 EMIT_ONE_BYTE ('@' + revision); \
3961 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3962 if (CHARSET_DIMENSION (charset) == 1) \
3965 if (! CHARSET_ISO_CHARS_96 (charset)) \
3966 b = intermediate_char_94[reg]; \
3968 b = intermediate_char_96[reg]; \
3969 EMIT_ONE_ASCII_BYTE (b); \
3973 EMIT_ONE_ASCII_BYTE ('$'); \
3974 if (! CHARSET_ISO_CHARS_96 (charset)) \
3976 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3978 || final_char < '@' || final_char > 'B') \
3979 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3982 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3984 EMIT_ONE_ASCII_BYTE (final_char); \
3986 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3990 /* The following two macros produce codes (control character or escape
3991 sequence) for ISO2022 single-shift functions (single-shift-2 and
3994 #define ENCODE_SINGLE_SHIFT_2 \
3996 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3997 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3999 EMIT_ONE_BYTE (ISO_CODE_SS2); \
4000 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4004 #define ENCODE_SINGLE_SHIFT_3 \
4006 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4007 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
4009 EMIT_ONE_BYTE (ISO_CODE_SS3); \
4010 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4014 /* The following four macros produce codes (control character or
4015 escape sequence) for ISO2022 locking-shift functions (shift-in,
4016 shift-out, locking-shift-2, and locking-shift-3). */
4018 #define ENCODE_SHIFT_IN \
4020 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
4021 CODING_ISO_INVOCATION (coding, 0) = 0; \
4025 #define ENCODE_SHIFT_OUT \
4027 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
4028 CODING_ISO_INVOCATION (coding, 0) = 1; \
4032 #define ENCODE_LOCKING_SHIFT_2 \
4034 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
4035 CODING_ISO_INVOCATION (coding, 0) = 2; \
4039 #define ENCODE_LOCKING_SHIFT_3 \
4041 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
4042 CODING_ISO_INVOCATION (coding, 0) = 3; \
4046 /* Produce codes for a DIMENSION1 character whose character set is
4047 CHARSET and whose position-code is C1. Designation and invocation
4048 sequences are also produced in advance if necessary. */
4050 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
4052 int id = CHARSET_ID (charset); \
4054 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
4055 && id == charset_ascii) \
4057 id = charset_jisx0201_roman; \
4058 charset = CHARSET_FROM_ID (id); \
4061 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
4063 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4064 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
4066 EMIT_ONE_BYTE (c1 | 0x80); \
4067 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
4070 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
4072 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
4075 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
4077 EMIT_ONE_BYTE (c1 | 0x80); \
4081 /* Since CHARSET is not yet invoked to any graphic planes, we \
4082 must invoke it, or, at first, designate it to some graphic \
4083 register. Then repeat the loop to actually produce the \
4085 dst = encode_invocation_designation (charset, coding, dst, \
4090 /* Produce codes for a DIMENSION2 character whose character set is
4091 CHARSET and whose position-codes are C1 and C2. Designation and
4092 invocation codes are also produced in advance if necessary. */
4094 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
4096 int id = CHARSET_ID (charset); \
4098 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
4099 && id == charset_jisx0208) \
4101 id = charset_jisx0208_1978; \
4102 charset = CHARSET_FROM_ID (id); \
4105 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
4107 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4108 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
4110 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
4111 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
4114 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
4116 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
4119 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
4121 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
4125 /* Since CHARSET is not yet invoked to any graphic planes, we \
4126 must invoke it, or, at first, designate it to some graphic \
4127 register. Then repeat the loop to actually produce the \
4129 dst = encode_invocation_designation (charset, coding, dst, \
4134 #define ENCODE_ISO_CHARACTER(charset, c) \
4137 CODING_ENCODE_CHAR (coding, dst, dst_end, (charset), (c), code); \
4139 if (CHARSET_DIMENSION (charset) == 1) \
4140 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
4142 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
4146 /* Produce designation and invocation codes at a place pointed by DST
4147 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
4150 static unsigned char *
4151 encode_invocation_designation (struct charset
*charset
,
4152 struct coding_system
*coding
,
4153 unsigned char *dst
, ptrdiff_t *p_nchars
)
4155 bool multibytep
= coding
->dst_multibyte
;
4156 ptrdiff_t produced_chars
= *p_nchars
;
4157 int reg
; /* graphic register number */
4158 int id
= CHARSET_ID (charset
);
4160 /* At first, check designations. */
4161 for (reg
= 0; reg
< 4; reg
++)
4162 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
4167 /* CHARSET is not yet designated to any graphic registers. */
4168 /* At first check the requested designation. */
4169 reg
= CODING_ISO_REQUEST (coding
, id
);
4171 /* Since CHARSET requests no special designation, designate it
4172 to graphic register 0. */
4175 ENCODE_DESIGNATION (charset
, reg
, coding
);
4178 if (CODING_ISO_INVOCATION (coding
, 0) != reg
4179 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
4181 /* Since the graphic register REG is not invoked to any graphic
4182 planes, invoke it to graphic plane 0. */
4185 case 0: /* graphic register 0 */
4189 case 1: /* graphic register 1 */
4193 case 2: /* graphic register 2 */
4194 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
4195 ENCODE_SINGLE_SHIFT_2
;
4197 ENCODE_LOCKING_SHIFT_2
;
4200 case 3: /* graphic register 3 */
4201 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
4202 ENCODE_SINGLE_SHIFT_3
;
4204 ENCODE_LOCKING_SHIFT_3
;
4209 *p_nchars
= produced_chars
;
4214 /* Produce codes for designation and invocation to reset the graphic
4215 planes and registers to initial state. */
4216 #define ENCODE_RESET_PLANE_AND_REGISTER() \
4219 struct charset *charset; \
4221 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
4223 for (reg = 0; reg < 4; reg++) \
4224 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
4225 && (CODING_ISO_DESIGNATION (coding, reg) \
4226 != CODING_ISO_INITIAL (coding, reg))) \
4228 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
4229 ENCODE_DESIGNATION (charset, reg, coding); \
4234 /* Produce designation sequences of charsets in the line started from
4235 CHARBUF to a place pointed by DST, and return the number of
4236 produced bytes. DST should not directly point a buffer text area
4237 which may be relocated by char_charset call.
4239 If the current block ends before any end-of-line, we may fail to
4240 find all the necessary designations. */
4243 encode_designation_at_bol (struct coding_system
*coding
,
4244 int *charbuf
, int *charbuf_end
,
4247 unsigned char *orig
= dst
;
4248 struct charset
*charset
;
4249 /* Table of charsets to be designated to each graphic register. */
4251 int c
, found
= 0, reg
;
4252 ptrdiff_t produced_chars
= 0;
4253 bool multibytep
= coding
->dst_multibyte
;
4255 Lisp_Object charset_list
;
4257 attrs
= CODING_ID_ATTRS (coding
->id
);
4258 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4259 if (EQ (charset_list
, Qiso_2022
))
4260 charset_list
= Viso_2022_charset_list
;
4262 for (reg
= 0; reg
< 4; reg
++)
4265 while (charbuf
< charbuf_end
&& found
< 4)
4272 charset
= char_charset (c
, charset_list
, NULL
);
4273 id
= CHARSET_ID (charset
);
4274 reg
= CODING_ISO_REQUEST (coding
, id
);
4275 if (reg
>= 0 && r
[reg
] < 0)
4284 for (reg
= 0; reg
< 4; reg
++)
4286 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
4287 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
4293 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
4296 encode_coding_iso_2022 (struct coding_system
*coding
)
4298 bool multibytep
= coding
->dst_multibyte
;
4299 int *charbuf
= coding
->charbuf
;
4300 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4301 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4302 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4304 bool bol_designation
4305 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
4306 && CODING_ISO_BOL (coding
));
4307 ptrdiff_t produced_chars
= 0;
4308 Lisp_Object attrs
, eol_type
, charset_list
;
4309 bool ascii_compatible
;
4311 int preferred_charset_id
= -1;
4313 CODING_GET_INFO (coding
, attrs
, charset_list
);
4314 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
4315 if (VECTORP (eol_type
))
4318 setup_iso_safe_charsets (attrs
);
4319 /* Charset list may have been changed. */
4320 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4321 coding
->safe_charsets
= SDATA (CODING_ATTR_SAFE_CHARSETS (attrs
));
4324 = (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
))
4325 && ! (CODING_ISO_FLAGS (coding
) & (CODING_ISO_FLAG_DESIGNATION
4326 | CODING_ISO_FLAG_LOCKING_SHIFT
)));
4328 while (charbuf
< charbuf_end
)
4330 ASSURE_DESTINATION (safe_room
);
4332 if (bol_designation
)
4334 /* We have to produce designation sequences if any now. */
4335 unsigned char desig_buf
[16];
4339 charset_map_loaded
= 0;
4340 nbytes
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
,
4342 if (charset_map_loaded
4343 && (offset
= coding_change_destination (coding
)))
4348 memcpy (dst
, desig_buf
, nbytes
);
4350 /* We are sure that designation sequences are all ASCII bytes. */
4351 produced_chars
+= nbytes
;
4352 bol_designation
= 0;
4353 ASSURE_DESTINATION (safe_room
);
4360 /* Handle an annotation. */
4363 case CODING_ANNOTATE_COMPOSITION_MASK
:
4364 /* Not yet implemented. */
4366 case CODING_ANNOTATE_CHARSET_MASK
:
4367 preferred_charset_id
= charbuf
[2];
4368 if (preferred_charset_id
>= 0
4369 && NILP (Fmemq (make_number (preferred_charset_id
),
4371 preferred_charset_id
= -1;
4380 /* Now encode the character C. */
4381 if (c
< 0x20 || c
== 0x7F)
4384 || (c
== '\r' && EQ (eol_type
, Qmac
)))
4386 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4387 ENCODE_RESET_PLANE_AND_REGISTER ();
4388 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
4392 for (i
= 0; i
< 4; i
++)
4393 CODING_ISO_DESIGNATION (coding
, i
)
4394 = CODING_ISO_INITIAL (coding
, i
);
4396 bol_designation
= ((CODING_ISO_FLAGS (coding
)
4397 & CODING_ISO_FLAG_DESIGNATE_AT_BOL
)
4400 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
4401 ENCODE_RESET_PLANE_AND_REGISTER ();
4402 EMIT_ONE_ASCII_BYTE (c
);
4404 else if (ASCII_CHAR_P (c
))
4406 if (ascii_compatible
)
4407 EMIT_ONE_ASCII_BYTE (c
);
4410 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
4411 ENCODE_ISO_CHARACTER (charset
, c
);
4414 else if (CHAR_BYTE8_P (c
))
4416 c
= CHAR_TO_BYTE8 (c
);
4421 struct charset
*charset
;
4423 if (preferred_charset_id
>= 0)
4427 charset
= CHARSET_FROM_ID (preferred_charset_id
);
4428 CODING_CHAR_CHARSET_P (coding
, dst
, dst_end
, c
, charset
, result
);
4430 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
4434 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
4438 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4440 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4441 charset
= CHARSET_FROM_ID (charset_ascii
);
4445 c
= coding
->default_char
;
4446 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
,
4447 charset_list
, NULL
, charset
);
4450 ENCODE_ISO_CHARACTER (charset
, c
);
4454 if (coding
->mode
& CODING_MODE_LAST_BLOCK
4455 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4457 ASSURE_DESTINATION (safe_room
);
4458 ENCODE_RESET_PLANE_AND_REGISTER ();
4460 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4461 CODING_ISO_BOL (coding
) = bol_designation
;
4462 coding
->produced_char
+= produced_chars
;
4463 coding
->produced
= dst
- coding
->destination
;
4468 /*** 8,9. SJIS and BIG5 handlers ***/
4470 /* Although SJIS and BIG5 are not ISO's coding system, they are used
4471 quite widely. So, for the moment, Emacs supports them in the bare
4472 C code. But, in the future, they may be supported only by CCL. */
4474 /* SJIS is a coding system encoding three character sets: ASCII, right
4475 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
4476 as is. A character of charset katakana-jisx0201 is encoded by
4477 "position-code + 0x80". A character of charset japanese-jisx0208
4478 is encoded in 2-byte but two position-codes are divided and shifted
4479 so that it fit in the range below.
4481 --- CODE RANGE of SJIS ---
4482 (character set) (range)
4484 KATAKANA-JISX0201 0xA0 .. 0xDF
4485 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
4486 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
4487 -------------------------------
4491 /* BIG5 is a coding system encoding two character sets: ASCII and
4492 Big5. An ASCII character is encoded as is. Big5 is a two-byte
4493 character set and is encoded in two-byte.
4495 --- CODE RANGE of BIG5 ---
4496 (character set) (range)
4498 Big5 (1st byte) 0xA1 .. 0xFE
4499 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
4500 --------------------------
4504 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4505 Return true if a text is encoded in SJIS. */
4508 detect_coding_sjis (struct coding_system
*coding
,
4509 struct coding_detection_info
*detect_info
)
4511 const unsigned char *src
= coding
->source
, *src_base
;
4512 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4513 bool multibytep
= coding
->src_multibyte
;
4514 ptrdiff_t consumed_chars
= 0;
4517 Lisp_Object attrs
, charset_list
;
4518 int max_first_byte_of_2_byte_code
;
4520 CODING_GET_INFO (coding
, attrs
, charset_list
);
4521 max_first_byte_of_2_byte_code
4522 = (XINT (Flength (charset_list
)) > 3 ? 0xFC : 0xEF);
4524 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
4525 /* A coding system of this category is always ASCII compatible. */
4526 src
+= coding
->head_ascii
;
4534 if ((c
>= 0x81 && c
<= 0x9F)
4535 || (c
>= 0xE0 && c
<= max_first_byte_of_2_byte_code
))
4538 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
4540 found
= CATEGORY_MASK_SJIS
;
4542 else if (c
>= 0xA0 && c
< 0xE0)
4543 found
= CATEGORY_MASK_SJIS
;
4547 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4551 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4553 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4556 detect_info
->found
|= found
;
4560 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4561 Return true if a text is encoded in BIG5. */
4564 detect_coding_big5 (struct coding_system
*coding
,
4565 struct coding_detection_info
*detect_info
)
4567 const unsigned char *src
= coding
->source
, *src_base
;
4568 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4569 bool multibytep
= coding
->src_multibyte
;
4570 ptrdiff_t consumed_chars
= 0;
4574 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4575 /* A coding system of this category is always ASCII compatible. */
4576 src
+= coding
->head_ascii
;
4587 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4589 found
= CATEGORY_MASK_BIG5
;
4594 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4598 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4600 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4603 detect_info
->found
|= found
;
4607 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4610 decode_coding_sjis (struct coding_system
*coding
)
4612 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4613 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4614 const unsigned char *src_base
;
4615 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4616 /* We may produce one charset annotation in one loop and one more at
4619 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
4620 ptrdiff_t consumed_chars
= 0, consumed_chars_base
;
4621 bool multibytep
= coding
->src_multibyte
;
4622 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4623 struct charset
*charset_kanji2
;
4624 Lisp_Object attrs
, charset_list
, val
;
4625 ptrdiff_t char_offset
= coding
->produced_char
;
4626 ptrdiff_t last_offset
= char_offset
;
4627 int last_id
= charset_ascii
;
4629 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4630 int byte_after_cr
= -1;
4632 CODING_GET_INFO (coding
, attrs
, charset_list
);
4635 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4636 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4637 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4638 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4643 struct charset
*charset
;
4646 consumed_chars_base
= consumed_chars
;
4648 if (charbuf
>= charbuf_end
)
4650 if (byte_after_cr
>= 0)
4655 if (byte_after_cr
>= 0)
4656 c
= byte_after_cr
, byte_after_cr
= -1;
4663 if (eol_dos
&& c
== '\r')
4664 ONE_MORE_BYTE (byte_after_cr
);
4665 charset
= charset_roman
;
4667 else if (c
== 0x80 || c
== 0xA0)
4669 else if (c
>= 0xA1 && c
<= 0xDF)
4671 /* SJIS -> JISX0201-Kana */
4673 charset
= charset_kana
;
4677 /* SJIS -> JISX0208 */
4679 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4683 charset
= charset_kanji
;
4685 else if (c
<= 0xFC && charset_kanji2
)
4687 /* SJIS -> JISX0213-2 */
4689 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4693 charset
= charset_kanji2
;
4697 if (charset
->id
!= charset_ascii
4698 && last_id
!= charset
->id
)
4700 if (last_id
!= charset_ascii
)
4701 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4702 last_id
= charset
->id
;
4703 last_offset
= char_offset
;
4705 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4712 consumed_chars
= consumed_chars_base
;
4714 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4720 if (last_id
!= charset_ascii
)
4721 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4722 coding
->consumed_char
+= consumed_chars_base
;
4723 coding
->consumed
= src_base
- coding
->source
;
4724 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4728 decode_coding_big5 (struct coding_system
*coding
)
4730 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4731 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4732 const unsigned char *src_base
;
4733 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4734 /* We may produce one charset annotation in one loop and one more at
4737 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
4738 ptrdiff_t consumed_chars
= 0, consumed_chars_base
;
4739 bool multibytep
= coding
->src_multibyte
;
4740 struct charset
*charset_roman
, *charset_big5
;
4741 Lisp_Object attrs
, charset_list
, val
;
4742 ptrdiff_t char_offset
= coding
->produced_char
;
4743 ptrdiff_t last_offset
= char_offset
;
4744 int last_id
= charset_ascii
;
4746 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4747 int byte_after_cr
= -1;
4749 CODING_GET_INFO (coding
, attrs
, charset_list
);
4751 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4752 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4757 struct charset
*charset
;
4760 consumed_chars_base
= consumed_chars
;
4762 if (charbuf
>= charbuf_end
)
4764 if (byte_after_cr
>= 0)
4769 if (byte_after_cr
>= 0)
4770 c
= byte_after_cr
, byte_after_cr
= -1;
4778 if (eol_dos
&& c
== '\r')
4779 ONE_MORE_BYTE (byte_after_cr
);
4780 charset
= charset_roman
;
4785 if (c
< 0xA1 || c
> 0xFE)
4788 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4791 charset
= charset_big5
;
4793 if (charset
->id
!= charset_ascii
4794 && last_id
!= charset
->id
)
4796 if (last_id
!= charset_ascii
)
4797 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4798 last_id
= charset
->id
;
4799 last_offset
= char_offset
;
4801 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4808 consumed_chars
= consumed_chars_base
;
4810 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4816 if (last_id
!= charset_ascii
)
4817 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4818 coding
->consumed_char
+= consumed_chars_base
;
4819 coding
->consumed
= src_base
- coding
->source
;
4820 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4823 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4824 This function can encode charsets `ascii', `katakana-jisx0201',
4825 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4826 are sure that all these charsets are registered as official charset
4827 (i.e. do not have extended leading-codes). Characters of other
4828 charsets are produced without any encoding. */
4831 encode_coding_sjis (struct coding_system
*coding
)
4833 bool multibytep
= coding
->dst_multibyte
;
4834 int *charbuf
= coding
->charbuf
;
4835 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4836 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4837 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4839 ptrdiff_t produced_chars
= 0;
4840 Lisp_Object attrs
, charset_list
, val
;
4841 bool ascii_compatible
;
4842 struct charset
*charset_kanji
, *charset_kana
;
4843 struct charset
*charset_kanji2
;
4846 CODING_GET_INFO (coding
, attrs
, charset_list
);
4847 val
= XCDR (charset_list
);
4848 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4849 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4850 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4852 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4854 while (charbuf
< charbuf_end
)
4856 ASSURE_DESTINATION (safe_room
);
4858 /* Now encode the character C. */
4859 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4860 EMIT_ONE_ASCII_BYTE (c
);
4861 else if (CHAR_BYTE8_P (c
))
4863 c
= CHAR_TO_BYTE8 (c
);
4869 struct charset
*charset
;
4870 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
4875 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4877 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4878 charset
= CHARSET_FROM_ID (charset_ascii
);
4882 c
= coding
->default_char
;
4883 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
,
4884 charset_list
, &code
, charset
);
4887 if (code
== CHARSET_INVALID_CODE (charset
))
4889 if (charset
== charset_kanji
)
4893 c1
= code
>> 8, c2
= code
& 0xFF;
4894 EMIT_TWO_BYTES (c1
, c2
);
4896 else if (charset
== charset_kana
)
4897 EMIT_ONE_BYTE (code
| 0x80);
4898 else if (charset_kanji2
&& charset
== charset_kanji2
)
4903 if (c1
== 0x21 || (c1
>= 0x23 && c1
<= 0x25)
4905 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4907 JIS_TO_SJIS2 (code
);
4908 c1
= code
>> 8, c2
= code
& 0xFF;
4909 EMIT_TWO_BYTES (c1
, c2
);
4912 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4915 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4918 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4919 coding
->produced_char
+= produced_chars
;
4920 coding
->produced
= dst
- coding
->destination
;
4925 encode_coding_big5 (struct coding_system
*coding
)
4927 bool multibytep
= coding
->dst_multibyte
;
4928 int *charbuf
= coding
->charbuf
;
4929 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4930 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4931 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4933 ptrdiff_t produced_chars
= 0;
4934 Lisp_Object attrs
, charset_list
, val
;
4935 bool ascii_compatible
;
4936 struct charset
*charset_big5
;
4939 CODING_GET_INFO (coding
, attrs
, charset_list
);
4940 val
= XCDR (charset_list
);
4941 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4942 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4944 while (charbuf
< charbuf_end
)
4946 ASSURE_DESTINATION (safe_room
);
4948 /* Now encode the character C. */
4949 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4950 EMIT_ONE_ASCII_BYTE (c
);
4951 else if (CHAR_BYTE8_P (c
))
4953 c
= CHAR_TO_BYTE8 (c
);
4959 struct charset
*charset
;
4960 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
4965 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4967 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4968 charset
= CHARSET_FROM_ID (charset_ascii
);
4972 c
= coding
->default_char
;
4973 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
,
4974 charset_list
, &code
, charset
);
4977 if (code
== CHARSET_INVALID_CODE (charset
))
4979 if (charset
== charset_big5
)
4983 c1
= code
>> 8, c2
= code
& 0xFF;
4984 EMIT_TWO_BYTES (c1
, c2
);
4987 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4990 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4991 coding
->produced_char
+= produced_chars
;
4992 coding
->produced
= dst
- coding
->destination
;
4997 /*** 10. CCL handlers ***/
4999 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5000 Return true if a text is encoded in a coding system of which
5001 encoder/decoder are written in CCL program. */
5004 detect_coding_ccl (struct coding_system
*coding
,
5005 struct coding_detection_info
*detect_info
)
5007 const unsigned char *src
= coding
->source
, *src_base
;
5008 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5009 bool multibytep
= coding
->src_multibyte
;
5010 ptrdiff_t consumed_chars
= 0;
5012 unsigned char *valids
;
5013 ptrdiff_t head_ascii
= coding
->head_ascii
;
5016 detect_info
->checked
|= CATEGORY_MASK_CCL
;
5018 coding
= &coding_categories
[coding_category_ccl
];
5019 valids
= CODING_CCL_VALIDS (coding
);
5020 attrs
= CODING_ID_ATTRS (coding
->id
);
5021 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
5030 if (c
< 0 || ! valids
[c
])
5032 if ((valids
[c
] > 1))
5033 found
= CATEGORY_MASK_CCL
;
5035 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
5039 detect_info
->found
|= found
;
5044 decode_coding_ccl (struct coding_system
*coding
)
5046 const unsigned char *src
= coding
->source
+ coding
->consumed
;
5047 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5048 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
5049 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
5050 ptrdiff_t consumed_chars
= 0;
5051 bool multibytep
= coding
->src_multibyte
;
5052 struct ccl_program
*ccl
= &coding
->spec
.ccl
->ccl
;
5053 int source_charbuf
[1024];
5054 int source_byteidx
[1025];
5055 Lisp_Object attrs
, charset_list
;
5057 CODING_GET_INFO (coding
, attrs
, charset_list
);
5061 const unsigned char *p
= src
;
5067 while (i
< 1024 && p
< src_end
)
5069 source_byteidx
[i
] = p
- src
;
5070 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
5072 source_byteidx
[i
] = p
- src
;
5075 while (i
< 1024 && p
< src_end
)
5076 source_charbuf
[i
++] = *p
++;
5078 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
5079 ccl
->last_block
= 1;
5080 /* As ccl_driver calls DECODE_CHAR, buffer may be relocated. */
5081 charset_map_loaded
= 0;
5082 ccl_driver (ccl
, source_charbuf
, charbuf
, i
, charbuf_end
- charbuf
,
5084 if (charset_map_loaded
5085 && (offset
= coding_change_source (coding
)))
5091 charbuf
+= ccl
->produced
;
5093 src
+= source_byteidx
[ccl
->consumed
];
5095 src
+= ccl
->consumed
;
5096 consumed_chars
+= ccl
->consumed
;
5097 if (p
== src_end
|| ccl
->status
!= CCL_STAT_SUSPEND_BY_SRC
)
5101 switch (ccl
->status
)
5103 case CCL_STAT_SUSPEND_BY_SRC
:
5104 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5106 case CCL_STAT_SUSPEND_BY_DST
:
5107 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
5110 case CCL_STAT_INVALID_CMD
:
5111 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
5114 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5117 coding
->consumed_char
+= consumed_chars
;
5118 coding
->consumed
= src
- coding
->source
;
5119 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
5123 encode_coding_ccl (struct coding_system
*coding
)
5125 struct ccl_program
*ccl
= &coding
->spec
.ccl
->ccl
;
5126 bool multibytep
= coding
->dst_multibyte
;
5127 int *charbuf
= coding
->charbuf
;
5128 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
5129 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5130 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5131 int destination_charbuf
[1024];
5132 ptrdiff_t produced_chars
= 0;
5134 Lisp_Object attrs
, charset_list
;
5136 CODING_GET_INFO (coding
, attrs
, charset_list
);
5137 if (coding
->consumed_char
== coding
->src_chars
5138 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
5139 ccl
->last_block
= 1;
5145 /* As ccl_driver calls DECODE_CHAR, buffer may be relocated. */
5146 charset_map_loaded
= 0;
5147 ccl_driver (ccl
, charbuf
, destination_charbuf
,
5148 charbuf_end
- charbuf
, 1024, charset_list
);
5149 if (charset_map_loaded
5150 && (offset
= coding_change_destination (coding
)))
5154 ASSURE_DESTINATION (ccl
->produced
* 2);
5155 for (i
= 0; i
< ccl
->produced
; i
++)
5156 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
5160 ASSURE_DESTINATION (ccl
->produced
);
5161 for (i
= 0; i
< ccl
->produced
; i
++)
5162 *dst
++ = destination_charbuf
[i
] & 0xFF;
5163 produced_chars
+= ccl
->produced
;
5165 charbuf
+= ccl
->consumed
;
5166 if (ccl
->status
== CCL_STAT_QUIT
5167 || ccl
->status
== CCL_STAT_INVALID_CMD
)
5170 while (charbuf
< charbuf_end
);
5172 switch (ccl
->status
)
5174 case CCL_STAT_SUSPEND_BY_SRC
:
5175 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5177 case CCL_STAT_SUSPEND_BY_DST
:
5178 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
5181 case CCL_STAT_INVALID_CMD
:
5182 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
5185 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5189 coding
->produced_char
+= produced_chars
;
5190 coding
->produced
= dst
- coding
->destination
;
5195 /*** 10, 11. no-conversion handlers ***/
5197 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
5200 decode_coding_raw_text (struct coding_system
*coding
)
5203 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
5205 coding
->chars_at_source
= 1;
5206 coding
->consumed_char
= coding
->src_chars
;
5207 coding
->consumed
= coding
->src_bytes
;
5208 if (eol_dos
&& coding
->source
[coding
->src_bytes
- 1] == '\r')
5210 coding
->consumed_char
--;
5212 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5215 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5219 encode_coding_raw_text (struct coding_system
*coding
)
5221 bool multibytep
= coding
->dst_multibyte
;
5222 int *charbuf
= coding
->charbuf
;
5223 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
5224 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5225 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5226 ptrdiff_t produced_chars
= 0;
5231 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
5233 if (coding
->src_multibyte
)
5234 while (charbuf
< charbuf_end
)
5236 ASSURE_DESTINATION (safe_room
);
5238 if (ASCII_CHAR_P (c
))
5239 EMIT_ONE_ASCII_BYTE (c
);
5240 else if (CHAR_BYTE8_P (c
))
5242 c
= CHAR_TO_BYTE8 (c
);
5247 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
5249 CHAR_STRING_ADVANCE (c
, p1
);
5252 EMIT_ONE_BYTE (*p0
);
5259 while (charbuf
< charbuf_end
)
5261 ASSURE_DESTINATION (safe_room
);
5268 if (coding
->src_multibyte
)
5270 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5272 while (charbuf
< charbuf_end
)
5274 ASSURE_DESTINATION (safe_room
);
5276 if (ASCII_CHAR_P (c
))
5278 else if (CHAR_BYTE8_P (c
))
5279 *dst
++ = CHAR_TO_BYTE8 (c
);
5281 CHAR_STRING_ADVANCE (c
, dst
);
5286 ASSURE_DESTINATION (charbuf_end
- charbuf
);
5287 while (charbuf
< charbuf_end
&& dst
< dst_end
)
5288 *dst
++ = *charbuf
++;
5290 produced_chars
= dst
- (coding
->destination
+ coding
->produced
);
5292 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5293 coding
->produced_char
+= produced_chars
;
5294 coding
->produced
= dst
- coding
->destination
;
5298 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5299 Return true if a text is encoded in a charset-based coding system. */
5302 detect_coding_charset (struct coding_system
*coding
,
5303 struct coding_detection_info
*detect_info
)
5305 const unsigned char *src
= coding
->source
, *src_base
;
5306 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5307 bool multibytep
= coding
->src_multibyte
;
5308 ptrdiff_t consumed_chars
= 0;
5309 Lisp_Object attrs
, valids
, name
;
5311 ptrdiff_t head_ascii
= coding
->head_ascii
;
5312 bool check_latin_extra
= 0;
5314 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
5316 coding
= &coding_categories
[coding_category_charset
];
5317 attrs
= CODING_ID_ATTRS (coding
->id
);
5318 valids
= AREF (attrs
, coding_attr_charset_valids
);
5319 name
= CODING_ID_NAME (coding
->id
);
5320 if (strncmp (SSDATA (SYMBOL_NAME (name
)),
5321 "iso-8859-", sizeof ("iso-8859-") - 1) == 0
5322 || strncmp (SSDATA (SYMBOL_NAME (name
)),
5323 "iso-latin-", sizeof ("iso-latin-") - 1) == 0)
5324 check_latin_extra
= 1;
5326 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
5333 struct charset
*charset
;
5340 val
= AREF (valids
, c
);
5346 && check_latin_extra
5347 && (!VECTORP (Vlatin_extra_code_table
)
5348 || NILP (AREF (Vlatin_extra_code_table
, c
))))
5350 found
= CATEGORY_MASK_CHARSET
;
5354 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5355 dim
= CHARSET_DIMENSION (charset
);
5356 for (idx
= 1; idx
< dim
; idx
++)
5361 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 4]
5362 || c
> charset
->code_space
[(dim
- 1 - idx
) * 4 + 1])
5371 for (; CONSP (val
); val
= XCDR (val
))
5373 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5374 dim
= CHARSET_DIMENSION (charset
);
5380 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 4]
5381 || c
> charset
->code_space
[(dim
- 1 - idx
) * 4 + 1])
5396 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
5400 detect_info
->found
|= found
;
5405 decode_coding_charset (struct coding_system
*coding
)
5407 const unsigned char *src
= coding
->source
+ coding
->consumed
;
5408 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5409 const unsigned char *src_base
;
5410 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
5411 /* We may produce one charset annotation in one loop and one more at
5414 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
5415 ptrdiff_t consumed_chars
= 0, consumed_chars_base
;
5416 bool multibytep
= coding
->src_multibyte
;
5417 Lisp_Object attrs
= CODING_ID_ATTRS (coding
->id
);
5419 ptrdiff_t char_offset
= coding
->produced_char
;
5420 ptrdiff_t last_offset
= char_offset
;
5421 int last_id
= charset_ascii
;
5423 = !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
5424 int byte_after_cr
= -1;
5426 valids
= AREF (attrs
, coding_attr_charset_valids
);
5432 struct charset
*charset
;
5438 consumed_chars_base
= consumed_chars
;
5440 if (charbuf
>= charbuf_end
)
5442 if (byte_after_cr
>= 0)
5447 if (byte_after_cr
>= 0)
5455 if (eol_dos
&& c
== '\r')
5456 ONE_MORE_BYTE (byte_after_cr
);
5462 val
= AREF (valids
, c
);
5463 if (! INTEGERP (val
) && ! CONSP (val
))
5467 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5468 dim
= CHARSET_DIMENSION (charset
);
5472 code
= (code
<< 8) | c
;
5475 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
5480 /* VAL is a list of charset IDs. It is assured that the
5481 list is sorted by charset dimensions (smaller one
5485 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5486 dim
= CHARSET_DIMENSION (charset
);
5490 code
= (code
<< 8) | c
;
5493 CODING_DECODE_CHAR (coding
, src
, src_base
,
5494 src_end
, charset
, code
, c
);
5502 if (charset
->id
!= charset_ascii
5503 && last_id
!= charset
->id
)
5505 if (last_id
!= charset_ascii
)
5506 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5507 last_id
= charset
->id
;
5508 last_offset
= char_offset
;
5517 consumed_chars
= consumed_chars_base
;
5519 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
5525 if (last_id
!= charset_ascii
)
5526 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5527 coding
->consumed_char
+= consumed_chars_base
;
5528 coding
->consumed
= src_base
- coding
->source
;
5529 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
5533 encode_coding_charset (struct coding_system
*coding
)
5535 bool multibytep
= coding
->dst_multibyte
;
5536 int *charbuf
= coding
->charbuf
;
5537 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
5538 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5539 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5540 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5541 ptrdiff_t produced_chars
= 0;
5542 Lisp_Object attrs
, charset_list
;
5543 bool ascii_compatible
;
5546 CODING_GET_INFO (coding
, attrs
, charset_list
);
5547 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
5549 while (charbuf
< charbuf_end
)
5551 struct charset
*charset
;
5554 ASSURE_DESTINATION (safe_room
);
5556 if (ascii_compatible
&& ASCII_CHAR_P (c
))
5557 EMIT_ONE_ASCII_BYTE (c
);
5558 else if (CHAR_BYTE8_P (c
))
5560 c
= CHAR_TO_BYTE8 (c
);
5565 CODING_CHAR_CHARSET (coding
, dst
, dst_end
, c
, charset_list
,
5570 if (CHARSET_DIMENSION (charset
) == 1)
5571 EMIT_ONE_BYTE (code
);
5572 else if (CHARSET_DIMENSION (charset
) == 2)
5573 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
5574 else if (CHARSET_DIMENSION (charset
) == 3)
5575 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
5577 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
5578 (code
>> 8) & 0xFF, code
& 0xFF);
5582 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
5583 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
5585 c
= coding
->default_char
;
5591 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5592 coding
->produced_char
+= produced_chars
;
5593 coding
->produced
= dst
- coding
->destination
;
5598 /*** 7. C library functions ***/
5600 /* Setup coding context CODING from information about CODING_SYSTEM.
5601 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
5602 CODING_SYSTEM is invalid, signal an error. */
5605 setup_coding_system (Lisp_Object coding_system
, struct coding_system
*coding
)
5608 Lisp_Object eol_type
;
5609 Lisp_Object coding_type
;
5612 if (NILP (coding_system
))
5613 coding_system
= Qundecided
;
5615 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
5617 attrs
= CODING_ID_ATTRS (coding
->id
);
5618 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
5621 coding
->head_ascii
= -1;
5622 if (VECTORP (eol_type
))
5623 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5624 | CODING_REQUIRE_DETECTION_MASK
);
5625 else if (! EQ (eol_type
, Qunix
))
5626 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5627 | CODING_REQUIRE_ENCODING_MASK
);
5629 coding
->common_flags
= 0;
5630 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
5631 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5632 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
5633 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5634 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
5635 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
5637 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5638 coding
->max_charset_id
= SCHARS (val
) - 1;
5639 coding
->safe_charsets
= SDATA (val
);
5640 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
5641 coding
->carryover_bytes
= 0;
5643 coding_type
= CODING_ATTR_TYPE (attrs
);
5644 if (EQ (coding_type
, Qundecided
))
5646 coding
->detector
= NULL
;
5647 coding
->decoder
= decode_coding_raw_text
;
5648 coding
->encoder
= encode_coding_raw_text
;
5649 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5651 else if (EQ (coding_type
, Qiso_2022
))
5654 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5656 /* Invoke graphic register 0 to plane 0. */
5657 CODING_ISO_INVOCATION (coding
, 0) = 0;
5658 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
5659 CODING_ISO_INVOCATION (coding
, 1)
5660 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
5661 /* Setup the initial status of designation. */
5662 for (i
= 0; i
< 4; i
++)
5663 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
5664 /* Not single shifting initially. */
5665 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
5666 /* Beginning of buffer should also be regarded as bol. */
5667 CODING_ISO_BOL (coding
) = 1;
5668 coding
->detector
= detect_coding_iso_2022
;
5669 coding
->decoder
= decode_coding_iso_2022
;
5670 coding
->encoder
= encode_coding_iso_2022
;
5671 if (flags
& CODING_ISO_FLAG_SAFE
)
5672 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
5673 coding
->common_flags
5674 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5675 | CODING_REQUIRE_FLUSHING_MASK
);
5676 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
5677 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
5678 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
5679 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
5680 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5682 setup_iso_safe_charsets (attrs
);
5683 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5684 coding
->max_charset_id
= SCHARS (val
) - 1;
5685 coding
->safe_charsets
= SDATA (val
);
5687 CODING_ISO_FLAGS (coding
) = flags
;
5688 CODING_ISO_CMP_STATUS (coding
)->state
= COMPOSING_NO
;
5689 CODING_ISO_CMP_STATUS (coding
)->method
= COMPOSITION_NO
;
5690 CODING_ISO_EXTSEGMENT_LEN (coding
) = 0;
5691 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 0;
5693 else if (EQ (coding_type
, Qcharset
))
5695 coding
->detector
= detect_coding_charset
;
5696 coding
->decoder
= decode_coding_charset
;
5697 coding
->encoder
= encode_coding_charset
;
5698 coding
->common_flags
5699 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5701 else if (EQ (coding_type
, Qutf_8
))
5703 val
= AREF (attrs
, coding_attr_utf_bom
);
5704 CODING_UTF_8_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5705 : EQ (val
, Qt
) ? utf_with_bom
5707 coding
->detector
= detect_coding_utf_8
;
5708 coding
->decoder
= decode_coding_utf_8
;
5709 coding
->encoder
= encode_coding_utf_8
;
5710 coding
->common_flags
5711 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5712 if (CODING_UTF_8_BOM (coding
) == utf_detect_bom
)
5713 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5715 else if (EQ (coding_type
, Qutf_16
))
5717 val
= AREF (attrs
, coding_attr_utf_bom
);
5718 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5719 : EQ (val
, Qt
) ? utf_with_bom
5721 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5722 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5723 : utf_16_little_endian
);
5724 CODING_UTF_16_SURROGATE (coding
) = 0;
5725 coding
->detector
= detect_coding_utf_16
;
5726 coding
->decoder
= decode_coding_utf_16
;
5727 coding
->encoder
= encode_coding_utf_16
;
5728 coding
->common_flags
5729 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5730 if (CODING_UTF_16_BOM (coding
) == utf_detect_bom
)
5731 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5733 else if (EQ (coding_type
, Qccl
))
5735 coding
->detector
= detect_coding_ccl
;
5736 coding
->decoder
= decode_coding_ccl
;
5737 coding
->encoder
= encode_coding_ccl
;
5738 coding
->common_flags
5739 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5740 | CODING_REQUIRE_FLUSHING_MASK
);
5742 else if (EQ (coding_type
, Qemacs_mule
))
5744 coding
->detector
= detect_coding_emacs_mule
;
5745 coding
->decoder
= decode_coding_emacs_mule
;
5746 coding
->encoder
= encode_coding_emacs_mule
;
5747 coding
->common_flags
5748 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5749 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5750 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5752 Lisp_Object tail
, safe_charsets
;
5753 int max_charset_id
= 0;
5755 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5757 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5758 max_charset_id
= XFASTINT (XCAR (tail
));
5759 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
5760 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
5761 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5763 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5764 coding
->max_charset_id
= max_charset_id
;
5765 coding
->safe_charsets
= SDATA (safe_charsets
);
5767 coding
->spec
.emacs_mule
.cmp_status
.state
= COMPOSING_NO
;
5768 coding
->spec
.emacs_mule
.cmp_status
.method
= COMPOSITION_NO
;
5770 else if (EQ (coding_type
, Qshift_jis
))
5772 coding
->detector
= detect_coding_sjis
;
5773 coding
->decoder
= decode_coding_sjis
;
5774 coding
->encoder
= encode_coding_sjis
;
5775 coding
->common_flags
5776 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5778 else if (EQ (coding_type
, Qbig5
))
5780 coding
->detector
= detect_coding_big5
;
5781 coding
->decoder
= decode_coding_big5
;
5782 coding
->encoder
= encode_coding_big5
;
5783 coding
->common_flags
5784 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5786 else /* EQ (coding_type, Qraw_text) */
5788 coding
->detector
= NULL
;
5789 coding
->decoder
= decode_coding_raw_text
;
5790 coding
->encoder
= encode_coding_raw_text
;
5791 if (! EQ (eol_type
, Qunix
))
5793 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5794 if (! VECTORP (eol_type
))
5795 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5803 /* Return a list of charsets supported by CODING. */
5806 coding_charset_list (struct coding_system
*coding
)
5808 Lisp_Object attrs
, charset_list
;
5810 CODING_GET_INFO (coding
, attrs
, charset_list
);
5811 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5813 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5815 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5816 charset_list
= Viso_2022_charset_list
;
5818 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5820 charset_list
= Vemacs_mule_charset_list
;
5822 return charset_list
;
5826 /* Return a list of charsets supported by CODING-SYSTEM. */
5829 coding_system_charset_list (Lisp_Object coding_system
)
5832 Lisp_Object attrs
, charset_list
;
5834 CHECK_CODING_SYSTEM_GET_ID (coding_system
, id
);
5835 attrs
= CODING_ID_ATTRS (id
);
5837 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5839 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5841 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5842 charset_list
= Viso_2022_charset_list
;
5844 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
5846 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5848 charset_list
= Vemacs_mule_charset_list
;
5852 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
5854 return charset_list
;
5858 /* Return raw-text or one of its subsidiaries that has the same
5859 eol_type as CODING-SYSTEM. */
5862 raw_text_coding_system (Lisp_Object coding_system
)
5864 Lisp_Object spec
, attrs
;
5865 Lisp_Object eol_type
, raw_text_eol_type
;
5867 if (NILP (coding_system
))
5869 spec
= CODING_SYSTEM_SPEC (coding_system
);
5870 attrs
= AREF (spec
, 0);
5872 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5873 return coding_system
;
5875 eol_type
= AREF (spec
, 2);
5876 if (VECTORP (eol_type
))
5878 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5879 raw_text_eol_type
= AREF (spec
, 2);
5880 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5881 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5882 : AREF (raw_text_eol_type
, 2));
5886 /* If CODING_SYSTEM doesn't specify end-of-line format, return one of
5887 the subsidiary that has the same eol-spec as PARENT (if it is not
5888 nil and specifies end-of-line format) or the system's setting
5889 (system_eol_type). */
5892 coding_inherit_eol_type (Lisp_Object coding_system
, Lisp_Object parent
)
5894 Lisp_Object spec
, eol_type
;
5896 if (NILP (coding_system
))
5897 coding_system
= Qraw_text
;
5898 spec
= CODING_SYSTEM_SPEC (coding_system
);
5899 eol_type
= AREF (spec
, 2);
5900 if (VECTORP (eol_type
))
5902 Lisp_Object parent_eol_type
;
5904 if (! NILP (parent
))
5906 Lisp_Object parent_spec
;
5908 parent_spec
= CODING_SYSTEM_SPEC (parent
);
5909 parent_eol_type
= AREF (parent_spec
, 2);
5910 if (VECTORP (parent_eol_type
))
5911 parent_eol_type
= system_eol_type
;
5914 parent_eol_type
= system_eol_type
;
5915 if (EQ (parent_eol_type
, Qunix
))
5916 coding_system
= AREF (eol_type
, 0);
5917 else if (EQ (parent_eol_type
, Qdos
))
5918 coding_system
= AREF (eol_type
, 1);
5919 else if (EQ (parent_eol_type
, Qmac
))
5920 coding_system
= AREF (eol_type
, 2);
5922 return coding_system
;
5926 /* Check if text-conversion and eol-conversion of CODING_SYSTEM are
5927 decided for writing to a process. If not, complement them, and
5928 return a new coding system. */
5931 complement_process_encoding_system (Lisp_Object coding_system
)
5933 Lisp_Object coding_base
= Qnil
, eol_base
= Qnil
;
5934 Lisp_Object spec
, attrs
;
5937 for (i
= 0; i
< 3; i
++)
5940 coding_system
= CDR_SAFE (Vdefault_process_coding_system
);
5942 coding_system
= preferred_coding_system ();
5943 spec
= CODING_SYSTEM_SPEC (coding_system
);
5946 attrs
= AREF (spec
, 0);
5947 if (NILP (coding_base
) && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
5948 coding_base
= CODING_ATTR_BASE_NAME (attrs
);
5949 if (NILP (eol_base
) && ! VECTORP (AREF (spec
, 2)))
5950 eol_base
= coding_system
;
5951 if (! NILP (coding_base
) && ! NILP (eol_base
))
5956 /* The original CODING_SYSTEM didn't specify text-conversion or
5957 eol-conversion. Be sure that we return a fully complemented
5959 coding_system
= coding_inherit_eol_type (coding_base
, eol_base
);
5960 return coding_system
;
5964 /* Emacs has a mechanism to automatically detect a coding system if it
5965 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5966 it's impossible to distinguish some coding systems accurately
5967 because they use the same range of codes. So, at first, coding
5968 systems are categorized into 7, those are:
5970 o coding-category-emacs-mule
5972 The category for a coding system which has the same code range
5973 as Emacs' internal format. Assigned the coding-system (Lisp
5974 symbol) `emacs-mule' by default.
5976 o coding-category-sjis
5978 The category for a coding system which has the same code range
5979 as SJIS. Assigned the coding-system (Lisp
5980 symbol) `japanese-shift-jis' by default.
5982 o coding-category-iso-7
5984 The category for a coding system which has the same code range
5985 as ISO2022 of 7-bit environment. This doesn't use any locking
5986 shift and single shift functions. This can encode/decode all
5987 charsets. Assigned the coding-system (Lisp symbol)
5988 `iso-2022-7bit' by default.
5990 o coding-category-iso-7-tight
5992 Same as coding-category-iso-7 except that this can
5993 encode/decode only the specified charsets.
5995 o coding-category-iso-8-1
5997 The category for a coding system which has the same code range
5998 as ISO2022 of 8-bit environment and graphic plane 1 used only
5999 for DIMENSION1 charset. This doesn't use any locking shift
6000 and single shift functions. Assigned the coding-system (Lisp
6001 symbol) `iso-latin-1' by default.
6003 o coding-category-iso-8-2
6005 The category for a coding system which has the same code range
6006 as ISO2022 of 8-bit environment and graphic plane 1 used only
6007 for DIMENSION2 charset. This doesn't use any locking shift
6008 and single shift functions. Assigned the coding-system (Lisp
6009 symbol) `japanese-iso-8bit' by default.
6011 o coding-category-iso-7-else
6013 The category for a coding system which has the same code range
6014 as ISO2022 of 7-bit environment but uses locking shift or
6015 single shift functions. Assigned the coding-system (Lisp
6016 symbol) `iso-2022-7bit-lock' by default.
6018 o coding-category-iso-8-else
6020 The category for a coding system which has the same code range
6021 as ISO2022 of 8-bit environment but uses locking shift or
6022 single shift functions. Assigned the coding-system (Lisp
6023 symbol) `iso-2022-8bit-ss2' by default.
6025 o coding-category-big5
6027 The category for a coding system which has the same code range
6028 as BIG5. Assigned the coding-system (Lisp symbol)
6029 `cn-big5' by default.
6031 o coding-category-utf-8
6033 The category for a coding system which has the same code range
6034 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
6035 symbol) `utf-8' by default.
6037 o coding-category-utf-16-be
6039 The category for a coding system in which a text has an
6040 Unicode signature (cf. Unicode Standard) in the order of BIG
6041 endian at the head. Assigned the coding-system (Lisp symbol)
6042 `utf-16-be' by default.
6044 o coding-category-utf-16-le
6046 The category for a coding system in which a text has an
6047 Unicode signature (cf. Unicode Standard) in the order of
6048 LITTLE endian at the head. Assigned the coding-system (Lisp
6049 symbol) `utf-16-le' by default.
6051 o coding-category-ccl
6053 The category for a coding system of which encoder/decoder is
6054 written in CCL programs. The default value is nil, i.e., no
6055 coding system is assigned.
6057 o coding-category-binary
6059 The category for a coding system not categorized in any of the
6060 above. Assigned the coding-system (Lisp symbol)
6061 `no-conversion' by default.
6063 Each of them is a Lisp symbol and the value is an actual
6064 `coding-system's (this is also a Lisp symbol) assigned by a user.
6065 What Emacs does actually is to detect a category of coding system.
6066 Then, it uses a `coding-system' assigned to it. If Emacs can't
6067 decide only one possible category, it selects a category of the
6068 highest priority. Priorities of categories are also specified by a
6069 user in a Lisp variable `coding-category-list'.
6073 #define EOL_SEEN_NONE 0
6074 #define EOL_SEEN_LF 1
6075 #define EOL_SEEN_CR 2
6076 #define EOL_SEEN_CRLF 4
6078 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
6079 SOURCE is encoded. If CATEGORY is one of
6080 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
6081 two-byte, else they are encoded by one-byte.
6083 Return one of EOL_SEEN_XXX. */
6085 #define MAX_EOL_CHECK_COUNT 3
6088 detect_eol (const unsigned char *source
, ptrdiff_t src_bytes
,
6089 enum coding_category category
)
6091 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
6094 int eol_seen
= EOL_SEEN_NONE
;
6096 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
6098 bool msb
= category
== (coding_category_utf_16_le
6099 | coding_category_utf_16_le_nosig
);
6102 while (src
+ 1 < src_end
)
6105 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
6110 this_eol
= EOL_SEEN_LF
;
6111 else if (src
+ 3 >= src_end
6112 || src
[msb
+ 2] != 0
6113 || src
[lsb
+ 2] != '\n')
6114 this_eol
= EOL_SEEN_CR
;
6117 this_eol
= EOL_SEEN_CRLF
;
6121 if (eol_seen
== EOL_SEEN_NONE
)
6122 /* This is the first end-of-line. */
6123 eol_seen
= this_eol
;
6124 else if (eol_seen
!= this_eol
)
6126 /* The found type is different from what found before.
6127 Allow for stray ^M characters in DOS EOL files. */
6128 if ((eol_seen
== EOL_SEEN_CR
&& this_eol
== EOL_SEEN_CRLF
)
6129 || (eol_seen
== EOL_SEEN_CRLF
6130 && this_eol
== EOL_SEEN_CR
))
6131 eol_seen
= EOL_SEEN_CRLF
;
6134 eol_seen
= EOL_SEEN_LF
;
6138 if (++total
== MAX_EOL_CHECK_COUNT
)
6145 while (src
< src_end
)
6148 if (c
== '\n' || c
== '\r')
6153 this_eol
= EOL_SEEN_LF
;
6154 else if (src
>= src_end
|| *src
!= '\n')
6155 this_eol
= EOL_SEEN_CR
;
6157 this_eol
= EOL_SEEN_CRLF
, src
++;
6159 if (eol_seen
== EOL_SEEN_NONE
)
6160 /* This is the first end-of-line. */
6161 eol_seen
= this_eol
;
6162 else if (eol_seen
!= this_eol
)
6164 /* The found type is different from what found before.
6165 Allow for stray ^M characters in DOS EOL files. */
6166 if ((eol_seen
== EOL_SEEN_CR
&& this_eol
== EOL_SEEN_CRLF
)
6167 || (eol_seen
== EOL_SEEN_CRLF
&& this_eol
== EOL_SEEN_CR
))
6168 eol_seen
= EOL_SEEN_CRLF
;
6171 eol_seen
= EOL_SEEN_LF
;
6175 if (++total
== MAX_EOL_CHECK_COUNT
)
6184 adjust_coding_eol_type (struct coding_system
*coding
, int eol_seen
)
6186 Lisp_Object eol_type
;
6188 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6189 if (eol_seen
& EOL_SEEN_LF
)
6191 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
6194 else if (eol_seen
& EOL_SEEN_CRLF
)
6196 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
6199 else if (eol_seen
& EOL_SEEN_CR
)
6201 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
6207 /* Detect how a text specified in CODING is encoded. If a coding
6208 system is detected, update fields of CODING by the detected coding
6212 detect_coding (struct coding_system
*coding
)
6214 const unsigned char *src
, *src_end
;
6215 unsigned int saved_mode
= coding
->mode
;
6217 coding
->consumed
= coding
->consumed_char
= 0;
6218 coding
->produced
= coding
->produced_char
= 0;
6219 coding_set_source (coding
);
6221 src_end
= coding
->source
+ coding
->src_bytes
;
6222 coding
->head_ascii
= 0;
6224 /* If we have not yet decided the text encoding type, detect it
6226 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
6229 struct coding_detection_info detect_info
;
6230 bool null_byte_found
= 0, eight_bit_found
= 0;
6232 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
6233 for (src
= coding
->source
; src
< src_end
; src
++)
6238 eight_bit_found
= 1;
6239 if (null_byte_found
)
6244 if ((c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
6245 && ! inhibit_iso_escape_detection
6246 && ! detect_info
.checked
)
6248 if (detect_coding_iso_2022 (coding
, &detect_info
))
6250 /* We have scanned the whole data. */
6251 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
6253 /* We didn't find an 8-bit code. We may
6254 have found a null-byte, but it's very
6255 rare that a binary file conforms to
6258 coding
->head_ascii
= src
- coding
->source
;
6260 detect_info
.rejected
|= ~CATEGORY_MASK_ISO_ESCAPE
;
6264 else if (! c
&& !inhibit_null_byte_detection
)
6266 null_byte_found
= 1;
6267 if (eight_bit_found
)
6270 if (! eight_bit_found
)
6271 coding
->head_ascii
++;
6273 else if (! eight_bit_found
)
6274 coding
->head_ascii
++;
6277 if (null_byte_found
|| eight_bit_found
6278 || coding
->head_ascii
< coding
->src_bytes
6279 || detect_info
.found
)
6281 enum coding_category category
;
6282 struct coding_system
*this;
6284 if (coding
->head_ascii
== coding
->src_bytes
)
6285 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
6286 for (i
= 0; i
< coding_category_raw_text
; i
++)
6288 category
= coding_priorities
[i
];
6289 this = coding_categories
+ category
;
6290 if (detect_info
.found
& (1 << category
))
6295 if (null_byte_found
)
6297 detect_info
.checked
|= ~CATEGORY_MASK_UTF_16
;
6298 detect_info
.rejected
|= ~CATEGORY_MASK_UTF_16
;
6300 for (i
= 0; i
< coding_category_raw_text
; i
++)
6302 category
= coding_priorities
[i
];
6303 this = coding_categories
+ category
;
6304 /* Some of this->detector (e.g. detect_coding_sjis)
6305 require this information. */
6306 coding
->id
= this->id
;
6309 /* No coding system of this category is defined. */
6310 detect_info
.rejected
|= (1 << category
);
6312 else if (category
>= coding_category_raw_text
)
6314 else if (detect_info
.checked
& (1 << category
))
6316 if (detect_info
.found
& (1 << category
))
6319 else if ((*(this->detector
)) (coding
, &detect_info
)
6320 && detect_info
.found
& (1 << category
))
6322 if (category
== coding_category_utf_16_auto
)
6324 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
6325 category
= coding_category_utf_16_le
;
6327 category
= coding_category_utf_16_be
;
6334 if (i
< coding_category_raw_text
)
6335 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
6336 else if (null_byte_found
)
6337 setup_coding_system (Qno_conversion
, coding
);
6338 else if ((detect_info
.rejected
& CATEGORY_MASK_ANY
)
6339 == CATEGORY_MASK_ANY
)
6340 setup_coding_system (Qraw_text
, coding
);
6341 else if (detect_info
.rejected
)
6342 for (i
= 0; i
< coding_category_raw_text
; i
++)
6343 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
6345 this = coding_categories
+ coding_priorities
[i
];
6346 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
6351 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
6352 == coding_category_utf_8_auto
)
6354 Lisp_Object coding_systems
;
6355 struct coding_detection_info detect_info
;
6358 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6359 detect_info
.found
= detect_info
.rejected
= 0;
6360 coding
->head_ascii
= 0;
6361 if (CONSP (coding_systems
)
6362 && detect_coding_utf_8 (coding
, &detect_info
))
6364 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
6365 setup_coding_system (XCAR (coding_systems
), coding
);
6367 setup_coding_system (XCDR (coding_systems
), coding
);
6370 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
6371 == coding_category_utf_16_auto
)
6373 Lisp_Object coding_systems
;
6374 struct coding_detection_info detect_info
;
6377 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6378 detect_info
.found
= detect_info
.rejected
= 0;
6379 coding
->head_ascii
= 0;
6380 if (CONSP (coding_systems
)
6381 && detect_coding_utf_16 (coding
, &detect_info
))
6383 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
6384 setup_coding_system (XCAR (coding_systems
), coding
);
6385 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
6386 setup_coding_system (XCDR (coding_systems
), coding
);
6389 coding
->mode
= saved_mode
;
6394 decode_eol (struct coding_system
*coding
)
6396 Lisp_Object eol_type
;
6397 unsigned char *p
, *pbeg
, *pend
;
6399 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6400 if (EQ (eol_type
, Qunix
) || inhibit_eol_conversion
)
6403 if (NILP (coding
->dst_object
))
6404 pbeg
= coding
->destination
;
6406 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
6407 pend
= pbeg
+ coding
->produced
;
6409 if (VECTORP (eol_type
))
6411 int eol_seen
= EOL_SEEN_NONE
;
6413 for (p
= pbeg
; p
< pend
; p
++)
6416 eol_seen
|= EOL_SEEN_LF
;
6417 else if (*p
== '\r')
6419 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
6421 eol_seen
|= EOL_SEEN_CRLF
;
6425 eol_seen
|= EOL_SEEN_CR
;
6428 /* Handle DOS-style EOLs in a file with stray ^M characters. */
6429 if ((eol_seen
& EOL_SEEN_CRLF
) != 0
6430 && (eol_seen
& EOL_SEEN_CR
) != 0
6431 && (eol_seen
& EOL_SEEN_LF
) == 0)
6432 eol_seen
= EOL_SEEN_CRLF
;
6433 else if (eol_seen
!= EOL_SEEN_NONE
6434 && eol_seen
!= EOL_SEEN_LF
6435 && eol_seen
!= EOL_SEEN_CRLF
6436 && eol_seen
!= EOL_SEEN_CR
)
6437 eol_seen
= EOL_SEEN_LF
;
6438 if (eol_seen
!= EOL_SEEN_NONE
)
6439 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
6442 if (EQ (eol_type
, Qmac
))
6444 for (p
= pbeg
; p
< pend
; p
++)
6448 else if (EQ (eol_type
, Qdos
))
6452 if (NILP (coding
->dst_object
))
6454 /* Start deleting '\r' from the tail to minimize the memory
6456 for (p
= pend
- 2; p
>= pbeg
; p
--)
6459 memmove (p
, p
+ 1, pend
-- - p
- 1);
6465 ptrdiff_t pos_byte
= coding
->dst_pos_byte
;
6466 ptrdiff_t pos
= coding
->dst_pos
;
6467 ptrdiff_t pos_end
= pos
+ coding
->produced_char
- 1;
6469 while (pos
< pos_end
)
6471 p
= BYTE_POS_ADDR (pos_byte
);
6472 if (*p
== '\r' && p
[1] == '\n')
6474 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
6479 if (coding
->dst_multibyte
)
6480 pos_byte
+= BYTES_BY_CHAR_HEAD (*p
);
6485 coding
->produced
-= n
;
6486 coding
->produced_char
-= n
;
6491 /* Return a translation table (or list of them) from coding system
6492 attribute vector ATTRS for encoding (if ENCODEP) or decoding (if
6496 get_translation_table (Lisp_Object attrs
, bool encodep
, int *max_lookup
)
6498 Lisp_Object standard
, translation_table
;
6501 if (NILP (Venable_character_translation
))
6508 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
6509 standard
= Vstandard_translation_table_for_encode
;
6511 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
6512 standard
= Vstandard_translation_table_for_decode
;
6513 if (NILP (translation_table
))
6514 translation_table
= standard
;
6517 if (SYMBOLP (translation_table
))
6518 translation_table
= Fget (translation_table
, Qtranslation_table
);
6519 else if (CONSP (translation_table
))
6521 translation_table
= Fcopy_sequence (translation_table
);
6522 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
6523 if (SYMBOLP (XCAR (val
)))
6524 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
6526 if (CHAR_TABLE_P (standard
))
6528 if (CONSP (translation_table
))
6529 translation_table
= nconc2 (translation_table
,
6530 Fcons (standard
, Qnil
));
6532 translation_table
= Fcons (translation_table
,
6533 Fcons (standard
, Qnil
));
6540 if (CHAR_TABLE_P (translation_table
)
6541 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
6543 val
= XCHAR_TABLE (translation_table
)->extras
[1];
6544 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
6545 *max_lookup
= XFASTINT (val
);
6547 else if (CONSP (translation_table
))
6551 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
6552 if (CHAR_TABLE_P (XCAR (tail
))
6553 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
6555 Lisp_Object tailval
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
6556 if (NATNUMP (tailval
) && *max_lookup
< XFASTINT (tailval
))
6557 *max_lookup
= XFASTINT (tailval
);
6561 return translation_table
;
6564 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
6567 if (CHAR_TABLE_P (table)) \
6569 trans = CHAR_TABLE_REF (table, c); \
6570 if (CHARACTERP (trans)) \
6571 c = XFASTINT (trans), trans = Qnil; \
6573 else if (CONSP (table)) \
6577 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
6578 if (CHAR_TABLE_P (XCAR (tail))) \
6580 trans = CHAR_TABLE_REF (XCAR (tail), c); \
6581 if (CHARACTERP (trans)) \
6582 c = XFASTINT (trans), trans = Qnil; \
6583 else if (! NILP (trans)) \
6590 /* Return a translation of character(s) at BUF according to TRANS.
6591 TRANS is TO-CHAR or ((FROM . TO) ...) where
6592 FROM = [FROM-CHAR ...], TO is TO-CHAR or [TO-CHAR ...].
6593 The return value is TO-CHAR or ([FROM-CHAR ...] . TO) if a
6594 translation is found, and Qnil if not found..
6595 If BUF is too short to lookup characters in FROM, return Qt. */
6598 get_translation (Lisp_Object trans
, int *buf
, int *buf_end
)
6601 if (INTEGERP (trans
))
6603 for (; CONSP (trans
); trans
= XCDR (trans
))
6605 Lisp_Object val
= XCAR (trans
);
6606 Lisp_Object from
= XCAR (val
);
6607 ptrdiff_t len
= ASIZE (from
);
6610 for (i
= 0; i
< len
; i
++)
6612 if (buf
+ i
== buf_end
)
6614 if (XINT (AREF (from
, i
)) != buf
[i
])
6625 produce_chars (struct coding_system
*coding
, Lisp_Object translation_table
,
6628 unsigned char *dst
= coding
->destination
+ coding
->produced
;
6629 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
6631 ptrdiff_t produced_chars
= 0;
6634 if (! coding
->chars_at_source
)
6636 /* Source characters are in coding->charbuf. */
6637 int *buf
= coding
->charbuf
;
6638 int *buf_end
= buf
+ coding
->charbuf_used
;
6640 if (EQ (coding
->src_object
, coding
->dst_object
))
6642 coding_set_source (coding
);
6643 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
6646 while (buf
< buf_end
)
6653 ptrdiff_t from_nchars
= 1, to_nchars
= 1;
6654 Lisp_Object trans
= Qnil
;
6656 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6659 trans
= get_translation (trans
, buf
, buf_end
);
6660 if (INTEGERP (trans
))
6662 else if (CONSP (trans
))
6664 from_nchars
= ASIZE (XCAR (trans
));
6665 trans
= XCDR (trans
);
6666 if (INTEGERP (trans
))
6670 to_nchars
= ASIZE (trans
);
6671 c
= XINT (AREF (trans
, 0));
6674 else if (EQ (trans
, Qt
) && ! last_block
)
6678 if ((dst_end
- dst
) / MAX_MULTIBYTE_LENGTH
< to_nchars
)
6680 if (((min (PTRDIFF_MAX
, SIZE_MAX
) - (buf_end
- buf
))
6681 / MAX_MULTIBYTE_LENGTH
)
6683 memory_full (SIZE_MAX
);
6684 dst
= alloc_destination (coding
,
6686 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
6688 if (EQ (coding
->src_object
, coding
->dst_object
))
6690 coding_set_source (coding
);
6691 dst_end
= (((unsigned char *) coding
->source
)
6692 + coding
->consumed
);
6695 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6698 for (i
= 0; i
< to_nchars
; i
++)
6701 c
= XINT (AREF (trans
, i
));
6702 if (coding
->dst_multibyte
6703 || ! CHAR_BYTE8_P (c
))
6704 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
6706 *dst
++ = CHAR_TO_BYTE8 (c
);
6708 produced_chars
+= to_nchars
;
6712 /* This is an annotation datum. (-C) is the length. */
6715 carryover
= buf_end
- buf
;
6719 /* Source characters are at coding->source. */
6720 const unsigned char *src
= coding
->source
;
6721 const unsigned char *src_end
= src
+ coding
->consumed
;
6723 if (EQ (coding
->dst_object
, coding
->src_object
))
6724 dst_end
= (unsigned char *) src
;
6725 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
6727 if (coding
->src_multibyte
)
6729 bool multibytep
= 1;
6730 ptrdiff_t consumed_chars
= 0;
6734 const unsigned char *src_base
= src
;
6740 if (EQ (coding
->src_object
, coding
->dst_object
))
6741 dst_end
= (unsigned char *) src
;
6744 ptrdiff_t offset
= src
- coding
->source
;
6746 dst
= alloc_destination (coding
, src_end
- src
+ 1,
6748 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6749 coding_set_source (coding
);
6750 src
= coding
->source
+ offset
;
6751 src_end
= coding
->source
+ coding
->consumed
;
6752 if (EQ (coding
->src_object
, coding
->dst_object
))
6753 dst_end
= (unsigned char *) src
;
6763 while (src
< src_end
)
6765 bool multibytep
= 1;
6768 if (dst
>= dst_end
- 1)
6770 if (EQ (coding
->src_object
, coding
->dst_object
))
6771 dst_end
= (unsigned char *) src
;
6772 if (dst
>= dst_end
- 1)
6774 ptrdiff_t offset
= src
- coding
->source
;
6775 ptrdiff_t more_bytes
;
6777 if (EQ (coding
->src_object
, coding
->dst_object
))
6778 more_bytes
= ((src_end
- src
) / 2) + 2;
6780 more_bytes
= src_end
- src
+ 2;
6781 dst
= alloc_destination (coding
, more_bytes
, dst
);
6782 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6783 coding_set_source (coding
);
6784 src
= coding
->source
+ offset
;
6785 src_end
= coding
->source
+ coding
->consumed
;
6786 if (EQ (coding
->src_object
, coding
->dst_object
))
6787 dst_end
= (unsigned char *) src
;
6795 if (!EQ (coding
->src_object
, coding
->dst_object
))
6797 ptrdiff_t require
= coding
->src_bytes
- coding
->dst_bytes
;
6801 ptrdiff_t offset
= src
- coding
->source
;
6803 dst
= alloc_destination (coding
, require
, dst
);
6804 coding_set_source (coding
);
6805 src
= coding
->source
+ offset
;
6806 src_end
= coding
->source
+ coding
->consumed
;
6809 produced_chars
= coding
->consumed_char
;
6810 while (src
< src_end
)
6815 produced
= dst
- (coding
->destination
+ coding
->produced
);
6816 if (BUFFERP (coding
->dst_object
) && produced_chars
> 0)
6817 insert_from_gap (produced_chars
, produced
);
6818 coding
->produced
+= produced
;
6819 coding
->produced_char
+= produced_chars
;
6823 /* Compose text in CODING->object according to the annotation data at
6824 CHARBUF. CHARBUF is an array:
6825 [ -LENGTH ANNOTATION_MASK NCHARS NBYTES METHOD [ COMPONENTS... ] ]
6829 produce_composition (struct coding_system
*coding
, int *charbuf
, ptrdiff_t pos
)
6833 enum composition_method method
;
6834 Lisp_Object components
;
6836 len
= -charbuf
[0] - MAX_ANNOTATION_LENGTH
;
6837 to
= pos
+ charbuf
[2];
6838 method
= (enum composition_method
) (charbuf
[4]);
6840 if (method
== COMPOSITION_RELATIVE
)
6844 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6847 if (method
== COMPOSITION_WITH_RULE
)
6848 len
= charbuf
[2] * 3 - 2;
6849 charbuf
+= MAX_ANNOTATION_LENGTH
;
6850 /* charbuf = [ CHRA ... CHAR] or [ CHAR -2 RULE ... CHAR ] */
6851 for (i
= j
= 0; i
< len
&& charbuf
[i
] != -1; i
++, j
++)
6853 if (charbuf
[i
] >= 0)
6854 args
[j
] = make_number (charbuf
[i
]);
6858 args
[j
] = make_number (charbuf
[i
] % 0x100);
6861 components
= (i
== j
? Fstring (j
, args
) : Fvector (j
, args
));
6863 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6867 /* Put `charset' property on text in CODING->object according to
6868 the annotation data at CHARBUF. CHARBUF is an array:
6869 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6873 produce_charset (struct coding_system
*coding
, int *charbuf
, ptrdiff_t pos
)
6875 ptrdiff_t from
= pos
- charbuf
[2];
6876 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6878 Fput_text_property (make_number (from
), make_number (pos
),
6879 Qcharset
, CHARSET_NAME (charset
),
6880 coding
->dst_object
);
6884 #define CHARBUF_SIZE 0x4000
6886 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6888 int size = CHARBUF_SIZE; \
6890 coding->charbuf = NULL; \
6891 while (size > 1024) \
6893 coding->charbuf = alloca (sizeof (int) * size); \
6894 if (coding->charbuf) \
6898 if (! coding->charbuf) \
6900 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6903 coding->charbuf_size = size; \
6908 produce_annotation (struct coding_system
*coding
, ptrdiff_t pos
)
6910 int *charbuf
= coding
->charbuf
;
6911 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6913 if (NILP (coding
->dst_object
))
6916 while (charbuf
< charbuf_end
)
6922 int len
= -*charbuf
;
6927 case CODING_ANNOTATE_COMPOSITION_MASK
:
6928 produce_composition (coding
, charbuf
, pos
);
6930 case CODING_ANNOTATE_CHARSET_MASK
:
6931 produce_charset (coding
, charbuf
, pos
);
6939 /* Decode the data at CODING->src_object into CODING->dst_object.
6940 CODING->src_object is a buffer, a string, or nil.
6941 CODING->dst_object is a buffer.
6943 If CODING->src_object is a buffer, it must be the current buffer.
6944 In this case, if CODING->src_pos is positive, it is a position of
6945 the source text in the buffer, otherwise, the source text is in the
6946 gap area of the buffer, and CODING->src_pos specifies the offset of
6947 the text from GPT (which must be the same as PT). If this is the
6948 same buffer as CODING->dst_object, CODING->src_pos must be
6951 If CODING->src_object is a string, CODING->src_pos is an index to
6954 If CODING->src_object is nil, CODING->source must already point to
6955 the non-relocatable memory area. In this case, CODING->src_pos is
6956 an offset from CODING->source.
6958 The decoded data is inserted at the current point of the buffer
6963 decode_coding (struct coding_system
*coding
)
6966 Lisp_Object undo_list
;
6967 Lisp_Object translation_table
;
6968 struct ccl_spec cclspec
;
6972 if (BUFFERP (coding
->src_object
)
6973 && coding
->src_pos
> 0
6974 && coding
->src_pos
< GPT
6975 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6976 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6979 if (BUFFERP (coding
->dst_object
))
6981 set_buffer_internal (XBUFFER (coding
->dst_object
));
6983 move_gap_both (PT
, PT_BYTE
);
6985 /* We must disable undo_list in order to record the whole insert
6986 transaction via record_insert at the end. But doing so also
6987 disables the recording of the first change to the undo_list.
6988 Therefore we check for first change here and record it via
6989 record_first_change if needed. */
6990 if (MODIFF
<= SAVE_MODIFF
)
6991 record_first_change ();
6993 undo_list
= BVAR (current_buffer
, undo_list
);
6994 bset_undo_list (current_buffer
, Qt
);
6997 coding
->consumed
= coding
->consumed_char
= 0;
6998 coding
->produced
= coding
->produced_char
= 0;
6999 coding
->chars_at_source
= 0;
7000 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
7003 ALLOC_CONVERSION_WORK_AREA (coding
);
7005 attrs
= CODING_ID_ATTRS (coding
->id
);
7006 translation_table
= get_translation_table (attrs
, 0, NULL
);
7009 if (coding
->decoder
== decode_coding_ccl
)
7011 coding
->spec
.ccl
= &cclspec
;
7012 setup_ccl_program (&cclspec
.ccl
, CODING_CCL_DECODER (coding
));
7016 ptrdiff_t pos
= coding
->dst_pos
+ coding
->produced_char
;
7018 coding_set_source (coding
);
7019 coding
->annotated
= 0;
7020 coding
->charbuf_used
= carryover
;
7021 (*(coding
->decoder
)) (coding
);
7022 coding_set_destination (coding
);
7023 carryover
= produce_chars (coding
, translation_table
, 0);
7024 if (coding
->annotated
)
7025 produce_annotation (coding
, pos
);
7026 for (i
= 0; i
< carryover
; i
++)
7028 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
7030 while (coding
->result
== CODING_RESULT_INSUFFICIENT_DST
7031 || (coding
->consumed
< coding
->src_bytes
7032 && (coding
->result
== CODING_RESULT_SUCCESS
7033 || coding
->result
== CODING_RESULT_INVALID_SRC
)));
7037 coding_set_destination (coding
);
7038 coding
->charbuf_used
= carryover
;
7039 produce_chars (coding
, translation_table
, 1);
7042 coding
->carryover_bytes
= 0;
7043 if (coding
->consumed
< coding
->src_bytes
)
7045 int nbytes
= coding
->src_bytes
- coding
->consumed
;
7046 const unsigned char *src
;
7048 coding_set_source (coding
);
7049 coding_set_destination (coding
);
7050 src
= coding
->source
+ coding
->consumed
;
7052 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
7054 /* Flush out unprocessed data as binary chars. We are sure
7055 that the number of data is less than the size of
7057 coding
->charbuf_used
= 0;
7058 coding
->chars_at_source
= 0;
7060 while (nbytes
-- > 0)
7065 c
= BYTE8_TO_CHAR (c
);
7066 coding
->charbuf
[coding
->charbuf_used
++] = c
;
7068 produce_chars (coding
, Qnil
, 1);
7072 /* Record unprocessed bytes in coding->carryover. We are
7073 sure that the number of data is less than the size of
7074 coding->carryover. */
7075 unsigned char *p
= coding
->carryover
;
7077 if (nbytes
> sizeof coding
->carryover
)
7078 nbytes
= sizeof coding
->carryover
;
7079 coding
->carryover_bytes
= nbytes
;
7080 while (nbytes
-- > 0)
7083 coding
->consumed
= coding
->src_bytes
;
7086 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
)
7087 && !inhibit_eol_conversion
)
7088 decode_eol (coding
);
7089 if (BUFFERP (coding
->dst_object
))
7091 bset_undo_list (current_buffer
, undo_list
);
7092 record_insert (coding
->dst_pos
, coding
->produced_char
);
7097 /* Extract an annotation datum from a composition starting at POS and
7098 ending before LIMIT of CODING->src_object (buffer or string), store
7099 the data in BUF, set *STOP to a starting position of the next
7100 composition (if any) or to LIMIT, and return the address of the
7101 next element of BUF.
7103 If such an annotation is not found, set *STOP to a starting
7104 position of a composition after POS (if any) or to LIMIT, and
7108 handle_composition_annotation (ptrdiff_t pos
, ptrdiff_t limit
,
7109 struct coding_system
*coding
, int *buf
,
7112 ptrdiff_t start
, end
;
7115 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
7118 else if (start
> pos
)
7124 /* We found a composition. Store the corresponding
7125 annotation data in BUF. */
7127 enum composition_method method
= COMPOSITION_METHOD (prop
);
7128 int nchars
= COMPOSITION_LENGTH (prop
);
7130 ADD_COMPOSITION_DATA (buf
, nchars
, 0, method
);
7131 if (method
!= COMPOSITION_RELATIVE
)
7133 Lisp_Object components
;
7134 ptrdiff_t i
, len
, i_byte
;
7136 components
= COMPOSITION_COMPONENTS (prop
);
7137 if (VECTORP (components
))
7139 len
= ASIZE (components
);
7140 for (i
= 0; i
< len
; i
++)
7141 *buf
++ = XINT (AREF (components
, i
));
7143 else if (STRINGP (components
))
7145 len
= SCHARS (components
);
7149 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
7153 else if (INTEGERP (components
))
7156 *buf
++ = XINT (components
);
7158 else if (CONSP (components
))
7160 for (len
= 0; CONSP (components
);
7161 len
++, components
= XCDR (components
))
7162 *buf
++ = XINT (XCAR (components
));
7170 if (find_composition (end
, limit
, &start
, &end
, &prop
,
7181 /* Extract an annotation datum from a text property `charset' at POS of
7182 CODING->src_object (buffer of string), store the data in BUF, set
7183 *STOP to the position where the value of `charset' property changes
7184 (limiting by LIMIT), and return the address of the next element of
7187 If the property value is nil, set *STOP to the position where the
7188 property value is non-nil (limiting by LIMIT), and return BUF. */
7191 handle_charset_annotation (ptrdiff_t pos
, ptrdiff_t limit
,
7192 struct coding_system
*coding
, int *buf
,
7195 Lisp_Object val
, next
;
7198 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
7199 if (! NILP (val
) && CHARSETP (val
))
7200 id
= XINT (CHARSET_SYMBOL_ID (val
));
7203 ADD_CHARSET_DATA (buf
, 0, id
);
7204 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
7206 make_number (limit
));
7207 *stop
= XINT (next
);
7213 consume_chars (struct coding_system
*coding
, Lisp_Object translation_table
,
7216 int *buf
= coding
->charbuf
;
7217 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
7218 const unsigned char *src
= coding
->source
+ coding
->consumed
;
7219 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
7220 ptrdiff_t pos
= coding
->src_pos
+ coding
->consumed_char
;
7221 ptrdiff_t end_pos
= coding
->src_pos
+ coding
->src_chars
;
7222 bool multibytep
= coding
->src_multibyte
;
7223 Lisp_Object eol_type
;
7225 ptrdiff_t stop
, stop_composition
, stop_charset
;
7226 int *lookup_buf
= NULL
;
7228 if (! NILP (translation_table
))
7229 lookup_buf
= alloca (sizeof (int) * max_lookup
);
7231 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
7232 if (VECTORP (eol_type
))
7235 /* Note: composition handling is not yet implemented. */
7236 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
7238 if (NILP (coding
->src_object
))
7239 stop
= stop_composition
= stop_charset
= end_pos
;
7242 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
7243 stop
= stop_composition
= pos
;
7245 stop
= stop_composition
= end_pos
;
7246 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
7247 stop
= stop_charset
= pos
;
7249 stop_charset
= end_pos
;
7252 /* Compensate for CRLF and conversion. */
7253 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
7254 while (buf
< buf_end
)
7262 if (pos
== stop_composition
)
7263 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
7264 buf
, &stop_composition
);
7265 if (pos
== stop_charset
)
7266 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
7267 buf
, &stop_charset
);
7268 stop
= (stop_composition
< stop_charset
7269 ? stop_composition
: stop_charset
);
7276 if (coding
->encoder
== encode_coding_raw_text
7277 || coding
->encoder
== encode_coding_ccl
)
7279 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
7280 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
+= bytes
;
7282 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
7285 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
++;
7286 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
7288 if (! EQ (eol_type
, Qunix
))
7292 if (EQ (eol_type
, Qdos
))
7300 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
7305 ptrdiff_t from_nchars
= 1, to_nchars
= 1;
7306 int *lookup_buf_end
;
7307 const unsigned char *p
= src
;
7311 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
7312 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
7313 lookup_buf_end
= lookup_buf
+ i
;
7314 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
);
7315 if (INTEGERP (trans
))
7317 else if (CONSP (trans
))
7319 from_nchars
= ASIZE (XCAR (trans
));
7320 trans
= XCDR (trans
);
7321 if (INTEGERP (trans
))
7325 to_nchars
= ASIZE (trans
);
7326 if (buf_end
- buf
< to_nchars
)
7328 c
= XINT (AREF (trans
, 0));
7334 for (i
= 1; i
< to_nchars
; i
++)
7335 *buf
++ = XINT (AREF (trans
, i
));
7336 for (i
= 1; i
< from_nchars
; i
++, pos
++)
7337 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
7341 coding
->consumed
= src
- coding
->source
;
7342 coding
->consumed_char
= pos
- coding
->src_pos
;
7343 coding
->charbuf_used
= buf
- coding
->charbuf
;
7344 coding
->chars_at_source
= 0;
7348 /* Encode the text at CODING->src_object into CODING->dst_object.
7349 CODING->src_object is a buffer or a string.
7350 CODING->dst_object is a buffer or nil.
7352 If CODING->src_object is a buffer, it must be the current buffer.
7353 In this case, if CODING->src_pos is positive, it is a position of
7354 the source text in the buffer, otherwise. the source text is in the
7355 gap area of the buffer, and coding->src_pos specifies the offset of
7356 the text from GPT (which must be the same as PT). If this is the
7357 same buffer as CODING->dst_object, CODING->src_pos must be
7358 negative and CODING should not have `pre-write-conversion'.
7360 If CODING->src_object is a string, CODING should not have
7361 `pre-write-conversion'.
7363 If CODING->dst_object is a buffer, the encoded data is inserted at
7364 the current point of that buffer.
7366 If CODING->dst_object is nil, the encoded data is placed at the
7367 memory area specified by CODING->destination. */
7370 encode_coding (struct coding_system
*coding
)
7373 Lisp_Object translation_table
;
7375 struct ccl_spec cclspec
;
7377 attrs
= CODING_ID_ATTRS (coding
->id
);
7378 if (coding
->encoder
== encode_coding_raw_text
)
7379 translation_table
= Qnil
, max_lookup
= 0;
7381 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
7383 if (BUFFERP (coding
->dst_object
))
7385 set_buffer_internal (XBUFFER (coding
->dst_object
));
7386 coding
->dst_multibyte
7387 = ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
7390 coding
->consumed
= coding
->consumed_char
= 0;
7391 coding
->produced
= coding
->produced_char
= 0;
7392 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
7395 ALLOC_CONVERSION_WORK_AREA (coding
);
7397 if (coding
->encoder
== encode_coding_ccl
)
7399 coding
->spec
.ccl
= &cclspec
;
7400 setup_ccl_program (&cclspec
.ccl
, CODING_CCL_ENCODER (coding
));
7403 coding_set_source (coding
);
7404 consume_chars (coding
, translation_table
, max_lookup
);
7405 coding_set_destination (coding
);
7406 (*(coding
->encoder
)) (coding
);
7407 } while (coding
->consumed_char
< coding
->src_chars
);
7409 if (BUFFERP (coding
->dst_object
) && coding
->produced_char
> 0)
7410 insert_from_gap (coding
->produced_char
, coding
->produced
);
7414 /* Name (or base name) of work buffer for code conversion. */
7415 static Lisp_Object Vcode_conversion_workbuf_name
;
7417 /* A working buffer used by the top level conversion. Once it is
7418 created, it is never destroyed. It has the name
7419 Vcode_conversion_workbuf_name. The other working buffers are
7420 destroyed after the use is finished, and their names are modified
7421 versions of Vcode_conversion_workbuf_name. */
7422 static Lisp_Object Vcode_conversion_reused_workbuf
;
7424 /* True iff Vcode_conversion_reused_workbuf is already in use. */
7425 static bool reused_workbuf_in_use
;
7428 /* Return a working buffer of code conversion. MULTIBYTE specifies the
7429 multibyteness of returning buffer. */
7432 make_conversion_work_buffer (bool multibyte
)
7434 Lisp_Object name
, workbuf
;
7435 struct buffer
*current
;
7437 if (reused_workbuf_in_use
)
7439 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
7440 workbuf
= Fget_buffer_create (name
);
7444 reused_workbuf_in_use
= 1;
7445 if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf
)))
7446 Vcode_conversion_reused_workbuf
7447 = Fget_buffer_create (Vcode_conversion_workbuf_name
);
7448 workbuf
= Vcode_conversion_reused_workbuf
;
7450 current
= current_buffer
;
7451 set_buffer_internal (XBUFFER (workbuf
));
7452 /* We can't allow modification hooks to run in the work buffer. For
7453 instance, directory_files_internal assumes that file decoding
7454 doesn't compile new regexps. */
7455 Fset (Fmake_local_variable (Qinhibit_modification_hooks
), Qt
);
7457 bset_undo_list (current_buffer
, Qt
);
7458 bset_enable_multibyte_characters (current_buffer
, multibyte
? Qt
: Qnil
);
7459 set_buffer_internal (current
);
7465 code_conversion_restore (Lisp_Object arg
)
7467 Lisp_Object current
, workbuf
;
7468 struct gcpro gcpro1
;
7471 current
= XCAR (arg
);
7472 workbuf
= XCDR (arg
);
7473 if (! NILP (workbuf
))
7475 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
7476 reused_workbuf_in_use
= 0;
7478 Fkill_buffer (workbuf
);
7480 set_buffer_internal (XBUFFER (current
));
7486 code_conversion_save (bool with_work_buf
, bool multibyte
)
7488 Lisp_Object workbuf
= Qnil
;
7491 workbuf
= make_conversion_work_buffer (multibyte
);
7492 record_unwind_protect (code_conversion_restore
,
7493 Fcons (Fcurrent_buffer (), workbuf
));
7498 decode_coding_gap (struct coding_system
*coding
,
7499 ptrdiff_t chars
, ptrdiff_t bytes
)
7501 ptrdiff_t count
= SPECPDL_INDEX ();
7504 code_conversion_save (0, 0);
7506 coding
->src_object
= Fcurrent_buffer ();
7507 coding
->src_chars
= chars
;
7508 coding
->src_bytes
= bytes
;
7509 coding
->src_pos
= -chars
;
7510 coding
->src_pos_byte
= -bytes
;
7511 coding
->src_multibyte
= chars
< bytes
;
7512 coding
->dst_object
= coding
->src_object
;
7513 coding
->dst_pos
= PT
;
7514 coding
->dst_pos_byte
= PT_BYTE
;
7515 coding
->dst_multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
7517 if (CODING_REQUIRE_DETECTION (coding
))
7518 detect_coding (coding
);
7520 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
7521 current_buffer
->text
->inhibit_shrinking
= 1;
7522 decode_coding (coding
);
7523 current_buffer
->text
->inhibit_shrinking
= 0;
7525 attrs
= CODING_ID_ATTRS (coding
->id
);
7526 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7528 ptrdiff_t prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7531 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7532 val
= call1 (CODING_ATTR_POST_READ (attrs
),
7533 make_number (coding
->produced_char
));
7535 coding
->produced_char
+= Z
- prev_Z
;
7536 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7539 unbind_to (count
, Qnil
);
7543 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
7544 SRC_OBJECT into DST_OBJECT by coding context CODING.
7546 SRC_OBJECT is a buffer, a string, or Qnil.
7548 If it is a buffer, the text is at point of the buffer. FROM and TO
7549 are positions in the buffer.
7551 If it is a string, the text is at the beginning of the string.
7552 FROM and TO are indices to the string.
7554 If it is nil, the text is at coding->source. FROM and TO are
7555 indices to coding->source.
7557 DST_OBJECT is a buffer, Qt, or Qnil.
7559 If it is a buffer, the decoded text is inserted at point of the
7560 buffer. If the buffer is the same as SRC_OBJECT, the source text
7563 If it is Qt, a string is made from the decoded text, and
7564 set in CODING->dst_object.
7566 If it is Qnil, the decoded text is stored at CODING->destination.
7567 The caller must allocate CODING->dst_bytes bytes at
7568 CODING->destination by xmalloc. If the decoded text is longer than
7569 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
7573 decode_coding_object (struct coding_system
*coding
,
7574 Lisp_Object src_object
,
7575 ptrdiff_t from
, ptrdiff_t from_byte
,
7576 ptrdiff_t to
, ptrdiff_t to_byte
,
7577 Lisp_Object dst_object
)
7579 ptrdiff_t count
= SPECPDL_INDEX ();
7580 unsigned char *destination
IF_LINT (= NULL
);
7581 ptrdiff_t dst_bytes
IF_LINT (= 0);
7582 ptrdiff_t chars
= to
- from
;
7583 ptrdiff_t bytes
= to_byte
- from_byte
;
7585 ptrdiff_t saved_pt
= -1, saved_pt_byte
IF_LINT (= 0);
7586 bool need_marker_adjustment
= 0;
7587 Lisp_Object old_deactivate_mark
;
7589 old_deactivate_mark
= Vdeactivate_mark
;
7591 if (NILP (dst_object
))
7593 destination
= coding
->destination
;
7594 dst_bytes
= coding
->dst_bytes
;
7597 coding
->src_object
= src_object
;
7598 coding
->src_chars
= chars
;
7599 coding
->src_bytes
= bytes
;
7600 coding
->src_multibyte
= chars
< bytes
;
7602 if (STRINGP (src_object
))
7604 coding
->src_pos
= from
;
7605 coding
->src_pos_byte
= from_byte
;
7607 else if (BUFFERP (src_object
))
7609 set_buffer_internal (XBUFFER (src_object
));
7611 move_gap_both (from
, from_byte
);
7612 if (EQ (src_object
, dst_object
))
7614 struct Lisp_Marker
*tail
;
7616 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7618 tail
->need_adjustment
7619 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7620 need_marker_adjustment
|= tail
->need_adjustment
;
7622 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7623 TEMP_SET_PT_BOTH (from
, from_byte
);
7624 current_buffer
->text
->inhibit_shrinking
= 1;
7625 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7626 coding
->src_pos
= -chars
;
7627 coding
->src_pos_byte
= -bytes
;
7631 coding
->src_pos
= from
;
7632 coding
->src_pos_byte
= from_byte
;
7636 if (CODING_REQUIRE_DETECTION (coding
))
7637 detect_coding (coding
);
7638 attrs
= CODING_ID_ATTRS (coding
->id
);
7640 if (EQ (dst_object
, Qt
)
7641 || (! NILP (CODING_ATTR_POST_READ (attrs
))
7642 && NILP (dst_object
)))
7644 coding
->dst_multibyte
= !CODING_FOR_UNIBYTE (coding
);
7645 coding
->dst_object
= code_conversion_save (1, coding
->dst_multibyte
);
7646 coding
->dst_pos
= BEG
;
7647 coding
->dst_pos_byte
= BEG_BYTE
;
7649 else if (BUFFERP (dst_object
))
7651 code_conversion_save (0, 0);
7652 coding
->dst_object
= dst_object
;
7653 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
7654 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
7655 coding
->dst_multibyte
7656 = ! NILP (BVAR (XBUFFER (dst_object
), enable_multibyte_characters
));
7660 code_conversion_save (0, 0);
7661 coding
->dst_object
= Qnil
;
7662 /* Most callers presume this will return a multibyte result, and they
7663 won't use `binary' or `raw-text' anyway, so let's not worry about
7664 CODING_FOR_UNIBYTE. */
7665 coding
->dst_multibyte
= 1;
7668 decode_coding (coding
);
7670 if (BUFFERP (coding
->dst_object
))
7671 set_buffer_internal (XBUFFER (coding
->dst_object
));
7673 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7675 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7676 ptrdiff_t prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7679 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7680 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7681 old_deactivate_mark
);
7682 val
= safe_call1 (CODING_ATTR_POST_READ (attrs
),
7683 make_number (coding
->produced_char
));
7686 coding
->produced_char
+= Z
- prev_Z
;
7687 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7690 if (EQ (dst_object
, Qt
))
7692 coding
->dst_object
= Fbuffer_string ();
7694 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
7696 set_buffer_internal (XBUFFER (coding
->dst_object
));
7697 if (dst_bytes
< coding
->produced
)
7699 destination
= xrealloc (destination
, coding
->produced
);
7702 record_conversion_result (coding
,
7703 CODING_RESULT_INSUFFICIENT_MEM
);
7704 unbind_to (count
, Qnil
);
7707 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
7708 move_gap_both (BEGV
, BEGV_BYTE
);
7709 memcpy (destination
, BEGV_ADDR
, coding
->produced
);
7710 coding
->destination
= destination
;
7716 /* This is the case of:
7717 (BUFFERP (src_object) && EQ (src_object, dst_object))
7718 As we have moved PT while replacing the original buffer
7719 contents, we must recover it now. */
7720 set_buffer_internal (XBUFFER (src_object
));
7721 current_buffer
->text
->inhibit_shrinking
= 0;
7722 if (saved_pt
< from
)
7723 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7724 else if (saved_pt
< from
+ chars
)
7725 TEMP_SET_PT_BOTH (from
, from_byte
);
7726 else if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
7727 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7728 saved_pt_byte
+ (coding
->produced
- bytes
));
7730 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7731 saved_pt_byte
+ (coding
->produced
- bytes
));
7733 if (need_marker_adjustment
)
7735 struct Lisp_Marker
*tail
;
7737 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7738 if (tail
->need_adjustment
)
7740 tail
->need_adjustment
= 0;
7741 if (tail
->insertion_type
)
7743 tail
->bytepos
= from_byte
;
7744 tail
->charpos
= from
;
7748 tail
->bytepos
= from_byte
+ coding
->produced
;
7750 = (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
7751 ? tail
->bytepos
: from
+ coding
->produced_char
);
7757 Vdeactivate_mark
= old_deactivate_mark
;
7758 unbind_to (count
, coding
->dst_object
);
7763 encode_coding_object (struct coding_system
*coding
,
7764 Lisp_Object src_object
,
7765 ptrdiff_t from
, ptrdiff_t from_byte
,
7766 ptrdiff_t to
, ptrdiff_t to_byte
,
7767 Lisp_Object dst_object
)
7769 ptrdiff_t count
= SPECPDL_INDEX ();
7770 ptrdiff_t chars
= to
- from
;
7771 ptrdiff_t bytes
= to_byte
- from_byte
;
7773 ptrdiff_t saved_pt
= -1, saved_pt_byte
IF_LINT (= 0);
7774 bool need_marker_adjustment
= 0;
7775 bool kill_src_buffer
= 0;
7776 Lisp_Object old_deactivate_mark
;
7778 old_deactivate_mark
= Vdeactivate_mark
;
7780 coding
->src_object
= src_object
;
7781 coding
->src_chars
= chars
;
7782 coding
->src_bytes
= bytes
;
7783 coding
->src_multibyte
= chars
< bytes
;
7785 attrs
= CODING_ID_ATTRS (coding
->id
);
7787 if (EQ (src_object
, dst_object
))
7789 struct Lisp_Marker
*tail
;
7791 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7793 tail
->need_adjustment
7794 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7795 need_marker_adjustment
|= tail
->need_adjustment
;
7799 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
7801 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
7802 set_buffer_internal (XBUFFER (coding
->src_object
));
7803 if (STRINGP (src_object
))
7804 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
7805 else if (BUFFERP (src_object
))
7806 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
7808 insert_1_both ((char *) coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
7810 if (EQ (src_object
, dst_object
))
7812 set_buffer_internal (XBUFFER (src_object
));
7813 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7814 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7815 set_buffer_internal (XBUFFER (coding
->src_object
));
7819 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7821 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7822 old_deactivate_mark
);
7823 safe_call2 (CODING_ATTR_PRE_WRITE (attrs
),
7824 make_number (BEG
), make_number (Z
));
7827 if (XBUFFER (coding
->src_object
) != current_buffer
)
7828 kill_src_buffer
= 1;
7829 coding
->src_object
= Fcurrent_buffer ();
7831 move_gap_both (BEG
, BEG_BYTE
);
7832 coding
->src_chars
= Z
- BEG
;
7833 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
7834 coding
->src_pos
= BEG
;
7835 coding
->src_pos_byte
= BEG_BYTE
;
7836 coding
->src_multibyte
= Z
< Z_BYTE
;
7838 else if (STRINGP (src_object
))
7840 code_conversion_save (0, 0);
7841 coding
->src_pos
= from
;
7842 coding
->src_pos_byte
= from_byte
;
7844 else if (BUFFERP (src_object
))
7846 code_conversion_save (0, 0);
7847 set_buffer_internal (XBUFFER (src_object
));
7848 if (EQ (src_object
, dst_object
))
7850 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7851 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
7852 coding
->src_pos
= 0;
7853 coding
->src_pos_byte
= 0;
7857 if (from
< GPT
&& to
>= GPT
)
7858 move_gap_both (from
, from_byte
);
7859 coding
->src_pos
= from
;
7860 coding
->src_pos_byte
= from_byte
;
7864 code_conversion_save (0, 0);
7866 if (BUFFERP (dst_object
))
7868 coding
->dst_object
= dst_object
;
7869 if (EQ (src_object
, dst_object
))
7871 coding
->dst_pos
= from
;
7872 coding
->dst_pos_byte
= from_byte
;
7876 struct buffer
*current
= current_buffer
;
7878 set_buffer_temp (XBUFFER (dst_object
));
7879 coding
->dst_pos
= PT
;
7880 coding
->dst_pos_byte
= PT_BYTE
;
7881 move_gap_both (coding
->dst_pos
, coding
->dst_pos_byte
);
7882 set_buffer_temp (current
);
7884 coding
->dst_multibyte
7885 = ! NILP (BVAR (XBUFFER (dst_object
), enable_multibyte_characters
));
7887 else if (EQ (dst_object
, Qt
))
7889 ptrdiff_t dst_bytes
= max (1, coding
->src_chars
);
7890 coding
->dst_object
= Qnil
;
7891 coding
->destination
= xmalloc (dst_bytes
);
7892 coding
->dst_bytes
= dst_bytes
;
7893 coding
->dst_multibyte
= 0;
7897 coding
->dst_object
= Qnil
;
7898 coding
->dst_multibyte
= 0;
7901 encode_coding (coding
);
7903 if (EQ (dst_object
, Qt
))
7905 if (BUFFERP (coding
->dst_object
))
7906 coding
->dst_object
= Fbuffer_string ();
7910 = make_unibyte_string ((char *) coding
->destination
,
7912 xfree (coding
->destination
);
7918 /* This is the case of:
7919 (BUFFERP (src_object) && EQ (src_object, dst_object))
7920 As we have moved PT while replacing the original buffer
7921 contents, we must recover it now. */
7922 set_buffer_internal (XBUFFER (src_object
));
7923 if (saved_pt
< from
)
7924 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7925 else if (saved_pt
< from
+ chars
)
7926 TEMP_SET_PT_BOTH (from
, from_byte
);
7927 else if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
7928 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7929 saved_pt_byte
+ (coding
->produced
- bytes
));
7931 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7932 saved_pt_byte
+ (coding
->produced
- bytes
));
7934 if (need_marker_adjustment
)
7936 struct Lisp_Marker
*tail
;
7938 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7939 if (tail
->need_adjustment
)
7941 tail
->need_adjustment
= 0;
7942 if (tail
->insertion_type
)
7944 tail
->bytepos
= from_byte
;
7945 tail
->charpos
= from
;
7949 tail
->bytepos
= from_byte
+ coding
->produced
;
7951 = (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
7952 ? tail
->bytepos
: from
+ coding
->produced_char
);
7958 if (kill_src_buffer
)
7959 Fkill_buffer (coding
->src_object
);
7961 Vdeactivate_mark
= old_deactivate_mark
;
7962 unbind_to (count
, Qnil
);
7967 preferred_coding_system (void)
7969 int id
= coding_categories
[coding_priorities
[0]].id
;
7971 return CODING_ID_NAME (id
);
7976 /*** 8. Emacs Lisp library functions ***/
7978 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7979 doc
: /* Return t if OBJECT is nil or a coding-system.
7980 See the documentation of `define-coding-system' for information
7981 about coding-system objects. */)
7982 (Lisp_Object object
)
7985 || CODING_SYSTEM_ID (object
) >= 0)
7987 if (! SYMBOLP (object
)
7988 || NILP (Fget (object
, Qcoding_system_define_form
)))
7993 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7994 Sread_non_nil_coding_system
, 1, 1, 0,
7995 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7996 (Lisp_Object prompt
)
8001 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
8002 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
8004 while (SCHARS (val
) == 0);
8005 return (Fintern (val
, Qnil
));
8008 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
8009 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
8010 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
8011 Ignores case when completing coding systems (all Emacs coding systems
8012 are lower-case). */)
8013 (Lisp_Object prompt
, Lisp_Object default_coding_system
)
8016 ptrdiff_t count
= SPECPDL_INDEX ();
8018 if (SYMBOLP (default_coding_system
))
8019 default_coding_system
= SYMBOL_NAME (default_coding_system
);
8020 specbind (Qcompletion_ignore_case
, Qt
);
8021 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
8022 Qt
, Qnil
, Qcoding_system_history
,
8023 default_coding_system
, Qnil
);
8024 unbind_to (count
, Qnil
);
8025 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
8028 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
8030 doc
: /* Check validity of CODING-SYSTEM.
8031 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
8032 It is valid if it is nil or a symbol defined as a coding system by the
8033 function `define-coding-system'. */)
8034 (Lisp_Object coding_system
)
8036 Lisp_Object define_form
;
8038 define_form
= Fget (coding_system
, Qcoding_system_define_form
);
8039 if (! NILP (define_form
))
8041 Fput (coding_system
, Qcoding_system_define_form
, Qnil
);
8042 safe_eval (define_form
);
8044 if (!NILP (Fcoding_system_p (coding_system
)))
8045 return coding_system
;
8046 xsignal1 (Qcoding_system_error
, coding_system
);
8050 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
8051 HIGHEST, return the coding system of the highest
8052 priority among the detected coding systems. Otherwise return a
8053 list of detected coding systems sorted by their priorities. If
8054 MULTIBYTEP, it is assumed that the bytes are in correct
8055 multibyte form but contains only ASCII and eight-bit chars.
8056 Otherwise, the bytes are raw bytes.
8058 CODING-SYSTEM controls the detection as below:
8060 If it is nil, detect both text-format and eol-format. If the
8061 text-format part of CODING-SYSTEM is already specified
8062 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
8063 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
8064 detect only text-format. */
8067 detect_coding_system (const unsigned char *src
,
8068 ptrdiff_t src_chars
, ptrdiff_t src_bytes
,
8069 bool highest
, bool multibytep
,
8070 Lisp_Object coding_system
)
8072 const unsigned char *src_end
= src
+ src_bytes
;
8073 Lisp_Object attrs
, eol_type
;
8074 Lisp_Object val
= Qnil
;
8075 struct coding_system coding
;
8077 struct coding_detection_info detect_info
;
8078 enum coding_category base_category
;
8079 bool null_byte_found
= 0, eight_bit_found
= 0;
8081 if (NILP (coding_system
))
8082 coding_system
= Qundecided
;
8083 setup_coding_system (coding_system
, &coding
);
8084 attrs
= CODING_ID_ATTRS (coding
.id
);
8085 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
8086 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
8088 coding
.source
= src
;
8089 coding
.src_chars
= src_chars
;
8090 coding
.src_bytes
= src_bytes
;
8091 coding
.src_multibyte
= multibytep
;
8092 coding
.consumed
= 0;
8093 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8094 coding
.head_ascii
= 0;
8096 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
8098 /* At first, detect text-format if necessary. */
8099 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8100 if (base_category
== coding_category_undecided
)
8102 enum coding_category category
IF_LINT (= 0);
8103 struct coding_system
*this IF_LINT (= NULL
);
8106 /* Skip all ASCII bytes except for a few ISO2022 controls. */
8107 for (; src
< src_end
; src
++)
8112 eight_bit_found
= 1;
8113 if (null_byte_found
)
8118 if ((c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
8119 && ! inhibit_iso_escape_detection
8120 && ! detect_info
.checked
)
8122 if (detect_coding_iso_2022 (&coding
, &detect_info
))
8124 /* We have scanned the whole data. */
8125 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
8127 /* We didn't find an 8-bit code. We may
8128 have found a null-byte, but it's very
8129 rare that a binary file confirm to
8132 coding
.head_ascii
= src
- coding
.source
;
8134 detect_info
.rejected
|= ~CATEGORY_MASK_ISO_ESCAPE
;
8138 else if (! c
&& !inhibit_null_byte_detection
)
8140 null_byte_found
= 1;
8141 if (eight_bit_found
)
8144 if (! eight_bit_found
)
8145 coding
.head_ascii
++;
8147 else if (! eight_bit_found
)
8148 coding
.head_ascii
++;
8151 if (null_byte_found
|| eight_bit_found
8152 || coding
.head_ascii
< coding
.src_bytes
8153 || detect_info
.found
)
8155 if (coding
.head_ascii
== coding
.src_bytes
)
8156 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
8157 for (i
= 0; i
< coding_category_raw_text
; i
++)
8159 category
= coding_priorities
[i
];
8160 this = coding_categories
+ category
;
8161 if (detect_info
.found
& (1 << category
))
8166 if (null_byte_found
)
8168 detect_info
.checked
|= ~CATEGORY_MASK_UTF_16
;
8169 detect_info
.rejected
|= ~CATEGORY_MASK_UTF_16
;
8171 for (i
= 0; i
< coding_category_raw_text
; i
++)
8173 category
= coding_priorities
[i
];
8174 this = coding_categories
+ category
;
8178 /* No coding system of this category is defined. */
8179 detect_info
.rejected
|= (1 << category
);
8181 else if (category
>= coding_category_raw_text
)
8183 else if (detect_info
.checked
& (1 << category
))
8186 && (detect_info
.found
& (1 << category
)))
8189 else if ((*(this->detector
)) (&coding
, &detect_info
)
8191 && (detect_info
.found
& (1 << category
)))
8193 if (category
== coding_category_utf_16_auto
)
8195 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
8196 category
= coding_category_utf_16_le
;
8198 category
= coding_category_utf_16_be
;
8206 if ((detect_info
.rejected
& CATEGORY_MASK_ANY
) == CATEGORY_MASK_ANY
8209 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
8210 id
= CODING_SYSTEM_ID (Qno_conversion
);
8211 val
= Fcons (make_number (id
), Qnil
);
8213 else if (! detect_info
.rejected
&& ! detect_info
.found
)
8215 detect_info
.found
= CATEGORY_MASK_ANY
;
8216 id
= coding_categories
[coding_category_undecided
].id
;
8217 val
= Fcons (make_number (id
), Qnil
);
8221 if (detect_info
.found
)
8223 detect_info
.found
= 1 << category
;
8224 val
= Fcons (make_number (this->id
), Qnil
);
8227 for (i
= 0; i
< coding_category_raw_text
; i
++)
8228 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
8230 detect_info
.found
= 1 << coding_priorities
[i
];
8231 id
= coding_categories
[coding_priorities
[i
]].id
;
8232 val
= Fcons (make_number (id
), Qnil
);
8238 int mask
= detect_info
.rejected
| detect_info
.found
;
8241 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
8243 category
= coding_priorities
[i
];
8244 if (! (mask
& (1 << category
)))
8246 found
|= 1 << category
;
8247 id
= coding_categories
[category
].id
;
8249 val
= Fcons (make_number (id
), val
);
8252 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
8254 category
= coding_priorities
[i
];
8255 if (detect_info
.found
& (1 << category
))
8257 id
= coding_categories
[category
].id
;
8258 val
= Fcons (make_number (id
), val
);
8261 detect_info
.found
|= found
;
8264 else if (base_category
== coding_category_utf_8_auto
)
8266 if (detect_coding_utf_8 (&coding
, &detect_info
))
8268 struct coding_system
*this;
8270 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
8271 this = coding_categories
+ coding_category_utf_8_sig
;
8273 this = coding_categories
+ coding_category_utf_8_nosig
;
8274 val
= Fcons (make_number (this->id
), Qnil
);
8277 else if (base_category
== coding_category_utf_16_auto
)
8279 if (detect_coding_utf_16 (&coding
, &detect_info
))
8281 struct coding_system
*this;
8283 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
8284 this = coding_categories
+ coding_category_utf_16_le
;
8285 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
8286 this = coding_categories
+ coding_category_utf_16_be
;
8287 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
8288 this = coding_categories
+ coding_category_utf_16_be_nosig
;
8290 this = coding_categories
+ coding_category_utf_16_le_nosig
;
8291 val
= Fcons (make_number (this->id
), Qnil
);
8296 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
8297 val
= Fcons (make_number (coding
.id
), Qnil
);
8300 /* Then, detect eol-format if necessary. */
8302 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
= -1;
8305 if (VECTORP (eol_type
))
8307 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
8309 if (null_byte_found
)
8310 normal_eol
= EOL_SEEN_LF
;
8312 normal_eol
= detect_eol (coding
.source
, src_bytes
,
8313 coding_category_raw_text
);
8315 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
8316 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
8317 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
8318 coding_category_utf_16_be
);
8319 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
8320 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
8321 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
8322 coding_category_utf_16_le
);
8326 if (EQ (eol_type
, Qunix
))
8327 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
8328 else if (EQ (eol_type
, Qdos
))
8329 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
8331 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
8334 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
8336 enum coding_category category
;
8339 id
= XINT (XCAR (tail
));
8340 attrs
= CODING_ID_ATTRS (id
);
8341 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8342 eol_type
= CODING_ID_EOL_TYPE (id
);
8343 if (VECTORP (eol_type
))
8345 if (category
== coding_category_utf_16_be
8346 || category
== coding_category_utf_16_be_nosig
)
8347 this_eol
= utf_16_be_eol
;
8348 else if (category
== coding_category_utf_16_le
8349 || category
== coding_category_utf_16_le_nosig
)
8350 this_eol
= utf_16_le_eol
;
8352 this_eol
= normal_eol
;
8354 if (this_eol
== EOL_SEEN_LF
)
8355 XSETCAR (tail
, AREF (eol_type
, 0));
8356 else if (this_eol
== EOL_SEEN_CRLF
)
8357 XSETCAR (tail
, AREF (eol_type
, 1));
8358 else if (this_eol
== EOL_SEEN_CR
)
8359 XSETCAR (tail
, AREF (eol_type
, 2));
8361 XSETCAR (tail
, CODING_ID_NAME (id
));
8364 XSETCAR (tail
, CODING_ID_NAME (id
));
8368 return (highest
? (CONSP (val
) ? XCAR (val
) : Qnil
) : val
);
8372 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
8374 doc
: /* Detect coding system of the text in the region between START and END.
8375 Return a list of possible coding systems ordered by priority.
8376 The coding systems to try and their priorities follows what
8377 the function `coding-system-priority-list' (which see) returns.
8379 If only ASCII characters are found (except for such ISO-2022 control
8380 characters as ESC), it returns a list of single element `undecided'
8381 or its subsidiary coding system according to a detected end-of-line
8384 If optional argument HIGHEST is non-nil, return the coding system of
8385 highest priority. */)
8386 (Lisp_Object start
, Lisp_Object end
, Lisp_Object highest
)
8389 ptrdiff_t from_byte
, to_byte
;
8391 CHECK_NUMBER_COERCE_MARKER (start
);
8392 CHECK_NUMBER_COERCE_MARKER (end
);
8394 validate_region (&start
, &end
);
8395 from
= XINT (start
), to
= XINT (end
);
8396 from_byte
= CHAR_TO_BYTE (from
);
8397 to_byte
= CHAR_TO_BYTE (to
);
8399 if (from
< GPT
&& to
>= GPT
)
8400 move_gap_both (to
, to_byte
);
8402 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
8403 to
- from
, to_byte
- from_byte
,
8405 !NILP (BVAR (current_buffer
8406 , enable_multibyte_characters
)),
8410 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
8412 doc
: /* Detect coding system of the text in STRING.
8413 Return a list of possible coding systems ordered by priority.
8414 The coding systems to try and their priorities follows what
8415 the function `coding-system-priority-list' (which see) returns.
8417 If only ASCII characters are found (except for such ISO-2022 control
8418 characters as ESC), it returns a list of single element `undecided'
8419 or its subsidiary coding system according to a detected end-of-line
8422 If optional argument HIGHEST is non-nil, return the coding system of
8423 highest priority. */)
8424 (Lisp_Object string
, Lisp_Object highest
)
8426 CHECK_STRING (string
);
8428 return detect_coding_system (SDATA (string
),
8429 SCHARS (string
), SBYTES (string
),
8430 !NILP (highest
), STRING_MULTIBYTE (string
),
8436 char_encodable_p (int c
, Lisp_Object attrs
)
8439 struct charset
*charset
;
8440 Lisp_Object translation_table
;
8442 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
8443 if (! NILP (translation_table
))
8444 c
= translate_char (translation_table
, c
);
8445 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
8446 CONSP (tail
); tail
= XCDR (tail
))
8448 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
8449 if (CHAR_CHARSET_P (c
, charset
))
8452 return (! NILP (tail
));
8456 /* Return a list of coding systems that safely encode the text between
8457 START and END. If EXCLUDE is non-nil, it is a list of coding
8458 systems not to check. The returned list doesn't contain any such
8459 coding systems. In any case, if the text contains only ASCII or is
8460 unibyte, return t. */
8462 DEFUN ("find-coding-systems-region-internal",
8463 Ffind_coding_systems_region_internal
,
8464 Sfind_coding_systems_region_internal
, 2, 3, 0,
8465 doc
: /* Internal use only. */)
8466 (Lisp_Object start
, Lisp_Object end
, Lisp_Object exclude
)
8468 Lisp_Object coding_attrs_list
, safe_codings
;
8469 ptrdiff_t start_byte
, end_byte
;
8470 const unsigned char *p
, *pbeg
, *pend
;
8472 Lisp_Object tail
, elt
, work_table
;
8474 if (STRINGP (start
))
8476 if (!STRING_MULTIBYTE (start
)
8477 || SCHARS (start
) == SBYTES (start
))
8480 end_byte
= SBYTES (start
);
8484 CHECK_NUMBER_COERCE_MARKER (start
);
8485 CHECK_NUMBER_COERCE_MARKER (end
);
8486 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8487 args_out_of_range (start
, end
);
8488 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8490 start_byte
= CHAR_TO_BYTE (XINT (start
));
8491 end_byte
= CHAR_TO_BYTE (XINT (end
));
8492 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8495 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8497 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8498 move_gap_both (XINT (start
), start_byte
);
8500 move_gap_both (XINT (end
), end_byte
);
8504 coding_attrs_list
= Qnil
;
8505 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8507 || NILP (Fmemq (XCAR (tail
), exclude
)))
8511 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
8512 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
8513 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
8515 ASET (attrs
, coding_attr_trans_tbl
,
8516 get_translation_table (attrs
, 1, NULL
));
8517 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
8521 if (STRINGP (start
))
8522 p
= pbeg
= SDATA (start
);
8524 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8525 pend
= p
+ (end_byte
- start_byte
);
8527 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
8528 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8530 work_table
= Fmake_char_table (Qnil
, Qnil
);
8533 if (ASCII_BYTE_P (*p
))
8537 c
= STRING_CHAR_ADVANCE (p
);
8538 if (!NILP (char_table_ref (work_table
, c
)))
8539 /* This character was already checked. Ignore it. */
8542 charset_map_loaded
= 0;
8543 for (tail
= coding_attrs_list
; CONSP (tail
);)
8548 else if (char_encodable_p (c
, elt
))
8550 else if (CONSP (XCDR (tail
)))
8552 XSETCAR (tail
, XCAR (XCDR (tail
)));
8553 XSETCDR (tail
, XCDR (XCDR (tail
)));
8557 XSETCAR (tail
, Qnil
);
8561 if (charset_map_loaded
)
8563 ptrdiff_t p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8565 if (STRINGP (start
))
8566 pbeg
= SDATA (start
);
8568 pbeg
= BYTE_POS_ADDR (start_byte
);
8569 p
= pbeg
+ p_offset
;
8570 pend
= pbeg
+ pend_offset
;
8572 char_table_set (work_table
, c
, Qt
);
8576 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
8577 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
8578 if (! NILP (XCAR (tail
)))
8579 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
8581 return safe_codings
;
8585 DEFUN ("unencodable-char-position", Funencodable_char_position
,
8586 Sunencodable_char_position
, 3, 5, 0,
8588 Return position of first un-encodable character in a region.
8589 START and END specify the region and CODING-SYSTEM specifies the
8590 encoding to check. Return nil if CODING-SYSTEM does encode the region.
8592 If optional 4th argument COUNT is non-nil, it specifies at most how
8593 many un-encodable characters to search. In this case, the value is a
8596 If optional 5th argument STRING is non-nil, it is a string to search
8597 for un-encodable characters. In that case, START and END are indexes
8599 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object count
, Lisp_Object string
)
8602 struct coding_system coding
;
8603 Lisp_Object attrs
, charset_list
, translation_table
;
8604 Lisp_Object positions
;
8606 const unsigned char *p
, *stop
, *pend
;
8607 bool ascii_compatible
;
8609 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
8610 attrs
= CODING_ID_ATTRS (coding
.id
);
8611 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
8613 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
8614 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8615 translation_table
= get_translation_table (attrs
, 1, NULL
);
8619 validate_region (&start
, &end
);
8620 from
= XINT (start
);
8622 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
8623 || (ascii_compatible
8624 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
8626 p
= CHAR_POS_ADDR (from
);
8627 pend
= CHAR_POS_ADDR (to
);
8628 if (from
< GPT
&& to
>= GPT
)
8635 CHECK_STRING (string
);
8636 CHECK_NATNUM (start
);
8638 if (! (XINT (start
) <= XINT (end
) && XINT (end
) <= SCHARS (string
)))
8639 args_out_of_range_3 (string
, start
, end
);
8640 from
= XINT (start
);
8642 if (! STRING_MULTIBYTE (string
))
8644 p
= SDATA (string
) + string_char_to_byte (string
, from
);
8645 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
8646 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
8654 CHECK_NATNUM (count
);
8659 charset_map_loaded
= 0;
8664 if (ascii_compatible
)
8665 while (p
< stop
&& ASCII_BYTE_P (*p
))
8675 c
= STRING_CHAR_ADVANCE (p
);
8676 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
8677 && ! char_charset (translate_char (translation_table
, c
),
8678 charset_list
, NULL
))
8680 positions
= Fcons (make_number (from
), positions
);
8687 if (charset_map_loaded
&& NILP (string
))
8689 p
= CHAR_POS_ADDR (from
);
8690 pend
= CHAR_POS_ADDR (to
);
8691 if (from
< GPT
&& to
>= GPT
)
8695 charset_map_loaded
= 0;
8699 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
8703 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
8704 Scheck_coding_systems_region
, 3, 3, 0,
8705 doc
: /* Check if the region is encodable by coding systems.
8707 START and END are buffer positions specifying the region.
8708 CODING-SYSTEM-LIST is a list of coding systems to check.
8710 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
8711 CODING-SYSTEM is a member of CODING-SYSTEM-LIST and can't encode the
8712 whole region, POS0, POS1, ... are buffer positions where non-encodable
8713 characters are found.
8715 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
8718 START may be a string. In that case, check if the string is
8719 encodable, and the value contains indices to the string instead of
8720 buffer positions. END is ignored.
8722 If the current buffer (or START if it is a string) is unibyte, the value
8724 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system_list
)
8727 ptrdiff_t start_byte
, end_byte
;
8729 const unsigned char *p
, *pbeg
, *pend
;
8731 Lisp_Object tail
, elt
, attrs
;
8733 if (STRINGP (start
))
8735 if (!STRING_MULTIBYTE (start
)
8736 || SCHARS (start
) == SBYTES (start
))
8739 end_byte
= SBYTES (start
);
8744 CHECK_NUMBER_COERCE_MARKER (start
);
8745 CHECK_NUMBER_COERCE_MARKER (end
);
8746 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8747 args_out_of_range (start
, end
);
8748 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8750 start_byte
= CHAR_TO_BYTE (XINT (start
));
8751 end_byte
= CHAR_TO_BYTE (XINT (end
));
8752 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8755 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8757 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8758 move_gap_both (XINT (start
), start_byte
);
8760 move_gap_both (XINT (end
), end_byte
);
8766 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8769 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
8770 ASET (attrs
, coding_attr_trans_tbl
,
8771 get_translation_table (attrs
, 1, NULL
));
8772 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
8775 if (STRINGP (start
))
8776 p
= pbeg
= SDATA (start
);
8778 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8779 pend
= p
+ (end_byte
- start_byte
);
8781 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
8782 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8786 if (ASCII_BYTE_P (*p
))
8790 c
= STRING_CHAR_ADVANCE (p
);
8792 charset_map_loaded
= 0;
8793 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
8795 elt
= XCDR (XCAR (tail
));
8796 if (! char_encodable_p (c
, XCAR (elt
)))
8797 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
8799 if (charset_map_loaded
)
8801 ptrdiff_t p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8803 if (STRINGP (start
))
8804 pbeg
= SDATA (start
);
8806 pbeg
= BYTE_POS_ADDR (start_byte
);
8807 p
= pbeg
+ p_offset
;
8808 pend
= pbeg
+ pend_offset
;
8816 for (; CONSP (tail
); tail
= XCDR (tail
))
8819 if (CONSP (XCDR (XCDR (elt
))))
8820 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
8829 code_convert_region (Lisp_Object start
, Lisp_Object end
,
8830 Lisp_Object coding_system
, Lisp_Object dst_object
,
8831 bool encodep
, bool norecord
)
8833 struct coding_system coding
;
8834 ptrdiff_t from
, from_byte
, to
, to_byte
;
8835 Lisp_Object src_object
;
8837 CHECK_NUMBER_COERCE_MARKER (start
);
8838 CHECK_NUMBER_COERCE_MARKER (end
);
8839 if (NILP (coding_system
))
8840 coding_system
= Qno_conversion
;
8842 CHECK_CODING_SYSTEM (coding_system
);
8843 src_object
= Fcurrent_buffer ();
8844 if (NILP (dst_object
))
8845 dst_object
= src_object
;
8846 else if (! EQ (dst_object
, Qt
))
8847 CHECK_BUFFER (dst_object
);
8849 validate_region (&start
, &end
);
8850 from
= XFASTINT (start
);
8851 from_byte
= CHAR_TO_BYTE (from
);
8852 to
= XFASTINT (end
);
8853 to_byte
= CHAR_TO_BYTE (to
);
8855 setup_coding_system (coding_system
, &coding
);
8856 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8859 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8862 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8865 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8867 return (BUFFERP (dst_object
)
8868 ? make_number (coding
.produced_char
)
8869 : coding
.dst_object
);
8873 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
8874 3, 4, "r\nzCoding system: ",
8875 doc
: /* Decode the current region from the specified coding system.
8876 When called from a program, takes four arguments:
8877 START, END, CODING-SYSTEM, and DESTINATION.
8878 START and END are buffer positions.
8880 Optional 4th arguments DESTINATION specifies where the decoded text goes.
8881 If nil, the region between START and END is replaced by the decoded text.
8882 If buffer, the decoded text is inserted in that buffer after point (point
8884 In those cases, the length of the decoded text is returned.
8885 If DESTINATION is t, the decoded text is returned.
8887 This function sets `last-coding-system-used' to the precise coding system
8888 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8889 not fully specified.) */)
8890 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object destination
)
8892 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
8895 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
8896 3, 4, "r\nzCoding system: ",
8897 doc
: /* Encode the current region by specified coding system.
8898 When called from a program, takes four arguments:
8899 START, END, CODING-SYSTEM and DESTINATION.
8900 START and END are buffer positions.
8902 Optional 4th arguments DESTINATION specifies where the encoded text goes.
8903 If nil, the region between START and END is replace by the encoded text.
8904 If buffer, the encoded text is inserted in that buffer after point (point
8906 In those cases, the length of the encoded text is returned.
8907 If DESTINATION is t, the encoded text is returned.
8909 This function sets `last-coding-system-used' to the precise coding system
8910 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8911 not fully specified.) */)
8912 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object destination
)
8914 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
8918 code_convert_string (Lisp_Object string
, Lisp_Object coding_system
,
8919 Lisp_Object dst_object
, bool encodep
, bool nocopy
,
8922 struct coding_system coding
;
8923 ptrdiff_t chars
, bytes
;
8925 CHECK_STRING (string
);
8926 if (NILP (coding_system
))
8929 Vlast_coding_system_used
= Qno_conversion
;
8930 if (NILP (dst_object
))
8931 return (nocopy
? Fcopy_sequence (string
) : string
);
8934 if (NILP (coding_system
))
8935 coding_system
= Qno_conversion
;
8937 CHECK_CODING_SYSTEM (coding_system
);
8938 if (NILP (dst_object
))
8940 else if (! EQ (dst_object
, Qt
))
8941 CHECK_BUFFER (dst_object
);
8943 setup_coding_system (coding_system
, &coding
);
8944 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8945 chars
= SCHARS (string
);
8946 bytes
= SBYTES (string
);
8948 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8950 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8952 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8954 return (BUFFERP (dst_object
)
8955 ? make_number (coding
.produced_char
)
8956 : coding
.dst_object
);
8960 /* Encode or decode STRING according to CODING_SYSTEM.
8961 Do not set Vlast_coding_system_used.
8963 This function is called only from macros DECODE_FILE and
8964 ENCODE_FILE, thus we ignore character composition. */
8967 code_convert_string_norecord (Lisp_Object string
, Lisp_Object coding_system
,
8970 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
8974 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
8976 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8978 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8979 if the decoding operation is trivial.
8981 Optional fourth arg BUFFER non-nil means that the decoded text is
8982 inserted in that buffer after point (point does not move). In this
8983 case, the return value is the length of the decoded text.
8985 This function sets `last-coding-system-used' to the precise coding system
8986 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8987 not fully specified.) */)
8988 (Lisp_Object string
, Lisp_Object coding_system
, Lisp_Object nocopy
, Lisp_Object buffer
)
8990 return code_convert_string (string
, coding_system
, buffer
,
8991 0, ! NILP (nocopy
), 0);
8994 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
8996 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
8998 Optional third arg NOCOPY non-nil means it is OK to return STRING
8999 itself if the encoding operation is trivial.
9001 Optional fourth arg BUFFER non-nil means that the encoded text is
9002 inserted in that buffer after point (point does not move). In this
9003 case, the return value is the length of the encoded text.
9005 This function sets `last-coding-system-used' to the precise coding system
9006 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
9007 not fully specified.) */)
9008 (Lisp_Object string
, Lisp_Object coding_system
, Lisp_Object nocopy
, Lisp_Object buffer
)
9010 return code_convert_string (string
, coding_system
, buffer
,
9011 1, ! NILP (nocopy
), 0);
9015 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
9016 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
9017 Return the corresponding character. */)
9020 Lisp_Object spec
, attrs
, val
;
9021 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
9025 CHECK_NATNUM (code
);
9026 ch
= XFASTINT (code
);
9027 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
9028 attrs
= AREF (spec
, 0);
9030 if (ASCII_BYTE_P (ch
)
9031 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9034 val
= CODING_ATTR_CHARSET_LIST (attrs
);
9035 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9036 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9037 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
9042 charset
= charset_roman
;
9044 else if (ch
>= 0xA0 && ch
< 0xDF)
9047 charset
= charset_kana
;
9051 EMACS_INT c1
= ch
>> 8;
9054 if (c1
< 0x81 || (c1
> 0x9F && c1
< 0xE0) || c1
> 0xEF
9055 || c2
< 0x40 || c2
== 0x7F || c2
> 0xFC)
9056 error ("Invalid code: %"pI
"d", ch
);
9059 charset
= charset_kanji
;
9061 c
= DECODE_CHAR (charset
, c
);
9063 error ("Invalid code: %"pI
"d", ch
);
9064 return make_number (c
);
9068 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
9069 doc
: /* Encode a Japanese character CH to shift_jis encoding.
9070 Return the corresponding code in SJIS. */)
9073 Lisp_Object spec
, attrs
, charset_list
;
9075 struct charset
*charset
;
9078 CHECK_CHARACTER (ch
);
9080 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
9081 attrs
= AREF (spec
, 0);
9083 if (ASCII_CHAR_P (c
)
9084 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9087 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
9088 charset
= char_charset (c
, charset_list
, &code
);
9089 if (code
== CHARSET_INVALID_CODE (charset
))
9090 error ("Can't encode by shift_jis encoding: %c", c
);
9093 return make_number (code
);
9096 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
9097 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
9098 Return the corresponding character. */)
9101 Lisp_Object spec
, attrs
, val
;
9102 struct charset
*charset_roman
, *charset_big5
, *charset
;
9106 CHECK_NATNUM (code
);
9107 ch
= XFASTINT (code
);
9108 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
9109 attrs
= AREF (spec
, 0);
9111 if (ASCII_BYTE_P (ch
)
9112 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9115 val
= CODING_ATTR_CHARSET_LIST (attrs
);
9116 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9117 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
9122 charset
= charset_roman
;
9126 EMACS_INT b1
= ch
>> 8;
9128 if (b1
< 0xA1 || b1
> 0xFE
9129 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
9130 error ("Invalid code: %"pI
"d", ch
);
9132 charset
= charset_big5
;
9134 c
= DECODE_CHAR (charset
, c
);
9136 error ("Invalid code: %"pI
"d", ch
);
9137 return make_number (c
);
9140 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
9141 doc
: /* Encode the Big5 character CH to BIG5 coding system.
9142 Return the corresponding character code in Big5. */)
9145 Lisp_Object spec
, attrs
, charset_list
;
9146 struct charset
*charset
;
9150 CHECK_CHARACTER (ch
);
9152 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
9153 attrs
= AREF (spec
, 0);
9154 if (ASCII_CHAR_P (c
)
9155 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9158 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
9159 charset
= char_charset (c
, charset_list
, &code
);
9160 if (code
== CHARSET_INVALID_CODE (charset
))
9161 error ("Can't encode by Big5 encoding: %c", c
);
9163 return make_number (code
);
9167 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal
,
9168 Sset_terminal_coding_system_internal
, 1, 2, 0,
9169 doc
: /* Internal use only. */)
9170 (Lisp_Object coding_system
, Lisp_Object terminal
)
9172 struct terminal
*term
= get_terminal (terminal
, 1);
9173 struct coding_system
*terminal_coding
= TERMINAL_TERMINAL_CODING (term
);
9174 CHECK_SYMBOL (coding_system
);
9175 setup_coding_system (Fcheck_coding_system (coding_system
), terminal_coding
);
9176 /* We had better not send unsafe characters to terminal. */
9177 terminal_coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
9178 /* Character composition should be disabled. */
9179 terminal_coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9180 terminal_coding
->src_multibyte
= 1;
9181 terminal_coding
->dst_multibyte
= 0;
9183 (term
, (terminal_coding
->common_flags
& CODING_REQUIRE_ENCODING_MASK
9184 ? coding_charset_list (terminal_coding
)
9185 : Fcons (make_number (charset_ascii
), Qnil
)));
9189 DEFUN ("set-safe-terminal-coding-system-internal",
9190 Fset_safe_terminal_coding_system_internal
,
9191 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
9192 doc
: /* Internal use only. */)
9193 (Lisp_Object coding_system
)
9195 CHECK_SYMBOL (coding_system
);
9196 setup_coding_system (Fcheck_coding_system (coding_system
),
9197 &safe_terminal_coding
);
9198 /* Character composition should be disabled. */
9199 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9200 safe_terminal_coding
.src_multibyte
= 1;
9201 safe_terminal_coding
.dst_multibyte
= 0;
9205 DEFUN ("terminal-coding-system", Fterminal_coding_system
,
9206 Sterminal_coding_system
, 0, 1, 0,
9207 doc
: /* Return coding system specified for terminal output on the given terminal.
9208 TERMINAL may be a terminal object, a frame, or nil for the selected
9209 frame's terminal device. */)
9210 (Lisp_Object terminal
)
9212 struct coding_system
*terminal_coding
9213 = TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
9214 Lisp_Object coding_system
= CODING_ID_NAME (terminal_coding
->id
);
9216 /* For backward compatibility, return nil if it is `undecided'. */
9217 return (! EQ (coding_system
, Qundecided
) ? coding_system
: Qnil
);
9220 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal
,
9221 Sset_keyboard_coding_system_internal
, 1, 2, 0,
9222 doc
: /* Internal use only. */)
9223 (Lisp_Object coding_system
, Lisp_Object terminal
)
9225 struct terminal
*t
= get_terminal (terminal
, 1);
9226 CHECK_SYMBOL (coding_system
);
9227 if (NILP (coding_system
))
9228 coding_system
= Qno_conversion
;
9230 Fcheck_coding_system (coding_system
);
9231 setup_coding_system (coding_system
, TERMINAL_KEYBOARD_CODING (t
));
9232 /* Character composition should be disabled. */
9233 TERMINAL_KEYBOARD_CODING (t
)->common_flags
9234 &= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9238 DEFUN ("keyboard-coding-system",
9239 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 1, 0,
9240 doc
: /* Return coding system specified for decoding keyboard input. */)
9241 (Lisp_Object terminal
)
9243 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
9244 (get_terminal (terminal
, 1))->id
);
9248 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
9249 Sfind_operation_coding_system
, 1, MANY
, 0,
9250 doc
: /* Choose a coding system for an operation based on the target name.
9251 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
9252 DECODING-SYSTEM is the coding system to use for decoding
9253 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
9254 for encoding (in case OPERATION does encoding).
9256 The first argument OPERATION specifies an I/O primitive:
9257 For file I/O, `insert-file-contents' or `write-region'.
9258 For process I/O, `call-process', `call-process-region', or `start-process'.
9259 For network I/O, `open-network-stream'.
9261 The remaining arguments should be the same arguments that were passed
9262 to the primitive. Depending on which primitive, one of those arguments
9263 is selected as the TARGET. For example, if OPERATION does file I/O,
9264 whichever argument specifies the file name is TARGET.
9266 TARGET has a meaning which depends on OPERATION:
9267 For file I/O, TARGET is a file name (except for the special case below).
9268 For process I/O, TARGET is a process name.
9269 For network I/O, TARGET is a service name or a port number.
9271 This function looks up what is specified for TARGET in
9272 `file-coding-system-alist', `process-coding-system-alist',
9273 or `network-coding-system-alist' depending on OPERATION.
9274 They may specify a coding system, a cons of coding systems,
9275 or a function symbol to call.
9276 In the last case, we call the function with one argument,
9277 which is a list of all the arguments given to this function.
9278 If the function can't decide a coding system, it can return
9279 `undecided' so that the normal code-detection is performed.
9281 If OPERATION is `insert-file-contents', the argument corresponding to
9282 TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
9283 file name to look up, and BUFFER is a buffer that contains the file's
9284 contents (not yet decoded). If `file-coding-system-alist' specifies a
9285 function to call for FILENAME, that function should examine the
9286 contents of BUFFER instead of reading the file.
9288 usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
9289 (ptrdiff_t nargs
, Lisp_Object
*args
)
9291 Lisp_Object operation
, target_idx
, target
, val
;
9292 register Lisp_Object chain
;
9295 error ("Too few arguments");
9296 operation
= args
[0];
9297 if (!SYMBOLP (operation
)
9298 || (target_idx
= Fget (operation
, Qtarget_idx
), !NATNUMP (target_idx
)))
9299 error ("Invalid first argument");
9300 if (nargs
<= 1 + XFASTINT (target_idx
))
9301 error ("Too few arguments for operation `%s'",
9302 SDATA (SYMBOL_NAME (operation
)));
9303 target
= args
[XFASTINT (target_idx
) + 1];
9304 if (!(STRINGP (target
)
9305 || (EQ (operation
, Qinsert_file_contents
) && CONSP (target
)
9306 && STRINGP (XCAR (target
)) && BUFFERP (XCDR (target
)))
9307 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
9308 error ("Invalid argument %"pI
"d of operation `%s'",
9309 XFASTINT (target_idx
) + 1, SDATA (SYMBOL_NAME (operation
)));
9311 target
= XCAR (target
);
9313 chain
= ((EQ (operation
, Qinsert_file_contents
)
9314 || EQ (operation
, Qwrite_region
))
9315 ? Vfile_coding_system_alist
9316 : (EQ (operation
, Qopen_network_stream
)
9317 ? Vnetwork_coding_system_alist
9318 : Vprocess_coding_system_alist
));
9322 for (; CONSP (chain
); chain
= XCDR (chain
))
9328 && ((STRINGP (target
)
9329 && STRINGP (XCAR (elt
))
9330 && fast_string_match (XCAR (elt
), target
) >= 0)
9331 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
9334 /* Here, if VAL is both a valid coding system and a valid
9335 function symbol, we return VAL as a coding system. */
9338 if (! SYMBOLP (val
))
9340 if (! NILP (Fcoding_system_p (val
)))
9341 return Fcons (val
, val
);
9342 if (! NILP (Ffboundp (val
)))
9344 /* We use call1 rather than safe_call1
9345 so as to get bug reports about functions called here
9346 which don't handle the current interface. */
9347 val
= call1 (val
, Flist (nargs
, args
));
9350 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
9351 return Fcons (val
, val
);
9359 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
9360 Sset_coding_system_priority
, 0, MANY
, 0,
9361 doc
: /* Assign higher priority to the coding systems given as arguments.
9362 If multiple coding systems belong to the same category,
9363 all but the first one are ignored.
9365 usage: (set-coding-system-priority &rest coding-systems) */)
9366 (ptrdiff_t nargs
, Lisp_Object
*args
)
9369 bool changed
[coding_category_max
];
9370 enum coding_category priorities
[coding_category_max
];
9372 memset (changed
, 0, sizeof changed
);
9374 for (i
= j
= 0; i
< nargs
; i
++)
9376 enum coding_category category
;
9377 Lisp_Object spec
, attrs
;
9379 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
9380 attrs
= AREF (spec
, 0);
9381 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
9382 if (changed
[category
])
9383 /* Ignore this coding system because a coding system of the
9384 same category already had a higher priority. */
9386 changed
[category
] = 1;
9387 priorities
[j
++] = category
;
9388 if (coding_categories
[category
].id
>= 0
9389 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
9390 setup_coding_system (args
[i
], &coding_categories
[category
]);
9391 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
9394 /* Now we have decided top J priorities. Reflect the order of the
9395 original priorities to the remaining priorities. */
9397 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
9399 while (j
< coding_category_max
9400 && changed
[coding_priorities
[j
]])
9402 if (j
== coding_category_max
)
9404 priorities
[i
] = coding_priorities
[j
];
9407 memcpy (coding_priorities
, priorities
, sizeof priorities
);
9409 /* Update `coding-category-list'. */
9410 Vcoding_category_list
= Qnil
;
9411 for (i
= coding_category_max
; i
-- > 0; )
9412 Vcoding_category_list
9413 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
9414 Vcoding_category_list
);
9419 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
9420 Scoding_system_priority_list
, 0, 1, 0,
9421 doc
: /* Return a list of coding systems ordered by their priorities.
9422 The list contains a subset of coding systems; i.e. coding systems
9423 assigned to each coding category (see `coding-category-list').
9425 HIGHESTP non-nil means just return the highest priority one. */)
9426 (Lisp_Object highestp
)
9431 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
9433 enum coding_category category
= coding_priorities
[i
];
9434 int id
= coding_categories
[category
].id
;
9439 attrs
= CODING_ID_ATTRS (id
);
9440 if (! NILP (highestp
))
9441 return CODING_ATTR_BASE_NAME (attrs
);
9442 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
9444 return Fnreverse (val
);
9447 static const char *const suffixes
[] = { "-unix", "-dos", "-mac" };
9450 make_subsidiaries (Lisp_Object base
)
9452 Lisp_Object subsidiaries
;
9453 ptrdiff_t base_name_len
= SBYTES (SYMBOL_NAME (base
));
9454 char *buf
= alloca (base_name_len
+ 6);
9457 memcpy (buf
, SDATA (SYMBOL_NAME (base
)), base_name_len
);
9458 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
9459 for (i
= 0; i
< 3; i
++)
9461 strcpy (buf
+ base_name_len
, suffixes
[i
]);
9462 ASET (subsidiaries
, i
, intern (buf
));
9464 return subsidiaries
;
9468 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
9469 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
9470 doc
: /* For internal use only.
9471 usage: (define-coding-system-internal ...) */)
9472 (ptrdiff_t nargs
, Lisp_Object
*args
)
9475 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
9476 Lisp_Object attrs
; /* Vector of attributes. */
9477 Lisp_Object eol_type
;
9478 Lisp_Object aliases
;
9479 Lisp_Object coding_type
, charset_list
, safe_charsets
;
9480 enum coding_category category
;
9481 Lisp_Object tail
, val
;
9482 int max_charset_id
= 0;
9485 if (nargs
< coding_arg_max
)
9488 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
9490 name
= args
[coding_arg_name
];
9491 CHECK_SYMBOL (name
);
9492 ASET (attrs
, coding_attr_base_name
, name
);
9494 val
= args
[coding_arg_mnemonic
];
9495 if (! STRINGP (val
))
9496 CHECK_CHARACTER (val
);
9497 ASET (attrs
, coding_attr_mnemonic
, val
);
9499 coding_type
= args
[coding_arg_coding_type
];
9500 CHECK_SYMBOL (coding_type
);
9501 ASET (attrs
, coding_attr_type
, coding_type
);
9503 charset_list
= args
[coding_arg_charset_list
];
9504 if (SYMBOLP (charset_list
))
9506 if (EQ (charset_list
, Qiso_2022
))
9508 if (! EQ (coding_type
, Qiso_2022
))
9509 error ("Invalid charset-list");
9510 charset_list
= Viso_2022_charset_list
;
9512 else if (EQ (charset_list
, Qemacs_mule
))
9514 if (! EQ (coding_type
, Qemacs_mule
))
9515 error ("Invalid charset-list");
9516 charset_list
= Vemacs_mule_charset_list
;
9518 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9520 if (! RANGED_INTEGERP (0, XCAR (tail
), INT_MAX
- 1))
9521 error ("Invalid charset-list");
9522 if (max_charset_id
< XFASTINT (XCAR (tail
)))
9523 max_charset_id
= XFASTINT (XCAR (tail
));
9528 charset_list
= Fcopy_sequence (charset_list
);
9529 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9531 struct charset
*charset
;
9534 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9535 if (EQ (coding_type
, Qiso_2022
)
9536 ? CHARSET_ISO_FINAL (charset
) < 0
9537 : EQ (coding_type
, Qemacs_mule
)
9538 ? CHARSET_EMACS_MULE_ID (charset
) < 0
9540 error ("Can't handle charset `%s'",
9541 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9543 XSETCAR (tail
, make_number (charset
->id
));
9544 if (max_charset_id
< charset
->id
)
9545 max_charset_id
= charset
->id
;
9548 ASET (attrs
, coding_attr_charset_list
, charset_list
);
9550 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
9551 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
9552 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9553 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
9554 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
9556 ASET (attrs
, coding_attr_ascii_compat
, args
[coding_arg_ascii_compatible_p
]);
9558 val
= args
[coding_arg_decode_translation_table
];
9559 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9561 ASET (attrs
, coding_attr_decode_tbl
, val
);
9563 val
= args
[coding_arg_encode_translation_table
];
9564 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9566 ASET (attrs
, coding_attr_encode_tbl
, val
);
9568 val
= args
[coding_arg_post_read_conversion
];
9570 ASET (attrs
, coding_attr_post_read
, val
);
9572 val
= args
[coding_arg_pre_write_conversion
];
9574 ASET (attrs
, coding_attr_pre_write
, val
);
9576 val
= args
[coding_arg_default_char
];
9578 ASET (attrs
, coding_attr_default_char
, make_number (' '));
9581 CHECK_CHARACTER (val
);
9582 ASET (attrs
, coding_attr_default_char
, val
);
9585 val
= args
[coding_arg_for_unibyte
];
9586 ASET (attrs
, coding_attr_for_unibyte
, NILP (val
) ? Qnil
: Qt
);
9588 val
= args
[coding_arg_plist
];
9590 ASET (attrs
, coding_attr_plist
, val
);
9592 if (EQ (coding_type
, Qcharset
))
9594 /* Generate a lisp vector of 256 elements. Each element is nil,
9595 integer, or a list of charset IDs.
9597 If Nth element is nil, the byte code N is invalid in this
9600 If Nth element is a number NUM, N is the first byte of a
9601 charset whose ID is NUM.
9603 If Nth element is a list of charset IDs, N is the first byte
9604 of one of them. The list is sorted by dimensions of the
9605 charsets. A charset of smaller dimension comes first. */
9606 val
= Fmake_vector (make_number (256), Qnil
);
9608 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9610 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
9611 int dim
= CHARSET_DIMENSION (charset
);
9612 int idx
= (dim
- 1) * 4;
9614 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9615 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9617 for (i
= charset
->code_space
[idx
];
9618 i
<= charset
->code_space
[idx
+ 1]; i
++)
9620 Lisp_Object tmp
, tmp2
;
9623 tmp
= AREF (val
, i
);
9626 else if (NUMBERP (tmp
))
9628 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
9630 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
9632 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
9636 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
9638 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
9643 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
9646 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
9647 XSETCAR (tmp2
, XCAR (tail
));
9653 ASET (attrs
, coding_attr_charset_valids
, val
);
9654 category
= coding_category_charset
;
9656 else if (EQ (coding_type
, Qccl
))
9660 if (nargs
< coding_arg_ccl_max
)
9663 val
= args
[coding_arg_ccl_decoder
];
9664 CHECK_CCL_PROGRAM (val
);
9666 val
= Fcopy_sequence (val
);
9667 ASET (attrs
, coding_attr_ccl_decoder
, val
);
9669 val
= args
[coding_arg_ccl_encoder
];
9670 CHECK_CCL_PROGRAM (val
);
9672 val
= Fcopy_sequence (val
);
9673 ASET (attrs
, coding_attr_ccl_encoder
, val
);
9675 val
= args
[coding_arg_ccl_valids
];
9676 valids
= Fmake_string (make_number (256), make_number (0));
9677 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
9684 if (! (0 <= XINT (val
) && XINT (val
) <= 255))
9685 args_out_of_range_3 (val
, make_number (0), make_number (255));
9686 from
= to
= XINT (val
);
9691 CHECK_NATNUM_CAR (val
);
9692 CHECK_NUMBER_CDR (val
);
9693 if (XINT (XCAR (val
)) > 255)
9694 args_out_of_range_3 (XCAR (val
),
9695 make_number (0), make_number (255));
9696 from
= XINT (XCAR (val
));
9697 if (! (from
<= XINT (XCDR (val
)) && XINT (XCDR (val
)) <= 255))
9698 args_out_of_range_3 (XCDR (val
),
9699 XCAR (val
), make_number (255));
9700 to
= XINT (XCDR (val
));
9702 for (i
= from
; i
<= to
; i
++)
9703 SSET (valids
, i
, 1);
9705 ASET (attrs
, coding_attr_ccl_valids
, valids
);
9707 category
= coding_category_ccl
;
9709 else if (EQ (coding_type
, Qutf_16
))
9711 Lisp_Object bom
, endian
;
9713 ASET (attrs
, coding_attr_ascii_compat
, Qnil
);
9715 if (nargs
< coding_arg_utf16_max
)
9718 bom
= args
[coding_arg_utf16_bom
];
9719 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9723 CHECK_CODING_SYSTEM (val
);
9725 CHECK_CODING_SYSTEM (val
);
9727 ASET (attrs
, coding_attr_utf_bom
, bom
);
9729 endian
= args
[coding_arg_utf16_endian
];
9730 CHECK_SYMBOL (endian
);
9733 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
9734 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
9735 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
9737 category
= (CONSP (bom
)
9738 ? coding_category_utf_16_auto
9740 ? (EQ (endian
, Qbig
)
9741 ? coding_category_utf_16_be_nosig
9742 : coding_category_utf_16_le_nosig
)
9743 : (EQ (endian
, Qbig
)
9744 ? coding_category_utf_16_be
9745 : coding_category_utf_16_le
));
9747 else if (EQ (coding_type
, Qiso_2022
))
9749 Lisp_Object initial
, reg_usage
, request
, flags
;
9751 if (nargs
< coding_arg_iso2022_max
)
9754 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
9755 CHECK_VECTOR (initial
);
9756 for (i
= 0; i
< 4; i
++)
9758 val
= Faref (initial
, make_number (i
));
9761 struct charset
*charset
;
9763 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9764 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
9765 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
9766 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9769 ASET (initial
, i
, make_number (-1));
9772 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
9773 CHECK_CONS (reg_usage
);
9774 CHECK_NUMBER_CAR (reg_usage
);
9775 CHECK_NUMBER_CDR (reg_usage
);
9777 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
9778 for (tail
= request
; CONSP (tail
); tail
= XCDR (tail
))
9786 CHECK_CHARSET_GET_ID (tmp1
, id
);
9787 CHECK_NATNUM_CDR (val
);
9788 if (XINT (XCDR (val
)) >= 4)
9789 error ("Invalid graphic register number: %"pI
"d", XINT (XCDR (val
)));
9790 XSETCAR (val
, make_number (id
));
9793 flags
= args
[coding_arg_iso2022_flags
];
9794 CHECK_NATNUM (flags
);
9795 i
= XINT (flags
) & INT_MAX
;
9796 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
9797 i
|= CODING_ISO_FLAG_FULL_SUPPORT
;
9798 flags
= make_number (i
);
9800 ASET (attrs
, coding_attr_iso_initial
, initial
);
9801 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
9802 ASET (attrs
, coding_attr_iso_request
, request
);
9803 ASET (attrs
, coding_attr_iso_flags
, flags
);
9804 setup_iso_safe_charsets (attrs
);
9806 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
9807 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
9808 | CODING_ISO_FLAG_SINGLE_SHIFT
))
9809 ? coding_category_iso_7_else
9810 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9811 ? coding_category_iso_7
9812 : coding_category_iso_7_tight
);
9815 int id
= XINT (AREF (initial
, 1));
9817 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
9818 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9820 ? coding_category_iso_8_else
9821 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
9822 ? coding_category_iso_8_1
9823 : coding_category_iso_8_2
);
9825 if (category
!= coding_category_iso_8_1
9826 && category
!= coding_category_iso_8_2
)
9827 ASET (attrs
, coding_attr_ascii_compat
, Qnil
);
9829 else if (EQ (coding_type
, Qemacs_mule
))
9831 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
9832 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
9833 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9834 category
= coding_category_emacs_mule
;
9836 else if (EQ (coding_type
, Qshift_jis
))
9839 struct charset
*charset
;
9841 if (XINT (Flength (charset_list
)) != 3
9842 && XINT (Flength (charset_list
)) != 4)
9843 error ("There should be three or four charsets");
9845 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9846 if (CHARSET_DIMENSION (charset
) != 1)
9847 error ("Dimension of charset %s is not one",
9848 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9849 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9850 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9852 charset_list
= XCDR (charset_list
);
9853 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9854 if (CHARSET_DIMENSION (charset
) != 1)
9855 error ("Dimension of charset %s is not one",
9856 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9858 charset_list
= XCDR (charset_list
);
9859 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9860 if (CHARSET_DIMENSION (charset
) != 2)
9861 error ("Dimension of charset %s is not two",
9862 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9864 charset_list
= XCDR (charset_list
);
9865 if (! NILP (charset_list
))
9867 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9868 if (CHARSET_DIMENSION (charset
) != 2)
9869 error ("Dimension of charset %s is not two",
9870 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9873 category
= coding_category_sjis
;
9874 Vsjis_coding_system
= name
;
9876 else if (EQ (coding_type
, Qbig5
))
9878 struct charset
*charset
;
9880 if (XINT (Flength (charset_list
)) != 2)
9881 error ("There should be just two charsets");
9883 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9884 if (CHARSET_DIMENSION (charset
) != 1)
9885 error ("Dimension of charset %s is not one",
9886 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9887 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9888 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9890 charset_list
= XCDR (charset_list
);
9891 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9892 if (CHARSET_DIMENSION (charset
) != 2)
9893 error ("Dimension of charset %s is not two",
9894 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9896 category
= coding_category_big5
;
9897 Vbig5_coding_system
= name
;
9899 else if (EQ (coding_type
, Qraw_text
))
9901 category
= coding_category_raw_text
;
9902 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9904 else if (EQ (coding_type
, Qutf_8
))
9908 if (nargs
< coding_arg_utf8_max
)
9911 bom
= args
[coding_arg_utf8_bom
];
9912 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9916 CHECK_CODING_SYSTEM (val
);
9918 CHECK_CODING_SYSTEM (val
);
9920 ASET (attrs
, coding_attr_utf_bom
, bom
);
9922 ASET (attrs
, coding_attr_ascii_compat
, Qt
);
9924 category
= (CONSP (bom
) ? coding_category_utf_8_auto
9925 : NILP (bom
) ? coding_category_utf_8_nosig
9926 : coding_category_utf_8_sig
);
9928 else if (EQ (coding_type
, Qundecided
))
9929 category
= coding_category_undecided
;
9931 error ("Invalid coding system type: %s",
9932 SDATA (SYMBOL_NAME (coding_type
)));
9934 ASET (attrs
, coding_attr_category
, make_number (category
));
9935 ASET (attrs
, coding_attr_plist
,
9937 Fcons (AREF (Vcoding_category_table
, category
),
9938 CODING_ATTR_PLIST (attrs
))));
9939 ASET (attrs
, coding_attr_plist
,
9940 Fcons (QCascii_compatible_p
,
9941 Fcons (CODING_ATTR_ASCII_COMPAT (attrs
),
9942 CODING_ATTR_PLIST (attrs
))));
9944 eol_type
= args
[coding_arg_eol_type
];
9945 if (! NILP (eol_type
)
9946 && ! EQ (eol_type
, Qunix
)
9947 && ! EQ (eol_type
, Qdos
)
9948 && ! EQ (eol_type
, Qmac
))
9949 error ("Invalid eol-type");
9951 aliases
= Fcons (name
, Qnil
);
9953 if (NILP (eol_type
))
9955 eol_type
= make_subsidiaries (name
);
9956 for (i
= 0; i
< 3; i
++)
9958 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
9960 this_name
= AREF (eol_type
, i
);
9961 this_aliases
= Fcons (this_name
, Qnil
);
9962 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
9963 this_spec
= Fmake_vector (make_number (3), attrs
);
9964 ASET (this_spec
, 1, this_aliases
);
9965 ASET (this_spec
, 2, this_eol_type
);
9966 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
9967 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
9968 val
= Fassoc (Fsymbol_name (this_name
), Vcoding_system_alist
);
9970 Vcoding_system_alist
9971 = Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
9972 Vcoding_system_alist
);
9976 spec_vec
= Fmake_vector (make_number (3), attrs
);
9977 ASET (spec_vec
, 1, aliases
);
9978 ASET (spec_vec
, 2, eol_type
);
9980 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
9981 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
9982 val
= Fassoc (Fsymbol_name (name
), Vcoding_system_alist
);
9984 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
9985 Vcoding_system_alist
);
9988 int id
= coding_categories
[category
].id
;
9990 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
9991 setup_coding_system (name
, &coding_categories
[category
]);
9997 return Fsignal (Qwrong_number_of_arguments
,
9998 Fcons (intern ("define-coding-system-internal"),
9999 make_number (nargs
)));
10003 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
10005 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
10006 (Lisp_Object coding_system
, Lisp_Object prop
, Lisp_Object val
)
10008 Lisp_Object spec
, attrs
;
10010 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10011 attrs
= AREF (spec
, 0);
10012 if (EQ (prop
, QCmnemonic
))
10014 if (! STRINGP (val
))
10015 CHECK_CHARACTER (val
);
10016 ASET (attrs
, coding_attr_mnemonic
, val
);
10018 else if (EQ (prop
, QCdefault_char
))
10021 val
= make_number (' ');
10023 CHECK_CHARACTER (val
);
10024 ASET (attrs
, coding_attr_default_char
, val
);
10026 else if (EQ (prop
, QCdecode_translation_table
))
10028 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
10029 CHECK_SYMBOL (val
);
10030 ASET (attrs
, coding_attr_decode_tbl
, val
);
10032 else if (EQ (prop
, QCencode_translation_table
))
10034 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
10035 CHECK_SYMBOL (val
);
10036 ASET (attrs
, coding_attr_encode_tbl
, val
);
10038 else if (EQ (prop
, QCpost_read_conversion
))
10040 CHECK_SYMBOL (val
);
10041 ASET (attrs
, coding_attr_post_read
, val
);
10043 else if (EQ (prop
, QCpre_write_conversion
))
10045 CHECK_SYMBOL (val
);
10046 ASET (attrs
, coding_attr_pre_write
, val
);
10048 else if (EQ (prop
, QCascii_compatible_p
))
10050 ASET (attrs
, coding_attr_ascii_compat
, val
);
10053 ASET (attrs
, coding_attr_plist
,
10054 Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
));
10059 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
10060 Sdefine_coding_system_alias
, 2, 2, 0,
10061 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
10062 (Lisp_Object alias
, Lisp_Object coding_system
)
10064 Lisp_Object spec
, aliases
, eol_type
, val
;
10066 CHECK_SYMBOL (alias
);
10067 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10068 aliases
= AREF (spec
, 1);
10069 /* ALIASES should be a list of length more than zero, and the first
10070 element is a base coding system. Append ALIAS at the tail of the
10072 while (!NILP (XCDR (aliases
)))
10073 aliases
= XCDR (aliases
);
10074 XSETCDR (aliases
, Fcons (alias
, Qnil
));
10076 eol_type
= AREF (spec
, 2);
10077 if (VECTORP (eol_type
))
10079 Lisp_Object subsidiaries
;
10082 subsidiaries
= make_subsidiaries (alias
);
10083 for (i
= 0; i
< 3; i
++)
10084 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
10085 AREF (eol_type
, i
));
10088 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
10089 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
10090 val
= Fassoc (Fsymbol_name (alias
), Vcoding_system_alist
);
10092 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
10093 Vcoding_system_alist
);
10098 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
10100 doc
: /* Return the base of CODING-SYSTEM.
10101 Any alias or subsidiary coding system is not a base coding system. */)
10102 (Lisp_Object coding_system
)
10104 Lisp_Object spec
, attrs
;
10106 if (NILP (coding_system
))
10107 return (Qno_conversion
);
10108 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10109 attrs
= AREF (spec
, 0);
10110 return CODING_ATTR_BASE_NAME (attrs
);
10113 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
10115 doc
: "Return the property list of CODING-SYSTEM.")
10116 (Lisp_Object coding_system
)
10118 Lisp_Object spec
, attrs
;
10120 if (NILP (coding_system
))
10121 coding_system
= Qno_conversion
;
10122 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10123 attrs
= AREF (spec
, 0);
10124 return CODING_ATTR_PLIST (attrs
);
10128 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
10130 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
10131 (Lisp_Object coding_system
)
10135 if (NILP (coding_system
))
10136 coding_system
= Qno_conversion
;
10137 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10138 return AREF (spec
, 1);
10141 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
10142 Scoding_system_eol_type
, 1, 1, 0,
10143 doc
: /* Return eol-type of CODING-SYSTEM.
10144 An eol-type is an integer 0, 1, 2, or a vector of coding systems.
10146 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
10147 and CR respectively.
10149 A vector value indicates that a format of end-of-line should be
10150 detected automatically. Nth element of the vector is the subsidiary
10151 coding system whose eol-type is N. */)
10152 (Lisp_Object coding_system
)
10154 Lisp_Object spec
, eol_type
;
10157 if (NILP (coding_system
))
10158 coding_system
= Qno_conversion
;
10159 if (! CODING_SYSTEM_P (coding_system
))
10161 spec
= CODING_SYSTEM_SPEC (coding_system
);
10162 eol_type
= AREF (spec
, 2);
10163 if (VECTORP (eol_type
))
10164 return Fcopy_sequence (eol_type
);
10165 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
10166 return make_number (n
);
10172 /*** 9. Post-amble ***/
10175 init_coding_once (void)
10179 for (i
= 0; i
< coding_category_max
; i
++)
10181 coding_categories
[i
].id
= -1;
10182 coding_priorities
[i
] = i
;
10185 /* ISO2022 specific initialize routine. */
10186 for (i
= 0; i
< 0x20; i
++)
10187 iso_code_class
[i
] = ISO_control_0
;
10188 for (i
= 0x21; i
< 0x7F; i
++)
10189 iso_code_class
[i
] = ISO_graphic_plane_0
;
10190 for (i
= 0x80; i
< 0xA0; i
++)
10191 iso_code_class
[i
] = ISO_control_1
;
10192 for (i
= 0xA1; i
< 0xFF; i
++)
10193 iso_code_class
[i
] = ISO_graphic_plane_1
;
10194 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
10195 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
10196 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
10197 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
10198 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
10199 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
10200 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
10201 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
10202 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
10204 for (i
= 0; i
< 256; i
++)
10206 emacs_mule_bytes
[i
] = 1;
10208 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
10209 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
10210 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
10211 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
10217 syms_of_coding (void)
10219 staticpro (&Vcoding_system_hash_table
);
10221 Lisp_Object args
[2];
10224 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
10227 staticpro (&Vsjis_coding_system
);
10228 Vsjis_coding_system
= Qnil
;
10230 staticpro (&Vbig5_coding_system
);
10231 Vbig5_coding_system
= Qnil
;
10233 staticpro (&Vcode_conversion_reused_workbuf
);
10234 Vcode_conversion_reused_workbuf
= Qnil
;
10236 staticpro (&Vcode_conversion_workbuf_name
);
10237 Vcode_conversion_workbuf_name
= build_pure_c_string (" *code-conversion-work*");
10239 reused_workbuf_in_use
= 0;
10241 DEFSYM (Qcharset
, "charset");
10242 DEFSYM (Qtarget_idx
, "target-idx");
10243 DEFSYM (Qcoding_system_history
, "coding-system-history");
10244 Fset (Qcoding_system_history
, Qnil
);
10246 /* Target FILENAME is the first argument. */
10247 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
10248 /* Target FILENAME is the third argument. */
10249 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
10251 DEFSYM (Qcall_process
, "call-process");
10252 /* Target PROGRAM is the first argument. */
10253 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
10255 DEFSYM (Qcall_process_region
, "call-process-region");
10256 /* Target PROGRAM is the third argument. */
10257 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
10259 DEFSYM (Qstart_process
, "start-process");
10260 /* Target PROGRAM is the third argument. */
10261 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
10263 DEFSYM (Qopen_network_stream
, "open-network-stream");
10264 /* Target SERVICE is the fourth argument. */
10265 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
10267 DEFSYM (Qcoding_system
, "coding-system");
10268 DEFSYM (Qcoding_aliases
, "coding-aliases");
10270 DEFSYM (Qeol_type
, "eol-type");
10271 DEFSYM (Qunix
, "unix");
10272 DEFSYM (Qdos
, "dos");
10274 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
10275 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
10276 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
10277 DEFSYM (Qdefault_char
, "default-char");
10278 DEFSYM (Qundecided
, "undecided");
10279 DEFSYM (Qno_conversion
, "no-conversion");
10280 DEFSYM (Qraw_text
, "raw-text");
10282 DEFSYM (Qiso_2022
, "iso-2022");
10284 DEFSYM (Qutf_8
, "utf-8");
10285 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
10287 DEFSYM (Qutf_16
, "utf-16");
10288 DEFSYM (Qbig
, "big");
10289 DEFSYM (Qlittle
, "little");
10291 DEFSYM (Qshift_jis
, "shift-jis");
10292 DEFSYM (Qbig5
, "big5");
10294 DEFSYM (Qcoding_system_p
, "coding-system-p");
10296 DEFSYM (Qcoding_system_error
, "coding-system-error");
10297 Fput (Qcoding_system_error
, Qerror_conditions
,
10298 listn (CONSTYPE_PURE
, 2, Qcoding_system_error
, Qerror
));
10299 Fput (Qcoding_system_error
, Qerror_message
,
10300 build_pure_c_string ("Invalid coding system"));
10302 /* Intern this now in case it isn't already done.
10303 Setting this variable twice is harmless.
10304 But don't staticpro it here--that is done in alloc.c. */
10305 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
10307 DEFSYM (Qtranslation_table
, "translation-table");
10308 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
10309 DEFSYM (Qtranslation_table_id
, "translation-table-id");
10310 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
10311 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
10313 DEFSYM (Qvalid_codes
, "valid-codes");
10315 DEFSYM (Qemacs_mule
, "emacs-mule");
10317 DEFSYM (QCcategory
, ":category");
10318 DEFSYM (QCmnemonic
, ":mnemonic");
10319 DEFSYM (QCdefault_char
, ":default-char");
10320 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
10321 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
10322 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
10323 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
10324 DEFSYM (QCascii_compatible_p
, ":ascii-compatible-p");
10326 Vcoding_category_table
10327 = Fmake_vector (make_number (coding_category_max
), Qnil
);
10328 staticpro (&Vcoding_category_table
);
10329 /* Followings are target of code detection. */
10330 ASET (Vcoding_category_table
, coding_category_iso_7
,
10331 intern_c_string ("coding-category-iso-7"));
10332 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
10333 intern_c_string ("coding-category-iso-7-tight"));
10334 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
10335 intern_c_string ("coding-category-iso-8-1"));
10336 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
10337 intern_c_string ("coding-category-iso-8-2"));
10338 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
10339 intern_c_string ("coding-category-iso-7-else"));
10340 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
10341 intern_c_string ("coding-category-iso-8-else"));
10342 ASET (Vcoding_category_table
, coding_category_utf_8_auto
,
10343 intern_c_string ("coding-category-utf-8-auto"));
10344 ASET (Vcoding_category_table
, coding_category_utf_8_nosig
,
10345 intern_c_string ("coding-category-utf-8"));
10346 ASET (Vcoding_category_table
, coding_category_utf_8_sig
,
10347 intern_c_string ("coding-category-utf-8-sig"));
10348 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
10349 intern_c_string ("coding-category-utf-16-be"));
10350 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
10351 intern_c_string ("coding-category-utf-16-auto"));
10352 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
10353 intern_c_string ("coding-category-utf-16-le"));
10354 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
10355 intern_c_string ("coding-category-utf-16-be-nosig"));
10356 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
10357 intern_c_string ("coding-category-utf-16-le-nosig"));
10358 ASET (Vcoding_category_table
, coding_category_charset
,
10359 intern_c_string ("coding-category-charset"));
10360 ASET (Vcoding_category_table
, coding_category_sjis
,
10361 intern_c_string ("coding-category-sjis"));
10362 ASET (Vcoding_category_table
, coding_category_big5
,
10363 intern_c_string ("coding-category-big5"));
10364 ASET (Vcoding_category_table
, coding_category_ccl
,
10365 intern_c_string ("coding-category-ccl"));
10366 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
10367 intern_c_string ("coding-category-emacs-mule"));
10368 /* Followings are NOT target of code detection. */
10369 ASET (Vcoding_category_table
, coding_category_raw_text
,
10370 intern_c_string ("coding-category-raw-text"));
10371 ASET (Vcoding_category_table
, coding_category_undecided
,
10372 intern_c_string ("coding-category-undecided"));
10374 DEFSYM (Qinsufficient_source
, "insufficient-source");
10375 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
10376 DEFSYM (Qinvalid_source
, "invalid-source");
10377 DEFSYM (Qinterrupted
, "interrupted");
10378 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
10379 DEFSYM (Qcoding_system_define_form
, "coding-system-define-form");
10381 defsubr (&Scoding_system_p
);
10382 defsubr (&Sread_coding_system
);
10383 defsubr (&Sread_non_nil_coding_system
);
10384 defsubr (&Scheck_coding_system
);
10385 defsubr (&Sdetect_coding_region
);
10386 defsubr (&Sdetect_coding_string
);
10387 defsubr (&Sfind_coding_systems_region_internal
);
10388 defsubr (&Sunencodable_char_position
);
10389 defsubr (&Scheck_coding_systems_region
);
10390 defsubr (&Sdecode_coding_region
);
10391 defsubr (&Sencode_coding_region
);
10392 defsubr (&Sdecode_coding_string
);
10393 defsubr (&Sencode_coding_string
);
10394 defsubr (&Sdecode_sjis_char
);
10395 defsubr (&Sencode_sjis_char
);
10396 defsubr (&Sdecode_big5_char
);
10397 defsubr (&Sencode_big5_char
);
10398 defsubr (&Sset_terminal_coding_system_internal
);
10399 defsubr (&Sset_safe_terminal_coding_system_internal
);
10400 defsubr (&Sterminal_coding_system
);
10401 defsubr (&Sset_keyboard_coding_system_internal
);
10402 defsubr (&Skeyboard_coding_system
);
10403 defsubr (&Sfind_operation_coding_system
);
10404 defsubr (&Sset_coding_system_priority
);
10405 defsubr (&Sdefine_coding_system_internal
);
10406 defsubr (&Sdefine_coding_system_alias
);
10407 defsubr (&Scoding_system_put
);
10408 defsubr (&Scoding_system_base
);
10409 defsubr (&Scoding_system_plist
);
10410 defsubr (&Scoding_system_aliases
);
10411 defsubr (&Scoding_system_eol_type
);
10412 defsubr (&Scoding_system_priority_list
);
10414 DEFVAR_LISP ("coding-system-list", Vcoding_system_list
,
10415 doc
: /* List of coding systems.
10417 Do not alter the value of this variable manually. This variable should be
10418 updated by the functions `define-coding-system' and
10419 `define-coding-system-alias'. */);
10420 Vcoding_system_list
= Qnil
;
10422 DEFVAR_LISP ("coding-system-alist", Vcoding_system_alist
,
10423 doc
: /* Alist of coding system names.
10424 Each element is one element list of coding system name.
10425 This variable is given to `completing-read' as COLLECTION argument.
10427 Do not alter the value of this variable manually. This variable should be
10428 updated by the functions `make-coding-system' and
10429 `define-coding-system-alias'. */);
10430 Vcoding_system_alist
= Qnil
;
10432 DEFVAR_LISP ("coding-category-list", Vcoding_category_list
,
10433 doc
: /* List of coding-categories (symbols) ordered by priority.
10435 On detecting a coding system, Emacs tries code detection algorithms
10436 associated with each coding-category one by one in this order. When
10437 one algorithm agrees with a byte sequence of source text, the coding
10438 system bound to the corresponding coding-category is selected.
10440 Don't modify this variable directly, but use `set-coding-system-priority'. */);
10444 Vcoding_category_list
= Qnil
;
10445 for (i
= coding_category_max
- 1; i
>= 0; i
--)
10446 Vcoding_category_list
10447 = Fcons (AREF (Vcoding_category_table
, i
),
10448 Vcoding_category_list
);
10451 DEFVAR_LISP ("coding-system-for-read", Vcoding_system_for_read
,
10452 doc
: /* Specify the coding system for read operations.
10453 It is useful to bind this variable with `let', but do not set it globally.
10454 If the value is a coding system, it is used for decoding on read operation.
10455 If not, an appropriate element is used from one of the coding system alists.
10456 There are three such tables: `file-coding-system-alist',
10457 `process-coding-system-alist', and `network-coding-system-alist'. */);
10458 Vcoding_system_for_read
= Qnil
;
10460 DEFVAR_LISP ("coding-system-for-write", Vcoding_system_for_write
,
10461 doc
: /* Specify the coding system for write operations.
10462 Programs bind this variable with `let', but you should not set it globally.
10463 If the value is a coding system, it is used for encoding of output,
10464 when writing it to a file and when sending it to a file or subprocess.
10466 If this does not specify a coding system, an appropriate element
10467 is used from one of the coding system alists.
10468 There are three such tables: `file-coding-system-alist',
10469 `process-coding-system-alist', and `network-coding-system-alist'.
10470 For output to files, if the above procedure does not specify a coding system,
10471 the value of `buffer-file-coding-system' is used. */);
10472 Vcoding_system_for_write
= Qnil
;
10474 DEFVAR_LISP ("last-coding-system-used", Vlast_coding_system_used
,
10476 Coding system used in the latest file or process I/O. */);
10477 Vlast_coding_system_used
= Qnil
;
10479 DEFVAR_LISP ("last-code-conversion-error", Vlast_code_conversion_error
,
10481 Error status of the last code conversion.
10483 When an error was detected in the last code conversion, this variable
10484 is set to one of the following symbols.
10485 `insufficient-source'
10489 `insufficient-memory'
10490 When no error was detected, the value doesn't change. So, to check
10491 the error status of a code conversion by this variable, you must
10492 explicitly set this variable to nil before performing code
10494 Vlast_code_conversion_error
= Qnil
;
10496 DEFVAR_BOOL ("inhibit-eol-conversion", inhibit_eol_conversion
,
10498 *Non-nil means always inhibit code conversion of end-of-line format.
10499 See info node `Coding Systems' and info node `Text and Binary' concerning
10500 such conversion. */);
10501 inhibit_eol_conversion
= 0;
10503 DEFVAR_BOOL ("inherit-process-coding-system", inherit_process_coding_system
,
10505 Non-nil means process buffer inherits coding system of process output.
10506 Bind it to t if the process output is to be treated as if it were a file
10507 read from some filesystem. */);
10508 inherit_process_coding_system
= 0;
10510 DEFVAR_LISP ("file-coding-system-alist", Vfile_coding_system_alist
,
10512 Alist to decide a coding system to use for a file I/O operation.
10513 The format is ((PATTERN . VAL) ...),
10514 where PATTERN is a regular expression matching a file name,
10515 VAL is a coding system, a cons of coding systems, or a function symbol.
10516 If VAL is a coding system, it is used for both decoding and encoding
10518 If VAL is a cons of coding systems, the car part is used for decoding,
10519 and the cdr part is used for encoding.
10520 If VAL is a function symbol, the function must return a coding system
10521 or a cons of coding systems which are used as above. The function is
10522 called with an argument that is a list of the arguments with which
10523 `find-operation-coding-system' was called. If the function can't decide
10524 a coding system, it can return `undecided' so that the normal
10525 code-detection is performed.
10527 See also the function `find-operation-coding-system'
10528 and the variable `auto-coding-alist'. */);
10529 Vfile_coding_system_alist
= Qnil
;
10531 DEFVAR_LISP ("process-coding-system-alist", Vprocess_coding_system_alist
,
10533 Alist to decide a coding system to use for a process I/O operation.
10534 The format is ((PATTERN . VAL) ...),
10535 where PATTERN is a regular expression matching a program name,
10536 VAL is a coding system, a cons of coding systems, or a function symbol.
10537 If VAL is a coding system, it is used for both decoding what received
10538 from the program and encoding what sent to the program.
10539 If VAL is a cons of coding systems, the car part is used for decoding,
10540 and the cdr part is used for encoding.
10541 If VAL is a function symbol, the function must return a coding system
10542 or a cons of coding systems which are used as above.
10544 See also the function `find-operation-coding-system'. */);
10545 Vprocess_coding_system_alist
= Qnil
;
10547 DEFVAR_LISP ("network-coding-system-alist", Vnetwork_coding_system_alist
,
10549 Alist to decide a coding system to use for a network I/O operation.
10550 The format is ((PATTERN . VAL) ...),
10551 where PATTERN is a regular expression matching a network service name
10552 or is a port number to connect to,
10553 VAL is a coding system, a cons of coding systems, or a function symbol.
10554 If VAL is a coding system, it is used for both decoding what received
10555 from the network stream and encoding what sent to the network stream.
10556 If VAL is a cons of coding systems, the car part is used for decoding,
10557 and the cdr part is used for encoding.
10558 If VAL is a function symbol, the function must return a coding system
10559 or a cons of coding systems which are used as above.
10561 See also the function `find-operation-coding-system'. */);
10562 Vnetwork_coding_system_alist
= Qnil
;
10564 DEFVAR_LISP ("locale-coding-system", Vlocale_coding_system
,
10565 doc
: /* Coding system to use with system messages.
10566 Also used for decoding keyboard input on X Window system. */);
10567 Vlocale_coding_system
= Qnil
;
10569 /* The eol mnemonics are reset in startup.el system-dependently. */
10570 DEFVAR_LISP ("eol-mnemonic-unix", eol_mnemonic_unix
,
10572 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
10573 eol_mnemonic_unix
= build_pure_c_string (":");
10575 DEFVAR_LISP ("eol-mnemonic-dos", eol_mnemonic_dos
,
10577 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
10578 eol_mnemonic_dos
= build_pure_c_string ("\\");
10580 DEFVAR_LISP ("eol-mnemonic-mac", eol_mnemonic_mac
,
10582 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
10583 eol_mnemonic_mac
= build_pure_c_string ("/");
10585 DEFVAR_LISP ("eol-mnemonic-undecided", eol_mnemonic_undecided
,
10587 *String displayed in mode line when end-of-line format is not yet determined. */);
10588 eol_mnemonic_undecided
= build_pure_c_string (":");
10590 DEFVAR_LISP ("enable-character-translation", Venable_character_translation
,
10592 *Non-nil enables character translation while encoding and decoding. */);
10593 Venable_character_translation
= Qt
;
10595 DEFVAR_LISP ("standard-translation-table-for-decode",
10596 Vstandard_translation_table_for_decode
,
10597 doc
: /* Table for translating characters while decoding. */);
10598 Vstandard_translation_table_for_decode
= Qnil
;
10600 DEFVAR_LISP ("standard-translation-table-for-encode",
10601 Vstandard_translation_table_for_encode
,
10602 doc
: /* Table for translating characters while encoding. */);
10603 Vstandard_translation_table_for_encode
= Qnil
;
10605 DEFVAR_LISP ("charset-revision-table", Vcharset_revision_table
,
10606 doc
: /* Alist of charsets vs revision numbers.
10607 While encoding, if a charset (car part of an element) is found,
10608 designate it with the escape sequence identifying revision (cdr part
10609 of the element). */);
10610 Vcharset_revision_table
= Qnil
;
10612 DEFVAR_LISP ("default-process-coding-system",
10613 Vdefault_process_coding_system
,
10614 doc
: /* Cons of coding systems used for process I/O by default.
10615 The car part is used for decoding a process output,
10616 the cdr part is used for encoding a text to be sent to a process. */);
10617 Vdefault_process_coding_system
= Qnil
;
10619 DEFVAR_LISP ("latin-extra-code-table", Vlatin_extra_code_table
,
10621 Table of extra Latin codes in the range 128..159 (inclusive).
10622 This is a vector of length 256.
10623 If Nth element is non-nil, the existence of code N in a file
10624 \(or output of subprocess) doesn't prevent it to be detected as
10625 a coding system of ISO 2022 variant which has a flag
10626 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
10627 or reading output of a subprocess.
10628 Only 128th through 159th elements have a meaning. */);
10629 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
10631 DEFVAR_LISP ("select-safe-coding-system-function",
10632 Vselect_safe_coding_system_function
,
10634 Function to call to select safe coding system for encoding a text.
10636 If set, this function is called to force a user to select a proper
10637 coding system which can encode the text in the case that a default
10638 coding system used in each operation can't encode the text. The
10639 function should take care that the buffer is not modified while
10640 the coding system is being selected.
10642 The default value is `select-safe-coding-system' (which see). */);
10643 Vselect_safe_coding_system_function
= Qnil
;
10645 DEFVAR_BOOL ("coding-system-require-warning",
10646 coding_system_require_warning
,
10647 doc
: /* Internal use only.
10648 If non-nil, on writing a file, `select-safe-coding-system-function' is
10649 called even if `coding-system-for-write' is non-nil. The command
10650 `universal-coding-system-argument' binds this variable to t temporarily. */);
10651 coding_system_require_warning
= 0;
10654 DEFVAR_BOOL ("inhibit-iso-escape-detection",
10655 inhibit_iso_escape_detection
,
10657 If non-nil, Emacs ignores ISO-2022 escape sequences during code detection.
10659 When Emacs reads text, it tries to detect how the text is encoded.
10660 This code detection is sensitive to escape sequences. If Emacs sees
10661 a valid ISO-2022 escape sequence, it assumes the text is encoded in one
10662 of the ISO2022 encodings, and decodes text by the corresponding coding
10663 system (e.g. `iso-2022-7bit').
10665 However, there may be a case that you want to read escape sequences in
10666 a file as is. In such a case, you can set this variable to non-nil.
10667 Then the code detection will ignore any escape sequences, and no text is
10668 detected as encoded in some ISO-2022 encoding. The result is that all
10669 escape sequences become visible in a buffer.
10671 The default value is nil, and it is strongly recommended not to change
10672 it. That is because many Emacs Lisp source files that contain
10673 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
10674 in Emacs's distribution, and they won't be decoded correctly on
10675 reading if you suppress escape sequence detection.
10677 The other way to read escape sequences in a file without decoding is
10678 to explicitly specify some coding system that doesn't use ISO-2022
10679 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
10680 inhibit_iso_escape_detection
= 0;
10682 DEFVAR_BOOL ("inhibit-null-byte-detection",
10683 inhibit_null_byte_detection
,
10684 doc
: /* If non-nil, Emacs ignores null bytes on code detection.
10685 By default, Emacs treats it as binary data, and does not attempt to
10686 decode it. The effect is as if you specified `no-conversion' for
10689 Set this to non-nil when a regular text happens to include null bytes.
10690 Examples are Index nodes of Info files and null-byte delimited output
10691 from GNU Find and GNU Grep. Emacs will then ignore the null bytes and
10692 decode text as usual. */);
10693 inhibit_null_byte_detection
= 0;
10695 DEFVAR_LISP ("translation-table-for-input", Vtranslation_table_for_input
,
10696 doc
: /* Char table for translating self-inserting characters.
10697 This is applied to the result of input methods, not their input.
10698 See also `keyboard-translate-table'.
10700 Use of this variable for character code unification was rendered
10701 obsolete in Emacs 23.1 and later, since Unicode is now the basis of
10702 internal character representation. */);
10703 Vtranslation_table_for_input
= Qnil
;
10706 Lisp_Object args
[coding_arg_max
];
10707 Lisp_Object plist
[16];
10710 for (i
= 0; i
< coding_arg_max
; i
++)
10713 plist
[0] = intern_c_string (":name");
10714 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
10715 plist
[2] = intern_c_string (":mnemonic");
10716 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
10717 plist
[4] = intern_c_string (":coding-type");
10718 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
10719 plist
[6] = intern_c_string (":ascii-compatible-p");
10720 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
10721 plist
[8] = intern_c_string (":default-char");
10722 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
10723 plist
[10] = intern_c_string (":for-unibyte");
10724 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
10725 plist
[12] = intern_c_string (":docstring");
10726 plist
[13] = build_pure_c_string ("Do no conversion.\n\
10728 When you visit a file with this coding, the file is read into a\n\
10729 unibyte buffer as is, thus each byte of a file is treated as a\n\
10731 plist
[14] = intern_c_string (":eol-type");
10732 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
10733 args
[coding_arg_plist
] = Flist (16, plist
);
10734 Fdefine_coding_system_internal (coding_arg_max
, args
);
10736 plist
[1] = args
[coding_arg_name
] = Qundecided
;
10737 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
10738 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
10739 /* This is already set.
10740 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
10741 plist
[8] = intern_c_string (":charset-list");
10742 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
10743 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
10744 plist
[13] = build_pure_c_string ("No conversion on encoding, automatic conversion on decoding.");
10745 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
10746 args
[coding_arg_plist
] = Flist (16, plist
);
10747 Fdefine_coding_system_internal (coding_arg_max
, args
);
10750 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
10755 for (i
= 0; i
< coding_category_max
; i
++)
10756 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
10758 #if defined (DOS_NT)
10759 system_eol_type
= Qdos
;
10761 system_eol_type
= Qunix
;
10763 staticpro (&system_eol_type
);
10767 emacs_strerror (int error_number
)
10771 synchronize_system_messages_locale ();
10772 str
= strerror (error_number
);
10774 if (! NILP (Vlocale_coding_system
))
10776 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
10777 Vlocale_coding_system
,
10779 str
= SSDATA (dec
);