1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 2001-2011 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. In
59 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 1 if the byte sequence conforms to XXX, otherwise return 0.
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 int multibytep
= coding
->src_multibyte
;
162 int 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 int 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 int 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 int 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 ***/
292 #include "character.h"
295 #include "composite.h"
299 #include "termhooks.h"
301 Lisp_Object Vcoding_system_hash_table
;
303 Lisp_Object Qcoding_system
, Qcoding_aliases
, Qeol_type
;
304 Lisp_Object Qunix
, Qdos
;
305 Lisp_Object Qbuffer_file_coding_system
;
306 Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
307 Lisp_Object Qdefault_char
;
308 Lisp_Object Qno_conversion
, Qundecided
;
309 Lisp_Object Qcharset
, Qiso_2022
, Qutf_8
, Qutf_16
, Qshift_jis
, Qbig5
;
310 Lisp_Object Qbig
, Qlittle
;
311 Lisp_Object Qcoding_system_history
;
312 Lisp_Object Qvalid_codes
;
313 Lisp_Object QCcategory
, QCmnemonic
, QCdefault_char
;
314 Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
315 Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
316 Lisp_Object QCascii_compatible_p
;
318 Lisp_Object Qcall_process
, Qcall_process_region
;
319 Lisp_Object Qstart_process
, Qopen_network_stream
;
320 Lisp_Object Qtarget_idx
;
322 Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
323 Lisp_Object Qinterrupted
, Qinsufficient_memory
;
325 /* If a symbol has this property, evaluate the value to define the
326 symbol as a coding system. */
327 static Lisp_Object Qcoding_system_define_form
;
329 /* Format of end-of-line decided by system. This is Qunix on
330 Unix and Mac, Qdos on DOS/Windows.
331 This has an effect only for external encoding (i.e. for output to
332 file and process), not for in-buffer or Lisp string encoding. */
333 static Lisp_Object system_eol_type
;
337 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
339 /* Coding system emacs-mule and raw-text are for converting only
340 end-of-line format. */
341 Lisp_Object Qemacs_mule
, Qraw_text
;
342 Lisp_Object Qutf_8_emacs
;
344 /* Coding-systems are handed between Emacs Lisp programs and C internal
345 routines by the following three variables. */
346 /* Coding system to be used to encode text for terminal display when
347 terminal coding system is nil. */
348 struct coding_system safe_terminal_coding
;
352 Lisp_Object Qtranslation_table
;
353 Lisp_Object Qtranslation_table_id
;
354 Lisp_Object Qtranslation_table_for_decode
;
355 Lisp_Object Qtranslation_table_for_encode
;
357 /* Two special coding systems. */
358 Lisp_Object Vsjis_coding_system
;
359 Lisp_Object Vbig5_coding_system
;
361 /* ISO2022 section */
363 #define CODING_ISO_INITIAL(coding, reg) \
364 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
365 coding_attr_iso_initial), \
369 #define CODING_ISO_REQUEST(coding, charset_id) \
370 (((charset_id) <= (coding)->max_charset_id \
371 ? ((coding)->safe_charsets[charset_id] != 255 \
372 ? (coding)->safe_charsets[charset_id] \
377 #define CODING_ISO_FLAGS(coding) \
378 ((coding)->spec.iso_2022.flags)
379 #define CODING_ISO_DESIGNATION(coding, reg) \
380 ((coding)->spec.iso_2022.current_designation[reg])
381 #define CODING_ISO_INVOCATION(coding, plane) \
382 ((coding)->spec.iso_2022.current_invocation[plane])
383 #define CODING_ISO_SINGLE_SHIFTING(coding) \
384 ((coding)->spec.iso_2022.single_shifting)
385 #define CODING_ISO_BOL(coding) \
386 ((coding)->spec.iso_2022.bol)
387 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
388 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
389 #define CODING_ISO_CMP_STATUS(coding) \
390 (&(coding)->spec.iso_2022.cmp_status)
391 #define CODING_ISO_EXTSEGMENT_LEN(coding) \
392 ((coding)->spec.iso_2022.ctext_extended_segment_len)
393 #define CODING_ISO_EMBEDDED_UTF_8(coding) \
394 ((coding)->spec.iso_2022.embedded_utf_8)
396 /* Control characters of ISO2022. */
397 /* code */ /* function */
398 #define ISO_CODE_SO 0x0E /* shift-out */
399 #define ISO_CODE_SI 0x0F /* shift-in */
400 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
401 #define ISO_CODE_ESC 0x1B /* escape */
402 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
403 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
404 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
406 /* All code (1-byte) of ISO2022 is classified into one of the
408 enum iso_code_class_type
410 ISO_control_0
, /* Control codes in the range
411 0x00..0x1F and 0x7F, except for the
412 following 5 codes. */
413 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
414 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
415 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
416 ISO_escape
, /* ISO_CODE_SO (0x1B) */
417 ISO_control_1
, /* Control codes in the range
418 0x80..0x9F, except for the
419 following 3 codes. */
420 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
421 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
422 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
423 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
424 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
425 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
426 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
429 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
430 `iso-flags' attribute of an iso2022 coding system. */
432 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
433 instead of the correct short-form sequence (e.g. ESC $ A). */
434 #define CODING_ISO_FLAG_LONG_FORM 0x0001
436 /* If set, reset graphic planes and registers at end-of-line to the
438 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
440 /* If set, reset graphic planes and registers before any control
441 characters to the initial state. */
442 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
444 /* If set, encode by 7-bit environment. */
445 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
447 /* If set, use locking-shift function. */
448 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
450 /* If set, use single-shift function. Overwrite
451 CODING_ISO_FLAG_LOCKING_SHIFT. */
452 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
454 /* If set, use designation escape sequence. */
455 #define CODING_ISO_FLAG_DESIGNATION 0x0040
457 /* If set, produce revision number sequence. */
458 #define CODING_ISO_FLAG_REVISION 0x0080
460 /* If set, produce ISO6429's direction specifying sequence. */
461 #define CODING_ISO_FLAG_DIRECTION 0x0100
463 /* If set, assume designation states are reset at beginning of line on
465 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
467 /* If set, designation sequence should be placed at beginning of line
469 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
471 /* If set, do not encode unsafe characters on output. */
472 #define CODING_ISO_FLAG_SAFE 0x0800
474 /* If set, extra latin codes (128..159) are accepted as a valid code
476 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
478 #define CODING_ISO_FLAG_COMPOSITION 0x2000
480 /* #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000 */
482 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
484 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
486 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
488 /* A character to be produced on output if encoding of the original
489 character is prohibited by CODING_ISO_FLAG_SAFE. */
490 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
493 #define CODING_UTF_8_BOM(coding) \
494 ((coding)->spec.utf_8_bom)
497 #define CODING_UTF_16_BOM(coding) \
498 ((coding)->spec.utf_16.bom)
500 #define CODING_UTF_16_ENDIAN(coding) \
501 ((coding)->spec.utf_16.endian)
503 #define CODING_UTF_16_SURROGATE(coding) \
504 ((coding)->spec.utf_16.surrogate)
508 #define CODING_CCL_DECODER(coding) \
509 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
510 #define CODING_CCL_ENCODER(coding) \
511 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
512 #define CODING_CCL_VALIDS(coding) \
513 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
515 /* Index for each coding category in `coding_categories' */
519 coding_category_iso_7
,
520 coding_category_iso_7_tight
,
521 coding_category_iso_8_1
,
522 coding_category_iso_8_2
,
523 coding_category_iso_7_else
,
524 coding_category_iso_8_else
,
525 coding_category_utf_8_auto
,
526 coding_category_utf_8_nosig
,
527 coding_category_utf_8_sig
,
528 coding_category_utf_16_auto
,
529 coding_category_utf_16_be
,
530 coding_category_utf_16_le
,
531 coding_category_utf_16_be_nosig
,
532 coding_category_utf_16_le_nosig
,
533 coding_category_charset
,
534 coding_category_sjis
,
535 coding_category_big5
,
537 coding_category_emacs_mule
,
538 /* All above are targets of code detection. */
539 coding_category_raw_text
,
540 coding_category_undecided
,
544 /* Definitions of flag bits used in detect_coding_XXXX. */
545 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
546 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
547 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
548 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
549 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
550 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
551 #define CATEGORY_MASK_UTF_8_AUTO (1 << coding_category_utf_8_auto)
552 #define CATEGORY_MASK_UTF_8_NOSIG (1 << coding_category_utf_8_nosig)
553 #define CATEGORY_MASK_UTF_8_SIG (1 << coding_category_utf_8_sig)
554 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
555 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
556 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
557 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
558 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
559 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
560 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
561 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
562 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
563 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
564 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
566 /* This value is returned if detect_coding_mask () find nothing other
567 than ASCII characters. */
568 #define CATEGORY_MASK_ANY \
569 (CATEGORY_MASK_ISO_7 \
570 | CATEGORY_MASK_ISO_7_TIGHT \
571 | CATEGORY_MASK_ISO_8_1 \
572 | CATEGORY_MASK_ISO_8_2 \
573 | CATEGORY_MASK_ISO_7_ELSE \
574 | CATEGORY_MASK_ISO_8_ELSE \
575 | CATEGORY_MASK_UTF_8_AUTO \
576 | CATEGORY_MASK_UTF_8_NOSIG \
577 | CATEGORY_MASK_UTF_8_SIG \
578 | CATEGORY_MASK_UTF_16_AUTO \
579 | CATEGORY_MASK_UTF_16_BE \
580 | CATEGORY_MASK_UTF_16_LE \
581 | CATEGORY_MASK_UTF_16_BE_NOSIG \
582 | CATEGORY_MASK_UTF_16_LE_NOSIG \
583 | CATEGORY_MASK_CHARSET \
584 | CATEGORY_MASK_SJIS \
585 | CATEGORY_MASK_BIG5 \
586 | CATEGORY_MASK_CCL \
587 | CATEGORY_MASK_EMACS_MULE)
590 #define CATEGORY_MASK_ISO_7BIT \
591 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
593 #define CATEGORY_MASK_ISO_8BIT \
594 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
596 #define CATEGORY_MASK_ISO_ELSE \
597 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
599 #define CATEGORY_MASK_ISO_ESCAPE \
600 (CATEGORY_MASK_ISO_7 \
601 | CATEGORY_MASK_ISO_7_TIGHT \
602 | CATEGORY_MASK_ISO_7_ELSE \
603 | CATEGORY_MASK_ISO_8_ELSE)
605 #define CATEGORY_MASK_ISO \
606 ( CATEGORY_MASK_ISO_7BIT \
607 | CATEGORY_MASK_ISO_8BIT \
608 | CATEGORY_MASK_ISO_ELSE)
610 #define CATEGORY_MASK_UTF_16 \
611 (CATEGORY_MASK_UTF_16_AUTO \
612 | CATEGORY_MASK_UTF_16_BE \
613 | CATEGORY_MASK_UTF_16_LE \
614 | CATEGORY_MASK_UTF_16_BE_NOSIG \
615 | CATEGORY_MASK_UTF_16_LE_NOSIG)
617 #define CATEGORY_MASK_UTF_8 \
618 (CATEGORY_MASK_UTF_8_AUTO \
619 | CATEGORY_MASK_UTF_8_NOSIG \
620 | CATEGORY_MASK_UTF_8_SIG)
622 /* Table of coding categories (Lisp symbols). This variable is for
623 internal use only. */
624 static Lisp_Object Vcoding_category_table
;
626 /* Table of coding-categories ordered by priority. */
627 static enum coding_category coding_priorities
[coding_category_max
];
629 /* Nth element is a coding context for the coding system bound to the
630 Nth coding category. */
631 static struct coding_system coding_categories
[coding_category_max
];
633 /*** Commonly used macros and functions ***/
636 #define min(a, b) ((a) < (b) ? (a) : (b))
639 #define max(a, b) ((a) > (b) ? (a) : (b))
642 #define CODING_GET_INFO(coding, attrs, charset_list) \
644 (attrs) = CODING_ID_ATTRS ((coding)->id); \
645 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
649 /* Safely get one byte from the source text pointed by SRC which ends
650 at SRC_END, and set C to that byte. If there are not enough bytes
651 in the source, it jumps to `no_more_source'. If multibytep is
652 nonzero, and a multibyte character is found at SRC, set C to the
653 negative value of the character code. The caller should declare
654 and set these variables appropriately in advance:
655 src, src_end, multibytep */
657 #define ONE_MORE_BYTE(c) \
659 if (src == src_end) \
661 if (src_base < src) \
662 record_conversion_result \
663 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
664 goto no_more_source; \
667 if (multibytep && (c & 0x80)) \
669 if ((c & 0xFE) == 0xC0) \
670 c = ((c & 1) << 6) | *src++; \
674 c = - string_char (src, &src, NULL); \
675 record_conversion_result \
676 (coding, CODING_RESULT_INVALID_SRC); \
682 /* Safely get two bytes from the source text pointed by SRC which ends
683 at SRC_END, and set C1 and C2 to those bytes while skipping the
684 heading multibyte characters. If there are not enough bytes in the
685 source, it jumps to `no_more_source'. If multibytep is nonzero and
686 a multibyte character is found for C2, set C2 to the negative value
687 of the character code. The caller should declare and set these
688 variables appropriately in advance:
689 src, src_end, multibytep
690 It is intended that this macro is used in detect_coding_utf_16. */
692 #define TWO_MORE_BYTES(c1, c2) \
695 if (src == src_end) \
696 goto no_more_source; \
698 if (multibytep && (c1 & 0x80)) \
700 if ((c1 & 0xFE) == 0xC0) \
701 c1 = ((c1 & 1) << 6) | *src++; \
704 src += BYTES_BY_CHAR_HEAD (c1) - 1; \
709 if (src == src_end) \
710 goto no_more_source; \
712 if (multibytep && (c2 & 0x80)) \
714 if ((c2 & 0xFE) == 0xC0) \
715 c2 = ((c2 & 1) << 6) | *src++; \
722 /* Store a byte C in the place pointed by DST and increment DST to the
723 next free point, and increment PRODUCED_CHARS. The caller should
724 assure that C is 0..127, and declare and set the variable `dst'
725 appropriately in advance.
729 #define EMIT_ONE_ASCII_BYTE(c) \
736 /* Like EMIT_ONE_ASCII_BYTE but store two bytes; C1 and C2. */
738 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
740 produced_chars += 2; \
741 *dst++ = (c1), *dst++ = (c2); \
745 /* Store a byte C in the place pointed by DST and increment DST to the
746 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
747 nonzero, store in an appropriate multibyte from. The caller should
748 declare and set the variables `dst' and `multibytep' appropriately
751 #define EMIT_ONE_BYTE(c) \
758 ch = BYTE8_TO_CHAR (ch); \
759 CHAR_STRING_ADVANCE (ch, dst); \
766 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
768 #define EMIT_TWO_BYTES(c1, c2) \
770 produced_chars += 2; \
777 ch = BYTE8_TO_CHAR (ch); \
778 CHAR_STRING_ADVANCE (ch, dst); \
781 ch = BYTE8_TO_CHAR (ch); \
782 CHAR_STRING_ADVANCE (ch, dst); \
792 #define EMIT_THREE_BYTES(c1, c2, c3) \
794 EMIT_ONE_BYTE (c1); \
795 EMIT_TWO_BYTES (c2, c3); \
799 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
801 EMIT_TWO_BYTES (c1, c2); \
802 EMIT_TWO_BYTES (c3, c4); \
806 /* Prototypes for static functions. */
807 static void record_conversion_result (struct coding_system
*coding
,
808 enum coding_result_code result
);
809 static int detect_coding_utf_8 (struct coding_system
*,
810 struct coding_detection_info
*info
);
811 static void decode_coding_utf_8 (struct coding_system
*);
812 static int encode_coding_utf_8 (struct coding_system
*);
814 static int detect_coding_utf_16 (struct coding_system
*,
815 struct coding_detection_info
*info
);
816 static void decode_coding_utf_16 (struct coding_system
*);
817 static int encode_coding_utf_16 (struct coding_system
*);
819 static int detect_coding_iso_2022 (struct coding_system
*,
820 struct coding_detection_info
*info
);
821 static void decode_coding_iso_2022 (struct coding_system
*);
822 static int encode_coding_iso_2022 (struct coding_system
*);
824 static int detect_coding_emacs_mule (struct coding_system
*,
825 struct coding_detection_info
*info
);
826 static void decode_coding_emacs_mule (struct coding_system
*);
827 static int encode_coding_emacs_mule (struct coding_system
*);
829 static int detect_coding_sjis (struct coding_system
*,
830 struct coding_detection_info
*info
);
831 static void decode_coding_sjis (struct coding_system
*);
832 static int encode_coding_sjis (struct coding_system
*);
834 static int detect_coding_big5 (struct coding_system
*,
835 struct coding_detection_info
*info
);
836 static void decode_coding_big5 (struct coding_system
*);
837 static int encode_coding_big5 (struct coding_system
*);
839 static int detect_coding_ccl (struct coding_system
*,
840 struct coding_detection_info
*info
);
841 static void decode_coding_ccl (struct coding_system
*);
842 static int encode_coding_ccl (struct coding_system
*);
844 static void decode_coding_raw_text (struct coding_system
*);
845 static int encode_coding_raw_text (struct coding_system
*);
847 static void coding_set_source (struct coding_system
*);
848 static void coding_set_destination (struct coding_system
*);
849 static void coding_alloc_by_realloc (struct coding_system
*, EMACS_INT
);
850 static void coding_alloc_by_making_gap (struct coding_system
*,
851 EMACS_INT
, EMACS_INT
);
852 static unsigned char *alloc_destination (struct coding_system
*,
853 EMACS_INT
, unsigned char *);
854 static void setup_iso_safe_charsets (Lisp_Object
);
855 static unsigned char *encode_designation_at_bol (struct coding_system
*,
856 int *, unsigned char *);
857 static int detect_eol (const unsigned char *,
858 EMACS_INT
, enum coding_category
);
859 static Lisp_Object
adjust_coding_eol_type (struct coding_system
*, int);
860 static void decode_eol (struct coding_system
*);
861 static Lisp_Object
get_translation_table (Lisp_Object
, int, int *);
862 static Lisp_Object
get_translation (Lisp_Object
, int *, int *);
863 static int produce_chars (struct coding_system
*, Lisp_Object
, int);
864 static INLINE
void produce_charset (struct coding_system
*, int *,
866 static void produce_annotation (struct coding_system
*, EMACS_INT
);
867 static int decode_coding (struct coding_system
*);
868 static INLINE
int *handle_composition_annotation (EMACS_INT
, EMACS_INT
,
869 struct coding_system
*,
871 static INLINE
int *handle_charset_annotation (EMACS_INT
, EMACS_INT
,
872 struct coding_system
*,
874 static void consume_chars (struct coding_system
*, Lisp_Object
, int);
875 static int encode_coding (struct coding_system
*);
876 static Lisp_Object
make_conversion_work_buffer (int);
877 static Lisp_Object
code_conversion_restore (Lisp_Object
);
878 static INLINE
int char_encodable_p (int, Lisp_Object
);
879 static Lisp_Object
make_subsidiaries (Lisp_Object
);
882 record_conversion_result (struct coding_system
*coding
,
883 enum coding_result_code result
)
885 coding
->result
= result
;
888 case CODING_RESULT_INSUFFICIENT_SRC
:
889 Vlast_code_conversion_error
= Qinsufficient_source
;
891 case CODING_RESULT_INCONSISTENT_EOL
:
892 Vlast_code_conversion_error
= Qinconsistent_eol
;
894 case CODING_RESULT_INVALID_SRC
:
895 Vlast_code_conversion_error
= Qinvalid_source
;
897 case CODING_RESULT_INTERRUPT
:
898 Vlast_code_conversion_error
= Qinterrupted
;
900 case CODING_RESULT_INSUFFICIENT_MEM
:
901 Vlast_code_conversion_error
= Qinsufficient_memory
;
903 case CODING_RESULT_INSUFFICIENT_DST
:
904 /* Don't record this error in Vlast_code_conversion_error
905 because it happens just temporarily and is resolved when the
906 whole conversion is finished. */
908 case CODING_RESULT_SUCCESS
:
911 Vlast_code_conversion_error
= intern ("Unknown error");
915 /* This wrapper macro is used to preserve validity of pointers into
916 buffer text across calls to decode_char, which could cause
917 relocation of buffers if it loads a charset map, because loading a
918 charset map allocates large structures. */
919 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
921 charset_map_loaded = 0; \
922 c = DECODE_CHAR (charset, code); \
923 if (charset_map_loaded) \
925 const unsigned char *orig = coding->source; \
928 coding_set_source (coding); \
929 offset = coding->source - orig; \
931 src_base += offset; \
937 /* If there are at least BYTES length of room at dst, allocate memory
938 for coding->destination and update dst and dst_end. We don't have
939 to take care of coding->source which will be relocated. It is
940 handled by calling coding_set_source in encode_coding. */
942 #define ASSURE_DESTINATION(bytes) \
944 if (dst + (bytes) >= dst_end) \
946 int more_bytes = charbuf_end - charbuf + (bytes); \
948 dst = alloc_destination (coding, more_bytes, dst); \
949 dst_end = coding->destination + coding->dst_bytes; \
954 /* Store multibyte form of the character C in P, and advance P to the
955 end of the multibyte form. This is like CHAR_STRING_ADVANCE but it
956 never calls MAYBE_UNIFY_CHAR. */
958 #define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) \
960 if ((c) <= MAX_1_BYTE_CHAR) \
962 else if ((c) <= MAX_2_BYTE_CHAR) \
963 *(p)++ = (0xC0 | ((c) >> 6)), \
964 *(p)++ = (0x80 | ((c) & 0x3F)); \
965 else if ((c) <= MAX_3_BYTE_CHAR) \
966 *(p)++ = (0xE0 | ((c) >> 12)), \
967 *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \
968 *(p)++ = (0x80 | ((c) & 0x3F)); \
969 else if ((c) <= MAX_4_BYTE_CHAR) \
970 *(p)++ = (0xF0 | (c >> 18)), \
971 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
972 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
973 *(p)++ = (0x80 | (c & 0x3F)); \
974 else if ((c) <= MAX_5_BYTE_CHAR) \
976 *(p)++ = (0x80 | ((c >> 18) & 0x0F)), \
977 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
978 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
979 *(p)++ = (0x80 | (c & 0x3F)); \
981 (p) += BYTE8_STRING ((c) - 0x3FFF80, p); \
985 /* Return the character code of character whose multibyte form is at
986 P, and advance P to the end of the multibyte form. This is like
987 STRING_CHAR_ADVANCE, but it never calls MAYBE_UNIFY_CHAR. */
989 #define STRING_CHAR_ADVANCE_NO_UNIFY(p) \
992 : ! ((p)[0] & 0x20) \
994 ((((p)[-2] & 0x1F) << 6) \
996 | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0))) \
997 : ! ((p)[0] & 0x10) \
999 ((((p)[-3] & 0x0F) << 12) \
1000 | (((p)[-2] & 0x3F) << 6) \
1001 | ((p)[-1] & 0x3F))) \
1002 : ! ((p)[0] & 0x08) \
1004 ((((p)[-4] & 0xF) << 18) \
1005 | (((p)[-3] & 0x3F) << 12) \
1006 | (((p)[-2] & 0x3F) << 6) \
1007 | ((p)[-1] & 0x3F))) \
1009 ((((p)[-4] & 0x3F) << 18) \
1010 | (((p)[-3] & 0x3F) << 12) \
1011 | (((p)[-2] & 0x3F) << 6) \
1012 | ((p)[-1] & 0x3F))))
1016 coding_set_source (struct coding_system
*coding
)
1018 if (BUFFERP (coding
->src_object
))
1020 struct buffer
*buf
= XBUFFER (coding
->src_object
);
1022 if (coding
->src_pos
< 0)
1023 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
1025 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
1027 else if (STRINGP (coding
->src_object
))
1029 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
1033 /* Otherwise, the source is C string and is never relocated
1034 automatically. Thus we don't have to update anything. */
1039 coding_set_destination (struct coding_system
*coding
)
1041 if (BUFFERP (coding
->dst_object
))
1043 if (coding
->src_pos
< 0)
1045 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- BEG_BYTE
;
1046 coding
->dst_bytes
= (GAP_END_ADDR
1047 - (coding
->src_bytes
- coding
->consumed
)
1048 - coding
->destination
);
1052 /* We are sure that coding->dst_pos_byte is before the gap
1054 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
1055 + coding
->dst_pos_byte
- BEG_BYTE
);
1056 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
1057 - coding
->destination
);
1062 /* Otherwise, the destination is C string and is never relocated
1063 automatically. Thus we don't have to update anything. */
1069 coding_alloc_by_realloc (struct coding_system
*coding
, EMACS_INT bytes
)
1071 coding
->destination
= (unsigned char *) xrealloc (coding
->destination
,
1072 coding
->dst_bytes
+ bytes
);
1073 coding
->dst_bytes
+= bytes
;
1077 coding_alloc_by_making_gap (struct coding_system
*coding
,
1078 EMACS_INT gap_head_used
, EMACS_INT bytes
)
1080 if (EQ (coding
->src_object
, coding
->dst_object
))
1082 /* The gap may contain the produced data at the head and not-yet
1083 consumed data at the tail. To preserve those data, we at
1084 first make the gap size to zero, then increase the gap
1086 EMACS_INT add
= GAP_SIZE
;
1088 GPT
+= gap_head_used
, GPT_BYTE
+= gap_head_used
;
1089 GAP_SIZE
= 0; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1091 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1092 GPT
-= gap_head_used
, GPT_BYTE
-= gap_head_used
;
1096 Lisp_Object this_buffer
;
1098 this_buffer
= Fcurrent_buffer ();
1099 set_buffer_internal (XBUFFER (coding
->dst_object
));
1101 set_buffer_internal (XBUFFER (this_buffer
));
1106 static unsigned char *
1107 alloc_destination (struct coding_system
*coding
, EMACS_INT nbytes
,
1110 EMACS_INT offset
= dst
- coding
->destination
;
1112 if (BUFFERP (coding
->dst_object
))
1114 struct buffer
*buf
= XBUFFER (coding
->dst_object
);
1116 coding_alloc_by_making_gap (coding
, dst
- BUF_GPT_ADDR (buf
), nbytes
);
1119 coding_alloc_by_realloc (coding
, nbytes
);
1120 coding_set_destination (coding
);
1121 dst
= coding
->destination
+ offset
;
1125 /** Macros for annotations. */
1127 /* An annotation data is stored in the array coding->charbuf in this
1129 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1130 LENGTH is the number of elements in the annotation.
1131 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1132 NCHARS is the number of characters in the text annotated.
1134 The format of the following elements depend on ANNOTATION_MASK.
1136 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1138 ... NBYTES METHOD [ COMPOSITION-COMPONENTS ... ]
1140 NBYTES is the number of bytes specified in the header part of
1141 old-style emacs-mule encoding, or 0 for the other kind of
1144 METHOD is one of enum composition_method.
1146 Optional COMPOSITION-COMPONENTS are characters and composition
1149 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1152 If ANNOTATION_MASK is 0, this annotation is just a space holder to
1153 recover from an invalid annotation, and should be skipped by
1154 produce_annotation. */
1156 /* Maximum length of the header of annotation data. */
1157 #define MAX_ANNOTATION_LENGTH 5
1159 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1161 *(buf)++ = -(len); \
1162 *(buf)++ = (mask); \
1163 *(buf)++ = (nchars); \
1164 coding->annotated = 1; \
1167 #define ADD_COMPOSITION_DATA(buf, nchars, nbytes, method) \
1169 ADD_ANNOTATION_DATA (buf, 5, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1175 #define ADD_CHARSET_DATA(buf, nchars, id) \
1177 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1182 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1189 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1190 Check if a text is encoded in UTF-8. If it is, return 1, else
1193 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1194 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1195 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1196 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1197 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1198 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1200 #define UTF_8_BOM_1 0xEF
1201 #define UTF_8_BOM_2 0xBB
1202 #define UTF_8_BOM_3 0xBF
1205 detect_coding_utf_8 (struct coding_system
*coding
,
1206 struct coding_detection_info
*detect_info
)
1208 const unsigned char *src
= coding
->source
, *src_base
;
1209 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1210 int multibytep
= coding
->src_multibyte
;
1211 int consumed_chars
= 0;
1215 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1216 /* A coding system of this category is always ASCII compatible. */
1217 src
+= coding
->head_ascii
;
1221 int c
, c1
, c2
, c3
, c4
;
1225 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1228 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1230 if (UTF_8_2_OCTET_LEADING_P (c
))
1236 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1238 if (UTF_8_3_OCTET_LEADING_P (c
))
1241 if (src_base
== coding
->source
1242 && c
== UTF_8_BOM_1
&& c1
== UTF_8_BOM_2
&& c2
== UTF_8_BOM_3
)
1247 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1249 if (UTF_8_4_OCTET_LEADING_P (c
))
1255 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1257 if (UTF_8_5_OCTET_LEADING_P (c
))
1264 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1268 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1270 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1275 /* The first character 0xFFFE doesn't necessarily mean a BOM. */
1276 detect_info
->found
|= CATEGORY_MASK_UTF_8_SIG
| CATEGORY_MASK_UTF_8_NOSIG
;
1280 detect_info
->rejected
|= CATEGORY_MASK_UTF_8_SIG
;
1282 detect_info
->found
|= CATEGORY_MASK_UTF_8_NOSIG
;
1289 decode_coding_utf_8 (struct coding_system
*coding
)
1291 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1292 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1293 const unsigned char *src_base
;
1294 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1295 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1296 int consumed_chars
= 0, consumed_chars_base
= 0;
1297 int multibytep
= coding
->src_multibyte
;
1298 enum utf_bom_type bom
= CODING_UTF_8_BOM (coding
);
1300 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1301 int byte_after_cr
= -1;
1303 if (bom
!= utf_without_bom
)
1309 if (! UTF_8_3_OCTET_LEADING_P (c1
))
1314 if (! UTF_8_EXTRA_OCTET_P (c2
))
1319 if (! UTF_8_EXTRA_OCTET_P (c3
))
1323 if ((c1
!= UTF_8_BOM_1
)
1324 || (c2
!= UTF_8_BOM_2
) || (c3
!= UTF_8_BOM_3
))
1327 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1332 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1336 int c
, c1
, c2
, c3
, c4
, c5
;
1339 consumed_chars_base
= consumed_chars
;
1341 if (charbuf
>= charbuf_end
)
1343 if (byte_after_cr
>= 0)
1348 if (byte_after_cr
>= 0)
1349 c1
= byte_after_cr
, byte_after_cr
= -1;
1356 else if (UTF_8_1_OCTET_P (c1
))
1358 if (eol_dos
&& c1
== '\r')
1359 ONE_MORE_BYTE (byte_after_cr
);
1365 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1367 if (UTF_8_2_OCTET_LEADING_P (c1
))
1369 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1370 /* Reject overlong sequences here and below. Encoders
1371 producing them are incorrect, they can be misleading,
1372 and they mess up read/write invariance. */
1379 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1381 if (UTF_8_3_OCTET_LEADING_P (c1
))
1383 c
= (((c1
& 0xF) << 12)
1384 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1386 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1392 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1394 if (UTF_8_4_OCTET_LEADING_P (c1
))
1396 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1397 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1404 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1406 if (UTF_8_5_OCTET_LEADING_P (c1
))
1408 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1409 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1411 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1426 consumed_chars
= consumed_chars_base
;
1428 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1433 coding
->consumed_char
+= consumed_chars_base
;
1434 coding
->consumed
= src_base
- coding
->source
;
1435 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1440 encode_coding_utf_8 (struct coding_system
*coding
)
1442 int multibytep
= coding
->dst_multibyte
;
1443 int *charbuf
= coding
->charbuf
;
1444 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1445 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1446 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1447 int produced_chars
= 0;
1450 if (CODING_UTF_8_BOM (coding
) == utf_with_bom
)
1452 ASSURE_DESTINATION (3);
1453 EMIT_THREE_BYTES (UTF_8_BOM_1
, UTF_8_BOM_2
, UTF_8_BOM_3
);
1454 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1459 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1461 while (charbuf
< charbuf_end
)
1463 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1465 ASSURE_DESTINATION (safe_room
);
1467 if (CHAR_BYTE8_P (c
))
1469 c
= CHAR_TO_BYTE8 (c
);
1474 CHAR_STRING_ADVANCE_NO_UNIFY (c
, pend
);
1475 for (p
= str
; p
< pend
; p
++)
1482 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1484 while (charbuf
< charbuf_end
)
1486 ASSURE_DESTINATION (safe_room
);
1488 if (CHAR_BYTE8_P (c
))
1489 *dst
++ = CHAR_TO_BYTE8 (c
);
1491 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
1495 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1496 coding
->produced_char
+= produced_chars
;
1497 coding
->produced
= dst
- coding
->destination
;
1502 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1503 Check if a text is encoded in one of UTF-16 based coding systems.
1504 If it is, return 1, else return 0. */
1506 #define UTF_16_HIGH_SURROGATE_P(val) \
1507 (((val) & 0xFC00) == 0xD800)
1509 #define UTF_16_LOW_SURROGATE_P(val) \
1510 (((val) & 0xFC00) == 0xDC00)
1514 detect_coding_utf_16 (struct coding_system
*coding
,
1515 struct coding_detection_info
*detect_info
)
1517 const unsigned char *src
= coding
->source
;
1518 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1519 int multibytep
= coding
->src_multibyte
;
1522 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1523 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1524 && (coding
->src_chars
& 1))
1526 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1530 TWO_MORE_BYTES (c1
, c2
);
1531 if ((c1
== 0xFF) && (c2
== 0xFE))
1533 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1534 | CATEGORY_MASK_UTF_16_AUTO
);
1535 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1536 | CATEGORY_MASK_UTF_16_BE_NOSIG
1537 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1539 else if ((c1
== 0xFE) && (c2
== 0xFF))
1541 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1542 | CATEGORY_MASK_UTF_16_AUTO
);
1543 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1544 | CATEGORY_MASK_UTF_16_BE_NOSIG
1545 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1549 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1554 /* We check the dispersion of Eth and Oth bytes where E is even and
1555 O is odd. If both are high, we assume binary data.*/
1556 unsigned char e
[256], o
[256];
1557 unsigned e_num
= 1, o_num
= 1;
1564 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_AUTO
1565 |CATEGORY_MASK_UTF_16_BE
1566 | CATEGORY_MASK_UTF_16_LE
);
1568 while ((detect_info
->rejected
& CATEGORY_MASK_UTF_16
)
1569 != CATEGORY_MASK_UTF_16
)
1571 TWO_MORE_BYTES (c1
, c2
);
1579 detect_info
->rejected
|= CATEGORY_MASK_UTF_16_BE_NOSIG
;
1586 detect_info
->rejected
|= CATEGORY_MASK_UTF_16_LE_NOSIG
;
1597 decode_coding_utf_16 (struct coding_system
*coding
)
1599 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1600 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1601 const unsigned char *src_base
;
1602 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1603 /* We may produces at most 3 chars in one loop. */
1604 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
- 2;
1605 int consumed_chars
= 0, consumed_chars_base
= 0;
1606 int multibytep
= coding
->src_multibyte
;
1607 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1608 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1609 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1611 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1612 int byte_after_cr1
= -1, byte_after_cr2
= -1;
1614 if (bom
== utf_with_bom
)
1623 if (endian
== utf_16_big_endian
1624 ? c
!= 0xFEFF : c
!= 0xFFFE)
1626 /* The first two bytes are not BOM. Treat them as bytes
1627 for a normal character. */
1631 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1633 else if (bom
== utf_detect_bom
)
1635 /* We have already tried to detect BOM and failed in
1637 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1645 consumed_chars_base
= consumed_chars
;
1647 if (charbuf
>= charbuf_end
)
1649 if (byte_after_cr1
>= 0)
1654 if (byte_after_cr1
>= 0)
1655 c1
= byte_after_cr1
, byte_after_cr1
= -1;
1663 if (byte_after_cr2
>= 0)
1664 c2
= byte_after_cr2
, byte_after_cr2
= -1;
1669 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1673 c
= (endian
== utf_16_big_endian
1674 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1678 if (! UTF_16_LOW_SURROGATE_P (c
))
1680 if (endian
== utf_16_big_endian
)
1681 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1683 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1687 if (UTF_16_HIGH_SURROGATE_P (c
))
1688 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1694 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1695 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1696 *charbuf
++ = 0x10000 + c
;
1701 if (UTF_16_HIGH_SURROGATE_P (c
))
1702 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1705 if (eol_dos
&& c
== '\r')
1707 ONE_MORE_BYTE (byte_after_cr1
);
1708 ONE_MORE_BYTE (byte_after_cr2
);
1716 coding
->consumed_char
+= consumed_chars_base
;
1717 coding
->consumed
= src_base
- coding
->source
;
1718 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1722 encode_coding_utf_16 (struct coding_system
*coding
)
1724 int multibytep
= coding
->dst_multibyte
;
1725 int *charbuf
= coding
->charbuf
;
1726 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1727 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1728 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1730 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1731 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1732 int produced_chars
= 0;
1735 if (bom
!= utf_without_bom
)
1737 ASSURE_DESTINATION (safe_room
);
1739 EMIT_TWO_BYTES (0xFE, 0xFF);
1741 EMIT_TWO_BYTES (0xFF, 0xFE);
1742 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1745 while (charbuf
< charbuf_end
)
1747 ASSURE_DESTINATION (safe_room
);
1749 if (c
> MAX_UNICODE_CHAR
)
1750 c
= coding
->default_char
;
1755 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1757 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1764 c1
= (c
>> 10) + 0xD800;
1765 c2
= (c
& 0x3FF) + 0xDC00;
1767 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1769 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1772 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1773 coding
->produced
= dst
- coding
->destination
;
1774 coding
->produced_char
+= produced_chars
;
1779 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1781 /* Emacs' internal format for representation of multiple character
1782 sets is a kind of multi-byte encoding, i.e. characters are
1783 represented by variable-length sequences of one-byte codes.
1785 ASCII characters and control characters (e.g. `tab', `newline') are
1786 represented by one-byte sequences which are their ASCII codes, in
1787 the range 0x00 through 0x7F.
1789 8-bit characters of the range 0x80..0x9F are represented by
1790 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1793 8-bit characters of the range 0xA0..0xFF are represented by
1794 one-byte sequences which are their 8-bit code.
1796 The other characters are represented by a sequence of `base
1797 leading-code', optional `extended leading-code', and one or two
1798 `position-code's. The length of the sequence is determined by the
1799 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1800 whereas extended leading-code and position-code take the range 0xA0
1801 through 0xFF. See `charset.h' for more details about leading-code
1804 --- CODE RANGE of Emacs' internal format ---
1808 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1809 eight-bit-graphic 0xA0..0xBF
1810 ELSE 0x81..0x9D + [0xA0..0xFF]+
1811 ---------------------------------------------
1813 As this is the internal character representation, the format is
1814 usually not used externally (i.e. in a file or in a data sent to a
1815 process). But, it is possible to have a text externally in this
1816 format (i.e. by encoding by the coding system `emacs-mule').
1818 In that case, a sequence of one-byte codes has a slightly different
1821 At first, all characters in eight-bit-control are represented by
1822 one-byte sequences which are their 8-bit code.
1824 Next, character composition data are represented by the byte
1825 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1827 METHOD is 0xF2 plus one of composition method (enum
1828 composition_method),
1830 BYTES is 0xA0 plus a byte length of this composition data,
1832 CHARS is 0xA0 plus a number of characters composed by this
1835 COMPONENTs are characters of multibyte form or composition
1836 rules encoded by two-byte of ASCII codes.
1838 In addition, for backward compatibility, the following formats are
1839 also recognized as composition data on decoding.
1842 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1845 MSEQ is a multibyte form but in these special format:
1846 ASCII: 0xA0 ASCII_CODE+0x80,
1847 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1848 RULE is a one byte code of the range 0xA0..0xF0 that
1849 represents a composition rule.
1852 char emacs_mule_bytes
[256];
1855 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1856 Check if a text is encoded in `emacs-mule'. If it is, return 1,
1860 detect_coding_emacs_mule (struct coding_system
*coding
,
1861 struct coding_detection_info
*detect_info
)
1863 const unsigned char *src
= coding
->source
, *src_base
;
1864 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1865 int multibytep
= coding
->src_multibyte
;
1866 int consumed_chars
= 0;
1870 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1871 /* A coding system of this category is always ASCII compatible. */
1872 src
+= coding
->head_ascii
;
1882 /* Perhaps the start of composite character. We simply skip
1883 it because analyzing it is too heavy for detecting. But,
1884 at least, we check that the composite character
1885 constitutes of more than 4 bytes. */
1886 const unsigned char *src_start
;
1896 if (src
- src_start
<= 4)
1898 found
= CATEGORY_MASK_EMACS_MULE
;
1906 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1911 int more_bytes
= emacs_mule_bytes
[c
] - 1;
1913 while (more_bytes
> 0)
1918 src
--; /* Unread the last byte. */
1923 if (more_bytes
!= 0)
1925 found
= CATEGORY_MASK_EMACS_MULE
;
1928 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1932 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1934 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1937 detect_info
->found
|= found
;
1942 /* Parse emacs-mule multibyte sequence at SRC and return the decoded
1943 character. If CMP_STATUS indicates that we must expect MSEQ or
1944 RULE described above, decode it and return the negative value of
1945 the decoded character or rule. If an invalid byte is found, return
1946 -1. If SRC is too short, return -2. */
1949 emacs_mule_char (struct coding_system
*coding
, const unsigned char *src
,
1950 int *nbytes
, int *nchars
, int *id
,
1951 struct composition_status
*cmp_status
)
1953 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1954 const unsigned char *src_base
= src
;
1955 int multibytep
= coding
->src_multibyte
;
1959 int consumed_chars
= 0;
1966 charset_ID
= emacs_mule_charset
[0];
1972 if (cmp_status
->state
!= COMPOSING_NO
1973 && cmp_status
->old_form
)
1975 if (cmp_status
->state
== COMPOSING_CHAR
)
1990 *nbytes
= src
- src_base
;
1991 *nchars
= consumed_chars
;
1999 switch (emacs_mule_bytes
[c
])
2002 if ((charset_ID
= emacs_mule_charset
[c
]) < 0)
2011 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
2012 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
2015 if (c
< 0xA0 || (charset_ID
= emacs_mule_charset
[c
]) < 0)
2024 if ((charset_ID
= emacs_mule_charset
[c
]) < 0)
2029 code
= (c
& 0x7F) << 8;
2039 if (c
< 0 || (charset_ID
= emacs_mule_charset
[c
]) < 0)
2044 code
= (c
& 0x7F) << 8;
2053 charset_ID
= ASCII_BYTE_P (code
) ? charset_ascii
: charset_eight_bit
;
2059 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
2060 CHARSET_FROM_ID (charset_ID
), code
, c
);
2064 *nbytes
= src
- src_base
;
2065 *nchars
= consumed_chars
;
2068 return (mseq_found
? -c
: c
);
2078 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2080 /* Handle these composition sequence ('|': the end of header elements,
2081 BYTES and CHARS >= 0xA0):
2083 (1) relative composition: 0x80 0xF2 BYTES CHARS | CHAR ...
2084 (2) altchar composition: 0x80 0xF4 BYTES CHARS | ALT ... ALT CHAR ...
2085 (3) alt&rule composition: 0x80 0xF5 BYTES CHARS | ALT RULE ... ALT CHAR ...
2089 (4) relative composition: 0x80 | MSEQ ... MSEQ
2090 (5) rulebase composition: 0x80 0xFF | MSEQ MRULE ... MSEQ
2092 When the starter 0x80 and the following header elements are found,
2093 this annotation header is produced.
2095 [ -LENGTH(==-5) CODING_ANNOTATE_COMPOSITION_MASK NCHARS NBYTES METHOD ]
2097 NCHARS is CHARS - 0xA0 for (1), (2), (3), and 0 for (4), (5).
2098 NBYTES is BYTES - 0xA0 for (1), (2), (3), and 0 for (4), (5).
2100 Then, upon reading the following elements, these codes are produced
2101 until the composition end is found:
2104 (2) ALT ... ALT CHAR ... CHAR
2105 (3) ALT -2 DECODED-RULE ALT -2 DECODED-RULE ... ALT CHAR ... CHAR
2107 (5) CHAR -2 DECODED-RULE CHAR -2 DECODED-RULE ... CHAR
2109 When the composition end is found, LENGTH and NCHARS in the
2110 annotation header is updated as below:
2112 (1) LENGTH: unchanged, NCHARS: unchanged
2113 (2) LENGTH: length of the whole sequence minus NCHARS, NCHARS: unchanged
2114 (3) LENGTH: length of the whole sequence minus NCHARS, NCHARS: unchanged
2115 (4) LENGTH: unchanged, NCHARS: number of CHARs
2116 (5) LENGTH: unchanged, NCHARS: number of CHARs
2118 If an error is found while composing, the annotation header is
2119 changed to the original composition header (plus filler -1s) as
2122 (1),(2),(3) [ 0x80 0xF2+METHOD BYTES CHARS -1 ]
2123 (5) [ 0x80 0xFF -1 -1- -1 ]
2125 and the sequence [ -2 DECODED-RULE ] is changed to the original
2126 byte sequence as below:
2127 o the original byte sequence is B: [ B -1 ]
2128 o the original byte sequence is B1 B2: [ B1 B2 ]
2130 Most of the routines are implemented by macros because many
2131 variables and labels in the caller decode_coding_emacs_mule must be
2132 accessible, and they are usually called just once (thus doesn't
2133 increase the size of compiled object). */
2135 /* Decode a composition rule represented by C as a component of
2136 composition sequence of Emacs 20 style. Set RULE to the decoded
2139 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(c, rule) \
2144 if (c < 0 || c >= 81) \
2145 goto invalid_code; \
2146 gref = c / 9, nref = c % 9; \
2147 if (gref == 4) gref = 10; \
2148 if (nref == 4) nref = 10; \
2149 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
2153 /* Decode a composition rule represented by C and the following byte
2154 at SRC as a component of composition sequence of Emacs 21 style.
2155 Set RULE to the decoded rule. */
2157 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(c, rule) \
2162 if (gref < 0 || gref >= 81) \
2163 goto invalid_code; \
2164 ONE_MORE_BYTE (c); \
2166 if (nref < 0 || nref >= 81) \
2167 goto invalid_code; \
2168 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
2172 /* Start of Emacs 21 style format. The first three bytes at SRC are
2173 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is the
2174 byte length of this composition information, CHARS is the number of
2175 characters composed by this composition. */
2177 #define DECODE_EMACS_MULE_21_COMPOSITION() \
2179 enum composition_method method = c - 0xF2; \
2180 int nbytes, nchars; \
2182 ONE_MORE_BYTE (c); \
2184 goto invalid_code; \
2185 nbytes = c - 0xA0; \
2186 if (nbytes < 3 || (method == COMPOSITION_RELATIVE && nbytes != 4)) \
2187 goto invalid_code; \
2188 ONE_MORE_BYTE (c); \
2189 nchars = c - 0xA0; \
2190 if (nchars <= 0 || nchars >= MAX_COMPOSITION_COMPONENTS) \
2191 goto invalid_code; \
2192 cmp_status->old_form = 0; \
2193 cmp_status->method = method; \
2194 if (method == COMPOSITION_RELATIVE) \
2195 cmp_status->state = COMPOSING_CHAR; \
2197 cmp_status->state = COMPOSING_COMPONENT_CHAR; \
2198 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2199 cmp_status->nchars = nchars; \
2200 cmp_status->ncomps = nbytes - 4; \
2201 ADD_COMPOSITION_DATA (charbuf, nchars, nbytes, method); \
2205 /* Start of Emacs 20 style format for relative composition. */
2207 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION() \
2209 cmp_status->old_form = 1; \
2210 cmp_status->method = COMPOSITION_RELATIVE; \
2211 cmp_status->state = COMPOSING_CHAR; \
2212 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2213 cmp_status->nchars = cmp_status->ncomps = 0; \
2214 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
2218 /* Start of Emacs 20 style format for rule-base composition. */
2220 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION() \
2222 cmp_status->old_form = 1; \
2223 cmp_status->method = COMPOSITION_WITH_RULE; \
2224 cmp_status->state = COMPOSING_CHAR; \
2225 cmp_status->length = MAX_ANNOTATION_LENGTH; \
2226 cmp_status->nchars = cmp_status->ncomps = 0; \
2227 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
2231 #define DECODE_EMACS_MULE_COMPOSITION_START() \
2233 const unsigned char *current_src = src; \
2235 ONE_MORE_BYTE (c); \
2237 goto invalid_code; \
2238 if (c - 0xF2 >= COMPOSITION_RELATIVE \
2239 && c - 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS) \
2240 DECODE_EMACS_MULE_21_COMPOSITION (); \
2241 else if (c < 0xA0) \
2242 goto invalid_code; \
2243 else if (c < 0xC0) \
2245 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (); \
2246 /* Re-read C as a composition component. */ \
2247 src = current_src; \
2249 else if (c == 0xFF) \
2250 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (); \
2252 goto invalid_code; \
2255 #define EMACS_MULE_COMPOSITION_END() \
2257 int idx = - cmp_status->length; \
2259 if (cmp_status->old_form) \
2260 charbuf[idx + 2] = cmp_status->nchars; \
2261 else if (cmp_status->method > COMPOSITION_RELATIVE) \
2262 charbuf[idx] = charbuf[idx + 2] - cmp_status->length; \
2263 cmp_status->state = COMPOSING_NO; \
2268 emacs_mule_finish_composition (int *charbuf
,
2269 struct composition_status
*cmp_status
)
2271 int idx
= - cmp_status
->length
;
2274 if (cmp_status
->old_form
&& cmp_status
->nchars
> 0)
2276 charbuf
[idx
+ 2] = cmp_status
->nchars
;
2278 if (cmp_status
->method
== COMPOSITION_WITH_RULE
2279 && cmp_status
->state
== COMPOSING_CHAR
)
2281 /* The last rule was invalid. */
2282 int rule
= charbuf
[-1] + 0xA0;
2284 charbuf
[-2] = BYTE8_TO_CHAR (rule
);
2291 charbuf
[idx
++] = BYTE8_TO_CHAR (0x80);
2293 if (cmp_status
->method
== COMPOSITION_WITH_RULE
)
2295 charbuf
[idx
++] = BYTE8_TO_CHAR (0xFF);
2296 charbuf
[idx
++] = -3;
2302 int nchars
= charbuf
[idx
+ 1] + 0xA0;
2303 int nbytes
= charbuf
[idx
+ 2] + 0xA0;
2305 charbuf
[idx
++] = BYTE8_TO_CHAR (0xF2 + cmp_status
->method
);
2306 charbuf
[idx
++] = BYTE8_TO_CHAR (nbytes
);
2307 charbuf
[idx
++] = BYTE8_TO_CHAR (nchars
);
2308 charbuf
[idx
++] = -1;
2312 cmp_status
->state
= COMPOSING_NO
;
2316 #define EMACS_MULE_MAYBE_FINISH_COMPOSITION() \
2318 if (cmp_status->state != COMPOSING_NO) \
2319 char_offset += emacs_mule_finish_composition (charbuf, cmp_status); \
2324 decode_coding_emacs_mule (struct coding_system
*coding
)
2326 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2327 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2328 const unsigned char *src_base
;
2329 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2330 /* We may produce two annotations (charset and composition) in one
2331 loop and one more charset annotation at the end. */
2333 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 3);
2334 int consumed_chars
= 0, consumed_chars_base
;
2335 int multibytep
= coding
->src_multibyte
;
2336 int char_offset
= coding
->produced_char
;
2337 int last_offset
= char_offset
;
2338 int last_id
= charset_ascii
;
2340 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
2341 int byte_after_cr
= -1;
2342 struct composition_status
*cmp_status
= &coding
->spec
.emacs_mule
.cmp_status
;
2344 if (cmp_status
->state
!= COMPOSING_NO
)
2348 for (i
= 0; i
< cmp_status
->length
; i
++)
2349 *charbuf
++ = cmp_status
->carryover
[i
];
2350 coding
->annotated
= 1;
2355 int c
, id
IF_LINT (= 0);
2358 consumed_chars_base
= consumed_chars
;
2360 if (charbuf
>= charbuf_end
)
2362 if (byte_after_cr
>= 0)
2367 if (byte_after_cr
>= 0)
2368 c
= byte_after_cr
, byte_after_cr
= -1;
2372 if (c
< 0 || c
== 0x80)
2374 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2381 DECODE_EMACS_MULE_COMPOSITION_START ();
2387 if (eol_dos
&& c
== '\r')
2388 ONE_MORE_BYTE (byte_after_cr
);
2390 if (cmp_status
->state
!= COMPOSING_NO
)
2392 if (cmp_status
->old_form
)
2393 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2394 else if (cmp_status
->state
>= COMPOSING_COMPONENT_CHAR
)
2395 cmp_status
->ncomps
--;
2400 int nchars
IF_LINT (= 0), nbytes
IF_LINT (= 0);
2401 /* emacs_mule_char can load a charset map from a file, which
2402 allocates a large structure and might cause buffer text
2403 to be relocated as result. Thus, we need to remember the
2404 original pointer to buffer text, and fix up all related
2405 pointers after the call. */
2406 const unsigned char *orig
= coding
->source
;
2409 c
= emacs_mule_char (coding
, src_base
, &nbytes
, &nchars
, &id
,
2411 offset
= coding
->source
- orig
;
2425 src
= src_base
+ nbytes
;
2426 consumed_chars
= consumed_chars_base
+ nchars
;
2427 if (cmp_status
->state
>= COMPOSING_COMPONENT_CHAR
)
2428 cmp_status
->ncomps
-= nchars
;
2431 /* Now if C >= 0, we found a normally encoded character, if C <
2432 0, we found an old-style composition component character or
2435 if (cmp_status
->state
== COMPOSING_NO
)
2439 if (last_id
!= charset_ascii
)
2440 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
,
2443 last_offset
= char_offset
;
2448 else if (cmp_status
->state
== COMPOSING_CHAR
)
2450 if (cmp_status
->old_form
)
2454 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2461 cmp_status
->nchars
++;
2462 cmp_status
->length
++;
2463 if (cmp_status
->nchars
== MAX_COMPOSITION_COMPONENTS
)
2464 EMACS_MULE_COMPOSITION_END ();
2465 else if (cmp_status
->method
== COMPOSITION_WITH_RULE
)
2466 cmp_status
->state
= COMPOSING_RULE
;
2472 cmp_status
->length
++;
2473 cmp_status
->nchars
--;
2474 if (cmp_status
->nchars
== 0)
2475 EMACS_MULE_COMPOSITION_END ();
2478 else if (cmp_status
->state
== COMPOSING_RULE
)
2484 EMACS_MULE_COMPOSITION_END ();
2491 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (c
, rule
);
2496 cmp_status
->length
+= 2;
2497 cmp_status
->state
= COMPOSING_CHAR
;
2500 else if (cmp_status
->state
== COMPOSING_COMPONENT_CHAR
)
2503 cmp_status
->length
++;
2504 if (cmp_status
->ncomps
== 0)
2505 cmp_status
->state
= COMPOSING_CHAR
;
2506 else if (cmp_status
->ncomps
> 0)
2508 if (cmp_status
->method
== COMPOSITION_WITH_RULE_ALTCHARS
)
2509 cmp_status
->state
= COMPOSING_COMPONENT_RULE
;
2512 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2514 else /* COMPOSING_COMPONENT_RULE */
2518 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (c
, rule
);
2523 cmp_status
->length
+= 2;
2524 cmp_status
->ncomps
--;
2525 if (cmp_status
->ncomps
> 0)
2526 cmp_status
->state
= COMPOSING_COMPONENT_CHAR
;
2528 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2533 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2535 consumed_chars
= consumed_chars_base
;
2537 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2543 if (cmp_status
->state
!= COMPOSING_NO
)
2545 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
2546 EMACS_MULE_MAYBE_FINISH_COMPOSITION ();
2551 charbuf
-= cmp_status
->length
;
2552 for (i
= 0; i
< cmp_status
->length
; i
++)
2553 cmp_status
->carryover
[i
] = charbuf
[i
];
2556 if (last_id
!= charset_ascii
)
2557 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2558 coding
->consumed_char
+= consumed_chars_base
;
2559 coding
->consumed
= src_base
- coding
->source
;
2560 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2564 #define EMACS_MULE_LEADING_CODES(id, codes) \
2567 codes[0] = id, codes[1] = 0; \
2568 else if (id < 0xE0) \
2569 codes[0] = 0x9A, codes[1] = id; \
2570 else if (id < 0xF0) \
2571 codes[0] = 0x9B, codes[1] = id; \
2572 else if (id < 0xF5) \
2573 codes[0] = 0x9C, codes[1] = id; \
2575 codes[0] = 0x9D, codes[1] = id; \
2580 encode_coding_emacs_mule (struct coding_system
*coding
)
2582 int multibytep
= coding
->dst_multibyte
;
2583 int *charbuf
= coding
->charbuf
;
2584 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2585 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2586 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2588 int produced_chars
= 0;
2589 Lisp_Object attrs
, charset_list
;
2591 int preferred_charset_id
= -1;
2593 CODING_GET_INFO (coding
, attrs
, charset_list
);
2594 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2596 CODING_ATTR_CHARSET_LIST (attrs
)
2597 = charset_list
= Vemacs_mule_charset_list
;
2600 while (charbuf
< charbuf_end
)
2602 ASSURE_DESTINATION (safe_room
);
2607 /* Handle an annotation. */
2610 case CODING_ANNOTATE_COMPOSITION_MASK
:
2611 /* Not yet implemented. */
2613 case CODING_ANNOTATE_CHARSET_MASK
:
2614 preferred_charset_id
= charbuf
[3];
2615 if (preferred_charset_id
>= 0
2616 && NILP (Fmemq (make_number (preferred_charset_id
),
2618 preferred_charset_id
= -1;
2627 if (ASCII_CHAR_P (c
))
2628 EMIT_ONE_ASCII_BYTE (c
);
2629 else if (CHAR_BYTE8_P (c
))
2631 c
= CHAR_TO_BYTE8 (c
);
2636 struct charset
*charset
;
2640 unsigned char leading_codes
[2];
2642 if (preferred_charset_id
>= 0)
2644 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2645 if (CHAR_CHARSET_P (c
, charset
))
2646 code
= ENCODE_CHAR (charset
, c
);
2648 charset
= char_charset (c
, charset_list
, &code
);
2651 charset
= char_charset (c
, charset_list
, &code
);
2654 c
= coding
->default_char
;
2655 if (ASCII_CHAR_P (c
))
2657 EMIT_ONE_ASCII_BYTE (c
);
2660 charset
= char_charset (c
, charset_list
, &code
);
2662 dimension
= CHARSET_DIMENSION (charset
);
2663 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2664 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2665 EMIT_ONE_BYTE (leading_codes
[0]);
2666 if (leading_codes
[1])
2667 EMIT_ONE_BYTE (leading_codes
[1]);
2669 EMIT_ONE_BYTE (code
| 0x80);
2673 EMIT_ONE_BYTE (code
>> 8);
2674 EMIT_ONE_BYTE (code
& 0xFF);
2678 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2679 coding
->produced_char
+= produced_chars
;
2680 coding
->produced
= dst
- coding
->destination
;
2685 /*** 7. ISO2022 handlers ***/
2687 /* The following note describes the coding system ISO2022 briefly.
2688 Since the intention of this note is to help understand the
2689 functions in this file, some parts are NOT ACCURATE or are OVERLY
2690 SIMPLIFIED. For thorough understanding, please refer to the
2691 original document of ISO2022. This is equivalent to the standard
2692 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2694 ISO2022 provides many mechanisms to encode several character sets
2695 in 7-bit and 8-bit environments. For 7-bit environments, all text
2696 is encoded using bytes less than 128. This may make the encoded
2697 text a little bit longer, but the text passes more easily through
2698 several types of gateway, some of which strip off the MSB (Most
2701 There are two kinds of character sets: control character sets and
2702 graphic character sets. The former contain control characters such
2703 as `newline' and `escape' to provide control functions (control
2704 functions are also provided by escape sequences). The latter
2705 contain graphic characters such as 'A' and '-'. Emacs recognizes
2706 two control character sets and many graphic character sets.
2708 Graphic character sets are classified into one of the following
2709 four classes, according to the number of bytes (DIMENSION) and
2710 number of characters in one dimension (CHARS) of the set:
2711 - DIMENSION1_CHARS94
2712 - DIMENSION1_CHARS96
2713 - DIMENSION2_CHARS94
2714 - DIMENSION2_CHARS96
2716 In addition, each character set is assigned an identification tag,
2717 unique for each set, called the "final character" (denoted as <F>
2718 hereafter). The <F> of each character set is decided by ECMA(*)
2719 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2720 (0x30..0x3F are for private use only).
2722 Note (*): ECMA = European Computer Manufacturers Association
2724 Here are examples of graphic character sets [NAME(<F>)]:
2725 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2726 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2727 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2728 o DIMENSION2_CHARS96 -- none for the moment
2730 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2731 C0 [0x00..0x1F] -- control character plane 0
2732 GL [0x20..0x7F] -- graphic character plane 0
2733 C1 [0x80..0x9F] -- control character plane 1
2734 GR [0xA0..0xFF] -- graphic character plane 1
2736 A control character set is directly designated and invoked to C0 or
2737 C1 by an escape sequence. The most common case is that:
2738 - ISO646's control character set is designated/invoked to C0, and
2739 - ISO6429's control character set is designated/invoked to C1,
2740 and usually these designations/invocations are omitted in encoded
2741 text. In a 7-bit environment, only C0 can be used, and a control
2742 character for C1 is encoded by an appropriate escape sequence to
2743 fit into the environment. All control characters for C1 are
2744 defined to have corresponding escape sequences.
2746 A graphic character set is at first designated to one of four
2747 graphic registers (G0 through G3), then these graphic registers are
2748 invoked to GL or GR. These designations and invocations can be
2749 done independently. The most common case is that G0 is invoked to
2750 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2751 these invocations and designations are omitted in encoded text.
2752 In a 7-bit environment, only GL can be used.
2754 When a graphic character set of CHARS94 is invoked to GL, codes
2755 0x20 and 0x7F of the GL area work as control characters SPACE and
2756 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2759 There are two ways of invocation: locking-shift and single-shift.
2760 With locking-shift, the invocation lasts until the next different
2761 invocation, whereas with single-shift, the invocation affects the
2762 following character only and doesn't affect the locking-shift
2763 state. Invocations are done by the following control characters or
2766 ----------------------------------------------------------------------
2767 abbrev function cntrl escape seq description
2768 ----------------------------------------------------------------------
2769 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2770 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2771 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2772 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2773 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2774 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2775 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2776 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2777 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2778 ----------------------------------------------------------------------
2779 (*) These are not used by any known coding system.
2781 Control characters for these functions are defined by macros
2782 ISO_CODE_XXX in `coding.h'.
2784 Designations are done by the following escape sequences:
2785 ----------------------------------------------------------------------
2786 escape sequence description
2787 ----------------------------------------------------------------------
2788 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2789 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2790 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2791 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2792 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2793 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2794 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2795 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2796 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2797 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2798 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2799 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2800 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2801 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2802 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2803 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2804 ----------------------------------------------------------------------
2806 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2807 of dimension 1, chars 94, and final character <F>, etc...
2809 Note (*): Although these designations are not allowed in ISO2022,
2810 Emacs accepts them on decoding, and produces them on encoding
2811 CHARS96 character sets in a coding system which is characterized as
2812 7-bit environment, non-locking-shift, and non-single-shift.
2814 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2815 '(' must be omitted. We refer to this as "short-form" hereafter.
2817 Now you may notice that there are a lot of ways of encoding the
2818 same multilingual text in ISO2022. Actually, there exist many
2819 coding systems such as Compound Text (used in X11's inter client
2820 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2821 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2822 localized platforms), and all of these are variants of ISO2022.
2824 In addition to the above, Emacs handles two more kinds of escape
2825 sequences: ISO6429's direction specification and Emacs' private
2826 sequence for specifying character composition.
2828 ISO6429's direction specification takes the following form:
2829 o CSI ']' -- end of the current direction
2830 o CSI '0' ']' -- end of the current direction
2831 o CSI '1' ']' -- start of left-to-right text
2832 o CSI '2' ']' -- start of right-to-left text
2833 The control character CSI (0x9B: control sequence introducer) is
2834 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2836 Character composition specification takes the following form:
2837 o ESC '0' -- start relative composition
2838 o ESC '1' -- end composition
2839 o ESC '2' -- start rule-base composition (*)
2840 o ESC '3' -- start relative composition with alternate chars (**)
2841 o ESC '4' -- start rule-base composition with alternate chars (**)
2842 Since these are not standard escape sequences of any ISO standard,
2843 the use of them with these meanings is restricted to Emacs only.
2845 (*) This form is used only in Emacs 20.7 and older versions,
2846 but newer versions can safely decode it.
2847 (**) This form is used only in Emacs 21.1 and newer versions,
2848 and older versions can't decode it.
2850 Here's a list of example usages of these composition escape
2851 sequences (categorized by `enum composition_method').
2853 COMPOSITION_RELATIVE:
2854 ESC 0 CHAR [ CHAR ] ESC 1
2855 COMPOSITION_WITH_RULE:
2856 ESC 2 CHAR [ RULE CHAR ] ESC 1
2857 COMPOSITION_WITH_ALTCHARS:
2858 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2859 COMPOSITION_WITH_RULE_ALTCHARS:
2860 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2862 enum iso_code_class_type iso_code_class
[256];
2864 #define SAFE_CHARSET_P(coding, id) \
2865 ((id) <= (coding)->max_charset_id \
2866 && (coding)->safe_charsets[id] != 255)
2869 setup_iso_safe_charsets (Lisp_Object attrs
)
2871 Lisp_Object charset_list
, safe_charsets
;
2872 Lisp_Object request
;
2873 Lisp_Object reg_usage
;
2876 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2879 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2880 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2881 && ! EQ (charset_list
, Viso_2022_charset_list
))
2883 CODING_ATTR_CHARSET_LIST (attrs
)
2884 = charset_list
= Viso_2022_charset_list
;
2885 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2888 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2892 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2894 int id
= XINT (XCAR (tail
));
2895 if (max_charset_id
< id
)
2896 max_charset_id
= id
;
2899 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
2900 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
2901 request
= AREF (attrs
, coding_attr_iso_request
);
2902 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2903 reg94
= XINT (XCAR (reg_usage
));
2904 reg96
= XINT (XCDR (reg_usage
));
2906 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2910 struct charset
*charset
;
2913 charset
= CHARSET_FROM_ID (XINT (id
));
2914 reg
= Fcdr (Fassq (id
, request
));
2916 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2917 else if (charset
->iso_chars_96
)
2920 SSET (safe_charsets
, XINT (id
), reg96
);
2925 SSET (safe_charsets
, XINT (id
), reg94
);
2928 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2932 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2933 Check if a text is encoded in one of ISO-2022 based coding systems.
2934 If it is, return 1, else return 0. */
2937 detect_coding_iso_2022 (struct coding_system
*coding
,
2938 struct coding_detection_info
*detect_info
)
2940 const unsigned char *src
= coding
->source
, *src_base
= src
;
2941 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2942 int multibytep
= coding
->src_multibyte
;
2943 int single_shifting
= 0;
2946 int consumed_chars
= 0;
2950 int composition_count
= -1;
2952 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2954 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2956 struct coding_system
*this = &(coding_categories
[i
]);
2957 Lisp_Object attrs
, val
;
2961 attrs
= CODING_ID_ATTRS (this->id
);
2962 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2963 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Viso_2022_charset_list
))
2964 setup_iso_safe_charsets (attrs
);
2965 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2966 this->max_charset_id
= SCHARS (val
) - 1;
2967 this->safe_charsets
= SDATA (val
);
2970 /* A coding system of this category is always ASCII compatible. */
2971 src
+= coding
->head_ascii
;
2973 while (rejected
!= CATEGORY_MASK_ISO
)
2980 if (inhibit_iso_escape_detection
)
2982 single_shifting
= 0;
2984 if (c
== 'N' || c
== 'O')
2986 /* ESC <Fe> for SS2 or SS3. */
2987 single_shifting
= 1;
2988 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2992 /* End of composition. */
2993 if (composition_count
< 0
2994 || composition_count
> MAX_COMPOSITION_COMPONENTS
)
2997 composition_count
= -1;
2998 found
|= CATEGORY_MASK_ISO
;
3000 else if (c
>= '0' && c
<= '4')
3002 /* ESC <Fp> for start/end composition. */
3003 composition_count
= 0;
3007 if (c
>= '(' && c
<= '/')
3009 /* Designation sequence for a charset of dimension 1. */
3011 if (c1
< ' ' || c1
>= 0x80
3012 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
3013 /* Invalid designation sequence. Just ignore. */
3018 /* Designation sequence for a charset of dimension 2. */
3020 if (c
>= '@' && c
<= 'B')
3021 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
3022 id
= iso_charset_table
[1][0][c
];
3023 else if (c
>= '(' && c
<= '/')
3026 if (c1
< ' ' || c1
>= 0x80
3027 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
3028 /* Invalid designation sequence. Just ignore. */
3032 /* Invalid designation sequence. Just ignore it. */
3037 /* Invalid escape sequence. Just ignore it. */
3041 /* We found a valid designation sequence for CHARSET. */
3042 rejected
|= CATEGORY_MASK_ISO_8BIT
;
3043 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
3045 found
|= CATEGORY_MASK_ISO_7
;
3047 rejected
|= CATEGORY_MASK_ISO_7
;
3048 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
3050 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
3052 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
3053 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
3055 found
|= CATEGORY_MASK_ISO_7_ELSE
;
3057 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
3058 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
3060 found
|= CATEGORY_MASK_ISO_8_ELSE
;
3062 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
3068 /* Locking shift out/in. */
3069 if (inhibit_iso_escape_detection
)
3071 single_shifting
= 0;
3072 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
3076 /* Control sequence introducer. */
3077 single_shifting
= 0;
3078 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
3079 found
|= CATEGORY_MASK_ISO_8_ELSE
;
3080 goto check_extra_latin
;
3085 if (inhibit_iso_escape_detection
)
3087 single_shifting
= 0;
3088 rejected
|= CATEGORY_MASK_ISO_7BIT
;
3089 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
3090 & CODING_ISO_FLAG_SINGLE_SHIFT
)
3092 found
|= CATEGORY_MASK_ISO_8_1
;
3093 single_shifting
= 1;
3095 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
3096 & CODING_ISO_FLAG_SINGLE_SHIFT
)
3098 found
|= CATEGORY_MASK_ISO_8_2
;
3099 single_shifting
= 1;
3101 if (single_shifting
)
3104 if (! VECTORP (Vlatin_extra_code_table
)
3105 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
3107 rejected
= CATEGORY_MASK_ISO
;
3110 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
3111 & CODING_ISO_FLAG_LATIN_EXTRA
)
3112 found
|= CATEGORY_MASK_ISO_8_1
;
3114 rejected
|= CATEGORY_MASK_ISO_8_1
;
3115 rejected
|= CATEGORY_MASK_ISO_8_2
;
3123 if (composition_count
>= 0)
3124 composition_count
++;
3125 single_shifting
= 0;
3130 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
3131 found
|= CATEGORY_MASK_ISO_8_1
;
3132 /* Check the length of succeeding codes of the range
3133 0xA0..0FF. If the byte length is even, we include
3134 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
3135 only when we are not single shifting. */
3136 if (! single_shifting
3137 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
3140 while (src
< src_end
)
3152 if (len
& 1 && src
< src_end
)
3154 rejected
|= CATEGORY_MASK_ISO_8_2
;
3155 if (composition_count
>= 0)
3156 composition_count
+= len
;
3160 found
|= CATEGORY_MASK_ISO_8_2
;
3161 if (composition_count
>= 0)
3162 composition_count
+= len
/ 2;
3169 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
3173 detect_info
->rejected
|= rejected
;
3174 detect_info
->found
|= (found
& ~rejected
);
3179 /* Set designation state into CODING. Set CHARS_96 to -1 if the
3180 escape sequence should be kept. */
3181 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
3185 if (final < '0' || final >= 128 \
3186 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
3187 || !SAFE_CHARSET_P (coding, id)) \
3189 CODING_ISO_DESIGNATION (coding, reg) = -2; \
3193 prev = CODING_ISO_DESIGNATION (coding, reg); \
3194 if (id == charset_jisx0201_roman) \
3196 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3197 id = charset_ascii; \
3199 else if (id == charset_jisx0208_1978) \
3201 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3202 id = charset_jisx0208; \
3204 CODING_ISO_DESIGNATION (coding, reg) = id; \
3205 /* If there was an invalid designation to REG previously, and this \
3206 designation is ASCII to REG, we should keep this designation \
3208 if (prev == -2 && id == charset_ascii) \
3213 /* Handle these composition sequence (ALT: alternate char):
3215 (1) relative composition: ESC 0 CHAR ... ESC 1
3216 (2) rulebase composition: ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
3217 (3) altchar composition: ESC 3 ALT ... ALT ESC 0 CHAR ... ESC 1
3218 (4) alt&rule composition: ESC 4 ALT RULE ... ALT ESC 0 CHAR ... ESC 1
3220 When the start sequence (ESC 0/2/3/4) is found, this annotation
3223 [ -LENGTH(==-5) CODING_ANNOTATE_COMPOSITION_MASK NCHARS(==0) 0 METHOD ]
3225 Then, upon reading CHAR or RULE (one or two bytes), these codes are
3226 produced until the end sequence (ESC 1) is found:
3229 (2) CHAR -2 DECODED-RULE CHAR -2 DECODED-RULE ... CHAR
3230 (3) ALT ... ALT -1 -1 CHAR ... CHAR
3231 (4) ALT -2 DECODED-RULE ALT -2 DECODED-RULE ... ALT -1 -1 CHAR ... CHAR
3233 When the end sequence (ESC 1) is found, LENGTH and NCHARS in the
3234 annotation header is updated as below:
3236 (1) LENGTH: unchanged, NCHARS: number of CHARs
3237 (2) LENGTH: unchanged, NCHARS: number of CHARs
3238 (3) LENGTH: += number of ALTs + 2, NCHARS: number of CHARs
3239 (4) LENGTH: += number of ALTs * 3, NCHARS: number of CHARs
3241 If an error is found while composing, the annotation header is
3244 [ ESC '0'/'2'/'3'/'4' -2 0 ]
3246 and the sequence [ -2 DECODED-RULE ] is changed to the original
3247 byte sequence as below:
3248 o the original byte sequence is B: [ B -1 ]
3249 o the original byte sequence is B1 B2: [ B1 B2 ]
3250 and the sequence [ -1 -1 ] is changed to the original byte
3255 /* Decode a composition rule C1 and maybe one more byte from the
3256 source, and set RULE to the encoded composition rule. If the rule
3257 is invalid, goto invalid_code. */
3259 #define DECODE_COMPOSITION_RULE(rule) \
3263 goto invalid_code; \
3264 if (rule < 81) /* old format (before ver.21) */ \
3266 int gref = (rule) / 9; \
3267 int nref = (rule) % 9; \
3268 if (gref == 4) gref = 10; \
3269 if (nref == 4) nref = 10; \
3270 rule = COMPOSITION_ENCODE_RULE (gref, nref); \
3272 else /* new format (after ver.21) */ \
3276 ONE_MORE_BYTE (b); \
3277 if (! COMPOSITION_ENCODE_RULE_VALID (rule - 81, b - 32)) \
3278 goto invalid_code; \
3279 rule = COMPOSITION_ENCODE_RULE (rule - 81, b - 32); \
3280 rule += 0x100; /* Distinguish it from the old format. */ \
3284 #define ENCODE_COMPOSITION_RULE(rule) \
3286 int gref = (rule % 0x100) / 12, nref = (rule % 0x100) % 12; \
3288 if (rule < 0x100) /* old format */ \
3290 if (gref == 10) gref = 4; \
3291 if (nref == 10) nref = 4; \
3292 charbuf[idx] = 32 + gref * 9 + nref; \
3293 charbuf[idx + 1] = -1; \
3296 else /* new format */ \
3298 charbuf[idx] = 32 + 81 + gref; \
3299 charbuf[idx + 1] = 32 + nref; \
3304 /* Finish the current composition as invalid. */
3306 static int finish_composition (int *, struct composition_status
*);
3309 finish_composition (int *charbuf
, struct composition_status
*cmp_status
)
3311 int idx
= - cmp_status
->length
;
3314 /* Recover the original ESC sequence */
3315 charbuf
[idx
++] = ISO_CODE_ESC
;
3316 charbuf
[idx
++] = (cmp_status
->method
== COMPOSITION_RELATIVE
? '0'
3317 : cmp_status
->method
== COMPOSITION_WITH_RULE
? '2'
3318 : cmp_status
->method
== COMPOSITION_WITH_ALTCHARS
? '3'
3319 /* cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS */
3321 charbuf
[idx
++] = -2;
3323 charbuf
[idx
++] = -1;
3324 new_chars
= cmp_status
->nchars
;
3325 if (cmp_status
->method
>= COMPOSITION_WITH_RULE
)
3326 for (; idx
< 0; idx
++)
3328 int elt
= charbuf
[idx
];
3332 ENCODE_COMPOSITION_RULE (charbuf
[idx
+ 1]);
3337 charbuf
[idx
++] = ISO_CODE_ESC
;
3342 cmp_status
->state
= COMPOSING_NO
;
3346 /* If characters are under composition, finish the composition. */
3347 #define MAYBE_FINISH_COMPOSITION() \
3349 if (cmp_status->state != COMPOSING_NO) \
3350 char_offset += finish_composition (charbuf, cmp_status); \
3353 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
3355 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
3356 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
3357 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
3358 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
3360 Produce this annotation sequence now:
3362 [ -LENGTH(==-4) CODING_ANNOTATE_COMPOSITION_MASK NCHARS(==0) METHOD ]
3365 #define DECODE_COMPOSITION_START(c1) \
3368 && ((cmp_status->state == COMPOSING_COMPONENT_CHAR \
3369 && cmp_status->method == COMPOSITION_WITH_ALTCHARS) \
3370 || (cmp_status->state == COMPOSING_COMPONENT_RULE \
3371 && cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS))) \
3375 cmp_status->state = COMPOSING_CHAR; \
3376 cmp_status->length += 2; \
3380 MAYBE_FINISH_COMPOSITION (); \
3381 cmp_status->method = (c1 == '0' ? COMPOSITION_RELATIVE \
3382 : c1 == '2' ? COMPOSITION_WITH_RULE \
3383 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
3384 : COMPOSITION_WITH_RULE_ALTCHARS); \
3386 = (c1 <= '2' ? COMPOSING_CHAR : COMPOSING_COMPONENT_CHAR); \
3387 ADD_COMPOSITION_DATA (charbuf, 0, 0, cmp_status->method); \
3388 cmp_status->length = MAX_ANNOTATION_LENGTH; \
3389 cmp_status->nchars = cmp_status->ncomps = 0; \
3390 coding->annotated = 1; \
3395 /* Handle composition end sequence ESC 1. */
3397 #define DECODE_COMPOSITION_END() \
3399 if (cmp_status->nchars == 0 \
3400 || ((cmp_status->state == COMPOSING_CHAR) \
3401 == (cmp_status->method == COMPOSITION_WITH_RULE))) \
3403 MAYBE_FINISH_COMPOSITION (); \
3404 goto invalid_code; \
3406 if (cmp_status->method == COMPOSITION_WITH_ALTCHARS) \
3407 charbuf[- cmp_status->length] -= cmp_status->ncomps + 2; \
3408 else if (cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS) \
3409 charbuf[- cmp_status->length] -= cmp_status->ncomps * 3; \
3410 charbuf[- cmp_status->length + 2] = cmp_status->nchars; \
3411 char_offset += cmp_status->nchars; \
3412 cmp_status->state = COMPOSING_NO; \
3415 /* Store a composition rule RULE in charbuf, and update cmp_status. */
3417 #define STORE_COMPOSITION_RULE(rule) \
3420 *charbuf++ = rule; \
3421 cmp_status->length += 2; \
3422 cmp_status->state--; \
3425 /* Store a composed char or a component char C in charbuf, and update
3428 #define STORE_COMPOSITION_CHAR(c) \
3431 cmp_status->length++; \
3432 if (cmp_status->state == COMPOSING_CHAR) \
3433 cmp_status->nchars++; \
3435 cmp_status->ncomps++; \
3436 if (cmp_status->method == COMPOSITION_WITH_RULE \
3437 || (cmp_status->method == COMPOSITION_WITH_RULE_ALTCHARS \
3438 && cmp_status->state == COMPOSING_COMPONENT_CHAR)) \
3439 cmp_status->state++; \
3443 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
3446 decode_coding_iso_2022 (struct coding_system
*coding
)
3448 const unsigned char *src
= coding
->source
+ coding
->consumed
;
3449 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3450 const unsigned char *src_base
;
3451 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
3452 /* We may produce two annotations (charset and composition) in one
3453 loop and one more charset annotation at the end. */
3455 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 3);
3456 int consumed_chars
= 0, consumed_chars_base
;
3457 int multibytep
= coding
->src_multibyte
;
3458 /* Charsets invoked to graphic plane 0 and 1 respectively. */
3459 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3460 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3461 int charset_id_2
, charset_id_3
;
3462 struct charset
*charset
;
3464 struct composition_status
*cmp_status
= CODING_ISO_CMP_STATUS (coding
);
3465 Lisp_Object attrs
= CODING_ID_ATTRS (coding
->id
);
3466 int char_offset
= coding
->produced_char
;
3467 int last_offset
= char_offset
;
3468 int last_id
= charset_ascii
;
3470 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
3471 int byte_after_cr
= -1;
3474 setup_iso_safe_charsets (attrs
);
3475 coding
->safe_charsets
= SDATA (CODING_ATTR_SAFE_CHARSETS (attrs
));
3477 if (cmp_status
->state
!= COMPOSING_NO
)
3479 for (i
= 0; i
< cmp_status
->length
; i
++)
3480 *charbuf
++ = cmp_status
->carryover
[i
];
3481 coding
->annotated
= 1;
3489 consumed_chars_base
= consumed_chars
;
3491 if (charbuf
>= charbuf_end
)
3493 if (byte_after_cr
>= 0)
3498 if (byte_after_cr
>= 0)
3499 c1
= byte_after_cr
, byte_after_cr
= -1;
3505 if (CODING_ISO_EXTSEGMENT_LEN (coding
) > 0)
3507 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3509 CODING_ISO_EXTSEGMENT_LEN (coding
)--;
3513 if (CODING_ISO_EMBEDDED_UTF_8 (coding
))
3515 if (c1
== ISO_CODE_ESC
)
3517 if (src
+ 1 >= src_end
)
3518 goto no_more_source
;
3519 *charbuf
++ = ISO_CODE_ESC
;
3521 if (src
[0] == '%' && src
[1] == '@')
3524 consumed_chars
+= 2;
3526 /* We are sure charbuf can contain two more chars. */
3529 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 0;
3534 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3540 if ((cmp_status
->state
== COMPOSING_RULE
3541 || cmp_status
->state
== COMPOSING_COMPONENT_RULE
)
3542 && c1
!= ISO_CODE_ESC
)
3546 DECODE_COMPOSITION_RULE (rule
);
3547 STORE_COMPOSITION_RULE (rule
);
3551 /* We produce at most one character. */
3552 switch (iso_code_class
[c1
])
3554 case ISO_0x20_or_0x7F
:
3555 if (charset_id_0
< 0
3556 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
3557 /* This is SPACE or DEL. */
3558 charset
= CHARSET_FROM_ID (charset_ascii
);
3560 charset
= CHARSET_FROM_ID (charset_id_0
);
3563 case ISO_graphic_plane_0
:
3564 if (charset_id_0
< 0)
3565 charset
= CHARSET_FROM_ID (charset_ascii
);
3567 charset
= CHARSET_FROM_ID (charset_id_0
);
3570 case ISO_0xA0_or_0xFF
:
3571 if (charset_id_1
< 0
3572 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
3573 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
3575 /* This is a graphic character, we fall down ... */
3577 case ISO_graphic_plane_1
:
3578 if (charset_id_1
< 0)
3580 charset
= CHARSET_FROM_ID (charset_id_1
);
3584 if (eol_dos
&& c1
== '\r')
3585 ONE_MORE_BYTE (byte_after_cr
);
3586 MAYBE_FINISH_COMPOSITION ();
3587 charset
= CHARSET_FROM_ID (charset_ascii
);
3594 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3595 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3597 CODING_ISO_INVOCATION (coding
, 0) = 1;
3598 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3602 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3604 CODING_ISO_INVOCATION (coding
, 0) = 0;
3605 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3608 case ISO_single_shift_2_7
:
3609 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
))
3611 case ISO_single_shift_2
:
3612 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3614 /* SS2 is handled as an escape sequence of ESC 'N' */
3616 goto label_escape_sequence
;
3618 case ISO_single_shift_3
:
3619 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3621 /* SS2 is handled as an escape sequence of ESC 'O' */
3623 goto label_escape_sequence
;
3625 case ISO_control_sequence_introducer
:
3626 /* CSI is handled as an escape sequence of ESC '[' ... */
3628 goto label_escape_sequence
;
3632 label_escape_sequence
:
3633 /* Escape sequences handled here are invocation,
3634 designation, direction specification, and character
3635 composition specification. */
3638 case '&': /* revision of following character set */
3640 if (!(c1
>= '@' && c1
<= '~'))
3643 if (c1
!= ISO_CODE_ESC
)
3646 goto label_escape_sequence
;
3648 case '$': /* designation of 2-byte character set */
3649 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3655 if (c1
>= '@' && c1
<= 'B')
3656 { /* designation of JISX0208.1978, GB2312.1980,
3658 reg
= 0, chars96
= 0;
3660 else if (c1
>= 0x28 && c1
<= 0x2B)
3661 { /* designation of DIMENSION2_CHARS94 character set */
3662 reg
= c1
- 0x28, chars96
= 0;
3665 else if (c1
>= 0x2C && c1
<= 0x2F)
3666 { /* designation of DIMENSION2_CHARS96 character set */
3667 reg
= c1
- 0x2C, chars96
= 1;
3672 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3673 /* We must update these variables now. */
3675 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3677 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3683 case 'n': /* invocation of locking-shift-2 */
3684 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3685 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3687 CODING_ISO_INVOCATION (coding
, 0) = 2;
3688 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3691 case 'o': /* invocation of locking-shift-3 */
3692 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3693 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3695 CODING_ISO_INVOCATION (coding
, 0) = 3;
3696 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3699 case 'N': /* invocation of single-shift-2 */
3700 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3701 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3703 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3704 if (charset_id_2
< 0)
3705 charset
= CHARSET_FROM_ID (charset_ascii
);
3707 charset
= CHARSET_FROM_ID (charset_id_2
);
3709 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3713 case 'O': /* invocation of single-shift-3 */
3714 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3715 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3717 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3718 if (charset_id_3
< 0)
3719 charset
= CHARSET_FROM_ID (charset_ascii
);
3721 charset
= CHARSET_FROM_ID (charset_id_3
);
3723 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3727 case '0': case '2': case '3': case '4': /* start composition */
3728 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3730 if (last_id
!= charset_ascii
)
3732 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3733 last_id
= charset_ascii
;
3734 last_offset
= char_offset
;
3736 DECODE_COMPOSITION_START (c1
);
3739 case '1': /* end composition */
3740 if (cmp_status
->state
== COMPOSING_NO
)
3742 DECODE_COMPOSITION_END ();
3745 case '[': /* specification of direction */
3746 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
))
3748 /* For the moment, nested direction is not supported.
3749 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3750 left-to-right, and nonzero means right-to-left. */
3754 case ']': /* end of the current direction */
3755 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3757 case '0': /* end of the current direction */
3758 case '1': /* start of left-to-right direction */
3761 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3766 case '2': /* start of right-to-left direction */
3769 coding
->mode
|= CODING_MODE_DIRECTION
;
3783 /* CTEXT extended segment:
3784 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3785 We keep these bytes as is for the moment.
3786 They may be decoded by post-read-conversion. */
3790 ONE_MORE_BYTE (dim
);
3791 if (dim
< '0' || dim
> '4')
3799 size
= ((M
- 128) * 128) + (L
- 128);
3800 if (charbuf
+ 6 > charbuf_end
)
3802 *charbuf
++ = ISO_CODE_ESC
;
3806 *charbuf
++ = BYTE8_TO_CHAR (M
);
3807 *charbuf
++ = BYTE8_TO_CHAR (L
);
3808 CODING_ISO_EXTSEGMENT_LEN (coding
) = size
;
3812 /* XFree86 extension for embedding UTF-8 in CTEXT:
3813 ESC % G --UTF-8-BYTES-- ESC % @
3814 We keep these bytes as is for the moment.
3815 They may be decoded by post-read-conversion. */
3816 if (charbuf
+ 3 > charbuf_end
)
3818 *charbuf
++ = ISO_CODE_ESC
;
3821 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 1;
3829 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3834 if (c1
>= 0x28 && c1
<= 0x2B)
3835 { /* designation of DIMENSION1_CHARS94 character set */
3836 reg
= c1
- 0x28, chars96
= 0;
3839 else if (c1
>= 0x2C && c1
<= 0x2F)
3840 { /* designation of DIMENSION1_CHARS96 character set */
3841 reg
= c1
- 0x2C, chars96
= 1;
3846 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3847 /* We must update these variables now. */
3849 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3851 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3863 if (cmp_status
->state
== COMPOSING_NO
3864 && charset
->id
!= charset_ascii
3865 && last_id
!= charset
->id
)
3867 if (last_id
!= charset_ascii
)
3868 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3869 last_id
= charset
->id
;
3870 last_offset
= char_offset
;
3873 /* Now we know CHARSET and 1st position code C1 of a character.
3874 Produce a decoded character while getting 2nd and 3rd
3875 position codes C2, C3 if necessary. */
3876 if (CHARSET_DIMENSION (charset
) > 1)
3879 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0)
3880 || ((c1
& 0x80) != (c2
& 0x80)))
3881 /* C2 is not in a valid range. */
3883 if (CHARSET_DIMENSION (charset
) == 2)
3884 c1
= (c1
<< 8) | c2
;
3888 if (c3
< 0x20 || (c3
>= 0x80 && c3
< 0xA0)
3889 || ((c1
& 0x80) != (c3
& 0x80)))
3890 /* C3 is not in a valid range. */
3892 c1
= (c1
<< 16) | (c2
<< 8) | c2
;
3896 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3899 MAYBE_FINISH_COMPOSITION ();
3900 for (; src_base
< src
; src_base
++, char_offset
++)
3902 if (ASCII_BYTE_P (*src_base
))
3903 *charbuf
++ = *src_base
;
3905 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3908 else if (cmp_status
->state
== COMPOSING_NO
)
3913 else if ((cmp_status
->state
== COMPOSING_CHAR
3914 ? cmp_status
->nchars
3915 : cmp_status
->ncomps
)
3916 >= MAX_COMPOSITION_COMPONENTS
)
3918 /* Too long composition. */
3919 MAYBE_FINISH_COMPOSITION ();
3924 STORE_COMPOSITION_CHAR (c
);
3928 MAYBE_FINISH_COMPOSITION ();
3930 consumed_chars
= consumed_chars_base
;
3932 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3942 if (cmp_status
->state
!= COMPOSING_NO
)
3944 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
3945 MAYBE_FINISH_COMPOSITION ();
3948 charbuf
-= cmp_status
->length
;
3949 for (i
= 0; i
< cmp_status
->length
; i
++)
3950 cmp_status
->carryover
[i
] = charbuf
[i
];
3953 else if (last_id
!= charset_ascii
)
3954 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3955 coding
->consumed_char
+= consumed_chars_base
;
3956 coding
->consumed
= src_base
- coding
->source
;
3957 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3961 /* ISO2022 encoding stuff. */
3964 It is not enough to say just "ISO2022" on encoding, we have to
3965 specify more details. In Emacs, each coding system of ISO2022
3966 variant has the following specifications:
3967 1. Initial designation to G0 thru G3.
3968 2. Allows short-form designation?
3969 3. ASCII should be designated to G0 before control characters?
3970 4. ASCII should be designated to G0 at end of line?
3971 5. 7-bit environment or 8-bit environment?
3972 6. Use locking-shift?
3973 7. Use Single-shift?
3974 And the following two are only for Japanese:
3975 8. Use ASCII in place of JIS0201-1976-Roman?
3976 9. Use JISX0208-1983 in place of JISX0208-1978?
3977 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3978 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3982 /* Produce codes (escape sequence) for designating CHARSET to graphic
3983 register REG at DST, and increment DST. If <final-char> of CHARSET is
3984 '@', 'A', or 'B' and the coding system CODING allows, produce
3985 designation sequence of short-form. */
3987 #define ENCODE_DESIGNATION(charset, reg, coding) \
3989 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3990 const char *intermediate_char_94 = "()*+"; \
3991 const char *intermediate_char_96 = ",-./"; \
3992 int revision = -1; \
3994 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3995 revision = CHARSET_ISO_REVISION (charset); \
3997 if (revision >= 0) \
3999 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
4000 EMIT_ONE_BYTE ('@' + revision); \
4002 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
4003 if (CHARSET_DIMENSION (charset) == 1) \
4006 if (! CHARSET_ISO_CHARS_96 (charset)) \
4007 b = intermediate_char_94[reg]; \
4009 b = intermediate_char_96[reg]; \
4010 EMIT_ONE_ASCII_BYTE (b); \
4014 EMIT_ONE_ASCII_BYTE ('$'); \
4015 if (! CHARSET_ISO_CHARS_96 (charset)) \
4017 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
4019 || final_char < '@' || final_char > 'B') \
4020 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
4023 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
4025 EMIT_ONE_ASCII_BYTE (final_char); \
4027 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
4031 /* The following two macros produce codes (control character or escape
4032 sequence) for ISO2022 single-shift functions (single-shift-2 and
4035 #define ENCODE_SINGLE_SHIFT_2 \
4037 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4038 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
4040 EMIT_ONE_BYTE (ISO_CODE_SS2); \
4041 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4045 #define ENCODE_SINGLE_SHIFT_3 \
4047 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4048 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
4050 EMIT_ONE_BYTE (ISO_CODE_SS3); \
4051 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
4055 /* The following four macros produce codes (control character or
4056 escape sequence) for ISO2022 locking-shift functions (shift-in,
4057 shift-out, locking-shift-2, and locking-shift-3). */
4059 #define ENCODE_SHIFT_IN \
4061 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
4062 CODING_ISO_INVOCATION (coding, 0) = 0; \
4066 #define ENCODE_SHIFT_OUT \
4068 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
4069 CODING_ISO_INVOCATION (coding, 0) = 1; \
4073 #define ENCODE_LOCKING_SHIFT_2 \
4075 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
4076 CODING_ISO_INVOCATION (coding, 0) = 2; \
4080 #define ENCODE_LOCKING_SHIFT_3 \
4082 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
4083 CODING_ISO_INVOCATION (coding, 0) = 3; \
4087 /* Produce codes for a DIMENSION1 character whose character set is
4088 CHARSET and whose position-code is C1. Designation and invocation
4089 sequences are also produced in advance if necessary. */
4091 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
4093 int id = CHARSET_ID (charset); \
4095 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
4096 && id == charset_ascii) \
4098 id = charset_jisx0201_roman; \
4099 charset = CHARSET_FROM_ID (id); \
4102 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
4104 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4105 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
4107 EMIT_ONE_BYTE (c1 | 0x80); \
4108 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
4111 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
4113 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
4116 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
4118 EMIT_ONE_BYTE (c1 | 0x80); \
4122 /* Since CHARSET is not yet invoked to any graphic planes, we \
4123 must invoke it, or, at first, designate it to some graphic \
4124 register. Then repeat the loop to actually produce the \
4126 dst = encode_invocation_designation (charset, coding, dst, \
4131 /* Produce codes for a DIMENSION2 character whose character set is
4132 CHARSET and whose position-codes are C1 and C2. Designation and
4133 invocation codes are also produced in advance if necessary. */
4135 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
4137 int id = CHARSET_ID (charset); \
4139 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
4140 && id == charset_jisx0208) \
4142 id = charset_jisx0208_1978; \
4143 charset = CHARSET_FROM_ID (id); \
4146 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
4148 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
4149 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
4151 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
4152 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
4155 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
4157 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
4160 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
4162 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
4166 /* Since CHARSET is not yet invoked to any graphic planes, we \
4167 must invoke it, or, at first, designate it to some graphic \
4168 register. Then repeat the loop to actually produce the \
4170 dst = encode_invocation_designation (charset, coding, dst, \
4175 #define ENCODE_ISO_CHARACTER(charset, c) \
4177 int code = ENCODE_CHAR ((charset), (c)); \
4179 if (CHARSET_DIMENSION (charset) == 1) \
4180 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
4182 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
4186 /* Produce designation and invocation codes at a place pointed by DST
4187 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
4190 static unsigned char *
4191 encode_invocation_designation (struct charset
*charset
,
4192 struct coding_system
*coding
,
4193 unsigned char *dst
, int *p_nchars
)
4195 int multibytep
= coding
->dst_multibyte
;
4196 int produced_chars
= *p_nchars
;
4197 int reg
; /* graphic register number */
4198 int id
= CHARSET_ID (charset
);
4200 /* At first, check designations. */
4201 for (reg
= 0; reg
< 4; reg
++)
4202 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
4207 /* CHARSET is not yet designated to any graphic registers. */
4208 /* At first check the requested designation. */
4209 reg
= CODING_ISO_REQUEST (coding
, id
);
4211 /* Since CHARSET requests no special designation, designate it
4212 to graphic register 0. */
4215 ENCODE_DESIGNATION (charset
, reg
, coding
);
4218 if (CODING_ISO_INVOCATION (coding
, 0) != reg
4219 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
4221 /* Since the graphic register REG is not invoked to any graphic
4222 planes, invoke it to graphic plane 0. */
4225 case 0: /* graphic register 0 */
4229 case 1: /* graphic register 1 */
4233 case 2: /* graphic register 2 */
4234 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
4235 ENCODE_SINGLE_SHIFT_2
;
4237 ENCODE_LOCKING_SHIFT_2
;
4240 case 3: /* graphic register 3 */
4241 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
4242 ENCODE_SINGLE_SHIFT_3
;
4244 ENCODE_LOCKING_SHIFT_3
;
4249 *p_nchars
= produced_chars
;
4254 /* Produce codes for designation and invocation to reset the graphic
4255 planes and registers to initial state. */
4256 #define ENCODE_RESET_PLANE_AND_REGISTER() \
4259 struct charset *charset; \
4261 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
4263 for (reg = 0; reg < 4; reg++) \
4264 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
4265 && (CODING_ISO_DESIGNATION (coding, reg) \
4266 != CODING_ISO_INITIAL (coding, reg))) \
4268 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
4269 ENCODE_DESIGNATION (charset, reg, coding); \
4274 /* Produce designation sequences of charsets in the line started from
4275 SRC to a place pointed by DST, and return updated DST.
4277 If the current block ends before any end-of-line, we may fail to
4278 find all the necessary designations. */
4280 static unsigned char *
4281 encode_designation_at_bol (struct coding_system
*coding
, int *charbuf
,
4284 struct charset
*charset
;
4285 /* Table of charsets to be designated to each graphic register. */
4287 int c
, found
= 0, reg
;
4288 int produced_chars
= 0;
4289 int multibytep
= coding
->dst_multibyte
;
4291 Lisp_Object charset_list
;
4293 attrs
= CODING_ID_ATTRS (coding
->id
);
4294 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4295 if (EQ (charset_list
, Qiso_2022
))
4296 charset_list
= Viso_2022_charset_list
;
4298 for (reg
= 0; reg
< 4; reg
++)
4308 charset
= char_charset (c
, charset_list
, NULL
);
4309 id
= CHARSET_ID (charset
);
4310 reg
= CODING_ISO_REQUEST (coding
, id
);
4311 if (reg
>= 0 && r
[reg
] < 0)
4320 for (reg
= 0; reg
< 4; reg
++)
4322 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
4323 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
4329 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
4332 encode_coding_iso_2022 (struct coding_system
*coding
)
4334 int multibytep
= coding
->dst_multibyte
;
4335 int *charbuf
= coding
->charbuf
;
4336 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4337 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4338 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4341 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
4342 && CODING_ISO_BOL (coding
));
4343 int produced_chars
= 0;
4344 Lisp_Object attrs
, eol_type
, charset_list
;
4345 int ascii_compatible
;
4347 int preferred_charset_id
= -1;
4349 CODING_GET_INFO (coding
, attrs
, charset_list
);
4350 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
4351 if (VECTORP (eol_type
))
4354 setup_iso_safe_charsets (attrs
);
4355 /* Charset list may have been changed. */
4356 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4357 coding
->safe_charsets
= SDATA (CODING_ATTR_SAFE_CHARSETS (attrs
));
4360 = (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
))
4361 && ! (CODING_ISO_FLAGS (coding
) & (CODING_ISO_FLAG_DESIGNATION
4362 | CODING_ISO_FLAG_LOCKING_SHIFT
)));
4364 while (charbuf
< charbuf_end
)
4366 ASSURE_DESTINATION (safe_room
);
4368 if (bol_designation
)
4370 unsigned char *dst_prev
= dst
;
4372 /* We have to produce designation sequences if any now. */
4373 dst
= encode_designation_at_bol (coding
, charbuf
, dst
);
4374 bol_designation
= 0;
4375 /* We are sure that designation sequences are all ASCII bytes. */
4376 produced_chars
+= dst
- dst_prev
;
4383 /* Handle an annotation. */
4386 case CODING_ANNOTATE_COMPOSITION_MASK
:
4387 /* Not yet implemented. */
4389 case CODING_ANNOTATE_CHARSET_MASK
:
4390 preferred_charset_id
= charbuf
[2];
4391 if (preferred_charset_id
>= 0
4392 && NILP (Fmemq (make_number (preferred_charset_id
),
4394 preferred_charset_id
= -1;
4403 /* Now encode the character C. */
4404 if (c
< 0x20 || c
== 0x7F)
4407 || (c
== '\r' && EQ (eol_type
, Qmac
)))
4409 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4410 ENCODE_RESET_PLANE_AND_REGISTER ();
4411 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
4415 for (i
= 0; i
< 4; i
++)
4416 CODING_ISO_DESIGNATION (coding
, i
)
4417 = CODING_ISO_INITIAL (coding
, i
);
4420 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
4422 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
4423 ENCODE_RESET_PLANE_AND_REGISTER ();
4424 EMIT_ONE_ASCII_BYTE (c
);
4426 else if (ASCII_CHAR_P (c
))
4428 if (ascii_compatible
)
4429 EMIT_ONE_ASCII_BYTE (c
);
4432 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
4433 ENCODE_ISO_CHARACTER (charset
, c
);
4436 else if (CHAR_BYTE8_P (c
))
4438 c
= CHAR_TO_BYTE8 (c
);
4443 struct charset
*charset
;
4445 if (preferred_charset_id
>= 0)
4447 charset
= CHARSET_FROM_ID (preferred_charset_id
);
4448 if (! CHAR_CHARSET_P (c
, charset
))
4449 charset
= char_charset (c
, charset_list
, NULL
);
4452 charset
= char_charset (c
, charset_list
, NULL
);
4455 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4457 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4458 charset
= CHARSET_FROM_ID (charset_ascii
);
4462 c
= coding
->default_char
;
4463 charset
= char_charset (c
, charset_list
, NULL
);
4466 ENCODE_ISO_CHARACTER (charset
, c
);
4470 if (coding
->mode
& CODING_MODE_LAST_BLOCK
4471 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4473 ASSURE_DESTINATION (safe_room
);
4474 ENCODE_RESET_PLANE_AND_REGISTER ();
4476 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4477 CODING_ISO_BOL (coding
) = bol_designation
;
4478 coding
->produced_char
+= produced_chars
;
4479 coding
->produced
= dst
- coding
->destination
;
4484 /*** 8,9. SJIS and BIG5 handlers ***/
4486 /* Although SJIS and BIG5 are not ISO's coding system, they are used
4487 quite widely. So, for the moment, Emacs supports them in the bare
4488 C code. But, in the future, they may be supported only by CCL. */
4490 /* SJIS is a coding system encoding three character sets: ASCII, right
4491 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
4492 as is. A character of charset katakana-jisx0201 is encoded by
4493 "position-code + 0x80". A character of charset japanese-jisx0208
4494 is encoded in 2-byte but two position-codes are divided and shifted
4495 so that it fit in the range below.
4497 --- CODE RANGE of SJIS ---
4498 (character set) (range)
4500 KATAKANA-JISX0201 0xA0 .. 0xDF
4501 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
4502 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
4503 -------------------------------
4507 /* BIG5 is a coding system encoding two character sets: ASCII and
4508 Big5. An ASCII character is encoded as is. Big5 is a two-byte
4509 character set and is encoded in two-byte.
4511 --- CODE RANGE of BIG5 ---
4512 (character set) (range)
4514 Big5 (1st byte) 0xA1 .. 0xFE
4515 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
4516 --------------------------
4520 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4521 Check if a text is encoded in SJIS. If it is, return
4522 CATEGORY_MASK_SJIS, else return 0. */
4525 detect_coding_sjis (struct coding_system
*coding
,
4526 struct coding_detection_info
*detect_info
)
4528 const unsigned char *src
= coding
->source
, *src_base
;
4529 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4530 int multibytep
= coding
->src_multibyte
;
4531 int consumed_chars
= 0;
4534 Lisp_Object attrs
, charset_list
;
4535 int max_first_byte_of_2_byte_code
;
4537 CODING_GET_INFO (coding
, attrs
, charset_list
);
4538 max_first_byte_of_2_byte_code
4539 = (XINT (Flength (charset_list
)) > 3 ? 0xFC : 0xEF);
4541 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
4542 /* A coding system of this category is always ASCII compatible. */
4543 src
+= coding
->head_ascii
;
4551 if ((c
>= 0x81 && c
<= 0x9F)
4552 || (c
>= 0xE0 && c
<= max_first_byte_of_2_byte_code
))
4555 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
4557 found
= CATEGORY_MASK_SJIS
;
4559 else if (c
>= 0xA0 && c
< 0xE0)
4560 found
= CATEGORY_MASK_SJIS
;
4564 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4568 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4570 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4573 detect_info
->found
|= found
;
4577 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4578 Check if a text is encoded in BIG5. If it is, return
4579 CATEGORY_MASK_BIG5, else return 0. */
4582 detect_coding_big5 (struct coding_system
*coding
,
4583 struct coding_detection_info
*detect_info
)
4585 const unsigned char *src
= coding
->source
, *src_base
;
4586 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4587 int multibytep
= coding
->src_multibyte
;
4588 int consumed_chars
= 0;
4592 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4593 /* A coding system of this category is always ASCII compatible. */
4594 src
+= coding
->head_ascii
;
4605 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4607 found
= CATEGORY_MASK_BIG5
;
4612 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4616 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4618 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4621 detect_info
->found
|= found
;
4625 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4626 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4629 decode_coding_sjis (struct coding_system
*coding
)
4631 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4632 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4633 const unsigned char *src_base
;
4634 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4635 /* We may produce one charset annotation in one loop and one more at
4638 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
4639 int consumed_chars
= 0, consumed_chars_base
;
4640 int multibytep
= coding
->src_multibyte
;
4641 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4642 struct charset
*charset_kanji2
;
4643 Lisp_Object attrs
, charset_list
, val
;
4644 int char_offset
= coding
->produced_char
;
4645 int last_offset
= char_offset
;
4646 int last_id
= charset_ascii
;
4648 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4649 int byte_after_cr
= -1;
4651 CODING_GET_INFO (coding
, attrs
, charset_list
);
4654 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4655 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4656 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4657 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4662 struct charset
*charset
;
4665 consumed_chars_base
= consumed_chars
;
4667 if (charbuf
>= charbuf_end
)
4669 if (byte_after_cr
>= 0)
4674 if (byte_after_cr
>= 0)
4675 c
= byte_after_cr
, byte_after_cr
= -1;
4682 if (eol_dos
&& c
== '\r')
4683 ONE_MORE_BYTE (byte_after_cr
);
4684 charset
= charset_roman
;
4686 else if (c
== 0x80 || c
== 0xA0)
4688 else if (c
>= 0xA1 && c
<= 0xDF)
4690 /* SJIS -> JISX0201-Kana */
4692 charset
= charset_kana
;
4696 /* SJIS -> JISX0208 */
4698 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4702 charset
= charset_kanji
;
4704 else if (c
<= 0xFC && charset_kanji2
)
4706 /* SJIS -> JISX0213-2 */
4708 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4712 charset
= charset_kanji2
;
4716 if (charset
->id
!= charset_ascii
4717 && last_id
!= charset
->id
)
4719 if (last_id
!= charset_ascii
)
4720 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4721 last_id
= charset
->id
;
4722 last_offset
= char_offset
;
4724 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4731 consumed_chars
= consumed_chars_base
;
4733 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4739 if (last_id
!= charset_ascii
)
4740 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4741 coding
->consumed_char
+= consumed_chars_base
;
4742 coding
->consumed
= src_base
- coding
->source
;
4743 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4747 decode_coding_big5 (struct coding_system
*coding
)
4749 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4750 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4751 const unsigned char *src_base
;
4752 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4753 /* We may produce one charset annotation in one loop and one more at
4756 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
4757 int consumed_chars
= 0, consumed_chars_base
;
4758 int multibytep
= coding
->src_multibyte
;
4759 struct charset
*charset_roman
, *charset_big5
;
4760 Lisp_Object attrs
, charset_list
, val
;
4761 int char_offset
= coding
->produced_char
;
4762 int last_offset
= char_offset
;
4763 int last_id
= charset_ascii
;
4765 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4766 int byte_after_cr
= -1;
4768 CODING_GET_INFO (coding
, attrs
, charset_list
);
4770 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4771 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4776 struct charset
*charset
;
4779 consumed_chars_base
= consumed_chars
;
4781 if (charbuf
>= charbuf_end
)
4783 if (byte_after_cr
>= 0)
4788 if (byte_after_cr
>= 0)
4789 c
= byte_after_cr
, byte_after_cr
= -1;
4797 if (eol_dos
&& c
== '\r')
4798 ONE_MORE_BYTE (byte_after_cr
);
4799 charset
= charset_roman
;
4804 if (c
< 0xA1 || c
> 0xFE)
4807 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4810 charset
= charset_big5
;
4812 if (charset
->id
!= charset_ascii
4813 && last_id
!= charset
->id
)
4815 if (last_id
!= charset_ascii
)
4816 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4817 last_id
= charset
->id
;
4818 last_offset
= char_offset
;
4820 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4827 consumed_chars
= consumed_chars_base
;
4829 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4835 if (last_id
!= charset_ascii
)
4836 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4837 coding
->consumed_char
+= consumed_chars_base
;
4838 coding
->consumed
= src_base
- coding
->source
;
4839 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4842 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4843 This function can encode charsets `ascii', `katakana-jisx0201',
4844 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4845 are sure that all these charsets are registered as official charset
4846 (i.e. do not have extended leading-codes). Characters of other
4847 charsets are produced without any encoding. If SJIS_P is 1, encode
4848 SJIS text, else encode BIG5 text. */
4851 encode_coding_sjis (struct coding_system
*coding
)
4853 int multibytep
= coding
->dst_multibyte
;
4854 int *charbuf
= coding
->charbuf
;
4855 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4856 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4857 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4859 int produced_chars
= 0;
4860 Lisp_Object attrs
, charset_list
, val
;
4861 int ascii_compatible
;
4862 struct charset
*charset_kanji
, *charset_kana
;
4863 struct charset
*charset_kanji2
;
4866 CODING_GET_INFO (coding
, attrs
, charset_list
);
4867 val
= XCDR (charset_list
);
4868 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4869 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4870 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4872 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4874 while (charbuf
< charbuf_end
)
4876 ASSURE_DESTINATION (safe_room
);
4878 /* Now encode the character C. */
4879 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4880 EMIT_ONE_ASCII_BYTE (c
);
4881 else if (CHAR_BYTE8_P (c
))
4883 c
= CHAR_TO_BYTE8 (c
);
4889 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4893 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4895 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4896 charset
= CHARSET_FROM_ID (charset_ascii
);
4900 c
= coding
->default_char
;
4901 charset
= char_charset (c
, charset_list
, &code
);
4904 if (code
== CHARSET_INVALID_CODE (charset
))
4906 if (charset
== charset_kanji
)
4910 c1
= code
>> 8, c2
= code
& 0xFF;
4911 EMIT_TWO_BYTES (c1
, c2
);
4913 else if (charset
== charset_kana
)
4914 EMIT_ONE_BYTE (code
| 0x80);
4915 else if (charset_kanji2
&& charset
== charset_kanji2
)
4920 if (c1
== 0x21 || (c1
>= 0x23 && c1
<= 0x25)
4922 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4924 JIS_TO_SJIS2 (code
);
4925 c1
= code
>> 8, c2
= code
& 0xFF;
4926 EMIT_TWO_BYTES (c1
, c2
);
4929 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4932 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4935 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4936 coding
->produced_char
+= produced_chars
;
4937 coding
->produced
= dst
- coding
->destination
;
4942 encode_coding_big5 (struct coding_system
*coding
)
4944 int multibytep
= coding
->dst_multibyte
;
4945 int *charbuf
= coding
->charbuf
;
4946 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4947 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4948 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4950 int produced_chars
= 0;
4951 Lisp_Object attrs
, charset_list
, val
;
4952 int ascii_compatible
;
4953 struct charset
*charset_big5
;
4956 CODING_GET_INFO (coding
, attrs
, charset_list
);
4957 val
= XCDR (charset_list
);
4958 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4959 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4961 while (charbuf
< charbuf_end
)
4963 ASSURE_DESTINATION (safe_room
);
4965 /* Now encode the character C. */
4966 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4967 EMIT_ONE_ASCII_BYTE (c
);
4968 else if (CHAR_BYTE8_P (c
))
4970 c
= CHAR_TO_BYTE8 (c
);
4976 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4980 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4982 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4983 charset
= CHARSET_FROM_ID (charset_ascii
);
4987 c
= coding
->default_char
;
4988 charset
= char_charset (c
, charset_list
, &code
);
4991 if (code
== CHARSET_INVALID_CODE (charset
))
4993 if (charset
== charset_big5
)
4997 c1
= code
>> 8, c2
= code
& 0xFF;
4998 EMIT_TWO_BYTES (c1
, c2
);
5001 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
5004 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5005 coding
->produced_char
+= produced_chars
;
5006 coding
->produced
= dst
- coding
->destination
;
5011 /*** 10. CCL handlers ***/
5013 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5014 Check if a text is encoded in a coding system of which
5015 encoder/decoder are written in CCL program. If it is, return
5016 CATEGORY_MASK_CCL, else return 0. */
5019 detect_coding_ccl (struct coding_system
*coding
,
5020 struct coding_detection_info
*detect_info
)
5022 const unsigned char *src
= coding
->source
, *src_base
;
5023 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5024 int multibytep
= coding
->src_multibyte
;
5025 int consumed_chars
= 0;
5027 unsigned char *valids
;
5028 int head_ascii
= coding
->head_ascii
;
5031 detect_info
->checked
|= CATEGORY_MASK_CCL
;
5033 coding
= &coding_categories
[coding_category_ccl
];
5034 valids
= CODING_CCL_VALIDS (coding
);
5035 attrs
= CODING_ID_ATTRS (coding
->id
);
5036 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
5045 if (c
< 0 || ! valids
[c
])
5047 if ((valids
[c
] > 1))
5048 found
= CATEGORY_MASK_CCL
;
5050 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
5054 detect_info
->found
|= found
;
5059 decode_coding_ccl (struct coding_system
*coding
)
5061 const unsigned char *src
= coding
->source
+ coding
->consumed
;
5062 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5063 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
5064 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
5065 int consumed_chars
= 0;
5066 int multibytep
= coding
->src_multibyte
;
5067 struct ccl_program
*ccl
= &coding
->spec
.ccl
->ccl
;
5068 int source_charbuf
[1024];
5069 int source_byteidx
[1025];
5070 Lisp_Object attrs
, charset_list
;
5072 CODING_GET_INFO (coding
, attrs
, charset_list
);
5076 const unsigned char *p
= src
;
5081 while (i
< 1024 && p
< src_end
)
5083 source_byteidx
[i
] = p
- src
;
5084 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
5086 source_byteidx
[i
] = p
- src
;
5089 while (i
< 1024 && p
< src_end
)
5090 source_charbuf
[i
++] = *p
++;
5092 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
5093 ccl
->last_block
= 1;
5094 ccl_driver (ccl
, source_charbuf
, charbuf
, i
, charbuf_end
- charbuf
,
5096 charbuf
+= ccl
->produced
;
5098 src
+= source_byteidx
[ccl
->consumed
];
5100 src
+= ccl
->consumed
;
5101 consumed_chars
+= ccl
->consumed
;
5102 if (p
== src_end
|| ccl
->status
!= CCL_STAT_SUSPEND_BY_SRC
)
5106 switch (ccl
->status
)
5108 case CCL_STAT_SUSPEND_BY_SRC
:
5109 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5111 case CCL_STAT_SUSPEND_BY_DST
:
5112 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
5115 case CCL_STAT_INVALID_CMD
:
5116 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
5119 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5122 coding
->consumed_char
+= consumed_chars
;
5123 coding
->consumed
= src
- coding
->source
;
5124 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
5128 encode_coding_ccl (struct coding_system
*coding
)
5130 struct ccl_program
*ccl
= &coding
->spec
.ccl
->ccl
;
5131 int multibytep
= coding
->dst_multibyte
;
5132 int *charbuf
= coding
->charbuf
;
5133 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
5134 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5135 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5136 int destination_charbuf
[1024];
5137 int i
, produced_chars
= 0;
5138 Lisp_Object attrs
, charset_list
;
5140 CODING_GET_INFO (coding
, attrs
, charset_list
);
5141 if (coding
->consumed_char
== coding
->src_chars
5142 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
5143 ccl
->last_block
= 1;
5145 while (charbuf
< charbuf_end
)
5147 ccl_driver (ccl
, charbuf
, destination_charbuf
,
5148 charbuf_end
- charbuf
, 1024, charset_list
);
5151 ASSURE_DESTINATION (ccl
->produced
* 2);
5152 for (i
= 0; i
< ccl
->produced
; i
++)
5153 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
5157 ASSURE_DESTINATION (ccl
->produced
);
5158 for (i
= 0; i
< ccl
->produced
; i
++)
5159 *dst
++ = destination_charbuf
[i
] & 0xFF;
5160 produced_chars
+= ccl
->produced
;
5162 charbuf
+= ccl
->consumed
;
5163 if (ccl
->status
== CCL_STAT_QUIT
5164 || ccl
->status
== CCL_STAT_INVALID_CMD
)
5168 switch (ccl
->status
)
5170 case CCL_STAT_SUSPEND_BY_SRC
:
5171 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5173 case CCL_STAT_SUSPEND_BY_DST
:
5174 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
5177 case CCL_STAT_INVALID_CMD
:
5178 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
5181 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5185 coding
->produced_char
+= produced_chars
;
5186 coding
->produced
= dst
- coding
->destination
;
5192 /*** 10, 11. no-conversion handlers ***/
5194 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
5197 decode_coding_raw_text (struct coding_system
*coding
)
5200 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
5202 coding
->chars_at_source
= 1;
5203 coding
->consumed_char
= coding
->src_chars
;
5204 coding
->consumed
= coding
->src_bytes
;
5205 if (eol_dos
&& coding
->source
[coding
->src_bytes
- 1] == '\r')
5207 coding
->consumed_char
--;
5209 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5212 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5216 encode_coding_raw_text (struct coding_system
*coding
)
5218 int multibytep
= coding
->dst_multibyte
;
5219 int *charbuf
= coding
->charbuf
;
5220 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
5221 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5222 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5223 int produced_chars
= 0;
5228 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
5230 if (coding
->src_multibyte
)
5231 while (charbuf
< charbuf_end
)
5233 ASSURE_DESTINATION (safe_room
);
5235 if (ASCII_CHAR_P (c
))
5236 EMIT_ONE_ASCII_BYTE (c
);
5237 else if (CHAR_BYTE8_P (c
))
5239 c
= CHAR_TO_BYTE8 (c
);
5244 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
5246 CHAR_STRING_ADVANCE (c
, p1
);
5249 EMIT_ONE_BYTE (*p0
);
5256 while (charbuf
< charbuf_end
)
5258 ASSURE_DESTINATION (safe_room
);
5265 if (coding
->src_multibyte
)
5267 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5269 while (charbuf
< charbuf_end
)
5271 ASSURE_DESTINATION (safe_room
);
5273 if (ASCII_CHAR_P (c
))
5275 else if (CHAR_BYTE8_P (c
))
5276 *dst
++ = CHAR_TO_BYTE8 (c
);
5278 CHAR_STRING_ADVANCE (c
, dst
);
5283 ASSURE_DESTINATION (charbuf_end
- charbuf
);
5284 while (charbuf
< charbuf_end
&& dst
< dst_end
)
5285 *dst
++ = *charbuf
++;
5287 produced_chars
= dst
- (coding
->destination
+ coding
->produced
);
5289 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5290 coding
->produced_char
+= produced_chars
;
5291 coding
->produced
= dst
- coding
->destination
;
5295 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5296 Check if a text is encoded in a charset-based coding system. If it
5297 is, return 1, else return 0. */
5300 detect_coding_charset (struct coding_system
*coding
,
5301 struct coding_detection_info
*detect_info
)
5303 const unsigned char *src
= coding
->source
, *src_base
;
5304 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5305 int multibytep
= coding
->src_multibyte
;
5306 int consumed_chars
= 0;
5307 Lisp_Object attrs
, valids
, name
;
5309 int head_ascii
= coding
->head_ascii
;
5310 int check_latin_extra
= 0;
5312 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
5314 coding
= &coding_categories
[coding_category_charset
];
5315 attrs
= CODING_ID_ATTRS (coding
->id
);
5316 valids
= AREF (attrs
, coding_attr_charset_valids
);
5317 name
= CODING_ID_NAME (coding
->id
);
5318 if (strncmp (SSDATA (SYMBOL_NAME (name
)),
5319 "iso-8859-", sizeof ("iso-8859-") - 1) == 0
5320 || strncmp (SSDATA (SYMBOL_NAME (name
)),
5321 "iso-latin-", sizeof ("iso-latin-") - 1) == 0)
5322 check_latin_extra
= 1;
5324 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
5331 struct charset
*charset
;
5338 val
= AREF (valids
, c
);
5344 && check_latin_extra
5345 && (!VECTORP (Vlatin_extra_code_table
)
5346 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
])))
5348 found
= CATEGORY_MASK_CHARSET
;
5352 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5353 dim
= CHARSET_DIMENSION (charset
);
5354 for (idx
= 1; idx
< dim
; idx
++)
5359 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 2]
5360 || c
> charset
->code_space
[(dim
- 1 - idx
) * 2 + 1])
5369 for (; CONSP (val
); val
= XCDR (val
))
5371 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5372 dim
= CHARSET_DIMENSION (charset
);
5378 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 4]
5379 || c
> charset
->code_space
[(dim
- 1 - idx
) * 4 + 1])
5394 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
5398 detect_info
->found
|= found
;
5403 decode_coding_charset (struct coding_system
*coding
)
5405 const unsigned char *src
= coding
->source
+ coding
->consumed
;
5406 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5407 const unsigned char *src_base
;
5408 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
5409 /* We may produce one charset annotation in one loop and one more at
5412 = coding
->charbuf
+ coding
->charbuf_size
- (MAX_ANNOTATION_LENGTH
* 2);
5413 int consumed_chars
= 0, consumed_chars_base
;
5414 int multibytep
= coding
->src_multibyte
;
5415 Lisp_Object attrs
= CODING_ID_ATTRS (coding
->id
);
5417 int char_offset
= coding
->produced_char
;
5418 int last_offset
= char_offset
;
5419 int last_id
= charset_ascii
;
5421 !inhibit_eol_conversion
&& EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
5422 int byte_after_cr
= -1;
5424 valids
= AREF (attrs
, coding_attr_charset_valids
);
5430 struct charset
*charset
;
5436 consumed_chars_base
= consumed_chars
;
5438 if (charbuf
>= charbuf_end
)
5440 if (byte_after_cr
>= 0)
5445 if (byte_after_cr
>= 0)
5453 if (eol_dos
&& c
== '\r')
5454 ONE_MORE_BYTE (byte_after_cr
);
5460 val
= AREF (valids
, c
);
5461 if (! INTEGERP (val
) && ! CONSP (val
))
5465 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5466 dim
= CHARSET_DIMENSION (charset
);
5470 code
= (code
<< 8) | c
;
5473 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
5478 /* VAL is a list of charset IDs. It is assured that the
5479 list is sorted by charset dimensions (smaller one
5483 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5484 dim
= CHARSET_DIMENSION (charset
);
5488 code
= (code
<< 8) | c
;
5491 CODING_DECODE_CHAR (coding
, src
, src_base
,
5492 src_end
, charset
, code
, c
);
5500 if (charset
->id
!= charset_ascii
5501 && last_id
!= charset
->id
)
5503 if (last_id
!= charset_ascii
)
5504 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5505 last_id
= charset
->id
;
5506 last_offset
= char_offset
;
5515 consumed_chars
= consumed_chars_base
;
5517 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
5523 if (last_id
!= charset_ascii
)
5524 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5525 coding
->consumed_char
+= consumed_chars_base
;
5526 coding
->consumed
= src_base
- coding
->source
;
5527 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
5531 encode_coding_charset (struct coding_system
*coding
)
5533 int multibytep
= coding
->dst_multibyte
;
5534 int *charbuf
= coding
->charbuf
;
5535 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
5536 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5537 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5538 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5539 int produced_chars
= 0;
5540 Lisp_Object attrs
, charset_list
;
5541 int ascii_compatible
;
5544 CODING_GET_INFO (coding
, attrs
, charset_list
);
5545 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
5547 while (charbuf
< charbuf_end
)
5549 struct charset
*charset
;
5552 ASSURE_DESTINATION (safe_room
);
5554 if (ascii_compatible
&& ASCII_CHAR_P (c
))
5555 EMIT_ONE_ASCII_BYTE (c
);
5556 else if (CHAR_BYTE8_P (c
))
5558 c
= CHAR_TO_BYTE8 (c
);
5563 charset
= char_charset (c
, charset_list
, &code
);
5566 if (CHARSET_DIMENSION (charset
) == 1)
5567 EMIT_ONE_BYTE (code
);
5568 else if (CHARSET_DIMENSION (charset
) == 2)
5569 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
5570 else if (CHARSET_DIMENSION (charset
) == 3)
5571 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
5573 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
5574 (code
>> 8) & 0xFF, code
& 0xFF);
5578 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
5579 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
5581 c
= coding
->default_char
;
5587 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5588 coding
->produced_char
+= produced_chars
;
5589 coding
->produced
= dst
- coding
->destination
;
5594 /*** 7. C library functions ***/
5596 /* Setup coding context CODING from information about CODING_SYSTEM.
5597 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
5598 CODING_SYSTEM is invalid, signal an error. */
5601 setup_coding_system (Lisp_Object coding_system
, struct coding_system
*coding
)
5604 Lisp_Object eol_type
;
5605 Lisp_Object coding_type
;
5608 if (NILP (coding_system
))
5609 coding_system
= Qundecided
;
5611 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
5613 attrs
= CODING_ID_ATTRS (coding
->id
);
5614 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
5617 coding
->head_ascii
= -1;
5618 if (VECTORP (eol_type
))
5619 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5620 | CODING_REQUIRE_DETECTION_MASK
);
5621 else if (! EQ (eol_type
, Qunix
))
5622 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5623 | CODING_REQUIRE_ENCODING_MASK
);
5625 coding
->common_flags
= 0;
5626 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
5627 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5628 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
5629 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5630 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
5631 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
5633 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5634 coding
->max_charset_id
= SCHARS (val
) - 1;
5635 coding
->safe_charsets
= SDATA (val
);
5636 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
5637 coding
->carryover_bytes
= 0;
5639 coding_type
= CODING_ATTR_TYPE (attrs
);
5640 if (EQ (coding_type
, Qundecided
))
5642 coding
->detector
= NULL
;
5643 coding
->decoder
= decode_coding_raw_text
;
5644 coding
->encoder
= encode_coding_raw_text
;
5645 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5647 else if (EQ (coding_type
, Qiso_2022
))
5650 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5652 /* Invoke graphic register 0 to plane 0. */
5653 CODING_ISO_INVOCATION (coding
, 0) = 0;
5654 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
5655 CODING_ISO_INVOCATION (coding
, 1)
5656 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
5657 /* Setup the initial status of designation. */
5658 for (i
= 0; i
< 4; i
++)
5659 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
5660 /* Not single shifting initially. */
5661 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
5662 /* Beginning of buffer should also be regarded as bol. */
5663 CODING_ISO_BOL (coding
) = 1;
5664 coding
->detector
= detect_coding_iso_2022
;
5665 coding
->decoder
= decode_coding_iso_2022
;
5666 coding
->encoder
= encode_coding_iso_2022
;
5667 if (flags
& CODING_ISO_FLAG_SAFE
)
5668 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
5669 coding
->common_flags
5670 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5671 | CODING_REQUIRE_FLUSHING_MASK
);
5672 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
5673 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
5674 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
5675 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
5676 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5678 setup_iso_safe_charsets (attrs
);
5679 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5680 coding
->max_charset_id
= SCHARS (val
) - 1;
5681 coding
->safe_charsets
= SDATA (val
);
5683 CODING_ISO_FLAGS (coding
) = flags
;
5684 CODING_ISO_CMP_STATUS (coding
)->state
= COMPOSING_NO
;
5685 CODING_ISO_CMP_STATUS (coding
)->method
= COMPOSITION_NO
;
5686 CODING_ISO_EXTSEGMENT_LEN (coding
) = 0;
5687 CODING_ISO_EMBEDDED_UTF_8 (coding
) = 0;
5689 else if (EQ (coding_type
, Qcharset
))
5691 coding
->detector
= detect_coding_charset
;
5692 coding
->decoder
= decode_coding_charset
;
5693 coding
->encoder
= encode_coding_charset
;
5694 coding
->common_flags
5695 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5697 else if (EQ (coding_type
, Qutf_8
))
5699 val
= AREF (attrs
, coding_attr_utf_bom
);
5700 CODING_UTF_8_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5701 : EQ (val
, Qt
) ? utf_with_bom
5703 coding
->detector
= detect_coding_utf_8
;
5704 coding
->decoder
= decode_coding_utf_8
;
5705 coding
->encoder
= encode_coding_utf_8
;
5706 coding
->common_flags
5707 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5708 if (CODING_UTF_8_BOM (coding
) == utf_detect_bom
)
5709 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5711 else if (EQ (coding_type
, Qutf_16
))
5713 val
= AREF (attrs
, coding_attr_utf_bom
);
5714 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5715 : EQ (val
, Qt
) ? utf_with_bom
5717 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5718 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5719 : utf_16_little_endian
);
5720 CODING_UTF_16_SURROGATE (coding
) = 0;
5721 coding
->detector
= detect_coding_utf_16
;
5722 coding
->decoder
= decode_coding_utf_16
;
5723 coding
->encoder
= encode_coding_utf_16
;
5724 coding
->common_flags
5725 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5726 if (CODING_UTF_16_BOM (coding
) == utf_detect_bom
)
5727 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5729 else if (EQ (coding_type
, Qccl
))
5731 coding
->detector
= detect_coding_ccl
;
5732 coding
->decoder
= decode_coding_ccl
;
5733 coding
->encoder
= encode_coding_ccl
;
5734 coding
->common_flags
5735 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5736 | CODING_REQUIRE_FLUSHING_MASK
);
5738 else if (EQ (coding_type
, Qemacs_mule
))
5740 coding
->detector
= detect_coding_emacs_mule
;
5741 coding
->decoder
= decode_coding_emacs_mule
;
5742 coding
->encoder
= encode_coding_emacs_mule
;
5743 coding
->common_flags
5744 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5745 coding
->spec
.emacs_mule
.full_support
= 1;
5746 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5747 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5749 Lisp_Object tail
, safe_charsets
;
5750 int max_charset_id
= 0;
5752 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5754 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5755 max_charset_id
= XFASTINT (XCAR (tail
));
5756 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
5757 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
5758 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5760 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5761 coding
->max_charset_id
= max_charset_id
;
5762 coding
->safe_charsets
= SDATA (safe_charsets
);
5763 coding
->spec
.emacs_mule
.full_support
= 1;
5765 coding
->spec
.emacs_mule
.cmp_status
.state
= COMPOSING_NO
;
5766 coding
->spec
.emacs_mule
.cmp_status
.method
= COMPOSITION_NO
;
5768 else if (EQ (coding_type
, Qshift_jis
))
5770 coding
->detector
= detect_coding_sjis
;
5771 coding
->decoder
= decode_coding_sjis
;
5772 coding
->encoder
= encode_coding_sjis
;
5773 coding
->common_flags
5774 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5776 else if (EQ (coding_type
, Qbig5
))
5778 coding
->detector
= detect_coding_big5
;
5779 coding
->decoder
= decode_coding_big5
;
5780 coding
->encoder
= encode_coding_big5
;
5781 coding
->common_flags
5782 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5784 else /* EQ (coding_type, Qraw_text) */
5786 coding
->detector
= NULL
;
5787 coding
->decoder
= decode_coding_raw_text
;
5788 coding
->encoder
= encode_coding_raw_text
;
5789 if (! EQ (eol_type
, Qunix
))
5791 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5792 if (! VECTORP (eol_type
))
5793 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5801 /* Return a list of charsets supported by CODING. */
5804 coding_charset_list (struct coding_system
*coding
)
5806 Lisp_Object attrs
, charset_list
;
5808 CODING_GET_INFO (coding
, attrs
, charset_list
);
5809 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5811 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5813 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5814 charset_list
= Viso_2022_charset_list
;
5816 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5818 charset_list
= Vemacs_mule_charset_list
;
5820 return charset_list
;
5824 /* Return a list of charsets supported by CODING-SYSTEM. */
5827 coding_system_charset_list (Lisp_Object coding_system
)
5830 Lisp_Object attrs
, charset_list
;
5832 CHECK_CODING_SYSTEM_GET_ID (coding_system
, id
);
5833 attrs
= CODING_ID_ATTRS (id
);
5835 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5837 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5839 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5840 charset_list
= Viso_2022_charset_list
;
5842 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
5844 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5846 charset_list
= Vemacs_mule_charset_list
;
5850 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
5852 return charset_list
;
5856 /* Return raw-text or one of its subsidiaries that has the same
5857 eol_type as CODING-SYSTEM. */
5860 raw_text_coding_system (Lisp_Object coding_system
)
5862 Lisp_Object spec
, attrs
;
5863 Lisp_Object eol_type
, raw_text_eol_type
;
5865 if (NILP (coding_system
))
5867 spec
= CODING_SYSTEM_SPEC (coding_system
);
5868 attrs
= AREF (spec
, 0);
5870 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5871 return coding_system
;
5873 eol_type
= AREF (spec
, 2);
5874 if (VECTORP (eol_type
))
5876 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5877 raw_text_eol_type
= AREF (spec
, 2);
5878 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5879 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5880 : AREF (raw_text_eol_type
, 2));
5884 /* If CODING_SYSTEM doesn't specify end-of-line format, return one of
5885 the subsidiary that has the same eol-spec as PARENT (if it is not
5886 nil and specifies end-of-line format) or the system's setting
5887 (system_eol_type). */
5890 coding_inherit_eol_type (Lisp_Object coding_system
, Lisp_Object parent
)
5892 Lisp_Object spec
, eol_type
;
5894 if (NILP (coding_system
))
5895 coding_system
= Qraw_text
;
5896 spec
= CODING_SYSTEM_SPEC (coding_system
);
5897 eol_type
= AREF (spec
, 2);
5898 if (VECTORP (eol_type
))
5900 Lisp_Object parent_eol_type
;
5902 if (! NILP (parent
))
5904 Lisp_Object parent_spec
;
5906 parent_spec
= CODING_SYSTEM_SPEC (parent
);
5907 parent_eol_type
= AREF (parent_spec
, 2);
5908 if (VECTORP (parent_eol_type
))
5909 parent_eol_type
= system_eol_type
;
5912 parent_eol_type
= system_eol_type
;
5913 if (EQ (parent_eol_type
, Qunix
))
5914 coding_system
= AREF (eol_type
, 0);
5915 else if (EQ (parent_eol_type
, Qdos
))
5916 coding_system
= AREF (eol_type
, 1);
5917 else if (EQ (parent_eol_type
, Qmac
))
5918 coding_system
= AREF (eol_type
, 2);
5920 return coding_system
;
5924 /* Check if text-conversion and eol-conversion of CODING_SYSTEM are
5925 decided for writing to a process. If not, complement them, and
5926 return a new coding system. */
5929 complement_process_encoding_system (Lisp_Object coding_system
)
5931 Lisp_Object coding_base
= Qnil
, eol_base
= Qnil
;
5932 Lisp_Object spec
, attrs
;
5935 for (i
= 0; i
< 3; i
++)
5938 coding_system
= CDR_SAFE (Vdefault_process_coding_system
);
5940 coding_system
= preferred_coding_system ();
5941 spec
= CODING_SYSTEM_SPEC (coding_system
);
5944 attrs
= AREF (spec
, 0);
5945 if (NILP (coding_base
) && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
5946 coding_base
= CODING_ATTR_BASE_NAME (attrs
);
5947 if (NILP (eol_base
) && ! VECTORP (AREF (spec
, 2)))
5948 eol_base
= coding_system
;
5949 if (! NILP (coding_base
) && ! NILP (eol_base
))
5954 /* The original CODING_SYSTEM didn't specify text-conversion or
5955 eol-conversion. Be sure that we return a fully complemented
5957 coding_system
= coding_inherit_eol_type (coding_base
, eol_base
);
5958 return coding_system
;
5962 /* Emacs has a mechanism to automatically detect a coding system if it
5963 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5964 it's impossible to distinguish some coding systems accurately
5965 because they use the same range of codes. So, at first, coding
5966 systems are categorized into 7, those are:
5968 o coding-category-emacs-mule
5970 The category for a coding system which has the same code range
5971 as Emacs' internal format. Assigned the coding-system (Lisp
5972 symbol) `emacs-mule' by default.
5974 o coding-category-sjis
5976 The category for a coding system which has the same code range
5977 as SJIS. Assigned the coding-system (Lisp
5978 symbol) `japanese-shift-jis' by default.
5980 o coding-category-iso-7
5982 The category for a coding system which has the same code range
5983 as ISO2022 of 7-bit environment. This doesn't use any locking
5984 shift and single shift functions. This can encode/decode all
5985 charsets. Assigned the coding-system (Lisp symbol)
5986 `iso-2022-7bit' by default.
5988 o coding-category-iso-7-tight
5990 Same as coding-category-iso-7 except that this can
5991 encode/decode only the specified charsets.
5993 o coding-category-iso-8-1
5995 The category for a coding system which has the same code range
5996 as ISO2022 of 8-bit environment and graphic plane 1 used only
5997 for DIMENSION1 charset. This doesn't use any locking shift
5998 and single shift functions. Assigned the coding-system (Lisp
5999 symbol) `iso-latin-1' by default.
6001 o coding-category-iso-8-2
6003 The category for a coding system which has the same code range
6004 as ISO2022 of 8-bit environment and graphic plane 1 used only
6005 for DIMENSION2 charset. This doesn't use any locking shift
6006 and single shift functions. Assigned the coding-system (Lisp
6007 symbol) `japanese-iso-8bit' by default.
6009 o coding-category-iso-7-else
6011 The category for a coding system which has the same code range
6012 as ISO2022 of 7-bit environment but uses locking shift or
6013 single shift functions. Assigned the coding-system (Lisp
6014 symbol) `iso-2022-7bit-lock' by default.
6016 o coding-category-iso-8-else
6018 The category for a coding system which has the same code range
6019 as ISO2022 of 8-bit environment but uses locking shift or
6020 single shift functions. Assigned the coding-system (Lisp
6021 symbol) `iso-2022-8bit-ss2' by default.
6023 o coding-category-big5
6025 The category for a coding system which has the same code range
6026 as BIG5. Assigned the coding-system (Lisp symbol)
6027 `cn-big5' by default.
6029 o coding-category-utf-8
6031 The category for a coding system which has the same code range
6032 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
6033 symbol) `utf-8' by default.
6035 o coding-category-utf-16-be
6037 The category for a coding system in which a text has an
6038 Unicode signature (cf. Unicode Standard) in the order of BIG
6039 endian at the head. Assigned the coding-system (Lisp symbol)
6040 `utf-16-be' by default.
6042 o coding-category-utf-16-le
6044 The category for a coding system in which a text has an
6045 Unicode signature (cf. Unicode Standard) in the order of
6046 LITTLE endian at the head. Assigned the coding-system (Lisp
6047 symbol) `utf-16-le' by default.
6049 o coding-category-ccl
6051 The category for a coding system of which encoder/decoder is
6052 written in CCL programs. The default value is nil, i.e., no
6053 coding system is assigned.
6055 o coding-category-binary
6057 The category for a coding system not categorized in any of the
6058 above. Assigned the coding-system (Lisp symbol)
6059 `no-conversion' by default.
6061 Each of them is a Lisp symbol and the value is an actual
6062 `coding-system's (this is also a Lisp symbol) assigned by a user.
6063 What Emacs does actually is to detect a category of coding system.
6064 Then, it uses a `coding-system' assigned to it. If Emacs can't
6065 decide only one possible category, it selects a category of the
6066 highest priority. Priorities of categories are also specified by a
6067 user in a Lisp variable `coding-category-list'.
6071 #define EOL_SEEN_NONE 0
6072 #define EOL_SEEN_LF 1
6073 #define EOL_SEEN_CR 2
6074 #define EOL_SEEN_CRLF 4
6076 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
6077 SOURCE is encoded. If CATEGORY is one of
6078 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
6079 two-byte, else they are encoded by one-byte.
6081 Return one of EOL_SEEN_XXX. */
6083 #define MAX_EOL_CHECK_COUNT 3
6086 detect_eol (const unsigned char *source
, EMACS_INT src_bytes
,
6087 enum coding_category category
)
6089 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
6092 int eol_seen
= EOL_SEEN_NONE
;
6094 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
6098 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 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 int 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
;
6306 /* No coding system of this category is defined. */
6307 detect_info
.rejected
|= (1 << category
);
6309 else if (category
>= coding_category_raw_text
)
6311 else if (detect_info
.checked
& (1 << category
))
6313 if (detect_info
.found
& (1 << category
))
6316 else if ((*(this->detector
)) (coding
, &detect_info
)
6317 && detect_info
.found
& (1 << category
))
6319 if (category
== coding_category_utf_16_auto
)
6321 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
6322 category
= coding_category_utf_16_le
;
6324 category
= coding_category_utf_16_be
;
6331 if (i
< coding_category_raw_text
)
6332 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
6333 else if (null_byte_found
)
6334 setup_coding_system (Qno_conversion
, coding
);
6335 else if ((detect_info
.rejected
& CATEGORY_MASK_ANY
)
6336 == CATEGORY_MASK_ANY
)
6337 setup_coding_system (Qraw_text
, coding
);
6338 else if (detect_info
.rejected
)
6339 for (i
= 0; i
< coding_category_raw_text
; i
++)
6340 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
6342 this = coding_categories
+ coding_priorities
[i
];
6343 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
6348 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
6349 == coding_category_utf_8_auto
)
6351 Lisp_Object coding_systems
;
6352 struct coding_detection_info detect_info
;
6355 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6356 detect_info
.found
= detect_info
.rejected
= 0;
6357 coding
->head_ascii
= 0;
6358 if (CONSP (coding_systems
)
6359 && detect_coding_utf_8 (coding
, &detect_info
))
6361 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
6362 setup_coding_system (XCAR (coding_systems
), coding
);
6364 setup_coding_system (XCDR (coding_systems
), coding
);
6367 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
6368 == coding_category_utf_16_auto
)
6370 Lisp_Object coding_systems
;
6371 struct coding_detection_info detect_info
;
6374 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6375 detect_info
.found
= detect_info
.rejected
= 0;
6376 coding
->head_ascii
= 0;
6377 if (CONSP (coding_systems
)
6378 && detect_coding_utf_16 (coding
, &detect_info
))
6380 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
6381 setup_coding_system (XCAR (coding_systems
), coding
);
6382 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
6383 setup_coding_system (XCDR (coding_systems
), coding
);
6386 coding
->mode
= saved_mode
;
6391 decode_eol (struct coding_system
*coding
)
6393 Lisp_Object eol_type
;
6394 unsigned char *p
, *pbeg
, *pend
;
6396 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6397 if (EQ (eol_type
, Qunix
) || inhibit_eol_conversion
)
6400 if (NILP (coding
->dst_object
))
6401 pbeg
= coding
->destination
;
6403 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
6404 pend
= pbeg
+ coding
->produced
;
6406 if (VECTORP (eol_type
))
6408 int eol_seen
= EOL_SEEN_NONE
;
6410 for (p
= pbeg
; p
< pend
; p
++)
6413 eol_seen
|= EOL_SEEN_LF
;
6414 else if (*p
== '\r')
6416 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
6418 eol_seen
|= EOL_SEEN_CRLF
;
6422 eol_seen
|= EOL_SEEN_CR
;
6425 /* Handle DOS-style EOLs in a file with stray ^M characters. */
6426 if ((eol_seen
& EOL_SEEN_CRLF
) != 0
6427 && (eol_seen
& EOL_SEEN_CR
) != 0
6428 && (eol_seen
& EOL_SEEN_LF
) == 0)
6429 eol_seen
= EOL_SEEN_CRLF
;
6430 else if (eol_seen
!= EOL_SEEN_NONE
6431 && eol_seen
!= EOL_SEEN_LF
6432 && eol_seen
!= EOL_SEEN_CRLF
6433 && eol_seen
!= EOL_SEEN_CR
)
6434 eol_seen
= EOL_SEEN_LF
;
6435 if (eol_seen
!= EOL_SEEN_NONE
)
6436 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
6439 if (EQ (eol_type
, Qmac
))
6441 for (p
= pbeg
; p
< pend
; p
++)
6445 else if (EQ (eol_type
, Qdos
))
6449 if (NILP (coding
->dst_object
))
6451 /* Start deleting '\r' from the tail to minimize the memory
6453 for (p
= pend
- 2; p
>= pbeg
; p
--)
6456 memmove (p
, p
+ 1, pend
-- - p
- 1);
6462 int pos_byte
= coding
->dst_pos_byte
;
6463 int pos
= coding
->dst_pos
;
6464 int pos_end
= pos
+ coding
->produced_char
- 1;
6466 while (pos
< pos_end
)
6468 p
= BYTE_POS_ADDR (pos_byte
);
6469 if (*p
== '\r' && p
[1] == '\n')
6471 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
6476 if (coding
->dst_multibyte
)
6477 pos_byte
+= BYTES_BY_CHAR_HEAD (*p
);
6482 coding
->produced
-= n
;
6483 coding
->produced_char
-= n
;
6488 /* Return a translation table (or list of them) from coding system
6489 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
6490 decoding (ENCODEP is zero). */
6493 get_translation_table (Lisp_Object attrs
, int encodep
, int *max_lookup
)
6495 Lisp_Object standard
, translation_table
;
6498 if (NILP (Venable_character_translation
))
6505 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
6506 standard
= Vstandard_translation_table_for_encode
;
6508 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
6509 standard
= Vstandard_translation_table_for_decode
;
6510 if (NILP (translation_table
))
6511 translation_table
= standard
;
6514 if (SYMBOLP (translation_table
))
6515 translation_table
= Fget (translation_table
, Qtranslation_table
);
6516 else if (CONSP (translation_table
))
6518 translation_table
= Fcopy_sequence (translation_table
);
6519 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
6520 if (SYMBOLP (XCAR (val
)))
6521 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
6523 if (CHAR_TABLE_P (standard
))
6525 if (CONSP (translation_table
))
6526 translation_table
= nconc2 (translation_table
,
6527 Fcons (standard
, Qnil
));
6529 translation_table
= Fcons (translation_table
,
6530 Fcons (standard
, Qnil
));
6537 if (CHAR_TABLE_P (translation_table
)
6538 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
6540 val
= XCHAR_TABLE (translation_table
)->extras
[1];
6541 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
6542 *max_lookup
= XFASTINT (val
);
6544 else if (CONSP (translation_table
))
6548 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
6549 if (CHAR_TABLE_P (XCAR (tail
))
6550 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
6552 Lisp_Object tailval
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
6553 if (NATNUMP (tailval
) && *max_lookup
< XFASTINT (tailval
))
6554 *max_lookup
= XFASTINT (tailval
);
6558 return translation_table
;
6561 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
6564 if (CHAR_TABLE_P (table)) \
6566 trans = CHAR_TABLE_REF (table, c); \
6567 if (CHARACTERP (trans)) \
6568 c = XFASTINT (trans), trans = Qnil; \
6570 else if (CONSP (table)) \
6574 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
6575 if (CHAR_TABLE_P (XCAR (tail))) \
6577 trans = CHAR_TABLE_REF (XCAR (tail), c); \
6578 if (CHARACTERP (trans)) \
6579 c = XFASTINT (trans), trans = Qnil; \
6580 else if (! NILP (trans)) \
6587 /* Return a translation of character(s) at BUF according to TRANS.
6588 TRANS is TO-CHAR or ((FROM . TO) ...) where
6589 FROM = [FROM-CHAR ...], TO is TO-CHAR or [TO-CHAR ...].
6590 The return value is TO-CHAR or ([FROM-CHAR ...] . TO) if a
6591 translation is found, and Qnil if not found..
6592 If BUF is too short to lookup characters in FROM, return Qt. */
6595 get_translation (Lisp_Object trans
, int *buf
, int *buf_end
)
6598 if (INTEGERP (trans
))
6600 for (; CONSP (trans
); trans
= XCDR (trans
))
6602 Lisp_Object val
= XCAR (trans
);
6603 Lisp_Object from
= XCAR (val
);
6604 int len
= ASIZE (from
);
6607 for (i
= 0; i
< len
; i
++)
6609 if (buf
+ i
== buf_end
)
6611 if (XINT (AREF (from
, i
)) != buf
[i
])
6622 produce_chars (struct coding_system
*coding
, Lisp_Object translation_table
,
6625 unsigned char *dst
= coding
->destination
+ coding
->produced
;
6626 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
6628 EMACS_INT produced_chars
= 0;
6631 if (! coding
->chars_at_source
)
6633 /* Source characters are in coding->charbuf. */
6634 int *buf
= coding
->charbuf
;
6635 int *buf_end
= buf
+ coding
->charbuf_used
;
6637 if (EQ (coding
->src_object
, coding
->dst_object
))
6639 coding_set_source (coding
);
6640 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
6643 while (buf
< buf_end
)
6649 int from_nchars
= 1, to_nchars
= 1;
6650 Lisp_Object trans
= Qnil
;
6652 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6655 trans
= get_translation (trans
, buf
, buf_end
);
6656 if (INTEGERP (trans
))
6658 else if (CONSP (trans
))
6660 from_nchars
= ASIZE (XCAR (trans
));
6661 trans
= XCDR (trans
);
6662 if (INTEGERP (trans
))
6666 to_nchars
= ASIZE (trans
);
6667 c
= XINT (AREF (trans
, 0));
6670 else if (EQ (trans
, Qt
) && ! last_block
)
6674 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
6676 dst
= alloc_destination (coding
,
6678 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
6680 if (EQ (coding
->src_object
, coding
->dst_object
))
6682 coding_set_source (coding
);
6683 dst_end
= (((unsigned char *) coding
->source
)
6684 + coding
->consumed
);
6687 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6690 for (i
= 0; i
< to_nchars
; i
++)
6693 c
= XINT (AREF (trans
, i
));
6694 if (coding
->dst_multibyte
6695 || ! CHAR_BYTE8_P (c
))
6696 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
6698 *dst
++ = CHAR_TO_BYTE8 (c
);
6700 produced_chars
+= to_nchars
;
6704 /* This is an annotation datum. (-C) is the length. */
6707 carryover
= buf_end
- buf
;
6711 /* Source characters are at coding->source. */
6712 const unsigned char *src
= coding
->source
;
6713 const unsigned char *src_end
= src
+ coding
->consumed
;
6715 if (EQ (coding
->dst_object
, coding
->src_object
))
6716 dst_end
= (unsigned char *) src
;
6717 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
6719 if (coding
->src_multibyte
)
6722 EMACS_INT consumed_chars
= 0;
6726 const unsigned char *src_base
= src
;
6732 if (EQ (coding
->src_object
, coding
->dst_object
))
6733 dst_end
= (unsigned char *) src
;
6736 EMACS_INT offset
= src
- coding
->source
;
6738 dst
= alloc_destination (coding
, src_end
- src
+ 1,
6740 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6741 coding_set_source (coding
);
6742 src
= coding
->source
+ offset
;
6743 src_end
= coding
->source
+ coding
->src_bytes
;
6744 if (EQ (coding
->src_object
, coding
->dst_object
))
6745 dst_end
= (unsigned char *) src
;
6755 while (src
< src_end
)
6760 if (dst
>= dst_end
- 1)
6762 if (EQ (coding
->src_object
, coding
->dst_object
))
6763 dst_end
= (unsigned char *) src
;
6764 if (dst
>= dst_end
- 1)
6766 EMACS_INT offset
= src
- coding
->source
;
6767 EMACS_INT more_bytes
;
6769 if (EQ (coding
->src_object
, coding
->dst_object
))
6770 more_bytes
= ((src_end
- src
) / 2) + 2;
6772 more_bytes
= src_end
- src
+ 2;
6773 dst
= alloc_destination (coding
, more_bytes
, dst
);
6774 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6775 coding_set_source (coding
);
6776 src
= coding
->source
+ offset
;
6777 src_end
= coding
->source
+ coding
->src_bytes
;
6778 if (EQ (coding
->src_object
, coding
->dst_object
))
6779 dst_end
= (unsigned char *) src
;
6787 if (!EQ (coding
->src_object
, coding
->dst_object
))
6789 EMACS_INT require
= coding
->src_bytes
- coding
->dst_bytes
;
6793 EMACS_INT offset
= src
- coding
->source
;
6795 dst
= alloc_destination (coding
, require
, dst
);
6796 coding_set_source (coding
);
6797 src
= coding
->source
+ offset
;
6798 src_end
= coding
->source
+ coding
->src_bytes
;
6801 produced_chars
= coding
->consumed_char
;
6802 while (src
< src_end
)
6807 produced
= dst
- (coding
->destination
+ coding
->produced
);
6808 if (BUFFERP (coding
->dst_object
) && produced_chars
> 0)
6809 insert_from_gap (produced_chars
, produced
);
6810 coding
->produced
+= produced
;
6811 coding
->produced_char
+= produced_chars
;
6815 /* Compose text in CODING->object according to the annotation data at
6816 CHARBUF. CHARBUF is an array:
6817 [ -LENGTH ANNOTATION_MASK NCHARS NBYTES METHOD [ COMPONENTS... ] ]
6821 produce_composition (struct coding_system
*coding
, int *charbuf
, EMACS_INT pos
)
6825 enum composition_method method
;
6826 Lisp_Object components
;
6828 len
= -charbuf
[0] - MAX_ANNOTATION_LENGTH
;
6829 to
= pos
+ charbuf
[2];
6830 method
= (enum composition_method
) (charbuf
[4]);
6832 if (method
== COMPOSITION_RELATIVE
)
6836 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6839 if (method
== COMPOSITION_WITH_RULE
)
6840 len
= charbuf
[2] * 3 - 2;
6841 charbuf
+= MAX_ANNOTATION_LENGTH
;
6842 /* charbuf = [ CHRA ... CHAR] or [ CHAR -2 RULE ... CHAR ] */
6843 for (i
= j
= 0; i
< len
&& charbuf
[i
] != -1; i
++, j
++)
6845 if (charbuf
[i
] >= 0)
6846 args
[j
] = make_number (charbuf
[i
]);
6850 args
[j
] = make_number (charbuf
[i
] % 0x100);
6853 components
= (i
== j
? Fstring (j
, args
) : Fvector (j
, args
));
6855 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6859 /* Put `charset' property on text in CODING->object according to
6860 the annotation data at CHARBUF. CHARBUF is an array:
6861 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6865 produce_charset (struct coding_system
*coding
, int *charbuf
, EMACS_INT pos
)
6867 EMACS_INT from
= pos
- charbuf
[2];
6868 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6870 Fput_text_property (make_number (from
), make_number (pos
),
6871 Qcharset
, CHARSET_NAME (charset
),
6872 coding
->dst_object
);
6876 #define CHARBUF_SIZE 0x4000
6878 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6880 int size = CHARBUF_SIZE; \
6882 coding->charbuf = NULL; \
6883 while (size > 1024) \
6885 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6886 if (coding->charbuf) \
6890 if (! coding->charbuf) \
6892 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6893 return coding->result; \
6895 coding->charbuf_size = size; \
6900 produce_annotation (struct coding_system
*coding
, EMACS_INT pos
)
6902 int *charbuf
= coding
->charbuf
;
6903 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6905 if (NILP (coding
->dst_object
))
6908 while (charbuf
< charbuf_end
)
6914 int len
= -*charbuf
;
6919 case CODING_ANNOTATE_COMPOSITION_MASK
:
6920 produce_composition (coding
, charbuf
, pos
);
6922 case CODING_ANNOTATE_CHARSET_MASK
:
6923 produce_charset (coding
, charbuf
, pos
);
6931 /* Decode the data at CODING->src_object into CODING->dst_object.
6932 CODING->src_object is a buffer, a string, or nil.
6933 CODING->dst_object is a buffer.
6935 If CODING->src_object is a buffer, it must be the current buffer.
6936 In this case, if CODING->src_pos is positive, it is a position of
6937 the source text in the buffer, otherwise, the source text is in the
6938 gap area of the buffer, and CODING->src_pos specifies the offset of
6939 the text from GPT (which must be the same as PT). If this is the
6940 same buffer as CODING->dst_object, CODING->src_pos must be
6943 If CODING->src_object is a string, CODING->src_pos is an index to
6946 If CODING->src_object is nil, CODING->source must already point to
6947 the non-relocatable memory area. In this case, CODING->src_pos is
6948 an offset from CODING->source.
6950 The decoded data is inserted at the current point of the buffer
6955 decode_coding (struct coding_system
*coding
)
6958 Lisp_Object undo_list
;
6959 Lisp_Object translation_table
;
6960 struct ccl_spec cclspec
;
6964 if (BUFFERP (coding
->src_object
)
6965 && coding
->src_pos
> 0
6966 && coding
->src_pos
< GPT
6967 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6968 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6971 if (BUFFERP (coding
->dst_object
))
6973 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6974 set_buffer_internal (XBUFFER (coding
->dst_object
));
6976 move_gap_both (PT
, PT_BYTE
);
6977 undo_list
= BVAR (current_buffer
, undo_list
);
6978 BVAR (current_buffer
, undo_list
) = Qt
;
6981 coding
->consumed
= coding
->consumed_char
= 0;
6982 coding
->produced
= coding
->produced_char
= 0;
6983 coding
->chars_at_source
= 0;
6984 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6987 ALLOC_CONVERSION_WORK_AREA (coding
);
6989 attrs
= CODING_ID_ATTRS (coding
->id
);
6990 translation_table
= get_translation_table (attrs
, 0, NULL
);
6993 if (coding
->decoder
== decode_coding_ccl
)
6995 coding
->spec
.ccl
= &cclspec
;
6996 setup_ccl_program (&cclspec
.ccl
, CODING_CCL_DECODER (coding
));
7000 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
7002 coding_set_source (coding
);
7003 coding
->annotated
= 0;
7004 coding
->charbuf_used
= carryover
;
7005 (*(coding
->decoder
)) (coding
);
7006 coding_set_destination (coding
);
7007 carryover
= produce_chars (coding
, translation_table
, 0);
7008 if (coding
->annotated
)
7009 produce_annotation (coding
, pos
);
7010 for (i
= 0; i
< carryover
; i
++)
7012 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
7014 while (coding
->result
== CODING_RESULT_INSUFFICIENT_DST
7015 || (coding
->consumed
< coding
->src_bytes
7016 && (coding
->result
== CODING_RESULT_SUCCESS
7017 || coding
->result
== CODING_RESULT_INVALID_SRC
)));
7021 coding_set_destination (coding
);
7022 coding
->charbuf_used
= carryover
;
7023 produce_chars (coding
, translation_table
, 1);
7026 coding
->carryover_bytes
= 0;
7027 if (coding
->consumed
< coding
->src_bytes
)
7029 int nbytes
= coding
->src_bytes
- coding
->consumed
;
7030 const unsigned char *src
;
7032 coding_set_source (coding
);
7033 coding_set_destination (coding
);
7034 src
= coding
->source
+ coding
->consumed
;
7036 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
7038 /* Flush out unprocessed data as binary chars. We are sure
7039 that the number of data is less than the size of
7041 coding
->charbuf_used
= 0;
7042 coding
->chars_at_source
= 0;
7044 while (nbytes
-- > 0)
7049 c
= BYTE8_TO_CHAR (c
);
7050 coding
->charbuf
[coding
->charbuf_used
++] = c
;
7052 produce_chars (coding
, Qnil
, 1);
7056 /* Record unprocessed bytes in coding->carryover. We are
7057 sure that the number of data is less than the size of
7058 coding->carryover. */
7059 unsigned char *p
= coding
->carryover
;
7061 if (nbytes
> sizeof coding
->carryover
)
7062 nbytes
= sizeof coding
->carryover
;
7063 coding
->carryover_bytes
= nbytes
;
7064 while (nbytes
-- > 0)
7067 coding
->consumed
= coding
->src_bytes
;
7070 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
)
7071 && !inhibit_eol_conversion
)
7072 decode_eol (coding
);
7073 if (BUFFERP (coding
->dst_object
))
7075 BVAR (current_buffer
, undo_list
) = undo_list
;
7076 record_insert (coding
->dst_pos
, coding
->produced_char
);
7078 return coding
->result
;
7082 /* Extract an annotation datum from a composition starting at POS and
7083 ending before LIMIT of CODING->src_object (buffer or string), store
7084 the data in BUF, set *STOP to a starting position of the next
7085 composition (if any) or to LIMIT, and return the address of the
7086 next element of BUF.
7088 If such an annotation is not found, set *STOP to a starting
7089 position of a composition after POS (if any) or to LIMIT, and
7093 handle_composition_annotation (EMACS_INT pos
, EMACS_INT limit
,
7094 struct coding_system
*coding
, int *buf
,
7097 EMACS_INT start
, end
;
7100 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
7103 else if (start
> pos
)
7109 /* We found a composition. Store the corresponding
7110 annotation data in BUF. */
7112 enum composition_method method
= COMPOSITION_METHOD (prop
);
7113 int nchars
= COMPOSITION_LENGTH (prop
);
7115 ADD_COMPOSITION_DATA (buf
, nchars
, 0, method
);
7116 if (method
!= COMPOSITION_RELATIVE
)
7118 Lisp_Object components
;
7121 components
= COMPOSITION_COMPONENTS (prop
);
7122 if (VECTORP (components
))
7124 len
= XVECTOR (components
)->size
;
7125 for (i
= 0; i
< len
; i
++)
7126 *buf
++ = XINT (AREF (components
, i
));
7128 else if (STRINGP (components
))
7130 len
= SCHARS (components
);
7134 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
7138 else if (INTEGERP (components
))
7141 *buf
++ = XINT (components
);
7143 else if (CONSP (components
))
7145 for (len
= 0; CONSP (components
);
7146 len
++, components
= XCDR (components
))
7147 *buf
++ = XINT (XCAR (components
));
7155 if (find_composition (end
, limit
, &start
, &end
, &prop
,
7166 /* Extract an annotation datum from a text property `charset' at POS of
7167 CODING->src_object (buffer of string), store the data in BUF, set
7168 *STOP to the position where the value of `charset' property changes
7169 (limiting by LIMIT), and return the address of the next element of
7172 If the property value is nil, set *STOP to the position where the
7173 property value is non-nil (limiting by LIMIT), and return BUF. */
7176 handle_charset_annotation (EMACS_INT pos
, EMACS_INT limit
,
7177 struct coding_system
*coding
, int *buf
,
7180 Lisp_Object val
, next
;
7183 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
7184 if (! NILP (val
) && CHARSETP (val
))
7185 id
= XINT (CHARSET_SYMBOL_ID (val
));
7188 ADD_CHARSET_DATA (buf
, 0, id
);
7189 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
7191 make_number (limit
));
7192 *stop
= XINT (next
);
7198 consume_chars (struct coding_system
*coding
, Lisp_Object translation_table
,
7201 int *buf
= coding
->charbuf
;
7202 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
7203 const unsigned char *src
= coding
->source
+ coding
->consumed
;
7204 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
7205 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
7206 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
7207 int multibytep
= coding
->src_multibyte
;
7208 Lisp_Object eol_type
;
7210 EMACS_INT stop
, stop_composition
, stop_charset
;
7211 int *lookup_buf
= NULL
;
7213 if (! NILP (translation_table
))
7214 lookup_buf
= alloca (sizeof (int) * max_lookup
);
7216 eol_type
= inhibit_eol_conversion
? Qunix
: CODING_ID_EOL_TYPE (coding
->id
);
7217 if (VECTORP (eol_type
))
7220 /* Note: composition handling is not yet implemented. */
7221 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
7223 if (NILP (coding
->src_object
))
7224 stop
= stop_composition
= stop_charset
= end_pos
;
7227 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
7228 stop
= stop_composition
= pos
;
7230 stop
= stop_composition
= end_pos
;
7231 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
7232 stop
= stop_charset
= pos
;
7234 stop_charset
= end_pos
;
7237 /* Compensate for CRLF and conversion. */
7238 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
7239 while (buf
< buf_end
)
7247 if (pos
== stop_composition
)
7248 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
7249 buf
, &stop_composition
);
7250 if (pos
== stop_charset
)
7251 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
7252 buf
, &stop_charset
);
7253 stop
= (stop_composition
< stop_charset
7254 ? stop_composition
: stop_charset
);
7261 if (coding
->encoder
== encode_coding_raw_text
7262 || coding
->encoder
== encode_coding_ccl
)
7264 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
7265 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
+= bytes
;
7267 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
7270 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
++;
7271 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
7273 if (! EQ (eol_type
, Qunix
))
7277 if (EQ (eol_type
, Qdos
))
7285 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
7290 int from_nchars
= 1, to_nchars
= 1;
7291 int *lookup_buf_end
;
7292 const unsigned char *p
= src
;
7296 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
7297 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
7298 lookup_buf_end
= lookup_buf
+ i
;
7299 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
);
7300 if (INTEGERP (trans
))
7302 else if (CONSP (trans
))
7304 from_nchars
= ASIZE (XCAR (trans
));
7305 trans
= XCDR (trans
);
7306 if (INTEGERP (trans
))
7310 to_nchars
= ASIZE (trans
);
7311 if (buf
+ to_nchars
> buf_end
)
7313 c
= XINT (AREF (trans
, 0));
7319 for (i
= 1; i
< to_nchars
; i
++)
7320 *buf
++ = XINT (AREF (trans
, i
));
7321 for (i
= 1; i
< from_nchars
; i
++, pos
++)
7322 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
7326 coding
->consumed
= src
- coding
->source
;
7327 coding
->consumed_char
= pos
- coding
->src_pos
;
7328 coding
->charbuf_used
= buf
- coding
->charbuf
;
7329 coding
->chars_at_source
= 0;
7333 /* Encode the text at CODING->src_object into CODING->dst_object.
7334 CODING->src_object is a buffer or a string.
7335 CODING->dst_object is a buffer or nil.
7337 If CODING->src_object is a buffer, it must be the current buffer.
7338 In this case, if CODING->src_pos is positive, it is a position of
7339 the source text in the buffer, otherwise. the source text is in the
7340 gap area of the buffer, and coding->src_pos specifies the offset of
7341 the text from GPT (which must be the same as PT). If this is the
7342 same buffer as CODING->dst_object, CODING->src_pos must be
7343 negative and CODING should not have `pre-write-conversion'.
7345 If CODING->src_object is a string, CODING should not have
7346 `pre-write-conversion'.
7348 If CODING->dst_object is a buffer, the encoded data is inserted at
7349 the current point of that buffer.
7351 If CODING->dst_object is nil, the encoded data is placed at the
7352 memory area specified by CODING->destination. */
7355 encode_coding (struct coding_system
*coding
)
7358 Lisp_Object translation_table
;
7360 struct ccl_spec cclspec
;
7362 attrs
= CODING_ID_ATTRS (coding
->id
);
7363 if (coding
->encoder
== encode_coding_raw_text
)
7364 translation_table
= Qnil
, max_lookup
= 0;
7366 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
7368 if (BUFFERP (coding
->dst_object
))
7370 set_buffer_internal (XBUFFER (coding
->dst_object
));
7371 coding
->dst_multibyte
7372 = ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
7375 coding
->consumed
= coding
->consumed_char
= 0;
7376 coding
->produced
= coding
->produced_char
= 0;
7377 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
7380 ALLOC_CONVERSION_WORK_AREA (coding
);
7382 if (coding
->encoder
== encode_coding_ccl
)
7384 coding
->spec
.ccl
= &cclspec
;
7385 setup_ccl_program (&cclspec
.ccl
, CODING_CCL_ENCODER (coding
));
7388 coding_set_source (coding
);
7389 consume_chars (coding
, translation_table
, max_lookup
);
7390 coding_set_destination (coding
);
7391 (*(coding
->encoder
)) (coding
);
7392 } while (coding
->consumed_char
< coding
->src_chars
);
7394 if (BUFFERP (coding
->dst_object
) && coding
->produced_char
> 0)
7395 insert_from_gap (coding
->produced_char
, coding
->produced
);
7397 return (coding
->result
);
7401 /* Name (or base name) of work buffer for code conversion. */
7402 static Lisp_Object Vcode_conversion_workbuf_name
;
7404 /* A working buffer used by the top level conversion. Once it is
7405 created, it is never destroyed. It has the name
7406 Vcode_conversion_workbuf_name. The other working buffers are
7407 destroyed after the use is finished, and their names are modified
7408 versions of Vcode_conversion_workbuf_name. */
7409 static Lisp_Object Vcode_conversion_reused_workbuf
;
7411 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
7412 static int reused_workbuf_in_use
;
7415 /* Return a working buffer of code conversion. MULTIBYTE specifies the
7416 multibyteness of returning buffer. */
7419 make_conversion_work_buffer (int multibyte
)
7421 Lisp_Object name
, workbuf
;
7422 struct buffer
*current
;
7424 if (reused_workbuf_in_use
++)
7426 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
7427 workbuf
= Fget_buffer_create (name
);
7431 if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf
)))
7432 Vcode_conversion_reused_workbuf
7433 = Fget_buffer_create (Vcode_conversion_workbuf_name
);
7434 workbuf
= Vcode_conversion_reused_workbuf
;
7436 current
= current_buffer
;
7437 set_buffer_internal (XBUFFER (workbuf
));
7438 /* We can't allow modification hooks to run in the work buffer. For
7439 instance, directory_files_internal assumes that file decoding
7440 doesn't compile new regexps. */
7441 Fset (Fmake_local_variable (Qinhibit_modification_hooks
), Qt
);
7443 BVAR (current_buffer
, undo_list
) = Qt
;
7444 BVAR (current_buffer
, enable_multibyte_characters
) = multibyte
? Qt
: Qnil
;
7445 set_buffer_internal (current
);
7451 code_conversion_restore (Lisp_Object arg
)
7453 Lisp_Object current
, workbuf
;
7454 struct gcpro gcpro1
;
7457 current
= XCAR (arg
);
7458 workbuf
= XCDR (arg
);
7459 if (! NILP (workbuf
))
7461 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
7462 reused_workbuf_in_use
= 0;
7463 else if (! NILP (Fbuffer_live_p (workbuf
)))
7464 Fkill_buffer (workbuf
);
7466 set_buffer_internal (XBUFFER (current
));
7472 code_conversion_save (int with_work_buf
, int multibyte
)
7474 Lisp_Object workbuf
= Qnil
;
7477 workbuf
= make_conversion_work_buffer (multibyte
);
7478 record_unwind_protect (code_conversion_restore
,
7479 Fcons (Fcurrent_buffer (), workbuf
));
7484 decode_coding_gap (struct coding_system
*coding
,
7485 EMACS_INT chars
, EMACS_INT bytes
)
7487 int count
= SPECPDL_INDEX ();
7490 code_conversion_save (0, 0);
7492 coding
->src_object
= Fcurrent_buffer ();
7493 coding
->src_chars
= chars
;
7494 coding
->src_bytes
= bytes
;
7495 coding
->src_pos
= -chars
;
7496 coding
->src_pos_byte
= -bytes
;
7497 coding
->src_multibyte
= chars
< bytes
;
7498 coding
->dst_object
= coding
->src_object
;
7499 coding
->dst_pos
= PT
;
7500 coding
->dst_pos_byte
= PT_BYTE
;
7501 coding
->dst_multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
7503 if (CODING_REQUIRE_DETECTION (coding
))
7504 detect_coding (coding
);
7506 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
7507 current_buffer
->text
->inhibit_shrinking
= 1;
7508 decode_coding (coding
);
7509 current_buffer
->text
->inhibit_shrinking
= 0;
7511 attrs
= CODING_ID_ATTRS (coding
->id
);
7512 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7514 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7517 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7518 val
= call1 (CODING_ATTR_POST_READ (attrs
),
7519 make_number (coding
->produced_char
));
7521 coding
->produced_char
+= Z
- prev_Z
;
7522 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7525 unbind_to (count
, Qnil
);
7526 return coding
->result
;
7530 encode_coding_gap (struct coding_system
*coding
,
7531 EMACS_INT chars
, EMACS_INT bytes
)
7533 int count
= SPECPDL_INDEX ();
7535 code_conversion_save (0, 0);
7537 coding
->src_object
= Fcurrent_buffer ();
7538 coding
->src_chars
= chars
;
7539 coding
->src_bytes
= bytes
;
7540 coding
->src_pos
= -chars
;
7541 coding
->src_pos_byte
= -bytes
;
7542 coding
->src_multibyte
= chars
< bytes
;
7543 coding
->dst_object
= coding
->src_object
;
7544 coding
->dst_pos
= PT
;
7545 coding
->dst_pos_byte
= PT_BYTE
;
7547 encode_coding (coding
);
7549 unbind_to (count
, Qnil
);
7550 return coding
->result
;
7554 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
7555 SRC_OBJECT into DST_OBJECT by coding context CODING.
7557 SRC_OBJECT is a buffer, a string, or Qnil.
7559 If it is a buffer, the text is at point of the buffer. FROM and TO
7560 are positions in the buffer.
7562 If it is a string, the text is at the beginning of the string.
7563 FROM and TO are indices to the string.
7565 If it is nil, the text is at coding->source. FROM and TO are
7566 indices to coding->source.
7568 DST_OBJECT is a buffer, Qt, or Qnil.
7570 If it is a buffer, the decoded text is inserted at point of the
7571 buffer. If the buffer is the same as SRC_OBJECT, the source text
7574 If it is Qt, a string is made from the decoded text, and
7575 set in CODING->dst_object.
7577 If it is Qnil, the decoded text is stored at CODING->destination.
7578 The caller must allocate CODING->dst_bytes bytes at
7579 CODING->destination by xmalloc. If the decoded text is longer than
7580 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
7584 decode_coding_object (struct coding_system
*coding
,
7585 Lisp_Object src_object
,
7586 EMACS_INT from
, EMACS_INT from_byte
,
7587 EMACS_INT to
, EMACS_INT to_byte
,
7588 Lisp_Object dst_object
)
7590 int count
= SPECPDL_INDEX ();
7591 unsigned char *destination
IF_LINT (= NULL
);
7592 EMACS_INT dst_bytes
IF_LINT (= 0);
7593 EMACS_INT chars
= to
- from
;
7594 EMACS_INT bytes
= to_byte
- from_byte
;
7596 int saved_pt
= -1, saved_pt_byte
IF_LINT (= 0);
7597 int need_marker_adjustment
= 0;
7598 Lisp_Object old_deactivate_mark
;
7600 old_deactivate_mark
= Vdeactivate_mark
;
7602 if (NILP (dst_object
))
7604 destination
= coding
->destination
;
7605 dst_bytes
= coding
->dst_bytes
;
7608 coding
->src_object
= src_object
;
7609 coding
->src_chars
= chars
;
7610 coding
->src_bytes
= bytes
;
7611 coding
->src_multibyte
= chars
< bytes
;
7613 if (STRINGP (src_object
))
7615 coding
->src_pos
= from
;
7616 coding
->src_pos_byte
= from_byte
;
7618 else if (BUFFERP (src_object
))
7620 set_buffer_internal (XBUFFER (src_object
));
7622 move_gap_both (from
, from_byte
);
7623 if (EQ (src_object
, dst_object
))
7625 struct Lisp_Marker
*tail
;
7627 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7629 tail
->need_adjustment
7630 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7631 need_marker_adjustment
|= tail
->need_adjustment
;
7633 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7634 TEMP_SET_PT_BOTH (from
, from_byte
);
7635 current_buffer
->text
->inhibit_shrinking
= 1;
7636 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7637 coding
->src_pos
= -chars
;
7638 coding
->src_pos_byte
= -bytes
;
7642 coding
->src_pos
= from
;
7643 coding
->src_pos_byte
= from_byte
;
7647 if (CODING_REQUIRE_DETECTION (coding
))
7648 detect_coding (coding
);
7649 attrs
= CODING_ID_ATTRS (coding
->id
);
7651 if (EQ (dst_object
, Qt
)
7652 || (! NILP (CODING_ATTR_POST_READ (attrs
))
7653 && NILP (dst_object
)))
7655 coding
->dst_multibyte
= !CODING_FOR_UNIBYTE (coding
);
7656 coding
->dst_object
= code_conversion_save (1, coding
->dst_multibyte
);
7657 coding
->dst_pos
= BEG
;
7658 coding
->dst_pos_byte
= BEG_BYTE
;
7660 else if (BUFFERP (dst_object
))
7662 code_conversion_save (0, 0);
7663 coding
->dst_object
= dst_object
;
7664 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
7665 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
7666 coding
->dst_multibyte
7667 = ! NILP (BVAR (XBUFFER (dst_object
), enable_multibyte_characters
));
7671 code_conversion_save (0, 0);
7672 coding
->dst_object
= Qnil
;
7673 /* Most callers presume this will return a multibyte result, and they
7674 won't use `binary' or `raw-text' anyway, so let's not worry about
7675 CODING_FOR_UNIBYTE. */
7676 coding
->dst_multibyte
= 1;
7679 decode_coding (coding
);
7681 if (BUFFERP (coding
->dst_object
))
7682 set_buffer_internal (XBUFFER (coding
->dst_object
));
7684 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7686 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7687 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7690 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7691 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7692 old_deactivate_mark
);
7693 val
= safe_call1 (CODING_ATTR_POST_READ (attrs
),
7694 make_number (coding
->produced_char
));
7697 coding
->produced_char
+= Z
- prev_Z
;
7698 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7701 if (EQ (dst_object
, Qt
))
7703 coding
->dst_object
= Fbuffer_string ();
7705 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
7707 set_buffer_internal (XBUFFER (coding
->dst_object
));
7708 if (dst_bytes
< coding
->produced
)
7710 destination
= xrealloc (destination
, coding
->produced
);
7713 record_conversion_result (coding
,
7714 CODING_RESULT_INSUFFICIENT_MEM
);
7715 unbind_to (count
, Qnil
);
7718 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
7719 move_gap_both (BEGV
, BEGV_BYTE
);
7720 memcpy (destination
, BEGV_ADDR
, coding
->produced
);
7721 coding
->destination
= destination
;
7727 /* This is the case of:
7728 (BUFFERP (src_object) && EQ (src_object, dst_object))
7729 As we have moved PT while replacing the original buffer
7730 contents, we must recover it now. */
7731 set_buffer_internal (XBUFFER (src_object
));
7732 current_buffer
->text
->inhibit_shrinking
= 0;
7733 if (saved_pt
< from
)
7734 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7735 else if (saved_pt
< from
+ chars
)
7736 TEMP_SET_PT_BOTH (from
, from_byte
);
7737 else if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
7738 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7739 saved_pt_byte
+ (coding
->produced
- bytes
));
7741 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7742 saved_pt_byte
+ (coding
->produced
- bytes
));
7744 if (need_marker_adjustment
)
7746 struct Lisp_Marker
*tail
;
7748 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7749 if (tail
->need_adjustment
)
7751 tail
->need_adjustment
= 0;
7752 if (tail
->insertion_type
)
7754 tail
->bytepos
= from_byte
;
7755 tail
->charpos
= from
;
7759 tail
->bytepos
= from_byte
+ coding
->produced
;
7761 = (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
7762 ? tail
->bytepos
: from
+ coding
->produced_char
);
7768 Vdeactivate_mark
= old_deactivate_mark
;
7769 unbind_to (count
, coding
->dst_object
);
7774 encode_coding_object (struct coding_system
*coding
,
7775 Lisp_Object src_object
,
7776 EMACS_INT from
, EMACS_INT from_byte
,
7777 EMACS_INT to
, EMACS_INT to_byte
,
7778 Lisp_Object dst_object
)
7780 int count
= SPECPDL_INDEX ();
7781 EMACS_INT chars
= to
- from
;
7782 EMACS_INT bytes
= to_byte
- from_byte
;
7784 int saved_pt
= -1, saved_pt_byte
IF_LINT (= 0);
7785 int need_marker_adjustment
= 0;
7786 int kill_src_buffer
= 0;
7787 Lisp_Object old_deactivate_mark
;
7789 old_deactivate_mark
= Vdeactivate_mark
;
7791 coding
->src_object
= src_object
;
7792 coding
->src_chars
= chars
;
7793 coding
->src_bytes
= bytes
;
7794 coding
->src_multibyte
= chars
< bytes
;
7796 attrs
= CODING_ID_ATTRS (coding
->id
);
7798 if (EQ (src_object
, dst_object
))
7800 struct Lisp_Marker
*tail
;
7802 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7804 tail
->need_adjustment
7805 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7806 need_marker_adjustment
|= tail
->need_adjustment
;
7810 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
7812 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
7813 set_buffer_internal (XBUFFER (coding
->src_object
));
7814 if (STRINGP (src_object
))
7815 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
7816 else if (BUFFERP (src_object
))
7817 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
7819 insert_1_both ((char *) coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
7821 if (EQ (src_object
, dst_object
))
7823 set_buffer_internal (XBUFFER (src_object
));
7824 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7825 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7826 set_buffer_internal (XBUFFER (coding
->src_object
));
7830 Lisp_Object args
[3];
7831 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7833 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7834 old_deactivate_mark
);
7835 args
[0] = CODING_ATTR_PRE_WRITE (attrs
);
7836 args
[1] = make_number (BEG
);
7837 args
[2] = make_number (Z
);
7838 safe_call (3, args
);
7841 if (XBUFFER (coding
->src_object
) != current_buffer
)
7842 kill_src_buffer
= 1;
7843 coding
->src_object
= Fcurrent_buffer ();
7845 move_gap_both (BEG
, BEG_BYTE
);
7846 coding
->src_chars
= Z
- BEG
;
7847 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
7848 coding
->src_pos
= BEG
;
7849 coding
->src_pos_byte
= BEG_BYTE
;
7850 coding
->src_multibyte
= Z
< Z_BYTE
;
7852 else if (STRINGP (src_object
))
7854 code_conversion_save (0, 0);
7855 coding
->src_pos
= from
;
7856 coding
->src_pos_byte
= from_byte
;
7858 else if (BUFFERP (src_object
))
7860 code_conversion_save (0, 0);
7861 set_buffer_internal (XBUFFER (src_object
));
7862 if (EQ (src_object
, dst_object
))
7864 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7865 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
7866 coding
->src_pos
= 0;
7867 coding
->src_pos_byte
= 0;
7871 if (from
< GPT
&& to
>= GPT
)
7872 move_gap_both (from
, from_byte
);
7873 coding
->src_pos
= from
;
7874 coding
->src_pos_byte
= from_byte
;
7878 code_conversion_save (0, 0);
7880 if (BUFFERP (dst_object
))
7882 coding
->dst_object
= dst_object
;
7883 if (EQ (src_object
, dst_object
))
7885 coding
->dst_pos
= from
;
7886 coding
->dst_pos_byte
= from_byte
;
7890 struct buffer
*current
= current_buffer
;
7892 set_buffer_temp (XBUFFER (dst_object
));
7893 coding
->dst_pos
= PT
;
7894 coding
->dst_pos_byte
= PT_BYTE
;
7895 move_gap_both (coding
->dst_pos
, coding
->dst_pos_byte
);
7896 set_buffer_temp (current
);
7898 coding
->dst_multibyte
7899 = ! NILP (BVAR (XBUFFER (dst_object
), enable_multibyte_characters
));
7901 else if (EQ (dst_object
, Qt
))
7903 coding
->dst_object
= Qnil
;
7904 coding
->dst_bytes
= coding
->src_chars
;
7905 if (coding
->dst_bytes
== 0)
7906 coding
->dst_bytes
= 1;
7907 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
7908 coding
->dst_multibyte
= 0;
7912 coding
->dst_object
= Qnil
;
7913 coding
->dst_multibyte
= 0;
7916 encode_coding (coding
);
7918 if (EQ (dst_object
, Qt
))
7920 if (BUFFERP (coding
->dst_object
))
7921 coding
->dst_object
= Fbuffer_string ();
7925 = make_unibyte_string ((char *) coding
->destination
,
7927 xfree (coding
->destination
);
7933 /* This is the case of:
7934 (BUFFERP (src_object) && EQ (src_object, dst_object))
7935 As we have moved PT while replacing the original buffer
7936 contents, we must recover it now. */
7937 set_buffer_internal (XBUFFER (src_object
));
7938 if (saved_pt
< from
)
7939 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7940 else if (saved_pt
< from
+ chars
)
7941 TEMP_SET_PT_BOTH (from
, from_byte
);
7942 else if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
7943 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7944 saved_pt_byte
+ (coding
->produced
- bytes
));
7946 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7947 saved_pt_byte
+ (coding
->produced
- bytes
));
7949 if (need_marker_adjustment
)
7951 struct Lisp_Marker
*tail
;
7953 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7954 if (tail
->need_adjustment
)
7956 tail
->need_adjustment
= 0;
7957 if (tail
->insertion_type
)
7959 tail
->bytepos
= from_byte
;
7960 tail
->charpos
= from
;
7964 tail
->bytepos
= from_byte
+ coding
->produced
;
7966 = (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
7967 ? tail
->bytepos
: from
+ coding
->produced_char
);
7973 if (kill_src_buffer
)
7974 Fkill_buffer (coding
->src_object
);
7976 Vdeactivate_mark
= old_deactivate_mark
;
7977 unbind_to (count
, Qnil
);
7982 preferred_coding_system (void)
7984 int id
= coding_categories
[coding_priorities
[0]].id
;
7986 return CODING_ID_NAME (id
);
7991 /*** 8. Emacs Lisp library functions ***/
7993 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7994 doc
: /* Return t if OBJECT is nil or a coding-system.
7995 See the documentation of `define-coding-system' for information
7996 about coding-system objects. */)
7997 (Lisp_Object object
)
8000 || CODING_SYSTEM_ID (object
) >= 0)
8002 if (! SYMBOLP (object
)
8003 || NILP (Fget (object
, Qcoding_system_define_form
)))
8008 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
8009 Sread_non_nil_coding_system
, 1, 1, 0,
8010 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
8011 (Lisp_Object prompt
)
8016 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
8017 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
8019 while (SCHARS (val
) == 0);
8020 return (Fintern (val
, Qnil
));
8023 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
8024 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
8025 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
8026 Ignores case when completing coding systems (all Emacs coding systems
8027 are lower-case). */)
8028 (Lisp_Object prompt
, Lisp_Object default_coding_system
)
8031 int count
= SPECPDL_INDEX ();
8033 if (SYMBOLP (default_coding_system
))
8034 default_coding_system
= SYMBOL_NAME (default_coding_system
);
8035 specbind (Qcompletion_ignore_case
, Qt
);
8036 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
8037 Qt
, Qnil
, Qcoding_system_history
,
8038 default_coding_system
, Qnil
);
8039 unbind_to (count
, Qnil
);
8040 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
8043 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
8045 doc
: /* Check validity of CODING-SYSTEM.
8046 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
8047 It is valid if it is nil or a symbol defined as a coding system by the
8048 function `define-coding-system'. */)
8049 (Lisp_Object coding_system
)
8051 Lisp_Object define_form
;
8053 define_form
= Fget (coding_system
, Qcoding_system_define_form
);
8054 if (! NILP (define_form
))
8056 Fput (coding_system
, Qcoding_system_define_form
, Qnil
);
8057 safe_eval (define_form
);
8059 if (!NILP (Fcoding_system_p (coding_system
)))
8060 return coding_system
;
8061 xsignal1 (Qcoding_system_error
, coding_system
);
8065 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
8066 HIGHEST is nonzero, return the coding system of the highest
8067 priority among the detected coding systems. Otherwise return a
8068 list of detected coding systems sorted by their priorities. If
8069 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
8070 multibyte form but contains only ASCII and eight-bit chars.
8071 Otherwise, the bytes are raw bytes.
8073 CODING-SYSTEM controls the detection as below:
8075 If it is nil, detect both text-format and eol-format. If the
8076 text-format part of CODING-SYSTEM is already specified
8077 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
8078 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
8079 detect only text-format. */
8082 detect_coding_system (const unsigned char *src
,
8083 EMACS_INT src_chars
, EMACS_INT src_bytes
,
8084 int highest
, int multibytep
,
8085 Lisp_Object coding_system
)
8087 const unsigned char *src_end
= src
+ src_bytes
;
8088 Lisp_Object attrs
, eol_type
;
8089 Lisp_Object val
= Qnil
;
8090 struct coding_system coding
;
8092 struct coding_detection_info detect_info
;
8093 enum coding_category base_category
;
8094 int null_byte_found
= 0, eight_bit_found
= 0;
8096 if (NILP (coding_system
))
8097 coding_system
= Qundecided
;
8098 setup_coding_system (coding_system
, &coding
);
8099 attrs
= CODING_ID_ATTRS (coding
.id
);
8100 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
8101 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
8103 coding
.source
= src
;
8104 coding
.src_chars
= src_chars
;
8105 coding
.src_bytes
= src_bytes
;
8106 coding
.src_multibyte
= multibytep
;
8107 coding
.consumed
= 0;
8108 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8109 coding
.head_ascii
= 0;
8111 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
8113 /* At first, detect text-format if necessary. */
8114 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8115 if (base_category
== coding_category_undecided
)
8117 enum coding_category category
IF_LINT (= 0);
8118 struct coding_system
*this IF_LINT (= NULL
);
8121 /* Skip all ASCII bytes except for a few ISO2022 controls. */
8122 for (; src
< src_end
; src
++)
8127 eight_bit_found
= 1;
8128 if (null_byte_found
)
8133 if ((c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
8134 && ! inhibit_iso_escape_detection
8135 && ! detect_info
.checked
)
8137 if (detect_coding_iso_2022 (&coding
, &detect_info
))
8139 /* We have scanned the whole data. */
8140 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
8142 /* We didn't find an 8-bit code. We may
8143 have found a null-byte, but it's very
8144 rare that a binary file confirm to
8147 coding
.head_ascii
= src
- coding
.source
;
8149 detect_info
.rejected
|= ~CATEGORY_MASK_ISO_ESCAPE
;
8153 else if (! c
&& !inhibit_null_byte_detection
)
8155 null_byte_found
= 1;
8156 if (eight_bit_found
)
8159 if (! eight_bit_found
)
8160 coding
.head_ascii
++;
8162 else if (! eight_bit_found
)
8163 coding
.head_ascii
++;
8166 if (null_byte_found
|| eight_bit_found
8167 || coding
.head_ascii
< coding
.src_bytes
8168 || detect_info
.found
)
8170 if (coding
.head_ascii
== coding
.src_bytes
)
8171 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
8172 for (i
= 0; i
< coding_category_raw_text
; i
++)
8174 category
= coding_priorities
[i
];
8175 this = coding_categories
+ category
;
8176 if (detect_info
.found
& (1 << category
))
8181 if (null_byte_found
)
8183 detect_info
.checked
|= ~CATEGORY_MASK_UTF_16
;
8184 detect_info
.rejected
|= ~CATEGORY_MASK_UTF_16
;
8186 for (i
= 0; i
< coding_category_raw_text
; i
++)
8188 category
= coding_priorities
[i
];
8189 this = coding_categories
+ category
;
8193 /* No coding system of this category is defined. */
8194 detect_info
.rejected
|= (1 << category
);
8196 else if (category
>= coding_category_raw_text
)
8198 else if (detect_info
.checked
& (1 << category
))
8201 && (detect_info
.found
& (1 << category
)))
8204 else if ((*(this->detector
)) (&coding
, &detect_info
)
8206 && (detect_info
.found
& (1 << category
)))
8208 if (category
== coding_category_utf_16_auto
)
8210 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
8211 category
= coding_category_utf_16_le
;
8213 category
= coding_category_utf_16_be
;
8221 if ((detect_info
.rejected
& CATEGORY_MASK_ANY
) == CATEGORY_MASK_ANY
8224 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
8225 id
= CODING_SYSTEM_ID (Qno_conversion
);
8226 val
= Fcons (make_number (id
), Qnil
);
8228 else if (! detect_info
.rejected
&& ! detect_info
.found
)
8230 detect_info
.found
= CATEGORY_MASK_ANY
;
8231 id
= coding_categories
[coding_category_undecided
].id
;
8232 val
= Fcons (make_number (id
), Qnil
);
8236 if (detect_info
.found
)
8238 detect_info
.found
= 1 << category
;
8239 val
= Fcons (make_number (this->id
), Qnil
);
8242 for (i
= 0; i
< coding_category_raw_text
; i
++)
8243 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
8245 detect_info
.found
= 1 << coding_priorities
[i
];
8246 id
= coding_categories
[coding_priorities
[i
]].id
;
8247 val
= Fcons (make_number (id
), Qnil
);
8253 int mask
= detect_info
.rejected
| detect_info
.found
;
8256 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
8258 category
= coding_priorities
[i
];
8259 if (! (mask
& (1 << category
)))
8261 found
|= 1 << category
;
8262 id
= coding_categories
[category
].id
;
8264 val
= Fcons (make_number (id
), val
);
8267 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
8269 category
= coding_priorities
[i
];
8270 if (detect_info
.found
& (1 << category
))
8272 id
= coding_categories
[category
].id
;
8273 val
= Fcons (make_number (id
), val
);
8276 detect_info
.found
|= found
;
8279 else if (base_category
== coding_category_utf_8_auto
)
8281 if (detect_coding_utf_8 (&coding
, &detect_info
))
8283 struct coding_system
*this;
8285 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
8286 this = coding_categories
+ coding_category_utf_8_sig
;
8288 this = coding_categories
+ coding_category_utf_8_nosig
;
8289 val
= Fcons (make_number (this->id
), Qnil
);
8292 else if (base_category
== coding_category_utf_16_auto
)
8294 if (detect_coding_utf_16 (&coding
, &detect_info
))
8296 struct coding_system
*this;
8298 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
8299 this = coding_categories
+ coding_category_utf_16_le
;
8300 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
8301 this = coding_categories
+ coding_category_utf_16_be
;
8302 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
8303 this = coding_categories
+ coding_category_utf_16_be_nosig
;
8305 this = coding_categories
+ coding_category_utf_16_le_nosig
;
8306 val
= Fcons (make_number (this->id
), Qnil
);
8311 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
8312 val
= Fcons (make_number (coding
.id
), Qnil
);
8315 /* Then, detect eol-format if necessary. */
8317 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
= -1;
8320 if (VECTORP (eol_type
))
8322 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
8324 if (null_byte_found
)
8325 normal_eol
= EOL_SEEN_LF
;
8327 normal_eol
= detect_eol (coding
.source
, src_bytes
,
8328 coding_category_raw_text
);
8330 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
8331 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
8332 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
8333 coding_category_utf_16_be
);
8334 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
8335 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
8336 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
8337 coding_category_utf_16_le
);
8341 if (EQ (eol_type
, Qunix
))
8342 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
8343 else if (EQ (eol_type
, Qdos
))
8344 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
8346 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
8349 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
8351 enum coding_category category
;
8354 id
= XINT (XCAR (tail
));
8355 attrs
= CODING_ID_ATTRS (id
);
8356 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8357 eol_type
= CODING_ID_EOL_TYPE (id
);
8358 if (VECTORP (eol_type
))
8360 if (category
== coding_category_utf_16_be
8361 || category
== coding_category_utf_16_be_nosig
)
8362 this_eol
= utf_16_be_eol
;
8363 else if (category
== coding_category_utf_16_le
8364 || category
== coding_category_utf_16_le_nosig
)
8365 this_eol
= utf_16_le_eol
;
8367 this_eol
= normal_eol
;
8369 if (this_eol
== EOL_SEEN_LF
)
8370 XSETCAR (tail
, AREF (eol_type
, 0));
8371 else if (this_eol
== EOL_SEEN_CRLF
)
8372 XSETCAR (tail
, AREF (eol_type
, 1));
8373 else if (this_eol
== EOL_SEEN_CR
)
8374 XSETCAR (tail
, AREF (eol_type
, 2));
8376 XSETCAR (tail
, CODING_ID_NAME (id
));
8379 XSETCAR (tail
, CODING_ID_NAME (id
));
8383 return (highest
? (CONSP (val
) ? XCAR (val
) : Qnil
) : val
);
8387 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
8389 doc
: /* Detect coding system of the text in the region between START and END.
8390 Return a list of possible coding systems ordered by priority.
8391 The coding systems to try and their priorities follows what
8392 the function `coding-system-priority-list' (which see) returns.
8394 If only ASCII characters are found (except for such ISO-2022 control
8395 characters as ESC), it returns a list of single element `undecided'
8396 or its subsidiary coding system according to a detected end-of-line
8399 If optional argument HIGHEST is non-nil, return the coding system of
8400 highest priority. */)
8401 (Lisp_Object start
, Lisp_Object end
, Lisp_Object highest
)
8404 int from_byte
, to_byte
;
8406 CHECK_NUMBER_COERCE_MARKER (start
);
8407 CHECK_NUMBER_COERCE_MARKER (end
);
8409 validate_region (&start
, &end
);
8410 from
= XINT (start
), to
= XINT (end
);
8411 from_byte
= CHAR_TO_BYTE (from
);
8412 to_byte
= CHAR_TO_BYTE (to
);
8414 if (from
< GPT
&& to
>= GPT
)
8415 move_gap_both (to
, to_byte
);
8417 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
8418 to
- from
, to_byte
- from_byte
,
8420 !NILP (BVAR (current_buffer
8421 , enable_multibyte_characters
)),
8425 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
8427 doc
: /* Detect coding system of the text in STRING.
8428 Return a list of possible coding systems ordered by priority.
8429 The coding systems to try and their priorities follows what
8430 the function `coding-system-priority-list' (which see) returns.
8432 If only ASCII characters are found (except for such ISO-2022 control
8433 characters as ESC), it returns a list of single element `undecided'
8434 or its subsidiary coding system according to a detected end-of-line
8437 If optional argument HIGHEST is non-nil, return the coding system of
8438 highest priority. */)
8439 (Lisp_Object string
, Lisp_Object highest
)
8441 CHECK_STRING (string
);
8443 return detect_coding_system (SDATA (string
),
8444 SCHARS (string
), SBYTES (string
),
8445 !NILP (highest
), STRING_MULTIBYTE (string
),
8451 char_encodable_p (int c
, Lisp_Object attrs
)
8454 struct charset
*charset
;
8455 Lisp_Object translation_table
;
8457 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
8458 if (! NILP (translation_table
))
8459 c
= translate_char (translation_table
, c
);
8460 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
8461 CONSP (tail
); tail
= XCDR (tail
))
8463 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
8464 if (CHAR_CHARSET_P (c
, charset
))
8467 return (! NILP (tail
));
8471 /* Return a list of coding systems that safely encode the text between
8472 START and END. If EXCLUDE is non-nil, it is a list of coding
8473 systems not to check. The returned list doesn't contain any such
8474 coding systems. In any case, if the text contains only ASCII or is
8475 unibyte, return t. */
8477 DEFUN ("find-coding-systems-region-internal",
8478 Ffind_coding_systems_region_internal
,
8479 Sfind_coding_systems_region_internal
, 2, 3, 0,
8480 doc
: /* Internal use only. */)
8481 (Lisp_Object start
, Lisp_Object end
, Lisp_Object exclude
)
8483 Lisp_Object coding_attrs_list
, safe_codings
;
8484 EMACS_INT start_byte
, end_byte
;
8485 const unsigned char *p
, *pbeg
, *pend
;
8487 Lisp_Object tail
, elt
, work_table
;
8489 if (STRINGP (start
))
8491 if (!STRING_MULTIBYTE (start
)
8492 || SCHARS (start
) == SBYTES (start
))
8495 end_byte
= SBYTES (start
);
8499 CHECK_NUMBER_COERCE_MARKER (start
);
8500 CHECK_NUMBER_COERCE_MARKER (end
);
8501 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8502 args_out_of_range (start
, end
);
8503 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8505 start_byte
= CHAR_TO_BYTE (XINT (start
));
8506 end_byte
= CHAR_TO_BYTE (XINT (end
));
8507 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8510 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8512 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8513 move_gap_both (XINT (start
), start_byte
);
8515 move_gap_both (XINT (end
), end_byte
);
8519 coding_attrs_list
= Qnil
;
8520 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8522 || NILP (Fmemq (XCAR (tail
), exclude
)))
8526 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
8527 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
8528 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
8530 ASET (attrs
, coding_attr_trans_tbl
,
8531 get_translation_table (attrs
, 1, NULL
));
8532 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
8536 if (STRINGP (start
))
8537 p
= pbeg
= SDATA (start
);
8539 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8540 pend
= p
+ (end_byte
- start_byte
);
8542 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
8543 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8545 work_table
= Fmake_char_table (Qnil
, Qnil
);
8548 if (ASCII_BYTE_P (*p
))
8552 c
= STRING_CHAR_ADVANCE (p
);
8553 if (!NILP (char_table_ref (work_table
, c
)))
8554 /* This character was already checked. Ignore it. */
8557 charset_map_loaded
= 0;
8558 for (tail
= coding_attrs_list
; CONSP (tail
);)
8563 else if (char_encodable_p (c
, elt
))
8565 else if (CONSP (XCDR (tail
)))
8567 XSETCAR (tail
, XCAR (XCDR (tail
)));
8568 XSETCDR (tail
, XCDR (XCDR (tail
)));
8572 XSETCAR (tail
, Qnil
);
8576 if (charset_map_loaded
)
8578 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8580 if (STRINGP (start
))
8581 pbeg
= SDATA (start
);
8583 pbeg
= BYTE_POS_ADDR (start_byte
);
8584 p
= pbeg
+ p_offset
;
8585 pend
= pbeg
+ pend_offset
;
8587 char_table_set (work_table
, c
, Qt
);
8591 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
8592 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
8593 if (! NILP (XCAR (tail
)))
8594 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
8596 return safe_codings
;
8600 DEFUN ("unencodable-char-position", Funencodable_char_position
,
8601 Sunencodable_char_position
, 3, 5, 0,
8603 Return position of first un-encodable character in a region.
8604 START and END specify the region and CODING-SYSTEM specifies the
8605 encoding to check. Return nil if CODING-SYSTEM does encode the region.
8607 If optional 4th argument COUNT is non-nil, it specifies at most how
8608 many un-encodable characters to search. In this case, the value is a
8611 If optional 5th argument STRING is non-nil, it is a string to search
8612 for un-encodable characters. In that case, START and END are indexes
8614 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object count
, Lisp_Object string
)
8617 struct coding_system coding
;
8618 Lisp_Object attrs
, charset_list
, translation_table
;
8619 Lisp_Object positions
;
8621 const unsigned char *p
, *stop
, *pend
;
8622 int ascii_compatible
;
8624 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
8625 attrs
= CODING_ID_ATTRS (coding
.id
);
8626 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
8628 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
8629 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8630 translation_table
= get_translation_table (attrs
, 1, NULL
);
8634 validate_region (&start
, &end
);
8635 from
= XINT (start
);
8637 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
8638 || (ascii_compatible
8639 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
8641 p
= CHAR_POS_ADDR (from
);
8642 pend
= CHAR_POS_ADDR (to
);
8643 if (from
< GPT
&& to
>= GPT
)
8650 CHECK_STRING (string
);
8651 CHECK_NATNUM (start
);
8653 from
= XINT (start
);
8656 || to
> SCHARS (string
))
8657 args_out_of_range_3 (string
, start
, end
);
8658 if (! STRING_MULTIBYTE (string
))
8660 p
= SDATA (string
) + string_char_to_byte (string
, from
);
8661 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
8662 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
8670 CHECK_NATNUM (count
);
8679 if (ascii_compatible
)
8680 while (p
< stop
&& ASCII_BYTE_P (*p
))
8690 c
= STRING_CHAR_ADVANCE (p
);
8691 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
8692 && ! char_charset (translate_char (translation_table
, c
),
8693 charset_list
, NULL
))
8695 positions
= Fcons (make_number (from
), positions
);
8704 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
8708 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
8709 Scheck_coding_systems_region
, 3, 3, 0,
8710 doc
: /* Check if the region is encodable by coding systems.
8712 START and END are buffer positions specifying the region.
8713 CODING-SYSTEM-LIST is a list of coding systems to check.
8715 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
8716 CODING-SYSTEM is a member of CODING-SYSTEM-LIST and can't encode the
8717 whole region, POS0, POS1, ... are buffer positions where non-encodable
8718 characters are found.
8720 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
8723 START may be a string. In that case, check if the string is
8724 encodable, and the value contains indices to the string instead of
8725 buffer positions. END is ignored.
8727 If the current buffer (or START if it is a string) is unibyte, the value
8729 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system_list
)
8732 EMACS_INT start_byte
, end_byte
;
8734 const unsigned char *p
, *pbeg
, *pend
;
8736 Lisp_Object tail
, elt
, attrs
;
8738 if (STRINGP (start
))
8740 if (!STRING_MULTIBYTE (start
)
8741 || SCHARS (start
) == SBYTES (start
))
8744 end_byte
= SBYTES (start
);
8749 CHECK_NUMBER_COERCE_MARKER (start
);
8750 CHECK_NUMBER_COERCE_MARKER (end
);
8751 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8752 args_out_of_range (start
, end
);
8753 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8755 start_byte
= CHAR_TO_BYTE (XINT (start
));
8756 end_byte
= CHAR_TO_BYTE (XINT (end
));
8757 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8760 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8762 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8763 move_gap_both (XINT (start
), start_byte
);
8765 move_gap_both (XINT (end
), end_byte
);
8771 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8774 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
8775 ASET (attrs
, coding_attr_trans_tbl
,
8776 get_translation_table (attrs
, 1, NULL
));
8777 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
8780 if (STRINGP (start
))
8781 p
= pbeg
= SDATA (start
);
8783 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8784 pend
= p
+ (end_byte
- start_byte
);
8786 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
8787 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8791 if (ASCII_BYTE_P (*p
))
8795 c
= STRING_CHAR_ADVANCE (p
);
8797 charset_map_loaded
= 0;
8798 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
8800 elt
= XCDR (XCAR (tail
));
8801 if (! char_encodable_p (c
, XCAR (elt
)))
8802 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
8804 if (charset_map_loaded
)
8806 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8808 if (STRINGP (start
))
8809 pbeg
= SDATA (start
);
8811 pbeg
= BYTE_POS_ADDR (start_byte
);
8812 p
= pbeg
+ p_offset
;
8813 pend
= pbeg
+ pend_offset
;
8821 for (; CONSP (tail
); tail
= XCDR (tail
))
8824 if (CONSP (XCDR (XCDR (elt
))))
8825 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
8834 code_convert_region (Lisp_Object start
, Lisp_Object end
,
8835 Lisp_Object coding_system
, Lisp_Object dst_object
,
8836 int encodep
, int norecord
)
8838 struct coding_system coding
;
8839 EMACS_INT from
, from_byte
, to
, to_byte
;
8840 Lisp_Object src_object
;
8842 CHECK_NUMBER_COERCE_MARKER (start
);
8843 CHECK_NUMBER_COERCE_MARKER (end
);
8844 if (NILP (coding_system
))
8845 coding_system
= Qno_conversion
;
8847 CHECK_CODING_SYSTEM (coding_system
);
8848 src_object
= Fcurrent_buffer ();
8849 if (NILP (dst_object
))
8850 dst_object
= src_object
;
8851 else if (! EQ (dst_object
, Qt
))
8852 CHECK_BUFFER (dst_object
);
8854 validate_region (&start
, &end
);
8855 from
= XFASTINT (start
);
8856 from_byte
= CHAR_TO_BYTE (from
);
8857 to
= XFASTINT (end
);
8858 to_byte
= CHAR_TO_BYTE (to
);
8860 setup_coding_system (coding_system
, &coding
);
8861 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8864 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8867 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8870 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8872 return (BUFFERP (dst_object
)
8873 ? make_number (coding
.produced_char
)
8874 : coding
.dst_object
);
8878 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
8879 3, 4, "r\nzCoding system: ",
8880 doc
: /* Decode the current region from the specified coding system.
8881 When called from a program, takes four arguments:
8882 START, END, CODING-SYSTEM, and DESTINATION.
8883 START and END are buffer positions.
8885 Optional 4th arguments DESTINATION specifies where the decoded text goes.
8886 If nil, the region between START and END is replaced by the decoded text.
8887 If buffer, the decoded text is inserted in that buffer after point (point
8889 In those cases, the length of the decoded text is returned.
8890 If DESTINATION is t, the decoded text is returned.
8892 This function sets `last-coding-system-used' to the precise coding system
8893 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8894 not fully specified.) */)
8895 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object destination
)
8897 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
8900 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
8901 3, 4, "r\nzCoding system: ",
8902 doc
: /* Encode the current region by specified coding system.
8903 When called from a program, takes four arguments:
8904 START, END, CODING-SYSTEM and DESTINATION.
8905 START and END are buffer positions.
8907 Optional 4th arguments DESTINATION specifies where the encoded text goes.
8908 If nil, the region between START and END is replace by the encoded text.
8909 If buffer, the encoded text is inserted in that buffer after point (point
8911 In those cases, the length of the encoded text is returned.
8912 If DESTINATION is t, the encoded text is returned.
8914 This function sets `last-coding-system-used' to the precise coding system
8915 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8916 not fully specified.) */)
8917 (Lisp_Object start
, Lisp_Object end
, Lisp_Object coding_system
, Lisp_Object destination
)
8919 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
8923 code_convert_string (Lisp_Object string
, Lisp_Object coding_system
,
8924 Lisp_Object dst_object
, int encodep
, int nocopy
, int norecord
)
8926 struct coding_system coding
;
8927 EMACS_INT chars
, bytes
;
8929 CHECK_STRING (string
);
8930 if (NILP (coding_system
))
8933 Vlast_coding_system_used
= Qno_conversion
;
8934 if (NILP (dst_object
))
8935 return (nocopy
? Fcopy_sequence (string
) : string
);
8938 if (NILP (coding_system
))
8939 coding_system
= Qno_conversion
;
8941 CHECK_CODING_SYSTEM (coding_system
);
8942 if (NILP (dst_object
))
8944 else if (! EQ (dst_object
, Qt
))
8945 CHECK_BUFFER (dst_object
);
8947 setup_coding_system (coding_system
, &coding
);
8948 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8949 chars
= SCHARS (string
);
8950 bytes
= SBYTES (string
);
8952 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8954 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8956 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8958 return (BUFFERP (dst_object
)
8959 ? make_number (coding
.produced_char
)
8960 : coding
.dst_object
);
8964 /* Encode or decode STRING according to CODING_SYSTEM.
8965 Do not set Vlast_coding_system_used.
8967 This function is called only from macros DECODE_FILE and
8968 ENCODE_FILE, thus we ignore character composition. */
8971 code_convert_string_norecord (Lisp_Object string
, Lisp_Object coding_system
,
8974 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
8978 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
8980 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8982 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8983 if the decoding operation is trivial.
8985 Optional fourth arg BUFFER non-nil means that the decoded text is
8986 inserted in that buffer after point (point does not move). In this
8987 case, the return value is the length of the decoded text.
8989 This function sets `last-coding-system-used' to the precise coding system
8990 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8991 not fully specified.) */)
8992 (Lisp_Object string
, Lisp_Object coding_system
, Lisp_Object nocopy
, Lisp_Object buffer
)
8994 return code_convert_string (string
, coding_system
, buffer
,
8995 0, ! NILP (nocopy
), 0);
8998 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
9000 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
9002 Optional third arg NOCOPY non-nil means it is OK to return STRING
9003 itself if the encoding operation is trivial.
9005 Optional fourth arg BUFFER non-nil means that the encoded text is
9006 inserted in that buffer after point (point does not move). In this
9007 case, the return value is the length of the encoded text.
9009 This function sets `last-coding-system-used' to the precise coding system
9010 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
9011 not fully specified.) */)
9012 (Lisp_Object string
, Lisp_Object coding_system
, Lisp_Object nocopy
, Lisp_Object buffer
)
9014 return code_convert_string (string
, coding_system
, buffer
,
9015 1, ! NILP (nocopy
), 1);
9019 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
9020 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
9021 Return the corresponding character. */)
9024 Lisp_Object spec
, attrs
, val
;
9025 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
9028 CHECK_NATNUM (code
);
9029 c
= XFASTINT (code
);
9030 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
9031 attrs
= AREF (spec
, 0);
9033 if (ASCII_BYTE_P (c
)
9034 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9037 val
= CODING_ATTR_CHARSET_LIST (attrs
);
9038 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9039 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9040 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
9043 charset
= charset_roman
;
9044 else if (c
>= 0xA0 && c
< 0xDF)
9046 charset
= charset_kana
;
9051 int c1
= c
>> 8, c2
= c
& 0xFF;
9053 if (c1
< 0x81 || (c1
> 0x9F && c1
< 0xE0) || c1
> 0xEF
9054 || c2
< 0x40 || c2
== 0x7F || c2
> 0xFC)
9055 error ("Invalid code: %d", code
);
9057 charset
= charset_kanji
;
9059 c
= DECODE_CHAR (charset
, c
);
9061 error ("Invalid code: %d", code
);
9062 return make_number (c
);
9066 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
9067 doc
: /* Encode a Japanese character CH to shift_jis encoding.
9068 Return the corresponding code in SJIS. */)
9071 Lisp_Object spec
, attrs
, charset_list
;
9073 struct charset
*charset
;
9076 CHECK_CHARACTER (ch
);
9078 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
9079 attrs
= AREF (spec
, 0);
9081 if (ASCII_CHAR_P (c
)
9082 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9085 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
9086 charset
= char_charset (c
, charset_list
, &code
);
9087 if (code
== CHARSET_INVALID_CODE (charset
))
9088 error ("Can't encode by shift_jis encoding: %d", c
);
9091 return make_number (code
);
9094 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
9095 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
9096 Return the corresponding character. */)
9099 Lisp_Object spec
, attrs
, val
;
9100 struct charset
*charset_roman
, *charset_big5
, *charset
;
9103 CHECK_NATNUM (code
);
9104 c
= XFASTINT (code
);
9105 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
9106 attrs
= AREF (spec
, 0);
9108 if (ASCII_BYTE_P (c
)
9109 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9112 val
= CODING_ATTR_CHARSET_LIST (attrs
);
9113 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
9114 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
9117 charset
= charset_roman
;
9120 int b1
= c
>> 8, b2
= c
& 0x7F;
9121 if (b1
< 0xA1 || b1
> 0xFE
9122 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
9123 error ("Invalid code: %d", code
);
9124 charset
= charset_big5
;
9126 c
= DECODE_CHAR (charset
, (unsigned )c
);
9128 error ("Invalid code: %d", code
);
9129 return make_number (c
);
9132 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
9133 doc
: /* Encode the Big5 character CH to BIG5 coding system.
9134 Return the corresponding character code in Big5. */)
9137 Lisp_Object spec
, attrs
, charset_list
;
9138 struct charset
*charset
;
9142 CHECK_CHARACTER (ch
);
9144 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
9145 attrs
= AREF (spec
, 0);
9146 if (ASCII_CHAR_P (c
)
9147 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
9150 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
9151 charset
= char_charset (c
, charset_list
, &code
);
9152 if (code
== CHARSET_INVALID_CODE (charset
))
9153 error ("Can't encode by Big5 encoding: %d", c
);
9155 return make_number (code
);
9159 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal
,
9160 Sset_terminal_coding_system_internal
, 1, 2, 0,
9161 doc
: /* Internal use only. */)
9162 (Lisp_Object coding_system
, Lisp_Object terminal
)
9164 struct terminal
*term
= get_terminal (terminal
, 1);
9165 struct coding_system
*terminal_coding
= TERMINAL_TERMINAL_CODING (term
);
9166 CHECK_SYMBOL (coding_system
);
9167 setup_coding_system (Fcheck_coding_system (coding_system
), terminal_coding
);
9168 /* We had better not send unsafe characters to terminal. */
9169 terminal_coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
9170 /* Character composition should be disabled. */
9171 terminal_coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9172 terminal_coding
->src_multibyte
= 1;
9173 terminal_coding
->dst_multibyte
= 0;
9174 if (terminal_coding
->common_flags
& CODING_REQUIRE_ENCODING_MASK
)
9175 term
->charset_list
= coding_charset_list (terminal_coding
);
9177 term
->charset_list
= Fcons (make_number (charset_ascii
), Qnil
);
9181 DEFUN ("set-safe-terminal-coding-system-internal",
9182 Fset_safe_terminal_coding_system_internal
,
9183 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
9184 doc
: /* Internal use only. */)
9185 (Lisp_Object coding_system
)
9187 CHECK_SYMBOL (coding_system
);
9188 setup_coding_system (Fcheck_coding_system (coding_system
),
9189 &safe_terminal_coding
);
9190 /* Character composition should be disabled. */
9191 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9192 safe_terminal_coding
.src_multibyte
= 1;
9193 safe_terminal_coding
.dst_multibyte
= 0;
9197 DEFUN ("terminal-coding-system", Fterminal_coding_system
,
9198 Sterminal_coding_system
, 0, 1, 0,
9199 doc
: /* Return coding system specified for terminal output on the given terminal.
9200 TERMINAL may be a terminal object, a frame, or nil for the selected
9201 frame's terminal device. */)
9202 (Lisp_Object terminal
)
9204 struct coding_system
*terminal_coding
9205 = TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
9206 Lisp_Object coding_system
= CODING_ID_NAME (terminal_coding
->id
);
9208 /* For backward compatibility, return nil if it is `undecided'. */
9209 return (! EQ (coding_system
, Qundecided
) ? coding_system
: Qnil
);
9212 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal
,
9213 Sset_keyboard_coding_system_internal
, 1, 2, 0,
9214 doc
: /* Internal use only. */)
9215 (Lisp_Object coding_system
, Lisp_Object terminal
)
9217 struct terminal
*t
= get_terminal (terminal
, 1);
9218 CHECK_SYMBOL (coding_system
);
9219 if (NILP (coding_system
))
9220 coding_system
= Qno_conversion
;
9222 Fcheck_coding_system (coding_system
);
9223 setup_coding_system (coding_system
, TERMINAL_KEYBOARD_CODING (t
));
9224 /* Character composition should be disabled. */
9225 TERMINAL_KEYBOARD_CODING (t
)->common_flags
9226 &= ~CODING_ANNOTATE_COMPOSITION_MASK
;
9230 DEFUN ("keyboard-coding-system",
9231 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 1, 0,
9232 doc
: /* Return coding system specified for decoding keyboard input. */)
9233 (Lisp_Object terminal
)
9235 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
9236 (get_terminal (terminal
, 1))->id
);
9240 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
9241 Sfind_operation_coding_system
, 1, MANY
, 0,
9242 doc
: /* Choose a coding system for an operation based on the target name.
9243 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
9244 DECODING-SYSTEM is the coding system to use for decoding
9245 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
9246 for encoding (in case OPERATION does encoding).
9248 The first argument OPERATION specifies an I/O primitive:
9249 For file I/O, `insert-file-contents' or `write-region'.
9250 For process I/O, `call-process', `call-process-region', or `start-process'.
9251 For network I/O, `open-network-stream'.
9253 The remaining arguments should be the same arguments that were passed
9254 to the primitive. Depending on which primitive, one of those arguments
9255 is selected as the TARGET. For example, if OPERATION does file I/O,
9256 whichever argument specifies the file name is TARGET.
9258 TARGET has a meaning which depends on OPERATION:
9259 For file I/O, TARGET is a file name (except for the special case below).
9260 For process I/O, TARGET is a process name.
9261 For network I/O, TARGET is a service name or a port number.
9263 This function looks up what is specified for TARGET in
9264 `file-coding-system-alist', `process-coding-system-alist',
9265 or `network-coding-system-alist' depending on OPERATION.
9266 They may specify a coding system, a cons of coding systems,
9267 or a function symbol to call.
9268 In the last case, we call the function with one argument,
9269 which is a list of all the arguments given to this function.
9270 If the function can't decide a coding system, it can return
9271 `undecided' so that the normal code-detection is performed.
9273 If OPERATION is `insert-file-contents', the argument corresponding to
9274 TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
9275 file name to look up, and BUFFER is a buffer that contains the file's
9276 contents (not yet decoded). If `file-coding-system-alist' specifies a
9277 function to call for FILENAME, that function should examine the
9278 contents of BUFFER instead of reading the file.
9280 usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
9281 (size_t nargs
, Lisp_Object
*args
)
9283 Lisp_Object operation
, target_idx
, target
, val
;
9284 register Lisp_Object chain
;
9287 error ("Too few arguments");
9288 operation
= args
[0];
9289 if (!SYMBOLP (operation
)
9290 || !NATNUMP (target_idx
= Fget (operation
, Qtarget_idx
)))
9291 error ("Invalid first argument");
9292 if (nargs
< 1 + XFASTINT (target_idx
))
9293 error ("Too few arguments for operation: %s",
9294 SDATA (SYMBOL_NAME (operation
)));
9295 target
= args
[XFASTINT (target_idx
) + 1];
9296 if (!(STRINGP (target
)
9297 || (EQ (operation
, Qinsert_file_contents
) && CONSP (target
)
9298 && STRINGP (XCAR (target
)) && BUFFERP (XCDR (target
)))
9299 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
9300 error ("Invalid %dth argument", XFASTINT (target_idx
) + 1);
9302 target
= XCAR (target
);
9304 chain
= ((EQ (operation
, Qinsert_file_contents
)
9305 || EQ (operation
, Qwrite_region
))
9306 ? Vfile_coding_system_alist
9307 : (EQ (operation
, Qopen_network_stream
)
9308 ? Vnetwork_coding_system_alist
9309 : Vprocess_coding_system_alist
));
9313 for (; CONSP (chain
); chain
= XCDR (chain
))
9319 && ((STRINGP (target
)
9320 && STRINGP (XCAR (elt
))
9321 && fast_string_match (XCAR (elt
), target
) >= 0)
9322 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
9325 /* Here, if VAL is both a valid coding system and a valid
9326 function symbol, we return VAL as a coding system. */
9329 if (! SYMBOLP (val
))
9331 if (! NILP (Fcoding_system_p (val
)))
9332 return Fcons (val
, val
);
9333 if (! NILP (Ffboundp (val
)))
9335 /* We use call1 rather than safe_call1
9336 so as to get bug reports about functions called here
9337 which don't handle the current interface. */
9338 val
= call1 (val
, Flist (nargs
, args
));
9341 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
9342 return Fcons (val
, val
);
9350 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
9351 Sset_coding_system_priority
, 0, MANY
, 0,
9352 doc
: /* Assign higher priority to the coding systems given as arguments.
9353 If multiple coding systems belong to the same category,
9354 all but the first one are ignored.
9356 usage: (set-coding-system-priority &rest coding-systems) */)
9357 (size_t nargs
, Lisp_Object
*args
)
9360 int changed
[coding_category_max
];
9361 enum coding_category priorities
[coding_category_max
];
9363 memset (changed
, 0, sizeof changed
);
9365 for (i
= j
= 0; i
< nargs
; i
++)
9367 enum coding_category category
;
9368 Lisp_Object spec
, attrs
;
9370 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
9371 attrs
= AREF (spec
, 0);
9372 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
9373 if (changed
[category
])
9374 /* Ignore this coding system because a coding system of the
9375 same category already had a higher priority. */
9377 changed
[category
] = 1;
9378 priorities
[j
++] = category
;
9379 if (coding_categories
[category
].id
>= 0
9380 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
9381 setup_coding_system (args
[i
], &coding_categories
[category
]);
9382 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
9385 /* Now we have decided top J priorities. Reflect the order of the
9386 original priorities to the remaining priorities. */
9388 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
9390 while (j
< coding_category_max
9391 && changed
[coding_priorities
[j
]])
9393 if (j
== coding_category_max
)
9395 priorities
[i
] = coding_priorities
[j
];
9398 memcpy (coding_priorities
, priorities
, sizeof priorities
);
9400 /* Update `coding-category-list'. */
9401 Vcoding_category_list
= Qnil
;
9402 for (i
= coding_category_max
; i
-- > 0; )
9403 Vcoding_category_list
9404 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
9405 Vcoding_category_list
);
9410 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
9411 Scoding_system_priority_list
, 0, 1, 0,
9412 doc
: /* Return a list of coding systems ordered by their priorities.
9413 The list contains a subset of coding systems; i.e. coding systems
9414 assigned to each coding category (see `coding-category-list').
9416 HIGHESTP non-nil means just return the highest priority one. */)
9417 (Lisp_Object highestp
)
9422 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
9424 enum coding_category category
= coding_priorities
[i
];
9425 int id
= coding_categories
[category
].id
;
9430 attrs
= CODING_ID_ATTRS (id
);
9431 if (! NILP (highestp
))
9432 return CODING_ATTR_BASE_NAME (attrs
);
9433 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
9435 return Fnreverse (val
);
9438 static const char *const suffixes
[] = { "-unix", "-dos", "-mac" };
9441 make_subsidiaries (Lisp_Object base
)
9443 Lisp_Object subsidiaries
;
9444 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
9445 char *buf
= (char *) alloca (base_name_len
+ 6);
9448 memcpy (buf
, SDATA (SYMBOL_NAME (base
)), base_name_len
);
9449 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
9450 for (i
= 0; i
< 3; i
++)
9452 memcpy (buf
+ base_name_len
, suffixes
[i
], strlen (suffixes
[i
]) + 1);
9453 ASET (subsidiaries
, i
, intern (buf
));
9455 return subsidiaries
;
9459 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
9460 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
9461 doc
: /* For internal use only.
9462 usage: (define-coding-system-internal ...) */)
9463 (size_t nargs
, Lisp_Object
*args
)
9466 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
9467 Lisp_Object attrs
; /* Vector of attributes. */
9468 Lisp_Object eol_type
;
9469 Lisp_Object aliases
;
9470 Lisp_Object coding_type
, charset_list
, safe_charsets
;
9471 enum coding_category category
;
9472 Lisp_Object tail
, val
;
9473 int max_charset_id
= 0;
9476 if (nargs
< coding_arg_max
)
9479 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
9481 name
= args
[coding_arg_name
];
9482 CHECK_SYMBOL (name
);
9483 CODING_ATTR_BASE_NAME (attrs
) = name
;
9485 val
= args
[coding_arg_mnemonic
];
9486 if (! STRINGP (val
))
9487 CHECK_CHARACTER (val
);
9488 CODING_ATTR_MNEMONIC (attrs
) = val
;
9490 coding_type
= args
[coding_arg_coding_type
];
9491 CHECK_SYMBOL (coding_type
);
9492 CODING_ATTR_TYPE (attrs
) = coding_type
;
9494 charset_list
= args
[coding_arg_charset_list
];
9495 if (SYMBOLP (charset_list
))
9497 if (EQ (charset_list
, Qiso_2022
))
9499 if (! EQ (coding_type
, Qiso_2022
))
9500 error ("Invalid charset-list");
9501 charset_list
= Viso_2022_charset_list
;
9503 else if (EQ (charset_list
, Qemacs_mule
))
9505 if (! EQ (coding_type
, Qemacs_mule
))
9506 error ("Invalid charset-list");
9507 charset_list
= Vemacs_mule_charset_list
;
9509 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9510 if (max_charset_id
< XFASTINT (XCAR (tail
)))
9511 max_charset_id
= XFASTINT (XCAR (tail
));
9515 charset_list
= Fcopy_sequence (charset_list
);
9516 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9518 struct charset
*charset
;
9521 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9522 if (EQ (coding_type
, Qiso_2022
)
9523 ? CHARSET_ISO_FINAL (charset
) < 0
9524 : EQ (coding_type
, Qemacs_mule
)
9525 ? CHARSET_EMACS_MULE_ID (charset
) < 0
9527 error ("Can't handle charset `%s'",
9528 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9530 XSETCAR (tail
, make_number (charset
->id
));
9531 if (max_charset_id
< charset
->id
)
9532 max_charset_id
= charset
->id
;
9535 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
9537 safe_charsets
= make_uninit_string (max_charset_id
+ 1);
9538 memset (SDATA (safe_charsets
), 255, max_charset_id
+ 1);
9539 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9540 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
9541 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
9543 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
9545 val
= args
[coding_arg_decode_translation_table
];
9546 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9548 CODING_ATTR_DECODE_TBL (attrs
) = val
;
9550 val
= args
[coding_arg_encode_translation_table
];
9551 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9553 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
9555 val
= args
[coding_arg_post_read_conversion
];
9557 CODING_ATTR_POST_READ (attrs
) = val
;
9559 val
= args
[coding_arg_pre_write_conversion
];
9561 CODING_ATTR_PRE_WRITE (attrs
) = val
;
9563 val
= args
[coding_arg_default_char
];
9565 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
9568 CHECK_CHARACTER (val
);
9569 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
9572 val
= args
[coding_arg_for_unibyte
];
9573 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
9575 val
= args
[coding_arg_plist
];
9577 CODING_ATTR_PLIST (attrs
) = val
;
9579 if (EQ (coding_type
, Qcharset
))
9581 /* Generate a lisp vector of 256 elements. Each element is nil,
9582 integer, or a list of charset IDs.
9584 If Nth element is nil, the byte code N is invalid in this
9587 If Nth element is a number NUM, N is the first byte of a
9588 charset whose ID is NUM.
9590 If Nth element is a list of charset IDs, N is the first byte
9591 of one of them. The list is sorted by dimensions of the
9592 charsets. A charset of smaller dimension comes first. */
9593 val
= Fmake_vector (make_number (256), Qnil
);
9595 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9597 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
9598 int dim
= CHARSET_DIMENSION (charset
);
9599 int idx
= (dim
- 1) * 4;
9601 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9602 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9604 for (i
= charset
->code_space
[idx
];
9605 i
<= charset
->code_space
[idx
+ 1]; i
++)
9607 Lisp_Object tmp
, tmp2
;
9610 tmp
= AREF (val
, i
);
9613 else if (NUMBERP (tmp
))
9615 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
9617 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
9619 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
9623 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
9625 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
9630 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
9633 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
9634 XSETCAR (tmp2
, XCAR (tail
));
9640 ASET (attrs
, coding_attr_charset_valids
, val
);
9641 category
= coding_category_charset
;
9643 else if (EQ (coding_type
, Qccl
))
9647 if (nargs
< coding_arg_ccl_max
)
9650 val
= args
[coding_arg_ccl_decoder
];
9651 CHECK_CCL_PROGRAM (val
);
9653 val
= Fcopy_sequence (val
);
9654 ASET (attrs
, coding_attr_ccl_decoder
, val
);
9656 val
= args
[coding_arg_ccl_encoder
];
9657 CHECK_CCL_PROGRAM (val
);
9659 val
= Fcopy_sequence (val
);
9660 ASET (attrs
, coding_attr_ccl_encoder
, val
);
9662 val
= args
[coding_arg_ccl_valids
];
9663 valids
= Fmake_string (make_number (256), make_number (0));
9664 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
9671 from
= to
= XINT (val
);
9672 if (from
< 0 || from
> 255)
9673 args_out_of_range_3 (val
, make_number (0), make_number (255));
9678 CHECK_NATNUM_CAR (val
);
9679 CHECK_NATNUM_CDR (val
);
9680 from
= XINT (XCAR (val
));
9682 args_out_of_range_3 (XCAR (val
),
9683 make_number (0), make_number (255));
9684 to
= XINT (XCDR (val
));
9685 if (to
< from
|| to
> 255)
9686 args_out_of_range_3 (XCDR (val
),
9687 XCAR (val
), make_number (255));
9689 for (i
= from
; i
<= to
; i
++)
9690 SSET (valids
, i
, 1);
9692 ASET (attrs
, coding_attr_ccl_valids
, valids
);
9694 category
= coding_category_ccl
;
9696 else if (EQ (coding_type
, Qutf_16
))
9698 Lisp_Object bom
, endian
;
9700 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
9702 if (nargs
< coding_arg_utf16_max
)
9705 bom
= args
[coding_arg_utf16_bom
];
9706 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9710 CHECK_CODING_SYSTEM (val
);
9712 CHECK_CODING_SYSTEM (val
);
9714 ASET (attrs
, coding_attr_utf_bom
, bom
);
9716 endian
= args
[coding_arg_utf16_endian
];
9717 CHECK_SYMBOL (endian
);
9720 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
9721 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
9722 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
9724 category
= (CONSP (bom
)
9725 ? coding_category_utf_16_auto
9727 ? (EQ (endian
, Qbig
)
9728 ? coding_category_utf_16_be_nosig
9729 : coding_category_utf_16_le_nosig
)
9730 : (EQ (endian
, Qbig
)
9731 ? coding_category_utf_16_be
9732 : coding_category_utf_16_le
));
9734 else if (EQ (coding_type
, Qiso_2022
))
9736 Lisp_Object initial
, reg_usage
, request
, flags
;
9738 if (nargs
< coding_arg_iso2022_max
)
9741 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
9742 CHECK_VECTOR (initial
);
9743 for (i
= 0; i
< 4; i
++)
9745 val
= Faref (initial
, make_number (i
));
9748 struct charset
*charset
;
9750 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9751 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
9752 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
9753 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9756 ASET (initial
, i
, make_number (-1));
9759 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
9760 CHECK_CONS (reg_usage
);
9761 CHECK_NUMBER_CAR (reg_usage
);
9762 CHECK_NUMBER_CDR (reg_usage
);
9764 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
9765 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
9773 CHECK_CHARSET_GET_ID (tmp1
, id
);
9774 CHECK_NATNUM_CDR (val
);
9775 if (XINT (XCDR (val
)) >= 4)
9776 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
9777 XSETCAR (val
, make_number (id
));
9780 flags
= args
[coding_arg_iso2022_flags
];
9781 CHECK_NATNUM (flags
);
9783 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
9784 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
9786 ASET (attrs
, coding_attr_iso_initial
, initial
);
9787 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
9788 ASET (attrs
, coding_attr_iso_request
, request
);
9789 ASET (attrs
, coding_attr_iso_flags
, flags
);
9790 setup_iso_safe_charsets (attrs
);
9792 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
9793 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
9794 | CODING_ISO_FLAG_SINGLE_SHIFT
))
9795 ? coding_category_iso_7_else
9796 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9797 ? coding_category_iso_7
9798 : coding_category_iso_7_tight
);
9801 int id
= XINT (AREF (initial
, 1));
9803 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
9804 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9806 ? coding_category_iso_8_else
9807 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
9808 ? coding_category_iso_8_1
9809 : coding_category_iso_8_2
);
9811 if (category
!= coding_category_iso_8_1
9812 && category
!= coding_category_iso_8_2
)
9813 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
9815 else if (EQ (coding_type
, Qemacs_mule
))
9817 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
9818 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
9819 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9820 category
= coding_category_emacs_mule
;
9822 else if (EQ (coding_type
, Qshift_jis
))
9825 struct charset
*charset
;
9827 if (XINT (Flength (charset_list
)) != 3
9828 && XINT (Flength (charset_list
)) != 4)
9829 error ("There should be three or four charsets");
9831 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9832 if (CHARSET_DIMENSION (charset
) != 1)
9833 error ("Dimension of charset %s is not one",
9834 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9835 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9836 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9838 charset_list
= XCDR (charset_list
);
9839 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9840 if (CHARSET_DIMENSION (charset
) != 1)
9841 error ("Dimension of charset %s is not one",
9842 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9844 charset_list
= XCDR (charset_list
);
9845 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9846 if (CHARSET_DIMENSION (charset
) != 2)
9847 error ("Dimension of charset %s is not two",
9848 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9850 charset_list
= XCDR (charset_list
);
9851 if (! NILP (charset_list
))
9853 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9854 if (CHARSET_DIMENSION (charset
) != 2)
9855 error ("Dimension of charset %s is not two",
9856 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9859 category
= coding_category_sjis
;
9860 Vsjis_coding_system
= name
;
9862 else if (EQ (coding_type
, Qbig5
))
9864 struct charset
*charset
;
9866 if (XINT (Flength (charset_list
)) != 2)
9867 error ("There should be just two charsets");
9869 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9870 if (CHARSET_DIMENSION (charset
) != 1)
9871 error ("Dimension of charset %s is not one",
9872 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9873 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9874 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9876 charset_list
= XCDR (charset_list
);
9877 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9878 if (CHARSET_DIMENSION (charset
) != 2)
9879 error ("Dimension of charset %s is not two",
9880 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9882 category
= coding_category_big5
;
9883 Vbig5_coding_system
= name
;
9885 else if (EQ (coding_type
, Qraw_text
))
9887 category
= coding_category_raw_text
;
9888 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9890 else if (EQ (coding_type
, Qutf_8
))
9894 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9896 if (nargs
< coding_arg_utf8_max
)
9899 bom
= args
[coding_arg_utf8_bom
];
9900 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9904 CHECK_CODING_SYSTEM (val
);
9906 CHECK_CODING_SYSTEM (val
);
9908 ASET (attrs
, coding_attr_utf_bom
, bom
);
9910 category
= (CONSP (bom
) ? coding_category_utf_8_auto
9911 : NILP (bom
) ? coding_category_utf_8_nosig
9912 : coding_category_utf_8_sig
);
9914 else if (EQ (coding_type
, Qundecided
))
9915 category
= coding_category_undecided
;
9917 error ("Invalid coding system type: %s",
9918 SDATA (SYMBOL_NAME (coding_type
)));
9920 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
9921 CODING_ATTR_PLIST (attrs
)
9922 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
9923 CODING_ATTR_PLIST (attrs
)));
9924 CODING_ATTR_PLIST (attrs
)
9925 = Fcons (QCascii_compatible_p
,
9926 Fcons (CODING_ATTR_ASCII_COMPAT (attrs
),
9927 CODING_ATTR_PLIST (attrs
)));
9929 eol_type
= args
[coding_arg_eol_type
];
9930 if (! NILP (eol_type
)
9931 && ! EQ (eol_type
, Qunix
)
9932 && ! EQ (eol_type
, Qdos
)
9933 && ! EQ (eol_type
, Qmac
))
9934 error ("Invalid eol-type");
9936 aliases
= Fcons (name
, Qnil
);
9938 if (NILP (eol_type
))
9940 eol_type
= make_subsidiaries (name
);
9941 for (i
= 0; i
< 3; i
++)
9943 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
9945 this_name
= AREF (eol_type
, i
);
9946 this_aliases
= Fcons (this_name
, Qnil
);
9947 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
9948 this_spec
= Fmake_vector (make_number (3), attrs
);
9949 ASET (this_spec
, 1, this_aliases
);
9950 ASET (this_spec
, 2, this_eol_type
);
9951 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
9952 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
9953 val
= Fassoc (Fsymbol_name (this_name
), Vcoding_system_alist
);
9955 Vcoding_system_alist
9956 = Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
9957 Vcoding_system_alist
);
9961 spec_vec
= Fmake_vector (make_number (3), attrs
);
9962 ASET (spec_vec
, 1, aliases
);
9963 ASET (spec_vec
, 2, eol_type
);
9965 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
9966 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
9967 val
= Fassoc (Fsymbol_name (name
), Vcoding_system_alist
);
9969 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
9970 Vcoding_system_alist
);
9973 int id
= coding_categories
[category
].id
;
9975 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
9976 setup_coding_system (name
, &coding_categories
[category
]);
9982 return Fsignal (Qwrong_number_of_arguments
,
9983 Fcons (intern ("define-coding-system-internal"),
9984 make_number (nargs
)));
9988 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
9990 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
9991 (Lisp_Object coding_system
, Lisp_Object prop
, Lisp_Object val
)
9993 Lisp_Object spec
, attrs
;
9995 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9996 attrs
= AREF (spec
, 0);
9997 if (EQ (prop
, QCmnemonic
))
9999 if (! STRINGP (val
))
10000 CHECK_CHARACTER (val
);
10001 CODING_ATTR_MNEMONIC (attrs
) = val
;
10003 else if (EQ (prop
, QCdefault_char
))
10006 val
= make_number (' ');
10008 CHECK_CHARACTER (val
);
10009 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
10011 else if (EQ (prop
, QCdecode_translation_table
))
10013 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
10014 CHECK_SYMBOL (val
);
10015 CODING_ATTR_DECODE_TBL (attrs
) = val
;
10017 else if (EQ (prop
, QCencode_translation_table
))
10019 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
10020 CHECK_SYMBOL (val
);
10021 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
10023 else if (EQ (prop
, QCpost_read_conversion
))
10025 CHECK_SYMBOL (val
);
10026 CODING_ATTR_POST_READ (attrs
) = val
;
10028 else if (EQ (prop
, QCpre_write_conversion
))
10030 CHECK_SYMBOL (val
);
10031 CODING_ATTR_PRE_WRITE (attrs
) = val
;
10033 else if (EQ (prop
, QCascii_compatible_p
))
10035 CODING_ATTR_ASCII_COMPAT (attrs
) = val
;
10038 CODING_ATTR_PLIST (attrs
)
10039 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
10044 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
10045 Sdefine_coding_system_alias
, 2, 2, 0,
10046 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
10047 (Lisp_Object alias
, Lisp_Object coding_system
)
10049 Lisp_Object spec
, aliases
, eol_type
, val
;
10051 CHECK_SYMBOL (alias
);
10052 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10053 aliases
= AREF (spec
, 1);
10054 /* ALIASES should be a list of length more than zero, and the first
10055 element is a base coding system. Append ALIAS at the tail of the
10057 while (!NILP (XCDR (aliases
)))
10058 aliases
= XCDR (aliases
);
10059 XSETCDR (aliases
, Fcons (alias
, Qnil
));
10061 eol_type
= AREF (spec
, 2);
10062 if (VECTORP (eol_type
))
10064 Lisp_Object subsidiaries
;
10067 subsidiaries
= make_subsidiaries (alias
);
10068 for (i
= 0; i
< 3; i
++)
10069 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
10070 AREF (eol_type
, i
));
10073 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
10074 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
10075 val
= Fassoc (Fsymbol_name (alias
), Vcoding_system_alist
);
10077 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
10078 Vcoding_system_alist
);
10083 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
10085 doc
: /* Return the base of CODING-SYSTEM.
10086 Any alias or subsidiary coding system is not a base coding system. */)
10087 (Lisp_Object coding_system
)
10089 Lisp_Object spec
, attrs
;
10091 if (NILP (coding_system
))
10092 return (Qno_conversion
);
10093 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10094 attrs
= AREF (spec
, 0);
10095 return CODING_ATTR_BASE_NAME (attrs
);
10098 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
10100 doc
: "Return the property list of CODING-SYSTEM.")
10101 (Lisp_Object coding_system
)
10103 Lisp_Object spec
, attrs
;
10105 if (NILP (coding_system
))
10106 coding_system
= Qno_conversion
;
10107 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10108 attrs
= AREF (spec
, 0);
10109 return CODING_ATTR_PLIST (attrs
);
10113 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
10115 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
10116 (Lisp_Object coding_system
)
10120 if (NILP (coding_system
))
10121 coding_system
= Qno_conversion
;
10122 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
10123 return AREF (spec
, 1);
10126 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
10127 Scoding_system_eol_type
, 1, 1, 0,
10128 doc
: /* Return eol-type of CODING-SYSTEM.
10129 An eol-type is an integer 0, 1, 2, or a vector of coding systems.
10131 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
10132 and CR respectively.
10134 A vector value indicates that a format of end-of-line should be
10135 detected automatically. Nth element of the vector is the subsidiary
10136 coding system whose eol-type is N. */)
10137 (Lisp_Object coding_system
)
10139 Lisp_Object spec
, eol_type
;
10142 if (NILP (coding_system
))
10143 coding_system
= Qno_conversion
;
10144 if (! CODING_SYSTEM_P (coding_system
))
10146 spec
= CODING_SYSTEM_SPEC (coding_system
);
10147 eol_type
= AREF (spec
, 2);
10148 if (VECTORP (eol_type
))
10149 return Fcopy_sequence (eol_type
);
10150 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
10151 return make_number (n
);
10157 /*** 9. Post-amble ***/
10160 init_coding_once (void)
10164 for (i
= 0; i
< coding_category_max
; i
++)
10166 coding_categories
[i
].id
= -1;
10167 coding_priorities
[i
] = i
;
10170 /* ISO2022 specific initialize routine. */
10171 for (i
= 0; i
< 0x20; i
++)
10172 iso_code_class
[i
] = ISO_control_0
;
10173 for (i
= 0x21; i
< 0x7F; i
++)
10174 iso_code_class
[i
] = ISO_graphic_plane_0
;
10175 for (i
= 0x80; i
< 0xA0; i
++)
10176 iso_code_class
[i
] = ISO_control_1
;
10177 for (i
= 0xA1; i
< 0xFF; i
++)
10178 iso_code_class
[i
] = ISO_graphic_plane_1
;
10179 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
10180 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
10181 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
10182 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
10183 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
10184 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
10185 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
10186 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
10187 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
10189 for (i
= 0; i
< 256; i
++)
10191 emacs_mule_bytes
[i
] = 1;
10193 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
10194 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
10195 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
10196 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
10202 syms_of_coding (void)
10204 staticpro (&Vcoding_system_hash_table
);
10206 Lisp_Object args
[2];
10209 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
10212 staticpro (&Vsjis_coding_system
);
10213 Vsjis_coding_system
= Qnil
;
10215 staticpro (&Vbig5_coding_system
);
10216 Vbig5_coding_system
= Qnil
;
10218 staticpro (&Vcode_conversion_reused_workbuf
);
10219 Vcode_conversion_reused_workbuf
= Qnil
;
10221 staticpro (&Vcode_conversion_workbuf_name
);
10222 Vcode_conversion_workbuf_name
= make_pure_c_string (" *code-conversion-work*");
10224 reused_workbuf_in_use
= 0;
10226 DEFSYM (Qcharset
, "charset");
10227 DEFSYM (Qtarget_idx
, "target-idx");
10228 DEFSYM (Qcoding_system_history
, "coding-system-history");
10229 Fset (Qcoding_system_history
, Qnil
);
10231 /* Target FILENAME is the first argument. */
10232 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
10233 /* Target FILENAME is the third argument. */
10234 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
10236 DEFSYM (Qcall_process
, "call-process");
10237 /* Target PROGRAM is the first argument. */
10238 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
10240 DEFSYM (Qcall_process_region
, "call-process-region");
10241 /* Target PROGRAM is the third argument. */
10242 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
10244 DEFSYM (Qstart_process
, "start-process");
10245 /* Target PROGRAM is the third argument. */
10246 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
10248 DEFSYM (Qopen_network_stream
, "open-network-stream");
10249 /* Target SERVICE is the fourth argument. */
10250 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
10252 DEFSYM (Qcoding_system
, "coding-system");
10253 DEFSYM (Qcoding_aliases
, "coding-aliases");
10255 DEFSYM (Qeol_type
, "eol-type");
10256 DEFSYM (Qunix
, "unix");
10257 DEFSYM (Qdos
, "dos");
10259 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
10260 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
10261 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
10262 DEFSYM (Qdefault_char
, "default-char");
10263 DEFSYM (Qundecided
, "undecided");
10264 DEFSYM (Qno_conversion
, "no-conversion");
10265 DEFSYM (Qraw_text
, "raw-text");
10267 DEFSYM (Qiso_2022
, "iso-2022");
10269 DEFSYM (Qutf_8
, "utf-8");
10270 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
10272 DEFSYM (Qutf_16
, "utf-16");
10273 DEFSYM (Qbig
, "big");
10274 DEFSYM (Qlittle
, "little");
10276 DEFSYM (Qshift_jis
, "shift-jis");
10277 DEFSYM (Qbig5
, "big5");
10279 DEFSYM (Qcoding_system_p
, "coding-system-p");
10281 DEFSYM (Qcoding_system_error
, "coding-system-error");
10282 Fput (Qcoding_system_error
, Qerror_conditions
,
10283 pure_cons (Qcoding_system_error
, pure_cons (Qerror
, Qnil
)));
10284 Fput (Qcoding_system_error
, Qerror_message
,
10285 make_pure_c_string ("Invalid coding system"));
10287 /* Intern this now in case it isn't already done.
10288 Setting this variable twice is harmless.
10289 But don't staticpro it here--that is done in alloc.c. */
10290 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
10292 DEFSYM (Qtranslation_table
, "translation-table");
10293 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
10294 DEFSYM (Qtranslation_table_id
, "translation-table-id");
10295 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
10296 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
10298 DEFSYM (Qvalid_codes
, "valid-codes");
10300 DEFSYM (Qemacs_mule
, "emacs-mule");
10302 DEFSYM (QCcategory
, ":category");
10303 DEFSYM (QCmnemonic
, ":mnemonic");
10304 DEFSYM (QCdefault_char
, ":default-char");
10305 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
10306 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
10307 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
10308 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
10309 DEFSYM (QCascii_compatible_p
, ":ascii-compatible-p");
10311 Vcoding_category_table
10312 = Fmake_vector (make_number (coding_category_max
), Qnil
);
10313 staticpro (&Vcoding_category_table
);
10314 /* Followings are target of code detection. */
10315 ASET (Vcoding_category_table
, coding_category_iso_7
,
10316 intern_c_string ("coding-category-iso-7"));
10317 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
10318 intern_c_string ("coding-category-iso-7-tight"));
10319 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
10320 intern_c_string ("coding-category-iso-8-1"));
10321 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
10322 intern_c_string ("coding-category-iso-8-2"));
10323 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
10324 intern_c_string ("coding-category-iso-7-else"));
10325 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
10326 intern_c_string ("coding-category-iso-8-else"));
10327 ASET (Vcoding_category_table
, coding_category_utf_8_auto
,
10328 intern_c_string ("coding-category-utf-8-auto"));
10329 ASET (Vcoding_category_table
, coding_category_utf_8_nosig
,
10330 intern_c_string ("coding-category-utf-8"));
10331 ASET (Vcoding_category_table
, coding_category_utf_8_sig
,
10332 intern_c_string ("coding-category-utf-8-sig"));
10333 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
10334 intern_c_string ("coding-category-utf-16-be"));
10335 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
10336 intern_c_string ("coding-category-utf-16-auto"));
10337 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
10338 intern_c_string ("coding-category-utf-16-le"));
10339 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
10340 intern_c_string ("coding-category-utf-16-be-nosig"));
10341 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
10342 intern_c_string ("coding-category-utf-16-le-nosig"));
10343 ASET (Vcoding_category_table
, coding_category_charset
,
10344 intern_c_string ("coding-category-charset"));
10345 ASET (Vcoding_category_table
, coding_category_sjis
,
10346 intern_c_string ("coding-category-sjis"));
10347 ASET (Vcoding_category_table
, coding_category_big5
,
10348 intern_c_string ("coding-category-big5"));
10349 ASET (Vcoding_category_table
, coding_category_ccl
,
10350 intern_c_string ("coding-category-ccl"));
10351 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
10352 intern_c_string ("coding-category-emacs-mule"));
10353 /* Followings are NOT target of code detection. */
10354 ASET (Vcoding_category_table
, coding_category_raw_text
,
10355 intern_c_string ("coding-category-raw-text"));
10356 ASET (Vcoding_category_table
, coding_category_undecided
,
10357 intern_c_string ("coding-category-undecided"));
10359 DEFSYM (Qinsufficient_source
, "insufficient-source");
10360 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
10361 DEFSYM (Qinvalid_source
, "invalid-source");
10362 DEFSYM (Qinterrupted
, "interrupted");
10363 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
10364 DEFSYM (Qcoding_system_define_form
, "coding-system-define-form");
10366 defsubr (&Scoding_system_p
);
10367 defsubr (&Sread_coding_system
);
10368 defsubr (&Sread_non_nil_coding_system
);
10369 defsubr (&Scheck_coding_system
);
10370 defsubr (&Sdetect_coding_region
);
10371 defsubr (&Sdetect_coding_string
);
10372 defsubr (&Sfind_coding_systems_region_internal
);
10373 defsubr (&Sunencodable_char_position
);
10374 defsubr (&Scheck_coding_systems_region
);
10375 defsubr (&Sdecode_coding_region
);
10376 defsubr (&Sencode_coding_region
);
10377 defsubr (&Sdecode_coding_string
);
10378 defsubr (&Sencode_coding_string
);
10379 defsubr (&Sdecode_sjis_char
);
10380 defsubr (&Sencode_sjis_char
);
10381 defsubr (&Sdecode_big5_char
);
10382 defsubr (&Sencode_big5_char
);
10383 defsubr (&Sset_terminal_coding_system_internal
);
10384 defsubr (&Sset_safe_terminal_coding_system_internal
);
10385 defsubr (&Sterminal_coding_system
);
10386 defsubr (&Sset_keyboard_coding_system_internal
);
10387 defsubr (&Skeyboard_coding_system
);
10388 defsubr (&Sfind_operation_coding_system
);
10389 defsubr (&Sset_coding_system_priority
);
10390 defsubr (&Sdefine_coding_system_internal
);
10391 defsubr (&Sdefine_coding_system_alias
);
10392 defsubr (&Scoding_system_put
);
10393 defsubr (&Scoding_system_base
);
10394 defsubr (&Scoding_system_plist
);
10395 defsubr (&Scoding_system_aliases
);
10396 defsubr (&Scoding_system_eol_type
);
10397 defsubr (&Scoding_system_priority_list
);
10399 DEFVAR_LISP ("coding-system-list", Vcoding_system_list
,
10400 doc
: /* List of coding systems.
10402 Do not alter the value of this variable manually. This variable should be
10403 updated by the functions `define-coding-system' and
10404 `define-coding-system-alias'. */);
10405 Vcoding_system_list
= Qnil
;
10407 DEFVAR_LISP ("coding-system-alist", Vcoding_system_alist
,
10408 doc
: /* Alist of coding system names.
10409 Each element is one element list of coding system name.
10410 This variable is given to `completing-read' as COLLECTION argument.
10412 Do not alter the value of this variable manually. This variable should be
10413 updated by the functions `make-coding-system' and
10414 `define-coding-system-alias'. */);
10415 Vcoding_system_alist
= Qnil
;
10417 DEFVAR_LISP ("coding-category-list", Vcoding_category_list
,
10418 doc
: /* List of coding-categories (symbols) ordered by priority.
10420 On detecting a coding system, Emacs tries code detection algorithms
10421 associated with each coding-category one by one in this order. When
10422 one algorithm agrees with a byte sequence of source text, the coding
10423 system bound to the corresponding coding-category is selected.
10425 Don't modify this variable directly, but use `set-coding-system-priority'. */);
10429 Vcoding_category_list
= Qnil
;
10430 for (i
= coding_category_max
- 1; i
>= 0; i
--)
10431 Vcoding_category_list
10432 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
10433 Vcoding_category_list
);
10436 DEFVAR_LISP ("coding-system-for-read", Vcoding_system_for_read
,
10437 doc
: /* Specify the coding system for read operations.
10438 It is useful to bind this variable with `let', but do not set it globally.
10439 If the value is a coding system, it is used for decoding on read operation.
10440 If not, an appropriate element is used from one of the coding system alists.
10441 There are three such tables: `file-coding-system-alist',
10442 `process-coding-system-alist', and `network-coding-system-alist'. */);
10443 Vcoding_system_for_read
= Qnil
;
10445 DEFVAR_LISP ("coding-system-for-write", Vcoding_system_for_write
,
10446 doc
: /* Specify the coding system for write operations.
10447 Programs bind this variable with `let', but you should not set it globally.
10448 If the value is a coding system, it is used for encoding of output,
10449 when writing it to a file and when sending it to a file or subprocess.
10451 If this does not specify a coding system, an appropriate element
10452 is used from one of the coding system alists.
10453 There are three such tables: `file-coding-system-alist',
10454 `process-coding-system-alist', and `network-coding-system-alist'.
10455 For output to files, if the above procedure does not specify a coding system,
10456 the value of `buffer-file-coding-system' is used. */);
10457 Vcoding_system_for_write
= Qnil
;
10459 DEFVAR_LISP ("last-coding-system-used", Vlast_coding_system_used
,
10461 Coding system used in the latest file or process I/O. */);
10462 Vlast_coding_system_used
= Qnil
;
10464 DEFVAR_LISP ("last-code-conversion-error", Vlast_code_conversion_error
,
10466 Error status of the last code conversion.
10468 When an error was detected in the last code conversion, this variable
10469 is set to one of the following symbols.
10470 `insufficient-source'
10474 `insufficient-memory'
10475 When no error was detected, the value doesn't change. So, to check
10476 the error status of a code conversion by this variable, you must
10477 explicitly set this variable to nil before performing code
10479 Vlast_code_conversion_error
= Qnil
;
10481 DEFVAR_BOOL ("inhibit-eol-conversion", inhibit_eol_conversion
,
10483 *Non-nil means always inhibit code conversion of end-of-line format.
10484 See info node `Coding Systems' and info node `Text and Binary' concerning
10485 such conversion. */);
10486 inhibit_eol_conversion
= 0;
10488 DEFVAR_BOOL ("inherit-process-coding-system", inherit_process_coding_system
,
10490 Non-nil means process buffer inherits coding system of process output.
10491 Bind it to t if the process output is to be treated as if it were a file
10492 read from some filesystem. */);
10493 inherit_process_coding_system
= 0;
10495 DEFVAR_LISP ("file-coding-system-alist", Vfile_coding_system_alist
,
10497 Alist to decide a coding system to use for a file I/O operation.
10498 The format is ((PATTERN . VAL) ...),
10499 where PATTERN is a regular expression matching a file name,
10500 VAL is a coding system, a cons of coding systems, or a function symbol.
10501 If VAL is a coding system, it is used for both decoding and encoding
10503 If VAL is a cons of coding systems, the car part is used for decoding,
10504 and the cdr part is used for encoding.
10505 If VAL is a function symbol, the function must return a coding system
10506 or a cons of coding systems which are used as above. The function is
10507 called with an argument that is a list of the arguments with which
10508 `find-operation-coding-system' was called. If the function can't decide
10509 a coding system, it can return `undecided' so that the normal
10510 code-detection is performed.
10512 See also the function `find-operation-coding-system'
10513 and the variable `auto-coding-alist'. */);
10514 Vfile_coding_system_alist
= Qnil
;
10516 DEFVAR_LISP ("process-coding-system-alist", Vprocess_coding_system_alist
,
10518 Alist to decide a coding system to use for a process I/O operation.
10519 The format is ((PATTERN . VAL) ...),
10520 where PATTERN is a regular expression matching a program name,
10521 VAL is a coding system, a cons of coding systems, or a function symbol.
10522 If VAL is a coding system, it is used for both decoding what received
10523 from the program and encoding what sent to the program.
10524 If VAL is a cons of coding systems, the car part is used for decoding,
10525 and the cdr part is used for encoding.
10526 If VAL is a function symbol, the function must return a coding system
10527 or a cons of coding systems which are used as above.
10529 See also the function `find-operation-coding-system'. */);
10530 Vprocess_coding_system_alist
= Qnil
;
10532 DEFVAR_LISP ("network-coding-system-alist", Vnetwork_coding_system_alist
,
10534 Alist to decide a coding system to use for a network I/O operation.
10535 The format is ((PATTERN . VAL) ...),
10536 where PATTERN is a regular expression matching a network service name
10537 or is a port number to connect to,
10538 VAL is a coding system, a cons of coding systems, or a function symbol.
10539 If VAL is a coding system, it is used for both decoding what received
10540 from the network stream and encoding what sent to the network stream.
10541 If VAL is a cons of coding systems, the car part is used for decoding,
10542 and the cdr part is used for encoding.
10543 If VAL is a function symbol, the function must return a coding system
10544 or a cons of coding systems which are used as above.
10546 See also the function `find-operation-coding-system'. */);
10547 Vnetwork_coding_system_alist
= Qnil
;
10549 DEFVAR_LISP ("locale-coding-system", Vlocale_coding_system
,
10550 doc
: /* Coding system to use with system messages.
10551 Also used for decoding keyboard input on X Window system. */);
10552 Vlocale_coding_system
= Qnil
;
10554 /* The eol mnemonics are reset in startup.el system-dependently. */
10555 DEFVAR_LISP ("eol-mnemonic-unix", eol_mnemonic_unix
,
10557 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
10558 eol_mnemonic_unix
= make_pure_c_string (":");
10560 DEFVAR_LISP ("eol-mnemonic-dos", eol_mnemonic_dos
,
10562 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
10563 eol_mnemonic_dos
= make_pure_c_string ("\\");
10565 DEFVAR_LISP ("eol-mnemonic-mac", eol_mnemonic_mac
,
10567 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
10568 eol_mnemonic_mac
= make_pure_c_string ("/");
10570 DEFVAR_LISP ("eol-mnemonic-undecided", eol_mnemonic_undecided
,
10572 *String displayed in mode line when end-of-line format is not yet determined. */);
10573 eol_mnemonic_undecided
= make_pure_c_string (":");
10575 DEFVAR_LISP ("enable-character-translation", Venable_character_translation
,
10577 *Non-nil enables character translation while encoding and decoding. */);
10578 Venable_character_translation
= Qt
;
10580 DEFVAR_LISP ("standard-translation-table-for-decode",
10581 Vstandard_translation_table_for_decode
,
10582 doc
: /* Table for translating characters while decoding. */);
10583 Vstandard_translation_table_for_decode
= Qnil
;
10585 DEFVAR_LISP ("standard-translation-table-for-encode",
10586 Vstandard_translation_table_for_encode
,
10587 doc
: /* Table for translating characters while encoding. */);
10588 Vstandard_translation_table_for_encode
= Qnil
;
10590 DEFVAR_LISP ("charset-revision-table", Vcharset_revision_table
,
10591 doc
: /* Alist of charsets vs revision numbers.
10592 While encoding, if a charset (car part of an element) is found,
10593 designate it with the escape sequence identifying revision (cdr part
10594 of the element). */);
10595 Vcharset_revision_table
= Qnil
;
10597 DEFVAR_LISP ("default-process-coding-system",
10598 Vdefault_process_coding_system
,
10599 doc
: /* Cons of coding systems used for process I/O by default.
10600 The car part is used for decoding a process output,
10601 the cdr part is used for encoding a text to be sent to a process. */);
10602 Vdefault_process_coding_system
= Qnil
;
10604 DEFVAR_LISP ("latin-extra-code-table", Vlatin_extra_code_table
,
10606 Table of extra Latin codes in the range 128..159 (inclusive).
10607 This is a vector of length 256.
10608 If Nth element is non-nil, the existence of code N in a file
10609 \(or output of subprocess) doesn't prevent it to be detected as
10610 a coding system of ISO 2022 variant which has a flag
10611 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
10612 or reading output of a subprocess.
10613 Only 128th through 159th elements have a meaning. */);
10614 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
10616 DEFVAR_LISP ("select-safe-coding-system-function",
10617 Vselect_safe_coding_system_function
,
10619 Function to call to select safe coding system for encoding a text.
10621 If set, this function is called to force a user to select a proper
10622 coding system which can encode the text in the case that a default
10623 coding system used in each operation can't encode the text. The
10624 function should take care that the buffer is not modified while
10625 the coding system is being selected.
10627 The default value is `select-safe-coding-system' (which see). */);
10628 Vselect_safe_coding_system_function
= Qnil
;
10630 DEFVAR_BOOL ("coding-system-require-warning",
10631 coding_system_require_warning
,
10632 doc
: /* Internal use only.
10633 If non-nil, on writing a file, `select-safe-coding-system-function' is
10634 called even if `coding-system-for-write' is non-nil. The command
10635 `universal-coding-system-argument' binds this variable to t temporarily. */);
10636 coding_system_require_warning
= 0;
10639 DEFVAR_BOOL ("inhibit-iso-escape-detection",
10640 inhibit_iso_escape_detection
,
10642 If non-nil, Emacs ignores ISO-2022 escape sequences during code detection.
10644 When Emacs reads text, it tries to detect how the text is encoded.
10645 This code detection is sensitive to escape sequences. If Emacs sees
10646 a valid ISO-2022 escape sequence, it assumes the text is encoded in one
10647 of the ISO2022 encodings, and decodes text by the corresponding coding
10648 system (e.g. `iso-2022-7bit').
10650 However, there may be a case that you want to read escape sequences in
10651 a file as is. In such a case, you can set this variable to non-nil.
10652 Then the code detection will ignore any escape sequences, and no text is
10653 detected as encoded in some ISO-2022 encoding. The result is that all
10654 escape sequences become visible in a buffer.
10656 The default value is nil, and it is strongly recommended not to change
10657 it. That is because many Emacs Lisp source files that contain
10658 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
10659 in Emacs's distribution, and they won't be decoded correctly on
10660 reading if you suppress escape sequence detection.
10662 The other way to read escape sequences in a file without decoding is
10663 to explicitly specify some coding system that doesn't use ISO-2022
10664 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
10665 inhibit_iso_escape_detection
= 0;
10667 DEFVAR_BOOL ("inhibit-null-byte-detection",
10668 inhibit_null_byte_detection
,
10669 doc
: /* If non-nil, Emacs ignores null bytes on code detection.
10670 By default, Emacs treats it as binary data, and does not attempt to
10671 decode it. The effect is as if you specified `no-conversion' for
10674 Set this to non-nil when a regular text happens to include null bytes.
10675 Examples are Index nodes of Info files and null-byte delimited output
10676 from GNU Find and GNU Grep. Emacs will then ignore the null bytes and
10677 decode text as usual. */);
10678 inhibit_null_byte_detection
= 0;
10680 DEFVAR_LISP ("translation-table-for-input", Vtranslation_table_for_input
,
10681 doc
: /* Char table for translating self-inserting characters.
10682 This is applied to the result of input methods, not their input.
10683 See also `keyboard-translate-table'.
10685 Use of this variable for character code unification was rendered
10686 obsolete in Emacs 23.1 and later, since Unicode is now the basis of
10687 internal character representation. */);
10688 Vtranslation_table_for_input
= Qnil
;
10691 Lisp_Object args
[coding_arg_max
];
10692 Lisp_Object plist
[16];
10695 for (i
= 0; i
< coding_arg_max
; i
++)
10698 plist
[0] = intern_c_string (":name");
10699 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
10700 plist
[2] = intern_c_string (":mnemonic");
10701 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
10702 plist
[4] = intern_c_string (":coding-type");
10703 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
10704 plist
[6] = intern_c_string (":ascii-compatible-p");
10705 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
10706 plist
[8] = intern_c_string (":default-char");
10707 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
10708 plist
[10] = intern_c_string (":for-unibyte");
10709 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
10710 plist
[12] = intern_c_string (":docstring");
10711 plist
[13] = make_pure_c_string ("Do no conversion.\n\
10713 When you visit a file with this coding, the file is read into a\n\
10714 unibyte buffer as is, thus each byte of a file is treated as a\n\
10716 plist
[14] = intern_c_string (":eol-type");
10717 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
10718 args
[coding_arg_plist
] = Flist (16, plist
);
10719 Fdefine_coding_system_internal (coding_arg_max
, args
);
10721 plist
[1] = args
[coding_arg_name
] = Qundecided
;
10722 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
10723 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
10724 /* This is already set.
10725 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
10726 plist
[8] = intern_c_string (":charset-list");
10727 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
10728 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
10729 plist
[13] = make_pure_c_string ("No conversion on encoding, automatic conversion on decoding.");
10730 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
10731 args
[coding_arg_plist
] = Flist (16, plist
);
10732 Fdefine_coding_system_internal (coding_arg_max
, args
);
10735 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
10740 for (i
= 0; i
< coding_category_max
; i
++)
10741 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
10743 #if defined (DOS_NT)
10744 system_eol_type
= Qdos
;
10746 system_eol_type
= Qunix
;
10748 staticpro (&system_eol_type
);
10752 emacs_strerror (int error_number
)
10756 synchronize_system_messages_locale ();
10757 str
= strerror (error_number
);
10759 if (! NILP (Vlocale_coding_system
))
10761 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
10762 Vlocale_coding_system
,
10764 str
= SSDATA (dec
);