1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H14PRO021
9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
12 This file is part of GNU Emacs.
14 GNU Emacs is free software: you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation, either version 3 of the License, or
17 (at your option) any later version.
19 GNU Emacs is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
27 /*** TABLE OF CONTENTS ***
31 2. Emacs' internal format (emacs-utf-8) handlers
34 5. Charset-base coding systems handlers
35 6. emacs-mule (old Emacs' internal format) handlers
37 8. Shift-JIS and BIG5 handlers
39 10. C library functions
40 11. Emacs Lisp library functions
45 /*** 0. General comments ***
50 A coding system is an object for an encoding mechanism that contains
51 information about how to convert byte sequences to character
52 sequences and vice versa. When we say "decode", it means converting
53 a byte sequence of a specific coding system into a character
54 sequence that is represented by Emacs' internal coding system
55 `emacs-utf-8', and when we say "encode", it means converting a
56 character sequence of emacs-utf-8 to a byte sequence of a specific
59 In Emacs Lisp, a coding system is represented by a Lisp symbol. In
60 C level, a coding system is represented by a vector of attributes
61 stored in the hash table Vcharset_hash_table. The conversion from
62 coding system symbol to attributes vector is done by looking up
63 Vcharset_hash_table by the symbol.
65 Coding systems are classified into the following types depending on
66 the encoding mechanism. Here's a brief description of the types.
72 o Charset-base coding system
74 A coding system defined by one or more (coded) character sets.
75 Decoding and encoding are done by a code converter defined for each
78 o Old Emacs internal format (emacs-mule)
80 The coding system adopted by old versions of Emacs (20 and 21).
82 o ISO2022-base coding system
84 The most famous coding system for multiple character sets. X's
85 Compound Text, various EUCs (Extended Unix Code), and coding systems
86 used in the Internet communication such as ISO-2022-JP are all
89 o SJIS (or Shift-JIS or MS-Kanji-Code)
91 A coding system to encode character sets: ASCII, JISX0201, and
92 JISX0208. Widely used for PC's in Japan. Details are described in
97 A coding system to encode character sets: ASCII and Big5. Widely
98 used for Chinese (mainly in Taiwan and Hong Kong). Details are
99 described in section 8. In this file, when we write "big5" (all
100 lowercase), we mean the coding system, and when we write "Big5"
101 (capitalized), we mean the character set.
105 If a user wants to decode/encode text encoded in a coding system
106 not listed above, he can supply a decoder and an encoder for it in
107 CCL (Code Conversion Language) programs. Emacs executes the CCL
108 program while decoding/encoding.
112 A coding system for text containing raw eight-bit data. Emacs
113 treats each byte of source text as a character (except for
114 end-of-line conversion).
118 Like raw text, but don't do end-of-line conversion.
123 How text end-of-line is encoded depends on operating system. For
124 instance, Unix's format is just one byte of LF (line-feed) code,
125 whereas DOS's format is two-byte sequence of `carriage-return' and
126 `line-feed' codes. MacOS's format is usually one byte of
129 Since text character encoding and end-of-line encoding are
130 independent, any coding system described above can take any format
131 of end-of-line (except for no-conversion).
135 Before using a coding system for code conversion (i.e. decoding and
136 encoding), we setup a structure of type `struct coding_system'.
137 This structure keeps various information about a specific code
138 conversion (e.g. the location of source and destination data).
145 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
147 These functions check if a byte sequence specified as a source in
148 CODING conforms to the format of XXX, and update the members of
151 Return 1 if the byte sequence conforms to XXX, otherwise return 0.
153 Below is the template of these functions. */
157 detect_coding_XXX (coding
, detect_info
)
158 struct coding_system
*coding
;
159 struct coding_detection_info
*detect_info
;
161 const unsigned char *src
= coding
->source
;
162 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
163 int multibytep
= coding
->src_multibyte
;
164 int consumed_chars
= 0;
170 /* Get one byte from the source. If the souce is exausted, jump
171 to no_more_source:. */
174 if (! __C_conforms_to_XXX___ (c
))
176 if (! __C_strongly_suggests_XXX__ (c
))
177 found
= CATEGORY_MASK_XXX
;
179 /* The byte sequence is invalid for XXX. */
180 detect_info
->rejected
|= CATEGORY_MASK_XXX
;
184 /* The source exausted successfully. */
185 detect_info
->found
|= found
;
190 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
192 These functions decode a byte sequence specified as a source by
193 CODING. The resulting multibyte text goes to a place pointed to by
194 CODING->charbuf, the length of which should not exceed
195 CODING->charbuf_size;
197 These functions set the information of original and decoded texts in
198 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
199 They also set CODING->result to one of CODING_RESULT_XXX indicating
200 how the decoding is finished.
202 Below is the template of these functions. */
206 decode_coding_XXXX (coding
)
207 struct coding_system
*coding
;
209 const unsigned char *src
= coding
->source
+ coding
->consumed
;
210 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
211 /* SRC_BASE remembers the start position in source in each loop.
212 The loop will be exited when there's not enough source code, or
213 when there's no room in CHARBUF for a decoded character. */
214 const unsigned char *src_base
;
215 /* A buffer to produce decoded characters. */
216 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
217 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
218 int multibytep
= coding
->src_multibyte
;
223 if (charbuf
< charbuf_end
)
224 /* No more room to produce a decoded character. */
231 if (src_base
< src_end
232 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
233 /* If the source ends by partial bytes to construct a character,
234 treat them as eight-bit raw data. */
235 while (src_base
< src_end
&& charbuf
< charbuf_end
)
236 *charbuf
++ = *src_base
++;
237 /* Remember how many bytes and characters we consumed. If the
238 source is multibyte, the bytes and chars are not identical. */
239 coding
->consumed
= coding
->consumed_char
= src_base
- coding
->source
;
240 /* Remember how many characters we produced. */
241 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
245 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
247 These functions encode SRC_BYTES length text at SOURCE of Emacs'
248 internal multibyte format by CODING. The resulting byte sequence
249 goes to a place pointed to by DESTINATION, the length of which
250 should not exceed DST_BYTES.
252 These functions set the information of original and encoded texts in
253 the members produced, produced_char, consumed, and consumed_char of
254 the structure *CODING. They also set the member result to one of
255 CODING_RESULT_XXX indicating how the encoding finished.
257 DST_BYTES zero means that source area and destination area are
258 overlapped, which means that we can produce a encoded text until it
259 reaches at the head of not-yet-encoded source text.
261 Below is a template of these functions. */
264 encode_coding_XXX (coding
)
265 struct coding_system
*coding
;
267 int multibytep
= coding
->dst_multibyte
;
268 int *charbuf
= coding
->charbuf
;
269 int *charbuf_end
= charbuf
->charbuf
+ coding
->charbuf_used
;
270 unsigned char *dst
= coding
->destination
+ coding
->produced
;
271 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
272 unsigned char *adjusted_dst_end
= dst_end
- _MAX_BYTES_PRODUCED_IN_LOOP_
;
273 int produced_chars
= 0;
275 for (; charbuf
< charbuf_end
&& dst
< adjusted_dst_end
; charbuf
++)
278 /* Encode C into DST, and increment DST. */
280 label_no_more_destination
:
281 /* How many chars and bytes we produced. */
282 coding
->produced_char
+= produced_chars
;
283 coding
->produced
= dst
- coding
->destination
;
288 /*** 1. Preamble ***/
295 #include "character.h"
298 #include "composite.h"
302 #include "termhooks.h"
304 Lisp_Object Vcoding_system_hash_table
;
306 Lisp_Object Qcoding_system
, Qcoding_aliases
, Qeol_type
;
307 Lisp_Object Qunix
, Qdos
;
308 extern Lisp_Object Qmac
; /* frame.c */
309 Lisp_Object Qbuffer_file_coding_system
;
310 Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
311 Lisp_Object Qdefault_char
;
312 Lisp_Object Qno_conversion
, Qundecided
;
313 Lisp_Object Qcharset
, Qiso_2022
, Qutf_8
, Qutf_16
, Qshift_jis
, Qbig5
;
314 Lisp_Object Qbig
, Qlittle
;
315 Lisp_Object Qcoding_system_history
;
316 Lisp_Object Qvalid_codes
;
317 Lisp_Object QCcategory
, QCmnemonic
, QCdefault_char
;
318 Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
319 Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
320 Lisp_Object QCascii_compatible_p
;
322 extern Lisp_Object Qinsert_file_contents
, Qwrite_region
;
323 Lisp_Object Qcall_process
, Qcall_process_region
;
324 Lisp_Object Qstart_process
, Qopen_network_stream
;
325 Lisp_Object Qtarget_idx
;
327 Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
328 Lisp_Object Qinterrupted
, Qinsufficient_memory
;
330 extern Lisp_Object Qcompletion_ignore_case
;
332 /* If a symbol has this property, evaluate the value to define the
333 symbol as a coding system. */
334 static Lisp_Object Qcoding_system_define_form
;
336 int coding_system_require_warning
;
338 Lisp_Object Vselect_safe_coding_system_function
;
340 /* Mnemonic string for each format of end-of-line. */
341 Lisp_Object eol_mnemonic_unix
, eol_mnemonic_dos
, eol_mnemonic_mac
;
342 /* Mnemonic string to indicate format of end-of-line is not yet
344 Lisp_Object eol_mnemonic_undecided
;
346 /* Format of end-of-line decided by system. This is Qunix on
347 Unix and Mac, Qdos on DOS/Windows.
348 This has an effect only for external encoding (i.e. for output to
349 file and process), not for in-buffer or Lisp string encoding. */
350 static Lisp_Object system_eol_type
;
354 Lisp_Object Vcoding_system_list
, Vcoding_system_alist
;
356 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
358 /* Coding system emacs-mule and raw-text are for converting only
359 end-of-line format. */
360 Lisp_Object Qemacs_mule
, Qraw_text
;
361 Lisp_Object Qutf_8_emacs
;
363 /* Coding-systems are handed between Emacs Lisp programs and C internal
364 routines by the following three variables. */
365 /* Coding-system for reading files and receiving data from process. */
366 Lisp_Object Vcoding_system_for_read
;
367 /* Coding-system for writing files and sending data to process. */
368 Lisp_Object Vcoding_system_for_write
;
369 /* Coding-system actually used in the latest I/O. */
370 Lisp_Object Vlast_coding_system_used
;
371 /* Set to non-nil when an error is detected while code conversion. */
372 Lisp_Object Vlast_code_conversion_error
;
373 /* A vector of length 256 which contains information about special
374 Latin codes (especially for dealing with Microsoft codes). */
375 Lisp_Object Vlatin_extra_code_table
;
377 /* Flag to inhibit code conversion of end-of-line format. */
378 int inhibit_eol_conversion
;
380 /* Flag to inhibit ISO2022 escape sequence detection. */
381 int inhibit_iso_escape_detection
;
383 /* Flag to make buffer-file-coding-system inherit from process-coding. */
384 int inherit_process_coding_system
;
386 /* Coding system to be used to encode text for terminal display when
387 terminal coding system is nil. */
388 struct coding_system safe_terminal_coding
;
390 Lisp_Object Vfile_coding_system_alist
;
391 Lisp_Object Vprocess_coding_system_alist
;
392 Lisp_Object Vnetwork_coding_system_alist
;
394 Lisp_Object Vlocale_coding_system
;
398 /* Flag to tell if we look up translation table on character code
400 Lisp_Object Venable_character_translation
;
401 /* Standard translation table to look up on decoding (reading). */
402 Lisp_Object Vstandard_translation_table_for_decode
;
403 /* Standard translation table to look up on encoding (writing). */
404 Lisp_Object Vstandard_translation_table_for_encode
;
406 Lisp_Object Qtranslation_table
;
407 Lisp_Object Qtranslation_table_id
;
408 Lisp_Object Qtranslation_table_for_decode
;
409 Lisp_Object Qtranslation_table_for_encode
;
411 /* Alist of charsets vs revision number. */
412 static Lisp_Object Vcharset_revision_table
;
414 /* Default coding systems used for process I/O. */
415 Lisp_Object Vdefault_process_coding_system
;
417 /* Char table for translating Quail and self-inserting input. */
418 Lisp_Object Vtranslation_table_for_input
;
420 /* Two special coding systems. */
421 Lisp_Object Vsjis_coding_system
;
422 Lisp_Object Vbig5_coding_system
;
424 /* ISO2022 section */
426 #define CODING_ISO_INITIAL(coding, reg) \
427 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
428 coding_attr_iso_initial), \
432 #define CODING_ISO_REQUEST(coding, charset_id) \
433 ((charset_id <= (coding)->max_charset_id \
434 ? (coding)->safe_charsets[charset_id] \
438 #define CODING_ISO_FLAGS(coding) \
439 ((coding)->spec.iso_2022.flags)
440 #define CODING_ISO_DESIGNATION(coding, reg) \
441 ((coding)->spec.iso_2022.current_designation[reg])
442 #define CODING_ISO_INVOCATION(coding, plane) \
443 ((coding)->spec.iso_2022.current_invocation[plane])
444 #define CODING_ISO_SINGLE_SHIFTING(coding) \
445 ((coding)->spec.iso_2022.single_shifting)
446 #define CODING_ISO_BOL(coding) \
447 ((coding)->spec.iso_2022.bol)
448 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
449 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
451 /* Control characters of ISO2022. */
452 /* code */ /* function */
453 #define ISO_CODE_LF 0x0A /* line-feed */
454 #define ISO_CODE_CR 0x0D /* carriage-return */
455 #define ISO_CODE_SO 0x0E /* shift-out */
456 #define ISO_CODE_SI 0x0F /* shift-in */
457 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
458 #define ISO_CODE_ESC 0x1B /* escape */
459 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
460 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
461 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
463 /* All code (1-byte) of ISO2022 is classified into one of the
465 enum iso_code_class_type
467 ISO_control_0
, /* Control codes in the range
468 0x00..0x1F and 0x7F, except for the
469 following 5 codes. */
470 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
471 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
472 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
473 ISO_escape
, /* ISO_CODE_SO (0x1B) */
474 ISO_control_1
, /* Control codes in the range
475 0x80..0x9F, except for the
476 following 3 codes. */
477 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
478 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
479 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
480 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
481 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
482 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
483 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
486 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
487 `iso-flags' attribute of an iso2022 coding system. */
489 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
490 instead of the correct short-form sequence (e.g. ESC $ A). */
491 #define CODING_ISO_FLAG_LONG_FORM 0x0001
493 /* If set, reset graphic planes and registers at end-of-line to the
495 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
497 /* If set, reset graphic planes and registers before any control
498 characters to the initial state. */
499 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
501 /* If set, encode by 7-bit environment. */
502 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
504 /* If set, use locking-shift function. */
505 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
507 /* If set, use single-shift function. Overwrite
508 CODING_ISO_FLAG_LOCKING_SHIFT. */
509 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
511 /* If set, use designation escape sequence. */
512 #define CODING_ISO_FLAG_DESIGNATION 0x0040
514 /* If set, produce revision number sequence. */
515 #define CODING_ISO_FLAG_REVISION 0x0080
517 /* If set, produce ISO6429's direction specifying sequence. */
518 #define CODING_ISO_FLAG_DIRECTION 0x0100
520 /* If set, assume designation states are reset at beginning of line on
522 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
524 /* If set, designation sequence should be placed at beginning of line
526 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
528 /* If set, do not encode unsafe charactes on output. */
529 #define CODING_ISO_FLAG_SAFE 0x0800
531 /* If set, extra latin codes (128..159) are accepted as a valid code
533 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
535 #define CODING_ISO_FLAG_COMPOSITION 0x2000
537 #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000
539 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
541 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
543 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
545 /* A character to be produced on output if encoding of the original
546 character is prohibited by CODING_ISO_FLAG_SAFE. */
547 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
550 #define CODING_UTF_8_BOM(coding) \
551 ((coding)->spec.utf_8_bom)
554 #define CODING_UTF_16_BOM(coding) \
555 ((coding)->spec.utf_16.bom)
557 #define CODING_UTF_16_ENDIAN(coding) \
558 ((coding)->spec.utf_16.endian)
560 #define CODING_UTF_16_SURROGATE(coding) \
561 ((coding)->spec.utf_16.surrogate)
565 #define CODING_CCL_DECODER(coding) \
566 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
567 #define CODING_CCL_ENCODER(coding) \
568 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
569 #define CODING_CCL_VALIDS(coding) \
570 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
572 /* Index for each coding category in `coding_categories' */
576 coding_category_iso_7
,
577 coding_category_iso_7_tight
,
578 coding_category_iso_8_1
,
579 coding_category_iso_8_2
,
580 coding_category_iso_7_else
,
581 coding_category_iso_8_else
,
582 coding_category_utf_8_auto
,
583 coding_category_utf_8_nosig
,
584 coding_category_utf_8_sig
,
585 coding_category_utf_16_auto
,
586 coding_category_utf_16_be
,
587 coding_category_utf_16_le
,
588 coding_category_utf_16_be_nosig
,
589 coding_category_utf_16_le_nosig
,
590 coding_category_charset
,
591 coding_category_sjis
,
592 coding_category_big5
,
594 coding_category_emacs_mule
,
595 /* All above are targets of code detection. */
596 coding_category_raw_text
,
597 coding_category_undecided
,
601 /* Definitions of flag bits used in detect_coding_XXXX. */
602 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
603 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
604 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
605 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
606 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
607 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
608 #define CATEGORY_MASK_UTF_8_AUTO (1 << coding_category_utf_8_auto)
609 #define CATEGORY_MASK_UTF_8_NOSIG (1 << coding_category_utf_8_nosig)
610 #define CATEGORY_MASK_UTF_8_SIG (1 << coding_category_utf_8_sig)
611 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
612 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
613 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
614 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
615 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
616 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
617 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
618 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
619 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
620 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
621 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
623 /* This value is returned if detect_coding_mask () find nothing other
624 than ASCII characters. */
625 #define CATEGORY_MASK_ANY \
626 (CATEGORY_MASK_ISO_7 \
627 | CATEGORY_MASK_ISO_7_TIGHT \
628 | CATEGORY_MASK_ISO_8_1 \
629 | CATEGORY_MASK_ISO_8_2 \
630 | CATEGORY_MASK_ISO_7_ELSE \
631 | CATEGORY_MASK_ISO_8_ELSE \
632 | CATEGORY_MASK_UTF_8_AUTO \
633 | CATEGORY_MASK_UTF_8_NOSIG \
634 | CATEGORY_MASK_UTF_8_SIG \
635 | CATEGORY_MASK_UTF_16_AUTO \
636 | CATEGORY_MASK_UTF_16_BE \
637 | CATEGORY_MASK_UTF_16_LE \
638 | CATEGORY_MASK_UTF_16_BE_NOSIG \
639 | CATEGORY_MASK_UTF_16_LE_NOSIG \
640 | CATEGORY_MASK_CHARSET \
641 | CATEGORY_MASK_SJIS \
642 | CATEGORY_MASK_BIG5 \
643 | CATEGORY_MASK_CCL \
644 | CATEGORY_MASK_EMACS_MULE)
647 #define CATEGORY_MASK_ISO_7BIT \
648 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
650 #define CATEGORY_MASK_ISO_8BIT \
651 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
653 #define CATEGORY_MASK_ISO_ELSE \
654 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
656 #define CATEGORY_MASK_ISO_ESCAPE \
657 (CATEGORY_MASK_ISO_7 \
658 | CATEGORY_MASK_ISO_7_TIGHT \
659 | CATEGORY_MASK_ISO_7_ELSE \
660 | CATEGORY_MASK_ISO_8_ELSE)
662 #define CATEGORY_MASK_ISO \
663 ( CATEGORY_MASK_ISO_7BIT \
664 | CATEGORY_MASK_ISO_8BIT \
665 | CATEGORY_MASK_ISO_ELSE)
667 #define CATEGORY_MASK_UTF_16 \
668 (CATEGORY_MASK_UTF_16_AUTO \
669 | CATEGORY_MASK_UTF_16_BE \
670 | CATEGORY_MASK_UTF_16_LE \
671 | CATEGORY_MASK_UTF_16_BE_NOSIG \
672 | CATEGORY_MASK_UTF_16_LE_NOSIG)
674 #define CATEGORY_MASK_UTF_8 \
675 (CATEGORY_MASK_UTF_8_AUTO \
676 | CATEGORY_MASK_UTF_8_NOSIG \
677 | CATEGORY_MASK_UTF_8_SIG)
679 /* List of symbols `coding-category-xxx' ordered by priority. This
680 variable is exposed to Emacs Lisp. */
681 static Lisp_Object Vcoding_category_list
;
683 /* Table of coding categories (Lisp symbols). This variable is for
685 static Lisp_Object Vcoding_category_table
;
687 /* Table of coding-categories ordered by priority. */
688 static enum coding_category coding_priorities
[coding_category_max
];
690 /* Nth element is a coding context for the coding system bound to the
691 Nth coding category. */
692 static struct coding_system coding_categories
[coding_category_max
];
694 /*** Commonly used macros and functions ***/
697 #define min(a, b) ((a) < (b) ? (a) : (b))
700 #define max(a, b) ((a) > (b) ? (a) : (b))
703 #define CODING_GET_INFO(coding, attrs, charset_list) \
705 (attrs) = CODING_ID_ATTRS ((coding)->id); \
706 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
710 /* Safely get one byte from the source text pointed by SRC which ends
711 at SRC_END, and set C to that byte. If there are not enough bytes
712 in the source, it jumps to `no_more_source'. If multibytep is
713 nonzero, and a multibyte character is found at SRC, set C to the
714 negative value of the character code. The caller should declare
715 and set these variables appropriately in advance:
716 src, src_end, multibytep */
718 #define ONE_MORE_BYTE(c) \
720 if (src == src_end) \
722 if (src_base < src) \
723 record_conversion_result \
724 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
725 goto no_more_source; \
728 if (multibytep && (c & 0x80)) \
730 if ((c & 0xFE) == 0xC0) \
731 c = ((c & 1) << 6) | *src++; \
735 c = - string_char (src, &src, NULL); \
736 record_conversion_result \
737 (coding, CODING_RESULT_INVALID_SRC); \
744 #define ONE_MORE_BYTE_NO_CHECK(c) \
747 if (multibytep && (c & 0x80)) \
749 if ((c & 0xFE) == 0xC0) \
750 c = ((c & 1) << 6) | *src++; \
754 c = - string_char (src, &src, NULL); \
755 record_conversion_result \
756 (coding, CODING_RESULT_INVALID_SRC); \
763 /* Store a byte C in the place pointed by DST and increment DST to the
764 next free point, and increment PRODUCED_CHARS. The caller should
765 assure that C is 0..127, and declare and set the variable `dst'
766 appropriately in advance.
770 #define EMIT_ONE_ASCII_BYTE(c) \
777 /* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
779 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
781 produced_chars += 2; \
782 *dst++ = (c1), *dst++ = (c2); \
786 /* Store a byte C in the place pointed by DST and increment DST to the
787 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
788 nonzero, store in an appropriate multibyte from. The caller should
789 declare and set the variables `dst' and `multibytep' appropriately
792 #define EMIT_ONE_BYTE(c) \
799 ch = BYTE8_TO_CHAR (ch); \
800 CHAR_STRING_ADVANCE (ch, dst); \
807 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
809 #define EMIT_TWO_BYTES(c1, c2) \
811 produced_chars += 2; \
818 ch = BYTE8_TO_CHAR (ch); \
819 CHAR_STRING_ADVANCE (ch, dst); \
822 ch = BYTE8_TO_CHAR (ch); \
823 CHAR_STRING_ADVANCE (ch, dst); \
833 #define EMIT_THREE_BYTES(c1, c2, c3) \
835 EMIT_ONE_BYTE (c1); \
836 EMIT_TWO_BYTES (c2, c3); \
840 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
842 EMIT_TWO_BYTES (c1, c2); \
843 EMIT_TWO_BYTES (c3, c4); \
847 /* Prototypes for static functions. */
848 static void record_conversion_result
P_ ((struct coding_system
*coding
,
849 enum coding_result_code result
));
850 static int detect_coding_utf_8
P_ ((struct coding_system
*,
851 struct coding_detection_info
*info
));
852 static void decode_coding_utf_8
P_ ((struct coding_system
*));
853 static int encode_coding_utf_8
P_ ((struct coding_system
*));
855 static int detect_coding_utf_16
P_ ((struct coding_system
*,
856 struct coding_detection_info
*info
));
857 static void decode_coding_utf_16
P_ ((struct coding_system
*));
858 static int encode_coding_utf_16
P_ ((struct coding_system
*));
860 static int detect_coding_iso_2022
P_ ((struct coding_system
*,
861 struct coding_detection_info
*info
));
862 static void decode_coding_iso_2022
P_ ((struct coding_system
*));
863 static int encode_coding_iso_2022
P_ ((struct coding_system
*));
865 static int detect_coding_emacs_mule
P_ ((struct coding_system
*,
866 struct coding_detection_info
*info
));
867 static void decode_coding_emacs_mule
P_ ((struct coding_system
*));
868 static int encode_coding_emacs_mule
P_ ((struct coding_system
*));
870 static int detect_coding_sjis
P_ ((struct coding_system
*,
871 struct coding_detection_info
*info
));
872 static void decode_coding_sjis
P_ ((struct coding_system
*));
873 static int encode_coding_sjis
P_ ((struct coding_system
*));
875 static int detect_coding_big5
P_ ((struct coding_system
*,
876 struct coding_detection_info
*info
));
877 static void decode_coding_big5
P_ ((struct coding_system
*));
878 static int encode_coding_big5
P_ ((struct coding_system
*));
880 static int detect_coding_ccl
P_ ((struct coding_system
*,
881 struct coding_detection_info
*info
));
882 static void decode_coding_ccl
P_ ((struct coding_system
*));
883 static int encode_coding_ccl
P_ ((struct coding_system
*));
885 static void decode_coding_raw_text
P_ ((struct coding_system
*));
886 static int encode_coding_raw_text
P_ ((struct coding_system
*));
888 static void coding_set_source
P_ ((struct coding_system
*));
889 static void coding_set_destination
P_ ((struct coding_system
*));
890 static void coding_alloc_by_realloc
P_ ((struct coding_system
*, EMACS_INT
));
891 static void coding_alloc_by_making_gap
P_ ((struct coding_system
*,
892 EMACS_INT
, EMACS_INT
));
893 static unsigned char *alloc_destination
P_ ((struct coding_system
*,
894 EMACS_INT
, unsigned char *));
895 static void setup_iso_safe_charsets
P_ ((Lisp_Object
));
896 static unsigned char *encode_designation_at_bol
P_ ((struct coding_system
*,
899 static int detect_eol
P_ ((const unsigned char *,
900 EMACS_INT
, enum coding_category
));
901 static Lisp_Object adjust_coding_eol_type
P_ ((struct coding_system
*, int));
902 static void decode_eol
P_ ((struct coding_system
*));
903 static Lisp_Object get_translation_table
P_ ((Lisp_Object
, int, int *));
904 static Lisp_Object get_translation
P_ ((Lisp_Object
, int *, int *,
906 static int produce_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
907 static INLINE
void produce_composition
P_ ((struct coding_system
*, int *,
909 static INLINE
void produce_charset
P_ ((struct coding_system
*, int *,
911 static void produce_annotation
P_ ((struct coding_system
*, EMACS_INT
));
912 static int decode_coding
P_ ((struct coding_system
*));
913 static INLINE
int *handle_composition_annotation
P_ ((EMACS_INT
, EMACS_INT
,
914 struct coding_system
*,
915 int *, EMACS_INT
*));
916 static INLINE
int *handle_charset_annotation
P_ ((EMACS_INT
, EMACS_INT
,
917 struct coding_system
*,
918 int *, EMACS_INT
*));
919 static void consume_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
920 static int encode_coding
P_ ((struct coding_system
*));
921 static Lisp_Object make_conversion_work_buffer
P_ ((int));
922 static Lisp_Object code_conversion_restore
P_ ((Lisp_Object
));
923 static INLINE
int char_encodable_p
P_ ((int, Lisp_Object
));
924 static Lisp_Object make_subsidiaries
P_ ((Lisp_Object
));
927 record_conversion_result (struct coding_system
*coding
,
928 enum coding_result_code result
)
930 coding
->result
= result
;
933 case CODING_RESULT_INSUFFICIENT_SRC
:
934 Vlast_code_conversion_error
= Qinsufficient_source
;
936 case CODING_RESULT_INCONSISTENT_EOL
:
937 Vlast_code_conversion_error
= Qinconsistent_eol
;
939 case CODING_RESULT_INVALID_SRC
:
940 Vlast_code_conversion_error
= Qinvalid_source
;
942 case CODING_RESULT_INTERRUPT
:
943 Vlast_code_conversion_error
= Qinterrupted
;
945 case CODING_RESULT_INSUFFICIENT_MEM
:
946 Vlast_code_conversion_error
= Qinsufficient_memory
;
949 Vlast_code_conversion_error
= intern ("Unknown error");
953 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
955 charset_map_loaded = 0; \
956 c = DECODE_CHAR (charset, code); \
957 if (charset_map_loaded) \
959 const unsigned char *orig = coding->source; \
962 coding_set_source (coding); \
963 offset = coding->source - orig; \
965 src_base += offset; \
971 /* If there are at least BYTES length of room at dst, allocate memory
972 for coding->destination and update dst and dst_end. We don't have
973 to take care of coding->source which will be relocated. It is
974 handled by calling coding_set_source in encode_coding. */
976 #define ASSURE_DESTINATION(bytes) \
978 if (dst + (bytes) >= dst_end) \
980 int more_bytes = charbuf_end - charbuf + (bytes); \
982 dst = alloc_destination (coding, more_bytes, dst); \
983 dst_end = coding->destination + coding->dst_bytes; \
988 /* Store multibyte form of the character C in P, and advance P to the
989 end of the multibyte form. This is like CHAR_STRING_ADVANCE but it
990 never calls MAYBE_UNIFY_CHAR. */
992 #define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) \
994 if ((c) <= MAX_1_BYTE_CHAR) \
996 else if ((c) <= MAX_2_BYTE_CHAR) \
997 *(p)++ = (0xC0 | ((c) >> 6)), \
998 *(p)++ = (0x80 | ((c) & 0x3F)); \
999 else if ((c) <= MAX_3_BYTE_CHAR) \
1000 *(p)++ = (0xE0 | ((c) >> 12)), \
1001 *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \
1002 *(p)++ = (0x80 | ((c) & 0x3F)); \
1003 else if ((c) <= MAX_4_BYTE_CHAR) \
1004 *(p)++ = (0xF0 | (c >> 18)), \
1005 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
1006 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
1007 *(p)++ = (0x80 | (c & 0x3F)); \
1008 else if ((c) <= MAX_5_BYTE_CHAR) \
1010 *(p)++ = (0x80 | ((c >> 18) & 0x0F)), \
1011 *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \
1012 *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \
1013 *(p)++ = (0x80 | (c & 0x3F)); \
1015 (p) += BYTE8_STRING ((c) - 0x3FFF80, p); \
1019 /* Return the character code of character whose multibyte form is at
1020 P, and advance P to the end of the multibyte form. This is like
1021 STRING_CHAR_ADVANCE, but it never calls MAYBE_UNIFY_CHAR. */
1023 #define STRING_CHAR_ADVANCE_NO_UNIFY(p) \
1026 : ! ((p)[0] & 0x20) \
1028 ((((p)[-2] & 0x1F) << 6) \
1029 | ((p)[-1] & 0x3F) \
1030 | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0))) \
1031 : ! ((p)[0] & 0x10) \
1033 ((((p)[-3] & 0x0F) << 12) \
1034 | (((p)[-2] & 0x3F) << 6) \
1035 | ((p)[-1] & 0x3F))) \
1036 : ! ((p)[0] & 0x08) \
1038 ((((p)[-4] & 0xF) << 18) \
1039 | (((p)[-3] & 0x3F) << 12) \
1040 | (((p)[-2] & 0x3F) << 6) \
1041 | ((p)[-1] & 0x3F))) \
1043 ((((p)[-4] & 0x3F) << 18) \
1044 | (((p)[-3] & 0x3F) << 12) \
1045 | (((p)[-2] & 0x3F) << 6) \
1046 | ((p)[-1] & 0x3F))))
1050 coding_set_source (coding
)
1051 struct coding_system
*coding
;
1053 if (BUFFERP (coding
->src_object
))
1055 struct buffer
*buf
= XBUFFER (coding
->src_object
);
1057 if (coding
->src_pos
< 0)
1058 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
1060 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
1062 else if (STRINGP (coding
->src_object
))
1064 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
1067 /* Otherwise, the source is C string and is never relocated
1068 automatically. Thus we don't have to update anything. */
1073 coding_set_destination (coding
)
1074 struct coding_system
*coding
;
1076 if (BUFFERP (coding
->dst_object
))
1078 if (coding
->src_pos
< 0)
1080 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- BEG_BYTE
;
1081 coding
->dst_bytes
= (GAP_END_ADDR
1082 - (coding
->src_bytes
- coding
->consumed
)
1083 - coding
->destination
);
1087 /* We are sure that coding->dst_pos_byte is before the gap
1089 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
1090 + coding
->dst_pos_byte
- BEG_BYTE
);
1091 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
1092 - coding
->destination
);
1096 /* Otherwise, the destination is C string and is never relocated
1097 automatically. Thus we don't have to update anything. */
1103 coding_alloc_by_realloc (coding
, bytes
)
1104 struct coding_system
*coding
;
1107 coding
->destination
= (unsigned char *) xrealloc (coding
->destination
,
1108 coding
->dst_bytes
+ bytes
);
1109 coding
->dst_bytes
+= bytes
;
1113 coding_alloc_by_making_gap (coding
, gap_head_used
, bytes
)
1114 struct coding_system
*coding
;
1115 EMACS_INT gap_head_used
, bytes
;
1117 if (EQ (coding
->src_object
, coding
->dst_object
))
1119 /* The gap may contain the produced data at the head and not-yet
1120 consumed data at the tail. To preserve those data, we at
1121 first make the gap size to zero, then increase the gap
1123 EMACS_INT add
= GAP_SIZE
;
1125 GPT
+= gap_head_used
, GPT_BYTE
+= gap_head_used
;
1126 GAP_SIZE
= 0; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1128 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1129 GPT
-= gap_head_used
, GPT_BYTE
-= gap_head_used
;
1133 Lisp_Object this_buffer
;
1135 this_buffer
= Fcurrent_buffer ();
1136 set_buffer_internal (XBUFFER (coding
->dst_object
));
1138 set_buffer_internal (XBUFFER (this_buffer
));
1143 static unsigned char *
1144 alloc_destination (coding
, nbytes
, dst
)
1145 struct coding_system
*coding
;
1149 EMACS_INT offset
= dst
- coding
->destination
;
1151 if (BUFFERP (coding
->dst_object
))
1153 struct buffer
*buf
= XBUFFER (coding
->dst_object
);
1155 coding_alloc_by_making_gap (coding
, dst
- BUF_GPT_ADDR (buf
), nbytes
);
1158 coding_alloc_by_realloc (coding
, nbytes
);
1159 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1160 coding_set_destination (coding
);
1161 dst
= coding
->destination
+ offset
;
1165 /** Macros for annotations. */
1167 /* Maximum length of annotation data (sum of annotations for
1168 composition and charset). */
1169 #define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
1171 /* An annotation data is stored in the array coding->charbuf in this
1173 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1174 LENGTH is the number of elements in the annotation.
1175 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1176 NCHARS is the number of characters in the text annotated.
1178 The format of the following elements depend on ANNOTATION_MASK.
1180 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1182 ... METHOD [ COMPOSITION-COMPONENTS ... ]
1183 METHOD is one of enum composition_method.
1184 Optionnal COMPOSITION-COMPONENTS are characters and composition
1187 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1190 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1192 *(buf)++ = -(len); \
1193 *(buf)++ = (mask); \
1194 *(buf)++ = (nchars); \
1195 coding->annotated = 1; \
1198 #define ADD_COMPOSITION_DATA(buf, nchars, method) \
1200 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1205 #define ADD_CHARSET_DATA(buf, nchars, id) \
1207 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1212 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1219 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1220 Check if a text is encoded in UTF-8. If it is, return 1, else
1223 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1224 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1225 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1226 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1227 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1228 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1230 #define UTF_BOM 0xFEFF
1231 #define UTF_8_BOM_1 0xEF
1232 #define UTF_8_BOM_2 0xBB
1233 #define UTF_8_BOM_3 0xBF
1236 detect_coding_utf_8 (coding
, detect_info
)
1237 struct coding_system
*coding
;
1238 struct coding_detection_info
*detect_info
;
1240 const unsigned char *src
= coding
->source
, *src_base
;
1241 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1242 int multibytep
= coding
->src_multibyte
;
1243 int consumed_chars
= 0;
1247 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1248 /* A coding system of this category is always ASCII compatible. */
1249 src
+= coding
->head_ascii
;
1253 int c
, c1
, c2
, c3
, c4
;
1257 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1260 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1262 if (UTF_8_2_OCTET_LEADING_P (c
))
1268 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1270 if (UTF_8_3_OCTET_LEADING_P (c
))
1273 if (src_base
== coding
->source
1274 && c
== UTF_8_BOM_1
&& c1
== UTF_8_BOM_2
&& c2
== UTF_8_BOM_3
)
1279 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1281 if (UTF_8_4_OCTET_LEADING_P (c
))
1287 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1289 if (UTF_8_5_OCTET_LEADING_P (c
))
1296 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1300 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1302 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1307 /* The first character 0xFFFE doesn't necessarily mean a BOM. */
1308 detect_info
->found
|= CATEGORY_MASK_UTF_8_SIG
| CATEGORY_MASK_UTF_8_NOSIG
;
1312 detect_info
->rejected
|= CATEGORY_MASK_UTF_8_SIG
;
1314 detect_info
->found
|= CATEGORY_MASK_UTF_8_NOSIG
;
1321 decode_coding_utf_8 (coding
)
1322 struct coding_system
*coding
;
1324 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1325 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1326 const unsigned char *src_base
;
1327 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1328 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1329 int consumed_chars
= 0, consumed_chars_base
= 0;
1330 int multibytep
= coding
->src_multibyte
;
1331 enum utf_bom_type bom
= CODING_UTF_8_BOM (coding
);
1332 Lisp_Object attr
, charset_list
;
1333 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1334 int byte_after_cr
= -1;
1336 CODING_GET_INFO (coding
, attr
, charset_list
);
1338 if (bom
!= utf_without_bom
)
1344 if (! UTF_8_3_OCTET_LEADING_P (c1
))
1349 if (! UTF_8_EXTRA_OCTET_P (c2
))
1354 if (! UTF_8_EXTRA_OCTET_P (c3
))
1358 if ((c1
!= UTF_8_BOM_1
)
1359 || (c2
!= UTF_8_BOM_2
) || (c3
!= UTF_8_BOM_3
))
1362 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1367 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1373 int c
, c1
, c2
, c3
, c4
, c5
;
1376 consumed_chars_base
= consumed_chars
;
1378 if (charbuf
>= charbuf_end
)
1380 if (byte_after_cr
>= 0)
1385 if (byte_after_cr
>= 0)
1386 c1
= byte_after_cr
, byte_after_cr
= -1;
1393 else if (UTF_8_1_OCTET_P(c1
))
1395 if (eol_crlf
&& c1
== '\r')
1396 ONE_MORE_BYTE (byte_after_cr
);
1402 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1404 if (UTF_8_2_OCTET_LEADING_P (c1
))
1406 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1407 /* Reject overlong sequences here and below. Encoders
1408 producing them are incorrect, they can be misleading,
1409 and they mess up read/write invariance. */
1416 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1418 if (UTF_8_3_OCTET_LEADING_P (c1
))
1420 c
= (((c1
& 0xF) << 12)
1421 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1423 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1429 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1431 if (UTF_8_4_OCTET_LEADING_P (c1
))
1433 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1434 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1441 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1443 if (UTF_8_5_OCTET_LEADING_P (c1
))
1445 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1446 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1448 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1463 consumed_chars
= consumed_chars_base
;
1465 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1470 coding
->consumed_char
+= consumed_chars_base
;
1471 coding
->consumed
= src_base
- coding
->source
;
1472 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1477 encode_coding_utf_8 (coding
)
1478 struct coding_system
*coding
;
1480 int multibytep
= coding
->dst_multibyte
;
1481 int *charbuf
= coding
->charbuf
;
1482 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1483 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1484 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1485 int produced_chars
= 0;
1488 if (CODING_UTF_8_BOM (coding
) == utf_with_bom
)
1490 ASSURE_DESTINATION (3);
1491 EMIT_THREE_BYTES (UTF_8_BOM_1
, UTF_8_BOM_2
, UTF_8_BOM_3
);
1492 CODING_UTF_8_BOM (coding
) = utf_without_bom
;
1497 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1499 while (charbuf
< charbuf_end
)
1501 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1503 ASSURE_DESTINATION (safe_room
);
1505 if (CHAR_BYTE8_P (c
))
1507 c
= CHAR_TO_BYTE8 (c
);
1512 CHAR_STRING_ADVANCE_NO_UNIFY (c
, pend
);
1513 for (p
= str
; p
< pend
; p
++)
1520 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1522 while (charbuf
< charbuf_end
)
1524 ASSURE_DESTINATION (safe_room
);
1526 if (CHAR_BYTE8_P (c
))
1527 *dst
++ = CHAR_TO_BYTE8 (c
);
1529 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
1533 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1534 coding
->produced_char
+= produced_chars
;
1535 coding
->produced
= dst
- coding
->destination
;
1540 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1541 Check if a text is encoded in one of UTF-16 based coding systems.
1542 If it is, return 1, else return 0. */
1544 #define UTF_16_HIGH_SURROGATE_P(val) \
1545 (((val) & 0xFC00) == 0xD800)
1547 #define UTF_16_LOW_SURROGATE_P(val) \
1548 (((val) & 0xFC00) == 0xDC00)
1550 #define UTF_16_INVALID_P(val) \
1551 (((val) == 0xFFFE) \
1552 || ((val) == 0xFFFF) \
1553 || UTF_16_LOW_SURROGATE_P (val))
1557 detect_coding_utf_16 (coding
, detect_info
)
1558 struct coding_system
*coding
;
1559 struct coding_detection_info
*detect_info
;
1561 const unsigned char *src
= coding
->source
, *src_base
= src
;
1562 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1563 int multibytep
= coding
->src_multibyte
;
1564 int consumed_chars
= 0;
1567 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1568 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1569 && (coding
->src_chars
& 1))
1571 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1577 if ((c1
== 0xFF) && (c2
== 0xFE))
1579 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1580 | CATEGORY_MASK_UTF_16_AUTO
);
1581 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1582 | CATEGORY_MASK_UTF_16_BE_NOSIG
1583 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1585 else if ((c1
== 0xFE) && (c2
== 0xFF))
1587 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1588 | CATEGORY_MASK_UTF_16_AUTO
);
1589 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1590 | CATEGORY_MASK_UTF_16_BE_NOSIG
1591 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1595 /* We check the dispersion of Eth and Oth bytes where E is even and
1596 O is odd. If both are high, we assume binary data.*/
1597 unsigned char e
[256], o
[256];
1598 unsigned e_num
= 1, o_num
= 1;
1605 detect_info
->rejected
1606 |= (CATEGORY_MASK_UTF_16_BE
| CATEGORY_MASK_UTF_16_LE
);
1627 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1636 decode_coding_utf_16 (coding
)
1637 struct coding_system
*coding
;
1639 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1640 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1641 const unsigned char *src_base
;
1642 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1643 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1644 int consumed_chars
= 0, consumed_chars_base
= 0;
1645 int multibytep
= coding
->src_multibyte
;
1646 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1647 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1648 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1649 Lisp_Object attr
, charset_list
;
1650 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
1651 int byte_after_cr1
= -1, byte_after_cr2
= -1;
1653 CODING_GET_INFO (coding
, attr
, charset_list
);
1655 if (bom
== utf_with_bom
)
1664 if (endian
== utf_16_big_endian
1665 ? c
!= 0xFEFF : c
!= 0xFFFE)
1667 /* The first two bytes are not BOM. Treat them as bytes
1668 for a normal character. */
1672 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1674 else if (bom
== utf_detect_bom
)
1676 /* We have already tried to detect BOM and failed in
1678 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1686 consumed_chars_base
= consumed_chars
;
1688 if (charbuf
+ 2 >= charbuf_end
)
1690 if (byte_after_cr1
>= 0)
1695 if (byte_after_cr1
>= 0)
1696 c1
= byte_after_cr1
, byte_after_cr1
= -1;
1704 if (byte_after_cr2
>= 0)
1705 c2
= byte_after_cr2
, byte_after_cr2
= -1;
1710 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1714 c
= (endian
== utf_16_big_endian
1715 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1719 if (! UTF_16_LOW_SURROGATE_P (c
))
1721 if (endian
== utf_16_big_endian
)
1722 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1724 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1728 if (UTF_16_HIGH_SURROGATE_P (c
))
1729 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1735 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1736 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1737 *charbuf
++ = 0x10000 + c
;
1742 if (UTF_16_HIGH_SURROGATE_P (c
))
1743 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1746 if (eol_crlf
&& c
== '\r')
1748 ONE_MORE_BYTE (byte_after_cr1
);
1749 ONE_MORE_BYTE (byte_after_cr2
);
1757 coding
->consumed_char
+= consumed_chars_base
;
1758 coding
->consumed
= src_base
- coding
->source
;
1759 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1763 encode_coding_utf_16 (coding
)
1764 struct coding_system
*coding
;
1766 int multibytep
= coding
->dst_multibyte
;
1767 int *charbuf
= coding
->charbuf
;
1768 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1769 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1770 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1772 enum utf_bom_type bom
= CODING_UTF_16_BOM (coding
);
1773 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1774 int produced_chars
= 0;
1775 Lisp_Object attrs
, charset_list
;
1778 CODING_GET_INFO (coding
, attrs
, charset_list
);
1780 if (bom
!= utf_without_bom
)
1782 ASSURE_DESTINATION (safe_room
);
1784 EMIT_TWO_BYTES (0xFE, 0xFF);
1786 EMIT_TWO_BYTES (0xFF, 0xFE);
1787 CODING_UTF_16_BOM (coding
) = utf_without_bom
;
1790 while (charbuf
< charbuf_end
)
1792 ASSURE_DESTINATION (safe_room
);
1794 if (c
>= MAX_UNICODE_CHAR
)
1795 c
= coding
->default_char
;
1800 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1802 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1809 c1
= (c
>> 10) + 0xD800;
1810 c2
= (c
& 0x3FF) + 0xDC00;
1812 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1814 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1817 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1818 coding
->produced
= dst
- coding
->destination
;
1819 coding
->produced_char
+= produced_chars
;
1824 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1826 /* Emacs' internal format for representation of multiple character
1827 sets is a kind of multi-byte encoding, i.e. characters are
1828 represented by variable-length sequences of one-byte codes.
1830 ASCII characters and control characters (e.g. `tab', `newline') are
1831 represented by one-byte sequences which are their ASCII codes, in
1832 the range 0x00 through 0x7F.
1834 8-bit characters of the range 0x80..0x9F are represented by
1835 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1838 8-bit characters of the range 0xA0..0xFF are represented by
1839 one-byte sequences which are their 8-bit code.
1841 The other characters are represented by a sequence of `base
1842 leading-code', optional `extended leading-code', and one or two
1843 `position-code's. The length of the sequence is determined by the
1844 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1845 whereas extended leading-code and position-code take the range 0xA0
1846 through 0xFF. See `charset.h' for more details about leading-code
1849 --- CODE RANGE of Emacs' internal format ---
1853 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1854 eight-bit-graphic 0xA0..0xBF
1855 ELSE 0x81..0x9D + [0xA0..0xFF]+
1856 ---------------------------------------------
1858 As this is the internal character representation, the format is
1859 usually not used externally (i.e. in a file or in a data sent to a
1860 process). But, it is possible to have a text externally in this
1861 format (i.e. by encoding by the coding system `emacs-mule').
1863 In that case, a sequence of one-byte codes has a slightly different
1866 At first, all characters in eight-bit-control are represented by
1867 one-byte sequences which are their 8-bit code.
1869 Next, character composition data are represented by the byte
1870 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1872 METHOD is 0xF0 plus one of composition method (enum
1873 composition_method),
1875 BYTES is 0xA0 plus a byte length of this composition data,
1877 CHARS is 0x20 plus a number of characters composed by this
1880 COMPONENTs are characters of multibye form or composition
1881 rules encoded by two-byte of ASCII codes.
1883 In addition, for backward compatibility, the following formats are
1884 also recognized as composition data on decoding.
1887 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1890 MSEQ is a multibyte form but in these special format:
1891 ASCII: 0xA0 ASCII_CODE+0x80,
1892 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1893 RULE is a one byte code of the range 0xA0..0xF0 that
1894 represents a composition rule.
1897 char emacs_mule_bytes
[256];
1900 emacs_mule_char (coding
, src
, nbytes
, nchars
, id
)
1901 struct coding_system
*coding
;
1902 const unsigned char *src
;
1903 int *nbytes
, *nchars
, *id
;
1905 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1906 const unsigned char *src_base
= src
;
1907 int multibytep
= coding
->src_multibyte
;
1908 struct charset
*charset
;
1911 int consumed_chars
= 0;
1917 charset
= emacs_mule_charset
[0];
1923 /* Old style component character of a composition. */
1933 switch (emacs_mule_bytes
[c
])
1936 if (! (charset
= emacs_mule_charset
[c
]))
1945 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1946 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1949 if (c
< 0xA0 || ! (charset
= emacs_mule_charset
[c
]))
1958 if (! (charset
= emacs_mule_charset
[c
]))
1963 code
= (c
& 0x7F) << 8;
1973 if (c
< 0 || ! (charset
= emacs_mule_charset
[c
]))
1978 code
= (c
& 0x7F) << 8;
1987 charset
= CHARSET_FROM_ID (ASCII_BYTE_P (code
)
1988 ? charset_ascii
: charset_eight_bit
);
1994 c
= DECODE_CHAR (charset
, code
);
1998 *nbytes
= src
- src_base
;
1999 *nchars
= consumed_chars
;
2012 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2013 Check if a text is encoded in `emacs-mule'. If it is, return 1,
2017 detect_coding_emacs_mule (coding
, detect_info
)
2018 struct coding_system
*coding
;
2019 struct coding_detection_info
*detect_info
;
2021 const unsigned char *src
= coding
->source
, *src_base
;
2022 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2023 int multibytep
= coding
->src_multibyte
;
2024 int consumed_chars
= 0;
2028 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
2029 /* A coding system of this category is always ASCII compatible. */
2030 src
+= coding
->head_ascii
;
2040 /* Perhaps the start of composite character. We simple skip
2041 it because analyzing it is too heavy for detecting. But,
2042 at least, we check that the composite character
2043 constitutes of more than 4 bytes. */
2044 const unsigned char *src_base
;
2054 if (src
- src_base
<= 4)
2056 found
= CATEGORY_MASK_EMACS_MULE
;
2064 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
2069 int more_bytes
= emacs_mule_bytes
[*src_base
] - 1;
2071 while (more_bytes
> 0)
2076 src
--; /* Unread the last byte. */
2081 if (more_bytes
!= 0)
2083 found
= CATEGORY_MASK_EMACS_MULE
;
2086 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
2090 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
2092 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
2095 detect_info
->found
|= found
;
2100 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2102 /* Decode a character represented as a component of composition
2103 sequence of Emacs 20/21 style at SRC. Set C to that character and
2104 update SRC to the head of next character (or an encoded composition
2105 rule). If SRC doesn't points a composition component, set C to -1.
2106 If SRC points an invalid byte sequence, global exit by a return
2109 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
2113 int nbytes, nchars; \
2115 if (src == src_end) \
2117 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
2122 goto invalid_code; \
2126 consumed_chars += nchars; \
2131 /* Decode a composition rule represented as a component of composition
2132 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
2133 and increment BUF. If SRC points an invalid byte sequence, set C
2136 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
2138 int c, gref, nref; \
2140 if (src >= src_end) \
2141 goto invalid_code; \
2142 ONE_MORE_BYTE_NO_CHECK (c); \
2144 if (c < 0 || c >= 81) \
2145 goto invalid_code; \
2147 gref = c / 9, nref = c % 9; \
2148 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
2152 /* Decode a composition rule represented as a component of composition
2153 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
2154 and increment BUF. If SRC points an invalid byte sequence, set C
2157 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
2161 if (src + 1>= src_end) \
2162 goto invalid_code; \
2163 ONE_MORE_BYTE_NO_CHECK (gref); \
2165 ONE_MORE_BYTE_NO_CHECK (nref); \
2167 if (gref < 0 || gref >= 81 \
2168 || nref < 0 || nref >= 81) \
2169 goto invalid_code; \
2170 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
2174 #define DECODE_EMACS_MULE_21_COMPOSITION(c) \
2176 /* Emacs 21 style format. The first three bytes at SRC are \
2177 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
2178 the byte length of this composition information, CHARS is the \
2179 number of characters composed by this composition. */ \
2180 enum composition_method method = c - 0xF2; \
2181 int *charbuf_base = charbuf; \
2182 int consumed_chars_limit; \
2183 int nbytes, nchars; \
2185 ONE_MORE_BYTE (c); \
2187 goto invalid_code; \
2188 nbytes = c - 0xA0; \
2190 goto invalid_code; \
2191 ONE_MORE_BYTE (c); \
2193 goto invalid_code; \
2194 nchars = c - 0xA0; \
2195 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
2196 consumed_chars_limit = consumed_chars_base + nbytes; \
2197 if (method != COMPOSITION_RELATIVE) \
2200 while (consumed_chars < consumed_chars_limit) \
2202 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
2203 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
2205 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
2208 if (consumed_chars < consumed_chars_limit) \
2209 goto invalid_code; \
2210 charbuf_base[0] -= i; \
2215 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
2217 /* Emacs 20 style format for relative composition. */ \
2218 /* Store multibyte form of characters to be composed. */ \
2219 enum composition_method method = COMPOSITION_RELATIVE; \
2220 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2221 int *buf = components; \
2225 ONE_MORE_BYTE (c); /* skip 0x80 */ \
2226 for (i = 0; *src >= 0xA0 && i < MAX_COMPOSITION_COMPONENTS; i++) \
2227 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2229 goto invalid_code; \
2230 ADD_COMPOSITION_DATA (charbuf, i, method); \
2231 for (j = 0; j < i; j++) \
2232 *charbuf++ = components[j]; \
2236 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
2238 /* Emacs 20 style format for rule-base composition. */ \
2239 /* Store multibyte form of characters to be composed. */ \
2240 enum composition_method method = COMPOSITION_WITH_RULE; \
2241 int *charbuf_base = charbuf; \
2242 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2243 int *buf = components; \
2246 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2247 for (i = 1; i < MAX_COMPOSITION_COMPONENTS; i++) \
2251 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
2252 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2254 if (i <= 1 || (buf - components) % 2 == 0) \
2255 goto invalid_code; \
2256 if (charbuf + i + (i / 2) + 1 >= charbuf_end) \
2257 goto no_more_source; \
2258 ADD_COMPOSITION_DATA (charbuf, i, method); \
2260 for (j = 0; j < i; j++) \
2261 *charbuf++ = components[j]; \
2262 charbuf_base[0] -= i; \
2263 for (j = 0; j < i; j += 2) \
2264 *charbuf++ = components[j]; \
2269 decode_coding_emacs_mule (coding
)
2270 struct coding_system
*coding
;
2272 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2273 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2274 const unsigned char *src_base
;
2275 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2277 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
2278 int consumed_chars
= 0, consumed_chars_base
;
2279 int multibytep
= coding
->src_multibyte
;
2280 Lisp_Object attrs
, charset_list
;
2281 int char_offset
= coding
->produced_char
;
2282 int last_offset
= char_offset
;
2283 int last_id
= charset_ascii
;
2284 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
2285 int byte_after_cr
= -1;
2287 CODING_GET_INFO (coding
, attrs
, charset_list
);
2294 consumed_chars_base
= consumed_chars
;
2296 if (charbuf
>= charbuf_end
)
2298 if (byte_after_cr
>= 0)
2303 if (byte_after_cr
>= 0)
2304 c
= byte_after_cr
, byte_after_cr
= -1;
2314 if (eol_crlf
&& c
== '\r')
2315 ONE_MORE_BYTE (byte_after_cr
);
2324 if (c
- 0xF2 >= COMPOSITION_RELATIVE
2325 && c
- 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS
)
2326 DECODE_EMACS_MULE_21_COMPOSITION (c
);
2328 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c
);
2330 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c
);
2334 else if (c
< 0xA0 && emacs_mule_bytes
[c
] > 1)
2340 consumed_chars
= consumed_chars_base
;
2341 c
= emacs_mule_char (coding
, src
, &nbytes
, &nchars
, &id
);
2350 if (last_id
!= charset_ascii
)
2351 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2353 last_offset
= char_offset
;
2357 consumed_chars
+= nchars
;
2366 consumed_chars
= consumed_chars_base
;
2368 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2374 if (last_id
!= charset_ascii
)
2375 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2376 coding
->consumed_char
+= consumed_chars_base
;
2377 coding
->consumed
= src_base
- coding
->source
;
2378 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2382 #define EMACS_MULE_LEADING_CODES(id, codes) \
2385 codes[0] = id, codes[1] = 0; \
2386 else if (id < 0xE0) \
2387 codes[0] = 0x9A, codes[1] = id; \
2388 else if (id < 0xF0) \
2389 codes[0] = 0x9B, codes[1] = id; \
2390 else if (id < 0xF5) \
2391 codes[0] = 0x9C, codes[1] = id; \
2393 codes[0] = 0x9D, codes[1] = id; \
2398 encode_coding_emacs_mule (coding
)
2399 struct coding_system
*coding
;
2401 int multibytep
= coding
->dst_multibyte
;
2402 int *charbuf
= coding
->charbuf
;
2403 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2404 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2405 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2407 int produced_chars
= 0;
2408 Lisp_Object attrs
, charset_list
;
2410 int preferred_charset_id
= -1;
2412 CODING_GET_INFO (coding
, attrs
, charset_list
);
2413 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2415 CODING_ATTR_CHARSET_LIST (attrs
)
2416 = charset_list
= Vemacs_mule_charset_list
;
2419 while (charbuf
< charbuf_end
)
2421 ASSURE_DESTINATION (safe_room
);
2426 /* Handle an annotation. */
2429 case CODING_ANNOTATE_COMPOSITION_MASK
:
2430 /* Not yet implemented. */
2432 case CODING_ANNOTATE_CHARSET_MASK
:
2433 preferred_charset_id
= charbuf
[3];
2434 if (preferred_charset_id
>= 0
2435 && NILP (Fmemq (make_number (preferred_charset_id
),
2437 preferred_charset_id
= -1;
2446 if (ASCII_CHAR_P (c
))
2447 EMIT_ONE_ASCII_BYTE (c
);
2448 else if (CHAR_BYTE8_P (c
))
2450 c
= CHAR_TO_BYTE8 (c
);
2455 struct charset
*charset
;
2459 unsigned char leading_codes
[2];
2461 if (preferred_charset_id
>= 0)
2463 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2464 if (CHAR_CHARSET_P (c
, charset
))
2465 code
= ENCODE_CHAR (charset
, c
);
2467 charset
= char_charset (c
, charset_list
, &code
);
2470 charset
= char_charset (c
, charset_list
, &code
);
2473 c
= coding
->default_char
;
2474 if (ASCII_CHAR_P (c
))
2476 EMIT_ONE_ASCII_BYTE (c
);
2479 charset
= char_charset (c
, charset_list
, &code
);
2481 dimension
= CHARSET_DIMENSION (charset
);
2482 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2483 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2484 EMIT_ONE_BYTE (leading_codes
[0]);
2485 if (leading_codes
[1])
2486 EMIT_ONE_BYTE (leading_codes
[1]);
2488 EMIT_ONE_BYTE (code
| 0x80);
2492 EMIT_ONE_BYTE (code
>> 8);
2493 EMIT_ONE_BYTE (code
& 0xFF);
2497 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2498 coding
->produced_char
+= produced_chars
;
2499 coding
->produced
= dst
- coding
->destination
;
2504 /*** 7. ISO2022 handlers ***/
2506 /* The following note describes the coding system ISO2022 briefly.
2507 Since the intention of this note is to help understand the
2508 functions in this file, some parts are NOT ACCURATE or are OVERLY
2509 SIMPLIFIED. For thorough understanding, please refer to the
2510 original document of ISO2022. This is equivalent to the standard
2511 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2513 ISO2022 provides many mechanisms to encode several character sets
2514 in 7-bit and 8-bit environments. For 7-bit environments, all text
2515 is encoded using bytes less than 128. This may make the encoded
2516 text a little bit longer, but the text passes more easily through
2517 several types of gateway, some of which strip off the MSB (Most
2520 There are two kinds of character sets: control character sets and
2521 graphic character sets. The former contain control characters such
2522 as `newline' and `escape' to provide control functions (control
2523 functions are also provided by escape sequences). The latter
2524 contain graphic characters such as 'A' and '-'. Emacs recognizes
2525 two control character sets and many graphic character sets.
2527 Graphic character sets are classified into one of the following
2528 four classes, according to the number of bytes (DIMENSION) and
2529 number of characters in one dimension (CHARS) of the set:
2530 - DIMENSION1_CHARS94
2531 - DIMENSION1_CHARS96
2532 - DIMENSION2_CHARS94
2533 - DIMENSION2_CHARS96
2535 In addition, each character set is assigned an identification tag,
2536 unique for each set, called the "final character" (denoted as <F>
2537 hereafter). The <F> of each character set is decided by ECMA(*)
2538 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2539 (0x30..0x3F are for private use only).
2541 Note (*): ECMA = European Computer Manufacturers Association
2543 Here are examples of graphic character sets [NAME(<F>)]:
2544 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2545 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2546 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2547 o DIMENSION2_CHARS96 -- none for the moment
2549 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2550 C0 [0x00..0x1F] -- control character plane 0
2551 GL [0x20..0x7F] -- graphic character plane 0
2552 C1 [0x80..0x9F] -- control character plane 1
2553 GR [0xA0..0xFF] -- graphic character plane 1
2555 A control character set is directly designated and invoked to C0 or
2556 C1 by an escape sequence. The most common case is that:
2557 - ISO646's control character set is designated/invoked to C0, and
2558 - ISO6429's control character set is designated/invoked to C1,
2559 and usually these designations/invocations are omitted in encoded
2560 text. In a 7-bit environment, only C0 can be used, and a control
2561 character for C1 is encoded by an appropriate escape sequence to
2562 fit into the environment. All control characters for C1 are
2563 defined to have corresponding escape sequences.
2565 A graphic character set is at first designated to one of four
2566 graphic registers (G0 through G3), then these graphic registers are
2567 invoked to GL or GR. These designations and invocations can be
2568 done independently. The most common case is that G0 is invoked to
2569 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2570 these invocations and designations are omitted in encoded text.
2571 In a 7-bit environment, only GL can be used.
2573 When a graphic character set of CHARS94 is invoked to GL, codes
2574 0x20 and 0x7F of the GL area work as control characters SPACE and
2575 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2578 There are two ways of invocation: locking-shift and single-shift.
2579 With locking-shift, the invocation lasts until the next different
2580 invocation, whereas with single-shift, the invocation affects the
2581 following character only and doesn't affect the locking-shift
2582 state. Invocations are done by the following control characters or
2585 ----------------------------------------------------------------------
2586 abbrev function cntrl escape seq description
2587 ----------------------------------------------------------------------
2588 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2589 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2590 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2591 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2592 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2593 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2594 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2595 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2596 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2597 ----------------------------------------------------------------------
2598 (*) These are not used by any known coding system.
2600 Control characters for these functions are defined by macros
2601 ISO_CODE_XXX in `coding.h'.
2603 Designations are done by the following escape sequences:
2604 ----------------------------------------------------------------------
2605 escape sequence description
2606 ----------------------------------------------------------------------
2607 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2608 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2609 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2610 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2611 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2612 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2613 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2614 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2615 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2616 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2617 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2618 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2619 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2620 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2621 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2622 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2623 ----------------------------------------------------------------------
2625 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2626 of dimension 1, chars 94, and final character <F>, etc...
2628 Note (*): Although these designations are not allowed in ISO2022,
2629 Emacs accepts them on decoding, and produces them on encoding
2630 CHARS96 character sets in a coding system which is characterized as
2631 7-bit environment, non-locking-shift, and non-single-shift.
2633 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2634 '(' must be omitted. We refer to this as "short-form" hereafter.
2636 Now you may notice that there are a lot of ways of encoding the
2637 same multilingual text in ISO2022. Actually, there exist many
2638 coding systems such as Compound Text (used in X11's inter client
2639 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2640 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2641 localized platforms), and all of these are variants of ISO2022.
2643 In addition to the above, Emacs handles two more kinds of escape
2644 sequences: ISO6429's direction specification and Emacs' private
2645 sequence for specifying character composition.
2647 ISO6429's direction specification takes the following form:
2648 o CSI ']' -- end of the current direction
2649 o CSI '0' ']' -- end of the current direction
2650 o CSI '1' ']' -- start of left-to-right text
2651 o CSI '2' ']' -- start of right-to-left text
2652 The control character CSI (0x9B: control sequence introducer) is
2653 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2655 Character composition specification takes the following form:
2656 o ESC '0' -- start relative composition
2657 o ESC '1' -- end composition
2658 o ESC '2' -- start rule-base composition (*)
2659 o ESC '3' -- start relative composition with alternate chars (**)
2660 o ESC '4' -- start rule-base composition with alternate chars (**)
2661 Since these are not standard escape sequences of any ISO standard,
2662 the use of them with these meanings is restricted to Emacs only.
2664 (*) This form is used only in Emacs 20.7 and older versions,
2665 but newer versions can safely decode it.
2666 (**) This form is used only in Emacs 21.1 and newer versions,
2667 and older versions can't decode it.
2669 Here's a list of example usages of these composition escape
2670 sequences (categorized by `enum composition_method').
2672 COMPOSITION_RELATIVE:
2673 ESC 0 CHAR [ CHAR ] ESC 1
2674 COMPOSITION_WITH_RULE:
2675 ESC 2 CHAR [ RULE CHAR ] ESC 1
2676 COMPOSITION_WITH_ALTCHARS:
2677 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2678 COMPOSITION_WITH_RULE_ALTCHARS:
2679 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2681 enum iso_code_class_type iso_code_class
[256];
2683 #define SAFE_CHARSET_P(coding, id) \
2684 ((id) <= (coding)->max_charset_id \
2685 && (coding)->safe_charsets[id] >= 0)
2688 #define SHIFT_OUT_OK(category) \
2689 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2692 setup_iso_safe_charsets (attrs
)
2695 Lisp_Object charset_list
, safe_charsets
;
2696 Lisp_Object request
;
2697 Lisp_Object reg_usage
;
2700 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2703 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2704 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2705 && ! EQ (charset_list
, Viso_2022_charset_list
))
2707 CODING_ATTR_CHARSET_LIST (attrs
)
2708 = charset_list
= Viso_2022_charset_list
;
2709 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2712 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2716 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2718 int id
= XINT (XCAR (tail
));
2719 if (max_charset_id
< id
)
2720 max_charset_id
= id
;
2723 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
2725 request
= AREF (attrs
, coding_attr_iso_request
);
2726 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2727 reg94
= XINT (XCAR (reg_usage
));
2728 reg96
= XINT (XCDR (reg_usage
));
2730 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2734 struct charset
*charset
;
2737 charset
= CHARSET_FROM_ID (XINT (id
));
2738 reg
= Fcdr (Fassq (id
, request
));
2740 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2741 else if (charset
->iso_chars_96
)
2744 SSET (safe_charsets
, XINT (id
), reg96
);
2749 SSET (safe_charsets
, XINT (id
), reg94
);
2752 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2756 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2757 Check if a text is encoded in one of ISO-2022 based codig systems.
2758 If it is, return 1, else return 0. */
2761 detect_coding_iso_2022 (coding
, detect_info
)
2762 struct coding_system
*coding
;
2763 struct coding_detection_info
*detect_info
;
2765 const unsigned char *src
= coding
->source
, *src_base
= src
;
2766 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2767 int multibytep
= coding
->src_multibyte
;
2768 int single_shifting
= 0;
2771 int consumed_chars
= 0;
2775 int composition_count
= -1;
2777 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2779 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2781 struct coding_system
*this = &(coding_categories
[i
]);
2782 Lisp_Object attrs
, val
;
2786 attrs
= CODING_ID_ATTRS (this->id
);
2787 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2788 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs
), Viso_2022_charset_list
))
2789 setup_iso_safe_charsets (attrs
);
2790 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2791 this->max_charset_id
= SCHARS (val
) - 1;
2792 this->safe_charsets
= (char *) SDATA (val
);
2795 /* A coding system of this category is always ASCII compatible. */
2796 src
+= coding
->head_ascii
;
2798 while (rejected
!= CATEGORY_MASK_ISO
)
2805 if (inhibit_iso_escape_detection
)
2807 single_shifting
= 0;
2809 if (c
>= '(' && c
<= '/')
2811 /* Designation sequence for a charset of dimension 1. */
2813 if (c1
< ' ' || c1
>= 0x80
2814 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2815 /* Invalid designation sequence. Just ignore. */
2820 /* Designation sequence for a charset of dimension 2. */
2822 if (c
>= '@' && c
<= 'B')
2823 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2824 id
= iso_charset_table
[1][0][c
];
2825 else if (c
>= '(' && c
<= '/')
2828 if (c1
< ' ' || c1
>= 0x80
2829 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2830 /* Invalid designation sequence. Just ignore. */
2834 /* Invalid designation sequence. Just ignore it. */
2837 else if (c
== 'N' || c
== 'O')
2839 /* ESC <Fe> for SS2 or SS3. */
2840 single_shifting
= 1;
2841 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2846 /* End of composition. */
2847 if (composition_count
< 0
2848 || composition_count
> MAX_COMPOSITION_COMPONENTS
)
2851 composition_count
= -1;
2852 found
|= CATEGORY_MASK_ISO
;
2854 else if (c
>= '0' && c
<= '4')
2856 /* ESC <Fp> for start/end composition. */
2857 composition_count
= 0;
2862 /* Invalid escape sequence. Just ignore it. */
2866 /* We found a valid designation sequence for CHARSET. */
2867 rejected
|= CATEGORY_MASK_ISO_8BIT
;
2868 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
2870 found
|= CATEGORY_MASK_ISO_7
;
2872 rejected
|= CATEGORY_MASK_ISO_7
;
2873 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
2875 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
2877 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
2878 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
2880 found
|= CATEGORY_MASK_ISO_7_ELSE
;
2882 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
2883 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
2885 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2887 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
2892 /* Locking shift out/in. */
2893 if (inhibit_iso_escape_detection
)
2895 single_shifting
= 0;
2896 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2900 /* Control sequence introducer. */
2901 single_shifting
= 0;
2902 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2903 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2904 goto check_extra_latin
;
2909 if (inhibit_iso_escape_detection
)
2911 single_shifting
= 0;
2912 rejected
|= CATEGORY_MASK_ISO_7BIT
;
2913 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2914 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2915 found
|= CATEGORY_MASK_ISO_8_1
, single_shifting
= 1;
2916 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
2917 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2918 found
|= CATEGORY_MASK_ISO_8_2
, single_shifting
= 1;
2919 if (single_shifting
)
2921 goto check_extra_latin
;
2928 if (composition_count
>= 0)
2929 composition_count
++;
2930 single_shifting
= 0;
2935 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2936 found
|= CATEGORY_MASK_ISO_8_1
;
2937 /* Check the length of succeeding codes of the range
2938 0xA0..0FF. If the byte length is even, we include
2939 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2940 only when we are not single shifting. */
2941 if (! single_shifting
2942 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
2945 while (src
< src_end
)
2953 if (i
& 1 && src
< src_end
)
2955 rejected
|= CATEGORY_MASK_ISO_8_2
;
2956 if (composition_count
>= 0)
2957 composition_count
+= i
;
2961 found
|= CATEGORY_MASK_ISO_8_2
;
2962 if (composition_count
>= 0)
2963 composition_count
+= i
/ 2;
2969 single_shifting
= 0;
2970 if (! VECTORP (Vlatin_extra_code_table
)
2971 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
2973 rejected
= CATEGORY_MASK_ISO
;
2976 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2977 & CODING_ISO_FLAG_LATIN_EXTRA
)
2978 found
|= CATEGORY_MASK_ISO_8_1
;
2980 rejected
|= CATEGORY_MASK_ISO_8_1
;
2981 rejected
|= CATEGORY_MASK_ISO_8_2
;
2984 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
2988 detect_info
->rejected
|= rejected
;
2989 detect_info
->found
|= (found
& ~rejected
);
2994 /* Set designation state into CODING. Set CHARS_96 to -1 if the
2995 escape sequence should be kept. */
2996 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
3000 if (final < '0' || final >= 128 \
3001 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
3002 || !SAFE_CHARSET_P (coding, id)) \
3004 CODING_ISO_DESIGNATION (coding, reg) = -2; \
3008 prev = CODING_ISO_DESIGNATION (coding, reg); \
3009 if (id == charset_jisx0201_roman) \
3011 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3012 id = charset_ascii; \
3014 else if (id == charset_jisx0208_1978) \
3016 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3017 id = charset_jisx0208; \
3019 CODING_ISO_DESIGNATION (coding, reg) = id; \
3020 /* If there was an invalid designation to REG previously, and this \
3021 designation is ASCII to REG, we should keep this designation \
3023 if (prev == -2 && id == charset_ascii) \
3028 #define MAYBE_FINISH_COMPOSITION() \
3031 if (composition_state == COMPOSING_NO) \
3033 /* It is assured that we have enough room for producing \
3034 characters stored in the table `components'. */ \
3035 if (charbuf + component_idx > charbuf_end) \
3036 goto no_more_source; \
3037 composition_state = COMPOSING_NO; \
3038 if (method == COMPOSITION_RELATIVE \
3039 || method == COMPOSITION_WITH_ALTCHARS) \
3041 for (i = 0; i < component_idx; i++) \
3042 *charbuf++ = components[i]; \
3043 char_offset += component_idx; \
3047 for (i = 0; i < component_idx; i += 2) \
3048 *charbuf++ = components[i]; \
3049 char_offset += (component_idx / 2) + 1; \
3054 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
3055 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
3056 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
3057 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
3058 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
3061 #define DECODE_COMPOSITION_START(c1) \
3064 && composition_state == COMPOSING_COMPONENT_RULE) \
3066 component_len = component_idx; \
3067 composition_state = COMPOSING_CHAR; \
3071 const unsigned char *p; \
3073 MAYBE_FINISH_COMPOSITION (); \
3074 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
3075 goto no_more_source; \
3076 for (p = src; p < src_end - 1; p++) \
3077 if (*p == ISO_CODE_ESC && p[1] == '1') \
3079 if (p == src_end - 1) \
3081 if (coding->mode & CODING_MODE_LAST_BLOCK) \
3082 goto invalid_code; \
3083 /* The current composition doesn't end in the current \
3085 record_conversion_result \
3086 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
3087 goto no_more_source; \
3090 /* This is surely the start of a composition. */ \
3091 method = (c1 == '0' ? COMPOSITION_RELATIVE \
3092 : c1 == '2' ? COMPOSITION_WITH_RULE \
3093 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
3094 : COMPOSITION_WITH_RULE_ALTCHARS); \
3095 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
3096 : COMPOSING_COMPONENT_CHAR); \
3097 component_idx = component_len = 0; \
3102 /* Handle compositoin end sequence ESC 1. */
3104 #define DECODE_COMPOSITION_END() \
3106 int nchars = (component_len > 0 ? component_idx - component_len \
3107 : method == COMPOSITION_RELATIVE ? component_idx \
3108 : (component_idx + 1) / 2); \
3110 int *saved_charbuf = charbuf; \
3112 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
3113 if (method != COMPOSITION_RELATIVE) \
3115 if (component_len == 0) \
3116 for (i = 0; i < component_idx; i++) \
3117 *charbuf++ = components[i]; \
3119 for (i = 0; i < component_len; i++) \
3120 *charbuf++ = components[i]; \
3121 *saved_charbuf = saved_charbuf - charbuf; \
3123 if (method == COMPOSITION_WITH_RULE) \
3124 for (i = 0; i < component_idx; i += 2, char_offset++) \
3125 *charbuf++ = components[i]; \
3127 for (i = component_len; i < component_idx; i++, char_offset++) \
3128 *charbuf++ = components[i]; \
3129 coding->annotated = 1; \
3130 composition_state = COMPOSING_NO; \
3134 /* Decode a composition rule from the byte C1 (and maybe one more byte
3135 from SRC) and store one encoded composition rule in
3136 coding->cmp_data. */
3138 #define DECODE_COMPOSITION_RULE(c1) \
3141 if (c1 < 81) /* old format (before ver.21) */ \
3143 int gref = (c1) / 9; \
3144 int nref = (c1) % 9; \
3145 if (gref == 4) gref = 10; \
3146 if (nref == 4) nref = 10; \
3147 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
3149 else if (c1 < 93) /* new format (after ver.21) */ \
3151 ONE_MORE_BYTE (c2); \
3152 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
3159 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
3162 decode_coding_iso_2022 (coding
)
3163 struct coding_system
*coding
;
3165 const unsigned char *src
= coding
->source
+ coding
->consumed
;
3166 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3167 const unsigned char *src_base
;
3168 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
3170 = coding
->charbuf
+ coding
->charbuf_size
- 4 - MAX_ANNOTATION_LENGTH
;
3171 int consumed_chars
= 0, consumed_chars_base
;
3172 int multibytep
= coding
->src_multibyte
;
3173 /* Charsets invoked to graphic plane 0 and 1 respectively. */
3174 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3175 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3176 int charset_id_2
, charset_id_3
;
3177 struct charset
*charset
;
3179 /* For handling composition sequence. */
3180 #define COMPOSING_NO 0
3181 #define COMPOSING_CHAR 1
3182 #define COMPOSING_RULE 2
3183 #define COMPOSING_COMPONENT_CHAR 3
3184 #define COMPOSING_COMPONENT_RULE 4
3186 int composition_state
= COMPOSING_NO
;
3187 enum composition_method method
;
3188 int components
[MAX_COMPOSITION_COMPONENTS
* 2 + 1];
3191 Lisp_Object attrs
, charset_list
;
3192 int char_offset
= coding
->produced_char
;
3193 int last_offset
= char_offset
;
3194 int last_id
= charset_ascii
;
3195 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
3196 int byte_after_cr
= -1;
3198 CODING_GET_INFO (coding
, attrs
, charset_list
);
3199 setup_iso_safe_charsets (attrs
);
3200 /* Charset list may have been changed. */
3201 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3202 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
3209 consumed_chars_base
= consumed_chars
;
3211 if (charbuf
>= charbuf_end
)
3213 if (byte_after_cr
>= 0)
3218 if (byte_after_cr
>= 0)
3219 c1
= byte_after_cr
, byte_after_cr
= -1;
3225 /* We produce at most one character. */
3226 switch (iso_code_class
[c1
])
3228 case ISO_0x20_or_0x7F
:
3229 if (composition_state
!= COMPOSING_NO
)
3231 if (composition_state
== COMPOSING_RULE
3232 || composition_state
== COMPOSING_COMPONENT_RULE
)
3234 if (component_idx
< MAX_COMPOSITION_COMPONENTS
* 2 + 1)
3236 DECODE_COMPOSITION_RULE (c1
);
3237 components
[component_idx
++] = c1
;
3238 composition_state
--;
3241 /* Too long composition. */
3242 MAYBE_FINISH_COMPOSITION ();
3245 if (charset_id_0
< 0
3246 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
3247 /* This is SPACE or DEL. */
3248 charset
= CHARSET_FROM_ID (charset_ascii
);
3250 charset
= CHARSET_FROM_ID (charset_id_0
);
3253 case ISO_graphic_plane_0
:
3254 if (composition_state
!= COMPOSING_NO
)
3256 if (composition_state
== COMPOSING_RULE
3257 || composition_state
== COMPOSING_COMPONENT_RULE
)
3259 if (component_idx
< MAX_COMPOSITION_COMPONENTS
* 2 + 1)
3261 DECODE_COMPOSITION_RULE (c1
);
3262 components
[component_idx
++] = c1
;
3263 composition_state
--;
3266 MAYBE_FINISH_COMPOSITION ();
3269 if (charset_id_0
< 0)
3270 charset
= CHARSET_FROM_ID (charset_ascii
);
3272 charset
= CHARSET_FROM_ID (charset_id_0
);
3275 case ISO_0xA0_or_0xFF
:
3276 if (charset_id_1
< 0
3277 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
3278 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
3280 /* This is a graphic character, we fall down ... */
3282 case ISO_graphic_plane_1
:
3283 if (charset_id_1
< 0)
3285 charset
= CHARSET_FROM_ID (charset_id_1
);
3289 if (eol_crlf
&& c1
== '\r')
3290 ONE_MORE_BYTE (byte_after_cr
);
3291 MAYBE_FINISH_COMPOSITION ();
3292 charset
= CHARSET_FROM_ID (charset_ascii
);
3296 MAYBE_FINISH_COMPOSITION ();
3300 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3301 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3303 CODING_ISO_INVOCATION (coding
, 0) = 1;
3304 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3308 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3310 CODING_ISO_INVOCATION (coding
, 0) = 0;
3311 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3314 case ISO_single_shift_2_7
:
3315 case ISO_single_shift_2
:
3316 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3318 /* SS2 is handled as an escape sequence of ESC 'N' */
3320 goto label_escape_sequence
;
3322 case ISO_single_shift_3
:
3323 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3325 /* SS2 is handled as an escape sequence of ESC 'O' */
3327 goto label_escape_sequence
;
3329 case ISO_control_sequence_introducer
:
3330 /* CSI is handled as an escape sequence of ESC '[' ... */
3332 goto label_escape_sequence
;
3336 label_escape_sequence
:
3337 /* Escape sequences handled here are invocation,
3338 designation, direction specification, and character
3339 composition specification. */
3342 case '&': /* revision of following character set */
3344 if (!(c1
>= '@' && c1
<= '~'))
3347 if (c1
!= ISO_CODE_ESC
)
3350 goto label_escape_sequence
;
3352 case '$': /* designation of 2-byte character set */
3353 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3359 if (c1
>= '@' && c1
<= 'B')
3360 { /* designation of JISX0208.1978, GB2312.1980,
3362 reg
= 0, chars96
= 0;
3364 else if (c1
>= 0x28 && c1
<= 0x2B)
3365 { /* designation of DIMENSION2_CHARS94 character set */
3366 reg
= c1
- 0x28, chars96
= 0;
3369 else if (c1
>= 0x2C && c1
<= 0x2F)
3370 { /* designation of DIMENSION2_CHARS96 character set */
3371 reg
= c1
- 0x2C, chars96
= 1;
3376 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3377 /* We must update these variables now. */
3379 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3381 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3387 case 'n': /* invocation of locking-shift-2 */
3388 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3389 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3391 CODING_ISO_INVOCATION (coding
, 0) = 2;
3392 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3395 case 'o': /* invocation of locking-shift-3 */
3396 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3397 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3399 CODING_ISO_INVOCATION (coding
, 0) = 3;
3400 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3403 case 'N': /* invocation of single-shift-2 */
3404 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3405 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3407 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3408 if (charset_id_2
< 0)
3409 charset
= CHARSET_FROM_ID (charset_ascii
);
3411 charset
= CHARSET_FROM_ID (charset_id_2
);
3413 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3417 case 'O': /* invocation of single-shift-3 */
3418 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3419 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3421 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3422 if (charset_id_3
< 0)
3423 charset
= CHARSET_FROM_ID (charset_ascii
);
3425 charset
= CHARSET_FROM_ID (charset_id_3
);
3427 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3431 case '0': case '2': case '3': case '4': /* start composition */
3432 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3434 DECODE_COMPOSITION_START (c1
);
3437 case '1': /* end composition */
3438 if (composition_state
== COMPOSING_NO
)
3440 DECODE_COMPOSITION_END ();
3443 case '[': /* specification of direction */
3444 if (! CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
)
3446 /* For the moment, nested direction is not supported.
3447 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3448 left-to-right, and nozero means right-to-left. */
3452 case ']': /* end of the current direction */
3453 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3455 case '0': /* end of the current direction */
3456 case '1': /* start of left-to-right direction */
3459 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3464 case '2': /* start of right-to-left direction */
3467 coding
->mode
|= CODING_MODE_DIRECTION
;
3481 /* CTEXT extended segment:
3482 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3483 We keep these bytes as is for the moment.
3484 They may be decoded by post-read-conversion. */
3488 ONE_MORE_BYTE (dim
);
3491 size
= ((M
- 128) * 128) + (L
- 128);
3492 if (charbuf
+ 8 + size
> charbuf_end
)
3494 *charbuf
++ = ISO_CODE_ESC
;
3498 *charbuf
++ = BYTE8_TO_CHAR (M
);
3499 *charbuf
++ = BYTE8_TO_CHAR (L
);
3503 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3508 /* XFree86 extension for embedding UTF-8 in CTEXT:
3509 ESC % G --UTF-8-BYTES-- ESC % @
3510 We keep these bytes as is for the moment.
3511 They may be decoded by post-read-conversion. */
3514 if (p
+ 6 > charbuf_end
)
3516 *p
++ = ISO_CODE_ESC
;
3519 while (p
< charbuf_end
)
3522 if (c1
== ISO_CODE_ESC
3523 && src
+ 1 < src_end
3530 *p
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3532 if (p
+ 3 > charbuf_end
)
3534 *p
++ = ISO_CODE_ESC
;
3545 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3550 if (c1
>= 0x28 && c1
<= 0x2B)
3551 { /* designation of DIMENSION1_CHARS94 character set */
3552 reg
= c1
- 0x28, chars96
= 0;
3555 else if (c1
>= 0x2C && c1
<= 0x2F)
3556 { /* designation of DIMENSION1_CHARS96 character set */
3557 reg
= c1
- 0x2C, chars96
= 1;
3562 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3563 /* We must update these variables now. */
3565 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3567 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3575 if (charset
->id
!= charset_ascii
3576 && last_id
!= charset
->id
)
3578 if (last_id
!= charset_ascii
)
3579 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3580 last_id
= charset
->id
;
3581 last_offset
= char_offset
;
3584 /* Now we know CHARSET and 1st position code C1 of a character.
3585 Produce a decoded character while getting 2nd position code
3588 if (CHARSET_DIMENSION (charset
) > 1)
3591 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3592 /* C2 is not in a valid range. */
3594 c1
= (c1
<< 8) | (c2
& 0x7F);
3595 if (CHARSET_DIMENSION (charset
) > 2)
3598 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3599 /* C2 is not in a valid range. */
3601 c1
= (c1
<< 8) | (c2
& 0x7F);
3605 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3608 MAYBE_FINISH_COMPOSITION ();
3609 for (; src_base
< src
; src_base
++, char_offset
++)
3611 if (ASCII_BYTE_P (*src_base
))
3612 *charbuf
++ = *src_base
;
3614 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3617 else if (composition_state
== COMPOSING_NO
)
3624 if (component_idx
< MAX_COMPOSITION_COMPONENTS
* 2 + 1)
3626 components
[component_idx
++] = c
;
3627 if (method
== COMPOSITION_WITH_RULE
3628 || (method
== COMPOSITION_WITH_RULE_ALTCHARS
3629 && composition_state
== COMPOSING_COMPONENT_CHAR
))
3630 composition_state
++;
3634 MAYBE_FINISH_COMPOSITION ();
3642 MAYBE_FINISH_COMPOSITION ();
3644 consumed_chars
= consumed_chars_base
;
3646 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3656 if (last_id
!= charset_ascii
)
3657 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3658 coding
->consumed_char
+= consumed_chars_base
;
3659 coding
->consumed
= src_base
- coding
->source
;
3660 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3664 /* ISO2022 encoding stuff. */
3667 It is not enough to say just "ISO2022" on encoding, we have to
3668 specify more details. In Emacs, each coding system of ISO2022
3669 variant has the following specifications:
3670 1. Initial designation to G0 thru G3.
3671 2. Allows short-form designation?
3672 3. ASCII should be designated to G0 before control characters?
3673 4. ASCII should be designated to G0 at end of line?
3674 5. 7-bit environment or 8-bit environment?
3675 6. Use locking-shift?
3676 7. Use Single-shift?
3677 And the following two are only for Japanese:
3678 8. Use ASCII in place of JIS0201-1976-Roman?
3679 9. Use JISX0208-1983 in place of JISX0208-1978?
3680 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3681 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3685 /* Produce codes (escape sequence) for designating CHARSET to graphic
3686 register REG at DST, and increment DST. If <final-char> of CHARSET is
3687 '@', 'A', or 'B' and the coding system CODING allows, produce
3688 designation sequence of short-form. */
3690 #define ENCODE_DESIGNATION(charset, reg, coding) \
3692 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3693 char *intermediate_char_94 = "()*+"; \
3694 char *intermediate_char_96 = ",-./"; \
3695 int revision = -1; \
3698 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3699 revision = CHARSET_ISO_REVISION (charset); \
3701 if (revision >= 0) \
3703 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3704 EMIT_ONE_BYTE ('@' + revision); \
3706 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3707 if (CHARSET_DIMENSION (charset) == 1) \
3709 if (! CHARSET_ISO_CHARS_96 (charset)) \
3710 c = intermediate_char_94[reg]; \
3712 c = intermediate_char_96[reg]; \
3713 EMIT_ONE_ASCII_BYTE (c); \
3717 EMIT_ONE_ASCII_BYTE ('$'); \
3718 if (! CHARSET_ISO_CHARS_96 (charset)) \
3720 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3722 || final_char < '@' || final_char > 'B') \
3723 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3726 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3728 EMIT_ONE_ASCII_BYTE (final_char); \
3730 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3734 /* The following two macros produce codes (control character or escape
3735 sequence) for ISO2022 single-shift functions (single-shift-2 and
3738 #define ENCODE_SINGLE_SHIFT_2 \
3740 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3741 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3743 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3744 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3748 #define ENCODE_SINGLE_SHIFT_3 \
3750 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3751 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3753 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3754 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3758 /* The following four macros produce codes (control character or
3759 escape sequence) for ISO2022 locking-shift functions (shift-in,
3760 shift-out, locking-shift-2, and locking-shift-3). */
3762 #define ENCODE_SHIFT_IN \
3764 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3765 CODING_ISO_INVOCATION (coding, 0) = 0; \
3769 #define ENCODE_SHIFT_OUT \
3771 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3772 CODING_ISO_INVOCATION (coding, 0) = 1; \
3776 #define ENCODE_LOCKING_SHIFT_2 \
3778 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3779 CODING_ISO_INVOCATION (coding, 0) = 2; \
3783 #define ENCODE_LOCKING_SHIFT_3 \
3785 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3786 CODING_ISO_INVOCATION (coding, 0) = 3; \
3790 /* Produce codes for a DIMENSION1 character whose character set is
3791 CHARSET and whose position-code is C1. Designation and invocation
3792 sequences are also produced in advance if necessary. */
3794 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3796 int id = CHARSET_ID (charset); \
3798 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3799 && id == charset_ascii) \
3801 id = charset_jisx0201_roman; \
3802 charset = CHARSET_FROM_ID (id); \
3805 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3807 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3808 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3810 EMIT_ONE_BYTE (c1 | 0x80); \
3811 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3814 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3816 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3819 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3821 EMIT_ONE_BYTE (c1 | 0x80); \
3825 /* Since CHARSET is not yet invoked to any graphic planes, we \
3826 must invoke it, or, at first, designate it to some graphic \
3827 register. Then repeat the loop to actually produce the \
3829 dst = encode_invocation_designation (charset, coding, dst, \
3834 /* Produce codes for a DIMENSION2 character whose character set is
3835 CHARSET and whose position-codes are C1 and C2. Designation and
3836 invocation codes are also produced in advance if necessary. */
3838 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3840 int id = CHARSET_ID (charset); \
3842 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3843 && id == charset_jisx0208) \
3845 id = charset_jisx0208_1978; \
3846 charset = CHARSET_FROM_ID (id); \
3849 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3851 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3852 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3854 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3855 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3858 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3860 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3863 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3865 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3869 /* Since CHARSET is not yet invoked to any graphic planes, we \
3870 must invoke it, or, at first, designate it to some graphic \
3871 register. Then repeat the loop to actually produce the \
3873 dst = encode_invocation_designation (charset, coding, dst, \
3878 #define ENCODE_ISO_CHARACTER(charset, c) \
3880 int code = ENCODE_CHAR ((charset),(c)); \
3882 if (CHARSET_DIMENSION (charset) == 1) \
3883 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3885 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
3889 /* Produce designation and invocation codes at a place pointed by DST
3890 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
3894 encode_invocation_designation (charset
, coding
, dst
, p_nchars
)
3895 struct charset
*charset
;
3896 struct coding_system
*coding
;
3900 int multibytep
= coding
->dst_multibyte
;
3901 int produced_chars
= *p_nchars
;
3902 int reg
; /* graphic register number */
3903 int id
= CHARSET_ID (charset
);
3905 /* At first, check designations. */
3906 for (reg
= 0; reg
< 4; reg
++)
3907 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
3912 /* CHARSET is not yet designated to any graphic registers. */
3913 /* At first check the requested designation. */
3914 reg
= CODING_ISO_REQUEST (coding
, id
);
3916 /* Since CHARSET requests no special designation, designate it
3917 to graphic register 0. */
3920 ENCODE_DESIGNATION (charset
, reg
, coding
);
3923 if (CODING_ISO_INVOCATION (coding
, 0) != reg
3924 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
3926 /* Since the graphic register REG is not invoked to any graphic
3927 planes, invoke it to graphic plane 0. */
3930 case 0: /* graphic register 0 */
3934 case 1: /* graphic register 1 */
3938 case 2: /* graphic register 2 */
3939 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3940 ENCODE_SINGLE_SHIFT_2
;
3942 ENCODE_LOCKING_SHIFT_2
;
3945 case 3: /* graphic register 3 */
3946 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3947 ENCODE_SINGLE_SHIFT_3
;
3949 ENCODE_LOCKING_SHIFT_3
;
3954 *p_nchars
= produced_chars
;
3958 /* The following three macros produce codes for indicating direction
3960 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
3962 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
3963 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
3965 EMIT_ONE_BYTE (ISO_CODE_CSI); \
3969 #define ENCODE_DIRECTION_R2L() \
3971 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3972 EMIT_TWO_ASCII_BYTES ('2', ']'); \
3976 #define ENCODE_DIRECTION_L2R() \
3978 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3979 EMIT_TWO_ASCII_BYTES ('0', ']'); \
3983 /* Produce codes for designation and invocation to reset the graphic
3984 planes and registers to initial state. */
3985 #define ENCODE_RESET_PLANE_AND_REGISTER() \
3988 struct charset *charset; \
3990 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
3992 for (reg = 0; reg < 4; reg++) \
3993 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
3994 && (CODING_ISO_DESIGNATION (coding, reg) \
3995 != CODING_ISO_INITIAL (coding, reg))) \
3997 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
3998 ENCODE_DESIGNATION (charset, reg, coding); \
4003 /* Produce designation sequences of charsets in the line started from
4004 SRC to a place pointed by DST, and return updated DST.
4006 If the current block ends before any end-of-line, we may fail to
4007 find all the necessary designations. */
4009 static unsigned char *
4010 encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
)
4011 struct coding_system
*coding
;
4012 int *charbuf
, *charbuf_end
;
4015 struct charset
*charset
;
4016 /* Table of charsets to be designated to each graphic register. */
4018 int c
, found
= 0, reg
;
4019 int produced_chars
= 0;
4020 int multibytep
= coding
->dst_multibyte
;
4022 Lisp_Object charset_list
;
4024 attrs
= CODING_ID_ATTRS (coding
->id
);
4025 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4026 if (EQ (charset_list
, Qiso_2022
))
4027 charset_list
= Viso_2022_charset_list
;
4029 for (reg
= 0; reg
< 4; reg
++)
4039 charset
= char_charset (c
, charset_list
, NULL
);
4040 id
= CHARSET_ID (charset
);
4041 reg
= CODING_ISO_REQUEST (coding
, id
);
4042 if (reg
>= 0 && r
[reg
] < 0)
4051 for (reg
= 0; reg
< 4; reg
++)
4053 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
4054 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
4060 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
4063 encode_coding_iso_2022 (coding
)
4064 struct coding_system
*coding
;
4066 int multibytep
= coding
->dst_multibyte
;
4067 int *charbuf
= coding
->charbuf
;
4068 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4069 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4070 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4073 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
4074 && CODING_ISO_BOL (coding
));
4075 int produced_chars
= 0;
4076 Lisp_Object attrs
, eol_type
, charset_list
;
4077 int ascii_compatible
;
4079 int preferred_charset_id
= -1;
4081 CODING_GET_INFO (coding
, attrs
, charset_list
);
4082 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
4083 if (VECTORP (eol_type
))
4086 setup_iso_safe_charsets (attrs
);
4087 /* Charset list may have been changed. */
4088 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
4089 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
4091 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4093 while (charbuf
< charbuf_end
)
4095 ASSURE_DESTINATION (safe_room
);
4097 if (bol_designation
)
4099 unsigned char *dst_prev
= dst
;
4101 /* We have to produce designation sequences if any now. */
4102 dst
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
);
4103 bol_designation
= 0;
4104 /* We are sure that designation sequences are all ASCII bytes. */
4105 produced_chars
+= dst
- dst_prev
;
4112 /* Handle an annotation. */
4115 case CODING_ANNOTATE_COMPOSITION_MASK
:
4116 /* Not yet implemented. */
4118 case CODING_ANNOTATE_CHARSET_MASK
:
4119 preferred_charset_id
= charbuf
[2];
4120 if (preferred_charset_id
>= 0
4121 && NILP (Fmemq (make_number (preferred_charset_id
),
4123 preferred_charset_id
= -1;
4132 /* Now encode the character C. */
4133 if (c
< 0x20 || c
== 0x7F)
4136 || (c
== '\r' && EQ (eol_type
, Qmac
)))
4138 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4139 ENCODE_RESET_PLANE_AND_REGISTER ();
4140 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
4144 for (i
= 0; i
< 4; i
++)
4145 CODING_ISO_DESIGNATION (coding
, i
)
4146 = CODING_ISO_INITIAL (coding
, i
);
4149 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
4151 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
4152 ENCODE_RESET_PLANE_AND_REGISTER ();
4153 EMIT_ONE_ASCII_BYTE (c
);
4155 else if (ASCII_CHAR_P (c
))
4157 if (ascii_compatible
)
4158 EMIT_ONE_ASCII_BYTE (c
);
4161 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
4162 ENCODE_ISO_CHARACTER (charset
, c
);
4165 else if (CHAR_BYTE8_P (c
))
4167 c
= CHAR_TO_BYTE8 (c
);
4172 struct charset
*charset
;
4174 if (preferred_charset_id
>= 0)
4176 charset
= CHARSET_FROM_ID (preferred_charset_id
);
4177 if (! CHAR_CHARSET_P (c
, charset
))
4178 charset
= char_charset (c
, charset_list
, NULL
);
4181 charset
= char_charset (c
, charset_list
, NULL
);
4184 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4186 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4187 charset
= CHARSET_FROM_ID (charset_ascii
);
4191 c
= coding
->default_char
;
4192 charset
= char_charset (c
, charset_list
, NULL
);
4195 ENCODE_ISO_CHARACTER (charset
, c
);
4199 if (coding
->mode
& CODING_MODE_LAST_BLOCK
4200 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
4202 ASSURE_DESTINATION (safe_room
);
4203 ENCODE_RESET_PLANE_AND_REGISTER ();
4205 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4206 CODING_ISO_BOL (coding
) = bol_designation
;
4207 coding
->produced_char
+= produced_chars
;
4208 coding
->produced
= dst
- coding
->destination
;
4213 /*** 8,9. SJIS and BIG5 handlers ***/
4215 /* Although SJIS and BIG5 are not ISO's coding system, they are used
4216 quite widely. So, for the moment, Emacs supports them in the bare
4217 C code. But, in the future, they may be supported only by CCL. */
4219 /* SJIS is a coding system encoding three character sets: ASCII, right
4220 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
4221 as is. A character of charset katakana-jisx0201 is encoded by
4222 "position-code + 0x80". A character of charset japanese-jisx0208
4223 is encoded in 2-byte but two position-codes are divided and shifted
4224 so that it fit in the range below.
4226 --- CODE RANGE of SJIS ---
4227 (character set) (range)
4229 KATAKANA-JISX0201 0xA0 .. 0xDF
4230 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
4231 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
4232 -------------------------------
4236 /* BIG5 is a coding system encoding two character sets: ASCII and
4237 Big5. An ASCII character is encoded as is. Big5 is a two-byte
4238 character set and is encoded in two-byte.
4240 --- CODE RANGE of BIG5 ---
4241 (character set) (range)
4243 Big5 (1st byte) 0xA1 .. 0xFE
4244 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
4245 --------------------------
4249 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4250 Check if a text is encoded in SJIS. If it is, return
4251 CATEGORY_MASK_SJIS, else return 0. */
4254 detect_coding_sjis (coding
, detect_info
)
4255 struct coding_system
*coding
;
4256 struct coding_detection_info
*detect_info
;
4258 const unsigned char *src
= coding
->source
, *src_base
;
4259 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4260 int multibytep
= coding
->src_multibyte
;
4261 int consumed_chars
= 0;
4265 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
4266 /* A coding system of this category is always ASCII compatible. */
4267 src
+= coding
->head_ascii
;
4275 if ((c
>= 0x81 && c
<= 0x9F) || (c
>= 0xE0 && c
<= 0xEF))
4278 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
4280 found
= CATEGORY_MASK_SJIS
;
4282 else if (c
>= 0xA0 && c
< 0xE0)
4283 found
= CATEGORY_MASK_SJIS
;
4287 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4291 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4293 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4296 detect_info
->found
|= found
;
4300 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4301 Check if a text is encoded in BIG5. If it is, return
4302 CATEGORY_MASK_BIG5, else return 0. */
4305 detect_coding_big5 (coding
, detect_info
)
4306 struct coding_system
*coding
;
4307 struct coding_detection_info
*detect_info
;
4309 const unsigned char *src
= coding
->source
, *src_base
;
4310 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4311 int multibytep
= coding
->src_multibyte
;
4312 int consumed_chars
= 0;
4316 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4317 /* A coding system of this category is always ASCII compatible. */
4318 src
+= coding
->head_ascii
;
4329 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4331 found
= CATEGORY_MASK_BIG5
;
4336 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4340 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4342 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4345 detect_info
->found
|= found
;
4349 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4350 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4353 decode_coding_sjis (coding
)
4354 struct coding_system
*coding
;
4356 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4357 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4358 const unsigned char *src_base
;
4359 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4361 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4362 int consumed_chars
= 0, consumed_chars_base
;
4363 int multibytep
= coding
->src_multibyte
;
4364 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4365 struct charset
*charset_kanji2
;
4366 Lisp_Object attrs
, charset_list
, val
;
4367 int char_offset
= coding
->produced_char
;
4368 int last_offset
= char_offset
;
4369 int last_id
= charset_ascii
;
4370 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4371 int byte_after_cr
= -1;
4373 CODING_GET_INFO (coding
, attrs
, charset_list
);
4376 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4377 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4378 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4379 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4384 struct charset
*charset
;
4387 consumed_chars_base
= consumed_chars
;
4389 if (charbuf
>= charbuf_end
)
4391 if (byte_after_cr
>= 0)
4396 if (byte_after_cr
>= 0)
4397 c
= byte_after_cr
, byte_after_cr
= -1;
4404 if (eol_crlf
&& c
== '\r')
4405 ONE_MORE_BYTE (byte_after_cr
);
4406 charset
= charset_roman
;
4408 else if (c
== 0x80 || c
== 0xA0)
4410 else if (c
>= 0xA1 && c
<= 0xDF)
4412 /* SJIS -> JISX0201-Kana */
4414 charset
= charset_kana
;
4418 /* SJIS -> JISX0208 */
4420 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4424 charset
= charset_kanji
;
4426 else if (c
<= 0xFC && charset_kanji2
)
4428 /* SJIS -> JISX0213-2 */
4430 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4434 charset
= charset_kanji2
;
4438 if (charset
->id
!= charset_ascii
4439 && last_id
!= charset
->id
)
4441 if (last_id
!= charset_ascii
)
4442 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4443 last_id
= charset
->id
;
4444 last_offset
= char_offset
;
4446 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4453 consumed_chars
= consumed_chars_base
;
4455 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4461 if (last_id
!= charset_ascii
)
4462 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4463 coding
->consumed_char
+= consumed_chars_base
;
4464 coding
->consumed
= src_base
- coding
->source
;
4465 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4469 decode_coding_big5 (coding
)
4470 struct coding_system
*coding
;
4472 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4473 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4474 const unsigned char *src_base
;
4475 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4477 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4478 int consumed_chars
= 0, consumed_chars_base
;
4479 int multibytep
= coding
->src_multibyte
;
4480 struct charset
*charset_roman
, *charset_big5
;
4481 Lisp_Object attrs
, charset_list
, val
;
4482 int char_offset
= coding
->produced_char
;
4483 int last_offset
= char_offset
;
4484 int last_id
= charset_ascii
;
4485 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4486 int byte_after_cr
= -1;
4488 CODING_GET_INFO (coding
, attrs
, charset_list
);
4490 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4491 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4496 struct charset
*charset
;
4499 consumed_chars_base
= consumed_chars
;
4501 if (charbuf
>= charbuf_end
)
4503 if (byte_after_cr
>= 0)
4508 if (byte_after_cr
>= 0)
4509 c
= byte_after_cr
, byte_after_cr
= -1;
4517 if (eol_crlf
&& c
== '\r')
4518 ONE_MORE_BYTE (byte_after_cr
);
4519 charset
= charset_roman
;
4524 if (c
< 0xA1 || c
> 0xFE)
4527 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4530 charset
= charset_big5
;
4532 if (charset
->id
!= charset_ascii
4533 && last_id
!= charset
->id
)
4535 if (last_id
!= charset_ascii
)
4536 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4537 last_id
= charset
->id
;
4538 last_offset
= char_offset
;
4540 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4547 consumed_chars
= consumed_chars_base
;
4549 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4555 if (last_id
!= charset_ascii
)
4556 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4557 coding
->consumed_char
+= consumed_chars_base
;
4558 coding
->consumed
= src_base
- coding
->source
;
4559 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4562 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4563 This function can encode charsets `ascii', `katakana-jisx0201',
4564 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4565 are sure that all these charsets are registered as official charset
4566 (i.e. do not have extended leading-codes). Characters of other
4567 charsets are produced without any encoding. If SJIS_P is 1, encode
4568 SJIS text, else encode BIG5 text. */
4571 encode_coding_sjis (coding
)
4572 struct coding_system
*coding
;
4574 int multibytep
= coding
->dst_multibyte
;
4575 int *charbuf
= coding
->charbuf
;
4576 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4577 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4578 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4580 int produced_chars
= 0;
4581 Lisp_Object attrs
, charset_list
, val
;
4582 int ascii_compatible
;
4583 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4584 struct charset
*charset_kanji2
;
4587 CODING_GET_INFO (coding
, attrs
, charset_list
);
4589 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4590 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4591 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4592 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4594 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4596 while (charbuf
< charbuf_end
)
4598 ASSURE_DESTINATION (safe_room
);
4600 /* Now encode the character C. */
4601 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4602 EMIT_ONE_ASCII_BYTE (c
);
4603 else if (CHAR_BYTE8_P (c
))
4605 c
= CHAR_TO_BYTE8 (c
);
4611 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4615 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4617 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4618 charset
= CHARSET_FROM_ID (charset_ascii
);
4622 c
= coding
->default_char
;
4623 charset
= char_charset (c
, charset_list
, &code
);
4626 if (code
== CHARSET_INVALID_CODE (charset
))
4628 if (charset
== charset_kanji
)
4632 c1
= code
>> 8, c2
= code
& 0xFF;
4633 EMIT_TWO_BYTES (c1
, c2
);
4635 else if (charset
== charset_kana
)
4636 EMIT_ONE_BYTE (code
| 0x80);
4637 else if (charset_kanji2
&& charset
== charset_kanji2
)
4642 if (c1
== 0x21 || (c1
>= 0x23 && c1
< 0x25)
4643 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4645 JIS_TO_SJIS2 (code
);
4646 c1
= code
>> 8, c2
= code
& 0xFF;
4647 EMIT_TWO_BYTES (c1
, c2
);
4650 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4653 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4656 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4657 coding
->produced_char
+= produced_chars
;
4658 coding
->produced
= dst
- coding
->destination
;
4663 encode_coding_big5 (coding
)
4664 struct coding_system
*coding
;
4666 int multibytep
= coding
->dst_multibyte
;
4667 int *charbuf
= coding
->charbuf
;
4668 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4669 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4670 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4672 int produced_chars
= 0;
4673 Lisp_Object attrs
, charset_list
, val
;
4674 int ascii_compatible
;
4675 struct charset
*charset_roman
, *charset_big5
;
4678 CODING_GET_INFO (coding
, attrs
, charset_list
);
4680 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4681 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4682 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4684 while (charbuf
< charbuf_end
)
4686 ASSURE_DESTINATION (safe_room
);
4688 /* Now encode the character C. */
4689 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4690 EMIT_ONE_ASCII_BYTE (c
);
4691 else if (CHAR_BYTE8_P (c
))
4693 c
= CHAR_TO_BYTE8 (c
);
4699 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4703 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4705 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4706 charset
= CHARSET_FROM_ID (charset_ascii
);
4710 c
= coding
->default_char
;
4711 charset
= char_charset (c
, charset_list
, &code
);
4714 if (code
== CHARSET_INVALID_CODE (charset
))
4716 if (charset
== charset_big5
)
4720 c1
= code
>> 8, c2
= code
& 0xFF;
4721 EMIT_TWO_BYTES (c1
, c2
);
4724 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4727 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4728 coding
->produced_char
+= produced_chars
;
4729 coding
->produced
= dst
- coding
->destination
;
4734 /*** 10. CCL handlers ***/
4736 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4737 Check if a text is encoded in a coding system of which
4738 encoder/decoder are written in CCL program. If it is, return
4739 CATEGORY_MASK_CCL, else return 0. */
4742 detect_coding_ccl (coding
, detect_info
)
4743 struct coding_system
*coding
;
4744 struct coding_detection_info
*detect_info
;
4746 const unsigned char *src
= coding
->source
, *src_base
;
4747 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4748 int multibytep
= coding
->src_multibyte
;
4749 int consumed_chars
= 0;
4751 unsigned char *valids
;
4752 int head_ascii
= coding
->head_ascii
;
4755 detect_info
->checked
|= CATEGORY_MASK_CCL
;
4757 coding
= &coding_categories
[coding_category_ccl
];
4758 valids
= CODING_CCL_VALIDS (coding
);
4759 attrs
= CODING_ID_ATTRS (coding
->id
);
4760 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4769 if (c
< 0 || ! valids
[c
])
4771 if ((valids
[c
] > 1))
4772 found
= CATEGORY_MASK_CCL
;
4774 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
4778 detect_info
->found
|= found
;
4783 decode_coding_ccl (coding
)
4784 struct coding_system
*coding
;
4786 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4787 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4788 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4789 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
4790 int consumed_chars
= 0;
4791 int multibytep
= coding
->src_multibyte
;
4792 struct ccl_program ccl
;
4793 int source_charbuf
[1024];
4794 int source_byteidx
[1024];
4795 Lisp_Object attrs
, charset_list
;
4797 CODING_GET_INFO (coding
, attrs
, charset_list
);
4798 setup_ccl_program (&ccl
, CODING_CCL_DECODER (coding
));
4800 while (src
< src_end
)
4802 const unsigned char *p
= src
;
4803 int *source
, *source_end
;
4807 while (i
< 1024 && p
< src_end
)
4809 source_byteidx
[i
] = p
- src
;
4810 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
4813 while (i
< 1024 && p
< src_end
)
4814 source_charbuf
[i
++] = *p
++;
4816 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4819 source
= source_charbuf
;
4820 source_end
= source
+ i
;
4821 while (source
< source_end
)
4823 ccl_driver (&ccl
, source
, charbuf
,
4824 source_end
- source
, charbuf_end
- charbuf
,
4826 source
+= ccl
.consumed
;
4827 charbuf
+= ccl
.produced
;
4828 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_DST
)
4831 if (source
< source_end
)
4832 src
+= source_byteidx
[source
- source_charbuf
];
4835 consumed_chars
+= source
- source_charbuf
;
4837 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_SRC
4838 && ccl
.status
!= CODING_RESULT_INSUFFICIENT_SRC
)
4844 case CCL_STAT_SUSPEND_BY_SRC
:
4845 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4847 case CCL_STAT_SUSPEND_BY_DST
:
4850 case CCL_STAT_INVALID_CMD
:
4851 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4854 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4857 coding
->consumed_char
+= consumed_chars
;
4858 coding
->consumed
= src
- coding
->source
;
4859 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4863 encode_coding_ccl (coding
)
4864 struct coding_system
*coding
;
4866 struct ccl_program ccl
;
4867 int multibytep
= coding
->dst_multibyte
;
4868 int *charbuf
= coding
->charbuf
;
4869 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4870 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4871 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4872 int destination_charbuf
[1024];
4873 int i
, produced_chars
= 0;
4874 Lisp_Object attrs
, charset_list
;
4876 CODING_GET_INFO (coding
, attrs
, charset_list
);
4877 setup_ccl_program (&ccl
, CODING_CCL_ENCODER (coding
));
4879 ccl
.last_block
= coding
->mode
& CODING_MODE_LAST_BLOCK
;
4880 ccl
.dst_multibyte
= coding
->dst_multibyte
;
4882 while (charbuf
< charbuf_end
)
4884 ccl_driver (&ccl
, charbuf
, destination_charbuf
,
4885 charbuf_end
- charbuf
, 1024, charset_list
);
4888 ASSURE_DESTINATION (ccl
.produced
* 2);
4889 for (i
= 0; i
< ccl
.produced
; i
++)
4890 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
4894 ASSURE_DESTINATION (ccl
.produced
);
4895 for (i
= 0; i
< ccl
.produced
; i
++)
4896 *dst
++ = destination_charbuf
[i
] & 0xFF;
4897 produced_chars
+= ccl
.produced
;
4899 charbuf
+= ccl
.consumed
;
4900 if (ccl
.status
== CCL_STAT_QUIT
4901 || ccl
.status
== CCL_STAT_INVALID_CMD
)
4907 case CCL_STAT_SUSPEND_BY_SRC
:
4908 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4910 case CCL_STAT_SUSPEND_BY_DST
:
4911 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
4914 case CCL_STAT_INVALID_CMD
:
4915 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4918 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4922 coding
->produced_char
+= produced_chars
;
4923 coding
->produced
= dst
- coding
->destination
;
4929 /*** 10, 11. no-conversion handlers ***/
4931 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4934 decode_coding_raw_text (coding
)
4935 struct coding_system
*coding
;
4937 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
4939 coding
->chars_at_source
= 1;
4940 coding
->consumed_char
= coding
->src_chars
;
4941 coding
->consumed
= coding
->src_bytes
;
4942 if (eol_crlf
&& coding
->source
[coding
->src_bytes
- 1] == '\r')
4944 coding
->consumed_char
--;
4946 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4949 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4953 encode_coding_raw_text (coding
)
4954 struct coding_system
*coding
;
4956 int multibytep
= coding
->dst_multibyte
;
4957 int *charbuf
= coding
->charbuf
;
4958 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
4959 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4960 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4961 int produced_chars
= 0;
4966 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
4968 if (coding
->src_multibyte
)
4969 while (charbuf
< charbuf_end
)
4971 ASSURE_DESTINATION (safe_room
);
4973 if (ASCII_CHAR_P (c
))
4974 EMIT_ONE_ASCII_BYTE (c
);
4975 else if (CHAR_BYTE8_P (c
))
4977 c
= CHAR_TO_BYTE8 (c
);
4982 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
4984 CHAR_STRING_ADVANCE (c
, p1
);
4987 EMIT_ONE_BYTE (*p0
);
4993 while (charbuf
< charbuf_end
)
4995 ASSURE_DESTINATION (safe_room
);
5002 if (coding
->src_multibyte
)
5004 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5006 while (charbuf
< charbuf_end
)
5008 ASSURE_DESTINATION (safe_room
);
5010 if (ASCII_CHAR_P (c
))
5012 else if (CHAR_BYTE8_P (c
))
5013 *dst
++ = CHAR_TO_BYTE8 (c
);
5015 CHAR_STRING_ADVANCE (c
, dst
);
5020 ASSURE_DESTINATION (charbuf_end
- charbuf
);
5021 while (charbuf
< charbuf_end
&& dst
< dst_end
)
5022 *dst
++ = *charbuf
++;
5024 produced_chars
= dst
- (coding
->destination
+ coding
->produced
);
5026 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5027 coding
->produced_char
+= produced_chars
;
5028 coding
->produced
= dst
- coding
->destination
;
5032 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
5033 Check if a text is encoded in a charset-based coding system. If it
5034 is, return 1, else return 0. */
5037 detect_coding_charset (coding
, detect_info
)
5038 struct coding_system
*coding
;
5039 struct coding_detection_info
*detect_info
;
5041 const unsigned char *src
= coding
->source
, *src_base
;
5042 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5043 int multibytep
= coding
->src_multibyte
;
5044 int consumed_chars
= 0;
5045 Lisp_Object attrs
, valids
, name
;
5047 int head_ascii
= coding
->head_ascii
;
5048 int check_latin_extra
= 0;
5050 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
5052 coding
= &coding_categories
[coding_category_charset
];
5053 attrs
= CODING_ID_ATTRS (coding
->id
);
5054 valids
= AREF (attrs
, coding_attr_charset_valids
);
5055 name
= CODING_ID_NAME (coding
->id
);
5056 if (VECTORP (Vlatin_extra_code_table
)
5057 && strcmp ((char *) SDATA (SYMBOL_NAME (name
)), "iso-8859-"))
5058 check_latin_extra
= 1;
5059 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
5066 struct charset
*charset
;
5073 val
= AREF (valids
, c
);
5079 && check_latin_extra
5080 && NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
5082 found
= CATEGORY_MASK_CHARSET
;
5086 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5087 dim
= CHARSET_DIMENSION (charset
);
5088 for (idx
= 1; idx
< dim
; idx
++)
5093 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 2]
5094 || c
> charset
->code_space
[(dim
- 1 - idx
) * 2 + 1])
5103 for (; CONSP (val
); val
= XCDR (val
))
5105 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5106 dim
= CHARSET_DIMENSION (charset
);
5112 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 4]
5113 || c
> charset
->code_space
[(dim
- 1 - idx
) * 4 + 1])
5128 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
5132 detect_info
->found
|= found
;
5137 decode_coding_charset (coding
)
5138 struct coding_system
*coding
;
5140 const unsigned char *src
= coding
->source
+ coding
->consumed
;
5141 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
5142 const unsigned char *src_base
;
5143 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
5145 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
5146 int consumed_chars
= 0, consumed_chars_base
;
5147 int multibytep
= coding
->src_multibyte
;
5148 Lisp_Object attrs
, charset_list
, valids
;
5149 int char_offset
= coding
->produced_char
;
5150 int last_offset
= char_offset
;
5151 int last_id
= charset_ascii
;
5152 int eol_crlf
= EQ (CODING_ID_EOL_TYPE (coding
->id
), Qdos
);
5153 int byte_after_cr
= -1;
5155 CODING_GET_INFO (coding
, attrs
, charset_list
);
5156 valids
= AREF (attrs
, coding_attr_charset_valids
);
5162 struct charset
*charset
;
5168 consumed_chars_base
= consumed_chars
;
5170 if (charbuf
>= charbuf_end
)
5172 if (byte_after_cr
>= 0)
5177 if (byte_after_cr
>= 0)
5185 if (eol_crlf
&& c
== '\r')
5186 ONE_MORE_BYTE (byte_after_cr
);
5192 val
= AREF (valids
, c
);
5193 if (! INTEGERP (val
) && ! CONSP (val
))
5197 charset
= CHARSET_FROM_ID (XFASTINT (val
));
5198 dim
= CHARSET_DIMENSION (charset
);
5202 code
= (code
<< 8) | c
;
5205 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
5210 /* VAL is a list of charset IDs. It is assured that the
5211 list is sorted by charset dimensions (smaller one
5215 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
5216 dim
= CHARSET_DIMENSION (charset
);
5220 code
= (code
<< 8) | c
;
5223 CODING_DECODE_CHAR (coding
, src
, src_base
,
5224 src_end
, charset
, code
, c
);
5232 if (charset
->id
!= charset_ascii
5233 && last_id
!= charset
->id
)
5235 if (last_id
!= charset_ascii
)
5236 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5237 last_id
= charset
->id
;
5238 last_offset
= char_offset
;
5247 consumed_chars
= consumed_chars_base
;
5249 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
5255 if (last_id
!= charset_ascii
)
5256 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
5257 coding
->consumed_char
+= consumed_chars_base
;
5258 coding
->consumed
= src_base
- coding
->source
;
5259 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
5263 encode_coding_charset (coding
)
5264 struct coding_system
*coding
;
5266 int multibytep
= coding
->dst_multibyte
;
5267 int *charbuf
= coding
->charbuf
;
5268 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
5269 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5270 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5271 int safe_room
= MAX_MULTIBYTE_LENGTH
;
5272 int produced_chars
= 0;
5273 Lisp_Object attrs
, charset_list
;
5274 int ascii_compatible
;
5277 CODING_GET_INFO (coding
, attrs
, charset_list
);
5278 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
5280 while (charbuf
< charbuf_end
)
5282 struct charset
*charset
;
5285 ASSURE_DESTINATION (safe_room
);
5287 if (ascii_compatible
&& ASCII_CHAR_P (c
))
5288 EMIT_ONE_ASCII_BYTE (c
);
5289 else if (CHAR_BYTE8_P (c
))
5291 c
= CHAR_TO_BYTE8 (c
);
5296 charset
= char_charset (c
, charset_list
, &code
);
5299 if (CHARSET_DIMENSION (charset
) == 1)
5300 EMIT_ONE_BYTE (code
);
5301 else if (CHARSET_DIMENSION (charset
) == 2)
5302 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
5303 else if (CHARSET_DIMENSION (charset
) == 3)
5304 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
5306 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
5307 (code
>> 8) & 0xFF, code
& 0xFF);
5311 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
5312 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
5314 c
= coding
->default_char
;
5320 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
5321 coding
->produced_char
+= produced_chars
;
5322 coding
->produced
= dst
- coding
->destination
;
5327 /*** 7. C library functions ***/
5329 /* Setup coding context CODING from information about CODING_SYSTEM.
5330 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
5331 CODING_SYSTEM is invalid, signal an error. */
5334 setup_coding_system (coding_system
, coding
)
5335 Lisp_Object coding_system
;
5336 struct coding_system
*coding
;
5339 Lisp_Object eol_type
;
5340 Lisp_Object coding_type
;
5343 if (NILP (coding_system
))
5344 coding_system
= Qundecided
;
5346 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
5348 attrs
= CODING_ID_ATTRS (coding
->id
);
5349 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5352 coding
->head_ascii
= -1;
5353 if (VECTORP (eol_type
))
5354 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5355 | CODING_REQUIRE_DETECTION_MASK
);
5356 else if (! EQ (eol_type
, Qunix
))
5357 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5358 | CODING_REQUIRE_ENCODING_MASK
);
5360 coding
->common_flags
= 0;
5361 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
5362 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5363 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
5364 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5365 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
5366 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
5368 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5369 coding
->max_charset_id
= SCHARS (val
) - 1;
5370 coding
->safe_charsets
= (char *) SDATA (val
);
5371 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
5373 coding_type
= CODING_ATTR_TYPE (attrs
);
5374 if (EQ (coding_type
, Qundecided
))
5376 coding
->detector
= NULL
;
5377 coding
->decoder
= decode_coding_raw_text
;
5378 coding
->encoder
= encode_coding_raw_text
;
5379 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5381 else if (EQ (coding_type
, Qiso_2022
))
5384 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5386 /* Invoke graphic register 0 to plane 0. */
5387 CODING_ISO_INVOCATION (coding
, 0) = 0;
5388 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
5389 CODING_ISO_INVOCATION (coding
, 1)
5390 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
5391 /* Setup the initial status of designation. */
5392 for (i
= 0; i
< 4; i
++)
5393 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
5394 /* Not single shifting initially. */
5395 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
5396 /* Beginning of buffer should also be regarded as bol. */
5397 CODING_ISO_BOL (coding
) = 1;
5398 coding
->detector
= detect_coding_iso_2022
;
5399 coding
->decoder
= decode_coding_iso_2022
;
5400 coding
->encoder
= encode_coding_iso_2022
;
5401 if (flags
& CODING_ISO_FLAG_SAFE
)
5402 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
5403 coding
->common_flags
5404 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5405 | CODING_REQUIRE_FLUSHING_MASK
);
5406 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
5407 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
5408 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
5409 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
5410 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5412 setup_iso_safe_charsets (attrs
);
5413 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5414 coding
->max_charset_id
= SCHARS (val
) - 1;
5415 coding
->safe_charsets
= (char *) SDATA (val
);
5417 CODING_ISO_FLAGS (coding
) = flags
;
5419 else if (EQ (coding_type
, Qcharset
))
5421 coding
->detector
= detect_coding_charset
;
5422 coding
->decoder
= decode_coding_charset
;
5423 coding
->encoder
= encode_coding_charset
;
5424 coding
->common_flags
5425 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5427 else if (EQ (coding_type
, Qutf_8
))
5429 val
= AREF (attrs
, coding_attr_utf_bom
);
5430 CODING_UTF_8_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5431 : EQ (val
, Qt
) ? utf_with_bom
5433 coding
->detector
= detect_coding_utf_8
;
5434 coding
->decoder
= decode_coding_utf_8
;
5435 coding
->encoder
= encode_coding_utf_8
;
5436 coding
->common_flags
5437 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5438 if (CODING_UTF_8_BOM (coding
) == utf_detect_bom
)
5439 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5441 else if (EQ (coding_type
, Qutf_16
))
5443 val
= AREF (attrs
, coding_attr_utf_bom
);
5444 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_detect_bom
5445 : EQ (val
, Qt
) ? utf_with_bom
5447 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5448 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5449 : utf_16_little_endian
);
5450 CODING_UTF_16_SURROGATE (coding
) = 0;
5451 coding
->detector
= detect_coding_utf_16
;
5452 coding
->decoder
= decode_coding_utf_16
;
5453 coding
->encoder
= encode_coding_utf_16
;
5454 coding
->common_flags
5455 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5456 if (CODING_UTF_16_BOM (coding
) == utf_detect_bom
)
5457 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5459 else if (EQ (coding_type
, Qccl
))
5461 coding
->detector
= detect_coding_ccl
;
5462 coding
->decoder
= decode_coding_ccl
;
5463 coding
->encoder
= encode_coding_ccl
;
5464 coding
->common_flags
5465 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5466 | CODING_REQUIRE_FLUSHING_MASK
);
5468 else if (EQ (coding_type
, Qemacs_mule
))
5470 coding
->detector
= detect_coding_emacs_mule
;
5471 coding
->decoder
= decode_coding_emacs_mule
;
5472 coding
->encoder
= encode_coding_emacs_mule
;
5473 coding
->common_flags
5474 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5475 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5476 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5478 Lisp_Object tail
, safe_charsets
;
5479 int max_charset_id
= 0;
5481 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5483 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5484 max_charset_id
= XFASTINT (XCAR (tail
));
5485 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
5487 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5489 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5490 coding
->max_charset_id
= max_charset_id
;
5491 coding
->safe_charsets
= (char *) SDATA (safe_charsets
);
5494 else if (EQ (coding_type
, Qshift_jis
))
5496 coding
->detector
= detect_coding_sjis
;
5497 coding
->decoder
= decode_coding_sjis
;
5498 coding
->encoder
= encode_coding_sjis
;
5499 coding
->common_flags
5500 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5502 else if (EQ (coding_type
, Qbig5
))
5504 coding
->detector
= detect_coding_big5
;
5505 coding
->decoder
= decode_coding_big5
;
5506 coding
->encoder
= encode_coding_big5
;
5507 coding
->common_flags
5508 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5510 else /* EQ (coding_type, Qraw_text) */
5512 coding
->detector
= NULL
;
5513 coding
->decoder
= decode_coding_raw_text
;
5514 coding
->encoder
= encode_coding_raw_text
;
5515 if (! EQ (eol_type
, Qunix
))
5517 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5518 if (! VECTORP (eol_type
))
5519 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5527 /* Return a list of charsets supported by CODING. */
5530 coding_charset_list (coding
)
5531 struct coding_system
*coding
;
5533 Lisp_Object attrs
, charset_list
;
5535 CODING_GET_INFO (coding
, attrs
, charset_list
);
5536 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5538 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5540 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5541 charset_list
= Viso_2022_charset_list
;
5543 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5545 charset_list
= Vemacs_mule_charset_list
;
5547 return charset_list
;
5551 /* Return raw-text or one of its subsidiaries that has the same
5552 eol_type as CODING-SYSTEM. */
5555 raw_text_coding_system (coding_system
)
5556 Lisp_Object coding_system
;
5558 Lisp_Object spec
, attrs
;
5559 Lisp_Object eol_type
, raw_text_eol_type
;
5561 if (NILP (coding_system
))
5563 spec
= CODING_SYSTEM_SPEC (coding_system
);
5564 attrs
= AREF (spec
, 0);
5566 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5567 return coding_system
;
5569 eol_type
= AREF (spec
, 2);
5570 if (VECTORP (eol_type
))
5572 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5573 raw_text_eol_type
= AREF (spec
, 2);
5574 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5575 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5576 : AREF (raw_text_eol_type
, 2));
5580 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5581 does, return one of the subsidiary that has the same eol-spec as
5582 PARENT. Otherwise, return CODING_SYSTEM. If PARENT is nil,
5583 inherit end-of-line format from the system's setting
5584 (system_eol_type). */
5587 coding_inherit_eol_type (coding_system
, parent
)
5588 Lisp_Object coding_system
, parent
;
5590 Lisp_Object spec
, eol_type
;
5592 if (NILP (coding_system
))
5593 coding_system
= Qraw_text
;
5594 spec
= CODING_SYSTEM_SPEC (coding_system
);
5595 eol_type
= AREF (spec
, 2);
5596 if (VECTORP (eol_type
))
5598 Lisp_Object parent_eol_type
;
5600 if (! NILP (parent
))
5602 Lisp_Object parent_spec
;
5604 parent_spec
= CODING_SYSTEM_SPEC (parent
);
5605 parent_eol_type
= AREF (parent_spec
, 2);
5608 parent_eol_type
= system_eol_type
;
5609 if (EQ (parent_eol_type
, Qunix
))
5610 coding_system
= AREF (eol_type
, 0);
5611 else if (EQ (parent_eol_type
, Qdos
))
5612 coding_system
= AREF (eol_type
, 1);
5613 else if (EQ (parent_eol_type
, Qmac
))
5614 coding_system
= AREF (eol_type
, 2);
5616 return coding_system
;
5619 /* Emacs has a mechanism to automatically detect a coding system if it
5620 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5621 it's impossible to distinguish some coding systems accurately
5622 because they use the same range of codes. So, at first, coding
5623 systems are categorized into 7, those are:
5625 o coding-category-emacs-mule
5627 The category for a coding system which has the same code range
5628 as Emacs' internal format. Assigned the coding-system (Lisp
5629 symbol) `emacs-mule' by default.
5631 o coding-category-sjis
5633 The category for a coding system which has the same code range
5634 as SJIS. Assigned the coding-system (Lisp
5635 symbol) `japanese-shift-jis' by default.
5637 o coding-category-iso-7
5639 The category for a coding system which has the same code range
5640 as ISO2022 of 7-bit environment. This doesn't use any locking
5641 shift and single shift functions. This can encode/decode all
5642 charsets. Assigned the coding-system (Lisp symbol)
5643 `iso-2022-7bit' by default.
5645 o coding-category-iso-7-tight
5647 Same as coding-category-iso-7 except that this can
5648 encode/decode only the specified charsets.
5650 o coding-category-iso-8-1
5652 The category for a coding system which has the same code range
5653 as ISO2022 of 8-bit environment and graphic plane 1 used only
5654 for DIMENSION1 charset. This doesn't use any locking shift
5655 and single shift functions. Assigned the coding-system (Lisp
5656 symbol) `iso-latin-1' by default.
5658 o coding-category-iso-8-2
5660 The category for a coding system which has the same code range
5661 as ISO2022 of 8-bit environment and graphic plane 1 used only
5662 for DIMENSION2 charset. This doesn't use any locking shift
5663 and single shift functions. Assigned the coding-system (Lisp
5664 symbol) `japanese-iso-8bit' by default.
5666 o coding-category-iso-7-else
5668 The category for a coding system which has the same code range
5669 as ISO2022 of 7-bit environemnt but uses locking shift or
5670 single shift functions. Assigned the coding-system (Lisp
5671 symbol) `iso-2022-7bit-lock' by default.
5673 o coding-category-iso-8-else
5675 The category for a coding system which has the same code range
5676 as ISO2022 of 8-bit environemnt but uses locking shift or
5677 single shift functions. Assigned the coding-system (Lisp
5678 symbol) `iso-2022-8bit-ss2' by default.
5680 o coding-category-big5
5682 The category for a coding system which has the same code range
5683 as BIG5. Assigned the coding-system (Lisp symbol)
5684 `cn-big5' by default.
5686 o coding-category-utf-8
5688 The category for a coding system which has the same code range
5689 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
5690 symbol) `utf-8' by default.
5692 o coding-category-utf-16-be
5694 The category for a coding system in which a text has an
5695 Unicode signature (cf. Unicode Standard) in the order of BIG
5696 endian at the head. Assigned the coding-system (Lisp symbol)
5697 `utf-16-be' by default.
5699 o coding-category-utf-16-le
5701 The category for a coding system in which a text has an
5702 Unicode signature (cf. Unicode Standard) in the order of
5703 LITTLE endian at the head. Assigned the coding-system (Lisp
5704 symbol) `utf-16-le' by default.
5706 o coding-category-ccl
5708 The category for a coding system of which encoder/decoder is
5709 written in CCL programs. The default value is nil, i.e., no
5710 coding system is assigned.
5712 o coding-category-binary
5714 The category for a coding system not categorized in any of the
5715 above. Assigned the coding-system (Lisp symbol)
5716 `no-conversion' by default.
5718 Each of them is a Lisp symbol and the value is an actual
5719 `coding-system's (this is also a Lisp symbol) assigned by a user.
5720 What Emacs does actually is to detect a category of coding system.
5721 Then, it uses a `coding-system' assigned to it. If Emacs can't
5722 decide only one possible category, it selects a category of the
5723 highest priority. Priorities of categories are also specified by a
5724 user in a Lisp variable `coding-category-list'.
5728 #define EOL_SEEN_NONE 0
5729 #define EOL_SEEN_LF 1
5730 #define EOL_SEEN_CR 2
5731 #define EOL_SEEN_CRLF 4
5733 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
5734 SOURCE is encoded. If CATEGORY is one of
5735 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5736 two-byte, else they are encoded by one-byte.
5738 Return one of EOL_SEEN_XXX. */
5740 #define MAX_EOL_CHECK_COUNT 3
5743 detect_eol (source
, src_bytes
, category
)
5744 const unsigned char *source
;
5745 EMACS_INT src_bytes
;
5746 enum coding_category category
;
5748 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
5751 int eol_seen
= EOL_SEEN_NONE
;
5753 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
5757 msb
= category
== (coding_category_utf_16_le
5758 | coding_category_utf_16_le_nosig
);
5761 while (src
+ 1 < src_end
)
5764 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
5769 this_eol
= EOL_SEEN_LF
;
5770 else if (src
+ 3 >= src_end
5771 || src
[msb
+ 2] != 0
5772 || src
[lsb
+ 2] != '\n')
5773 this_eol
= EOL_SEEN_CR
;
5775 this_eol
= EOL_SEEN_CRLF
;
5777 if (eol_seen
== EOL_SEEN_NONE
)
5778 /* This is the first end-of-line. */
5779 eol_seen
= this_eol
;
5780 else if (eol_seen
!= this_eol
)
5782 /* The found type is different from what found before. */
5783 eol_seen
= EOL_SEEN_LF
;
5786 if (++total
== MAX_EOL_CHECK_COUNT
)
5794 while (src
< src_end
)
5797 if (c
== '\n' || c
== '\r')
5802 this_eol
= EOL_SEEN_LF
;
5803 else if (src
>= src_end
|| *src
!= '\n')
5804 this_eol
= EOL_SEEN_CR
;
5806 this_eol
= EOL_SEEN_CRLF
, src
++;
5808 if (eol_seen
== EOL_SEEN_NONE
)
5809 /* This is the first end-of-line. */
5810 eol_seen
= this_eol
;
5811 else if (eol_seen
!= this_eol
)
5813 /* The found type is different from what found before. */
5814 eol_seen
= EOL_SEEN_LF
;
5817 if (++total
== MAX_EOL_CHECK_COUNT
)
5827 adjust_coding_eol_type (coding
, eol_seen
)
5828 struct coding_system
*coding
;
5831 Lisp_Object eol_type
;
5833 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5834 if (eol_seen
& EOL_SEEN_LF
)
5836 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
5839 else if (eol_seen
& EOL_SEEN_CRLF
)
5841 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
5844 else if (eol_seen
& EOL_SEEN_CR
)
5846 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
5852 /* Detect how a text specified in CODING is encoded. If a coding
5853 system is detected, update fields of CODING by the detected coding
5857 detect_coding (coding
)
5858 struct coding_system
*coding
;
5860 const unsigned char *src
, *src_end
;
5862 coding
->consumed
= coding
->consumed_char
= 0;
5863 coding
->produced
= coding
->produced_char
= 0;
5864 coding_set_source (coding
);
5866 src_end
= coding
->source
+ coding
->src_bytes
;
5867 coding
->head_ascii
= 0;
5869 /* If we have not yet decided the text encoding type, detect it
5871 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
5874 struct coding_detection_info detect_info
;
5875 int null_byte_found
= 0, eight_bit_found
= 0;
5877 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
5878 for (src
= coding
->source
; src
< src_end
; src
++)
5883 eight_bit_found
= 1;
5884 if (null_byte_found
)
5889 if ((c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
5890 && ! inhibit_iso_escape_detection
5891 && ! detect_info
.checked
)
5893 if (detect_coding_iso_2022 (coding
, &detect_info
))
5895 /* We have scanned the whole data. */
5896 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
5898 /* We didn't find an 8-bit code. We may
5899 have found a null-byte, but it's very
5900 rare that a binary file confirm to
5903 coding
->head_ascii
= src
- coding
->source
;
5905 detect_info
.rejected
|= ~CATEGORY_MASK_ISO_ESCAPE
;
5911 null_byte_found
= 1;
5912 if (eight_bit_found
)
5915 if (! eight_bit_found
)
5916 coding
->head_ascii
++;
5918 else if (! eight_bit_found
)
5919 coding
->head_ascii
++;
5922 if (null_byte_found
|| eight_bit_found
5923 || coding
->head_ascii
< coding
->src_bytes
5924 || detect_info
.found
)
5926 enum coding_category category
;
5927 struct coding_system
*this;
5929 if (coding
->head_ascii
== coding
->src_bytes
)
5930 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
5931 for (i
= 0; i
< coding_category_raw_text
; i
++)
5933 category
= coding_priorities
[i
];
5934 this = coding_categories
+ category
;
5935 if (detect_info
.found
& (1 << category
))
5940 if (null_byte_found
)
5942 detect_info
.checked
|= ~CATEGORY_MASK_UTF_16
;
5943 detect_info
.rejected
|= ~CATEGORY_MASK_UTF_16
;
5945 for (i
= 0; i
< coding_category_raw_text
; i
++)
5947 category
= coding_priorities
[i
];
5948 this = coding_categories
+ category
;
5951 /* No coding system of this category is defined. */
5952 detect_info
.rejected
|= (1 << category
);
5954 else if (category
>= coding_category_raw_text
)
5956 else if (detect_info
.checked
& (1 << category
))
5958 if (detect_info
.found
& (1 << category
))
5961 else if ((*(this->detector
)) (coding
, &detect_info
)
5962 && detect_info
.found
& (1 << category
))
5964 if (category
== coding_category_utf_16_auto
)
5966 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5967 category
= coding_category_utf_16_le
;
5969 category
= coding_category_utf_16_be
;
5976 if (i
< coding_category_raw_text
)
5977 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5978 else if (null_byte_found
)
5979 setup_coding_system (Qno_conversion
, coding
);
5980 else if ((detect_info
.rejected
& CATEGORY_MASK_ANY
)
5981 == CATEGORY_MASK_ANY
)
5982 setup_coding_system (Qraw_text
, coding
);
5983 else if (detect_info
.rejected
)
5984 for (i
= 0; i
< coding_category_raw_text
; i
++)
5985 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
5987 this = coding_categories
+ coding_priorities
[i
];
5988 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5993 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
5994 == coding_category_utf_8_auto
)
5996 Lisp_Object coding_systems
;
5997 struct coding_detection_info detect_info
;
6000 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6001 detect_info
.found
= detect_info
.rejected
= 0;
6002 coding
->head_ascii
= 0;
6003 if (CONSP (coding_systems
)
6004 && detect_coding_utf_8 (coding
, &detect_info
))
6006 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
6007 setup_coding_system (XCAR (coding_systems
), coding
);
6009 setup_coding_system (XCDR (coding_systems
), coding
);
6012 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
6013 == coding_category_utf_16_auto
)
6015 Lisp_Object coding_systems
;
6016 struct coding_detection_info detect_info
;
6019 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_bom
);
6020 detect_info
.found
= detect_info
.rejected
= 0;
6021 coding
->head_ascii
= 0;
6022 if (CONSP (coding_systems
)
6023 && detect_coding_utf_16 (coding
, &detect_info
))
6025 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
6026 setup_coding_system (XCAR (coding_systems
), coding
);
6027 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
6028 setup_coding_system (XCDR (coding_systems
), coding
);
6036 struct coding_system
*coding
;
6038 Lisp_Object eol_type
;
6039 unsigned char *p
, *pbeg
, *pend
;
6041 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6042 if (EQ (eol_type
, Qunix
))
6045 if (NILP (coding
->dst_object
))
6046 pbeg
= coding
->destination
;
6048 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
6049 pend
= pbeg
+ coding
->produced
;
6051 if (VECTORP (eol_type
))
6053 int eol_seen
= EOL_SEEN_NONE
;
6055 for (p
= pbeg
; p
< pend
; p
++)
6058 eol_seen
|= EOL_SEEN_LF
;
6059 else if (*p
== '\r')
6061 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
6063 eol_seen
|= EOL_SEEN_CRLF
;
6067 eol_seen
|= EOL_SEEN_CR
;
6070 if (eol_seen
!= EOL_SEEN_NONE
6071 && eol_seen
!= EOL_SEEN_LF
6072 && eol_seen
!= EOL_SEEN_CRLF
6073 && eol_seen
!= EOL_SEEN_CR
)
6074 eol_seen
= EOL_SEEN_LF
;
6075 if (eol_seen
!= EOL_SEEN_NONE
)
6076 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
6079 if (EQ (eol_type
, Qmac
))
6081 for (p
= pbeg
; p
< pend
; p
++)
6085 else if (EQ (eol_type
, Qdos
))
6089 if (NILP (coding
->dst_object
))
6091 /* Start deleting '\r' from the tail to minimize the memory
6093 for (p
= pend
- 2; p
>= pbeg
; p
--)
6096 safe_bcopy ((char *) (p
+ 1), (char *) p
, pend
-- - p
- 1);
6102 int pos_byte
= coding
->dst_pos_byte
;
6103 int pos
= coding
->dst_pos
;
6104 int pos_end
= pos
+ coding
->produced_char
- 1;
6106 while (pos
< pos_end
)
6108 p
= BYTE_POS_ADDR (pos_byte
);
6109 if (*p
== '\r' && p
[1] == '\n')
6111 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
6116 if (coding
->dst_multibyte
)
6117 pos_byte
+= BYTES_BY_CHAR_HEAD (*p
);
6122 coding
->produced
-= n
;
6123 coding
->produced_char
-= n
;
6128 /* Return a translation table (or list of them) from coding system
6129 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
6130 decoding (ENCODEP is zero). */
6133 get_translation_table (attrs
, encodep
, max_lookup
)
6135 int encodep
, *max_lookup
;
6137 Lisp_Object standard
, translation_table
;
6141 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
6142 standard
= Vstandard_translation_table_for_encode
;
6144 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
6145 standard
= Vstandard_translation_table_for_decode
;
6146 if (NILP (translation_table
))
6147 translation_table
= standard
;
6150 if (SYMBOLP (translation_table
))
6151 translation_table
= Fget (translation_table
, Qtranslation_table
);
6152 else if (CONSP (translation_table
))
6154 translation_table
= Fcopy_sequence (translation_table
);
6155 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
6156 if (SYMBOLP (XCAR (val
)))
6157 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
6159 if (CHAR_TABLE_P (standard
))
6161 if (CONSP (translation_table
))
6162 translation_table
= nconc2 (translation_table
,
6163 Fcons (standard
, Qnil
));
6165 translation_table
= Fcons (translation_table
,
6166 Fcons (standard
, Qnil
));
6173 if (CHAR_TABLE_P (translation_table
)
6174 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
6176 val
= XCHAR_TABLE (translation_table
)->extras
[1];
6177 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
6178 *max_lookup
= XFASTINT (val
);
6180 else if (CONSP (translation_table
))
6182 Lisp_Object tail
, val
;
6184 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
6185 if (CHAR_TABLE_P (XCAR (tail
))
6186 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
6188 val
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
6189 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
6190 *max_lookup
= XFASTINT (val
);
6194 return translation_table
;
6197 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
6200 if (CHAR_TABLE_P (table)) \
6202 trans = CHAR_TABLE_REF (table, c); \
6203 if (CHARACTERP (trans)) \
6204 c = XFASTINT (trans), trans = Qnil; \
6206 else if (CONSP (table)) \
6210 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
6211 if (CHAR_TABLE_P (XCAR (tail))) \
6213 trans = CHAR_TABLE_REF (XCAR (tail), c); \
6214 if (CHARACTERP (trans)) \
6215 c = XFASTINT (trans), trans = Qnil; \
6216 else if (! NILP (trans)) \
6224 get_translation (val
, buf
, buf_end
, last_block
, from_nchars
, to_nchars
)
6228 int *from_nchars
, *to_nchars
;
6230 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
6234 Lisp_Object from
, tail
;
6237 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
6242 for (i
= 0; i
< len
; i
++)
6244 if (buf
+ i
== buf_end
)
6250 if (XINT (AREF (from
, i
)) != buf
[i
])
6264 *buf
= XINT (AREF (val
, 0)), *to_nchars
= ASIZE (val
);
6272 produce_chars (coding
, translation_table
, last_block
)
6273 struct coding_system
*coding
;
6274 Lisp_Object translation_table
;
6277 unsigned char *dst
= coding
->destination
+ coding
->produced
;
6278 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
6280 EMACS_INT produced_chars
= 0;
6283 if (! coding
->chars_at_source
)
6285 /* Source characters are in coding->charbuf. */
6286 int *buf
= coding
->charbuf
;
6287 int *buf_end
= buf
+ coding
->charbuf_used
;
6289 if (EQ (coding
->src_object
, coding
->dst_object
))
6291 coding_set_source (coding
);
6292 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
6295 while (buf
< buf_end
)
6301 int from_nchars
= 1, to_nchars
= 1;
6302 Lisp_Object trans
= Qnil
;
6304 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6307 trans
= get_translation (trans
, buf
, buf_end
, last_block
,
6308 &from_nchars
, &to_nchars
);
6314 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
6316 dst
= alloc_destination (coding
,
6318 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
6320 if (EQ (coding
->src_object
, coding
->dst_object
))
6322 coding_set_source (coding
);
6323 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
6326 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6329 for (i
= 0; i
< to_nchars
; i
++)
6332 c
= XINT (AREF (trans
, i
));
6333 if (coding
->dst_multibyte
6334 || ! CHAR_BYTE8_P (c
))
6335 CHAR_STRING_ADVANCE_NO_UNIFY (c
, dst
);
6337 *dst
++ = CHAR_TO_BYTE8 (c
);
6339 produced_chars
+= to_nchars
;
6341 while (--from_nchars
> 0)
6345 /* This is an annotation datum. (-C) is the length. */
6348 carryover
= buf_end
- buf
;
6352 /* Source characters are at coding->source. */
6353 const unsigned char *src
= coding
->source
;
6354 const unsigned char *src_end
= src
+ coding
->consumed
;
6356 if (EQ (coding
->dst_object
, coding
->src_object
))
6357 dst_end
= (unsigned char *) src
;
6358 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
6360 if (coding
->src_multibyte
)
6363 EMACS_INT consumed_chars
= 0;
6367 const unsigned char *src_base
= src
;
6373 if (EQ (coding
->src_object
, coding
->dst_object
))
6374 dst_end
= (unsigned char *) src
;
6377 EMACS_INT offset
= src
- coding
->source
;
6379 dst
= alloc_destination (coding
, src_end
- src
+ 1,
6381 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6382 coding_set_source (coding
);
6383 src
= coding
->source
+ offset
;
6384 src_end
= coding
->source
+ coding
->src_bytes
;
6385 if (EQ (coding
->src_object
, coding
->dst_object
))
6386 dst_end
= (unsigned char *) src
;
6396 while (src
< src_end
)
6401 if (dst
>= dst_end
- 1)
6403 if (EQ (coding
->src_object
, coding
->dst_object
))
6404 dst_end
= (unsigned char *) src
;
6405 if (dst
>= dst_end
- 1)
6407 EMACS_INT offset
= src
- coding
->source
;
6408 EMACS_INT more_bytes
;
6410 if (EQ (coding
->src_object
, coding
->dst_object
))
6411 more_bytes
= ((src_end
- src
) / 2) + 2;
6413 more_bytes
= src_end
- src
+ 2;
6414 dst
= alloc_destination (coding
, more_bytes
, dst
);
6415 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6416 coding_set_source (coding
);
6417 src
= coding
->source
+ offset
;
6418 src_end
= coding
->source
+ coding
->src_bytes
;
6419 if (EQ (coding
->src_object
, coding
->dst_object
))
6420 dst_end
= (unsigned char *) src
;
6428 if (!EQ (coding
->src_object
, coding
->dst_object
))
6430 EMACS_INT require
= coding
->src_bytes
- coding
->dst_bytes
;
6434 EMACS_INT offset
= src
- coding
->source
;
6436 dst
= alloc_destination (coding
, require
, dst
);
6437 coding_set_source (coding
);
6438 src
= coding
->source
+ offset
;
6439 src_end
= coding
->source
+ coding
->src_bytes
;
6442 produced_chars
= coding
->consumed_char
;
6443 while (src
< src_end
)
6448 produced
= dst
- (coding
->destination
+ coding
->produced
);
6449 if (BUFFERP (coding
->dst_object
) && produced_chars
> 0)
6450 insert_from_gap (produced_chars
, produced
);
6451 coding
->produced
+= produced
;
6452 coding
->produced_char
+= produced_chars
;
6456 /* Compose text in CODING->object according to the annotation data at
6457 CHARBUF. CHARBUF is an array:
6458 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
6462 produce_composition (coding
, charbuf
, pos
)
6463 struct coding_system
*coding
;
6469 enum composition_method method
;
6470 Lisp_Object components
;
6473 to
= pos
+ charbuf
[2];
6476 method
= (enum composition_method
) (charbuf
[3]);
6478 if (method
== COMPOSITION_RELATIVE
)
6480 else if (method
>= COMPOSITION_WITH_RULE
6481 && method
<= COMPOSITION_WITH_RULE_ALTCHARS
)
6483 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6488 for (i
= 0; i
< len
; i
++)
6490 args
[i
] = make_number (charbuf
[i
]);
6494 components
= (method
== COMPOSITION_WITH_ALTCHARS
6495 ? Fstring (len
, args
) : Fvector (len
, args
));
6499 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6503 /* Put `charset' property on text in CODING->object according to
6504 the annotation data at CHARBUF. CHARBUF is an array:
6505 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6509 produce_charset (coding
, charbuf
, pos
)
6510 struct coding_system
*coding
;
6514 EMACS_INT from
= pos
- charbuf
[2];
6515 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6517 Fput_text_property (make_number (from
), make_number (pos
),
6518 Qcharset
, CHARSET_NAME (charset
),
6519 coding
->dst_object
);
6523 #define CHARBUF_SIZE 0x4000
6525 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6527 int size = CHARBUF_SIZE;; \
6529 coding->charbuf = NULL; \
6530 while (size > 1024) \
6532 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6533 if (coding->charbuf) \
6537 if (! coding->charbuf) \
6539 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6540 return coding->result; \
6542 coding->charbuf_size = size; \
6547 produce_annotation (coding
, pos
)
6548 struct coding_system
*coding
;
6551 int *charbuf
= coding
->charbuf
;
6552 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6554 if (NILP (coding
->dst_object
))
6557 while (charbuf
< charbuf_end
)
6563 int len
= -*charbuf
;
6566 case CODING_ANNOTATE_COMPOSITION_MASK
:
6567 produce_composition (coding
, charbuf
, pos
);
6569 case CODING_ANNOTATE_CHARSET_MASK
:
6570 produce_charset (coding
, charbuf
, pos
);
6580 /* Decode the data at CODING->src_object into CODING->dst_object.
6581 CODING->src_object is a buffer, a string, or nil.
6582 CODING->dst_object is a buffer.
6584 If CODING->src_object is a buffer, it must be the current buffer.
6585 In this case, if CODING->src_pos is positive, it is a position of
6586 the source text in the buffer, otherwise, the source text is in the
6587 gap area of the buffer, and CODING->src_pos specifies the offset of
6588 the text from GPT (which must be the same as PT). If this is the
6589 same buffer as CODING->dst_object, CODING->src_pos must be
6592 If CODING->src_object is a string, CODING->src_pos is an index to
6595 If CODING->src_object is nil, CODING->source must already point to
6596 the non-relocatable memory area. In this case, CODING->src_pos is
6597 an offset from CODING->source.
6599 The decoded data is inserted at the current point of the buffer
6604 decode_coding (coding
)
6605 struct coding_system
*coding
;
6608 Lisp_Object undo_list
;
6609 Lisp_Object translation_table
;
6613 if (BUFFERP (coding
->src_object
)
6614 && coding
->src_pos
> 0
6615 && coding
->src_pos
< GPT
6616 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6617 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6620 if (BUFFERP (coding
->dst_object
))
6622 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6623 set_buffer_internal (XBUFFER (coding
->dst_object
));
6625 move_gap_both (PT
, PT_BYTE
);
6626 undo_list
= current_buffer
->undo_list
;
6627 current_buffer
->undo_list
= Qt
;
6630 coding
->consumed
= coding
->consumed_char
= 0;
6631 coding
->produced
= coding
->produced_char
= 0;
6632 coding
->chars_at_source
= 0;
6633 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6636 ALLOC_CONVERSION_WORK_AREA (coding
);
6638 attrs
= CODING_ID_ATTRS (coding
->id
);
6639 translation_table
= get_translation_table (attrs
, 0, NULL
);
6644 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
6646 coding_set_source (coding
);
6647 coding
->annotated
= 0;
6648 coding
->charbuf_used
= carryover
;
6649 (*(coding
->decoder
)) (coding
);
6650 coding_set_destination (coding
);
6651 carryover
= produce_chars (coding
, translation_table
, 0);
6652 if (coding
->annotated
)
6653 produce_annotation (coding
, pos
);
6654 for (i
= 0; i
< carryover
; i
++)
6656 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
6658 while (coding
->consumed
< coding
->src_bytes
6659 && (coding
->result
== CODING_RESULT_SUCCESS
6660 || coding
->result
== CODING_RESULT_INVALID_SRC
));
6664 coding_set_destination (coding
);
6665 coding
->charbuf_used
= carryover
;
6666 produce_chars (coding
, translation_table
, 1);
6669 coding
->carryover_bytes
= 0;
6670 if (coding
->consumed
< coding
->src_bytes
)
6672 int nbytes
= coding
->src_bytes
- coding
->consumed
;
6673 const unsigned char *src
;
6675 coding_set_source (coding
);
6676 coding_set_destination (coding
);
6677 src
= coding
->source
+ coding
->consumed
;
6679 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
6681 /* Flush out unprocessed data as binary chars. We are sure
6682 that the number of data is less than the size of
6684 coding
->charbuf_used
= 0;
6685 coding
->chars_at_source
= 0;
6687 while (nbytes
-- > 0)
6692 c
= BYTE8_TO_CHAR (c
);
6693 coding
->charbuf
[coding
->charbuf_used
++] = c
;
6695 produce_chars (coding
, Qnil
, 1);
6699 /* Record unprocessed bytes in coding->carryover. We are
6700 sure that the number of data is less than the size of
6701 coding->carryover. */
6702 unsigned char *p
= coding
->carryover
;
6704 coding
->carryover_bytes
= nbytes
;
6705 while (nbytes
-- > 0)
6708 coding
->consumed
= coding
->src_bytes
;
6711 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
))
6712 decode_eol (coding
);
6713 if (BUFFERP (coding
->dst_object
))
6715 current_buffer
->undo_list
= undo_list
;
6716 record_insert (coding
->dst_pos
, coding
->produced_char
);
6718 return coding
->result
;
6722 /* Extract an annotation datum from a composition starting at POS and
6723 ending before LIMIT of CODING->src_object (buffer or string), store
6724 the data in BUF, set *STOP to a starting position of the next
6725 composition (if any) or to LIMIT, and return the address of the
6726 next element of BUF.
6728 If such an annotation is not found, set *STOP to a starting
6729 position of a composition after POS (if any) or to LIMIT, and
6733 handle_composition_annotation (pos
, limit
, coding
, buf
, stop
)
6734 EMACS_INT pos
, limit
;
6735 struct coding_system
*coding
;
6739 EMACS_INT start
, end
;
6742 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
6745 else if (start
> pos
)
6751 /* We found a composition. Store the corresponding
6752 annotation data in BUF. */
6754 enum composition_method method
= COMPOSITION_METHOD (prop
);
6755 int nchars
= COMPOSITION_LENGTH (prop
);
6757 ADD_COMPOSITION_DATA (buf
, nchars
, method
);
6758 if (method
!= COMPOSITION_RELATIVE
)
6760 Lisp_Object components
;
6763 components
= COMPOSITION_COMPONENTS (prop
);
6764 if (VECTORP (components
))
6766 len
= XVECTOR (components
)->size
;
6767 for (i
= 0; i
< len
; i
++)
6768 *buf
++ = XINT (AREF (components
, i
));
6770 else if (STRINGP (components
))
6772 len
= SCHARS (components
);
6776 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
6780 else if (INTEGERP (components
))
6783 *buf
++ = XINT (components
);
6785 else if (CONSP (components
))
6787 for (len
= 0; CONSP (components
);
6788 len
++, components
= XCDR (components
))
6789 *buf
++ = XINT (XCAR (components
));
6797 if (find_composition (end
, limit
, &start
, &end
, &prop
,
6808 /* Extract an annotation datum from a text property `charset' at POS of
6809 CODING->src_object (buffer of string), store the data in BUF, set
6810 *STOP to the position where the value of `charset' property changes
6811 (limiting by LIMIT), and return the address of the next element of
6814 If the property value is nil, set *STOP to the position where the
6815 property value is non-nil (limiting by LIMIT), and return BUF. */
6818 handle_charset_annotation (pos
, limit
, coding
, buf
, stop
)
6819 EMACS_INT pos
, limit
;
6820 struct coding_system
*coding
;
6824 Lisp_Object val
, next
;
6827 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
6828 if (! NILP (val
) && CHARSETP (val
))
6829 id
= XINT (CHARSET_SYMBOL_ID (val
));
6832 ADD_CHARSET_DATA (buf
, 0, id
);
6833 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
6835 make_number (limit
));
6836 *stop
= XINT (next
);
6842 consume_chars (coding
, translation_table
, max_lookup
)
6843 struct coding_system
*coding
;
6844 Lisp_Object translation_table
;
6847 int *buf
= coding
->charbuf
;
6848 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
6849 const unsigned char *src
= coding
->source
+ coding
->consumed
;
6850 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
6851 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
6852 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
6853 int multibytep
= coding
->src_multibyte
;
6854 Lisp_Object eol_type
;
6856 EMACS_INT stop
, stop_composition
, stop_charset
;
6857 int *lookup_buf
= NULL
;
6859 if (! NILP (translation_table
))
6860 lookup_buf
= alloca (sizeof (int) * max_lookup
);
6862 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6863 if (VECTORP (eol_type
))
6866 /* Note: composition handling is not yet implemented. */
6867 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
6869 if (NILP (coding
->src_object
))
6870 stop
= stop_composition
= stop_charset
= end_pos
;
6873 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
6874 stop
= stop_composition
= pos
;
6876 stop
= stop_composition
= end_pos
;
6877 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
6878 stop
= stop_charset
= pos
;
6880 stop_charset
= end_pos
;
6883 /* Compensate for CRLF and conversion. */
6884 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
6885 while (buf
< buf_end
)
6893 if (pos
== stop_composition
)
6894 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
6895 buf
, &stop_composition
);
6896 if (pos
== stop_charset
)
6897 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
6898 buf
, &stop_charset
);
6899 stop
= (stop_composition
< stop_charset
6900 ? stop_composition
: stop_charset
);
6907 if (coding
->encoder
== encode_coding_raw_text
)
6909 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
6910 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
+= bytes
;
6912 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
6915 c
= STRING_CHAR_ADVANCE_NO_UNIFY (src
), pos
++;
6916 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
6918 if (! EQ (eol_type
, Qunix
))
6922 if (EQ (eol_type
, Qdos
))
6930 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6935 int from_nchars
= 1, to_nchars
= 1;
6936 int *lookup_buf_end
;
6937 const unsigned char *p
= src
;
6941 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
6942 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
6943 lookup_buf_end
= lookup_buf
+ i
;
6944 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
, 1,
6945 &from_nchars
, &to_nchars
);
6947 || buf
+ to_nchars
> buf_end
)
6949 *buf
++ = *lookup_buf
;
6950 for (i
= 1; i
< to_nchars
; i
++)
6951 *buf
++ = XINT (AREF (trans
, i
));
6952 for (i
= 1; i
< from_nchars
; i
++, pos
++)
6953 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
6957 coding
->consumed
= src
- coding
->source
;
6958 coding
->consumed_char
= pos
- coding
->src_pos
;
6959 coding
->charbuf_used
= buf
- coding
->charbuf
;
6960 coding
->chars_at_source
= 0;
6964 /* Encode the text at CODING->src_object into CODING->dst_object.
6965 CODING->src_object is a buffer or a string.
6966 CODING->dst_object is a buffer or nil.
6968 If CODING->src_object is a buffer, it must be the current buffer.
6969 In this case, if CODING->src_pos is positive, it is a position of
6970 the source text in the buffer, otherwise. the source text is in the
6971 gap area of the buffer, and coding->src_pos specifies the offset of
6972 the text from GPT (which must be the same as PT). If this is the
6973 same buffer as CODING->dst_object, CODING->src_pos must be
6974 negative and CODING should not have `pre-write-conversion'.
6976 If CODING->src_object is a string, CODING should not have
6977 `pre-write-conversion'.
6979 If CODING->dst_object is a buffer, the encoded data is inserted at
6980 the current point of that buffer.
6982 If CODING->dst_object is nil, the encoded data is placed at the
6983 memory area specified by CODING->destination. */
6986 encode_coding (coding
)
6987 struct coding_system
*coding
;
6990 Lisp_Object translation_table
;
6993 attrs
= CODING_ID_ATTRS (coding
->id
);
6994 if (coding
->encoder
== encode_coding_raw_text
)
6995 translation_table
= Qnil
, max_lookup
= 0;
6997 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
6999 if (BUFFERP (coding
->dst_object
))
7001 set_buffer_internal (XBUFFER (coding
->dst_object
));
7002 coding
->dst_multibyte
7003 = ! NILP (current_buffer
->enable_multibyte_characters
);
7006 coding
->consumed
= coding
->consumed_char
= 0;
7007 coding
->produced
= coding
->produced_char
= 0;
7008 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
7011 ALLOC_CONVERSION_WORK_AREA (coding
);
7014 coding_set_source (coding
);
7015 consume_chars (coding
, translation_table
, max_lookup
);
7016 coding_set_destination (coding
);
7017 (*(coding
->encoder
)) (coding
);
7018 } while (coding
->consumed_char
< coding
->src_chars
);
7020 if (BUFFERP (coding
->dst_object
) && coding
->produced_char
> 0)
7021 insert_from_gap (coding
->produced_char
, coding
->produced
);
7023 return (coding
->result
);
7027 /* Name (or base name) of work buffer for code conversion. */
7028 static Lisp_Object Vcode_conversion_workbuf_name
;
7030 /* A working buffer used by the top level conversion. Once it is
7031 created, it is never destroyed. It has the name
7032 Vcode_conversion_workbuf_name. The other working buffers are
7033 destroyed after the use is finished, and their names are modified
7034 versions of Vcode_conversion_workbuf_name. */
7035 static Lisp_Object Vcode_conversion_reused_workbuf
;
7037 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
7038 static int reused_workbuf_in_use
;
7041 /* Return a working buffer of code convesion. MULTIBYTE specifies the
7042 multibyteness of returning buffer. */
7045 make_conversion_work_buffer (multibyte
)
7048 Lisp_Object name
, workbuf
;
7049 struct buffer
*current
;
7051 if (reused_workbuf_in_use
++)
7053 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
7054 workbuf
= Fget_buffer_create (name
);
7058 if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf
)))
7059 Vcode_conversion_reused_workbuf
7060 = Fget_buffer_create (Vcode_conversion_workbuf_name
);
7061 workbuf
= Vcode_conversion_reused_workbuf
;
7063 current
= current_buffer
;
7064 set_buffer_internal (XBUFFER (workbuf
));
7065 /* We can't allow modification hooks to run in the work buffer. For
7066 instance, directory_files_internal assumes that file decoding
7067 doesn't compile new regexps. */
7068 Fset (Fmake_local_variable (Qinhibit_modification_hooks
), Qt
);
7070 current_buffer
->undo_list
= Qt
;
7071 current_buffer
->enable_multibyte_characters
= multibyte
? Qt
: Qnil
;
7072 set_buffer_internal (current
);
7078 code_conversion_restore (arg
)
7081 Lisp_Object current
, workbuf
;
7082 struct gcpro gcpro1
;
7085 current
= XCAR (arg
);
7086 workbuf
= XCDR (arg
);
7087 if (! NILP (workbuf
))
7089 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
7090 reused_workbuf_in_use
= 0;
7091 else if (! NILP (Fbuffer_live_p (workbuf
)))
7092 Fkill_buffer (workbuf
);
7094 set_buffer_internal (XBUFFER (current
));
7100 code_conversion_save (with_work_buf
, multibyte
)
7101 int with_work_buf
, multibyte
;
7103 Lisp_Object workbuf
= Qnil
;
7106 workbuf
= make_conversion_work_buffer (multibyte
);
7107 record_unwind_protect (code_conversion_restore
,
7108 Fcons (Fcurrent_buffer (), workbuf
));
7113 decode_coding_gap (coding
, chars
, bytes
)
7114 struct coding_system
*coding
;
7115 EMACS_INT chars
, bytes
;
7117 int count
= specpdl_ptr
- specpdl
;
7120 code_conversion_save (0, 0);
7122 coding
->src_object
= Fcurrent_buffer ();
7123 coding
->src_chars
= chars
;
7124 coding
->src_bytes
= bytes
;
7125 coding
->src_pos
= -chars
;
7126 coding
->src_pos_byte
= -bytes
;
7127 coding
->src_multibyte
= chars
< bytes
;
7128 coding
->dst_object
= coding
->src_object
;
7129 coding
->dst_pos
= PT
;
7130 coding
->dst_pos_byte
= PT_BYTE
;
7131 coding
->dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
7133 if (CODING_REQUIRE_DETECTION (coding
))
7134 detect_coding (coding
);
7136 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
7137 current_buffer
->text
->inhibit_shrinking
= 1;
7138 decode_coding (coding
);
7139 current_buffer
->text
->inhibit_shrinking
= 0;
7141 attrs
= CODING_ID_ATTRS (coding
->id
);
7142 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7144 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7147 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7148 val
= call1 (CODING_ATTR_POST_READ (attrs
),
7149 make_number (coding
->produced_char
));
7151 coding
->produced_char
+= Z
- prev_Z
;
7152 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7155 unbind_to (count
, Qnil
);
7156 return coding
->result
;
7160 encode_coding_gap (coding
, chars
, bytes
)
7161 struct coding_system
*coding
;
7162 EMACS_INT chars
, bytes
;
7164 int count
= specpdl_ptr
- specpdl
;
7166 code_conversion_save (0, 0);
7168 coding
->src_object
= Fcurrent_buffer ();
7169 coding
->src_chars
= chars
;
7170 coding
->src_bytes
= bytes
;
7171 coding
->src_pos
= -chars
;
7172 coding
->src_pos_byte
= -bytes
;
7173 coding
->src_multibyte
= chars
< bytes
;
7174 coding
->dst_object
= coding
->src_object
;
7175 coding
->dst_pos
= PT
;
7176 coding
->dst_pos_byte
= PT_BYTE
;
7178 encode_coding (coding
);
7180 unbind_to (count
, Qnil
);
7181 return coding
->result
;
7185 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
7186 SRC_OBJECT into DST_OBJECT by coding context CODING.
7188 SRC_OBJECT is a buffer, a string, or Qnil.
7190 If it is a buffer, the text is at point of the buffer. FROM and TO
7191 are positions in the buffer.
7193 If it is a string, the text is at the beginning of the string.
7194 FROM and TO are indices to the string.
7196 If it is nil, the text is at coding->source. FROM and TO are
7197 indices to coding->source.
7199 DST_OBJECT is a buffer, Qt, or Qnil.
7201 If it is a buffer, the decoded text is inserted at point of the
7202 buffer. If the buffer is the same as SRC_OBJECT, the source text
7205 If it is Qt, a string is made from the decoded text, and
7206 set in CODING->dst_object.
7208 If it is Qnil, the decoded text is stored at CODING->destination.
7209 The caller must allocate CODING->dst_bytes bytes at
7210 CODING->destination by xmalloc. If the decoded text is longer than
7211 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
7215 decode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
7217 struct coding_system
*coding
;
7218 Lisp_Object src_object
;
7219 EMACS_INT from
, from_byte
, to
, to_byte
;
7220 Lisp_Object dst_object
;
7222 int count
= specpdl_ptr
- specpdl
;
7223 unsigned char *destination
;
7224 EMACS_INT dst_bytes
;
7225 EMACS_INT chars
= to
- from
;
7226 EMACS_INT bytes
= to_byte
- from_byte
;
7228 int saved_pt
= -1, saved_pt_byte
;
7229 int need_marker_adjustment
= 0;
7230 Lisp_Object old_deactivate_mark
;
7232 old_deactivate_mark
= Vdeactivate_mark
;
7234 if (NILP (dst_object
))
7236 destination
= coding
->destination
;
7237 dst_bytes
= coding
->dst_bytes
;
7240 coding
->src_object
= src_object
;
7241 coding
->src_chars
= chars
;
7242 coding
->src_bytes
= bytes
;
7243 coding
->src_multibyte
= chars
< bytes
;
7245 if (STRINGP (src_object
))
7247 coding
->src_pos
= from
;
7248 coding
->src_pos_byte
= from_byte
;
7250 else if (BUFFERP (src_object
))
7252 set_buffer_internal (XBUFFER (src_object
));
7254 move_gap_both (from
, from_byte
);
7255 if (EQ (src_object
, dst_object
))
7257 struct Lisp_Marker
*tail
;
7259 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7261 tail
->need_adjustment
7262 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7263 need_marker_adjustment
|= tail
->need_adjustment
;
7265 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7266 TEMP_SET_PT_BOTH (from
, from_byte
);
7267 current_buffer
->text
->inhibit_shrinking
= 1;
7268 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7269 coding
->src_pos
= -chars
;
7270 coding
->src_pos_byte
= -bytes
;
7274 coding
->src_pos
= from
;
7275 coding
->src_pos_byte
= from_byte
;
7279 if (CODING_REQUIRE_DETECTION (coding
))
7280 detect_coding (coding
);
7281 attrs
= CODING_ID_ATTRS (coding
->id
);
7283 if (EQ (dst_object
, Qt
)
7284 || (! NILP (CODING_ATTR_POST_READ (attrs
))
7285 && NILP (dst_object
)))
7287 coding
->dst_multibyte
= !CODING_FOR_UNIBYTE (coding
);
7288 coding
->dst_object
= code_conversion_save (1, coding
->dst_multibyte
);
7289 coding
->dst_pos
= BEG
;
7290 coding
->dst_pos_byte
= BEG_BYTE
;
7292 else if (BUFFERP (dst_object
))
7294 code_conversion_save (0, 0);
7295 coding
->dst_object
= dst_object
;
7296 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
7297 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
7298 coding
->dst_multibyte
7299 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
7303 code_conversion_save (0, 0);
7304 coding
->dst_object
= Qnil
;
7305 /* Most callers presume this will return a multibyte result, and they
7306 won't use `binary' or `raw-text' anyway, so let's not worry about
7307 CODING_FOR_UNIBYTE. */
7308 coding
->dst_multibyte
= 1;
7311 decode_coding (coding
);
7313 if (BUFFERP (coding
->dst_object
))
7314 set_buffer_internal (XBUFFER (coding
->dst_object
));
7316 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
7318 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7319 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
7322 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
7323 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7324 old_deactivate_mark
);
7325 val
= safe_call1 (CODING_ATTR_POST_READ (attrs
),
7326 make_number (coding
->produced_char
));
7329 coding
->produced_char
+= Z
- prev_Z
;
7330 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
7333 if (EQ (dst_object
, Qt
))
7335 coding
->dst_object
= Fbuffer_string ();
7337 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
7339 set_buffer_internal (XBUFFER (coding
->dst_object
));
7340 if (dst_bytes
< coding
->produced
)
7342 destination
= xrealloc (destination
, coding
->produced
);
7345 record_conversion_result (coding
,
7346 CODING_RESULT_INSUFFICIENT_DST
);
7347 unbind_to (count
, Qnil
);
7350 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
7351 move_gap_both (BEGV
, BEGV_BYTE
);
7352 bcopy (BEGV_ADDR
, destination
, coding
->produced
);
7353 coding
->destination
= destination
;
7359 /* This is the case of:
7360 (BUFFERP (src_object) && EQ (src_object, dst_object))
7361 As we have moved PT while replacing the original buffer
7362 contents, we must recover it now. */
7363 set_buffer_internal (XBUFFER (src_object
));
7364 current_buffer
->text
->inhibit_shrinking
= 0;
7365 if (saved_pt
< from
)
7366 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7367 else if (saved_pt
< from
+ chars
)
7368 TEMP_SET_PT_BOTH (from
, from_byte
);
7369 else if (! NILP (current_buffer
->enable_multibyte_characters
))
7370 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7371 saved_pt_byte
+ (coding
->produced
- bytes
));
7373 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7374 saved_pt_byte
+ (coding
->produced
- bytes
));
7376 if (need_marker_adjustment
)
7378 struct Lisp_Marker
*tail
;
7380 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7381 if (tail
->need_adjustment
)
7383 tail
->need_adjustment
= 0;
7384 if (tail
->insertion_type
)
7386 tail
->bytepos
= from_byte
;
7387 tail
->charpos
= from
;
7391 tail
->bytepos
= from_byte
+ coding
->produced
;
7393 = (NILP (current_buffer
->enable_multibyte_characters
)
7394 ? tail
->bytepos
: from
+ coding
->produced_char
);
7400 Vdeactivate_mark
= old_deactivate_mark
;
7401 unbind_to (count
, coding
->dst_object
);
7406 encode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
7408 struct coding_system
*coding
;
7409 Lisp_Object src_object
;
7410 EMACS_INT from
, from_byte
, to
, to_byte
;
7411 Lisp_Object dst_object
;
7413 int count
= specpdl_ptr
- specpdl
;
7414 EMACS_INT chars
= to
- from
;
7415 EMACS_INT bytes
= to_byte
- from_byte
;
7417 int saved_pt
= -1, saved_pt_byte
;
7418 int need_marker_adjustment
= 0;
7419 int kill_src_buffer
= 0;
7420 Lisp_Object old_deactivate_mark
;
7422 old_deactivate_mark
= Vdeactivate_mark
;
7424 coding
->src_object
= src_object
;
7425 coding
->src_chars
= chars
;
7426 coding
->src_bytes
= bytes
;
7427 coding
->src_multibyte
= chars
< bytes
;
7429 attrs
= CODING_ID_ATTRS (coding
->id
);
7431 if (EQ (src_object
, dst_object
))
7433 struct Lisp_Marker
*tail
;
7435 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7437 tail
->need_adjustment
7438 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7439 need_marker_adjustment
|= tail
->need_adjustment
;
7443 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
7445 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
7446 set_buffer_internal (XBUFFER (coding
->src_object
));
7447 if (STRINGP (src_object
))
7448 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
7449 else if (BUFFERP (src_object
))
7450 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
7452 insert_1_both (coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
7454 if (EQ (src_object
, dst_object
))
7456 set_buffer_internal (XBUFFER (src_object
));
7457 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7458 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7459 set_buffer_internal (XBUFFER (coding
->src_object
));
7463 Lisp_Object args
[3];
7464 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
7466 GCPRO5 (coding
->src_object
, coding
->dst_object
, src_object
, dst_object
,
7467 old_deactivate_mark
);
7468 args
[0] = CODING_ATTR_PRE_WRITE (attrs
);
7469 args
[1] = make_number (BEG
);
7470 args
[2] = make_number (Z
);
7471 safe_call (3, args
);
7474 if (XBUFFER (coding
->src_object
) != current_buffer
)
7475 kill_src_buffer
= 1;
7476 coding
->src_object
= Fcurrent_buffer ();
7478 move_gap_both (BEG
, BEG_BYTE
);
7479 coding
->src_chars
= Z
- BEG
;
7480 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
7481 coding
->src_pos
= BEG
;
7482 coding
->src_pos_byte
= BEG_BYTE
;
7483 coding
->src_multibyte
= Z
< Z_BYTE
;
7485 else if (STRINGP (src_object
))
7487 code_conversion_save (0, 0);
7488 coding
->src_pos
= from
;
7489 coding
->src_pos_byte
= from_byte
;
7491 else if (BUFFERP (src_object
))
7493 code_conversion_save (0, 0);
7494 set_buffer_internal (XBUFFER (src_object
));
7495 if (EQ (src_object
, dst_object
))
7497 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7498 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
7499 coding
->src_pos
= 0;
7500 coding
->src_pos_byte
= 0;
7504 if (from
< GPT
&& to
>= GPT
)
7505 move_gap_both (from
, from_byte
);
7506 coding
->src_pos
= from
;
7507 coding
->src_pos_byte
= from_byte
;
7511 code_conversion_save (0, 0);
7513 if (BUFFERP (dst_object
))
7515 coding
->dst_object
= dst_object
;
7516 if (EQ (src_object
, dst_object
))
7518 coding
->dst_pos
= from
;
7519 coding
->dst_pos_byte
= from_byte
;
7523 struct buffer
*current
= current_buffer
;
7525 set_buffer_temp (XBUFFER (dst_object
));
7526 coding
->dst_pos
= PT
;
7527 coding
->dst_pos_byte
= PT_BYTE
;
7528 move_gap_both (coding
->dst_pos
, coding
->dst_pos_byte
);
7529 set_buffer_temp (current
);
7531 coding
->dst_multibyte
7532 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
7534 else if (EQ (dst_object
, Qt
))
7536 coding
->dst_object
= Qnil
;
7537 coding
->dst_bytes
= coding
->src_chars
;
7538 if (coding
->dst_bytes
== 0)
7539 coding
->dst_bytes
= 1;
7540 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
7541 coding
->dst_multibyte
= 0;
7545 coding
->dst_object
= Qnil
;
7546 coding
->dst_multibyte
= 0;
7549 encode_coding (coding
);
7551 if (EQ (dst_object
, Qt
))
7553 if (BUFFERP (coding
->dst_object
))
7554 coding
->dst_object
= Fbuffer_string ();
7558 = make_unibyte_string ((char *) coding
->destination
,
7560 xfree (coding
->destination
);
7566 /* This is the case of:
7567 (BUFFERP (src_object) && EQ (src_object, dst_object))
7568 As we have moved PT while replacing the original buffer
7569 contents, we must recover it now. */
7570 set_buffer_internal (XBUFFER (src_object
));
7571 if (saved_pt
< from
)
7572 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7573 else if (saved_pt
< from
+ chars
)
7574 TEMP_SET_PT_BOTH (from
, from_byte
);
7575 else if (! NILP (current_buffer
->enable_multibyte_characters
))
7576 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7577 saved_pt_byte
+ (coding
->produced
- bytes
));
7579 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7580 saved_pt_byte
+ (coding
->produced
- bytes
));
7582 if (need_marker_adjustment
)
7584 struct Lisp_Marker
*tail
;
7586 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7587 if (tail
->need_adjustment
)
7589 tail
->need_adjustment
= 0;
7590 if (tail
->insertion_type
)
7592 tail
->bytepos
= from_byte
;
7593 tail
->charpos
= from
;
7597 tail
->bytepos
= from_byte
+ coding
->produced
;
7599 = (NILP (current_buffer
->enable_multibyte_characters
)
7600 ? tail
->bytepos
: from
+ coding
->produced_char
);
7606 if (kill_src_buffer
)
7607 Fkill_buffer (coding
->src_object
);
7609 Vdeactivate_mark
= old_deactivate_mark
;
7610 unbind_to (count
, Qnil
);
7615 preferred_coding_system ()
7617 int id
= coding_categories
[coding_priorities
[0]].id
;
7619 return CODING_ID_NAME (id
);
7624 /*** 8. Emacs Lisp library functions ***/
7626 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7627 doc
: /* Return t if OBJECT is nil or a coding-system.
7628 See the documentation of `define-coding-system' for information
7629 about coding-system objects. */)
7634 || CODING_SYSTEM_ID (object
) >= 0)
7636 if (! SYMBOLP (object
)
7637 || NILP (Fget (object
, Qcoding_system_define_form
)))
7642 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7643 Sread_non_nil_coding_system
, 1, 1, 0,
7644 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7651 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7652 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
7654 while (SCHARS (val
) == 0);
7655 return (Fintern (val
, Qnil
));
7658 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
7659 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
7660 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
7661 Ignores case when completing coding systems (all Emacs coding systems
7662 are lower-case). */)
7663 (prompt
, default_coding_system
)
7664 Lisp_Object prompt
, default_coding_system
;
7667 int count
= SPECPDL_INDEX ();
7669 if (SYMBOLP (default_coding_system
))
7670 default_coding_system
= SYMBOL_NAME (default_coding_system
);
7671 specbind (Qcompletion_ignore_case
, Qt
);
7672 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7673 Qt
, Qnil
, Qcoding_system_history
,
7674 default_coding_system
, Qnil
);
7675 unbind_to (count
, Qnil
);
7676 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
7679 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
7681 doc
: /* Check validity of CODING-SYSTEM.
7682 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7683 It is valid if it is nil or a symbol defined as a coding system by the
7684 function `define-coding-system'. */)
7686 Lisp_Object coding_system
;
7688 Lisp_Object define_form
;
7690 define_form
= Fget (coding_system
, Qcoding_system_define_form
);
7691 if (! NILP (define_form
))
7693 Fput (coding_system
, Qcoding_system_define_form
, Qnil
);
7694 safe_eval (define_form
);
7696 if (!NILP (Fcoding_system_p (coding_system
)))
7697 return coding_system
;
7698 xsignal1 (Qcoding_system_error
, coding_system
);
7702 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7703 HIGHEST is nonzero, return the coding system of the highest
7704 priority among the detected coding systems. Otherwize return a
7705 list of detected coding systems sorted by their priorities. If
7706 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7707 multibyte form but contains only ASCII and eight-bit chars.
7708 Otherwise, the bytes are raw bytes.
7710 CODING-SYSTEM controls the detection as below:
7712 If it is nil, detect both text-format and eol-format. If the
7713 text-format part of CODING-SYSTEM is already specified
7714 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7715 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7716 detect only text-format. */
7719 detect_coding_system (src
, src_chars
, src_bytes
, highest
, multibytep
,
7721 const unsigned char *src
;
7722 EMACS_INT src_chars
, src_bytes
;
7725 Lisp_Object coding_system
;
7727 const unsigned char *src_end
= src
+ src_bytes
;
7728 Lisp_Object attrs
, eol_type
;
7729 Lisp_Object val
= Qnil
;
7730 struct coding_system coding
;
7732 struct coding_detection_info detect_info
;
7733 enum coding_category base_category
;
7734 int null_byte_found
= 0, eight_bit_found
= 0;
7736 if (NILP (coding_system
))
7737 coding_system
= Qundecided
;
7738 setup_coding_system (coding_system
, &coding
);
7739 attrs
= CODING_ID_ATTRS (coding
.id
);
7740 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
7741 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
7743 coding
.source
= src
;
7744 coding
.src_chars
= src_chars
;
7745 coding
.src_bytes
= src_bytes
;
7746 coding
.src_multibyte
= multibytep
;
7747 coding
.consumed
= 0;
7748 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7749 coding
.head_ascii
= 0;
7751 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
7753 /* At first, detect text-format if necessary. */
7754 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7755 if (base_category
== coding_category_undecided
)
7757 enum coding_category category
;
7758 struct coding_system
*this;
7761 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7762 for (; src
< src_end
; src
++)
7767 eight_bit_found
= 1;
7768 if (null_byte_found
)
7773 if ((c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
7774 && ! inhibit_iso_escape_detection
7775 && ! detect_info
.checked
)
7777 if (detect_coding_iso_2022 (&coding
, &detect_info
))
7779 /* We have scanned the whole data. */
7780 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
7782 /* We didn't find an 8-bit code. We may
7783 have found a null-byte, but it's very
7784 rare that a binary file confirm to
7787 coding
.head_ascii
= src
- coding
.source
;
7789 detect_info
.rejected
|= ~CATEGORY_MASK_ISO_ESCAPE
;
7795 null_byte_found
= 1;
7796 if (eight_bit_found
)
7799 if (! eight_bit_found
)
7800 coding
.head_ascii
++;
7802 else if (! eight_bit_found
)
7803 coding
.head_ascii
++;
7806 if (null_byte_found
|| eight_bit_found
7807 || coding
.head_ascii
< coding
.src_bytes
7808 || detect_info
.found
)
7810 if (coding
.head_ascii
== coding
.src_bytes
)
7811 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7812 for (i
= 0; i
< coding_category_raw_text
; i
++)
7814 category
= coding_priorities
[i
];
7815 this = coding_categories
+ category
;
7816 if (detect_info
.found
& (1 << category
))
7821 if (null_byte_found
)
7823 detect_info
.checked
|= ~CATEGORY_MASK_UTF_16
;
7824 detect_info
.rejected
|= ~CATEGORY_MASK_UTF_16
;
7826 for (i
= 0; i
< coding_category_raw_text
; i
++)
7828 category
= coding_priorities
[i
];
7829 this = coding_categories
+ category
;
7833 /* No coding system of this category is defined. */
7834 detect_info
.rejected
|= (1 << category
);
7836 else if (category
>= coding_category_raw_text
)
7838 else if (detect_info
.checked
& (1 << category
))
7841 && (detect_info
.found
& (1 << category
)))
7844 else if ((*(this->detector
)) (&coding
, &detect_info
)
7846 && (detect_info
.found
& (1 << category
)))
7848 if (category
== coding_category_utf_16_auto
)
7850 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7851 category
= coding_category_utf_16_le
;
7853 category
= coding_category_utf_16_be
;
7861 if ((detect_info
.rejected
& CATEGORY_MASK_ANY
) == CATEGORY_MASK_ANY
)
7863 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
7864 id
= coding_categories
[coding_category_raw_text
].id
;
7865 val
= Fcons (make_number (id
), Qnil
);
7867 else if (! detect_info
.rejected
&& ! detect_info
.found
)
7869 detect_info
.found
= CATEGORY_MASK_ANY
;
7870 id
= coding_categories
[coding_category_undecided
].id
;
7871 val
= Fcons (make_number (id
), Qnil
);
7875 if (detect_info
.found
)
7877 detect_info
.found
= 1 << category
;
7878 val
= Fcons (make_number (this->id
), Qnil
);
7881 for (i
= 0; i
< coding_category_raw_text
; i
++)
7882 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
7884 detect_info
.found
= 1 << coding_priorities
[i
];
7885 id
= coding_categories
[coding_priorities
[i
]].id
;
7886 val
= Fcons (make_number (id
), Qnil
);
7892 int mask
= detect_info
.rejected
| detect_info
.found
;
7895 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7897 category
= coding_priorities
[i
];
7898 if (! (mask
& (1 << category
)))
7900 found
|= 1 << category
;
7901 id
= coding_categories
[category
].id
;
7903 val
= Fcons (make_number (id
), val
);
7906 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7908 category
= coding_priorities
[i
];
7909 if (detect_info
.found
& (1 << category
))
7911 id
= coding_categories
[category
].id
;
7912 val
= Fcons (make_number (id
), val
);
7915 detect_info
.found
|= found
;
7918 else if (base_category
== coding_category_utf_8_auto
)
7920 if (detect_coding_utf_8 (&coding
, &detect_info
))
7922 struct coding_system
*this;
7924 if (detect_info
.found
& CATEGORY_MASK_UTF_8_SIG
)
7925 this = coding_categories
+ coding_category_utf_8_sig
;
7927 this = coding_categories
+ coding_category_utf_8_nosig
;
7928 val
= Fcons (make_number (this->id
), Qnil
);
7931 else if (base_category
== coding_category_utf_16_auto
)
7933 if (detect_coding_utf_16 (&coding
, &detect_info
))
7935 struct coding_system
*this;
7937 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7938 this = coding_categories
+ coding_category_utf_16_le
;
7939 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
7940 this = coding_categories
+ coding_category_utf_16_be
;
7941 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
7942 this = coding_categories
+ coding_category_utf_16_be_nosig
;
7944 this = coding_categories
+ coding_category_utf_16_le_nosig
;
7945 val
= Fcons (make_number (this->id
), Qnil
);
7950 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
7951 val
= Fcons (make_number (coding
.id
), Qnil
);
7954 /* Then, detect eol-format if necessary. */
7956 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
= -1;
7959 if (VECTORP (eol_type
))
7961 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
7963 if (null_byte_found
)
7964 normal_eol
= EOL_SEEN_LF
;
7966 normal_eol
= detect_eol (coding
.source
, src_bytes
,
7967 coding_category_raw_text
);
7969 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
7970 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
7971 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
7972 coding_category_utf_16_be
);
7973 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
7974 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
7975 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
7976 coding_category_utf_16_le
);
7980 if (EQ (eol_type
, Qunix
))
7981 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
7982 else if (EQ (eol_type
, Qdos
))
7983 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
7985 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
7988 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
7990 enum coding_category category
;
7993 id
= XINT (XCAR (tail
));
7994 attrs
= CODING_ID_ATTRS (id
);
7995 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7996 eol_type
= CODING_ID_EOL_TYPE (id
);
7997 if (VECTORP (eol_type
))
7999 if (category
== coding_category_utf_16_be
8000 || category
== coding_category_utf_16_be_nosig
)
8001 this_eol
= utf_16_be_eol
;
8002 else if (category
== coding_category_utf_16_le
8003 || category
== coding_category_utf_16_le_nosig
)
8004 this_eol
= utf_16_le_eol
;
8006 this_eol
= normal_eol
;
8008 if (this_eol
== EOL_SEEN_LF
)
8009 XSETCAR (tail
, AREF (eol_type
, 0));
8010 else if (this_eol
== EOL_SEEN_CRLF
)
8011 XSETCAR (tail
, AREF (eol_type
, 1));
8012 else if (this_eol
== EOL_SEEN_CR
)
8013 XSETCAR (tail
, AREF (eol_type
, 2));
8015 XSETCAR (tail
, CODING_ID_NAME (id
));
8018 XSETCAR (tail
, CODING_ID_NAME (id
));
8022 return (highest
? (CONSP (val
) ? XCAR (val
) : Qnil
) : val
);
8026 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
8028 doc
: /* Detect coding system of the text in the region between START and END.
8029 Return a list of possible coding systems ordered by priority.
8031 If only ASCII characters are found (except for such ISO-2022 control
8032 characters as ESC), it returns a list of single element `undecided'
8033 or its subsidiary coding system according to a detected end-of-line
8036 If optional argument HIGHEST is non-nil, return the coding system of
8037 highest priority. */)
8038 (start
, end
, highest
)
8039 Lisp_Object start
, end
, highest
;
8042 int from_byte
, to_byte
;
8044 CHECK_NUMBER_COERCE_MARKER (start
);
8045 CHECK_NUMBER_COERCE_MARKER (end
);
8047 validate_region (&start
, &end
);
8048 from
= XINT (start
), to
= XINT (end
);
8049 from_byte
= CHAR_TO_BYTE (from
);
8050 to_byte
= CHAR_TO_BYTE (to
);
8052 if (from
< GPT
&& to
>= GPT
)
8053 move_gap_both (to
, to_byte
);
8055 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
8056 to
- from
, to_byte
- from_byte
,
8058 !NILP (current_buffer
8059 ->enable_multibyte_characters
),
8063 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
8065 doc
: /* Detect coding system of the text in STRING.
8066 Return a list of possible coding systems ordered by priority.
8068 If only ASCII characters are found (except for such ISO-2022 control
8069 characters as ESC), it returns a list of single element `undecided'
8070 or its subsidiary coding system according to a detected end-of-line
8073 If optional argument HIGHEST is non-nil, return the coding system of
8074 highest priority. */)
8076 Lisp_Object string
, highest
;
8078 CHECK_STRING (string
);
8080 return detect_coding_system (SDATA (string
),
8081 SCHARS (string
), SBYTES (string
),
8082 !NILP (highest
), STRING_MULTIBYTE (string
),
8088 char_encodable_p (c
, attrs
)
8093 struct charset
*charset
;
8094 Lisp_Object translation_table
;
8096 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
8097 if (! NILP (translation_table
))
8098 c
= translate_char (translation_table
, c
);
8099 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
8100 CONSP (tail
); tail
= XCDR (tail
))
8102 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
8103 if (CHAR_CHARSET_P (c
, charset
))
8106 return (! NILP (tail
));
8110 /* Return a list of coding systems that safely encode the text between
8111 START and END. If EXCLUDE is non-nil, it is a list of coding
8112 systems not to check. The returned list doesn't contain any such
8113 coding systems. In any case, if the text contains only ASCII or is
8114 unibyte, return t. */
8116 DEFUN ("find-coding-systems-region-internal",
8117 Ffind_coding_systems_region_internal
,
8118 Sfind_coding_systems_region_internal
, 2, 3, 0,
8119 doc
: /* Internal use only. */)
8120 (start
, end
, exclude
)
8121 Lisp_Object start
, end
, exclude
;
8123 Lisp_Object coding_attrs_list
, safe_codings
;
8124 EMACS_INT start_byte
, end_byte
;
8125 const unsigned char *p
, *pbeg
, *pend
;
8127 Lisp_Object tail
, elt
;
8129 if (STRINGP (start
))
8131 if (!STRING_MULTIBYTE (start
)
8132 || SCHARS (start
) == SBYTES (start
))
8135 end_byte
= SBYTES (start
);
8139 CHECK_NUMBER_COERCE_MARKER (start
);
8140 CHECK_NUMBER_COERCE_MARKER (end
);
8141 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8142 args_out_of_range (start
, end
);
8143 if (NILP (current_buffer
->enable_multibyte_characters
))
8145 start_byte
= CHAR_TO_BYTE (XINT (start
));
8146 end_byte
= CHAR_TO_BYTE (XINT (end
));
8147 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8150 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8152 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8153 move_gap_both (XINT (start
), start_byte
);
8155 move_gap_both (XINT (end
), end_byte
);
8159 coding_attrs_list
= Qnil
;
8160 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8162 || NILP (Fmemq (XCAR (tail
), exclude
)))
8166 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
8167 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
8168 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
8170 ASET (attrs
, coding_attr_trans_tbl
,
8171 get_translation_table (attrs
, 1, NULL
));
8172 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
8176 if (STRINGP (start
))
8177 p
= pbeg
= SDATA (start
);
8179 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8180 pend
= p
+ (end_byte
- start_byte
);
8182 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
8183 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8187 if (ASCII_BYTE_P (*p
))
8191 c
= STRING_CHAR_ADVANCE (p
);
8193 charset_map_loaded
= 0;
8194 for (tail
= coding_attrs_list
; CONSP (tail
);)
8199 else if (char_encodable_p (c
, elt
))
8201 else if (CONSP (XCDR (tail
)))
8203 XSETCAR (tail
, XCAR (XCDR (tail
)));
8204 XSETCDR (tail
, XCDR (XCDR (tail
)));
8208 XSETCAR (tail
, Qnil
);
8212 if (charset_map_loaded
)
8214 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8216 if (STRINGP (start
))
8217 pbeg
= SDATA (start
);
8219 pbeg
= BYTE_POS_ADDR (start_byte
);
8220 p
= pbeg
+ p_offset
;
8221 pend
= pbeg
+ pend_offset
;
8226 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
8227 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
8228 if (! NILP (XCAR (tail
)))
8229 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
8231 return safe_codings
;
8235 DEFUN ("unencodable-char-position", Funencodable_char_position
,
8236 Sunencodable_char_position
, 3, 5, 0,
8238 Return position of first un-encodable character in a region.
8239 START and END specify the region and CODING-SYSTEM specifies the
8240 encoding to check. Return nil if CODING-SYSTEM does encode the region.
8242 If optional 4th argument COUNT is non-nil, it specifies at most how
8243 many un-encodable characters to search. In this case, the value is a
8246 If optional 5th argument STRING is non-nil, it is a string to search
8247 for un-encodable characters. In that case, START and END are indexes
8249 (start
, end
, coding_system
, count
, string
)
8250 Lisp_Object start
, end
, coding_system
, count
, string
;
8253 struct coding_system coding
;
8254 Lisp_Object attrs
, charset_list
, translation_table
;
8255 Lisp_Object positions
;
8257 const unsigned char *p
, *stop
, *pend
;
8258 int ascii_compatible
;
8260 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
8261 attrs
= CODING_ID_ATTRS (coding
.id
);
8262 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
8264 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
8265 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8266 translation_table
= get_translation_table (attrs
, 1, NULL
);
8270 validate_region (&start
, &end
);
8271 from
= XINT (start
);
8273 if (NILP (current_buffer
->enable_multibyte_characters
)
8274 || (ascii_compatible
8275 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
8277 p
= CHAR_POS_ADDR (from
);
8278 pend
= CHAR_POS_ADDR (to
);
8279 if (from
< GPT
&& to
>= GPT
)
8286 CHECK_STRING (string
);
8287 CHECK_NATNUM (start
);
8289 from
= XINT (start
);
8292 || to
> SCHARS (string
))
8293 args_out_of_range_3 (string
, start
, end
);
8294 if (! STRING_MULTIBYTE (string
))
8296 p
= SDATA (string
) + string_char_to_byte (string
, from
);
8297 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
8298 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
8306 CHECK_NATNUM (count
);
8315 if (ascii_compatible
)
8316 while (p
< stop
&& ASCII_BYTE_P (*p
))
8326 c
= STRING_CHAR_ADVANCE (p
);
8327 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
8328 && ! char_charset (translate_char (translation_table
, c
),
8329 charset_list
, NULL
))
8331 positions
= Fcons (make_number (from
), positions
);
8340 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
8344 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
8345 Scheck_coding_systems_region
, 3, 3, 0,
8346 doc
: /* Check if the region is encodable by coding systems.
8348 START and END are buffer positions specifying the region.
8349 CODING-SYSTEM-LIST is a list of coding systems to check.
8351 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
8352 CODING-SYSTEM is a member of CODING-SYSTEM-LIST and can't encode the
8353 whole region, POS0, POS1, ... are buffer positions where non-encodable
8354 characters are found.
8356 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
8359 START may be a string. In that case, check if the string is
8360 encodable, and the value contains indices to the string instead of
8361 buffer positions. END is ignored. */)
8362 (start
, end
, coding_system_list
)
8363 Lisp_Object start
, end
, coding_system_list
;
8366 EMACS_INT start_byte
, end_byte
;
8368 const unsigned char *p
, *pbeg
, *pend
;
8370 Lisp_Object tail
, elt
, attrs
;
8372 if (STRINGP (start
))
8374 if (!STRING_MULTIBYTE (start
)
8375 && SCHARS (start
) != SBYTES (start
))
8378 end_byte
= SBYTES (start
);
8383 CHECK_NUMBER_COERCE_MARKER (start
);
8384 CHECK_NUMBER_COERCE_MARKER (end
);
8385 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
8386 args_out_of_range (start
, end
);
8387 if (NILP (current_buffer
->enable_multibyte_characters
))
8389 start_byte
= CHAR_TO_BYTE (XINT (start
));
8390 end_byte
= CHAR_TO_BYTE (XINT (end
));
8391 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
8394 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
8396 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
8397 move_gap_both (XINT (start
), start_byte
);
8399 move_gap_both (XINT (end
), end_byte
);
8405 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
8408 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
8409 ASET (attrs
, coding_attr_trans_tbl
,
8410 get_translation_table (attrs
, 1, NULL
));
8411 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
8414 if (STRINGP (start
))
8415 p
= pbeg
= SDATA (start
);
8417 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
8418 pend
= p
+ (end_byte
- start_byte
);
8420 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
8421 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
8425 if (ASCII_BYTE_P (*p
))
8429 c
= STRING_CHAR_ADVANCE (p
);
8431 charset_map_loaded
= 0;
8432 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
8434 elt
= XCDR (XCAR (tail
));
8435 if (! char_encodable_p (c
, XCAR (elt
)))
8436 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
8438 if (charset_map_loaded
)
8440 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8442 if (STRINGP (start
))
8443 pbeg
= SDATA (start
);
8445 pbeg
= BYTE_POS_ADDR (start_byte
);
8446 p
= pbeg
+ p_offset
;
8447 pend
= pbeg
+ pend_offset
;
8455 for (; CONSP (tail
); tail
= XCDR (tail
))
8458 if (CONSP (XCDR (XCDR (elt
))))
8459 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
8468 code_convert_region (start
, end
, coding_system
, dst_object
, encodep
, norecord
)
8469 Lisp_Object start
, end
, coding_system
, dst_object
;
8470 int encodep
, norecord
;
8472 struct coding_system coding
;
8473 EMACS_INT from
, from_byte
, to
, to_byte
;
8474 Lisp_Object src_object
;
8476 CHECK_NUMBER_COERCE_MARKER (start
);
8477 CHECK_NUMBER_COERCE_MARKER (end
);
8478 if (NILP (coding_system
))
8479 coding_system
= Qno_conversion
;
8481 CHECK_CODING_SYSTEM (coding_system
);
8482 src_object
= Fcurrent_buffer ();
8483 if (NILP (dst_object
))
8484 dst_object
= src_object
;
8485 else if (! EQ (dst_object
, Qt
))
8486 CHECK_BUFFER (dst_object
);
8488 validate_region (&start
, &end
);
8489 from
= XFASTINT (start
);
8490 from_byte
= CHAR_TO_BYTE (from
);
8491 to
= XFASTINT (end
);
8492 to_byte
= CHAR_TO_BYTE (to
);
8494 setup_coding_system (coding_system
, &coding
);
8495 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8498 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8501 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8504 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8506 return (BUFFERP (dst_object
)
8507 ? make_number (coding
.produced_char
)
8508 : coding
.dst_object
);
8512 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
8513 3, 4, "r\nzCoding system: ",
8514 doc
: /* Decode the current region from the specified coding system.
8515 When called from a program, takes four arguments:
8516 START, END, CODING-SYSTEM, and DESTINATION.
8517 START and END are buffer positions.
8519 Optional 4th arguments DESTINATION specifies where the decoded text goes.
8520 If nil, the region between START and END is replaced by the decoded text.
8521 If buffer, the decoded text is inserted in that buffer after point (point
8523 In those cases, the length of the decoded text is returned.
8524 If DESTINATION is t, the decoded text is returned.
8526 This function sets `last-coding-system-used' to the precise coding system
8527 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8528 not fully specified.) */)
8529 (start
, end
, coding_system
, destination
)
8530 Lisp_Object start
, end
, coding_system
, destination
;
8532 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
8535 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
8536 3, 4, "r\nzCoding system: ",
8537 doc
: /* Encode the current region by specified coding system.
8538 When called from a program, takes four arguments:
8539 START, END, CODING-SYSTEM and DESTINATION.
8540 START and END are buffer positions.
8542 Optional 4th arguments DESTINATION specifies where the encoded text goes.
8543 If nil, the region between START and END is replace by the encoded text.
8544 If buffer, the encoded text is inserted in that buffer after point (point
8546 In those cases, the length of the encoded text is returned.
8547 If DESTINATION is t, the encoded text is returned.
8549 This function sets `last-coding-system-used' to the precise coding system
8550 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8551 not fully specified.) */)
8552 (start
, end
, coding_system
, destination
)
8553 Lisp_Object start
, end
, coding_system
, destination
;
8555 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
8559 code_convert_string (string
, coding_system
, dst_object
,
8560 encodep
, nocopy
, norecord
)
8561 Lisp_Object string
, coding_system
, dst_object
;
8562 int encodep
, nocopy
, norecord
;
8564 struct coding_system coding
;
8565 EMACS_INT chars
, bytes
;
8567 CHECK_STRING (string
);
8568 if (NILP (coding_system
))
8571 Vlast_coding_system_used
= Qno_conversion
;
8572 if (NILP (dst_object
))
8573 return (nocopy
? Fcopy_sequence (string
) : string
);
8576 if (NILP (coding_system
))
8577 coding_system
= Qno_conversion
;
8579 CHECK_CODING_SYSTEM (coding_system
);
8580 if (NILP (dst_object
))
8582 else if (! EQ (dst_object
, Qt
))
8583 CHECK_BUFFER (dst_object
);
8585 setup_coding_system (coding_system
, &coding
);
8586 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8587 chars
= SCHARS (string
);
8588 bytes
= SBYTES (string
);
8590 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8592 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8594 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8596 return (BUFFERP (dst_object
)
8597 ? make_number (coding
.produced_char
)
8598 : coding
.dst_object
);
8602 /* Encode or decode STRING according to CODING_SYSTEM.
8603 Do not set Vlast_coding_system_used.
8605 This function is called only from macros DECODE_FILE and
8606 ENCODE_FILE, thus we ignore character composition. */
8609 code_convert_string_norecord (string
, coding_system
, encodep
)
8610 Lisp_Object string
, coding_system
;
8613 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
8617 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
8619 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8621 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8622 if the decoding operation is trivial.
8624 Optional fourth arg BUFFER non-nil means that the decoded text is
8625 inserted in that buffer after point (point does not move). In this
8626 case, the return value is the length of the decoded text.
8628 This function sets `last-coding-system-used' to the precise coding system
8629 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8630 not fully specified.) */)
8631 (string
, coding_system
, nocopy
, buffer
)
8632 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8634 return code_convert_string (string
, coding_system
, buffer
,
8635 0, ! NILP (nocopy
), 0);
8638 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
8640 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
8642 Optional third arg NOCOPY non-nil means it is OK to return STRING
8643 itself if the encoding operation is trivial.
8645 Optional fourth arg BUFFER non-nil means that the encoded text is
8646 inserted in that buffer after point (point does not move). In this
8647 case, the return value is the length of the encoded text.
8649 This function sets `last-coding-system-used' to the precise coding system
8650 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8651 not fully specified.) */)
8652 (string
, coding_system
, nocopy
, buffer
)
8653 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8655 return code_convert_string (string
, coding_system
, buffer
,
8656 1, ! NILP (nocopy
), 1);
8660 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
8661 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
8662 Return the corresponding character. */)
8666 Lisp_Object spec
, attrs
, val
;
8667 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
8670 CHECK_NATNUM (code
);
8671 c
= XFASTINT (code
);
8672 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8673 attrs
= AREF (spec
, 0);
8675 if (ASCII_BYTE_P (c
)
8676 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8679 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8680 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8681 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8682 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8685 charset
= charset_roman
;
8686 else if (c
>= 0xA0 && c
< 0xDF)
8688 charset
= charset_kana
;
8693 int s1
= c
>> 8, s2
= c
& 0xFF;
8695 if (s1
< 0x81 || (s1
> 0x9F && s1
< 0xE0) || s1
> 0xEF
8696 || s2
< 0x40 || s2
== 0x7F || s2
> 0xFC)
8697 error ("Invalid code: %d", code
);
8699 charset
= charset_kanji
;
8701 c
= DECODE_CHAR (charset
, c
);
8703 error ("Invalid code: %d", code
);
8704 return make_number (c
);
8708 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
8709 doc
: /* Encode a Japanese character CH to shift_jis encoding.
8710 Return the corresponding code in SJIS. */)
8714 Lisp_Object spec
, attrs
, charset_list
;
8716 struct charset
*charset
;
8719 CHECK_CHARACTER (ch
);
8721 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8722 attrs
= AREF (spec
, 0);
8724 if (ASCII_CHAR_P (c
)
8725 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8728 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8729 charset
= char_charset (c
, charset_list
, &code
);
8730 if (code
== CHARSET_INVALID_CODE (charset
))
8731 error ("Can't encode by shift_jis encoding: %d", c
);
8734 return make_number (code
);
8737 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
8738 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
8739 Return the corresponding character. */)
8743 Lisp_Object spec
, attrs
, val
;
8744 struct charset
*charset_roman
, *charset_big5
, *charset
;
8747 CHECK_NATNUM (code
);
8748 c
= XFASTINT (code
);
8749 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8750 attrs
= AREF (spec
, 0);
8752 if (ASCII_BYTE_P (c
)
8753 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8756 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8757 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8758 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8761 charset
= charset_roman
;
8764 int b1
= c
>> 8, b2
= c
& 0x7F;
8765 if (b1
< 0xA1 || b1
> 0xFE
8766 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
8767 error ("Invalid code: %d", code
);
8768 charset
= charset_big5
;
8770 c
= DECODE_CHAR (charset
, (unsigned )c
);
8772 error ("Invalid code: %d", code
);
8773 return make_number (c
);
8776 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
8777 doc
: /* Encode the Big5 character CH to BIG5 coding system.
8778 Return the corresponding character code in Big5. */)
8782 Lisp_Object spec
, attrs
, charset_list
;
8783 struct charset
*charset
;
8787 CHECK_CHARACTER (ch
);
8789 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8790 attrs
= AREF (spec
, 0);
8791 if (ASCII_CHAR_P (c
)
8792 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8795 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8796 charset
= char_charset (c
, charset_list
, &code
);
8797 if (code
== CHARSET_INVALID_CODE (charset
))
8798 error ("Can't encode by Big5 encoding: %d", c
);
8800 return make_number (code
);
8804 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal
,
8805 Sset_terminal_coding_system_internal
, 1, 2, 0,
8806 doc
: /* Internal use only. */)
8807 (coding_system
, terminal
)
8808 Lisp_Object coding_system
;
8809 Lisp_Object terminal
;
8811 struct coding_system
*terminal_coding
= TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
8812 CHECK_SYMBOL (coding_system
);
8813 setup_coding_system (Fcheck_coding_system (coding_system
), terminal_coding
);
8814 /* We had better not send unsafe characters to terminal. */
8815 terminal_coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
8816 /* Characer composition should be disabled. */
8817 terminal_coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8818 terminal_coding
->src_multibyte
= 1;
8819 terminal_coding
->dst_multibyte
= 0;
8823 DEFUN ("set-safe-terminal-coding-system-internal",
8824 Fset_safe_terminal_coding_system_internal
,
8825 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
8826 doc
: /* Internal use only. */)
8828 Lisp_Object coding_system
;
8830 CHECK_SYMBOL (coding_system
);
8831 setup_coding_system (Fcheck_coding_system (coding_system
),
8832 &safe_terminal_coding
);
8833 /* Characer composition should be disabled. */
8834 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8835 safe_terminal_coding
.src_multibyte
= 1;
8836 safe_terminal_coding
.dst_multibyte
= 0;
8840 DEFUN ("terminal-coding-system", Fterminal_coding_system
,
8841 Sterminal_coding_system
, 0, 1, 0,
8842 doc
: /* Return coding system specified for terminal output on the given terminal.
8843 TERMINAL may be a terminal id, a frame, or nil for the selected
8844 frame's terminal device. */)
8846 Lisp_Object terminal
;
8848 struct coding_system
*terminal_coding
8849 = TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
8850 Lisp_Object coding_system
= CODING_ID_NAME (terminal_coding
->id
);
8852 /* For backward compatibility, return nil if it is `undecided'. */
8853 return (! EQ (coding_system
, Qundecided
) ? coding_system
: Qnil
);
8856 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal
,
8857 Sset_keyboard_coding_system_internal
, 1, 2, 0,
8858 doc
: /* Internal use only. */)
8859 (coding_system
, terminal
)
8860 Lisp_Object coding_system
;
8861 Lisp_Object terminal
;
8863 struct terminal
*t
= get_terminal (terminal
, 1);
8864 CHECK_SYMBOL (coding_system
);
8865 setup_coding_system (Fcheck_coding_system (coding_system
),
8866 TERMINAL_KEYBOARD_CODING (t
));
8867 /* Characer composition should be disabled. */
8868 TERMINAL_KEYBOARD_CODING (t
)->common_flags
8869 &= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8873 DEFUN ("keyboard-coding-system",
8874 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 1, 0,
8875 doc
: /* Return coding system specified for decoding keyboard input. */)
8877 Lisp_Object terminal
;
8879 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
8880 (get_terminal (terminal
, 1))->id
);
8884 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
8885 Sfind_operation_coding_system
, 1, MANY
, 0,
8886 doc
: /* Choose a coding system for an operation based on the target name.
8887 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8888 DECODING-SYSTEM is the coding system to use for decoding
8889 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8890 for encoding (in case OPERATION does encoding).
8892 The first argument OPERATION specifies an I/O primitive:
8893 For file I/O, `insert-file-contents' or `write-region'.
8894 For process I/O, `call-process', `call-process-region', or `start-process'.
8895 For network I/O, `open-network-stream'.
8897 The remaining arguments should be the same arguments that were passed
8898 to the primitive. Depending on which primitive, one of those arguments
8899 is selected as the TARGET. For example, if OPERATION does file I/O,
8900 whichever argument specifies the file name is TARGET.
8902 TARGET has a meaning which depends on OPERATION:
8903 For file I/O, TARGET is a file name (except for the special case below).
8904 For process I/O, TARGET is a process name.
8905 For network I/O, TARGET is a service name or a port number.
8907 This function looks up what is specified for TARGET in
8908 `file-coding-system-alist', `process-coding-system-alist',
8909 or `network-coding-system-alist' depending on OPERATION.
8910 They may specify a coding system, a cons of coding systems,
8911 or a function symbol to call.
8912 In the last case, we call the function with one argument,
8913 which is a list of all the arguments given to this function.
8914 If the function can't decide a coding system, it can return
8915 `undecided' so that the normal code-detection is performed.
8917 If OPERATION is `insert-file-contents', the argument corresponding to
8918 TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
8919 file name to look up, and BUFFER is a buffer that contains the file's
8920 contents (not yet decoded). If `file-coding-system-alist' specifies a
8921 function to call for FILENAME, that function should examine the
8922 contents of BUFFER instead of reading the file.
8924 usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
8929 Lisp_Object operation
, target_idx
, target
, val
;
8930 register Lisp_Object chain
;
8933 error ("Too few arguments");
8934 operation
= args
[0];
8935 if (!SYMBOLP (operation
)
8936 || !INTEGERP (target_idx
= Fget (operation
, Qtarget_idx
)))
8937 error ("Invalid first argument");
8938 if (nargs
< 1 + XINT (target_idx
))
8939 error ("Too few arguments for operation: %s",
8940 SDATA (SYMBOL_NAME (operation
)));
8941 target
= args
[XINT (target_idx
) + 1];
8942 if (!(STRINGP (target
)
8943 || (EQ (operation
, Qinsert_file_contents
) && CONSP (target
)
8944 && STRINGP (XCAR (target
)) && BUFFERP (XCDR (target
)))
8945 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
8946 error ("Invalid %dth argument", XINT (target_idx
) + 1);
8948 target
= XCAR (target
);
8950 chain
= ((EQ (operation
, Qinsert_file_contents
)
8951 || EQ (operation
, Qwrite_region
))
8952 ? Vfile_coding_system_alist
8953 : (EQ (operation
, Qopen_network_stream
)
8954 ? Vnetwork_coding_system_alist
8955 : Vprocess_coding_system_alist
));
8959 for (; CONSP (chain
); chain
= XCDR (chain
))
8965 && ((STRINGP (target
)
8966 && STRINGP (XCAR (elt
))
8967 && fast_string_match (XCAR (elt
), target
) >= 0)
8968 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
8971 /* Here, if VAL is both a valid coding system and a valid
8972 function symbol, we return VAL as a coding system. */
8975 if (! SYMBOLP (val
))
8977 if (! NILP (Fcoding_system_p (val
)))
8978 return Fcons (val
, val
);
8979 if (! NILP (Ffboundp (val
)))
8981 /* We use call1 rather than safe_call1
8982 so as to get bug reports about functions called here
8983 which don't handle the current interface. */
8984 val
= call1 (val
, Flist (nargs
, args
));
8987 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
8988 return Fcons (val
, val
);
8996 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
8997 Sset_coding_system_priority
, 0, MANY
, 0,
8998 doc
: /* Assign higher priority to the coding systems given as arguments.
8999 If multiple coding systems belong to the same category,
9000 all but the first one are ignored.
9002 usage: (set-coding-system-priority &rest coding-systems) */)
9008 int changed
[coding_category_max
];
9009 enum coding_category priorities
[coding_category_max
];
9011 bzero (changed
, sizeof changed
);
9013 for (i
= j
= 0; i
< nargs
; i
++)
9015 enum coding_category category
;
9016 Lisp_Object spec
, attrs
;
9018 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
9019 attrs
= AREF (spec
, 0);
9020 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
9021 if (changed
[category
])
9022 /* Ignore this coding system because a coding system of the
9023 same category already had a higher priority. */
9025 changed
[category
] = 1;
9026 priorities
[j
++] = category
;
9027 if (coding_categories
[category
].id
>= 0
9028 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
9029 setup_coding_system (args
[i
], &coding_categories
[category
]);
9030 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
9033 /* Now we have decided top J priorities. Reflect the order of the
9034 original priorities to the remaining priorities. */
9036 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
9038 while (j
< coding_category_max
9039 && changed
[coding_priorities
[j
]])
9041 if (j
== coding_category_max
)
9043 priorities
[i
] = coding_priorities
[j
];
9046 bcopy (priorities
, coding_priorities
, sizeof priorities
);
9048 /* Update `coding-category-list'. */
9049 Vcoding_category_list
= Qnil
;
9050 for (i
= coding_category_max
- 1; i
>= 0; i
--)
9051 Vcoding_category_list
9052 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
9053 Vcoding_category_list
);
9058 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
9059 Scoding_system_priority_list
, 0, 1, 0,
9060 doc
: /* Return a list of coding systems ordered by their priorities.
9061 HIGHESTP non-nil means just return the highest priority one. */)
9063 Lisp_Object highestp
;
9068 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
9070 enum coding_category category
= coding_priorities
[i
];
9071 int id
= coding_categories
[category
].id
;
9076 attrs
= CODING_ID_ATTRS (id
);
9077 if (! NILP (highestp
))
9078 return CODING_ATTR_BASE_NAME (attrs
);
9079 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
9081 return Fnreverse (val
);
9084 static char *suffixes
[] = { "-unix", "-dos", "-mac" };
9087 make_subsidiaries (base
)
9090 Lisp_Object subsidiaries
;
9091 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
9092 char *buf
= (char *) alloca (base_name_len
+ 6);
9095 bcopy (SDATA (SYMBOL_NAME (base
)), buf
, base_name_len
);
9096 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
9097 for (i
= 0; i
< 3; i
++)
9099 bcopy (suffixes
[i
], buf
+ base_name_len
, strlen (suffixes
[i
]) + 1);
9100 ASET (subsidiaries
, i
, intern (buf
));
9102 return subsidiaries
;
9106 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
9107 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
9108 doc
: /* For internal use only.
9109 usage: (define-coding-system-internal ...) */)
9115 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
9116 Lisp_Object attrs
; /* Vector of attributes. */
9117 Lisp_Object eol_type
;
9118 Lisp_Object aliases
;
9119 Lisp_Object coding_type
, charset_list
, safe_charsets
;
9120 enum coding_category category
;
9121 Lisp_Object tail
, val
;
9122 int max_charset_id
= 0;
9125 if (nargs
< coding_arg_max
)
9128 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
9130 name
= args
[coding_arg_name
];
9131 CHECK_SYMBOL (name
);
9132 CODING_ATTR_BASE_NAME (attrs
) = name
;
9134 val
= args
[coding_arg_mnemonic
];
9135 if (! STRINGP (val
))
9136 CHECK_CHARACTER (val
);
9137 CODING_ATTR_MNEMONIC (attrs
) = val
;
9139 coding_type
= args
[coding_arg_coding_type
];
9140 CHECK_SYMBOL (coding_type
);
9141 CODING_ATTR_TYPE (attrs
) = coding_type
;
9143 charset_list
= args
[coding_arg_charset_list
];
9144 if (SYMBOLP (charset_list
))
9146 if (EQ (charset_list
, Qiso_2022
))
9148 if (! EQ (coding_type
, Qiso_2022
))
9149 error ("Invalid charset-list");
9150 charset_list
= Viso_2022_charset_list
;
9152 else if (EQ (charset_list
, Qemacs_mule
))
9154 if (! EQ (coding_type
, Qemacs_mule
))
9155 error ("Invalid charset-list");
9156 charset_list
= Vemacs_mule_charset_list
;
9158 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9159 if (max_charset_id
< XFASTINT (XCAR (tail
)))
9160 max_charset_id
= XFASTINT (XCAR (tail
));
9164 charset_list
= Fcopy_sequence (charset_list
);
9165 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9167 struct charset
*charset
;
9170 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9171 if (EQ (coding_type
, Qiso_2022
)
9172 ? CHARSET_ISO_FINAL (charset
) < 0
9173 : EQ (coding_type
, Qemacs_mule
)
9174 ? CHARSET_EMACS_MULE_ID (charset
) < 0
9176 error ("Can't handle charset `%s'",
9177 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9179 XSETCAR (tail
, make_number (charset
->id
));
9180 if (max_charset_id
< charset
->id
)
9181 max_charset_id
= charset
->id
;
9184 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
9186 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
9188 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9189 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
9190 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
9192 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
9194 val
= args
[coding_arg_decode_translation_table
];
9195 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9197 CODING_ATTR_DECODE_TBL (attrs
) = val
;
9199 val
= args
[coding_arg_encode_translation_table
];
9200 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9202 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
9204 val
= args
[coding_arg_post_read_conversion
];
9206 CODING_ATTR_POST_READ (attrs
) = val
;
9208 val
= args
[coding_arg_pre_write_conversion
];
9210 CODING_ATTR_PRE_WRITE (attrs
) = val
;
9212 val
= args
[coding_arg_default_char
];
9214 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
9217 CHECK_CHARACTER (val
);
9218 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
9221 val
= args
[coding_arg_for_unibyte
];
9222 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
9224 val
= args
[coding_arg_plist
];
9226 CODING_ATTR_PLIST (attrs
) = val
;
9228 if (EQ (coding_type
, Qcharset
))
9230 /* Generate a lisp vector of 256 elements. Each element is nil,
9231 integer, or a list of charset IDs.
9233 If Nth element is nil, the byte code N is invalid in this
9236 If Nth element is a number NUM, N is the first byte of a
9237 charset whose ID is NUM.
9239 If Nth element is a list of charset IDs, N is the first byte
9240 of one of them. The list is sorted by dimensions of the
9241 charsets. A charset of smaller dimension comes firtst. */
9242 val
= Fmake_vector (make_number (256), Qnil
);
9244 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
9246 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
9247 int dim
= CHARSET_DIMENSION (charset
);
9248 int idx
= (dim
- 1) * 4;
9250 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9251 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9253 for (i
= charset
->code_space
[idx
];
9254 i
<= charset
->code_space
[idx
+ 1]; i
++)
9256 Lisp_Object tmp
, tmp2
;
9259 tmp
= AREF (val
, i
);
9262 else if (NUMBERP (tmp
))
9264 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
9266 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
9268 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
9272 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
9274 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
9279 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
9282 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
9283 XSETCAR (tmp2
, XCAR (tail
));
9289 ASET (attrs
, coding_attr_charset_valids
, val
);
9290 category
= coding_category_charset
;
9292 else if (EQ (coding_type
, Qccl
))
9296 if (nargs
< coding_arg_ccl_max
)
9299 val
= args
[coding_arg_ccl_decoder
];
9300 CHECK_CCL_PROGRAM (val
);
9302 val
= Fcopy_sequence (val
);
9303 ASET (attrs
, coding_attr_ccl_decoder
, val
);
9305 val
= args
[coding_arg_ccl_encoder
];
9306 CHECK_CCL_PROGRAM (val
);
9308 val
= Fcopy_sequence (val
);
9309 ASET (attrs
, coding_attr_ccl_encoder
, val
);
9311 val
= args
[coding_arg_ccl_valids
];
9312 valids
= Fmake_string (make_number (256), make_number (0));
9313 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
9320 from
= to
= XINT (val
);
9321 if (from
< 0 || from
> 255)
9322 args_out_of_range_3 (val
, make_number (0), make_number (255));
9327 CHECK_NATNUM_CAR (val
);
9328 CHECK_NATNUM_CDR (val
);
9329 from
= XINT (XCAR (val
));
9331 args_out_of_range_3 (XCAR (val
),
9332 make_number (0), make_number (255));
9333 to
= XINT (XCDR (val
));
9334 if (to
< from
|| to
> 255)
9335 args_out_of_range_3 (XCDR (val
),
9336 XCAR (val
), make_number (255));
9338 for (i
= from
; i
<= to
; i
++)
9339 SSET (valids
, i
, 1);
9341 ASET (attrs
, coding_attr_ccl_valids
, valids
);
9343 category
= coding_category_ccl
;
9345 else if (EQ (coding_type
, Qutf_16
))
9347 Lisp_Object bom
, endian
;
9349 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
9351 if (nargs
< coding_arg_utf16_max
)
9354 bom
= args
[coding_arg_utf16_bom
];
9355 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9359 CHECK_CODING_SYSTEM (val
);
9361 CHECK_CODING_SYSTEM (val
);
9363 ASET (attrs
, coding_attr_utf_bom
, bom
);
9365 endian
= args
[coding_arg_utf16_endian
];
9366 CHECK_SYMBOL (endian
);
9369 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
9370 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
9371 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
9373 category
= (CONSP (bom
)
9374 ? coding_category_utf_16_auto
9376 ? (EQ (endian
, Qbig
)
9377 ? coding_category_utf_16_be_nosig
9378 : coding_category_utf_16_le_nosig
)
9379 : (EQ (endian
, Qbig
)
9380 ? coding_category_utf_16_be
9381 : coding_category_utf_16_le
));
9383 else if (EQ (coding_type
, Qiso_2022
))
9385 Lisp_Object initial
, reg_usage
, request
, flags
;
9388 if (nargs
< coding_arg_iso2022_max
)
9391 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
9392 CHECK_VECTOR (initial
);
9393 for (i
= 0; i
< 4; i
++)
9395 val
= Faref (initial
, make_number (i
));
9398 struct charset
*charset
;
9400 CHECK_CHARSET_GET_CHARSET (val
, charset
);
9401 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
9402 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
9403 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9406 ASET (initial
, i
, make_number (-1));
9409 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
9410 CHECK_CONS (reg_usage
);
9411 CHECK_NUMBER_CAR (reg_usage
);
9412 CHECK_NUMBER_CDR (reg_usage
);
9414 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
9415 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
9423 CHECK_CHARSET_GET_ID (tmp
, id
);
9424 CHECK_NATNUM_CDR (val
);
9425 if (XINT (XCDR (val
)) >= 4)
9426 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
9427 XSETCAR (val
, make_number (id
));
9430 flags
= args
[coding_arg_iso2022_flags
];
9431 CHECK_NATNUM (flags
);
9433 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
9434 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
9436 ASET (attrs
, coding_attr_iso_initial
, initial
);
9437 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
9438 ASET (attrs
, coding_attr_iso_request
, request
);
9439 ASET (attrs
, coding_attr_iso_flags
, flags
);
9440 setup_iso_safe_charsets (attrs
);
9442 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
9443 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
9444 | CODING_ISO_FLAG_SINGLE_SHIFT
))
9445 ? coding_category_iso_7_else
9446 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9447 ? coding_category_iso_7
9448 : coding_category_iso_7_tight
);
9451 int id
= XINT (AREF (initial
, 1));
9453 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
9454 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9456 ? coding_category_iso_8_else
9457 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
9458 ? coding_category_iso_8_1
9459 : coding_category_iso_8_2
);
9461 if (category
!= coding_category_iso_8_1
9462 && category
!= coding_category_iso_8_2
)
9463 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
9465 else if (EQ (coding_type
, Qemacs_mule
))
9467 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
9468 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
9469 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9470 category
= coding_category_emacs_mule
;
9472 else if (EQ (coding_type
, Qshift_jis
))
9475 struct charset
*charset
;
9477 if (XINT (Flength (charset_list
)) != 3
9478 && XINT (Flength (charset_list
)) != 4)
9479 error ("There should be three or four charsets");
9481 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9482 if (CHARSET_DIMENSION (charset
) != 1)
9483 error ("Dimension of charset %s is not one",
9484 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9485 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9486 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9488 charset_list
= XCDR (charset_list
);
9489 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9490 if (CHARSET_DIMENSION (charset
) != 1)
9491 error ("Dimension of charset %s is not one",
9492 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9494 charset_list
= XCDR (charset_list
);
9495 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9496 if (CHARSET_DIMENSION (charset
) != 2)
9497 error ("Dimension of charset %s is not two",
9498 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9500 charset_list
= XCDR (charset_list
);
9501 if (! NILP (charset_list
))
9503 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9504 if (CHARSET_DIMENSION (charset
) != 2)
9505 error ("Dimension of charset %s is not two",
9506 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9509 category
= coding_category_sjis
;
9510 Vsjis_coding_system
= name
;
9512 else if (EQ (coding_type
, Qbig5
))
9514 struct charset
*charset
;
9516 if (XINT (Flength (charset_list
)) != 2)
9517 error ("There should be just two charsets");
9519 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9520 if (CHARSET_DIMENSION (charset
) != 1)
9521 error ("Dimension of charset %s is not one",
9522 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9523 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9524 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9526 charset_list
= XCDR (charset_list
);
9527 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9528 if (CHARSET_DIMENSION (charset
) != 2)
9529 error ("Dimension of charset %s is not two",
9530 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9532 category
= coding_category_big5
;
9533 Vbig5_coding_system
= name
;
9535 else if (EQ (coding_type
, Qraw_text
))
9537 category
= coding_category_raw_text
;
9538 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9540 else if (EQ (coding_type
, Qutf_8
))
9544 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9546 if (nargs
< coding_arg_utf8_max
)
9549 bom
= args
[coding_arg_utf8_bom
];
9550 if (! NILP (bom
) && ! EQ (bom
, Qt
))
9554 CHECK_CODING_SYSTEM (val
);
9556 CHECK_CODING_SYSTEM (val
);
9558 ASET (attrs
, coding_attr_utf_bom
, bom
);
9560 category
= (CONSP (bom
) ? coding_category_utf_8_auto
9561 : NILP (bom
) ? coding_category_utf_8_nosig
9562 : coding_category_utf_8_sig
);
9564 else if (EQ (coding_type
, Qundecided
))
9565 category
= coding_category_undecided
;
9567 error ("Invalid coding system type: %s",
9568 SDATA (SYMBOL_NAME (coding_type
)));
9570 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
9571 CODING_ATTR_PLIST (attrs
)
9572 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
9573 CODING_ATTR_PLIST (attrs
)));
9574 CODING_ATTR_PLIST (attrs
)
9575 = Fcons (QCascii_compatible_p
,
9576 Fcons (CODING_ATTR_ASCII_COMPAT (attrs
),
9577 CODING_ATTR_PLIST (attrs
)));
9579 eol_type
= args
[coding_arg_eol_type
];
9580 if (! NILP (eol_type
)
9581 && ! EQ (eol_type
, Qunix
)
9582 && ! EQ (eol_type
, Qdos
)
9583 && ! EQ (eol_type
, Qmac
))
9584 error ("Invalid eol-type");
9586 aliases
= Fcons (name
, Qnil
);
9588 if (NILP (eol_type
))
9590 eol_type
= make_subsidiaries (name
);
9591 for (i
= 0; i
< 3; i
++)
9593 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
9595 this_name
= AREF (eol_type
, i
);
9596 this_aliases
= Fcons (this_name
, Qnil
);
9597 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
9598 this_spec
= Fmake_vector (make_number (3), attrs
);
9599 ASET (this_spec
, 1, this_aliases
);
9600 ASET (this_spec
, 2, this_eol_type
);
9601 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
9602 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
9603 val
= Fassoc (Fsymbol_name (this_name
), Vcoding_system_alist
);
9605 Vcoding_system_alist
9606 = Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
9607 Vcoding_system_alist
);
9611 spec_vec
= Fmake_vector (make_number (3), attrs
);
9612 ASET (spec_vec
, 1, aliases
);
9613 ASET (spec_vec
, 2, eol_type
);
9615 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
9616 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
9617 val
= Fassoc (Fsymbol_name (name
), Vcoding_system_alist
);
9619 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
9620 Vcoding_system_alist
);
9623 int id
= coding_categories
[category
].id
;
9625 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
9626 setup_coding_system (name
, &coding_categories
[category
]);
9632 return Fsignal (Qwrong_number_of_arguments
,
9633 Fcons (intern ("define-coding-system-internal"),
9634 make_number (nargs
)));
9638 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
9640 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
9641 (coding_system
, prop
, val
)
9642 Lisp_Object coding_system
, prop
, val
;
9644 Lisp_Object spec
, attrs
;
9646 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9647 attrs
= AREF (spec
, 0);
9648 if (EQ (prop
, QCmnemonic
))
9650 if (! STRINGP (val
))
9651 CHECK_CHARACTER (val
);
9652 CODING_ATTR_MNEMONIC (attrs
) = val
;
9654 else if (EQ (prop
, QCdefault_char
))
9657 val
= make_number (' ');
9659 CHECK_CHARACTER (val
);
9660 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
9662 else if (EQ (prop
, QCdecode_translation_table
))
9664 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9666 CODING_ATTR_DECODE_TBL (attrs
) = val
;
9668 else if (EQ (prop
, QCencode_translation_table
))
9670 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9672 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
9674 else if (EQ (prop
, QCpost_read_conversion
))
9677 CODING_ATTR_POST_READ (attrs
) = val
;
9679 else if (EQ (prop
, QCpre_write_conversion
))
9682 CODING_ATTR_PRE_WRITE (attrs
) = val
;
9684 else if (EQ (prop
, QCascii_compatible_p
))
9686 CODING_ATTR_ASCII_COMPAT (attrs
) = val
;
9689 CODING_ATTR_PLIST (attrs
)
9690 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
9695 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
9696 Sdefine_coding_system_alias
, 2, 2, 0,
9697 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
9698 (alias
, coding_system
)
9699 Lisp_Object alias
, coding_system
;
9701 Lisp_Object spec
, aliases
, eol_type
, val
;
9703 CHECK_SYMBOL (alias
);
9704 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9705 aliases
= AREF (spec
, 1);
9706 /* ALIASES should be a list of length more than zero, and the first
9707 element is a base coding system. Append ALIAS at the tail of the
9709 while (!NILP (XCDR (aliases
)))
9710 aliases
= XCDR (aliases
);
9711 XSETCDR (aliases
, Fcons (alias
, Qnil
));
9713 eol_type
= AREF (spec
, 2);
9714 if (VECTORP (eol_type
))
9716 Lisp_Object subsidiaries
;
9719 subsidiaries
= make_subsidiaries (alias
);
9720 for (i
= 0; i
< 3; i
++)
9721 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
9722 AREF (eol_type
, i
));
9725 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
9726 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
9727 val
= Fassoc (Fsymbol_name (alias
), Vcoding_system_alist
);
9729 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
9730 Vcoding_system_alist
);
9735 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
9737 doc
: /* Return the base of CODING-SYSTEM.
9738 Any alias or subsidiary coding system is not a base coding system. */)
9740 Lisp_Object coding_system
;
9742 Lisp_Object spec
, attrs
;
9744 if (NILP (coding_system
))
9745 return (Qno_conversion
);
9746 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9747 attrs
= AREF (spec
, 0);
9748 return CODING_ATTR_BASE_NAME (attrs
);
9751 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
9753 doc
: "Return the property list of CODING-SYSTEM.")
9755 Lisp_Object coding_system
;
9757 Lisp_Object spec
, attrs
;
9759 if (NILP (coding_system
))
9760 coding_system
= Qno_conversion
;
9761 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9762 attrs
= AREF (spec
, 0);
9763 return CODING_ATTR_PLIST (attrs
);
9767 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
9769 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
9771 Lisp_Object coding_system
;
9775 if (NILP (coding_system
))
9776 coding_system
= Qno_conversion
;
9777 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9778 return AREF (spec
, 1);
9781 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
9782 Scoding_system_eol_type
, 1, 1, 0,
9783 doc
: /* Return eol-type of CODING-SYSTEM.
9784 An eol-type is an integer 0, 1, 2, or a vector of coding systems.
9786 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9787 and CR respectively.
9789 A vector value indicates that a format of end-of-line should be
9790 detected automatically. Nth element of the vector is the subsidiary
9791 coding system whose eol-type is N. */)
9793 Lisp_Object coding_system
;
9795 Lisp_Object spec
, eol_type
;
9798 if (NILP (coding_system
))
9799 coding_system
= Qno_conversion
;
9800 if (! CODING_SYSTEM_P (coding_system
))
9802 spec
= CODING_SYSTEM_SPEC (coding_system
);
9803 eol_type
= AREF (spec
, 2);
9804 if (VECTORP (eol_type
))
9805 return Fcopy_sequence (eol_type
);
9806 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
9807 return make_number (n
);
9813 /*** 9. Post-amble ***/
9820 for (i
= 0; i
< coding_category_max
; i
++)
9822 coding_categories
[i
].id
= -1;
9823 coding_priorities
[i
] = i
;
9826 /* ISO2022 specific initialize routine. */
9827 for (i
= 0; i
< 0x20; i
++)
9828 iso_code_class
[i
] = ISO_control_0
;
9829 for (i
= 0x21; i
< 0x7F; i
++)
9830 iso_code_class
[i
] = ISO_graphic_plane_0
;
9831 for (i
= 0x80; i
< 0xA0; i
++)
9832 iso_code_class
[i
] = ISO_control_1
;
9833 for (i
= 0xA1; i
< 0xFF; i
++)
9834 iso_code_class
[i
] = ISO_graphic_plane_1
;
9835 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
9836 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
9837 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
9838 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
9839 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
9840 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
9841 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
9842 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
9843 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
9845 for (i
= 0; i
< 256; i
++)
9847 emacs_mule_bytes
[i
] = 1;
9849 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
9850 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
9851 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
9852 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
9860 staticpro (&Vcoding_system_hash_table
);
9862 Lisp_Object args
[2];
9865 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
9868 staticpro (&Vsjis_coding_system
);
9869 Vsjis_coding_system
= Qnil
;
9871 staticpro (&Vbig5_coding_system
);
9872 Vbig5_coding_system
= Qnil
;
9874 staticpro (&Vcode_conversion_reused_workbuf
);
9875 Vcode_conversion_reused_workbuf
= Qnil
;
9877 staticpro (&Vcode_conversion_workbuf_name
);
9878 Vcode_conversion_workbuf_name
= build_string (" *code-conversion-work*");
9880 reused_workbuf_in_use
= 0;
9882 DEFSYM (Qcharset
, "charset");
9883 DEFSYM (Qtarget_idx
, "target-idx");
9884 DEFSYM (Qcoding_system_history
, "coding-system-history");
9885 Fset (Qcoding_system_history
, Qnil
);
9887 /* Target FILENAME is the first argument. */
9888 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
9889 /* Target FILENAME is the third argument. */
9890 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
9892 DEFSYM (Qcall_process
, "call-process");
9893 /* Target PROGRAM is the first argument. */
9894 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
9896 DEFSYM (Qcall_process_region
, "call-process-region");
9897 /* Target PROGRAM is the third argument. */
9898 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
9900 DEFSYM (Qstart_process
, "start-process");
9901 /* Target PROGRAM is the third argument. */
9902 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
9904 DEFSYM (Qopen_network_stream
, "open-network-stream");
9905 /* Target SERVICE is the fourth argument. */
9906 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
9908 DEFSYM (Qcoding_system
, "coding-system");
9909 DEFSYM (Qcoding_aliases
, "coding-aliases");
9911 DEFSYM (Qeol_type
, "eol-type");
9912 DEFSYM (Qunix
, "unix");
9913 DEFSYM (Qdos
, "dos");
9915 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
9916 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
9917 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
9918 DEFSYM (Qdefault_char
, "default-char");
9919 DEFSYM (Qundecided
, "undecided");
9920 DEFSYM (Qno_conversion
, "no-conversion");
9921 DEFSYM (Qraw_text
, "raw-text");
9923 DEFSYM (Qiso_2022
, "iso-2022");
9925 DEFSYM (Qutf_8
, "utf-8");
9926 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
9928 DEFSYM (Qutf_16
, "utf-16");
9929 DEFSYM (Qbig
, "big");
9930 DEFSYM (Qlittle
, "little");
9932 DEFSYM (Qshift_jis
, "shift-jis");
9933 DEFSYM (Qbig5
, "big5");
9935 DEFSYM (Qcoding_system_p
, "coding-system-p");
9937 DEFSYM (Qcoding_system_error
, "coding-system-error");
9938 Fput (Qcoding_system_error
, Qerror_conditions
,
9939 Fcons (Qcoding_system_error
, Fcons (Qerror
, Qnil
)));
9940 Fput (Qcoding_system_error
, Qerror_message
,
9941 build_string ("Invalid coding system"));
9943 /* Intern this now in case it isn't already done.
9944 Setting this variable twice is harmless.
9945 But don't staticpro it here--that is done in alloc.c. */
9946 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
9948 DEFSYM (Qtranslation_table
, "translation-table");
9949 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
9950 DEFSYM (Qtranslation_table_id
, "translation-table-id");
9951 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
9952 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
9954 DEFSYM (Qvalid_codes
, "valid-codes");
9956 DEFSYM (Qemacs_mule
, "emacs-mule");
9958 DEFSYM (QCcategory
, ":category");
9959 DEFSYM (QCmnemonic
, ":mnemonic");
9960 DEFSYM (QCdefault_char
, ":default-char");
9961 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
9962 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
9963 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
9964 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
9965 DEFSYM (QCascii_compatible_p
, ":ascii-compatible-p");
9967 Vcoding_category_table
9968 = Fmake_vector (make_number (coding_category_max
), Qnil
);
9969 staticpro (&Vcoding_category_table
);
9970 /* Followings are target of code detection. */
9971 ASET (Vcoding_category_table
, coding_category_iso_7
,
9972 intern ("coding-category-iso-7"));
9973 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
9974 intern ("coding-category-iso-7-tight"));
9975 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
9976 intern ("coding-category-iso-8-1"));
9977 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
9978 intern ("coding-category-iso-8-2"));
9979 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
9980 intern ("coding-category-iso-7-else"));
9981 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
9982 intern ("coding-category-iso-8-else"));
9983 ASET (Vcoding_category_table
, coding_category_utf_8_auto
,
9984 intern ("coding-category-utf-8-auto"));
9985 ASET (Vcoding_category_table
, coding_category_utf_8_nosig
,
9986 intern ("coding-category-utf-8"));
9987 ASET (Vcoding_category_table
, coding_category_utf_8_sig
,
9988 intern ("coding-category-utf-8-sig"));
9989 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
9990 intern ("coding-category-utf-16-be"));
9991 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
9992 intern ("coding-category-utf-16-auto"));
9993 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
9994 intern ("coding-category-utf-16-le"));
9995 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
9996 intern ("coding-category-utf-16-be-nosig"));
9997 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
9998 intern ("coding-category-utf-16-le-nosig"));
9999 ASET (Vcoding_category_table
, coding_category_charset
,
10000 intern ("coding-category-charset"));
10001 ASET (Vcoding_category_table
, coding_category_sjis
,
10002 intern ("coding-category-sjis"));
10003 ASET (Vcoding_category_table
, coding_category_big5
,
10004 intern ("coding-category-big5"));
10005 ASET (Vcoding_category_table
, coding_category_ccl
,
10006 intern ("coding-category-ccl"));
10007 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
10008 intern ("coding-category-emacs-mule"));
10009 /* Followings are NOT target of code detection. */
10010 ASET (Vcoding_category_table
, coding_category_raw_text
,
10011 intern ("coding-category-raw-text"));
10012 ASET (Vcoding_category_table
, coding_category_undecided
,
10013 intern ("coding-category-undecided"));
10015 DEFSYM (Qinsufficient_source
, "insufficient-source");
10016 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
10017 DEFSYM (Qinvalid_source
, "invalid-source");
10018 DEFSYM (Qinterrupted
, "interrupted");
10019 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
10020 DEFSYM (Qcoding_system_define_form
, "coding-system-define-form");
10022 defsubr (&Scoding_system_p
);
10023 defsubr (&Sread_coding_system
);
10024 defsubr (&Sread_non_nil_coding_system
);
10025 defsubr (&Scheck_coding_system
);
10026 defsubr (&Sdetect_coding_region
);
10027 defsubr (&Sdetect_coding_string
);
10028 defsubr (&Sfind_coding_systems_region_internal
);
10029 defsubr (&Sunencodable_char_position
);
10030 defsubr (&Scheck_coding_systems_region
);
10031 defsubr (&Sdecode_coding_region
);
10032 defsubr (&Sencode_coding_region
);
10033 defsubr (&Sdecode_coding_string
);
10034 defsubr (&Sencode_coding_string
);
10035 defsubr (&Sdecode_sjis_char
);
10036 defsubr (&Sencode_sjis_char
);
10037 defsubr (&Sdecode_big5_char
);
10038 defsubr (&Sencode_big5_char
);
10039 defsubr (&Sset_terminal_coding_system_internal
);
10040 defsubr (&Sset_safe_terminal_coding_system_internal
);
10041 defsubr (&Sterminal_coding_system
);
10042 defsubr (&Sset_keyboard_coding_system_internal
);
10043 defsubr (&Skeyboard_coding_system
);
10044 defsubr (&Sfind_operation_coding_system
);
10045 defsubr (&Sset_coding_system_priority
);
10046 defsubr (&Sdefine_coding_system_internal
);
10047 defsubr (&Sdefine_coding_system_alias
);
10048 defsubr (&Scoding_system_put
);
10049 defsubr (&Scoding_system_base
);
10050 defsubr (&Scoding_system_plist
);
10051 defsubr (&Scoding_system_aliases
);
10052 defsubr (&Scoding_system_eol_type
);
10053 defsubr (&Scoding_system_priority_list
);
10055 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list
,
10056 doc
: /* List of coding systems.
10058 Do not alter the value of this variable manually. This variable should be
10059 updated by the functions `define-coding-system' and
10060 `define-coding-system-alias'. */);
10061 Vcoding_system_list
= Qnil
;
10063 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist
,
10064 doc
: /* Alist of coding system names.
10065 Each element is one element list of coding system name.
10066 This variable is given to `completing-read' as COLLECTION argument.
10068 Do not alter the value of this variable manually. This variable should be
10069 updated by the functions `make-coding-system' and
10070 `define-coding-system-alias'. */);
10071 Vcoding_system_alist
= Qnil
;
10073 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list
,
10074 doc
: /* List of coding-categories (symbols) ordered by priority.
10076 On detecting a coding system, Emacs tries code detection algorithms
10077 associated with each coding-category one by one in this order. When
10078 one algorithm agrees with a byte sequence of source text, the coding
10079 system bound to the corresponding coding-category is selected.
10081 Don't modify this variable directly, but use `set-coding-priority'. */);
10085 Vcoding_category_list
= Qnil
;
10086 for (i
= coding_category_max
- 1; i
>= 0; i
--)
10087 Vcoding_category_list
10088 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
10089 Vcoding_category_list
);
10092 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read
,
10093 doc
: /* Specify the coding system for read operations.
10094 It is useful to bind this variable with `let', but do not set it globally.
10095 If the value is a coding system, it is used for decoding on read operation.
10096 If not, an appropriate element is used from one of the coding system alists.
10097 There are three such tables: `file-coding-system-alist',
10098 `process-coding-system-alist', and `network-coding-system-alist'. */);
10099 Vcoding_system_for_read
= Qnil
;
10101 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write
,
10102 doc
: /* Specify the coding system for write operations.
10103 Programs bind this variable with `let', but you should not set it globally.
10104 If the value is a coding system, it is used for encoding of output,
10105 when writing it to a file and when sending it to a file or subprocess.
10107 If this does not specify a coding system, an appropriate element
10108 is used from one of the coding system alists.
10109 There are three such tables: `file-coding-system-alist',
10110 `process-coding-system-alist', and `network-coding-system-alist'.
10111 For output to files, if the above procedure does not specify a coding system,
10112 the value of `buffer-file-coding-system' is used. */);
10113 Vcoding_system_for_write
= Qnil
;
10115 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used
,
10117 Coding system used in the latest file or process I/O. */);
10118 Vlast_coding_system_used
= Qnil
;
10120 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error
,
10122 Error status of the last code conversion.
10124 When an error was detected in the last code conversion, this variable
10125 is set to one of the following symbols.
10126 `insufficient-source'
10130 `insufficient-memory'
10131 When no error was detected, the value doesn't change. So, to check
10132 the error status of a code conversion by this variable, you must
10133 explicitly set this variable to nil before performing code
10135 Vlast_code_conversion_error
= Qnil
;
10137 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion
,
10139 *Non-nil means always inhibit code conversion of end-of-line format.
10140 See info node `Coding Systems' and info node `Text and Binary' concerning
10141 such conversion. */);
10142 inhibit_eol_conversion
= 0;
10144 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system
,
10146 Non-nil means process buffer inherits coding system of process output.
10147 Bind it to t if the process output is to be treated as if it were a file
10148 read from some filesystem. */);
10149 inherit_process_coding_system
= 0;
10151 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist
,
10153 Alist to decide a coding system to use for a file I/O operation.
10154 The format is ((PATTERN . VAL) ...),
10155 where PATTERN is a regular expression matching a file name,
10156 VAL is a coding system, a cons of coding systems, or a function symbol.
10157 If VAL is a coding system, it is used for both decoding and encoding
10159 If VAL is a cons of coding systems, the car part is used for decoding,
10160 and the cdr part is used for encoding.
10161 If VAL is a function symbol, the function must return a coding system
10162 or a cons of coding systems which are used as above. The function is
10163 called with an argument that is a list of the arguments with which
10164 `find-operation-coding-system' was called. If the function can't decide
10165 a coding system, it can return `undecided' so that the normal
10166 code-detection is performed.
10168 See also the function `find-operation-coding-system'
10169 and the variable `auto-coding-alist'. */);
10170 Vfile_coding_system_alist
= Qnil
;
10172 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist
,
10174 Alist to decide a coding system to use for a process I/O operation.
10175 The format is ((PATTERN . VAL) ...),
10176 where PATTERN is a regular expression matching a program name,
10177 VAL is a coding system, a cons of coding systems, or a function symbol.
10178 If VAL is a coding system, it is used for both decoding what received
10179 from the program and encoding what sent to the program.
10180 If VAL is a cons of coding systems, the car part is used for decoding,
10181 and the cdr part is used for encoding.
10182 If VAL is a function symbol, the function must return a coding system
10183 or a cons of coding systems which are used as above.
10185 See also the function `find-operation-coding-system'. */);
10186 Vprocess_coding_system_alist
= Qnil
;
10188 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist
,
10190 Alist to decide a coding system to use for a network I/O operation.
10191 The format is ((PATTERN . VAL) ...),
10192 where PATTERN is a regular expression matching a network service name
10193 or is a port number to connect to,
10194 VAL is a coding system, a cons of coding systems, or a function symbol.
10195 If VAL is a coding system, it is used for both decoding what received
10196 from the network stream and encoding what sent to the network stream.
10197 If VAL is a cons of coding systems, the car part is used for decoding,
10198 and the cdr part is used for encoding.
10199 If VAL is a function symbol, the function must return a coding system
10200 or a cons of coding systems which are used as above.
10202 See also the function `find-operation-coding-system'. */);
10203 Vnetwork_coding_system_alist
= Qnil
;
10205 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system
,
10206 doc
: /* Coding system to use with system messages.
10207 Also used for decoding keyboard input on X Window system. */);
10208 Vlocale_coding_system
= Qnil
;
10210 /* The eol mnemonics are reset in startup.el system-dependently. */
10211 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix
,
10213 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
10214 eol_mnemonic_unix
= build_string (":");
10216 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos
,
10218 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
10219 eol_mnemonic_dos
= build_string ("\\");
10221 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac
,
10223 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
10224 eol_mnemonic_mac
= build_string ("/");
10226 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided
,
10228 *String displayed in mode line when end-of-line format is not yet determined. */);
10229 eol_mnemonic_undecided
= build_string (":");
10231 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation
,
10233 *Non-nil enables character translation while encoding and decoding. */);
10234 Venable_character_translation
= Qt
;
10236 DEFVAR_LISP ("standard-translation-table-for-decode",
10237 &Vstandard_translation_table_for_decode
,
10238 doc
: /* Table for translating characters while decoding. */);
10239 Vstandard_translation_table_for_decode
= Qnil
;
10241 DEFVAR_LISP ("standard-translation-table-for-encode",
10242 &Vstandard_translation_table_for_encode
,
10243 doc
: /* Table for translating characters while encoding. */);
10244 Vstandard_translation_table_for_encode
= Qnil
;
10246 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table
,
10247 doc
: /* Alist of charsets vs revision numbers.
10248 While encoding, if a charset (car part of an element) is found,
10249 designate it with the escape sequence identifying revision (cdr part
10250 of the element). */);
10251 Vcharset_revision_table
= Qnil
;
10253 DEFVAR_LISP ("default-process-coding-system",
10254 &Vdefault_process_coding_system
,
10255 doc
: /* Cons of coding systems used for process I/O by default.
10256 The car part is used for decoding a process output,
10257 the cdr part is used for encoding a text to be sent to a process. */);
10258 Vdefault_process_coding_system
= Qnil
;
10260 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table
,
10262 Table of extra Latin codes in the range 128..159 (inclusive).
10263 This is a vector of length 256.
10264 If Nth element is non-nil, the existence of code N in a file
10265 \(or output of subprocess) doesn't prevent it to be detected as
10266 a coding system of ISO 2022 variant which has a flag
10267 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
10268 or reading output of a subprocess.
10269 Only 128th through 159th elements have a meaning. */);
10270 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
10272 DEFVAR_LISP ("select-safe-coding-system-function",
10273 &Vselect_safe_coding_system_function
,
10275 Function to call to select safe coding system for encoding a text.
10277 If set, this function is called to force a user to select a proper
10278 coding system which can encode the text in the case that a default
10279 coding system used in each operation can't encode the text. The
10280 function should take care that the buffer is not modified while
10281 the coding system is being selected.
10283 The default value is `select-safe-coding-system' (which see). */);
10284 Vselect_safe_coding_system_function
= Qnil
;
10286 DEFVAR_BOOL ("coding-system-require-warning",
10287 &coding_system_require_warning
,
10288 doc
: /* Internal use only.
10289 If non-nil, on writing a file, `select-safe-coding-system-function' is
10290 called even if `coding-system-for-write' is non-nil. The command
10291 `universal-coding-system-argument' binds this variable to t temporarily. */);
10292 coding_system_require_warning
= 0;
10295 DEFVAR_BOOL ("inhibit-iso-escape-detection",
10296 &inhibit_iso_escape_detection
,
10298 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
10300 By default, on reading a file, Emacs tries to detect how the text is
10301 encoded. This code detection is sensitive to escape sequences. If
10302 the sequence is valid as ISO2022, the code is determined as one of
10303 the ISO2022 encodings, and the file is decoded by the corresponding
10304 coding system (e.g. `iso-2022-7bit').
10306 However, there may be a case that you want to read escape sequences in
10307 a file as is. In such a case, you can set this variable to non-nil.
10308 Then, as the code detection ignores any escape sequences, no file is
10309 detected as encoded in some ISO2022 encoding. The result is that all
10310 escape sequences become visible in a buffer.
10312 The default value is nil, and it is strongly recommended not to change
10313 it. That is because many Emacs Lisp source files that contain
10314 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
10315 in Emacs's distribution, and they won't be decoded correctly on
10316 reading if you suppress escape sequence detection.
10318 The other way to read escape sequences in a file without decoding is
10319 to explicitly specify some coding system that doesn't use ISO2022's
10320 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
10321 inhibit_iso_escape_detection
= 0;
10323 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input
,
10324 doc
: /* Char table for translating self-inserting characters.
10325 This is applied to the result of input methods, not their input.
10326 See also `keyboard-translate-table'. */);
10327 Vtranslation_table_for_input
= Qnil
;
10330 Lisp_Object args
[coding_arg_max
];
10331 Lisp_Object plist
[16];
10334 for (i
= 0; i
< coding_arg_max
; i
++)
10337 plist
[0] = intern (":name");
10338 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
10339 plist
[2] = intern (":mnemonic");
10340 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
10341 plist
[4] = intern (":coding-type");
10342 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
10343 plist
[6] = intern (":ascii-compatible-p");
10344 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
10345 plist
[8] = intern (":default-char");
10346 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
10347 plist
[10] = intern (":for-unibyte");
10348 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
10349 plist
[12] = intern (":docstring");
10350 plist
[13] = build_string ("Do no conversion.\n\
10352 When you visit a file with this coding, the file is read into a\n\
10353 unibyte buffer as is, thus each byte of a file is treated as a\n\
10355 plist
[14] = intern (":eol-type");
10356 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
10357 args
[coding_arg_plist
] = Flist (16, plist
);
10358 Fdefine_coding_system_internal (coding_arg_max
, args
);
10360 plist
[1] = args
[coding_arg_name
] = Qundecided
;
10361 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
10362 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
10363 /* This is already set.
10364 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
10365 plist
[8] = intern (":charset-list");
10366 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
10367 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
10368 plist
[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
10369 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
10370 args
[coding_arg_plist
] = Flist (16, plist
);
10371 Fdefine_coding_system_internal (coding_arg_max
, args
);
10374 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
10379 for (i
= 0; i
< coding_category_max
; i
++)
10380 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
10382 #if defined (MSDOS) || defined (WINDOWSNT)
10383 system_eol_type
= Qdos
;
10385 system_eol_type
= Qunix
;
10387 staticpro (&system_eol_type
);
10391 emacs_strerror (error_number
)
10396 synchronize_system_messages_locale ();
10397 str
= strerror (error_number
);
10399 if (! NILP (Vlocale_coding_system
))
10401 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
10402 Vlocale_coding_system
,
10404 str
= (char *) SDATA (dec
);
10412 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
10413 (do not change this comment) */