1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2001, 2002 Free Software Foundation, Inc.
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H13PRO009
9 This file is part of GNU Emacs.
11 GNU Emacs is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
16 GNU Emacs is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GNU Emacs; see the file COPYING. If not, write to
23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /*** TABLE OF CONTENTS ***
30 2. Emacs' internal format (emacs-utf-8) handlers
33 5. Charset-base coding systems handlers
34 6. emacs-mule (old Emacs' internal format) handlers
36 8. Shift-JIS and BIG5 handlers
38 10. C library functions
39 11. Emacs Lisp library functions
44 /*** 0. General comments ***
49 A coding system is an object for an encoding mechanism that contains
50 information about how to convert byte sequences to character
51 sequences and vice versa. When we say "decode", it means converting
52 a byte sequence of a specific coding system into a character
53 sequence that is represented by Emacs' internal coding system
54 `emacs-utf-8', and when we say "encode", it means converting a
55 character sequence of emacs-utf-8 to a byte sequence of a specific
58 In Emacs Lisp, a coding system is represented by a Lisp symbol. In
59 C level, a coding system is represented by a vector of attributes
60 stored in the hash table Vcharset_hash_table. The conversion from
61 coding system symbol to attributes vector is done by looking up
62 Vcharset_hash_table by the symbol.
64 Coding systems are classified into the following types depending on
65 the encoding mechanism. Here's a brief description of the types.
71 o Charset-base coding system
73 A coding system defined by one or more (coded) character sets.
74 Decoding and encoding are done by a code converter defined for each
77 o Old Emacs internal format (emacs-mule)
79 The coding system adopted by old versions of Emacs (20 and 21).
81 o ISO2022-base coding system
83 The most famous coding system for multiple character sets. X's
84 Compound Text, various EUCs (Extended Unix Code), and coding systems
85 used in the Internet communication such as ISO-2022-JP are all
88 o SJIS (or Shift-JIS or MS-Kanji-Code)
90 A coding system to encode character sets: ASCII, JISX0201, and
91 JISX0208. Widely used for PC's in Japan. Details are described in
96 A coding system to encode character sets: ASCII and Big5. Widely
97 used for Chinese (mainly in Taiwan and Hong Kong). Details are
98 described in section 8. In this file, when we write "big5" (all
99 lowercase), we mean the coding system, and when we write "Big5"
100 (capitalized), we mean the character set.
104 If a user wants to decode/encode text encoded in a coding system
105 not listed above, he can supply a decoder and an encoder for it in
106 CCL (Code Conversion Language) programs. Emacs executes the CCL
107 program while decoding/encoding.
111 A coding system for text containing raw eight-bit data. Emacs
112 treats each byte of source text as a character (except for
113 end-of-line conversion).
117 Like raw text, but don't do end-of-line conversion.
122 How text end-of-line is encoded depends on operating system. For
123 instance, Unix's format is just one byte of LF (line-feed) code,
124 whereas DOS's format is two-byte sequence of `carriage-return' and
125 `line-feed' codes. MacOS's format is usually one byte of
128 Since text character encoding and end-of-line encoding are
129 independent, any coding system described above can take any format
130 of end-of-line (except for no-conversion).
134 Before using a coding system for code conversion (i.e. decoding and
135 encoding), we setup a structure of type `struct coding_system'.
136 This structure keeps various information about a specific code
137 conversion (e.g. the location of source and destination data).
144 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
146 These functions check if a byte sequence specified as a source in
147 CODING conforms to the format of XXX, and update the members of
150 Return 1 if the byte sequence conforms to XXX, otherwise return 0.
152 Below is the template of these functions. */
156 detect_coding_XXX (coding
, detect_info
)
157 struct coding_system
*coding
;
158 struct coding_detection_info
*detect_info
;
160 const unsigned char *src
= coding
->source
;
161 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
162 int multibytep
= coding
->src_multibyte
;
163 int consumed_chars
= 0;
169 /* Get one byte from the source. If the souce is exausted, jump
170 to no_more_source:. */
173 if (! __C_conforms_to_XXX___ (c
))
175 if (! __C_strongly_suggests_XXX__ (c
))
176 found
= CATEGORY_MASK_XXX
;
178 /* The byte sequence is invalid for XXX. */
179 detect_info
->rejected
|= CATEGORY_MASK_XXX
;
183 /* The source exausted successfully. */
184 detect_info
->found
|= found
;
189 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
191 These functions decode a byte sequence specified as a source by
192 CODING. The resulting multibyte text goes to a place pointed to by
193 CODING->charbuf, the length of which should not exceed
194 CODING->charbuf_size;
196 These functions set the information of original and decoded texts in
197 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
198 They also set CODING->result to one of CODING_RESULT_XXX indicating
199 how the decoding is finished.
201 Below is the template of these functions. */
205 decode_coding_XXXX (coding
)
206 struct coding_system
*coding
;
208 const unsigned char *src
= coding
->source
+ coding
->consumed
;
209 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
210 /* SRC_BASE remembers the start position in source in each loop.
211 The loop will be exited when there's not enough source code, or
212 when there's no room in CHARBUF for a decoded character. */
213 const unsigned char *src_base
;
214 /* A buffer to produce decoded characters. */
215 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
216 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
217 int multibytep
= coding
->src_multibyte
;
222 if (charbuf
< charbuf_end
)
223 /* No more room to produce a decoded character. */
230 if (src_base
< src_end
231 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
232 /* If the source ends by partial bytes to construct a character,
233 treat them as eight-bit raw data. */
234 while (src_base
< src_end
&& charbuf
< charbuf_end
)
235 *charbuf
++ = *src_base
++;
236 /* Remember how many bytes and characters we consumed. If the
237 source is multibyte, the bytes and chars are not identical. */
238 coding
->consumed
= coding
->consumed_char
= src_base
- coding
->source
;
239 /* Remember how many characters we produced. */
240 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
244 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
246 These functions encode SRC_BYTES length text at SOURCE of Emacs'
247 internal multibyte format by CODING. The resulting byte sequence
248 goes to a place pointed to by DESTINATION, the length of which
249 should not exceed DST_BYTES.
251 These functions set the information of original and encoded texts in
252 the members produced, produced_char, consumed, and consumed_char of
253 the structure *CODING. They also set the member result to one of
254 CODING_RESULT_XXX indicating how the encoding finished.
256 DST_BYTES zero means that source area and destination area are
257 overlapped, which means that we can produce a encoded text until it
258 reaches at the head of not-yet-encoded source text.
260 Below is a template of these functions. */
263 encode_coding_XXX (coding
)
264 struct coding_system
*coding
;
266 int multibytep
= coding
->dst_multibyte
;
267 int *charbuf
= coding
->charbuf
;
268 int *charbuf_end
= charbuf
->charbuf
+ coding
->charbuf_used
;
269 unsigned char *dst
= coding
->destination
+ coding
->produced
;
270 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
271 unsigned char *adjusted_dst_end
= dst_end
- _MAX_BYTES_PRODUCED_IN_LOOP_
;
272 int produced_chars
= 0;
274 for (; charbuf
< charbuf_end
&& dst
< adjusted_dst_end
; charbuf
++)
277 /* Encode C into DST, and increment DST. */
279 label_no_more_destination
:
280 /* How many chars and bytes we produced. */
281 coding
->produced_char
+= produced_chars
;
282 coding
->produced
= dst
- coding
->destination
;
287 /*** 1. Preamble ***/
294 #include "character.h"
297 #include "composite.h"
301 Lisp_Object Vcoding_system_hash_table
;
303 Lisp_Object Qcoding_system
, Qcoding_aliases
, Qeol_type
;
304 Lisp_Object Qunix
, Qdos
;
305 extern Lisp_Object Qmac
; /* frame.c */
306 Lisp_Object Qbuffer_file_coding_system
;
307 Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
308 Lisp_Object Qdefault_char
;
309 Lisp_Object Qno_conversion
, Qundecided
;
310 Lisp_Object Qcharset
, Qiso_2022
, Qutf_8
, Qutf_16
, Qshift_jis
, Qbig5
;
311 Lisp_Object Qbig
, Qlittle
;
312 Lisp_Object Qcoding_system_history
;
313 Lisp_Object Qvalid_codes
;
314 Lisp_Object QCcategory
, QCmnemonic
, QCdefalut_char
;
315 Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
316 Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
318 extern Lisp_Object Qinsert_file_contents
, Qwrite_region
;
319 Lisp_Object Qcall_process
, Qcall_process_region
, Qprocess_argument
;
320 Lisp_Object Qstart_process
, Qopen_network_stream
;
321 Lisp_Object Qtarget_idx
;
323 Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
324 Lisp_Object Qinterrupted
, Qinsufficient_memory
;
326 int coding_system_require_warning
;
328 Lisp_Object Vselect_safe_coding_system_function
;
330 /* Mnemonic string for each format of end-of-line. */
331 Lisp_Object eol_mnemonic_unix
, eol_mnemonic_dos
, eol_mnemonic_mac
;
332 /* Mnemonic string to indicate format of end-of-line is not yet
334 Lisp_Object eol_mnemonic_undecided
;
338 Lisp_Object Vcoding_system_list
, Vcoding_system_alist
;
340 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
342 /* Coding system emacs-mule and raw-text are for converting only
343 end-of-line format. */
344 Lisp_Object Qemacs_mule
, Qraw_text
;
345 Lisp_Object Qutf_8_emacs
;
347 /* Coding-systems are handed between Emacs Lisp programs and C internal
348 routines by the following three variables. */
349 /* Coding-system for reading files and receiving data from process. */
350 Lisp_Object Vcoding_system_for_read
;
351 /* Coding-system for writing files and sending data to process. */
352 Lisp_Object Vcoding_system_for_write
;
353 /* Coding-system actually used in the latest I/O. */
354 Lisp_Object Vlast_coding_system_used
;
355 /* Set to non-nil when an error is detected while code conversion. */
356 Lisp_Object Vlast_code_conversion_error
;
357 /* A vector of length 256 which contains information about special
358 Latin codes (especially for dealing with Microsoft codes). */
359 Lisp_Object Vlatin_extra_code_table
;
361 /* Flag to inhibit code conversion of end-of-line format. */
362 int inhibit_eol_conversion
;
364 /* Flag to inhibit ISO2022 escape sequence detection. */
365 int inhibit_iso_escape_detection
;
367 /* Flag to make buffer-file-coding-system inherit from process-coding. */
368 int inherit_process_coding_system
;
370 /* Coding system to be used to encode text for terminal display. */
371 struct coding_system terminal_coding
;
373 /* Coding system to be used to encode text for terminal display when
374 terminal coding system is nil. */
375 struct coding_system safe_terminal_coding
;
377 /* Coding system of what is sent from terminal keyboard. */
378 struct coding_system keyboard_coding
;
380 Lisp_Object Vfile_coding_system_alist
;
381 Lisp_Object Vprocess_coding_system_alist
;
382 Lisp_Object Vnetwork_coding_system_alist
;
384 Lisp_Object Vlocale_coding_system
;
388 /* Flag to tell if we look up translation table on character code
390 Lisp_Object Venable_character_translation
;
391 /* Standard translation table to look up on decoding (reading). */
392 Lisp_Object Vstandard_translation_table_for_decode
;
393 /* Standard translation table to look up on encoding (writing). */
394 Lisp_Object Vstandard_translation_table_for_encode
;
396 Lisp_Object Qtranslation_table
;
397 Lisp_Object Qtranslation_table_id
;
398 Lisp_Object Qtranslation_table_for_decode
;
399 Lisp_Object Qtranslation_table_for_encode
;
401 /* Alist of charsets vs revision number. */
402 static Lisp_Object Vcharset_revision_table
;
404 /* Default coding systems used for process I/O. */
405 Lisp_Object Vdefault_process_coding_system
;
407 /* Char table for translating Quail and self-inserting input. */
408 Lisp_Object Vtranslation_table_for_input
;
410 /* Two special coding systems. */
411 Lisp_Object Vsjis_coding_system
;
412 Lisp_Object Vbig5_coding_system
;
414 /* ISO2022 section */
416 #define CODING_ISO_INITIAL(coding, reg) \
417 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
418 coding_attr_iso_initial), \
422 #define CODING_ISO_REQUEST(coding, charset_id) \
423 ((charset_id <= (coding)->max_charset_id \
424 ? (coding)->safe_charsets[charset_id] \
428 #define CODING_ISO_FLAGS(coding) \
429 ((coding)->spec.iso_2022.flags)
430 #define CODING_ISO_DESIGNATION(coding, reg) \
431 ((coding)->spec.iso_2022.current_designation[reg])
432 #define CODING_ISO_INVOCATION(coding, plane) \
433 ((coding)->spec.iso_2022.current_invocation[plane])
434 #define CODING_ISO_SINGLE_SHIFTING(coding) \
435 ((coding)->spec.iso_2022.single_shifting)
436 #define CODING_ISO_BOL(coding) \
437 ((coding)->spec.iso_2022.bol)
438 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
439 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
441 /* Control characters of ISO2022. */
442 /* code */ /* function */
443 #define ISO_CODE_LF 0x0A /* line-feed */
444 #define ISO_CODE_CR 0x0D /* carriage-return */
445 #define ISO_CODE_SO 0x0E /* shift-out */
446 #define ISO_CODE_SI 0x0F /* shift-in */
447 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
448 #define ISO_CODE_ESC 0x1B /* escape */
449 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
450 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
451 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
453 /* All code (1-byte) of ISO2022 is classified into one of the
455 enum iso_code_class_type
457 ISO_control_0
, /* Control codes in the range
458 0x00..0x1F and 0x7F, except for the
459 following 5 codes. */
460 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
461 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
462 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
463 ISO_escape
, /* ISO_CODE_SO (0x1B) */
464 ISO_control_1
, /* Control codes in the range
465 0x80..0x9F, except for the
466 following 3 codes. */
467 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
468 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
469 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
470 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
471 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
472 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
473 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
476 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
477 `iso-flags' attribute of an iso2022 coding system. */
479 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
480 instead of the correct short-form sequence (e.g. ESC $ A). */
481 #define CODING_ISO_FLAG_LONG_FORM 0x0001
483 /* If set, reset graphic planes and registers at end-of-line to the
485 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
487 /* If set, reset graphic planes and registers before any control
488 characters to the initial state. */
489 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
491 /* If set, encode by 7-bit environment. */
492 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
494 /* If set, use locking-shift function. */
495 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
497 /* If set, use single-shift function. Overwrite
498 CODING_ISO_FLAG_LOCKING_SHIFT. */
499 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
501 /* If set, use designation escape sequence. */
502 #define CODING_ISO_FLAG_DESIGNATION 0x0040
504 /* If set, produce revision number sequence. */
505 #define CODING_ISO_FLAG_REVISION 0x0080
507 /* If set, produce ISO6429's direction specifying sequence. */
508 #define CODING_ISO_FLAG_DIRECTION 0x0100
510 /* If set, assume designation states are reset at beginning of line on
512 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
514 /* If set, designation sequence should be placed at beginning of line
516 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
518 /* If set, do not encode unsafe charactes on output. */
519 #define CODING_ISO_FLAG_SAFE 0x0800
521 /* If set, extra latin codes (128..159) are accepted as a valid code
523 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
525 #define CODING_ISO_FLAG_COMPOSITION 0x2000
527 #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000
529 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
531 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
533 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
535 /* A character to be produced on output if encoding of the original
536 character is prohibited by CODING_ISO_FLAG_SAFE. */
537 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
541 #define CODING_UTF_16_BOM(coding) \
542 ((coding)->spec.utf_16.bom)
544 #define CODING_UTF_16_ENDIAN(coding) \
545 ((coding)->spec.utf_16.endian)
547 #define CODING_UTF_16_SURROGATE(coding) \
548 ((coding)->spec.utf_16.surrogate)
552 #define CODING_CCL_DECODER(coding) \
553 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
554 #define CODING_CCL_ENCODER(coding) \
555 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
556 #define CODING_CCL_VALIDS(coding) \
557 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
559 /* Index for each coding category in `coding_categories' */
563 coding_category_iso_7
,
564 coding_category_iso_7_tight
,
565 coding_category_iso_8_1
,
566 coding_category_iso_8_2
,
567 coding_category_iso_7_else
,
568 coding_category_iso_8_else
,
569 coding_category_utf_8
,
570 coding_category_utf_16_auto
,
571 coding_category_utf_16_be
,
572 coding_category_utf_16_le
,
573 coding_category_utf_16_be_nosig
,
574 coding_category_utf_16_le_nosig
,
575 coding_category_charset
,
576 coding_category_sjis
,
577 coding_category_big5
,
579 coding_category_emacs_mule
,
580 /* All above are targets of code detection. */
581 coding_category_raw_text
,
582 coding_category_undecided
,
586 /* Definitions of flag bits used in detect_coding_XXXX. */
587 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
588 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
589 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
590 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
591 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
592 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
593 #define CATEGORY_MASK_UTF_8 (1 << coding_category_utf_8)
594 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
595 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
596 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
597 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
598 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
599 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
600 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
601 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
602 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
603 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
604 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
606 /* This value is returned if detect_coding_mask () find nothing other
607 than ASCII characters. */
608 #define CATEGORY_MASK_ANY \
609 (CATEGORY_MASK_ISO_7 \
610 | CATEGORY_MASK_ISO_7_TIGHT \
611 | CATEGORY_MASK_ISO_8_1 \
612 | CATEGORY_MASK_ISO_8_2 \
613 | CATEGORY_MASK_ISO_7_ELSE \
614 | CATEGORY_MASK_ISO_8_ELSE \
615 | CATEGORY_MASK_UTF_8 \
616 | CATEGORY_MASK_UTF_16_BE \
617 | CATEGORY_MASK_UTF_16_LE \
618 | CATEGORY_MASK_UTF_16_BE_NOSIG \
619 | CATEGORY_MASK_UTF_16_LE_NOSIG \
620 | CATEGORY_MASK_CHARSET \
621 | CATEGORY_MASK_SJIS \
622 | CATEGORY_MASK_BIG5 \
623 | CATEGORY_MASK_CCL \
624 | CATEGORY_MASK_EMACS_MULE)
627 #define CATEGORY_MASK_ISO_7BIT \
628 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
630 #define CATEGORY_MASK_ISO_8BIT \
631 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
633 #define CATEGORY_MASK_ISO_ELSE \
634 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
636 #define CATEGORY_MASK_ISO_ESCAPE \
637 (CATEGORY_MASK_ISO_7 \
638 | CATEGORY_MASK_ISO_7_TIGHT \
639 | CATEGORY_MASK_ISO_7_ELSE \
640 | CATEGORY_MASK_ISO_8_ELSE)
642 #define CATEGORY_MASK_ISO \
643 ( CATEGORY_MASK_ISO_7BIT \
644 | CATEGORY_MASK_ISO_8BIT \
645 | CATEGORY_MASK_ISO_ELSE)
647 #define CATEGORY_MASK_UTF_16 \
648 (CATEGORY_MASK_UTF_16_BE \
649 | CATEGORY_MASK_UTF_16_LE \
650 | CATEGORY_MASK_UTF_16_BE_NOSIG \
651 | CATEGORY_MASK_UTF_16_LE_NOSIG)
654 /* List of symbols `coding-category-xxx' ordered by priority. This
655 variable is exposed to Emacs Lisp. */
656 static Lisp_Object Vcoding_category_list
;
658 /* Table of coding categories (Lisp symbols). This variable is for
660 static Lisp_Object Vcoding_category_table
;
662 /* Table of coding-categories ordered by priority. */
663 static enum coding_category coding_priorities
[coding_category_max
];
665 /* Nth element is a coding context for the coding system bound to the
666 Nth coding category. */
667 static struct coding_system coding_categories
[coding_category_max
];
669 /*** Commonly used macros and functions ***/
672 #define min(a, b) ((a) < (b) ? (a) : (b))
675 #define max(a, b) ((a) > (b) ? (a) : (b))
678 #define CODING_GET_INFO(coding, attrs, charset_list) \
680 (attrs) = CODING_ID_ATTRS ((coding)->id); \
681 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
685 /* Safely get one byte from the source text pointed by SRC which ends
686 at SRC_END, and set C to that byte. If there are not enough bytes
687 in the source, it jumps to `no_more_source'. If multibytep is
688 nonzero, and a multibyte character is found at SRC, set C to the
689 negative value of the character code. The caller should declare
690 and set these variables appropriately in advance:
691 src, src_end, multibytep */
693 #define ONE_MORE_BYTE(c) \
695 if (src == src_end) \
697 if (src_base < src) \
698 record_conversion_result \
699 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
700 goto no_more_source; \
703 if (multibytep && (c & 0x80)) \
705 if ((c & 0xFE) == 0xC0) \
706 c = ((c & 1) << 6) | *src++; \
709 c = - string_char (--src, &src, NULL); \
710 record_conversion_result \
711 (coding, CODING_RESULT_INVALID_SRC); \
718 #define ONE_MORE_BYTE_NO_CHECK(c) \
721 if (multibytep && (c & 0x80)) \
723 if ((c & 0xFE) == 0xC0) \
724 c = ((c & 1) << 6) | *src++; \
727 c = - string_char (--src, &src, NULL); \
728 record_conversion_result \
729 (coding, CODING_RESULT_INVALID_SRC); \
736 /* Store a byte C in the place pointed by DST and increment DST to the
737 next free point, and increment PRODUCED_CHARS. The caller should
738 assure that C is 0..127, and declare and set the variable `dst'
739 appropriately in advance.
743 #define EMIT_ONE_ASCII_BYTE(c) \
750 /* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
752 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
754 produced_chars += 2; \
755 *dst++ = (c1), *dst++ = (c2); \
759 /* Store a byte C in the place pointed by DST and increment DST to the
760 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
761 nonzero, store in an appropriate multibyte from. The caller should
762 declare and set the variables `dst' and `multibytep' appropriately
765 #define EMIT_ONE_BYTE(c) \
772 ch = BYTE8_TO_CHAR (ch); \
773 CHAR_STRING_ADVANCE (ch, dst); \
780 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
782 #define EMIT_TWO_BYTES(c1, c2) \
784 produced_chars += 2; \
791 ch = BYTE8_TO_CHAR (ch); \
792 CHAR_STRING_ADVANCE (ch, dst); \
795 ch = BYTE8_TO_CHAR (ch); \
796 CHAR_STRING_ADVANCE (ch, dst); \
806 #define EMIT_THREE_BYTES(c1, c2, c3) \
808 EMIT_ONE_BYTE (c1); \
809 EMIT_TWO_BYTES (c2, c3); \
813 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
815 EMIT_TWO_BYTES (c1, c2); \
816 EMIT_TWO_BYTES (c3, c4); \
820 /* Prototypes for static functions. */
821 static void record_conversion_result
P_ ((struct coding_system
*coding
,
822 enum coding_result_code result
));
823 static int detect_coding_utf_8
P_ ((struct coding_system
*,
824 struct coding_detection_info
*info
));
825 static void decode_coding_utf_8
P_ ((struct coding_system
*));
826 static int encode_coding_utf_8
P_ ((struct coding_system
*));
828 static int detect_coding_utf_16
P_ ((struct coding_system
*,
829 struct coding_detection_info
*info
));
830 static void decode_coding_utf_16
P_ ((struct coding_system
*));
831 static int encode_coding_utf_16
P_ ((struct coding_system
*));
833 static int detect_coding_iso_2022
P_ ((struct coding_system
*,
834 struct coding_detection_info
*info
));
835 static void decode_coding_iso_2022
P_ ((struct coding_system
*));
836 static int encode_coding_iso_2022
P_ ((struct coding_system
*));
838 static int detect_coding_emacs_mule
P_ ((struct coding_system
*,
839 struct coding_detection_info
*info
));
840 static void decode_coding_emacs_mule
P_ ((struct coding_system
*));
841 static int encode_coding_emacs_mule
P_ ((struct coding_system
*));
843 static int detect_coding_sjis
P_ ((struct coding_system
*,
844 struct coding_detection_info
*info
));
845 static void decode_coding_sjis
P_ ((struct coding_system
*));
846 static int encode_coding_sjis
P_ ((struct coding_system
*));
848 static int detect_coding_big5
P_ ((struct coding_system
*,
849 struct coding_detection_info
*info
));
850 static void decode_coding_big5
P_ ((struct coding_system
*));
851 static int encode_coding_big5
P_ ((struct coding_system
*));
853 static int detect_coding_ccl
P_ ((struct coding_system
*,
854 struct coding_detection_info
*info
));
855 static void decode_coding_ccl
P_ ((struct coding_system
*));
856 static int encode_coding_ccl
P_ ((struct coding_system
*));
858 static void decode_coding_raw_text
P_ ((struct coding_system
*));
859 static int encode_coding_raw_text
P_ ((struct coding_system
*));
861 static void coding_set_source
P_ ((struct coding_system
*));
862 static void coding_set_destination
P_ ((struct coding_system
*));
863 static void coding_alloc_by_realloc
P_ ((struct coding_system
*, EMACS_INT
));
864 static void coding_alloc_by_making_gap
P_ ((struct coding_system
*,
866 static unsigned char *alloc_destination
P_ ((struct coding_system
*,
867 EMACS_INT
, unsigned char *));
868 static void setup_iso_safe_charsets
P_ ((Lisp_Object
));
869 static unsigned char *encode_designation_at_bol
P_ ((struct coding_system
*,
872 static int detect_eol
P_ ((const unsigned char *,
873 EMACS_INT
, enum coding_category
));
874 static Lisp_Object adjust_coding_eol_type
P_ ((struct coding_system
*, int));
875 static void decode_eol
P_ ((struct coding_system
*));
876 static Lisp_Object get_translation_table
P_ ((Lisp_Object
, int, int *));
877 static Lisp_Object get_translation
P_ ((Lisp_Object
, int *, int *,
879 static int produce_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
880 static INLINE
void produce_composition
P_ ((struct coding_system
*, int *,
882 static INLINE
void produce_charset
P_ ((struct coding_system
*, int *,
884 static void produce_annotation
P_ ((struct coding_system
*, EMACS_INT
));
885 static int decode_coding
P_ ((struct coding_system
*));
886 static INLINE
int *handle_composition_annotation
P_ ((EMACS_INT
, EMACS_INT
,
887 struct coding_system
*,
888 int *, EMACS_INT
*));
889 static INLINE
int *handle_charset_annotation
P_ ((EMACS_INT
, EMACS_INT
,
890 struct coding_system
*,
891 int *, EMACS_INT
*));
892 static void consume_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
893 static int encode_coding
P_ ((struct coding_system
*));
894 static Lisp_Object make_conversion_work_buffer
P_ ((int));
895 static Lisp_Object code_conversion_restore
P_ ((Lisp_Object
));
896 static INLINE
int char_encodable_p
P_ ((int, Lisp_Object
));
897 static Lisp_Object make_subsidiaries
P_ ((Lisp_Object
));
900 record_conversion_result (struct coding_system
*coding
,
901 enum coding_result_code result
)
903 coding
->result
= result
;
906 case CODING_RESULT_INSUFFICIENT_SRC
:
907 Vlast_code_conversion_error
= Qinsufficient_source
;
909 case CODING_RESULT_INCONSISTENT_EOL
:
910 Vlast_code_conversion_error
= Qinconsistent_eol
;
912 case CODING_RESULT_INVALID_SRC
:
913 Vlast_code_conversion_error
= Qinvalid_source
;
915 case CODING_RESULT_INTERRUPT
:
916 Vlast_code_conversion_error
= Qinterrupted
;
918 case CODING_RESULT_INSUFFICIENT_MEM
:
919 Vlast_code_conversion_error
= Qinsufficient_memory
;
924 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
926 charset_map_loaded = 0; \
927 c = DECODE_CHAR (charset, code); \
928 if (charset_map_loaded) \
930 const unsigned char *orig = coding->source; \
933 coding_set_source (coding); \
934 offset = coding->source - orig; \
936 src_base += offset; \
942 #define ASSURE_DESTINATION(bytes) \
944 if (dst + (bytes) >= dst_end) \
946 int more_bytes = charbuf_end - charbuf + (bytes); \
948 dst = alloc_destination (coding, more_bytes, dst); \
949 dst_end = coding->destination + coding->dst_bytes; \
956 coding_set_source (coding
)
957 struct coding_system
*coding
;
959 if (BUFFERP (coding
->src_object
))
961 struct buffer
*buf
= XBUFFER (coding
->src_object
);
963 if (coding
->src_pos
< 0)
964 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
966 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
968 else if (STRINGP (coding
->src_object
))
970 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
973 /* Otherwise, the source is C string and is never relocated
974 automatically. Thus we don't have to update anything. */
979 coding_set_destination (coding
)
980 struct coding_system
*coding
;
982 if (BUFFERP (coding
->dst_object
))
984 if (coding
->src_pos
< 0)
986 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- 1;
987 coding
->dst_bytes
= (GAP_END_ADDR
988 - (coding
->src_bytes
- coding
->consumed
)
989 - coding
->destination
);
993 /* We are sure that coding->dst_pos_byte is before the gap
995 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
996 + coding
->dst_pos_byte
- 1);
997 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
998 - coding
->destination
);
1002 /* Otherwise, the destination is C string and is never relocated
1003 automatically. Thus we don't have to update anything. */
1009 coding_alloc_by_realloc (coding
, bytes
)
1010 struct coding_system
*coding
;
1013 coding
->destination
= (unsigned char *) xrealloc (coding
->destination
,
1014 coding
->dst_bytes
+ bytes
);
1015 coding
->dst_bytes
+= bytes
;
1019 coding_alloc_by_making_gap (coding
, bytes
)
1020 struct coding_system
*coding
;
1023 if (BUFFERP (coding
->dst_object
)
1024 && EQ (coding
->src_object
, coding
->dst_object
))
1026 EMACS_INT add
= coding
->src_bytes
- coding
->consumed
;
1028 GAP_SIZE
-= add
; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1030 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1034 Lisp_Object this_buffer
;
1036 this_buffer
= Fcurrent_buffer ();
1037 set_buffer_internal (XBUFFER (coding
->dst_object
));
1039 set_buffer_internal (XBUFFER (this_buffer
));
1044 static unsigned char *
1045 alloc_destination (coding
, nbytes
, dst
)
1046 struct coding_system
*coding
;
1050 EMACS_INT offset
= dst
- coding
->destination
;
1052 if (BUFFERP (coding
->dst_object
))
1053 coding_alloc_by_making_gap (coding
, nbytes
);
1055 coding_alloc_by_realloc (coding
, nbytes
);
1056 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1057 coding_set_destination (coding
);
1058 dst
= coding
->destination
+ offset
;
1062 /** Macros for annotations. */
1064 /* Maximum length of annotation data (sum of annotations for
1065 composition and charset). */
1066 #define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
1068 /* An annotation data is stored in the array coding->charbuf in this
1070 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1071 LENGTH is the number of elements in the annotation.
1072 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1073 NCHARS is the number of characters in the text annotated.
1075 The format of the following elements depend on ANNOTATION_MASK.
1077 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1079 ... METHOD [ COMPOSITION-COMPONENTS ... ]
1080 METHOD is one of enum composition_method.
1081 Optionnal COMPOSITION-COMPONENTS are characters and composition
1084 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1087 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1089 *(buf)++ = -(len); \
1090 *(buf)++ = (mask); \
1091 *(buf)++ = (nchars); \
1092 coding->annotated = 1; \
1095 #define ADD_COMPOSITION_DATA(buf, nchars, method) \
1097 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1102 #define ADD_CHARSET_DATA(buf, nchars, id) \
1104 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1109 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1116 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1117 Check if a text is encoded in UTF-8. If it is, return 1, else
1120 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1121 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1122 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1123 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1124 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1125 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1128 detect_coding_utf_8 (coding
, detect_info
)
1129 struct coding_system
*coding
;
1130 struct coding_detection_info
*detect_info
;
1132 const unsigned char *src
= coding
->source
, *src_base
;
1133 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1134 int multibytep
= coding
->src_multibyte
;
1135 int consumed_chars
= 0;
1138 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1139 /* A coding system of this category is always ASCII compatible. */
1140 src
+= coding
->head_ascii
;
1144 int c
, c1
, c2
, c3
, c4
;
1148 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1151 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1153 if (UTF_8_2_OCTET_LEADING_P (c
))
1155 found
= CATEGORY_MASK_UTF_8
;
1159 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1161 if (UTF_8_3_OCTET_LEADING_P (c
))
1163 found
= CATEGORY_MASK_UTF_8
;
1167 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1169 if (UTF_8_4_OCTET_LEADING_P (c
))
1171 found
= CATEGORY_MASK_UTF_8
;
1175 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1177 if (UTF_8_5_OCTET_LEADING_P (c
))
1179 found
= CATEGORY_MASK_UTF_8
;
1184 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1188 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1190 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1193 detect_info
->found
|= found
;
1199 decode_coding_utf_8 (coding
)
1200 struct coding_system
*coding
;
1202 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1203 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1204 const unsigned char *src_base
;
1205 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1206 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1207 int consumed_chars
= 0, consumed_chars_base
;
1208 int multibytep
= coding
->src_multibyte
;
1209 Lisp_Object attr
, charset_list
;
1211 CODING_GET_INFO (coding
, attr
, charset_list
);
1215 int c
, c1
, c2
, c3
, c4
, c5
;
1218 consumed_chars_base
= consumed_chars
;
1220 if (charbuf
>= charbuf_end
)
1228 else if (UTF_8_1_OCTET_P(c1
))
1235 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1237 if (UTF_8_2_OCTET_LEADING_P (c1
))
1239 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1240 /* Reject overlong sequences here and below. Encoders
1241 producing them are incorrect, they can be misleading,
1242 and they mess up read/write invariance. */
1249 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1251 if (UTF_8_3_OCTET_LEADING_P (c1
))
1253 c
= (((c1
& 0xF) << 12)
1254 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1256 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1262 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1264 if (UTF_8_4_OCTET_LEADING_P (c1
))
1266 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1267 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1274 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1276 if (UTF_8_5_OCTET_LEADING_P (c1
))
1278 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1279 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1281 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1296 consumed_chars
= consumed_chars_base
;
1298 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1303 coding
->consumed_char
+= consumed_chars_base
;
1304 coding
->consumed
= src_base
- coding
->source
;
1305 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1310 encode_coding_utf_8 (coding
)
1311 struct coding_system
*coding
;
1313 int multibytep
= coding
->dst_multibyte
;
1314 int *charbuf
= coding
->charbuf
;
1315 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1316 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1317 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1318 int produced_chars
= 0;
1323 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1325 while (charbuf
< charbuf_end
)
1327 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1329 ASSURE_DESTINATION (safe_room
);
1331 if (CHAR_BYTE8_P (c
))
1333 c
= CHAR_TO_BYTE8 (c
);
1338 CHAR_STRING_ADVANCE (c
, pend
);
1339 for (p
= str
; p
< pend
; p
++)
1346 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1348 while (charbuf
< charbuf_end
)
1350 ASSURE_DESTINATION (safe_room
);
1352 if (CHAR_BYTE8_P (c
))
1353 *dst
++ = CHAR_TO_BYTE8 (c
);
1355 dst
+= CHAR_STRING (c
, dst
);
1359 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1360 coding
->produced_char
+= produced_chars
;
1361 coding
->produced
= dst
- coding
->destination
;
1366 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1367 Check if a text is encoded in one of UTF-16 based coding systems.
1368 If it is, return 1, else return 0. */
1370 #define UTF_16_HIGH_SURROGATE_P(val) \
1371 (((val) & 0xFC00) == 0xD800)
1373 #define UTF_16_LOW_SURROGATE_P(val) \
1374 (((val) & 0xFC00) == 0xDC00)
1376 #define UTF_16_INVALID_P(val) \
1377 (((val) == 0xFFFE) \
1378 || ((val) == 0xFFFF) \
1379 || UTF_16_LOW_SURROGATE_P (val))
1383 detect_coding_utf_16 (coding
, detect_info
)
1384 struct coding_system
*coding
;
1385 struct coding_detection_info
*detect_info
;
1387 const unsigned char *src
= coding
->source
, *src_base
= src
;
1388 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1389 int multibytep
= coding
->src_multibyte
;
1390 int consumed_chars
= 0;
1393 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1394 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1395 && (coding
->src_chars
& 1))
1397 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1403 if ((c1
== 0xFF) && (c2
== 0xFE))
1405 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1406 | CATEGORY_MASK_UTF_16_AUTO
);
1407 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1408 | CATEGORY_MASK_UTF_16_BE_NOSIG
1409 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1411 else if ((c1
== 0xFE) && (c2
== 0xFF))
1413 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1414 | CATEGORY_MASK_UTF_16_AUTO
);
1415 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1416 | CATEGORY_MASK_UTF_16_BE_NOSIG
1417 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1419 else if (c1
>= 0 && c2
>= 0)
1421 detect_info
->rejected
1422 |= (CATEGORY_MASK_UTF_16_BE
| CATEGORY_MASK_UTF_16_LE
);
1429 decode_coding_utf_16 (coding
)
1430 struct coding_system
*coding
;
1432 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1433 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1434 const unsigned char *src_base
;
1435 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1436 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1437 int consumed_chars
= 0, consumed_chars_base
;
1438 int multibytep
= coding
->src_multibyte
;
1439 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1440 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1441 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1442 Lisp_Object attr
, charset_list
;
1444 CODING_GET_INFO (coding
, attr
, charset_list
);
1446 if (bom
== utf_16_with_bom
)
1455 if (endian
== utf_16_big_endian
1456 ? c
!= 0xFEFF : c
!= 0xFFFE)
1458 /* The first two bytes are not BOM. Treat them as bytes
1459 for a normal character. */
1463 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1465 else if (bom
== utf_16_detect_bom
)
1467 /* We have already tried to detect BOM and failed in
1469 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1477 consumed_chars_base
= consumed_chars
;
1479 if (charbuf
+ 2 >= charbuf_end
)
1491 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1495 c
= (endian
== utf_16_big_endian
1496 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1499 if (! UTF_16_LOW_SURROGATE_P (c
))
1501 if (endian
== utf_16_big_endian
)
1502 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1504 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1508 if (UTF_16_HIGH_SURROGATE_P (c
))
1509 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1515 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1516 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1517 *charbuf
++ = 0x10000 + c
;
1522 if (UTF_16_HIGH_SURROGATE_P (c
))
1523 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1530 coding
->consumed_char
+= consumed_chars_base
;
1531 coding
->consumed
= src_base
- coding
->source
;
1532 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1536 encode_coding_utf_16 (coding
)
1537 struct coding_system
*coding
;
1539 int multibytep
= coding
->dst_multibyte
;
1540 int *charbuf
= coding
->charbuf
;
1541 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1542 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1543 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1545 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1546 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1547 int produced_chars
= 0;
1548 Lisp_Object attrs
, charset_list
;
1551 CODING_GET_INFO (coding
, attrs
, charset_list
);
1553 if (bom
!= utf_16_without_bom
)
1555 ASSURE_DESTINATION (safe_room
);
1557 EMIT_TWO_BYTES (0xFE, 0xFF);
1559 EMIT_TWO_BYTES (0xFF, 0xFE);
1560 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1563 while (charbuf
< charbuf_end
)
1565 ASSURE_DESTINATION (safe_room
);
1567 if (c
>= MAX_UNICODE_CHAR
)
1568 c
= coding
->default_char
;
1573 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1575 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1582 c1
= (c
>> 10) + 0xD800;
1583 c2
= (c
& 0x3FF) + 0xDC00;
1585 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1587 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1590 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1591 coding
->produced
= dst
- coding
->destination
;
1592 coding
->produced_char
+= produced_chars
;
1597 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1599 /* Emacs' internal format for representation of multiple character
1600 sets is a kind of multi-byte encoding, i.e. characters are
1601 represented by variable-length sequences of one-byte codes.
1603 ASCII characters and control characters (e.g. `tab', `newline') are
1604 represented by one-byte sequences which are their ASCII codes, in
1605 the range 0x00 through 0x7F.
1607 8-bit characters of the range 0x80..0x9F are represented by
1608 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1611 8-bit characters of the range 0xA0..0xFF are represented by
1612 one-byte sequences which are their 8-bit code.
1614 The other characters are represented by a sequence of `base
1615 leading-code', optional `extended leading-code', and one or two
1616 `position-code's. The length of the sequence is determined by the
1617 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1618 whereas extended leading-code and position-code take the range 0xA0
1619 through 0xFF. See `charset.h' for more details about leading-code
1622 --- CODE RANGE of Emacs' internal format ---
1626 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1627 eight-bit-graphic 0xA0..0xBF
1628 ELSE 0x81..0x9D + [0xA0..0xFF]+
1629 ---------------------------------------------
1631 As this is the internal character representation, the format is
1632 usually not used externally (i.e. in a file or in a data sent to a
1633 process). But, it is possible to have a text externally in this
1634 format (i.e. by encoding by the coding system `emacs-mule').
1636 In that case, a sequence of one-byte codes has a slightly different
1639 At first, all characters in eight-bit-control are represented by
1640 one-byte sequences which are their 8-bit code.
1642 Next, character composition data are represented by the byte
1643 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1645 METHOD is 0xF0 plus one of composition method (enum
1646 composition_method),
1648 BYTES is 0xA0 plus a byte length of this composition data,
1650 CHARS is 0x20 plus a number of characters composed by this
1653 COMPONENTs are characters of multibye form or composition
1654 rules encoded by two-byte of ASCII codes.
1656 In addition, for backward compatibility, the following formats are
1657 also recognized as composition data on decoding.
1660 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1663 MSEQ is a multibyte form but in these special format:
1664 ASCII: 0xA0 ASCII_CODE+0x80,
1665 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1666 RULE is a one byte code of the range 0xA0..0xF0 that
1667 represents a composition rule.
1670 char emacs_mule_bytes
[256];
1673 emacs_mule_char (coding
, src
, nbytes
, nchars
, id
)
1674 struct coding_system
*coding
;
1675 const unsigned char *src
;
1676 int *nbytes
, *nchars
, *id
;
1678 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1679 const unsigned char *src_base
= src
;
1680 int multibytep
= coding
->src_multibyte
;
1681 struct charset
*charset
;
1684 int consumed_chars
= 0;
1690 charset
= emacs_mule_charset
[0];
1694 switch (emacs_mule_bytes
[c
])
1697 if (! (charset
= emacs_mule_charset
[c
]))
1706 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1707 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1710 if (c
< 0xA0 || ! (charset
= emacs_mule_charset
[c
]))
1719 if (! (charset
= emacs_mule_charset
[c
]))
1724 code
= (c
& 0x7F) << 8;
1734 if (c
< 0 || ! (charset
= emacs_mule_charset
[c
]))
1739 code
= (c
& 0x7F) << 8;
1748 charset
= CHARSET_FROM_ID (ASCII_BYTE_P (code
)
1749 ? charset_ascii
: charset_eight_bit
);
1755 c
= DECODE_CHAR (charset
, code
);
1759 *nbytes
= src
- src_base
;
1760 *nchars
= consumed_chars
;
1773 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1774 Check if a text is encoded in `emacs-mule'. If it is, return 1,
1778 detect_coding_emacs_mule (coding
, detect_info
)
1779 struct coding_system
*coding
;
1780 struct coding_detection_info
*detect_info
;
1782 const unsigned char *src
= coding
->source
, *src_base
;
1783 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1784 int multibytep
= coding
->src_multibyte
;
1785 int consumed_chars
= 0;
1789 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1790 /* A coding system of this category is always ASCII compatible. */
1791 src
+= coding
->head_ascii
;
1801 /* Perhaps the start of composite character. We simple skip
1802 it because analyzing it is too heavy for detecting. But,
1803 at least, we check that the composite character
1804 constitues of more than 4 bytes. */
1805 const unsigned char *src_base
;
1815 if (src
- src_base
<= 4)
1817 found
= CATEGORY_MASK_EMACS_MULE
;
1825 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1830 int more_bytes
= emacs_mule_bytes
[*src_base
] - 1;
1832 while (more_bytes
> 0)
1837 src
--; /* Unread the last byte. */
1842 if (more_bytes
!= 0)
1844 found
= CATEGORY_MASK_EMACS_MULE
;
1847 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1851 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1853 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1856 detect_info
->found
|= found
;
1861 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
1863 /* Decode a character represented as a component of composition
1864 sequence of Emacs 20/21 style at SRC. Set C to that character and
1865 update SRC to the head of next character (or an encoded composition
1866 rule). If SRC doesn't points a composition component, set C to -1.
1867 If SRC points an invalid byte sequence, global exit by a return
1870 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
1874 int nbytes, nchars; \
1876 if (src == src_end) \
1878 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
1883 goto invalid_code; \
1887 consumed_chars += nchars; \
1892 /* Decode a composition rule represented as a component of composition
1893 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
1894 and increment BUF. If SRC points an invalid byte sequence, set C
1897 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
1899 int c, gref, nref; \
1901 if (src >= src_end) \
1902 goto invalid_code; \
1903 ONE_MORE_BYTE_NO_CHECK (c); \
1905 if (c < 0 || c >= 81) \
1906 goto invalid_code; \
1908 gref = c / 9, nref = c % 9; \
1909 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1913 /* Decode a composition rule represented as a component of composition
1914 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
1915 and increment BUF. If SRC points an invalid byte sequence, set C
1918 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
1922 if (src + 1>= src_end) \
1923 goto invalid_code; \
1924 ONE_MORE_BYTE_NO_CHECK (gref); \
1926 ONE_MORE_BYTE_NO_CHECK (nref); \
1928 if (gref < 0 || gref >= 81 \
1929 || nref < 0 || nref >= 81) \
1930 goto invalid_code; \
1931 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1935 #define DECODE_EMACS_MULE_21_COMPOSITION(c) \
1937 /* Emacs 21 style format. The first three bytes at SRC are \
1938 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
1939 the byte length of this composition information, CHARS is the \
1940 number of characters composed by this composition. */ \
1941 enum composition_method method = c - 0xF2; \
1942 int *charbuf_base = charbuf; \
1943 int consumed_chars_limit; \
1944 int nbytes, nchars; \
1946 ONE_MORE_BYTE (c); \
1948 goto invalid_code; \
1949 nbytes = c - 0xA0; \
1951 goto invalid_code; \
1952 ONE_MORE_BYTE (c); \
1954 goto invalid_code; \
1955 nchars = c - 0xA0; \
1956 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
1957 consumed_chars_limit = consumed_chars_base + nbytes; \
1958 if (method != COMPOSITION_RELATIVE) \
1961 while (consumed_chars < consumed_chars_limit) \
1963 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
1964 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
1966 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
1969 if (consumed_chars < consumed_chars_limit) \
1970 goto invalid_code; \
1971 charbuf_base[0] -= i; \
1976 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
1978 /* Emacs 20 style format for relative composition. */ \
1979 /* Store multibyte form of characters to be composed. */ \
1980 enum composition_method method = COMPOSITION_RELATIVE; \
1981 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
1982 int *buf = components; \
1986 ONE_MORE_BYTE (c); /* skip 0x80 */ \
1987 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
1988 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
1990 goto invalid_code; \
1991 ADD_COMPOSITION_DATA (charbuf, i, method); \
1992 for (j = 0; j < i; j++) \
1993 *charbuf++ = components[j]; \
1997 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
1999 /* Emacs 20 style format for rule-base composition. */ \
2000 /* Store multibyte form of characters to be composed. */ \
2001 enum composition_method method = COMPOSITION_WITH_RULE; \
2002 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2003 int *buf = components; \
2006 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2007 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
2009 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
2010 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2012 if (i < 1 || (buf - components) % 2 == 0) \
2013 goto invalid_code; \
2014 if (charbuf + i + (i / 2) + 1 < charbuf_end) \
2015 goto no_more_source; \
2016 ADD_COMPOSITION_DATA (buf, i, method); \
2017 for (j = 0; j < i; j++) \
2018 *charbuf++ = components[j]; \
2019 for (j = 0; j < i; j += 2) \
2020 *charbuf++ = components[j]; \
2025 decode_coding_emacs_mule (coding
)
2026 struct coding_system
*coding
;
2028 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2029 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2030 const unsigned char *src_base
;
2031 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2033 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
2034 int consumed_chars
= 0, consumed_chars_base
;
2035 int multibytep
= coding
->src_multibyte
;
2036 Lisp_Object attrs
, charset_list
;
2037 int char_offset
= coding
->produced_char
;
2038 int last_offset
= char_offset
;
2039 int last_id
= charset_ascii
;
2041 CODING_GET_INFO (coding
, attrs
, charset_list
);
2048 consumed_chars_base
= consumed_chars
;
2050 if (charbuf
>= charbuf_end
)
2069 if (c
- 0xF2 >= COMPOSITION_RELATIVE
2070 && c
- 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS
)
2071 DECODE_EMACS_MULE_21_COMPOSITION (c
);
2073 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c
);
2075 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c
);
2079 else if (c
< 0xA0 && emacs_mule_bytes
[c
] > 1)
2085 consumed_chars
= consumed_chars_base
;
2086 c
= emacs_mule_char (coding
, src
, &nbytes
, &nchars
, &id
);
2095 if (last_id
!= charset_ascii
)
2096 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2098 last_offset
= char_offset
;
2102 consumed_chars
+= nchars
;
2109 consumed_chars
= consumed_chars_base
;
2111 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2117 if (last_id
!= charset_ascii
)
2118 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2119 coding
->consumed_char
+= consumed_chars_base
;
2120 coding
->consumed
= src_base
- coding
->source
;
2121 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2125 #define EMACS_MULE_LEADING_CODES(id, codes) \
2128 codes[0] = id, codes[1] = 0; \
2129 else if (id < 0xE0) \
2130 codes[0] = 0x9A, codes[1] = id; \
2131 else if (id < 0xF0) \
2132 codes[0] = 0x9B, codes[1] = id; \
2133 else if (id < 0xF5) \
2134 codes[0] = 0x9C, codes[1] = id; \
2136 codes[0] = 0x9D, codes[1] = id; \
2141 encode_coding_emacs_mule (coding
)
2142 struct coding_system
*coding
;
2144 int multibytep
= coding
->dst_multibyte
;
2145 int *charbuf
= coding
->charbuf
;
2146 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2147 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2148 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2150 int produced_chars
= 0;
2151 Lisp_Object attrs
, charset_list
;
2153 int preferred_charset_id
= -1;
2155 CODING_GET_INFO (coding
, attrs
, charset_list
);
2156 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2158 CODING_ATTR_CHARSET_LIST (attrs
)
2159 = charset_list
= Vemacs_mule_charset_list
;
2162 while (charbuf
< charbuf_end
)
2164 ASSURE_DESTINATION (safe_room
);
2169 /* Handle an annotation. */
2172 case CODING_ANNOTATE_COMPOSITION_MASK
:
2173 /* Not yet implemented. */
2175 case CODING_ANNOTATE_CHARSET_MASK
:
2176 preferred_charset_id
= charbuf
[3];
2177 if (preferred_charset_id
>= 0
2178 && NILP (Fmemq (make_number (preferred_charset_id
),
2180 preferred_charset_id
= -1;
2189 if (ASCII_CHAR_P (c
))
2190 EMIT_ONE_ASCII_BYTE (c
);
2191 else if (CHAR_BYTE8_P (c
))
2193 c
= CHAR_TO_BYTE8 (c
);
2198 struct charset
*charset
;
2202 unsigned char leading_codes
[2];
2204 if (preferred_charset_id
>= 0)
2206 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2207 if (! CHAR_CHARSET_P (c
, charset
))
2208 charset
= char_charset (c
, charset_list
, NULL
);
2211 charset
= char_charset (c
, charset_list
, &code
);
2214 c
= coding
->default_char
;
2215 if (ASCII_CHAR_P (c
))
2217 EMIT_ONE_ASCII_BYTE (c
);
2220 charset
= char_charset (c
, charset_list
, &code
);
2222 dimension
= CHARSET_DIMENSION (charset
);
2223 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2224 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2225 EMIT_ONE_BYTE (leading_codes
[0]);
2226 if (leading_codes
[1])
2227 EMIT_ONE_BYTE (leading_codes
[1]);
2229 EMIT_ONE_BYTE (code
| 0x80);
2233 EMIT_ONE_BYTE (code
>> 8);
2234 EMIT_ONE_BYTE (code
& 0xFF);
2238 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2239 coding
->produced_char
+= produced_chars
;
2240 coding
->produced
= dst
- coding
->destination
;
2245 /*** 7. ISO2022 handlers ***/
2247 /* The following note describes the coding system ISO2022 briefly.
2248 Since the intention of this note is to help understand the
2249 functions in this file, some parts are NOT ACCURATE or are OVERLY
2250 SIMPLIFIED. For thorough understanding, please refer to the
2251 original document of ISO2022. This is equivalent to the standard
2252 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2254 ISO2022 provides many mechanisms to encode several character sets
2255 in 7-bit and 8-bit environments. For 7-bit environments, all text
2256 is encoded using bytes less than 128. This may make the encoded
2257 text a little bit longer, but the text passes more easily through
2258 several types of gateway, some of which strip off the MSB (Most
2261 There are two kinds of character sets: control character sets and
2262 graphic character sets. The former contain control characters such
2263 as `newline' and `escape' to provide control functions (control
2264 functions are also provided by escape sequences). The latter
2265 contain graphic characters such as 'A' and '-'. Emacs recognizes
2266 two control character sets and many graphic character sets.
2268 Graphic character sets are classified into one of the following
2269 four classes, according to the number of bytes (DIMENSION) and
2270 number of characters in one dimension (CHARS) of the set:
2271 - DIMENSION1_CHARS94
2272 - DIMENSION1_CHARS96
2273 - DIMENSION2_CHARS94
2274 - DIMENSION2_CHARS96
2276 In addition, each character set is assigned an identification tag,
2277 unique for each set, called the "final character" (denoted as <F>
2278 hereafter). The <F> of each character set is decided by ECMA(*)
2279 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2280 (0x30..0x3F are for private use only).
2282 Note (*): ECMA = European Computer Manufacturers Association
2284 Here are examples of graphic character sets [NAME(<F>)]:
2285 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2286 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2287 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2288 o DIMENSION2_CHARS96 -- none for the moment
2290 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2291 C0 [0x00..0x1F] -- control character plane 0
2292 GL [0x20..0x7F] -- graphic character plane 0
2293 C1 [0x80..0x9F] -- control character plane 1
2294 GR [0xA0..0xFF] -- graphic character plane 1
2296 A control character set is directly designated and invoked to C0 or
2297 C1 by an escape sequence. The most common case is that:
2298 - ISO646's control character set is designated/invoked to C0, and
2299 - ISO6429's control character set is designated/invoked to C1,
2300 and usually these designations/invocations are omitted in encoded
2301 text. In a 7-bit environment, only C0 can be used, and a control
2302 character for C1 is encoded by an appropriate escape sequence to
2303 fit into the environment. All control characters for C1 are
2304 defined to have corresponding escape sequences.
2306 A graphic character set is at first designated to one of four
2307 graphic registers (G0 through G3), then these graphic registers are
2308 invoked to GL or GR. These designations and invocations can be
2309 done independently. The most common case is that G0 is invoked to
2310 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2311 these invocations and designations are omitted in encoded text.
2312 In a 7-bit environment, only GL can be used.
2314 When a graphic character set of CHARS94 is invoked to GL, codes
2315 0x20 and 0x7F of the GL area work as control characters SPACE and
2316 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2319 There are two ways of invocation: locking-shift and single-shift.
2320 With locking-shift, the invocation lasts until the next different
2321 invocation, whereas with single-shift, the invocation affects the
2322 following character only and doesn't affect the locking-shift
2323 state. Invocations are done by the following control characters or
2326 ----------------------------------------------------------------------
2327 abbrev function cntrl escape seq description
2328 ----------------------------------------------------------------------
2329 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2330 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2331 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2332 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2333 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2334 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2335 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2336 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2337 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2338 ----------------------------------------------------------------------
2339 (*) These are not used by any known coding system.
2341 Control characters for these functions are defined by macros
2342 ISO_CODE_XXX in `coding.h'.
2344 Designations are done by the following escape sequences:
2345 ----------------------------------------------------------------------
2346 escape sequence description
2347 ----------------------------------------------------------------------
2348 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2349 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2350 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2351 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2352 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2353 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2354 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2355 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2356 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2357 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2358 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2359 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2360 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2361 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2362 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2363 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2364 ----------------------------------------------------------------------
2366 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2367 of dimension 1, chars 94, and final character <F>, etc...
2369 Note (*): Although these designations are not allowed in ISO2022,
2370 Emacs accepts them on decoding, and produces them on encoding
2371 CHARS96 character sets in a coding system which is characterized as
2372 7-bit environment, non-locking-shift, and non-single-shift.
2374 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2375 '(' must be omitted. We refer to this as "short-form" hereafter.
2377 Now you may notice that there are a lot of ways of encoding the
2378 same multilingual text in ISO2022. Actually, there exist many
2379 coding systems such as Compound Text (used in X11's inter client
2380 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2381 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2382 localized platforms), and all of these are variants of ISO2022.
2384 In addition to the above, Emacs handles two more kinds of escape
2385 sequences: ISO6429's direction specification and Emacs' private
2386 sequence for specifying character composition.
2388 ISO6429's direction specification takes the following form:
2389 o CSI ']' -- end of the current direction
2390 o CSI '0' ']' -- end of the current direction
2391 o CSI '1' ']' -- start of left-to-right text
2392 o CSI '2' ']' -- start of right-to-left text
2393 The control character CSI (0x9B: control sequence introducer) is
2394 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2396 Character composition specification takes the following form:
2397 o ESC '0' -- start relative composition
2398 o ESC '1' -- end composition
2399 o ESC '2' -- start rule-base composition (*)
2400 o ESC '3' -- start relative composition with alternate chars (**)
2401 o ESC '4' -- start rule-base composition with alternate chars (**)
2402 Since these are not standard escape sequences of any ISO standard,
2403 the use of them with these meanings is restricted to Emacs only.
2405 (*) This form is used only in Emacs 20.7 and older versions,
2406 but newer versions can safely decode it.
2407 (**) This form is used only in Emacs 21.1 and newer versions,
2408 and older versions can't decode it.
2410 Here's a list of example usages of these composition escape
2411 sequences (categorized by `enum composition_method').
2413 COMPOSITION_RELATIVE:
2414 ESC 0 CHAR [ CHAR ] ESC 1
2415 COMPOSITION_WITH_RULE:
2416 ESC 2 CHAR [ RULE CHAR ] ESC 1
2417 COMPOSITION_WITH_ALTCHARS:
2418 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2419 COMPOSITION_WITH_RULE_ALTCHARS:
2420 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2422 enum iso_code_class_type iso_code_class
[256];
2424 #define SAFE_CHARSET_P(coding, id) \
2425 ((id) <= (coding)->max_charset_id \
2426 && (coding)->safe_charsets[id] >= 0)
2429 #define SHIFT_OUT_OK(category) \
2430 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2433 setup_iso_safe_charsets (attrs
)
2436 Lisp_Object charset_list
, safe_charsets
;
2437 Lisp_Object request
;
2438 Lisp_Object reg_usage
;
2441 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2444 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2445 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2446 && ! EQ (charset_list
, Viso_2022_charset_list
))
2448 CODING_ATTR_CHARSET_LIST (attrs
)
2449 = charset_list
= Viso_2022_charset_list
;
2450 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2453 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2457 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2459 int id
= XINT (XCAR (tail
));
2460 if (max_charset_id
< id
)
2461 max_charset_id
= id
;
2464 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
2466 request
= AREF (attrs
, coding_attr_iso_request
);
2467 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2468 reg94
= XINT (XCAR (reg_usage
));
2469 reg96
= XINT (XCDR (reg_usage
));
2471 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2475 struct charset
*charset
;
2478 charset
= CHARSET_FROM_ID (XINT (id
));
2479 reg
= Fcdr (Fassq (id
, request
));
2481 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2482 else if (charset
->iso_chars_96
)
2485 SSET (safe_charsets
, XINT (id
), reg96
);
2490 SSET (safe_charsets
, XINT (id
), reg94
);
2493 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2497 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2498 Check if a text is encoded in one of ISO-2022 based codig systems.
2499 If it is, return 1, else return 0. */
2502 detect_coding_iso_2022 (coding
, detect_info
)
2503 struct coding_system
*coding
;
2504 struct coding_detection_info
*detect_info
;
2506 const unsigned char *src
= coding
->source
, *src_base
= src
;
2507 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2508 int multibytep
= coding
->src_multibyte
;
2509 int single_shifting
= 0;
2512 int consumed_chars
= 0;
2517 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2519 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2521 struct coding_system
*this = &(coding_categories
[i
]);
2522 Lisp_Object attrs
, val
;
2524 attrs
= CODING_ID_ATTRS (this->id
);
2525 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2526 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs
), Viso_2022_charset_list
))
2527 setup_iso_safe_charsets (attrs
);
2528 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2529 this->max_charset_id
= SCHARS (val
) - 1;
2530 this->safe_charsets
= (char *) SDATA (val
);
2533 /* A coding system of this category is always ASCII compatible. */
2534 src
+= coding
->head_ascii
;
2536 while (rejected
!= CATEGORY_MASK_ISO
)
2543 if (inhibit_iso_escape_detection
)
2545 single_shifting
= 0;
2547 if (c
>= '(' && c
<= '/')
2549 /* Designation sequence for a charset of dimension 1. */
2551 if (c1
< ' ' || c1
>= 0x80
2552 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2553 /* Invalid designation sequence. Just ignore. */
2558 /* Designation sequence for a charset of dimension 2. */
2560 if (c
>= '@' && c
<= 'B')
2561 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2562 id
= iso_charset_table
[1][0][c
];
2563 else if (c
>= '(' && c
<= '/')
2566 if (c1
< ' ' || c1
>= 0x80
2567 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2568 /* Invalid designation sequence. Just ignore. */
2572 /* Invalid designation sequence. Just ignore it. */
2575 else if (c
== 'N' || c
== 'O')
2577 /* ESC <Fe> for SS2 or SS3. */
2578 single_shifting
= 1;
2579 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2582 else if (c
>= '0' && c
<= '4')
2584 /* ESC <Fp> for start/end composition. */
2585 found
|= CATEGORY_MASK_ISO
;
2590 /* Invalid escape sequence. Just ignore it. */
2594 /* We found a valid designation sequence for CHARSET. */
2595 rejected
|= CATEGORY_MASK_ISO_8BIT
;
2596 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
2598 found
|= CATEGORY_MASK_ISO_7
;
2600 rejected
|= CATEGORY_MASK_ISO_7
;
2601 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
2603 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
2605 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
2606 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
2608 found
|= CATEGORY_MASK_ISO_7_ELSE
;
2610 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
2611 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
2613 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2615 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
2620 /* Locking shift out/in. */
2621 if (inhibit_iso_escape_detection
)
2623 single_shifting
= 0;
2624 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2625 found
|= CATEGORY_MASK_ISO_ELSE
;
2629 /* Control sequence introducer. */
2630 single_shifting
= 0;
2631 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2632 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2633 goto check_extra_latin
;
2638 if (inhibit_iso_escape_detection
)
2640 single_shifting
= 0;
2641 rejected
|= CATEGORY_MASK_ISO_7BIT
;
2642 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2643 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2644 found
|= CATEGORY_MASK_ISO_8_1
, single_shifting
= 1;
2645 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
2646 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2647 found
|= CATEGORY_MASK_ISO_8_2
, single_shifting
= 1;
2648 if (single_shifting
)
2650 goto check_extra_latin
;
2657 single_shifting
= 0;
2662 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2663 found
|= CATEGORY_MASK_ISO_8_1
;
2664 /* Check the length of succeeding codes of the range
2665 0xA0..0FF. If the byte length is even, we include
2666 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2667 only when we are not single shifting. */
2668 if (! single_shifting
2669 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
2672 while (src
< src_end
)
2680 if (i
& 1 && src
< src_end
)
2681 rejected
|= CATEGORY_MASK_ISO_8_2
;
2683 found
|= CATEGORY_MASK_ISO_8_2
;
2688 single_shifting
= 0;
2689 if (! VECTORP (Vlatin_extra_code_table
)
2690 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
2692 rejected
= CATEGORY_MASK_ISO
;
2695 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2696 & CODING_ISO_FLAG_LATIN_EXTRA
)
2697 found
|= CATEGORY_MASK_ISO_8_1
;
2699 rejected
|= CATEGORY_MASK_ISO_8_1
;
2700 rejected
|= CATEGORY_MASK_ISO_8_2
;
2703 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
2707 detect_info
->rejected
|= rejected
;
2708 detect_info
->found
|= (found
& ~rejected
);
2713 /* Set designation state into CODING. Set CHARS_96 to -1 if the
2714 escape sequence should be kept. */
2715 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
2719 if (final < '0' || final >= 128 \
2720 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
2721 || !SAFE_CHARSET_P (coding, id)) \
2723 CODING_ISO_DESIGNATION (coding, reg) = -2; \
2727 prev = CODING_ISO_DESIGNATION (coding, reg); \
2728 if (id == charset_jisx0201_roman) \
2730 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
2731 id = charset_ascii; \
2733 else if (id == charset_jisx0208_1978) \
2735 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
2736 id = charset_jisx0208; \
2738 CODING_ISO_DESIGNATION (coding, reg) = id; \
2739 /* If there was an invalid designation to REG previously, and this \
2740 designation is ASCII to REG, we should keep this designation \
2742 if (prev == -2 && id == charset_ascii) \
2747 #define MAYBE_FINISH_COMPOSITION() \
2750 if (composition_state == COMPOSING_NO) \
2752 /* It is assured that we have enough room for producing \
2753 characters stored in the table `components'. */ \
2754 if (charbuf + component_idx > charbuf_end) \
2755 goto no_more_source; \
2756 composition_state = COMPOSING_NO; \
2757 if (method == COMPOSITION_RELATIVE \
2758 || method == COMPOSITION_WITH_ALTCHARS) \
2760 for (i = 0; i < component_idx; i++) \
2761 *charbuf++ = components[i]; \
2762 char_offset += component_idx; \
2766 for (i = 0; i < component_idx; i += 2) \
2767 *charbuf++ = components[i]; \
2768 char_offset += (component_idx / 2) + 1; \
2773 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
2774 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
2775 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
2776 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
2777 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
2780 #define DECODE_COMPOSITION_START(c1) \
2783 && composition_state == COMPOSING_COMPONENT_RULE) \
2785 component_len = component_idx; \
2786 composition_state = COMPOSING_CHAR; \
2790 const unsigned char *p; \
2792 MAYBE_FINISH_COMPOSITION (); \
2793 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
2794 goto no_more_source; \
2795 for (p = src; p < src_end - 1; p++) \
2796 if (*p == ISO_CODE_ESC && p[1] == '1') \
2798 if (p == src_end - 1) \
2800 if (coding->mode & CODING_MODE_LAST_BLOCK) \
2801 goto invalid_code; \
2802 goto no_more_source; \
2805 /* This is surely the start of a composition. */ \
2806 method = (c1 == '0' ? COMPOSITION_RELATIVE \
2807 : c1 == '2' ? COMPOSITION_WITH_RULE \
2808 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
2809 : COMPOSITION_WITH_RULE_ALTCHARS); \
2810 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
2811 : COMPOSING_COMPONENT_CHAR); \
2812 component_idx = component_len = 0; \
2817 /* Handle compositoin end sequence ESC 1. */
2819 #define DECODE_COMPOSITION_END() \
2821 int nchars = (component_len > 0 ? component_idx - component_len \
2822 : method == COMPOSITION_RELATIVE ? component_idx \
2823 : (component_idx + 1) / 2); \
2825 int *saved_charbuf = charbuf; \
2827 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
2828 if (method != COMPOSITION_RELATIVE) \
2830 if (component_len == 0) \
2831 for (i = 0; i < component_idx; i++) \
2832 *charbuf++ = components[i]; \
2834 for (i = 0; i < component_len; i++) \
2835 *charbuf++ = components[i]; \
2836 *saved_charbuf = saved_charbuf - charbuf; \
2838 if (method == COMPOSITION_WITH_RULE) \
2839 for (i = 0; i < component_idx; i += 2, char_offset++) \
2840 *charbuf++ = components[i]; \
2842 for (i = component_len; i < component_idx; i++, char_offset++) \
2843 *charbuf++ = components[i]; \
2844 coding->annotated = 1; \
2845 composition_state = COMPOSING_NO; \
2849 /* Decode a composition rule from the byte C1 (and maybe one more byte
2850 from SRC) and store one encoded composition rule in
2851 coding->cmp_data. */
2853 #define DECODE_COMPOSITION_RULE(c1) \
2856 if (c1 < 81) /* old format (before ver.21) */ \
2858 int gref = (c1) / 9; \
2859 int nref = (c1) % 9; \
2860 if (gref == 4) gref = 10; \
2861 if (nref == 4) nref = 10; \
2862 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
2864 else if (c1 < 93) /* new format (after ver.21) */ \
2866 ONE_MORE_BYTE (c2); \
2867 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
2874 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2877 decode_coding_iso_2022 (coding
)
2878 struct coding_system
*coding
;
2880 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2881 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2882 const unsigned char *src_base
;
2883 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2885 = coding
->charbuf
+ coding
->charbuf_size
- 4 - MAX_ANNOTATION_LENGTH
;
2886 int consumed_chars
= 0, consumed_chars_base
;
2887 int multibytep
= coding
->src_multibyte
;
2888 /* Charsets invoked to graphic plane 0 and 1 respectively. */
2889 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
2890 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
2891 int charset_id_2
, charset_id_3
;
2892 struct charset
*charset
;
2894 /* For handling composition sequence. */
2895 #define COMPOSING_NO 0
2896 #define COMPOSING_CHAR 1
2897 #define COMPOSING_RULE 2
2898 #define COMPOSING_COMPONENT_CHAR 3
2899 #define COMPOSING_COMPONENT_RULE 4
2901 int composition_state
= COMPOSING_NO
;
2902 enum composition_method method
;
2903 int components
[MAX_COMPOSITION_COMPONENTS
* 2 + 1];
2906 Lisp_Object attrs
, charset_list
;
2907 int char_offset
= coding
->produced_char
;
2908 int last_offset
= char_offset
;
2909 int last_id
= charset_ascii
;
2911 CODING_GET_INFO (coding
, attrs
, charset_list
);
2912 setup_iso_safe_charsets (attrs
);
2919 consumed_chars_base
= consumed_chars
;
2921 if (charbuf
>= charbuf_end
)
2928 /* We produce at most one character. */
2929 switch (iso_code_class
[c1
])
2931 case ISO_0x20_or_0x7F
:
2932 if (composition_state
!= COMPOSING_NO
)
2934 if (composition_state
== COMPOSING_RULE
2935 || composition_state
== COMPOSING_COMPONENT_RULE
)
2937 DECODE_COMPOSITION_RULE (c1
);
2938 components
[component_idx
++] = c1
;
2939 composition_state
--;
2943 if (charset_id_0
< 0
2944 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
2945 /* This is SPACE or DEL. */
2946 charset
= CHARSET_FROM_ID (charset_ascii
);
2948 charset
= CHARSET_FROM_ID (charset_id_0
);
2951 case ISO_graphic_plane_0
:
2952 if (composition_state
!= COMPOSING_NO
)
2954 if (composition_state
== COMPOSING_RULE
2955 || composition_state
== COMPOSING_COMPONENT_RULE
)
2957 DECODE_COMPOSITION_RULE (c1
);
2958 components
[component_idx
++] = c1
;
2959 composition_state
--;
2963 if (charset_id_0
< 0)
2964 charset
= CHARSET_FROM_ID (charset_ascii
);
2966 charset
= CHARSET_FROM_ID (charset_id_0
);
2969 case ISO_0xA0_or_0xFF
:
2970 if (charset_id_1
< 0
2971 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
2972 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
2974 /* This is a graphic character, we fall down ... */
2976 case ISO_graphic_plane_1
:
2977 if (charset_id_1
< 0)
2979 charset
= CHARSET_FROM_ID (charset_id_1
);
2983 MAYBE_FINISH_COMPOSITION ();
2984 charset
= CHARSET_FROM_ID (charset_ascii
);
2988 MAYBE_FINISH_COMPOSITION ();
2992 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
2993 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
2995 CODING_ISO_INVOCATION (coding
, 0) = 1;
2996 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3000 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3002 CODING_ISO_INVOCATION (coding
, 0) = 0;
3003 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3006 case ISO_single_shift_2_7
:
3007 case ISO_single_shift_2
:
3008 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3010 /* SS2 is handled as an escape sequence of ESC 'N' */
3012 goto label_escape_sequence
;
3014 case ISO_single_shift_3
:
3015 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3017 /* SS2 is handled as an escape sequence of ESC 'O' */
3019 goto label_escape_sequence
;
3021 case ISO_control_sequence_introducer
:
3022 /* CSI is handled as an escape sequence of ESC '[' ... */
3024 goto label_escape_sequence
;
3028 label_escape_sequence
:
3029 /* Escape sequences handled here are invocation,
3030 designation, direction specification, and character
3031 composition specification. */
3034 case '&': /* revision of following character set */
3036 if (!(c1
>= '@' && c1
<= '~'))
3039 if (c1
!= ISO_CODE_ESC
)
3042 goto label_escape_sequence
;
3044 case '$': /* designation of 2-byte character set */
3045 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3051 if (c1
>= '@' && c1
<= 'B')
3052 { /* designation of JISX0208.1978, GB2312.1980,
3054 reg
= 0, chars96
= 0;
3056 else if (c1
>= 0x28 && c1
<= 0x2B)
3057 { /* designation of DIMENSION2_CHARS94 character set */
3058 reg
= c1
- 0x28, chars96
= 0;
3061 else if (c1
>= 0x2C && c1
<= 0x2F)
3062 { /* designation of DIMENSION2_CHARS96 character set */
3063 reg
= c1
- 0x2C, chars96
= 1;
3068 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3069 /* We must update these variables now. */
3071 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3073 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3079 case 'n': /* invocation of locking-shift-2 */
3080 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3081 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3083 CODING_ISO_INVOCATION (coding
, 0) = 2;
3084 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3087 case 'o': /* invocation of locking-shift-3 */
3088 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3089 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3091 CODING_ISO_INVOCATION (coding
, 0) = 3;
3092 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3095 case 'N': /* invocation of single-shift-2 */
3096 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3097 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3099 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3100 if (charset_id_2
< 0)
3101 charset
= CHARSET_FROM_ID (charset_ascii
);
3103 charset
= CHARSET_FROM_ID (charset_id_2
);
3105 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3109 case 'O': /* invocation of single-shift-3 */
3110 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3111 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3113 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3114 if (charset_id_3
< 0)
3115 charset
= CHARSET_FROM_ID (charset_ascii
);
3117 charset
= CHARSET_FROM_ID (charset_id_3
);
3119 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3123 case '0': case '2': case '3': case '4': /* start composition */
3124 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3126 DECODE_COMPOSITION_START (c1
);
3129 case '1': /* end composition */
3130 if (composition_state
== COMPOSING_NO
)
3132 DECODE_COMPOSITION_END ();
3135 case '[': /* specification of direction */
3136 if (! CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
)
3138 /* For the moment, nested direction is not supported.
3139 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3140 left-to-right, and nozero means right-to-left. */
3144 case ']': /* end of the current direction */
3145 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3147 case '0': /* end of the current direction */
3148 case '1': /* start of left-to-right direction */
3151 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3156 case '2': /* start of right-to-left direction */
3159 coding
->mode
|= CODING_MODE_DIRECTION
;
3173 /* CTEXT extended segment:
3174 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3175 We keep these bytes as is for the moment.
3176 They may be decoded by post-read-conversion. */
3180 ONE_MORE_BYTE (dim
);
3183 size
= ((M
- 128) * 128) + (L
- 128);
3184 if (charbuf
+ 8 + size
> charbuf_end
)
3186 *charbuf
++ = ISO_CODE_ESC
;
3190 *charbuf
++ = BYTE8_TO_CHAR (M
);
3191 *charbuf
++ = BYTE8_TO_CHAR (L
);
3195 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3200 /* XFree86 extension for embedding UTF-8 in CTEXT:
3201 ESC % G --UTF-8-BYTES-- ESC % @
3202 We keep these bytes as is for the moment.
3203 They may be decoded by post-read-conversion. */
3206 if (p
+ 6 > charbuf_end
)
3208 *p
++ = ISO_CODE_ESC
;
3211 while (p
< charbuf_end
)
3214 if (c1
== ISO_CODE_ESC
3215 && src
+ 1 < src_end
3222 *p
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3224 if (p
+ 3 > charbuf_end
)
3226 *p
++ = ISO_CODE_ESC
;
3237 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3242 if (c1
>= 0x28 && c1
<= 0x2B)
3243 { /* designation of DIMENSION1_CHARS94 character set */
3244 reg
= c1
- 0x28, chars96
= 0;
3247 else if (c1
>= 0x2C && c1
<= 0x2F)
3248 { /* designation of DIMENSION1_CHARS96 character set */
3249 reg
= c1
- 0x2C, chars96
= 1;
3254 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3255 /* We must update these variables now. */
3257 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3259 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3267 if (charset
->id
!= charset_ascii
3268 && last_id
!= charset
->id
)
3270 if (last_id
!= charset_ascii
)
3271 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3272 last_id
= charset
->id
;
3273 last_offset
= char_offset
;
3276 /* Now we know CHARSET and 1st position code C1 of a character.
3277 Produce a decoded character while getting 2nd position code
3280 if (CHARSET_DIMENSION (charset
) > 1)
3283 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3284 /* C2 is not in a valid range. */
3286 c1
= (c1
<< 8) | (c2
& 0x7F);
3287 if (CHARSET_DIMENSION (charset
) > 2)
3290 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3291 /* C2 is not in a valid range. */
3293 c1
= (c1
<< 8) | (c2
& 0x7F);
3297 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3300 MAYBE_FINISH_COMPOSITION ();
3301 for (; src_base
< src
; src_base
++, char_offset
++)
3303 if (ASCII_BYTE_P (*src_base
))
3304 *charbuf
++ = *src_base
;
3306 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3309 else if (composition_state
== COMPOSING_NO
)
3316 components
[component_idx
++] = c
;
3317 if (method
== COMPOSITION_WITH_RULE
3318 || (method
== COMPOSITION_WITH_RULE_ALTCHARS
3319 && composition_state
== COMPOSING_COMPONENT_CHAR
))
3320 composition_state
++;
3325 MAYBE_FINISH_COMPOSITION ();
3327 consumed_chars
= consumed_chars_base
;
3329 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3339 if (last_id
!= charset_ascii
)
3340 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3341 coding
->consumed_char
+= consumed_chars_base
;
3342 coding
->consumed
= src_base
- coding
->source
;
3343 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3347 /* ISO2022 encoding stuff. */
3350 It is not enough to say just "ISO2022" on encoding, we have to
3351 specify more details. In Emacs, each coding system of ISO2022
3352 variant has the following specifications:
3353 1. Initial designation to G0 thru G3.
3354 2. Allows short-form designation?
3355 3. ASCII should be designated to G0 before control characters?
3356 4. ASCII should be designated to G0 at end of line?
3357 5. 7-bit environment or 8-bit environment?
3358 6. Use locking-shift?
3359 7. Use Single-shift?
3360 And the following two are only for Japanese:
3361 8. Use ASCII in place of JIS0201-1976-Roman?
3362 9. Use JISX0208-1983 in place of JISX0208-1978?
3363 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3364 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3368 /* Produce codes (escape sequence) for designating CHARSET to graphic
3369 register REG at DST, and increment DST. If <final-char> of CHARSET is
3370 '@', 'A', or 'B' and the coding system CODING allows, produce
3371 designation sequence of short-form. */
3373 #define ENCODE_DESIGNATION(charset, reg, coding) \
3375 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3376 char *intermediate_char_94 = "()*+"; \
3377 char *intermediate_char_96 = ",-./"; \
3378 int revision = -1; \
3381 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3382 revision = CHARSET_ISO_REVISION (charset); \
3384 if (revision >= 0) \
3386 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3387 EMIT_ONE_BYTE ('@' + revision); \
3389 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3390 if (CHARSET_DIMENSION (charset) == 1) \
3392 if (! CHARSET_ISO_CHARS_96 (charset)) \
3393 c = intermediate_char_94[reg]; \
3395 c = intermediate_char_96[reg]; \
3396 EMIT_ONE_ASCII_BYTE (c); \
3400 EMIT_ONE_ASCII_BYTE ('$'); \
3401 if (! CHARSET_ISO_CHARS_96 (charset)) \
3403 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3405 || final_char < '@' || final_char > 'B') \
3406 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3409 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3411 EMIT_ONE_ASCII_BYTE (final_char); \
3413 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3417 /* The following two macros produce codes (control character or escape
3418 sequence) for ISO2022 single-shift functions (single-shift-2 and
3421 #define ENCODE_SINGLE_SHIFT_2 \
3423 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3424 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3426 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3427 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3431 #define ENCODE_SINGLE_SHIFT_3 \
3433 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3434 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3436 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3437 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3441 /* The following four macros produce codes (control character or
3442 escape sequence) for ISO2022 locking-shift functions (shift-in,
3443 shift-out, locking-shift-2, and locking-shift-3). */
3445 #define ENCODE_SHIFT_IN \
3447 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3448 CODING_ISO_INVOCATION (coding, 0) = 0; \
3452 #define ENCODE_SHIFT_OUT \
3454 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3455 CODING_ISO_INVOCATION (coding, 0) = 1; \
3459 #define ENCODE_LOCKING_SHIFT_2 \
3461 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3462 CODING_ISO_INVOCATION (coding, 0) = 2; \
3466 #define ENCODE_LOCKING_SHIFT_3 \
3468 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3469 CODING_ISO_INVOCATION (coding, 0) = 3; \
3473 /* Produce codes for a DIMENSION1 character whose character set is
3474 CHARSET and whose position-code is C1. Designation and invocation
3475 sequences are also produced in advance if necessary. */
3477 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3479 int id = CHARSET_ID (charset); \
3481 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3482 && id == charset_ascii) \
3484 id = charset_jisx0201_roman; \
3485 charset = CHARSET_FROM_ID (id); \
3488 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3490 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3491 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3493 EMIT_ONE_BYTE (c1 | 0x80); \
3494 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3497 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3499 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3502 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3504 EMIT_ONE_BYTE (c1 | 0x80); \
3508 /* Since CHARSET is not yet invoked to any graphic planes, we \
3509 must invoke it, or, at first, designate it to some graphic \
3510 register. Then repeat the loop to actually produce the \
3512 dst = encode_invocation_designation (charset, coding, dst, \
3517 /* Produce codes for a DIMENSION2 character whose character set is
3518 CHARSET and whose position-codes are C1 and C2. Designation and
3519 invocation codes are also produced in advance if necessary. */
3521 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3523 int id = CHARSET_ID (charset); \
3525 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3526 && id == charset_jisx0208) \
3528 id = charset_jisx0208_1978; \
3529 charset = CHARSET_FROM_ID (id); \
3532 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3534 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3535 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3537 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3538 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3541 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3543 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3546 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3548 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3552 /* Since CHARSET is not yet invoked to any graphic planes, we \
3553 must invoke it, or, at first, designate it to some graphic \
3554 register. Then repeat the loop to actually produce the \
3556 dst = encode_invocation_designation (charset, coding, dst, \
3561 #define ENCODE_ISO_CHARACTER(charset, c) \
3563 int code = ENCODE_CHAR ((charset),(c)); \
3565 if (CHARSET_DIMENSION (charset) == 1) \
3566 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3568 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
3572 /* Produce designation and invocation codes at a place pointed by DST
3573 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
3577 encode_invocation_designation (charset
, coding
, dst
, p_nchars
)
3578 struct charset
*charset
;
3579 struct coding_system
*coding
;
3583 int multibytep
= coding
->dst_multibyte
;
3584 int produced_chars
= *p_nchars
;
3585 int reg
; /* graphic register number */
3586 int id
= CHARSET_ID (charset
);
3588 /* At first, check designations. */
3589 for (reg
= 0; reg
< 4; reg
++)
3590 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
3595 /* CHARSET is not yet designated to any graphic registers. */
3596 /* At first check the requested designation. */
3597 reg
= CODING_ISO_REQUEST (coding
, id
);
3599 /* Since CHARSET requests no special designation, designate it
3600 to graphic register 0. */
3603 ENCODE_DESIGNATION (charset
, reg
, coding
);
3606 if (CODING_ISO_INVOCATION (coding
, 0) != reg
3607 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
3609 /* Since the graphic register REG is not invoked to any graphic
3610 planes, invoke it to graphic plane 0. */
3613 case 0: /* graphic register 0 */
3617 case 1: /* graphic register 1 */
3621 case 2: /* graphic register 2 */
3622 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3623 ENCODE_SINGLE_SHIFT_2
;
3625 ENCODE_LOCKING_SHIFT_2
;
3628 case 3: /* graphic register 3 */
3629 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3630 ENCODE_SINGLE_SHIFT_3
;
3632 ENCODE_LOCKING_SHIFT_3
;
3637 *p_nchars
= produced_chars
;
3641 /* The following three macros produce codes for indicating direction
3643 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
3645 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
3646 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
3648 EMIT_ONE_BYTE (ISO_CODE_CSI); \
3652 #define ENCODE_DIRECTION_R2L() \
3654 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3655 EMIT_TWO_ASCII_BYTES ('2', ']'); \
3659 #define ENCODE_DIRECTION_L2R() \
3661 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3662 EMIT_TWO_ASCII_BYTES ('0', ']'); \
3666 /* Produce codes for designation and invocation to reset the graphic
3667 planes and registers to initial state. */
3668 #define ENCODE_RESET_PLANE_AND_REGISTER() \
3671 struct charset *charset; \
3673 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
3675 for (reg = 0; reg < 4; reg++) \
3676 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
3677 && (CODING_ISO_DESIGNATION (coding, reg) \
3678 != CODING_ISO_INITIAL (coding, reg))) \
3680 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
3681 ENCODE_DESIGNATION (charset, reg, coding); \
3686 /* Produce designation sequences of charsets in the line started from
3687 SRC to a place pointed by DST, and return updated DST.
3689 If the current block ends before any end-of-line, we may fail to
3690 find all the necessary designations. */
3692 static unsigned char *
3693 encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
)
3694 struct coding_system
*coding
;
3695 int *charbuf
, *charbuf_end
;
3698 struct charset
*charset
;
3699 /* Table of charsets to be designated to each graphic register. */
3701 int c
, found
= 0, reg
;
3702 int produced_chars
= 0;
3703 int multibytep
= coding
->dst_multibyte
;
3705 Lisp_Object charset_list
;
3707 attrs
= CODING_ID_ATTRS (coding
->id
);
3708 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3709 if (EQ (charset_list
, Qiso_2022
))
3710 charset_list
= Viso_2022_charset_list
;
3712 for (reg
= 0; reg
< 4; reg
++)
3722 charset
= char_charset (c
, charset_list
, NULL
);
3723 id
= CHARSET_ID (charset
);
3724 reg
= CODING_ISO_REQUEST (coding
, id
);
3725 if (reg
>= 0 && r
[reg
] < 0)
3734 for (reg
= 0; reg
< 4; reg
++)
3736 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
3737 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
3743 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
3746 encode_coding_iso_2022 (coding
)
3747 struct coding_system
*coding
;
3749 int multibytep
= coding
->dst_multibyte
;
3750 int *charbuf
= coding
->charbuf
;
3751 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
3752 unsigned char *dst
= coding
->destination
+ coding
->produced
;
3753 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
3756 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
3757 && CODING_ISO_BOL (coding
));
3758 int produced_chars
= 0;
3759 Lisp_Object attrs
, eol_type
, charset_list
;
3760 int ascii_compatible
;
3762 int preferred_charset_id
= -1;
3764 CODING_GET_INFO (coding
, attrs
, charset_list
);
3765 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
3766 if (VECTORP (eol_type
))
3769 setup_iso_safe_charsets (attrs
);
3770 /* Charset list may have been changed. */
3771 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
); \
3772 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
3774 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
3776 while (charbuf
< charbuf_end
)
3778 ASSURE_DESTINATION (safe_room
);
3780 if (bol_designation
)
3782 unsigned char *dst_prev
= dst
;
3784 /* We have to produce designation sequences if any now. */
3785 dst
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
);
3786 bol_designation
= 0;
3787 /* We are sure that designation sequences are all ASCII bytes. */
3788 produced_chars
+= dst
- dst_prev
;
3795 /* Handle an annotation. */
3798 case CODING_ANNOTATE_COMPOSITION_MASK
:
3799 /* Not yet implemented. */
3801 case CODING_ANNOTATE_CHARSET_MASK
:
3802 preferred_charset_id
= charbuf
[2];
3803 if (preferred_charset_id
>= 0
3804 && NILP (Fmemq (make_number (preferred_charset_id
),
3806 preferred_charset_id
= -1;
3815 /* Now encode the character C. */
3816 if (c
< 0x20 || c
== 0x7F)
3819 || (c
== '\r' && EQ (eol_type
, Qmac
)))
3821 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3822 ENCODE_RESET_PLANE_AND_REGISTER ();
3823 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
3827 for (i
= 0; i
< 4; i
++)
3828 CODING_ISO_DESIGNATION (coding
, i
)
3829 = CODING_ISO_INITIAL (coding
, i
);
3832 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
3834 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
3835 ENCODE_RESET_PLANE_AND_REGISTER ();
3836 EMIT_ONE_ASCII_BYTE (c
);
3838 else if (ASCII_CHAR_P (c
))
3840 if (ascii_compatible
)
3841 EMIT_ONE_ASCII_BYTE (c
);
3844 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
3845 ENCODE_ISO_CHARACTER (charset
, c
);
3848 else if (CHAR_BYTE8_P (c
))
3850 c
= CHAR_TO_BYTE8 (c
);
3855 struct charset
*charset
;
3857 if (preferred_charset_id
>= 0)
3859 charset
= CHARSET_FROM_ID (preferred_charset_id
);
3860 if (! CHAR_CHARSET_P (c
, charset
))
3861 charset
= char_charset (c
, charset_list
, NULL
);
3864 charset
= char_charset (c
, charset_list
, NULL
);
3867 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
3869 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
3870 charset
= CHARSET_FROM_ID (charset_ascii
);
3874 c
= coding
->default_char
;
3875 charset
= char_charset (c
, charset_list
, NULL
);
3878 ENCODE_ISO_CHARACTER (charset
, c
);
3882 if (coding
->mode
& CODING_MODE_LAST_BLOCK
3883 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3885 ASSURE_DESTINATION (safe_room
);
3886 ENCODE_RESET_PLANE_AND_REGISTER ();
3888 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
3889 CODING_ISO_BOL (coding
) = bol_designation
;
3890 coding
->produced_char
+= produced_chars
;
3891 coding
->produced
= dst
- coding
->destination
;
3896 /*** 8,9. SJIS and BIG5 handlers ***/
3898 /* Although SJIS and BIG5 are not ISO's coding system, they are used
3899 quite widely. So, for the moment, Emacs supports them in the bare
3900 C code. But, in the future, they may be supported only by CCL. */
3902 /* SJIS is a coding system encoding three character sets: ASCII, right
3903 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
3904 as is. A character of charset katakana-jisx0201 is encoded by
3905 "position-code + 0x80". A character of charset japanese-jisx0208
3906 is encoded in 2-byte but two position-codes are divided and shifted
3907 so that it fit in the range below.
3909 --- CODE RANGE of SJIS ---
3910 (character set) (range)
3912 KATAKANA-JISX0201 0xA0 .. 0xDF
3913 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
3914 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
3915 -------------------------------
3919 /* BIG5 is a coding system encoding two character sets: ASCII and
3920 Big5. An ASCII character is encoded as is. Big5 is a two-byte
3921 character set and is encoded in two-byte.
3923 --- CODE RANGE of BIG5 ---
3924 (character set) (range)
3926 Big5 (1st byte) 0xA1 .. 0xFE
3927 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
3928 --------------------------
3932 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3933 Check if a text is encoded in SJIS. If it is, return
3934 CATEGORY_MASK_SJIS, else return 0. */
3937 detect_coding_sjis (coding
, detect_info
)
3938 struct coding_system
*coding
;
3939 struct coding_detection_info
*detect_info
;
3941 const unsigned char *src
= coding
->source
, *src_base
;
3942 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3943 int multibytep
= coding
->src_multibyte
;
3944 int consumed_chars
= 0;
3948 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
3949 /* A coding system of this category is always ASCII compatible. */
3950 src
+= coding
->head_ascii
;
3958 if ((c
>= 0x81 && c
<= 0x9F) || (c
>= 0xE0 && c
<= 0xEF))
3961 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
3963 found
= CATEGORY_MASK_SJIS
;
3965 else if (c
>= 0xA0 && c
< 0xE0)
3966 found
= CATEGORY_MASK_SJIS
;
3970 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3974 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
3976 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3979 detect_info
->found
|= found
;
3983 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3984 Check if a text is encoded in BIG5. If it is, return
3985 CATEGORY_MASK_BIG5, else return 0. */
3988 detect_coding_big5 (coding
, detect_info
)
3989 struct coding_system
*coding
;
3990 struct coding_detection_info
*detect_info
;
3992 const unsigned char *src
= coding
->source
, *src_base
;
3993 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3994 int multibytep
= coding
->src_multibyte
;
3995 int consumed_chars
= 0;
3999 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4000 /* A coding system of this category is always ASCII compatible. */
4001 src
+= coding
->head_ascii
;
4012 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4014 found
= CATEGORY_MASK_BIG5
;
4019 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4023 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4025 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4028 detect_info
->found
|= found
;
4032 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4033 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4036 decode_coding_sjis (coding
)
4037 struct coding_system
*coding
;
4039 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4040 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4041 const unsigned char *src_base
;
4042 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4044 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4045 int consumed_chars
= 0, consumed_chars_base
;
4046 int multibytep
= coding
->src_multibyte
;
4047 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4048 struct charset
*charset_kanji2
;
4049 Lisp_Object attrs
, charset_list
, val
;
4050 int char_offset
= coding
->produced_char
;
4051 int last_offset
= char_offset
;
4052 int last_id
= charset_ascii
;
4054 CODING_GET_INFO (coding
, attrs
, charset_list
);
4057 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4058 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4059 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4060 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4065 struct charset
*charset
;
4068 consumed_chars_base
= consumed_chars
;
4070 if (charbuf
>= charbuf_end
)
4077 charset
= charset_roman
;
4078 else if (c
== 0x80 || c
== 0xA0)
4080 else if (c
>= 0xA1 && c
<= 0xDF)
4082 /* SJIS -> JISX0201-Kana */
4084 charset
= charset_kana
;
4088 /* SJIS -> JISX0208 */
4090 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4094 charset
= charset_kanji
;
4096 else if (c
<= 0xFC && charset_kanji2
)
4098 /* SJIS -> JISX0213-2 */
4100 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4104 charset
= charset_kanji2
;
4108 if (charset
->id
!= charset_ascii
4109 && last_id
!= charset
->id
)
4111 if (last_id
!= charset_ascii
)
4112 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4113 last_id
= charset
->id
;
4114 last_offset
= char_offset
;
4116 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4123 consumed_chars
= consumed_chars_base
;
4125 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4131 if (last_id
!= charset_ascii
)
4132 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4133 coding
->consumed_char
+= consumed_chars_base
;
4134 coding
->consumed
= src_base
- coding
->source
;
4135 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4139 decode_coding_big5 (coding
)
4140 struct coding_system
*coding
;
4142 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4143 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4144 const unsigned char *src_base
;
4145 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4147 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4148 int consumed_chars
= 0, consumed_chars_base
;
4149 int multibytep
= coding
->src_multibyte
;
4150 struct charset
*charset_roman
, *charset_big5
;
4151 Lisp_Object attrs
, charset_list
, val
;
4152 int char_offset
= coding
->produced_char
;
4153 int last_offset
= char_offset
;
4154 int last_id
= charset_ascii
;
4156 CODING_GET_INFO (coding
, attrs
, charset_list
);
4158 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4159 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4164 struct charset
*charset
;
4167 consumed_chars_base
= consumed_chars
;
4169 if (charbuf
>= charbuf_end
)
4177 charset
= charset_roman
;
4181 if (c
< 0xA1 || c
> 0xFE)
4184 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4187 charset
= charset_big5
;
4189 if (charset
->id
!= charset_ascii
4190 && last_id
!= charset
->id
)
4192 if (last_id
!= charset_ascii
)
4193 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4194 last_id
= charset
->id
;
4195 last_offset
= char_offset
;
4197 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4204 consumed_chars
= consumed_chars_base
;
4206 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4212 if (last_id
!= charset_ascii
)
4213 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4214 coding
->consumed_char
+= consumed_chars_base
;
4215 coding
->consumed
= src_base
- coding
->source
;
4216 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4219 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4220 This function can encode charsets `ascii', `katakana-jisx0201',
4221 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4222 are sure that all these charsets are registered as official charset
4223 (i.e. do not have extended leading-codes). Characters of other
4224 charsets are produced without any encoding. If SJIS_P is 1, encode
4225 SJIS text, else encode BIG5 text. */
4228 encode_coding_sjis (coding
)
4229 struct coding_system
*coding
;
4231 int multibytep
= coding
->dst_multibyte
;
4232 int *charbuf
= coding
->charbuf
;
4233 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4234 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4235 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4237 int produced_chars
= 0;
4238 Lisp_Object attrs
, charset_list
, val
;
4239 int ascii_compatible
;
4240 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4241 struct charset
*charset_kanji2
;
4244 CODING_GET_INFO (coding
, attrs
, charset_list
);
4246 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4247 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4248 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4249 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4251 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4253 while (charbuf
< charbuf_end
)
4255 ASSURE_DESTINATION (safe_room
);
4257 /* Now encode the character C. */
4258 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4259 EMIT_ONE_ASCII_BYTE (c
);
4260 else if (CHAR_BYTE8_P (c
))
4262 c
= CHAR_TO_BYTE8 (c
);
4268 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4272 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4274 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4275 charset
= CHARSET_FROM_ID (charset_ascii
);
4279 c
= coding
->default_char
;
4280 charset
= char_charset (c
, charset_list
, &code
);
4283 if (code
== CHARSET_INVALID_CODE (charset
))
4285 if (charset
== charset_kanji
)
4289 c1
= code
>> 8, c2
= code
& 0xFF;
4290 EMIT_TWO_BYTES (c1
, c2
);
4292 else if (charset
== charset_kana
)
4293 EMIT_ONE_BYTE (code
| 0x80);
4294 else if (charset_kanji2
&& charset
== charset_kanji2
)
4299 if (c1
== 0x21 || (c1
>= 0x23 && c1
< 0x25)
4300 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4302 JIS_TO_SJIS2 (code
);
4303 c1
= code
>> 8, c2
= code
& 0xFF;
4304 EMIT_TWO_BYTES (c1
, c2
);
4307 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4310 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4313 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4314 coding
->produced_char
+= produced_chars
;
4315 coding
->produced
= dst
- coding
->destination
;
4320 encode_coding_big5 (coding
)
4321 struct coding_system
*coding
;
4323 int multibytep
= coding
->dst_multibyte
;
4324 int *charbuf
= coding
->charbuf
;
4325 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4326 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4327 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4329 int produced_chars
= 0;
4330 Lisp_Object attrs
, charset_list
, val
;
4331 int ascii_compatible
;
4332 struct charset
*charset_roman
, *charset_big5
;
4335 CODING_GET_INFO (coding
, attrs
, charset_list
);
4337 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4338 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4339 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4341 while (charbuf
< charbuf_end
)
4343 ASSURE_DESTINATION (safe_room
);
4345 /* Now encode the character C. */
4346 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4347 EMIT_ONE_ASCII_BYTE (c
);
4348 else if (CHAR_BYTE8_P (c
))
4350 c
= CHAR_TO_BYTE8 (c
);
4356 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4360 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4362 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4363 charset
= CHARSET_FROM_ID (charset_ascii
);
4367 c
= coding
->default_char
;
4368 charset
= char_charset (c
, charset_list
, &code
);
4371 if (code
== CHARSET_INVALID_CODE (charset
))
4373 if (charset
== charset_big5
)
4377 c1
= code
>> 8, c2
= code
& 0xFF;
4378 EMIT_TWO_BYTES (c1
, c2
);
4381 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4384 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4385 coding
->produced_char
+= produced_chars
;
4386 coding
->produced
= dst
- coding
->destination
;
4391 /*** 10. CCL handlers ***/
4393 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4394 Check if a text is encoded in a coding system of which
4395 encoder/decoder are written in CCL program. If it is, return
4396 CATEGORY_MASK_CCL, else return 0. */
4399 detect_coding_ccl (coding
, detect_info
)
4400 struct coding_system
*coding
;
4401 struct coding_detection_info
*detect_info
;
4403 const unsigned char *src
= coding
->source
, *src_base
;
4404 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4405 int multibytep
= coding
->src_multibyte
;
4406 int consumed_chars
= 0;
4408 unsigned char *valids
;
4409 int head_ascii
= coding
->head_ascii
;
4412 detect_info
->checked
|= CATEGORY_MASK_CCL
;
4414 coding
= &coding_categories
[coding_category_ccl
];
4415 valids
= CODING_CCL_VALIDS (coding
);
4416 attrs
= CODING_ID_ATTRS (coding
->id
);
4417 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4426 if (c
< 0 || ! valids
[c
])
4428 if ((valids
[c
] > 1))
4429 found
= CATEGORY_MASK_CCL
;
4431 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
4435 detect_info
->found
|= found
;
4440 decode_coding_ccl (coding
)
4441 struct coding_system
*coding
;
4443 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4444 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4445 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4446 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
4447 int consumed_chars
= 0;
4448 int multibytep
= coding
->src_multibyte
;
4449 struct ccl_program ccl
;
4450 int source_charbuf
[1024];
4451 int source_byteidx
[1024];
4452 Lisp_Object attrs
, charset_list
;
4454 CODING_GET_INFO (coding
, attrs
, charset_list
);
4455 setup_ccl_program (&ccl
, CODING_CCL_DECODER (coding
));
4457 while (src
< src_end
)
4459 const unsigned char *p
= src
;
4460 int *source
, *source_end
;
4464 while (i
< 1024 && p
< src_end
)
4466 source_byteidx
[i
] = p
- src
;
4467 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
4470 while (i
< 1024 && p
< src_end
)
4471 source_charbuf
[i
++] = *p
++;
4473 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4476 source
= source_charbuf
;
4477 source_end
= source
+ i
;
4478 while (source
< source_end
)
4480 ccl_driver (&ccl
, source
, charbuf
,
4481 source_end
- source
, charbuf_end
- charbuf
,
4483 source
+= ccl
.consumed
;
4484 charbuf
+= ccl
.produced
;
4485 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_DST
)
4488 if (source
< source_end
)
4489 src
+= source_byteidx
[source
- source_charbuf
];
4492 consumed_chars
+= source
- source_charbuf
;
4494 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_SRC
4495 && ccl
.status
!= CODING_RESULT_INSUFFICIENT_SRC
)
4501 case CCL_STAT_SUSPEND_BY_SRC
:
4502 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4504 case CCL_STAT_SUSPEND_BY_DST
:
4507 case CCL_STAT_INVALID_CMD
:
4508 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4511 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4514 coding
->consumed_char
+= consumed_chars
;
4515 coding
->consumed
= src
- coding
->source
;
4516 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4520 encode_coding_ccl (coding
)
4521 struct coding_system
*coding
;
4523 struct ccl_program ccl
;
4524 int multibytep
= coding
->dst_multibyte
;
4525 int *charbuf
= coding
->charbuf
;
4526 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4527 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4528 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4529 unsigned char *adjusted_dst_end
= dst_end
- 1;
4530 int destination_charbuf
[1024];
4531 int i
, produced_chars
= 0;
4532 Lisp_Object attrs
, charset_list
;
4534 CODING_GET_INFO (coding
, attrs
, charset_list
);
4535 setup_ccl_program (&ccl
, CODING_CCL_ENCODER (coding
));
4537 ccl
.last_block
= coding
->mode
& CODING_MODE_LAST_BLOCK
;
4538 ccl
.dst_multibyte
= coding
->dst_multibyte
;
4540 while (charbuf
< charbuf_end
&& dst
< adjusted_dst_end
)
4542 int dst_bytes
= dst_end
- dst
;
4543 if (dst_bytes
> 1024)
4546 ccl_driver (&ccl
, charbuf
, destination_charbuf
,
4547 charbuf_end
- charbuf
, dst_bytes
, charset_list
);
4548 charbuf
+= ccl
.consumed
;
4550 for (i
= 0; i
< ccl
.produced
; i
++)
4551 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
4554 for (i
= 0; i
< ccl
.produced
; i
++)
4555 *dst
++ = destination_charbuf
[i
] & 0xFF;
4556 produced_chars
+= ccl
.produced
;
4562 case CCL_STAT_SUSPEND_BY_SRC
:
4563 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4565 case CCL_STAT_SUSPEND_BY_DST
:
4566 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
4569 case CCL_STAT_INVALID_CMD
:
4570 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4573 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4577 coding
->produced_char
+= produced_chars
;
4578 coding
->produced
= dst
- coding
->destination
;
4584 /*** 10, 11. no-conversion handlers ***/
4586 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4589 decode_coding_raw_text (coding
)
4590 struct coding_system
*coding
;
4592 coding
->chars_at_source
= 1;
4593 coding
->consumed_char
= 0;
4594 coding
->consumed
= 0;
4595 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4599 encode_coding_raw_text (coding
)
4600 struct coding_system
*coding
;
4602 int multibytep
= coding
->dst_multibyte
;
4603 int *charbuf
= coding
->charbuf
;
4604 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
4605 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4606 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4607 int produced_chars
= 0;
4612 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
4614 if (coding
->src_multibyte
)
4615 while (charbuf
< charbuf_end
)
4617 ASSURE_DESTINATION (safe_room
);
4619 if (ASCII_CHAR_P (c
))
4620 EMIT_ONE_ASCII_BYTE (c
);
4621 else if (CHAR_BYTE8_P (c
))
4623 c
= CHAR_TO_BYTE8 (c
);
4628 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
4630 CHAR_STRING_ADVANCE (c
, p1
);
4633 EMIT_ONE_BYTE (*p0
);
4639 while (charbuf
< charbuf_end
)
4641 ASSURE_DESTINATION (safe_room
);
4648 if (coding
->src_multibyte
)
4650 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4652 while (charbuf
< charbuf_end
)
4654 ASSURE_DESTINATION (safe_room
);
4656 if (ASCII_CHAR_P (c
))
4658 else if (CHAR_BYTE8_P (c
))
4659 *dst
++ = CHAR_TO_BYTE8 (c
);
4661 CHAR_STRING_ADVANCE (c
, dst
);
4667 ASSURE_DESTINATION (charbuf_end
- charbuf
);
4668 while (charbuf
< charbuf_end
&& dst
< dst_end
)
4669 *dst
++ = *charbuf
++;
4670 produced_chars
= dst
- (coding
->destination
+ coding
->dst_bytes
);
4673 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4674 coding
->produced_char
+= produced_chars
;
4675 coding
->produced
= dst
- coding
->destination
;
4679 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4680 Check if a text is encoded in a charset-based coding system. If it
4681 is, return 1, else return 0. */
4684 detect_coding_charset (coding
, detect_info
)
4685 struct coding_system
*coding
;
4686 struct coding_detection_info
*detect_info
;
4688 const unsigned char *src
= coding
->source
, *src_base
;
4689 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4690 int multibytep
= coding
->src_multibyte
;
4691 int consumed_chars
= 0;
4692 Lisp_Object attrs
, valids
;
4695 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
4697 coding
= &coding_categories
[coding_category_charset
];
4698 attrs
= CODING_ID_ATTRS (coding
->id
);
4699 valids
= AREF (attrs
, coding_attr_charset_valids
);
4701 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4702 src
+= coding
->head_ascii
;
4712 if (NILP (AREF (valids
, c
)))
4715 found
= CATEGORY_MASK_CHARSET
;
4717 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
4721 detect_info
->found
|= found
;
4726 decode_coding_charset (coding
)
4727 struct coding_system
*coding
;
4729 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4730 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4731 const unsigned char *src_base
;
4732 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4734 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4735 int consumed_chars
= 0, consumed_chars_base
;
4736 int multibytep
= coding
->src_multibyte
;
4737 Lisp_Object attrs
, charset_list
, valids
;
4738 int char_offset
= coding
->produced_char
;
4739 int last_offset
= char_offset
;
4740 int last_id
= charset_ascii
;
4742 CODING_GET_INFO (coding
, attrs
, charset_list
);
4743 valids
= AREF (attrs
, coding_attr_charset_valids
);
4749 struct charset
*charset
;
4755 consumed_chars_base
= consumed_chars
;
4757 if (charbuf
>= charbuf_end
)
4765 val
= AREF (valids
, c
);
4770 charset
= CHARSET_FROM_ID (XFASTINT (val
));
4771 dim
= CHARSET_DIMENSION (charset
);
4775 code
= (code
<< 8) | c
;
4778 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
4783 /* VAL is a list of charset IDs. It is assured that the
4784 list is sorted by charset dimensions (smaller one
4788 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
4789 dim
= CHARSET_DIMENSION (charset
);
4793 code
= (code
<< 8) | c
;
4796 CODING_DECODE_CHAR (coding
, src
, src_base
,
4797 src_end
, charset
, code
, c
);
4805 if (charset
->id
!= charset_ascii
4806 && last_id
!= charset
->id
)
4808 if (last_id
!= charset_ascii
)
4809 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4810 last_id
= charset
->id
;
4811 last_offset
= char_offset
;
4820 consumed_chars
= consumed_chars_base
;
4822 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
4828 if (last_id
!= charset_ascii
)
4829 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4830 coding
->consumed_char
+= consumed_chars_base
;
4831 coding
->consumed
= src_base
- coding
->source
;
4832 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4836 encode_coding_charset (coding
)
4837 struct coding_system
*coding
;
4839 int multibytep
= coding
->dst_multibyte
;
4840 int *charbuf
= coding
->charbuf
;
4841 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4842 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4843 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4844 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4845 int produced_chars
= 0;
4846 Lisp_Object attrs
, charset_list
;
4847 int ascii_compatible
;
4850 CODING_GET_INFO (coding
, attrs
, charset_list
);
4851 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4853 while (charbuf
< charbuf_end
)
4855 struct charset
*charset
;
4858 ASSURE_DESTINATION (safe_room
);
4860 if (ascii_compatible
&& ASCII_CHAR_P (c
))
4861 EMIT_ONE_ASCII_BYTE (c
);
4862 else if (CHAR_BYTE8_P (c
))
4864 c
= CHAR_TO_BYTE8 (c
);
4869 charset
= char_charset (c
, charset_list
, &code
);
4872 if (CHARSET_DIMENSION (charset
) == 1)
4873 EMIT_ONE_BYTE (code
);
4874 else if (CHARSET_DIMENSION (charset
) == 2)
4875 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
4876 else if (CHARSET_DIMENSION (charset
) == 3)
4877 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
4879 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
4880 (code
>> 8) & 0xFF, code
& 0xFF);
4884 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4885 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4887 c
= coding
->default_char
;
4893 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4894 coding
->produced_char
+= produced_chars
;
4895 coding
->produced
= dst
- coding
->destination
;
4900 /*** 7. C library functions ***/
4902 /* Setup coding context CODING from information about CODING_SYSTEM.
4903 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
4904 CODING_SYSTEM is invalid, signal an error. */
4907 setup_coding_system (coding_system
, coding
)
4908 Lisp_Object coding_system
;
4909 struct coding_system
*coding
;
4912 Lisp_Object eol_type
;
4913 Lisp_Object coding_type
;
4916 if (NILP (coding_system
))
4917 coding_system
= Qundecided
;
4919 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
4921 attrs
= CODING_ID_ATTRS (coding
->id
);
4922 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
4925 coding
->head_ascii
= -1;
4926 coding
->common_flags
4927 = (VECTORP (eol_type
) ? CODING_REQUIRE_DETECTION_MASK
: 0);
4928 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
4929 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
4930 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
4931 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
4932 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
4933 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
4935 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4936 coding
->max_charset_id
= SCHARS (val
) - 1;
4937 coding
->safe_charsets
= (char *) SDATA (val
);
4938 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
4940 coding_type
= CODING_ATTR_TYPE (attrs
);
4941 if (EQ (coding_type
, Qundecided
))
4943 coding
->detector
= NULL
;
4944 coding
->decoder
= decode_coding_raw_text
;
4945 coding
->encoder
= encode_coding_raw_text
;
4946 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
4948 else if (EQ (coding_type
, Qiso_2022
))
4951 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
4953 /* Invoke graphic register 0 to plane 0. */
4954 CODING_ISO_INVOCATION (coding
, 0) = 0;
4955 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
4956 CODING_ISO_INVOCATION (coding
, 1)
4957 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
4958 /* Setup the initial status of designation. */
4959 for (i
= 0; i
< 4; i
++)
4960 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
4961 /* Not single shifting initially. */
4962 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
4963 /* Beginning of buffer should also be regarded as bol. */
4964 CODING_ISO_BOL (coding
) = 1;
4965 coding
->detector
= detect_coding_iso_2022
;
4966 coding
->decoder
= decode_coding_iso_2022
;
4967 coding
->encoder
= encode_coding_iso_2022
;
4968 if (flags
& CODING_ISO_FLAG_SAFE
)
4969 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
4970 coding
->common_flags
4971 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
4972 | CODING_REQUIRE_FLUSHING_MASK
);
4973 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
4974 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
4975 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
4976 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
4977 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
4979 setup_iso_safe_charsets (attrs
);
4980 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4981 coding
->max_charset_id
= SCHARS (val
) - 1;
4982 coding
->safe_charsets
= (char *) SDATA (val
);
4984 CODING_ISO_FLAGS (coding
) = flags
;
4986 else if (EQ (coding_type
, Qcharset
))
4988 coding
->detector
= detect_coding_charset
;
4989 coding
->decoder
= decode_coding_charset
;
4990 coding
->encoder
= encode_coding_charset
;
4991 coding
->common_flags
4992 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
4994 else if (EQ (coding_type
, Qutf_8
))
4996 coding
->detector
= detect_coding_utf_8
;
4997 coding
->decoder
= decode_coding_utf_8
;
4998 coding
->encoder
= encode_coding_utf_8
;
4999 coding
->common_flags
5000 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5002 else if (EQ (coding_type
, Qutf_16
))
5004 val
= AREF (attrs
, coding_attr_utf_16_bom
);
5005 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_16_detect_bom
5006 : EQ (val
, Qt
) ? utf_16_with_bom
5007 : utf_16_without_bom
);
5008 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5009 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5010 : utf_16_little_endian
);
5011 CODING_UTF_16_SURROGATE (coding
) = 0;
5012 coding
->detector
= detect_coding_utf_16
;
5013 coding
->decoder
= decode_coding_utf_16
;
5014 coding
->encoder
= encode_coding_utf_16
;
5015 coding
->common_flags
5016 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5017 if (CODING_UTF_16_BOM (coding
) == utf_16_detect_bom
)
5018 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5020 else if (EQ (coding_type
, Qccl
))
5022 coding
->detector
= detect_coding_ccl
;
5023 coding
->decoder
= decode_coding_ccl
;
5024 coding
->encoder
= encode_coding_ccl
;
5025 coding
->common_flags
5026 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5027 | CODING_REQUIRE_FLUSHING_MASK
);
5029 else if (EQ (coding_type
, Qemacs_mule
))
5031 coding
->detector
= detect_coding_emacs_mule
;
5032 coding
->decoder
= decode_coding_emacs_mule
;
5033 coding
->encoder
= encode_coding_emacs_mule
;
5034 coding
->common_flags
5035 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5036 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5037 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5039 Lisp_Object tail
, safe_charsets
;
5040 int max_charset_id
= 0;
5042 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5044 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5045 max_charset_id
= XFASTINT (XCAR (tail
));
5046 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
5048 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5050 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5051 coding
->max_charset_id
= max_charset_id
;
5052 coding
->safe_charsets
= (char *) SDATA (safe_charsets
);
5055 else if (EQ (coding_type
, Qshift_jis
))
5057 coding
->detector
= detect_coding_sjis
;
5058 coding
->decoder
= decode_coding_sjis
;
5059 coding
->encoder
= encode_coding_sjis
;
5060 coding
->common_flags
5061 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5063 else if (EQ (coding_type
, Qbig5
))
5065 coding
->detector
= detect_coding_big5
;
5066 coding
->decoder
= decode_coding_big5
;
5067 coding
->encoder
= encode_coding_big5
;
5068 coding
->common_flags
5069 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5071 else /* EQ (coding_type, Qraw_text) */
5073 coding
->detector
= NULL
;
5074 coding
->decoder
= decode_coding_raw_text
;
5075 coding
->encoder
= encode_coding_raw_text
;
5076 if (! EQ (eol_type
, Qunix
))
5078 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5079 if (! VECTORP (eol_type
))
5080 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5088 /* Return a list of charsets supported by CODING. */
5091 coding_charset_list (coding
)
5092 struct coding_system
*coding
;
5094 Lisp_Object attrs
, charset_list
, coding_type
;
5096 CODING_GET_INFO (coding
, attrs
, charset_list
);
5097 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5099 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5101 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5102 charset_list
= Viso_2022_charset_list
;
5104 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5106 charset_list
= Vemacs_mule_charset_list
;
5108 return charset_list
;
5112 /* Return raw-text or one of its subsidiaries that has the same
5113 eol_type as CODING-SYSTEM. */
5116 raw_text_coding_system (coding_system
)
5117 Lisp_Object coding_system
;
5119 Lisp_Object spec
, attrs
;
5120 Lisp_Object eol_type
, raw_text_eol_type
;
5122 if (NILP (coding_system
))
5124 spec
= CODING_SYSTEM_SPEC (coding_system
);
5125 attrs
= AREF (spec
, 0);
5127 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5128 return coding_system
;
5130 eol_type
= AREF (spec
, 2);
5131 if (VECTORP (eol_type
))
5133 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5134 raw_text_eol_type
= AREF (spec
, 2);
5135 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5136 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5137 : AREF (raw_text_eol_type
, 2));
5141 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5142 does, return one of the subsidiary that has the same eol-spec as
5143 PARENT. Otherwise, return CODING_SYSTEM. */
5146 coding_inherit_eol_type (coding_system
, parent
)
5147 Lisp_Object coding_system
, parent
;
5149 Lisp_Object spec
, eol_type
;
5151 if (NILP (coding_system
))
5152 coding_system
= Qraw_text
;
5153 spec
= CODING_SYSTEM_SPEC (coding_system
);
5154 eol_type
= AREF (spec
, 2);
5155 if (VECTORP (eol_type
)
5158 Lisp_Object parent_spec
;
5159 Lisp_Object parent_eol_type
;
5162 = CODING_SYSTEM_SPEC (buffer_defaults
.buffer_file_coding_system
);
5163 parent_eol_type
= AREF (parent_spec
, 2);
5164 if (EQ (parent_eol_type
, Qunix
))
5165 coding_system
= AREF (eol_type
, 0);
5166 else if (EQ (parent_eol_type
, Qdos
))
5167 coding_system
= AREF (eol_type
, 1);
5168 else if (EQ (parent_eol_type
, Qmac
))
5169 coding_system
= AREF (eol_type
, 2);
5171 return coding_system
;
5174 /* Emacs has a mechanism to automatically detect a coding system if it
5175 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5176 it's impossible to distinguish some coding systems accurately
5177 because they use the same range of codes. So, at first, coding
5178 systems are categorized into 7, those are:
5180 o coding-category-emacs-mule
5182 The category for a coding system which has the same code range
5183 as Emacs' internal format. Assigned the coding-system (Lisp
5184 symbol) `emacs-mule' by default.
5186 o coding-category-sjis
5188 The category for a coding system which has the same code range
5189 as SJIS. Assigned the coding-system (Lisp
5190 symbol) `japanese-shift-jis' by default.
5192 o coding-category-iso-7
5194 The category for a coding system which has the same code range
5195 as ISO2022 of 7-bit environment. This doesn't use any locking
5196 shift and single shift functions. This can encode/decode all
5197 charsets. Assigned the coding-system (Lisp symbol)
5198 `iso-2022-7bit' by default.
5200 o coding-category-iso-7-tight
5202 Same as coding-category-iso-7 except that this can
5203 encode/decode only the specified charsets.
5205 o coding-category-iso-8-1
5207 The category for a coding system which has the same code range
5208 as ISO2022 of 8-bit environment and graphic plane 1 used only
5209 for DIMENSION1 charset. This doesn't use any locking shift
5210 and single shift functions. Assigned the coding-system (Lisp
5211 symbol) `iso-latin-1' by default.
5213 o coding-category-iso-8-2
5215 The category for a coding system which has the same code range
5216 as ISO2022 of 8-bit environment and graphic plane 1 used only
5217 for DIMENSION2 charset. This doesn't use any locking shift
5218 and single shift functions. Assigned the coding-system (Lisp
5219 symbol) `japanese-iso-8bit' by default.
5221 o coding-category-iso-7-else
5223 The category for a coding system which has the same code range
5224 as ISO2022 of 7-bit environemnt but uses locking shift or
5225 single shift functions. Assigned the coding-system (Lisp
5226 symbol) `iso-2022-7bit-lock' by default.
5228 o coding-category-iso-8-else
5230 The category for a coding system which has the same code range
5231 as ISO2022 of 8-bit environemnt but uses locking shift or
5232 single shift functions. Assigned the coding-system (Lisp
5233 symbol) `iso-2022-8bit-ss2' by default.
5235 o coding-category-big5
5237 The category for a coding system which has the same code range
5238 as BIG5. Assigned the coding-system (Lisp symbol)
5239 `cn-big5' by default.
5241 o coding-category-utf-8
5243 The category for a coding system which has the same code range
5244 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
5245 symbol) `utf-8' by default.
5247 o coding-category-utf-16-be
5249 The category for a coding system in which a text has an
5250 Unicode signature (cf. Unicode Standard) in the order of BIG
5251 endian at the head. Assigned the coding-system (Lisp symbol)
5252 `utf-16-be' by default.
5254 o coding-category-utf-16-le
5256 The category for a coding system in which a text has an
5257 Unicode signature (cf. Unicode Standard) in the order of
5258 LITTLE endian at the head. Assigned the coding-system (Lisp
5259 symbol) `utf-16-le' by default.
5261 o coding-category-ccl
5263 The category for a coding system of which encoder/decoder is
5264 written in CCL programs. The default value is nil, i.e., no
5265 coding system is assigned.
5267 o coding-category-binary
5269 The category for a coding system not categorized in any of the
5270 above. Assigned the coding-system (Lisp symbol)
5271 `no-conversion' by default.
5273 Each of them is a Lisp symbol and the value is an actual
5274 `coding-system's (this is also a Lisp symbol) assigned by a user.
5275 What Emacs does actually is to detect a category of coding system.
5276 Then, it uses a `coding-system' assigned to it. If Emacs can't
5277 decide only one possible category, it selects a category of the
5278 highest priority. Priorities of categories are also specified by a
5279 user in a Lisp variable `coding-category-list'.
5283 #define EOL_SEEN_NONE 0
5284 #define EOL_SEEN_LF 1
5285 #define EOL_SEEN_CR 2
5286 #define EOL_SEEN_CRLF 4
5288 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
5289 SOURCE is encoded. If CATEGORY is one of
5290 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5291 two-byte, else they are encoded by one-byte.
5293 Return one of EOL_SEEN_XXX. */
5295 #define MAX_EOL_CHECK_COUNT 3
5298 detect_eol (source
, src_bytes
, category
)
5299 const unsigned char *source
;
5300 EMACS_INT src_bytes
;
5301 enum coding_category category
;
5303 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
5306 int eol_seen
= EOL_SEEN_NONE
;
5308 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
5312 msb
= category
== (coding_category_utf_16_le
5313 | coding_category_utf_16_le_nosig
);
5316 while (src
+ 1 < src_end
)
5319 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
5324 this_eol
= EOL_SEEN_LF
;
5325 else if (src
+ 3 >= src_end
5326 || src
[msb
+ 2] != 0
5327 || src
[lsb
+ 2] != '\n')
5328 this_eol
= EOL_SEEN_CR
;
5330 this_eol
= EOL_SEEN_CRLF
;
5332 if (eol_seen
== EOL_SEEN_NONE
)
5333 /* This is the first end-of-line. */
5334 eol_seen
= this_eol
;
5335 else if (eol_seen
!= this_eol
)
5337 /* The found type is different from what found before. */
5338 eol_seen
= EOL_SEEN_LF
;
5341 if (++total
== MAX_EOL_CHECK_COUNT
)
5349 while (src
< src_end
)
5352 if (c
== '\n' || c
== '\r')
5357 this_eol
= EOL_SEEN_LF
;
5358 else if (src
>= src_end
|| *src
!= '\n')
5359 this_eol
= EOL_SEEN_CR
;
5361 this_eol
= EOL_SEEN_CRLF
, src
++;
5363 if (eol_seen
== EOL_SEEN_NONE
)
5364 /* This is the first end-of-line. */
5365 eol_seen
= this_eol
;
5366 else if (eol_seen
!= this_eol
)
5368 /* The found type is different from what found before. */
5369 eol_seen
= EOL_SEEN_LF
;
5372 if (++total
== MAX_EOL_CHECK_COUNT
)
5382 adjust_coding_eol_type (coding
, eol_seen
)
5383 struct coding_system
*coding
;
5386 Lisp_Object eol_type
;
5388 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5389 if (eol_seen
& EOL_SEEN_LF
)
5391 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
5394 else if (eol_seen
& EOL_SEEN_CRLF
)
5396 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
5399 else if (eol_seen
& EOL_SEEN_CR
)
5401 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
5407 /* Detect how a text specified in CODING is encoded. If a coding
5408 system is detected, update fields of CODING by the detected coding
5412 detect_coding (coding
)
5413 struct coding_system
*coding
;
5415 const unsigned char *src
, *src_end
;
5417 coding
->consumed
= coding
->consumed_char
= 0;
5418 coding
->produced
= coding
->produced_char
= 0;
5419 coding_set_source (coding
);
5421 src_end
= coding
->source
+ coding
->src_bytes
;
5423 /* If we have not yet decided the text encoding type, detect it
5425 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
5428 struct coding_detection_info detect_info
;
5430 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
5431 for (i
= 0, src
= coding
->source
; src
< src_end
; i
++, src
++)
5437 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
5438 && ! inhibit_iso_escape_detection
5439 && ! detect_info
.checked
)
5441 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5442 if (detect_coding_iso_2022 (coding
, &detect_info
))
5444 /* We have scanned the whole data. */
5445 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
5446 /* We didn't find an 8-bit code. */
5452 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5454 if (coding
->head_ascii
< coding
->src_bytes
5455 || detect_info
.found
)
5457 enum coding_category category
;
5458 struct coding_system
*this;
5460 if (coding
->head_ascii
== coding
->src_bytes
)
5461 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
5462 for (i
= 0; i
< coding_category_raw_text
; i
++)
5464 category
= coding_priorities
[i
];
5465 this = coding_categories
+ category
;
5466 if (detect_info
.found
& (1 << category
))
5470 for (i
= 0; i
< coding_category_raw_text
; i
++)
5472 category
= coding_priorities
[i
];
5473 this = coding_categories
+ category
;
5476 /* No coding system of this category is defined. */
5477 detect_info
.rejected
|= (1 << category
);
5479 else if (category
>= coding_category_raw_text
)
5481 else if (detect_info
.checked
& (1 << category
))
5483 if (detect_info
.found
& (1 << category
))
5486 else if ((*(this->detector
)) (coding
, &detect_info
)
5487 && detect_info
.found
& (1 << category
))
5489 if (category
== coding_category_utf_16_auto
)
5491 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5492 category
= coding_category_utf_16_le
;
5494 category
= coding_category_utf_16_be
;
5500 if (i
< coding_category_raw_text
)
5501 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5502 else if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
5503 setup_coding_system (Qraw_text
, coding
);
5504 else if (detect_info
.rejected
)
5505 for (i
= 0; i
< coding_category_raw_text
; i
++)
5506 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
5508 this = coding_categories
+ coding_priorities
[i
];
5509 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5514 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
5515 == coding_category_utf_16_auto
)
5517 Lisp_Object coding_systems
;
5518 struct coding_detection_info detect_info
;
5521 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_16_bom
);
5522 detect_info
.found
= detect_info
.rejected
= 0;
5523 if (CONSP (coding_systems
)
5524 && detect_coding_utf_16 (coding
, &detect_info
))
5526 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5527 setup_coding_system (XCAR (coding_systems
), coding
);
5528 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
5529 setup_coding_system (XCDR (coding_systems
), coding
);
5537 struct coding_system
*coding
;
5539 Lisp_Object eol_type
;
5540 unsigned char *p
, *pbeg
, *pend
;
5542 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5543 if (EQ (eol_type
, Qunix
))
5546 if (NILP (coding
->dst_object
))
5547 pbeg
= coding
->destination
;
5549 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
5550 pend
= pbeg
+ coding
->produced
;
5552 if (VECTORP (eol_type
))
5554 int eol_seen
= EOL_SEEN_NONE
;
5556 for (p
= pbeg
; p
< pend
; p
++)
5559 eol_seen
|= EOL_SEEN_LF
;
5560 else if (*p
== '\r')
5562 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
5564 eol_seen
|= EOL_SEEN_CRLF
;
5568 eol_seen
|= EOL_SEEN_CR
;
5571 if (eol_seen
!= EOL_SEEN_NONE
5572 && eol_seen
!= EOL_SEEN_LF
5573 && eol_seen
!= EOL_SEEN_CRLF
5574 && eol_seen
!= EOL_SEEN_CR
)
5575 eol_seen
= EOL_SEEN_LF
;
5576 if (eol_seen
!= EOL_SEEN_NONE
)
5577 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
5580 if (EQ (eol_type
, Qmac
))
5582 for (p
= pbeg
; p
< pend
; p
++)
5586 else if (EQ (eol_type
, Qdos
))
5590 if (NILP (coding
->dst_object
))
5592 for (p
= pend
- 2; p
>= pbeg
; p
--)
5595 safe_bcopy ((char *) (p
+ 1), (char *) p
, pend
-- - p
- 1);
5601 for (p
= pend
- 2; p
>= pbeg
; p
--)
5604 int pos_byte
= coding
->dst_pos_byte
+ (p
- pbeg
);
5605 int pos
= BYTE_TO_CHAR (pos_byte
);
5607 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
5611 coding
->produced
-= n
;
5612 coding
->produced_char
-= n
;
5617 /* Return a translation table (or list of them) from coding system
5618 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
5619 decoding (ENCODEP is zero). */
5622 get_translation_table (attrs
, encodep
, max_lookup
)
5624 int encodep
, *max_lookup
;
5626 Lisp_Object standard
, translation_table
;
5630 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
5631 standard
= Vstandard_translation_table_for_encode
;
5633 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
5634 standard
= Vstandard_translation_table_for_decode
;
5635 if (NILP (translation_table
))
5636 translation_table
= standard
;
5639 if (SYMBOLP (translation_table
))
5640 translation_table
= Fget (translation_table
, Qtranslation_table
);
5641 else if (CONSP (translation_table
))
5643 translation_table
= Fcopy_sequence (translation_table
);
5644 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
5645 if (SYMBOLP (XCAR (val
)))
5646 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
5648 if (CHAR_TABLE_P (standard
))
5650 if (CONSP (translation_table
))
5651 translation_table
= nconc2 (translation_table
,
5652 Fcons (standard
, Qnil
));
5654 translation_table
= Fcons (translation_table
,
5655 Fcons (standard
, Qnil
));
5662 if (CHAR_TABLE_P (translation_table
)
5663 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
5665 val
= XCHAR_TABLE (translation_table
)->extras
[1];
5666 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5667 *max_lookup
= XFASTINT (val
);
5669 else if (CONSP (translation_table
))
5671 Lisp_Object tail
, val
;
5673 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
5674 if (CHAR_TABLE_P (XCAR (tail
))
5675 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
5677 val
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
5678 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5679 *max_lookup
= XFASTINT (val
);
5683 return translation_table
;
5686 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
5689 if (CHAR_TABLE_P (table)) \
5691 trans = CHAR_TABLE_REF (table, c); \
5692 if (CHARACTERP (trans)) \
5693 c = XFASTINT (trans), trans = Qnil; \
5695 else if (CONSP (table)) \
5699 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
5700 if (CHAR_TABLE_P (XCAR (tail))) \
5702 trans = CHAR_TABLE_REF (XCAR (tail), c); \
5703 if (CHARACTERP (trans)) \
5704 c = XFASTINT (trans), trans = Qnil; \
5705 else if (! NILP (trans)) \
5713 get_translation (val
, buf
, buf_end
, last_block
, from_nchars
, to_nchars
)
5717 int *from_nchars
, *to_nchars
;
5719 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
5723 Lisp_Object from
, tail
;
5726 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
5731 for (i
= 0; i
< len
; i
++)
5733 if (buf
+ i
== buf_end
)
5739 if (XINT (AREF (from
, i
)) != buf
[i
])
5753 *buf
= XINT (AREF (val
, 0)), *to_nchars
= ASIZE (val
);
5761 produce_chars (coding
, translation_table
, last_block
)
5762 struct coding_system
*coding
;
5763 Lisp_Object translation_table
;
5766 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5767 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5769 int produced_chars
= 0;
5772 if (! coding
->chars_at_source
)
5774 /* Characters are in coding->charbuf. */
5775 int *buf
= coding
->charbuf
;
5776 int *buf_end
= buf
+ coding
->charbuf_used
;
5778 if (BUFFERP (coding
->src_object
)
5779 && EQ (coding
->src_object
, coding
->dst_object
))
5780 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
5782 while (buf
< buf_end
)
5788 int from_nchars
= 1, to_nchars
= 1;
5789 Lisp_Object trans
= Qnil
;
5791 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
5794 trans
= get_translation (trans
, buf
, buf_end
, last_block
,
5795 &from_nchars
, &to_nchars
);
5801 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
5803 dst
= alloc_destination (coding
,
5805 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
5807 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5810 for (i
= 0; i
< to_nchars
; i
++)
5813 c
= XINT (AREF (trans
, i
));
5814 if (coding
->dst_multibyte
5815 || ! CHAR_BYTE8_P (c
))
5816 CHAR_STRING_ADVANCE (c
, dst
);
5818 *dst
++ = CHAR_TO_BYTE8 (c
);
5820 produced_chars
+= to_nchars
;
5822 while (--from_nchars
> 0)
5826 /* This is an annotation datum. (-C) is the length. */
5829 carryover
= buf_end
- buf
;
5833 const unsigned char *src
= coding
->source
;
5834 const unsigned char *src_end
= src
+ coding
->src_bytes
;
5835 Lisp_Object eol_type
;
5837 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5839 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
5841 if (coding
->src_multibyte
)
5848 const unsigned char *src_base
= src
;
5854 if (EQ (eol_type
, Qdos
))
5858 record_conversion_result
5859 (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5860 goto no_more_source
;
5865 else if (EQ (eol_type
, Qmac
))
5870 coding
->consumed
= src
- coding
->source
;
5872 if (EQ (coding
->src_object
, coding
->dst_object
))
5873 dst_end
= (unsigned char *) src
;
5876 dst
= alloc_destination (coding
, src_end
- src
+ 1,
5878 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5879 coding_set_source (coding
);
5880 src
= coding
->source
+ coding
->consumed
;
5881 src_end
= coding
->source
+ coding
->src_bytes
;
5891 while (src
< src_end
)
5898 if (EQ (eol_type
, Qdos
))
5904 else if (EQ (eol_type
, Qmac
))
5907 if (dst
>= dst_end
- 1)
5909 coding
->consumed
= src
- coding
->source
;
5911 if (EQ (coding
->src_object
, coding
->dst_object
))
5912 dst_end
= (unsigned char *) src
;
5913 if (dst
>= dst_end
- 1)
5915 dst
= alloc_destination (coding
, src_end
- src
+ 2,
5917 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5918 coding_set_source (coding
);
5919 src
= coding
->source
+ coding
->consumed
;
5920 src_end
= coding
->source
+ coding
->src_bytes
;
5928 if (!EQ (coding
->src_object
, coding
->dst_object
))
5930 int require
= coding
->src_bytes
- coding
->dst_bytes
;
5934 EMACS_INT offset
= src
- coding
->source
;
5936 dst
= alloc_destination (coding
, require
, dst
);
5937 coding_set_source (coding
);
5938 src
= coding
->source
+ offset
;
5939 src_end
= coding
->source
+ coding
->src_bytes
;
5942 produced_chars
= coding
->src_chars
;
5943 while (src
< src_end
)
5949 if (EQ (eol_type
, Qdos
))
5956 else if (EQ (eol_type
, Qmac
))
5962 coding
->consumed
= coding
->src_bytes
;
5963 coding
->consumed_char
= coding
->src_chars
;
5966 produced
= dst
- (coding
->destination
+ coding
->produced
);
5967 if (BUFFERP (coding
->dst_object
))
5968 insert_from_gap (produced_chars
, produced
);
5969 coding
->produced
+= produced
;
5970 coding
->produced_char
+= produced_chars
;
5974 /* Compose text in CODING->object according to the annotation data at
5975 CHARBUF. CHARBUF is an array:
5976 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
5980 produce_composition (coding
, charbuf
, pos
)
5981 struct coding_system
*coding
;
5987 enum composition_method method
;
5988 Lisp_Object components
;
5991 to
= pos
+ charbuf
[2];
5994 method
= (enum composition_method
) (charbuf
[3]);
5996 if (method
== COMPOSITION_RELATIVE
)
5998 else if (method
>= COMPOSITION_WITH_RULE
5999 && method
<= COMPOSITION_WITH_RULE_ALTCHARS
)
6001 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6006 for (i
= 0; i
< len
; i
++)
6008 args
[i
] = make_number (charbuf
[i
]);
6012 components
= (method
== COMPOSITION_WITH_ALTCHARS
6013 ? Fstring (len
, args
) : Fvector (len
, args
));
6017 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6021 /* Put `charset' property on text in CODING->object according to
6022 the annotation data at CHARBUF. CHARBUF is an array:
6023 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6027 produce_charset (coding
, charbuf
, pos
)
6028 struct coding_system
*coding
;
6032 EMACS_INT from
= pos
- charbuf
[2];
6033 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6035 Fput_text_property (make_number (from
), make_number (pos
),
6036 Qcharset
, CHARSET_NAME (charset
),
6037 coding
->dst_object
);
6041 #define CHARBUF_SIZE 0x4000
6043 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6045 int size = CHARBUF_SIZE;; \
6047 coding->charbuf = NULL; \
6048 while (size > 1024) \
6050 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6051 if (coding->charbuf) \
6055 if (! coding->charbuf) \
6057 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6058 return coding->result; \
6060 coding->charbuf_size = size; \
6065 produce_annotation (coding
, pos
)
6066 struct coding_system
*coding
;
6069 int *charbuf
= coding
->charbuf
;
6070 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6072 if (NILP (coding
->dst_object
))
6075 while (charbuf
< charbuf_end
)
6081 int len
= -*charbuf
;
6084 case CODING_ANNOTATE_COMPOSITION_MASK
:
6085 produce_composition (coding
, charbuf
, pos
);
6087 case CODING_ANNOTATE_CHARSET_MASK
:
6088 produce_charset (coding
, charbuf
, pos
);
6098 /* Decode the data at CODING->src_object into CODING->dst_object.
6099 CODING->src_object is a buffer, a string, or nil.
6100 CODING->dst_object is a buffer.
6102 If CODING->src_object is a buffer, it must be the current buffer.
6103 In this case, if CODING->src_pos is positive, it is a position of
6104 the source text in the buffer, otherwise, the source text is in the
6105 gap area of the buffer, and CODING->src_pos specifies the offset of
6106 the text from GPT (which must be the same as PT). If this is the
6107 same buffer as CODING->dst_object, CODING->src_pos must be
6110 If CODING->src_object is a string, CODING->src_pos in an index to
6113 If CODING->src_object is nil, CODING->source must already point to
6114 the non-relocatable memory area. In this case, CODING->src_pos is
6115 an offset from CODING->source.
6117 The decoded data is inserted at the current point of the buffer
6122 decode_coding (coding
)
6123 struct coding_system
*coding
;
6126 Lisp_Object undo_list
;
6127 Lisp_Object translation_table
;
6131 if (BUFFERP (coding
->src_object
)
6132 && coding
->src_pos
> 0
6133 && coding
->src_pos
< GPT
6134 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6135 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6138 if (BUFFERP (coding
->dst_object
))
6140 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6141 set_buffer_internal (XBUFFER (coding
->dst_object
));
6143 move_gap_both (PT
, PT_BYTE
);
6144 undo_list
= current_buffer
->undo_list
;
6145 current_buffer
->undo_list
= Qt
;
6148 coding
->consumed
= coding
->consumed_char
= 0;
6149 coding
->produced
= coding
->produced_char
= 0;
6150 coding
->chars_at_source
= 0;
6151 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6154 ALLOC_CONVERSION_WORK_AREA (coding
);
6156 attrs
= CODING_ID_ATTRS (coding
->id
);
6157 translation_table
= get_translation_table (attrs
, 0, NULL
);
6162 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
6164 coding_set_source (coding
);
6165 coding
->annotated
= 0;
6166 coding
->charbuf_used
= carryover
;
6167 (*(coding
->decoder
)) (coding
);
6168 coding_set_destination (coding
);
6169 carryover
= produce_chars (coding
, translation_table
, 0);
6170 if (coding
->annotated
)
6171 produce_annotation (coding
, pos
);
6172 for (i
= 0; i
< carryover
; i
++)
6174 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
6176 while (coding
->consumed
< coding
->src_bytes
6177 && ! coding
->result
);
6181 coding_set_destination (coding
);
6182 coding
->charbuf_used
= carryover
;
6183 produce_chars (coding
, translation_table
, 1);
6186 coding
->carryover_bytes
= 0;
6187 if (coding
->consumed
< coding
->src_bytes
)
6189 int nbytes
= coding
->src_bytes
- coding
->consumed
;
6190 const unsigned char *src
;
6192 coding_set_source (coding
);
6193 coding_set_destination (coding
);
6194 src
= coding
->source
+ coding
->consumed
;
6196 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
6198 /* Flush out unprocessed data as binary chars. We are sure
6199 that the number of data is less than the size of
6201 coding
->charbuf_used
= 0;
6202 while (nbytes
-- > 0)
6206 coding
->charbuf
[coding
->charbuf_used
++] = (c
& 0x80 ? - c
: c
);
6208 produce_chars (coding
, Qnil
, 1);
6212 /* Record unprocessed bytes in coding->carryover. We are
6213 sure that the number of data is less than the size of
6214 coding->carryover. */
6215 unsigned char *p
= coding
->carryover
;
6217 coding
->carryover_bytes
= nbytes
;
6218 while (nbytes
-- > 0)
6221 coding
->consumed
= coding
->src_bytes
;
6224 if (BUFFERP (coding
->dst_object
))
6226 current_buffer
->undo_list
= undo_list
;
6227 record_insert (coding
->dst_pos
, coding
->produced_char
);
6229 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
))
6230 decode_eol (coding
);
6231 return coding
->result
;
6235 /* Extract an annotation datum from a composition starting at POS and
6236 ending before LIMIT of CODING->src_object (buffer or string), store
6237 the data in BUF, set *STOP to a starting position of the next
6238 composition (if any) or to LIMIT, and return the address of the
6239 next element of BUF.
6241 If such an annotation is not found, set *STOP to a starting
6242 position of a composition after POS (if any) or to LIMIT, and
6246 handle_composition_annotation (pos
, limit
, coding
, buf
, stop
)
6247 EMACS_INT pos
, limit
;
6248 struct coding_system
*coding
;
6252 EMACS_INT start
, end
;
6255 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
6258 else if (start
> pos
)
6264 /* We found a composition. Store the corresponding
6265 annotation data in BUF. */
6267 enum composition_method method
= COMPOSITION_METHOD (prop
);
6268 int nchars
= COMPOSITION_LENGTH (prop
);
6270 ADD_COMPOSITION_DATA (buf
, nchars
, method
);
6271 if (method
!= COMPOSITION_RELATIVE
)
6273 Lisp_Object components
;
6276 components
= COMPOSITION_COMPONENTS (prop
);
6277 if (VECTORP (components
))
6279 len
= XVECTOR (components
)->size
;
6280 for (i
= 0; i
< len
; i
++)
6281 *buf
++ = XINT (AREF (components
, i
));
6283 else if (STRINGP (components
))
6285 len
= SCHARS (components
);
6289 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
6293 else if (INTEGERP (components
))
6296 *buf
++ = XINT (components
);
6298 else if (CONSP (components
))
6300 for (len
= 0; CONSP (components
);
6301 len
++, components
= XCDR (components
))
6302 *buf
++ = XINT (XCAR (components
));
6310 if (find_composition (end
, limit
, &start
, &end
, &prop
,
6321 /* Extract an annotation datum from a text property `charset' at POS of
6322 CODING->src_object (buffer of string), store the data in BUF, set
6323 *STOP to the position where the value of `charset' property changes
6324 (limiting by LIMIT), and return the address of the next element of
6327 If the property value is nil, set *STOP to the position where the
6328 property value is non-nil (limiting by LIMIT), and return BUF. */
6331 handle_charset_annotation (pos
, limit
, coding
, buf
, stop
)
6332 EMACS_INT pos
, limit
;
6333 struct coding_system
*coding
;
6337 Lisp_Object val
, next
;
6340 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
6341 if (! NILP (val
) && CHARSETP (val
))
6342 id
= XINT (CHARSET_SYMBOL_ID (val
));
6345 ADD_CHARSET_DATA (buf
, 0, id
);
6346 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
6348 make_number (limit
));
6349 *stop
= XINT (next
);
6355 consume_chars (coding
, translation_table
, max_lookup
)
6356 struct coding_system
*coding
;
6357 Lisp_Object translation_table
;
6360 int *buf
= coding
->charbuf
;
6361 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
6362 const unsigned char *src
= coding
->source
+ coding
->consumed
;
6363 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
6364 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
6365 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
6366 int multibytep
= coding
->src_multibyte
;
6367 Lisp_Object eol_type
;
6369 EMACS_INT stop
, stop_composition
, stop_charset
;
6370 int *lookup_buf
= NULL
;
6372 if (! NILP (translation_table
))
6373 lookup_buf
= alloca (sizeof (int) * max_lookup
);
6375 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6376 if (VECTORP (eol_type
))
6379 /* Note: composition handling is not yet implemented. */
6380 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
6382 if (NILP (coding
->src_object
))
6383 stop
= stop_composition
= stop_charset
= end_pos
;
6386 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
6387 stop
= stop_composition
= pos
;
6389 stop
= stop_composition
= end_pos
;
6390 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
6391 stop
= stop_charset
= pos
;
6393 stop_charset
= end_pos
;
6396 /* Compensate for CRLF and conversion. */
6397 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
6398 while (buf
< buf_end
)
6406 if (pos
== stop_composition
)
6407 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
6408 buf
, &stop_composition
);
6409 if (pos
== stop_charset
)
6410 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
6411 buf
, &stop_charset
);
6412 stop
= (stop_composition
< stop_charset
6413 ? stop_composition
: stop_charset
);
6420 if (coding
->encoder
== encode_coding_raw_text
)
6422 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
6423 c
= STRING_CHAR_ADVANCE (src
), pos
+= bytes
;
6425 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
6428 c
= STRING_CHAR_ADVANCE (src
), pos
++;
6429 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
6431 if (! EQ (eol_type
, Qunix
))
6435 if (EQ (eol_type
, Qdos
))
6443 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6448 int from_nchars
= 1, to_nchars
= 1;
6449 int *lookup_buf_end
;
6450 const unsigned char *p
= src
;
6454 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
6455 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
6456 lookup_buf_end
= lookup_buf
+ i
;
6457 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
, 1,
6458 &from_nchars
, &to_nchars
);
6460 || buf
+ to_nchars
> buf_end
)
6462 *buf
++ = *lookup_buf
;
6463 for (i
= 1; i
< to_nchars
; i
++)
6464 *buf
++ = XINT (AREF (trans
, i
));
6465 for (i
= 1; i
< from_nchars
; i
++, pos
++)
6466 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
6470 coding
->consumed
= src
- coding
->source
;
6471 coding
->consumed_char
= pos
- coding
->src_pos
;
6472 coding
->charbuf_used
= buf
- coding
->charbuf
;
6473 coding
->chars_at_source
= 0;
6477 /* Encode the text at CODING->src_object into CODING->dst_object.
6478 CODING->src_object is a buffer or a string.
6479 CODING->dst_object is a buffer or nil.
6481 If CODING->src_object is a buffer, it must be the current buffer.
6482 In this case, if CODING->src_pos is positive, it is a position of
6483 the source text in the buffer, otherwise. the source text is in the
6484 gap area of the buffer, and coding->src_pos specifies the offset of
6485 the text from GPT (which must be the same as PT). If this is the
6486 same buffer as CODING->dst_object, CODING->src_pos must be
6487 negative and CODING should not have `pre-write-conversion'.
6489 If CODING->src_object is a string, CODING should not have
6490 `pre-write-conversion'.
6492 If CODING->dst_object is a buffer, the encoded data is inserted at
6493 the current point of that buffer.
6495 If CODING->dst_object is nil, the encoded data is placed at the
6496 memory area specified by CODING->destination. */
6499 encode_coding (coding
)
6500 struct coding_system
*coding
;
6503 Lisp_Object translation_table
;
6506 attrs
= CODING_ID_ATTRS (coding
->id
);
6507 if (coding
->encoder
== encode_coding_raw_text
)
6508 translation_table
= Qnil
, max_lookup
= 0;
6510 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
6512 if (BUFFERP (coding
->dst_object
))
6514 set_buffer_internal (XBUFFER (coding
->dst_object
));
6515 coding
->dst_multibyte
6516 = ! NILP (current_buffer
->enable_multibyte_characters
);
6519 coding
->consumed
= coding
->consumed_char
= 0;
6520 coding
->produced
= coding
->produced_char
= 0;
6521 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6524 ALLOC_CONVERSION_WORK_AREA (coding
);
6527 coding_set_source (coding
);
6528 consume_chars (coding
, translation_table
, max_lookup
);
6529 coding_set_destination (coding
);
6530 (*(coding
->encoder
)) (coding
);
6531 } while (coding
->consumed_char
< coding
->src_chars
);
6533 if (BUFFERP (coding
->dst_object
))
6534 insert_from_gap (coding
->produced_char
, coding
->produced
);
6536 return (coding
->result
);
6540 /* Name (or base name) of work buffer for code conversion. */
6541 static Lisp_Object Vcode_conversion_workbuf_name
;
6543 /* A working buffer used by the top level conversion. Once it is
6544 created, it is never destroyed. It has the name
6545 Vcode_conversion_workbuf_name. The other working buffers are
6546 destroyed after the use is finished, and their names are modified
6547 versions of Vcode_conversion_workbuf_name. */
6548 static Lisp_Object Vcode_conversion_reused_workbuf
;
6550 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
6551 static int reused_workbuf_in_use
;
6554 /* Return a working buffer of code convesion. MULTIBYTE specifies the
6555 multibyteness of returning buffer. */
6558 make_conversion_work_buffer (multibyte
)
6561 Lisp_Object name
, workbuf
;
6562 struct buffer
*current
;
6564 if (reused_workbuf_in_use
++)
6566 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
6567 workbuf
= Fget_buffer_create (name
);
6571 name
= Vcode_conversion_workbuf_name
;
6572 workbuf
= Fget_buffer_create (name
);
6573 if (NILP (Vcode_conversion_reused_workbuf
))
6574 Vcode_conversion_reused_workbuf
= workbuf
;
6576 current
= current_buffer
;
6577 set_buffer_internal (XBUFFER (workbuf
));
6579 current_buffer
->undo_list
= Qt
;
6580 current_buffer
->enable_multibyte_characters
= multibyte
? Qt
: Qnil
;
6581 set_buffer_internal (current
);
6587 code_conversion_restore (arg
)
6590 Lisp_Object current
, workbuf
;
6592 current
= XCAR (arg
);
6593 workbuf
= XCDR (arg
);
6594 if (! NILP (workbuf
))
6596 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
6597 reused_workbuf_in_use
= 0;
6598 else if (! NILP (Fbuffer_live_p (workbuf
)))
6599 Fkill_buffer (workbuf
);
6601 set_buffer_internal (XBUFFER (current
));
6606 code_conversion_save (with_work_buf
, multibyte
)
6607 int with_work_buf
, multibyte
;
6609 Lisp_Object workbuf
= Qnil
;
6612 workbuf
= make_conversion_work_buffer (multibyte
);
6613 record_unwind_protect (code_conversion_restore
,
6614 Fcons (Fcurrent_buffer (), workbuf
));
6619 decode_coding_gap (coding
, chars
, bytes
)
6620 struct coding_system
*coding
;
6621 EMACS_INT chars
, bytes
;
6623 int count
= specpdl_ptr
- specpdl
;
6626 code_conversion_save (0, 0);
6628 coding
->src_object
= Fcurrent_buffer ();
6629 coding
->src_chars
= chars
;
6630 coding
->src_bytes
= bytes
;
6631 coding
->src_pos
= -chars
;
6632 coding
->src_pos_byte
= -bytes
;
6633 coding
->src_multibyte
= chars
< bytes
;
6634 coding
->dst_object
= coding
->src_object
;
6635 coding
->dst_pos
= PT
;
6636 coding
->dst_pos_byte
= PT_BYTE
;
6637 coding
->dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
6638 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6640 if (CODING_REQUIRE_DETECTION (coding
))
6641 detect_coding (coding
);
6643 decode_coding (coding
);
6645 attrs
= CODING_ID_ATTRS (coding
->id
);
6646 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6648 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6651 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6652 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6653 make_number (coding
->produced_char
));
6655 coding
->produced_char
+= Z
- prev_Z
;
6656 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6659 unbind_to (count
, Qnil
);
6660 return coding
->result
;
6664 encode_coding_gap (coding
, chars
, bytes
)
6665 struct coding_system
*coding
;
6666 EMACS_INT chars
, bytes
;
6668 int count
= specpdl_ptr
- specpdl
;
6670 code_conversion_save (0, 0);
6672 coding
->src_object
= Fcurrent_buffer ();
6673 coding
->src_chars
= chars
;
6674 coding
->src_bytes
= bytes
;
6675 coding
->src_pos
= -chars
;
6676 coding
->src_pos_byte
= -bytes
;
6677 coding
->src_multibyte
= chars
< bytes
;
6678 coding
->dst_object
= coding
->src_object
;
6679 coding
->dst_pos
= PT
;
6680 coding
->dst_pos_byte
= PT_BYTE
;
6682 encode_coding (coding
);
6684 unbind_to (count
, Qnil
);
6685 return coding
->result
;
6689 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
6690 SRC_OBJECT into DST_OBJECT by coding context CODING.
6692 SRC_OBJECT is a buffer, a string, or Qnil.
6694 If it is a buffer, the text is at point of the buffer. FROM and TO
6695 are positions in the buffer.
6697 If it is a string, the text is at the beginning of the string.
6698 FROM and TO are indices to the string.
6700 If it is nil, the text is at coding->source. FROM and TO are
6701 indices to coding->source.
6703 DST_OBJECT is a buffer, Qt, or Qnil.
6705 If it is a buffer, the decoded text is inserted at point of the
6706 buffer. If the buffer is the same as SRC_OBJECT, the source text
6709 If it is Qt, a string is made from the decoded text, and
6710 set in CODING->dst_object.
6712 If it is Qnil, the decoded text is stored at CODING->destination.
6713 The caller must allocate CODING->dst_bytes bytes at
6714 CODING->destination by xmalloc. If the decoded text is longer than
6715 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
6719 decode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6721 struct coding_system
*coding
;
6722 Lisp_Object src_object
;
6723 EMACS_INT from
, from_byte
, to
, to_byte
;
6724 Lisp_Object dst_object
;
6726 int count
= specpdl_ptr
- specpdl
;
6727 unsigned char *destination
;
6728 EMACS_INT dst_bytes
;
6729 EMACS_INT chars
= to
- from
;
6730 EMACS_INT bytes
= to_byte
- from_byte
;
6733 int saved_pt
= -1, saved_pt_byte
;
6735 buffer
= Fcurrent_buffer ();
6737 if (NILP (dst_object
))
6739 destination
= coding
->destination
;
6740 dst_bytes
= coding
->dst_bytes
;
6743 coding
->src_object
= src_object
;
6744 coding
->src_chars
= chars
;
6745 coding
->src_bytes
= bytes
;
6746 coding
->src_multibyte
= chars
< bytes
;
6748 if (STRINGP (src_object
))
6750 coding
->src_pos
= from
;
6751 coding
->src_pos_byte
= from_byte
;
6753 else if (BUFFERP (src_object
))
6755 set_buffer_internal (XBUFFER (src_object
));
6757 move_gap_both (from
, from_byte
);
6758 if (EQ (src_object
, dst_object
))
6760 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6761 TEMP_SET_PT_BOTH (from
, from_byte
);
6762 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6763 coding
->src_pos
= -chars
;
6764 coding
->src_pos_byte
= -bytes
;
6768 coding
->src_pos
= from
;
6769 coding
->src_pos_byte
= from_byte
;
6773 if (CODING_REQUIRE_DETECTION (coding
))
6774 detect_coding (coding
);
6775 attrs
= CODING_ID_ATTRS (coding
->id
);
6777 if (EQ (dst_object
, Qt
)
6778 || (! NILP (CODING_ATTR_POST_READ (attrs
))
6779 && NILP (dst_object
)))
6781 coding
->dst_object
= code_conversion_save (1, 1);
6782 coding
->dst_pos
= BEG
;
6783 coding
->dst_pos_byte
= BEG_BYTE
;
6784 coding
->dst_multibyte
= 1;
6786 else if (BUFFERP (dst_object
))
6788 code_conversion_save (0, 0);
6789 coding
->dst_object
= dst_object
;
6790 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6791 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6792 coding
->dst_multibyte
6793 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6797 code_conversion_save (0, 0);
6798 coding
->dst_object
= Qnil
;
6799 coding
->dst_multibyte
= 1;
6802 decode_coding (coding
);
6804 if (BUFFERP (coding
->dst_object
))
6805 set_buffer_internal (XBUFFER (coding
->dst_object
));
6807 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6809 struct gcpro gcpro1
, gcpro2
;
6810 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6813 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6814 GCPRO2 (coding
->src_object
, coding
->dst_object
);
6815 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6816 make_number (coding
->produced_char
));
6819 coding
->produced_char
+= Z
- prev_Z
;
6820 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6823 if (EQ (dst_object
, Qt
))
6825 coding
->dst_object
= Fbuffer_string ();
6827 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
6829 set_buffer_internal (XBUFFER (coding
->dst_object
));
6830 if (dst_bytes
< coding
->produced
)
6833 = (unsigned char *) xrealloc (destination
, coding
->produced
);
6836 record_conversion_result (coding
,
6837 CODING_RESULT_INSUFFICIENT_DST
);
6838 unbind_to (count
, Qnil
);
6841 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
6842 move_gap_both (BEGV
, BEGV_BYTE
);
6843 bcopy (BEGV_ADDR
, destination
, coding
->produced
);
6844 coding
->destination
= destination
;
6850 /* This is the case of:
6851 (BUFFERP (src_object) && EQ (src_object, dst_object))
6852 As we have moved PT while replacing the original buffer
6853 contents, we must recover it now. */
6854 set_buffer_internal (XBUFFER (src_object
));
6855 if (saved_pt
< from
)
6856 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
6857 else if (saved_pt
< from
+ chars
)
6858 TEMP_SET_PT_BOTH (from
, from_byte
);
6859 else if (! NILP (current_buffer
->enable_multibyte_characters
))
6860 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
6861 saved_pt_byte
+ (coding
->produced
- bytes
));
6863 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
6864 saved_pt_byte
+ (coding
->produced
- bytes
));
6867 unbind_to (count
, coding
->dst_object
);
6872 encode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6874 struct coding_system
*coding
;
6875 Lisp_Object src_object
;
6876 EMACS_INT from
, from_byte
, to
, to_byte
;
6877 Lisp_Object dst_object
;
6879 int count
= specpdl_ptr
- specpdl
;
6880 EMACS_INT chars
= to
- from
;
6881 EMACS_INT bytes
= to_byte
- from_byte
;
6884 int saved_pt
= -1, saved_pt_byte
;
6886 buffer
= Fcurrent_buffer ();
6888 coding
->src_object
= src_object
;
6889 coding
->src_chars
= chars
;
6890 coding
->src_bytes
= bytes
;
6891 coding
->src_multibyte
= chars
< bytes
;
6893 attrs
= CODING_ID_ATTRS (coding
->id
);
6895 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
6897 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
6898 set_buffer_internal (XBUFFER (coding
->src_object
));
6899 if (STRINGP (src_object
))
6900 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
6901 else if (BUFFERP (src_object
))
6902 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
6904 insert_1_both (coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
6906 if (EQ (src_object
, dst_object
))
6908 set_buffer_internal (XBUFFER (src_object
));
6909 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6910 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6911 set_buffer_internal (XBUFFER (coding
->src_object
));
6914 call2 (CODING_ATTR_PRE_WRITE (attrs
),
6915 make_number (BEG
), make_number (Z
));
6916 coding
->src_object
= Fcurrent_buffer ();
6918 move_gap_both (BEG
, BEG_BYTE
);
6919 coding
->src_chars
= Z
- BEG
;
6920 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
6921 coding
->src_pos
= BEG
;
6922 coding
->src_pos_byte
= BEG_BYTE
;
6923 coding
->src_multibyte
= Z
< Z_BYTE
;
6925 else if (STRINGP (src_object
))
6927 code_conversion_save (0, 0);
6928 coding
->src_pos
= from
;
6929 coding
->src_pos_byte
= from_byte
;
6931 else if (BUFFERP (src_object
))
6933 code_conversion_save (0, 0);
6934 set_buffer_internal (XBUFFER (src_object
));
6935 if (EQ (src_object
, dst_object
))
6937 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6938 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
6939 coding
->src_pos
= 0;
6940 coding
->src_pos_byte
= 0;
6944 if (from
< GPT
&& to
>= GPT
)
6945 move_gap_both (from
, from_byte
);
6946 coding
->src_pos
= from
;
6947 coding
->src_pos_byte
= from_byte
;
6951 code_conversion_save (0, 0);
6953 if (BUFFERP (dst_object
))
6955 coding
->dst_object
= dst_object
;
6956 if (EQ (src_object
, dst_object
))
6958 coding
->dst_pos
= from
;
6959 coding
->dst_pos_byte
= from_byte
;
6963 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6964 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6966 coding
->dst_multibyte
6967 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6969 else if (EQ (dst_object
, Qt
))
6971 coding
->dst_object
= Qnil
;
6972 coding
->dst_bytes
= coding
->src_chars
;
6973 if (coding
->dst_bytes
== 0)
6974 coding
->dst_bytes
= 1;
6975 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
6976 coding
->dst_multibyte
= 0;
6980 coding
->dst_object
= Qnil
;
6981 coding
->dst_multibyte
= 0;
6984 encode_coding (coding
);
6986 if (EQ (dst_object
, Qt
))
6988 if (BUFFERP (coding
->dst_object
))
6989 coding
->dst_object
= Fbuffer_string ();
6993 = make_unibyte_string ((char *) coding
->destination
,
6995 xfree (coding
->destination
);
7001 /* This is the case of:
7002 (BUFFERP (src_object) && EQ (src_object, dst_object))
7003 As we have moved PT while replacing the original buffer
7004 contents, we must recover it now. */
7005 set_buffer_internal (XBUFFER (src_object
));
7006 if (saved_pt
< from
)
7007 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7008 else if (saved_pt
< from
+ chars
)
7009 TEMP_SET_PT_BOTH (from
, from_byte
);
7010 else if (! NILP (current_buffer
->enable_multibyte_characters
))
7011 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7012 saved_pt_byte
+ (coding
->produced
- bytes
));
7014 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7015 saved_pt_byte
+ (coding
->produced
- bytes
));
7018 unbind_to (count
, Qnil
);
7023 preferred_coding_system ()
7025 int id
= coding_categories
[coding_priorities
[0]].id
;
7027 return CODING_ID_NAME (id
);
7032 /*** 8. Emacs Lisp library functions ***/
7034 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7035 doc
: /* Return t if OBJECT is nil or a coding-system.
7036 See the documentation of `define-coding-system' for information
7037 about coding-system objects. */)
7041 return ((NILP (obj
) || CODING_SYSTEM_P (obj
)) ? Qt
: Qnil
);
7044 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7045 Sread_non_nil_coding_system
, 1, 1, 0,
7046 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7053 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7054 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
7056 while (SCHARS (val
) == 0);
7057 return (Fintern (val
, Qnil
));
7060 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
7061 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
7062 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM. */)
7063 (prompt
, default_coding_system
)
7064 Lisp_Object prompt
, default_coding_system
;
7067 if (SYMBOLP (default_coding_system
))
7068 XSETSTRING (default_coding_system
, XPNTR (SYMBOL_NAME (default_coding_system
)));
7069 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7070 Qt
, Qnil
, Qcoding_system_history
,
7071 default_coding_system
, Qnil
);
7072 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
7075 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
7077 doc
: /* Check validity of CODING-SYSTEM.
7078 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7079 It is valid if it is nil or a symbol defined as a coding system by the
7080 function `define-coding-system'. */)
7082 Lisp_Object coding_system
;
7084 CHECK_SYMBOL (coding_system
);
7085 if (!NILP (Fcoding_system_p (coding_system
)))
7086 return coding_system
;
7088 Fsignal (Qcoding_system_error
, Fcons (coding_system
, Qnil
));
7092 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7093 HIGHEST is nonzero, return the coding system of the highest
7094 priority among the detected coding systems. Otherwize return a
7095 list of detected coding systems sorted by their priorities. If
7096 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7097 multibyte form but contains only ASCII and eight-bit chars.
7098 Otherwise, the bytes are raw bytes.
7100 CODING-SYSTEM controls the detection as below:
7102 If it is nil, detect both text-format and eol-format. If the
7103 text-format part of CODING-SYSTEM is already specified
7104 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7105 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7106 detect only text-format. */
7109 detect_coding_system (src
, src_chars
, src_bytes
, highest
, multibytep
,
7111 const unsigned char *src
;
7112 int src_chars
, src_bytes
, highest
;
7114 Lisp_Object coding_system
;
7116 const unsigned char *src_end
= src
+ src_bytes
;
7117 Lisp_Object attrs
, eol_type
;
7119 struct coding_system coding
;
7121 struct coding_detection_info detect_info
;
7122 enum coding_category base_category
;
7124 if (NILP (coding_system
))
7125 coding_system
= Qundecided
;
7126 setup_coding_system (coding_system
, &coding
);
7127 attrs
= CODING_ID_ATTRS (coding
.id
);
7128 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
7129 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
7131 coding
.source
= src
;
7132 coding
.src_chars
= src_chars
;
7133 coding
.src_bytes
= src_bytes
;
7134 coding
.src_multibyte
= multibytep
;
7135 coding
.consumed
= 0;
7136 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7138 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
7140 /* At first, detect text-format if necessary. */
7141 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7142 if (base_category
== coding_category_undecided
)
7144 enum coding_category category
;
7145 struct coding_system
*this;
7148 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7149 for (i
= 0; src
< src_end
; i
++, src
++)
7155 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
7156 && inhibit_iso_escape_detection
)
7158 coding
.head_ascii
= src
- coding
.source
;
7159 if (detect_coding_iso_2022 (&coding
, &detect_info
))
7161 /* We have scanned the whole data. */
7162 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
7163 /* We didn't find an 8-bit code. */
7169 coding
.head_ascii
= src
- coding
.source
;
7172 || detect_info
.found
)
7175 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7176 for (i
= 0; i
< coding_category_raw_text
; i
++)
7178 category
= coding_priorities
[i
];
7179 if (detect_info
.found
& (1 << category
))
7183 for (i
= 0; i
< coding_category_raw_text
; i
++)
7185 category
= coding_priorities
[i
];
7186 this = coding_categories
+ category
;
7190 /* No coding system of this category is defined. */
7191 detect_info
.rejected
|= (1 << category
);
7193 else if (category
>= coding_category_raw_text
)
7195 else if (detect_info
.checked
& (1 << category
))
7198 && (detect_info
.found
& (1 << category
)))
7203 if ((*(this->detector
)) (&coding
, &detect_info
)
7205 && (detect_info
.found
& (1 << category
)))
7207 if (category
== coding_category_utf_16_auto
)
7209 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7210 category
= coding_category_utf_16_le
;
7212 category
= coding_category_utf_16_be
;
7220 if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
7222 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
7223 id
= coding_categories
[coding_category_raw_text
].id
;
7224 val
= Fcons (make_number (id
), Qnil
);
7226 else if (! detect_info
.rejected
&& ! detect_info
.found
)
7228 detect_info
.found
= CATEGORY_MASK_ANY
;
7229 id
= coding_categories
[coding_category_undecided
].id
;
7230 val
= Fcons (make_number (id
), Qnil
);
7234 if (detect_info
.found
)
7236 detect_info
.found
= 1 << category
;
7237 val
= Fcons (make_number (this->id
), Qnil
);
7240 for (i
= 0; i
< coding_category_raw_text
; i
++)
7241 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
7243 detect_info
.found
= 1 << coding_priorities
[i
];
7244 id
= coding_categories
[coding_priorities
[i
]].id
;
7245 val
= Fcons (make_number (id
), Qnil
);
7251 int mask
= detect_info
.rejected
| detect_info
.found
;
7255 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7257 category
= coding_priorities
[i
];
7258 if (! (mask
& (1 << category
)))
7260 found
|= 1 << category
;
7261 id
= coding_categories
[category
].id
;
7262 val
= Fcons (make_number (id
), val
);
7265 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7267 category
= coding_priorities
[i
];
7268 if (detect_info
.found
& (1 << category
))
7270 id
= coding_categories
[category
].id
;
7271 val
= Fcons (make_number (id
), val
);
7274 detect_info
.found
|= found
;
7277 else if (base_category
== coding_category_utf_16_auto
)
7279 if (detect_coding_utf_16 (&coding
, &detect_info
))
7281 struct coding_system
*this;
7283 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7284 this = coding_categories
+ coding_category_utf_16_le
;
7285 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
7286 this = coding_categories
+ coding_category_utf_16_be
;
7287 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
7288 this = coding_categories
+ coding_category_utf_16_be_nosig
;
7290 this = coding_categories
+ coding_category_utf_16_le_nosig
;
7291 val
= Fcons (make_number (this->id
), Qnil
);
7296 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
7297 val
= Fcons (make_number (coding
.id
), Qnil
);
7300 /* Then, detect eol-format if necessary. */
7302 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
;
7305 if (VECTORP (eol_type
))
7307 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
7308 normal_eol
= detect_eol (coding
.source
, src_bytes
,
7309 coding_category_raw_text
);
7310 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
7311 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
7312 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
7313 coding_category_utf_16_be
);
7314 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
7315 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
7316 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
7317 coding_category_utf_16_le
);
7321 if (EQ (eol_type
, Qunix
))
7322 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
7323 else if (EQ (eol_type
, Qdos
))
7324 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
7326 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
7329 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
7331 enum coding_category category
;
7334 id
= XINT (XCAR (tail
));
7335 attrs
= CODING_ID_ATTRS (id
);
7336 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7337 eol_type
= CODING_ID_EOL_TYPE (id
);
7338 if (VECTORP (eol_type
))
7340 if (category
== coding_category_utf_16_be
7341 || category
== coding_category_utf_16_be_nosig
)
7342 this_eol
= utf_16_be_eol
;
7343 else if (category
== coding_category_utf_16_le
7344 || category
== coding_category_utf_16_le_nosig
)
7345 this_eol
= utf_16_le_eol
;
7347 this_eol
= normal_eol
;
7349 if (this_eol
== EOL_SEEN_LF
)
7350 XSETCAR (tail
, AREF (eol_type
, 0));
7351 else if (this_eol
== EOL_SEEN_CRLF
)
7352 XSETCAR (tail
, AREF (eol_type
, 1));
7353 else if (this_eol
== EOL_SEEN_CR
)
7354 XSETCAR (tail
, AREF (eol_type
, 2));
7356 XSETCAR (tail
, CODING_ID_NAME (id
));
7359 XSETCAR (tail
, CODING_ID_NAME (id
));
7363 return (highest
? XCAR (val
) : val
);
7367 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
7369 doc
: /* Detect coding system of the text in the region between START and END.
7370 Return a list of possible coding systems ordered by priority.
7372 If only ASCII characters are found, it returns a list of single element
7373 `undecided' or its subsidiary coding system according to a detected
7376 If optional argument HIGHEST is non-nil, return the coding system of
7377 highest priority. */)
7378 (start
, end
, highest
)
7379 Lisp_Object start
, end
, highest
;
7382 int from_byte
, to_byte
;
7384 CHECK_NUMBER_COERCE_MARKER (start
);
7385 CHECK_NUMBER_COERCE_MARKER (end
);
7387 validate_region (&start
, &end
);
7388 from
= XINT (start
), to
= XINT (end
);
7389 from_byte
= CHAR_TO_BYTE (from
);
7390 to_byte
= CHAR_TO_BYTE (to
);
7392 if (from
< GPT
&& to
>= GPT
)
7393 move_gap_both (to
, to_byte
);
7395 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
7396 to
- from
, to_byte
- from_byte
,
7398 !NILP (current_buffer
7399 ->enable_multibyte_characters
),
7403 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
7405 doc
: /* Detect coding system of the text in STRING.
7406 Return a list of possible coding systems ordered by priority.
7408 If only ASCII characters are found, it returns a list of single element
7409 `undecided' or its subsidiary coding system according to a detected
7412 If optional argument HIGHEST is non-nil, return the coding system of
7413 highest priority. */)
7415 Lisp_Object string
, highest
;
7417 CHECK_STRING (string
);
7419 return detect_coding_system (SDATA (string
),
7420 SCHARS (string
), SBYTES (string
),
7421 !NILP (highest
), STRING_MULTIBYTE (string
),
7427 char_encodable_p (c
, attrs
)
7432 struct charset
*charset
;
7433 Lisp_Object translation_table
;
7435 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
7436 if (! NILP (translation_table
))
7437 c
= translate_char (translation_table
, c
);
7438 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
7439 CONSP (tail
); tail
= XCDR (tail
))
7441 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
7442 if (CHAR_CHARSET_P (c
, charset
))
7445 return (! NILP (tail
));
7449 /* Return a list of coding systems that safely encode the text between
7450 START and END. If EXCLUDE is non-nil, it is a list of coding
7451 systems not to check. The returned list doesn't contain any such
7452 coding systems. In any case, if the text contains only ASCII or is
7453 unibyte, return t. */
7455 DEFUN ("find-coding-systems-region-internal",
7456 Ffind_coding_systems_region_internal
,
7457 Sfind_coding_systems_region_internal
, 2, 3, 0,
7458 doc
: /* Internal use only. */)
7459 (start
, end
, exclude
)
7460 Lisp_Object start
, end
, exclude
;
7462 Lisp_Object coding_attrs_list
, safe_codings
;
7463 EMACS_INT start_byte
, end_byte
;
7464 const unsigned char *p
, *pbeg
, *pend
;
7466 Lisp_Object tail
, elt
;
7468 if (STRINGP (start
))
7470 if (!STRING_MULTIBYTE (start
)
7471 || SCHARS (start
) == SBYTES (start
))
7474 end_byte
= SBYTES (start
);
7478 CHECK_NUMBER_COERCE_MARKER (start
);
7479 CHECK_NUMBER_COERCE_MARKER (end
);
7480 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7481 args_out_of_range (start
, end
);
7482 if (NILP (current_buffer
->enable_multibyte_characters
))
7484 start_byte
= CHAR_TO_BYTE (XINT (start
));
7485 end_byte
= CHAR_TO_BYTE (XINT (end
));
7486 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7489 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7491 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7492 move_gap_both (XINT (start
), start_byte
);
7494 move_gap_both (XINT (end
), end_byte
);
7498 coding_attrs_list
= Qnil
;
7499 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7501 || NILP (Fmemq (XCAR (tail
), exclude
)))
7505 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
7506 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
7507 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
7509 ASET (attrs
, coding_attr_trans_tbl
,
7510 get_translation_table (attrs
, 1, NULL
));
7511 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
7515 if (STRINGP (start
))
7516 p
= pbeg
= SDATA (start
);
7518 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7519 pend
= p
+ (end_byte
- start_byte
);
7521 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
7522 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7526 if (ASCII_BYTE_P (*p
))
7530 c
= STRING_CHAR_ADVANCE (p
);
7532 charset_map_loaded
= 0;
7533 for (tail
= coding_attrs_list
; CONSP (tail
);)
7538 else if (char_encodable_p (c
, elt
))
7540 else if (CONSP (XCDR (tail
)))
7542 XSETCAR (tail
, XCAR (XCDR (tail
)));
7543 XSETCDR (tail
, XCDR (XCDR (tail
)));
7547 XSETCAR (tail
, Qnil
);
7551 if (charset_map_loaded
)
7553 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7555 if (STRINGP (start
))
7556 pbeg
= SDATA (start
);
7558 pbeg
= BYTE_POS_ADDR (start_byte
);
7559 p
= pbeg
+ p_offset
;
7560 pend
= pbeg
+ pend_offset
;
7565 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
7566 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
7567 if (! NILP (XCAR (tail
)))
7568 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
7570 return safe_codings
;
7574 DEFUN ("unencodable-char-position", Funencodable_char_position
,
7575 Sunencodable_char_position
, 3, 5, 0,
7577 Return position of first un-encodable character in a region.
7578 START and END specfiy the region and CODING-SYSTEM specifies the
7579 encoding to check. Return nil if CODING-SYSTEM does encode the region.
7581 If optional 4th argument COUNT is non-nil, it specifies at most how
7582 many un-encodable characters to search. In this case, the value is a
7585 If optional 5th argument STRING is non-nil, it is a string to search
7586 for un-encodable characters. In that case, START and END are indexes
7588 (start
, end
, coding_system
, count
, string
)
7589 Lisp_Object start
, end
, coding_system
, count
, string
;
7592 struct coding_system coding
;
7593 Lisp_Object attrs
, charset_list
, translation_table
;
7594 Lisp_Object positions
;
7596 const unsigned char *p
, *stop
, *pend
;
7597 int ascii_compatible
;
7599 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
7600 attrs
= CODING_ID_ATTRS (coding
.id
);
7601 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
7603 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
7604 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
7605 translation_table
= get_translation_table (attrs
, 1, NULL
);
7609 validate_region (&start
, &end
);
7610 from
= XINT (start
);
7612 if (NILP (current_buffer
->enable_multibyte_characters
)
7613 || (ascii_compatible
7614 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
7616 p
= CHAR_POS_ADDR (from
);
7617 pend
= CHAR_POS_ADDR (to
);
7618 if (from
< GPT
&& to
>= GPT
)
7625 CHECK_STRING (string
);
7626 CHECK_NATNUM (start
);
7628 from
= XINT (start
);
7631 || to
> SCHARS (string
))
7632 args_out_of_range_3 (string
, start
, end
);
7633 if (! STRING_MULTIBYTE (string
))
7635 p
= SDATA (string
) + string_char_to_byte (string
, from
);
7636 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
7637 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
7645 CHECK_NATNUM (count
);
7654 if (ascii_compatible
)
7655 while (p
< stop
&& ASCII_BYTE_P (*p
))
7665 c
= STRING_CHAR_ADVANCE (p
);
7666 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
7667 && ! char_charset (translate_char (translation_table
, c
),
7668 charset_list
, NULL
))
7670 positions
= Fcons (make_number (from
), positions
);
7679 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
7683 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
7684 Scheck_coding_systems_region
, 3, 3, 0,
7685 doc
: /* Check if the region is encodable by coding systems.
7687 START and END are buffer positions specifying the region.
7688 CODING-SYSTEM-LIST is a list of coding systems to check.
7690 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
7691 CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
7692 whole region, POS0, POS1, ... are buffer positions where non-encodable
7693 characters are found.
7695 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
7698 START may be a string. In that case, check if the string is
7699 encodable, and the value contains indices to the string instead of
7700 buffer positions. END is ignored. */)
7701 (start
, end
, coding_system_list
)
7702 Lisp_Object start
, end
, coding_system_list
;
7705 EMACS_INT start_byte
, end_byte
;
7707 const unsigned char *p
, *pbeg
, *pend
;
7709 Lisp_Object tail
, elt
, attrs
;
7711 if (STRINGP (start
))
7713 if (!STRING_MULTIBYTE (start
)
7714 && SCHARS (start
) != SBYTES (start
))
7717 end_byte
= SBYTES (start
);
7722 CHECK_NUMBER_COERCE_MARKER (start
);
7723 CHECK_NUMBER_COERCE_MARKER (end
);
7724 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7725 args_out_of_range (start
, end
);
7726 if (NILP (current_buffer
->enable_multibyte_characters
))
7728 start_byte
= CHAR_TO_BYTE (XINT (start
));
7729 end_byte
= CHAR_TO_BYTE (XINT (end
));
7730 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7733 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7735 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7736 move_gap_both (XINT (start
), start_byte
);
7738 move_gap_both (XINT (end
), end_byte
);
7744 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7747 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
7748 ASET (attrs
, coding_attr_trans_tbl
,
7749 get_translation_table (attrs
, 1, NULL
));
7750 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
7753 if (STRINGP (start
))
7754 p
= pbeg
= SDATA (start
);
7756 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7757 pend
= p
+ (end_byte
- start_byte
);
7759 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
7760 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7764 if (ASCII_BYTE_P (*p
))
7768 c
= STRING_CHAR_ADVANCE (p
);
7770 charset_map_loaded
= 0;
7771 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
7773 elt
= XCDR (XCAR (tail
));
7774 if (! char_encodable_p (c
, XCAR (elt
)))
7775 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
7777 if (charset_map_loaded
)
7779 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7781 if (STRINGP (start
))
7782 pbeg
= SDATA (start
);
7784 pbeg
= BYTE_POS_ADDR (start_byte
);
7785 p
= pbeg
+ p_offset
;
7786 pend
= pbeg
+ pend_offset
;
7794 for (; CONSP (tail
); tail
= XCDR (tail
))
7797 if (CONSP (XCDR (XCDR (elt
))))
7798 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
7807 code_convert_region (start
, end
, coding_system
, dst_object
, encodep
, norecord
)
7808 Lisp_Object start
, end
, coding_system
, dst_object
;
7809 int encodep
, norecord
;
7811 struct coding_system coding
;
7812 EMACS_INT from
, from_byte
, to
, to_byte
;
7813 Lisp_Object src_object
;
7815 CHECK_NUMBER_COERCE_MARKER (start
);
7816 CHECK_NUMBER_COERCE_MARKER (end
);
7817 if (NILP (coding_system
))
7818 coding_system
= Qno_conversion
;
7820 CHECK_CODING_SYSTEM (coding_system
);
7821 src_object
= Fcurrent_buffer ();
7822 if (NILP (dst_object
))
7823 dst_object
= src_object
;
7824 else if (! EQ (dst_object
, Qt
))
7825 CHECK_BUFFER (dst_object
);
7827 validate_region (&start
, &end
);
7828 from
= XFASTINT (start
);
7829 from_byte
= CHAR_TO_BYTE (from
);
7830 to
= XFASTINT (end
);
7831 to_byte
= CHAR_TO_BYTE (to
);
7833 setup_coding_system (coding_system
, &coding
);
7834 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7837 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7840 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7843 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7845 return (BUFFERP (dst_object
)
7846 ? make_number (coding
.produced_char
)
7847 : coding
.dst_object
);
7851 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
7852 3, 4, "r\nzCoding system: ",
7853 doc
: /* Decode the current region from the specified coding system.
7854 When called from a program, takes four arguments:
7855 START, END, CODING-SYSTEM, and DESTINATION.
7856 START and END are buffer positions.
7858 Optional 4th arguments DESTINATION specifies where the decoded text goes.
7859 If nil, the region between START and END is replace by the decoded text.
7860 If buffer, the decoded text is inserted in the buffer.
7861 If t, the decoded text is returned.
7863 This function sets `last-coding-system-used' to the precise coding system
7864 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7865 not fully specified.)
7866 It returns the length of the decoded text. */)
7867 (start
, end
, coding_system
, destination
)
7868 Lisp_Object start
, end
, coding_system
, destination
;
7870 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
7873 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
7874 3, 4, "r\nzCoding system: ",
7875 doc
: /* Encode the current region by specified coding system.
7876 When called from a program, takes three arguments:
7877 START, END, and CODING-SYSTEM. START and END are buffer positions.
7879 Optional 4th arguments DESTINATION specifies where the encoded text goes.
7880 If nil, the region between START and END is replace by the encoded text.
7881 If buffer, the encoded text is inserted in the buffer.
7882 If t, the encoded text is returned.
7884 This function sets `last-coding-system-used' to the precise coding system
7885 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7886 not fully specified.)
7887 It returns the length of the encoded text. */)
7888 (start
, end
, coding_system
, destination
)
7889 Lisp_Object start
, end
, coding_system
, destination
;
7891 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
7895 code_convert_string (string
, coding_system
, dst_object
,
7896 encodep
, nocopy
, norecord
)
7897 Lisp_Object string
, coding_system
, dst_object
;
7898 int encodep
, nocopy
, norecord
;
7900 struct coding_system coding
;
7901 EMACS_INT chars
, bytes
;
7903 CHECK_STRING (string
);
7904 if (NILP (coding_system
))
7907 Vlast_coding_system_used
= Qno_conversion
;
7908 if (NILP (dst_object
))
7909 return (nocopy
? Fcopy_sequence (string
) : string
);
7912 if (NILP (coding_system
))
7913 coding_system
= Qno_conversion
;
7915 CHECK_CODING_SYSTEM (coding_system
);
7916 if (NILP (dst_object
))
7918 else if (! EQ (dst_object
, Qt
))
7919 CHECK_BUFFER (dst_object
);
7921 setup_coding_system (coding_system
, &coding
);
7922 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7923 chars
= SCHARS (string
);
7924 bytes
= SBYTES (string
);
7926 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7928 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7930 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7932 return (BUFFERP (dst_object
)
7933 ? make_number (coding
.produced_char
)
7934 : coding
.dst_object
);
7938 /* Encode or decode STRING according to CODING_SYSTEM.
7939 Do not set Vlast_coding_system_used.
7941 This function is called only from macros DECODE_FILE and
7942 ENCODE_FILE, thus we ignore character composition. */
7945 code_convert_string_norecord (string
, coding_system
, encodep
)
7946 Lisp_Object string
, coding_system
;
7949 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
7953 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
7955 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
7957 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
7958 if the decoding operation is trivial.
7960 Optional fourth arg BUFFER non-nil meant that the decoded text is
7961 inserted in BUFFER instead of returned as a string. In this case,
7962 the return value is BUFFER.
7964 This function sets `last-coding-system-used' to the precise coding system
7965 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7966 not fully specified. */)
7967 (string
, coding_system
, nocopy
, buffer
)
7968 Lisp_Object string
, coding_system
, nocopy
, buffer
;
7970 return code_convert_string (string
, coding_system
, buffer
,
7971 0, ! NILP (nocopy
), 0);
7974 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
7976 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
7978 Optional third arg NOCOPY non-nil means it is OK to return STRING
7979 itself if the encoding operation is trivial.
7981 Optional fourth arg BUFFER non-nil meant that the encoded text is
7982 inserted in BUFFER instead of returned as a string. In this case,
7983 the return value is BUFFER.
7985 This function sets `last-coding-system-used' to the precise coding system
7986 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7987 not fully specified.) */)
7988 (string
, coding_system
, nocopy
, buffer
)
7989 Lisp_Object string
, coding_system
, nocopy
, buffer
;
7991 return code_convert_string (string
, coding_system
, buffer
,
7992 1, ! NILP (nocopy
), 1);
7996 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
7997 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
7998 Return the corresponding character. */)
8002 Lisp_Object spec
, attrs
, val
;
8003 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
8006 CHECK_NATNUM (code
);
8007 c
= XFASTINT (code
);
8008 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8009 attrs
= AREF (spec
, 0);
8011 if (ASCII_BYTE_P (c
)
8012 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8015 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8016 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8017 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8018 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8021 charset
= charset_roman
;
8022 else if (c
>= 0xA0 && c
< 0xDF)
8024 charset
= charset_kana
;
8029 int s1
= c
>> 8, s2
= c
& 0xFF;
8031 if (s1
< 0x81 || (s1
> 0x9F && s1
< 0xE0) || s1
> 0xEF
8032 || s2
< 0x40 || s2
== 0x7F || s2
> 0xFC)
8033 error ("Invalid code: %d", code
);
8035 charset
= charset_kanji
;
8037 c
= DECODE_CHAR (charset
, c
);
8039 error ("Invalid code: %d", code
);
8040 return make_number (c
);
8044 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
8045 doc
: /* Encode a Japanese character CHAR to shift_jis encoding.
8046 Return the corresponding code in SJIS. */)
8050 Lisp_Object spec
, attrs
, charset_list
;
8052 struct charset
*charset
;
8055 CHECK_CHARACTER (ch
);
8057 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8058 attrs
= AREF (spec
, 0);
8060 if (ASCII_CHAR_P (c
)
8061 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8064 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8065 charset
= char_charset (c
, charset_list
, &code
);
8066 if (code
== CHARSET_INVALID_CODE (charset
))
8067 error ("Can't encode by shift_jis encoding: %d", c
);
8070 return make_number (code
);
8073 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
8074 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
8075 Return the corresponding character. */)
8079 Lisp_Object spec
, attrs
, val
;
8080 struct charset
*charset_roman
, *charset_big5
, *charset
;
8083 CHECK_NATNUM (code
);
8084 c
= XFASTINT (code
);
8085 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8086 attrs
= AREF (spec
, 0);
8088 if (ASCII_BYTE_P (c
)
8089 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8092 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8093 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8094 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8097 charset
= charset_roman
;
8100 int b1
= c
>> 8, b2
= c
& 0x7F;
8101 if (b1
< 0xA1 || b1
> 0xFE
8102 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
8103 error ("Invalid code: %d", code
);
8104 charset
= charset_big5
;
8106 c
= DECODE_CHAR (charset
, (unsigned )c
);
8108 error ("Invalid code: %d", code
);
8109 return make_number (c
);
8112 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
8113 doc
: /* Encode the Big5 character CHAR to BIG5 coding system.
8114 Return the corresponding character code in Big5. */)
8118 Lisp_Object spec
, attrs
, charset_list
;
8119 struct charset
*charset
;
8123 CHECK_CHARACTER (ch
);
8125 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8126 attrs
= AREF (spec
, 0);
8127 if (ASCII_CHAR_P (c
)
8128 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8131 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8132 charset
= char_charset (c
, charset_list
, &code
);
8133 if (code
== CHARSET_INVALID_CODE (charset
))
8134 error ("Can't encode by Big5 encoding: %d", c
);
8136 return make_number (code
);
8140 DEFUN ("set-terminal-coding-system-internal",
8141 Fset_terminal_coding_system_internal
,
8142 Sset_terminal_coding_system_internal
, 1, 1, 0,
8143 doc
: /* Internal use only. */)
8145 Lisp_Object coding_system
;
8147 CHECK_SYMBOL (coding_system
);
8148 setup_coding_system (Fcheck_coding_system (coding_system
),
8151 /* We had better not send unsafe characters to terminal. */
8152 terminal_coding
.mode
|= CODING_MODE_SAFE_ENCODING
;
8153 /* Characer composition should be disabled. */
8154 terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8155 terminal_coding
.src_multibyte
= 1;
8156 terminal_coding
.dst_multibyte
= 0;
8160 DEFUN ("set-safe-terminal-coding-system-internal",
8161 Fset_safe_terminal_coding_system_internal
,
8162 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
8163 doc
: /* Internal use only. */)
8165 Lisp_Object coding_system
;
8167 CHECK_SYMBOL (coding_system
);
8168 setup_coding_system (Fcheck_coding_system (coding_system
),
8169 &safe_terminal_coding
);
8170 /* Characer composition should be disabled. */
8171 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8172 safe_terminal_coding
.src_multibyte
= 1;
8173 safe_terminal_coding
.dst_multibyte
= 0;
8177 DEFUN ("terminal-coding-system",
8178 Fterminal_coding_system
, Sterminal_coding_system
, 0, 0, 0,
8179 doc
: /* Return coding system specified for terminal output. */)
8182 Lisp_Object coding_system
;
8184 coding_system
= CODING_ID_NAME (terminal_coding
.id
);
8185 /* For backward compatibility, return nil if it is `undecided'. */
8186 return (coding_system
!= Qundecided
? coding_system
: Qnil
);
8189 DEFUN ("set-keyboard-coding-system-internal",
8190 Fset_keyboard_coding_system_internal
,
8191 Sset_keyboard_coding_system_internal
, 1, 1, 0,
8192 doc
: /* Internal use only. */)
8194 Lisp_Object coding_system
;
8196 CHECK_SYMBOL (coding_system
);
8197 setup_coding_system (Fcheck_coding_system (coding_system
),
8199 /* Characer composition should be disabled. */
8200 keyboard_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8204 DEFUN ("keyboard-coding-system",
8205 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 0, 0,
8206 doc
: /* Return coding system specified for decoding keyboard input. */)
8209 return CODING_ID_NAME (keyboard_coding
.id
);
8213 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
8214 Sfind_operation_coding_system
, 1, MANY
, 0,
8215 doc
: /* Choose a coding system for an operation based on the target name.
8216 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8217 DECODING-SYSTEM is the coding system to use for decoding
8218 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8219 for encoding (in case OPERATION does encoding).
8221 The first argument OPERATION specifies an I/O primitive:
8222 For file I/O, `insert-file-contents' or `write-region'.
8223 For process I/O, `call-process', `call-process-region', or `start-process'.
8224 For network I/O, `open-network-stream'.
8226 The remaining arguments should be the same arguments that were passed
8227 to the primitive. Depending on which primitive, one of those arguments
8228 is selected as the TARGET. For example, if OPERATION does file I/O,
8229 whichever argument specifies the file name is TARGET.
8231 TARGET has a meaning which depends on OPERATION:
8232 For file I/O, TARGET is a file name.
8233 For process I/O, TARGET is a process name.
8234 For network I/O, TARGET is a service name or a port number
8236 This function looks up what specified for TARGET in,
8237 `file-coding-system-alist', `process-coding-system-alist',
8238 or `network-coding-system-alist' depending on OPERATION.
8239 They may specify a coding system, a cons of coding systems,
8240 or a function symbol to call.
8241 In the last case, we call the function with one argument,
8242 which is a list of all the arguments given to this function.
8244 usage: (find-operation-coding-system OPERATION ARGUMENTS ...) */)
8249 Lisp_Object operation
, target_idx
, target
, val
;
8250 register Lisp_Object chain
;
8253 error ("Too few arguments");
8254 operation
= args
[0];
8255 if (!SYMBOLP (operation
)
8256 || !INTEGERP (target_idx
= Fget (operation
, Qtarget_idx
)))
8257 error ("Invalid first arguement");
8258 if (nargs
< 1 + XINT (target_idx
))
8259 error ("Too few arguments for operation: %s",
8260 SDATA (SYMBOL_NAME (operation
)));
8261 target
= args
[XINT (target_idx
) + 1];
8262 if (!(STRINGP (target
)
8263 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
8264 error ("Invalid %dth argument", XINT (target_idx
) + 1);
8266 chain
= ((EQ (operation
, Qinsert_file_contents
)
8267 || EQ (operation
, Qwrite_region
))
8268 ? Vfile_coding_system_alist
8269 : (EQ (operation
, Qopen_network_stream
)
8270 ? Vnetwork_coding_system_alist
8271 : Vprocess_coding_system_alist
));
8275 for (; CONSP (chain
); chain
= XCDR (chain
))
8281 && ((STRINGP (target
)
8282 && STRINGP (XCAR (elt
))
8283 && fast_string_match (XCAR (elt
), target
) >= 0)
8284 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
8287 /* Here, if VAL is both a valid coding system and a valid
8288 function symbol, we return VAL as a coding system. */
8291 if (! SYMBOLP (val
))
8293 if (! NILP (Fcoding_system_p (val
)))
8294 return Fcons (val
, val
);
8295 if (! NILP (Ffboundp (val
)))
8297 val
= call1 (val
, Flist (nargs
, args
));
8300 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
8301 return Fcons (val
, val
);
8309 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
8310 Sset_coding_system_priority
, 0, MANY
, 0,
8311 doc
: /* Assign higher priority to the coding systems given as arguments.
8312 If multiple coding systems belongs to the same category,
8313 all but the first one are ignored.
8315 usage: (set-coding-system-priority ...) */)
8321 int changed
[coding_category_max
];
8322 enum coding_category priorities
[coding_category_max
];
8324 bzero (changed
, sizeof changed
);
8326 for (i
= j
= 0; i
< nargs
; i
++)
8328 enum coding_category category
;
8329 Lisp_Object spec
, attrs
;
8331 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
8332 attrs
= AREF (spec
, 0);
8333 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8334 if (changed
[category
])
8335 /* Ignore this coding system because a coding system of the
8336 same category already had a higher priority. */
8338 changed
[category
] = 1;
8339 priorities
[j
++] = category
;
8340 if (coding_categories
[category
].id
>= 0
8341 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
8342 setup_coding_system (args
[i
], &coding_categories
[category
]);
8343 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
8346 /* Now we have decided top J priorities. Reflect the order of the
8347 original priorities to the remaining priorities. */
8349 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
8351 while (j
< coding_category_max
8352 && changed
[coding_priorities
[j
]])
8354 if (j
== coding_category_max
)
8356 priorities
[i
] = coding_priorities
[j
];
8359 bcopy (priorities
, coding_priorities
, sizeof priorities
);
8361 /* Update `coding-category-list'. */
8362 Vcoding_category_list
= Qnil
;
8363 for (i
= coding_category_max
- 1; i
>= 0; i
--)
8364 Vcoding_category_list
8365 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
8366 Vcoding_category_list
);
8371 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
8372 Scoding_system_priority_list
, 0, 1, 0,
8373 doc
: /* Return a list of coding systems ordered by their priorities.
8374 HIGHESTP non-nil means just return the highest priority one. */)
8376 Lisp_Object highestp
;
8381 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
8383 enum coding_category category
= coding_priorities
[i
];
8384 int id
= coding_categories
[category
].id
;
8389 attrs
= CODING_ID_ATTRS (id
);
8390 if (! NILP (highestp
))
8391 return CODING_ATTR_BASE_NAME (attrs
);
8392 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
8394 return Fnreverse (val
);
8397 static char *suffixes
[] = { "-unix", "-dos", "-mac" };
8400 make_subsidiaries (base
)
8403 Lisp_Object subsidiaries
;
8404 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
8405 char *buf
= (char *) alloca (base_name_len
+ 6);
8408 bcopy (SDATA (SYMBOL_NAME (base
)), buf
, base_name_len
);
8409 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
8410 for (i
= 0; i
< 3; i
++)
8412 bcopy (suffixes
[i
], buf
+ base_name_len
, strlen (suffixes
[i
]) + 1);
8413 ASET (subsidiaries
, i
, intern (buf
));
8415 return subsidiaries
;
8419 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
8420 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
8421 doc
: /* For internal use only.
8422 usage: (define-coding-system-internal ...) */)
8428 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
8429 Lisp_Object attrs
; /* Vector of attributes. */
8430 Lisp_Object eol_type
;
8431 Lisp_Object aliases
;
8432 Lisp_Object coding_type
, charset_list
, safe_charsets
;
8433 enum coding_category category
;
8434 Lisp_Object tail
, val
;
8435 int max_charset_id
= 0;
8438 if (nargs
< coding_arg_max
)
8441 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
8443 name
= args
[coding_arg_name
];
8444 CHECK_SYMBOL (name
);
8445 CODING_ATTR_BASE_NAME (attrs
) = name
;
8447 val
= args
[coding_arg_mnemonic
];
8448 if (! STRINGP (val
))
8449 CHECK_CHARACTER (val
);
8450 CODING_ATTR_MNEMONIC (attrs
) = val
;
8452 coding_type
= args
[coding_arg_coding_type
];
8453 CHECK_SYMBOL (coding_type
);
8454 CODING_ATTR_TYPE (attrs
) = coding_type
;
8456 charset_list
= args
[coding_arg_charset_list
];
8457 if (SYMBOLP (charset_list
))
8459 if (EQ (charset_list
, Qiso_2022
))
8461 if (! EQ (coding_type
, Qiso_2022
))
8462 error ("Invalid charset-list");
8463 charset_list
= Viso_2022_charset_list
;
8465 else if (EQ (charset_list
, Qemacs_mule
))
8467 if (! EQ (coding_type
, Qemacs_mule
))
8468 error ("Invalid charset-list");
8469 charset_list
= Vemacs_mule_charset_list
;
8471 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8472 if (max_charset_id
< XFASTINT (XCAR (tail
)))
8473 max_charset_id
= XFASTINT (XCAR (tail
));
8477 charset_list
= Fcopy_sequence (charset_list
);
8478 for (tail
= charset_list
; !NILP (tail
); tail
= Fcdr (tail
))
8480 struct charset
*charset
;
8483 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8484 if (EQ (coding_type
, Qiso_2022
)
8485 ? CHARSET_ISO_FINAL (charset
) < 0
8486 : EQ (coding_type
, Qemacs_mule
)
8487 ? CHARSET_EMACS_MULE_ID (charset
) < 0
8489 error ("Can't handle charset `%s'",
8490 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8492 XSETCAR (tail
, make_number (charset
->id
));
8493 if (max_charset_id
< charset
->id
)
8494 max_charset_id
= charset
->id
;
8497 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
8499 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
8501 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8502 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
8503 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
8505 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
8507 val
= args
[coding_arg_decode_translation_table
];
8508 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8510 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8512 val
= args
[coding_arg_encode_translation_table
];
8513 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8515 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8517 val
= args
[coding_arg_post_read_conversion
];
8519 CODING_ATTR_POST_READ (attrs
) = val
;
8521 val
= args
[coding_arg_pre_write_conversion
];
8523 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8525 val
= args
[coding_arg_default_char
];
8527 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
8530 CHECK_CHARACTER (val
);
8531 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8534 val
= args
[coding_arg_for_unibyte
];
8535 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
8537 val
= args
[coding_arg_plist
];
8539 CODING_ATTR_PLIST (attrs
) = val
;
8541 if (EQ (coding_type
, Qcharset
))
8543 /* Generate a lisp vector of 256 elements. Each element is nil,
8544 integer, or a list of charset IDs.
8546 If Nth element is nil, the byte code N is invalid in this
8549 If Nth element is a number NUM, N is the first byte of a
8550 charset whose ID is NUM.
8552 If Nth element is a list of charset IDs, N is the first byte
8553 of one of them. The list is sorted by dimensions of the
8554 charsets. A charset of smaller dimension comes firtst. */
8555 val
= Fmake_vector (make_number (256), Qnil
);
8557 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8559 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
8560 int dim
= CHARSET_DIMENSION (charset
);
8561 int idx
= (dim
- 1) * 4;
8563 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8564 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8566 for (i
= charset
->code_space
[idx
];
8567 i
<= charset
->code_space
[idx
+ 1]; i
++)
8569 Lisp_Object tmp
, tmp2
;
8572 tmp
= AREF (val
, i
);
8575 else if (NUMBERP (tmp
))
8577 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
8579 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
8581 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
8585 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
8587 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
8592 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
8595 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
8596 XSETCAR (tmp2
, XCAR (tail
));
8602 ASET (attrs
, coding_attr_charset_valids
, val
);
8603 category
= coding_category_charset
;
8605 else if (EQ (coding_type
, Qccl
))
8609 if (nargs
< coding_arg_ccl_max
)
8612 val
= args
[coding_arg_ccl_decoder
];
8613 CHECK_CCL_PROGRAM (val
);
8615 val
= Fcopy_sequence (val
);
8616 ASET (attrs
, coding_attr_ccl_decoder
, val
);
8618 val
= args
[coding_arg_ccl_encoder
];
8619 CHECK_CCL_PROGRAM (val
);
8621 val
= Fcopy_sequence (val
);
8622 ASET (attrs
, coding_attr_ccl_encoder
, val
);
8624 val
= args
[coding_arg_ccl_valids
];
8625 valids
= Fmake_string (make_number (256), make_number (0));
8626 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
8633 from
= to
= XINT (val
);
8634 if (from
< 0 || from
> 255)
8635 args_out_of_range_3 (val
, make_number (0), make_number (255));
8640 CHECK_NATNUM_CAR (val
);
8641 CHECK_NATNUM_CDR (val
);
8642 from
= XINT (XCAR (val
));
8644 args_out_of_range_3 (XCAR (val
),
8645 make_number (0), make_number (255));
8646 to
= XINT (XCDR (val
));
8647 if (to
< from
|| to
> 255)
8648 args_out_of_range_3 (XCDR (val
),
8649 XCAR (val
), make_number (255));
8651 for (i
= from
; i
<= to
; i
++)
8652 SSET (valids
, i
, 1);
8654 ASET (attrs
, coding_attr_ccl_valids
, valids
);
8656 category
= coding_category_ccl
;
8658 else if (EQ (coding_type
, Qutf_16
))
8660 Lisp_Object bom
, endian
;
8662 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8664 if (nargs
< coding_arg_utf16_max
)
8667 bom
= args
[coding_arg_utf16_bom
];
8668 if (! NILP (bom
) && ! EQ (bom
, Qt
))
8672 CHECK_CODING_SYSTEM (val
);
8674 CHECK_CODING_SYSTEM (val
);
8676 ASET (attrs
, coding_attr_utf_16_bom
, bom
);
8678 endian
= args
[coding_arg_utf16_endian
];
8679 CHECK_SYMBOL (endian
);
8682 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
8683 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
8684 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
8686 category
= (CONSP (bom
)
8687 ? coding_category_utf_16_auto
8689 ? (EQ (endian
, Qbig
)
8690 ? coding_category_utf_16_be_nosig
8691 : coding_category_utf_16_le_nosig
)
8692 : (EQ (endian
, Qbig
)
8693 ? coding_category_utf_16_be
8694 : coding_category_utf_16_le
));
8696 else if (EQ (coding_type
, Qiso_2022
))
8698 Lisp_Object initial
, reg_usage
, request
, flags
;
8701 if (nargs
< coding_arg_iso2022_max
)
8704 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
8705 CHECK_VECTOR (initial
);
8706 for (i
= 0; i
< 4; i
++)
8708 val
= Faref (initial
, make_number (i
));
8711 struct charset
*charset
;
8713 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8714 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
8715 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
8716 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8719 ASET (initial
, i
, make_number (-1));
8722 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
8723 CHECK_CONS (reg_usage
);
8724 CHECK_NUMBER_CAR (reg_usage
);
8725 CHECK_NUMBER_CDR (reg_usage
);
8727 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
8728 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
8736 CHECK_CHARSET_GET_ID (tmp
, id
);
8737 CHECK_NATNUM_CDR (val
);
8738 if (XINT (XCDR (val
)) >= 4)
8739 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
8740 XSETCAR (val
, make_number (id
));
8743 flags
= args
[coding_arg_iso2022_flags
];
8744 CHECK_NATNUM (flags
);
8746 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
8747 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
8749 ASET (attrs
, coding_attr_iso_initial
, initial
);
8750 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
8751 ASET (attrs
, coding_attr_iso_request
, request
);
8752 ASET (attrs
, coding_attr_iso_flags
, flags
);
8753 setup_iso_safe_charsets (attrs
);
8755 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
8756 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
8757 | CODING_ISO_FLAG_SINGLE_SHIFT
))
8758 ? coding_category_iso_7_else
8759 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8760 ? coding_category_iso_7
8761 : coding_category_iso_7_tight
);
8764 int id
= XINT (AREF (initial
, 1));
8766 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
8767 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8769 ? coding_category_iso_8_else
8770 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
8771 ? coding_category_iso_8_1
8772 : coding_category_iso_8_2
);
8774 if (category
!= coding_category_iso_8_1
8775 && category
!= coding_category_iso_8_2
)
8776 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8778 else if (EQ (coding_type
, Qemacs_mule
))
8780 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
8781 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
8782 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8783 category
= coding_category_emacs_mule
;
8785 else if (EQ (coding_type
, Qshift_jis
))
8788 struct charset
*charset
;
8790 if (XINT (Flength (charset_list
)) != 3
8791 && XINT (Flength (charset_list
)) != 4)
8792 error ("There should be three or four charsets");
8794 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8795 if (CHARSET_DIMENSION (charset
) != 1)
8796 error ("Dimension of charset %s is not one",
8797 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8798 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8799 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8801 charset_list
= XCDR (charset_list
);
8802 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8803 if (CHARSET_DIMENSION (charset
) != 1)
8804 error ("Dimension of charset %s is not one",
8805 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8807 charset_list
= XCDR (charset_list
);
8808 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8809 if (CHARSET_DIMENSION (charset
) != 2)
8810 error ("Dimension of charset %s is not two",
8811 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8813 charset_list
= XCDR (charset_list
);
8814 if (! NILP (charset_list
))
8816 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8817 if (CHARSET_DIMENSION (charset
) != 2)
8818 error ("Dimension of charset %s is not two",
8819 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8822 category
= coding_category_sjis
;
8823 Vsjis_coding_system
= name
;
8825 else if (EQ (coding_type
, Qbig5
))
8827 struct charset
*charset
;
8829 if (XINT (Flength (charset_list
)) != 2)
8830 error ("There should be just two charsets");
8832 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8833 if (CHARSET_DIMENSION (charset
) != 1)
8834 error ("Dimension of charset %s is not one",
8835 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8836 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8837 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8839 charset_list
= XCDR (charset_list
);
8840 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8841 if (CHARSET_DIMENSION (charset
) != 2)
8842 error ("Dimension of charset %s is not two",
8843 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8845 category
= coding_category_big5
;
8846 Vbig5_coding_system
= name
;
8848 else if (EQ (coding_type
, Qraw_text
))
8850 category
= coding_category_raw_text
;
8851 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8853 else if (EQ (coding_type
, Qutf_8
))
8855 category
= coding_category_utf_8
;
8856 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8858 else if (EQ (coding_type
, Qundecided
))
8859 category
= coding_category_undecided
;
8861 error ("Invalid coding system type: %s",
8862 SDATA (SYMBOL_NAME (coding_type
)));
8864 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
8865 CODING_ATTR_PLIST (attrs
)
8866 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
8867 CODING_ATTR_PLIST (attrs
)));
8869 eol_type
= args
[coding_arg_eol_type
];
8870 if (! NILP (eol_type
)
8871 && ! EQ (eol_type
, Qunix
)
8872 && ! EQ (eol_type
, Qdos
)
8873 && ! EQ (eol_type
, Qmac
))
8874 error ("Invalid eol-type");
8876 aliases
= Fcons (name
, Qnil
);
8878 if (NILP (eol_type
))
8880 eol_type
= make_subsidiaries (name
);
8881 for (i
= 0; i
< 3; i
++)
8883 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
8885 this_name
= AREF (eol_type
, i
);
8886 this_aliases
= Fcons (this_name
, Qnil
);
8887 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
8888 this_spec
= Fmake_vector (make_number (3), attrs
);
8889 ASET (this_spec
, 1, this_aliases
);
8890 ASET (this_spec
, 2, this_eol_type
);
8891 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
8892 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
8893 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
8894 Vcoding_system_alist
);
8898 spec_vec
= Fmake_vector (make_number (3), attrs
);
8899 ASET (spec_vec
, 1, aliases
);
8900 ASET (spec_vec
, 2, eol_type
);
8902 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
8903 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
8904 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
8905 Vcoding_system_alist
);
8908 int id
= coding_categories
[category
].id
;
8910 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
8911 setup_coding_system (name
, &coding_categories
[category
]);
8917 return Fsignal (Qwrong_number_of_arguments
,
8918 Fcons (intern ("define-coding-system-internal"),
8919 make_number (nargs
)));
8923 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
8925 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
8926 (coding_system
, prop
, val
)
8927 Lisp_Object coding_system
, prop
, val
;
8929 Lisp_Object spec
, attrs
;
8931 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8932 attrs
= AREF (spec
, 0);
8933 if (EQ (prop
, QCmnemonic
))
8935 if (! STRINGP (val
))
8936 CHECK_CHARACTER (val
);
8937 CODING_ATTR_MNEMONIC (attrs
) = val
;
8939 else if (EQ (prop
, QCdefalut_char
))
8942 val
= make_number (' ');
8944 CHECK_CHARACTER (val
);
8945 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8947 else if (EQ (prop
, QCdecode_translation_table
))
8949 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8951 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8953 else if (EQ (prop
, QCencode_translation_table
))
8955 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8957 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8959 else if (EQ (prop
, QCpost_read_conversion
))
8962 CODING_ATTR_POST_READ (attrs
) = val
;
8964 else if (EQ (prop
, QCpre_write_conversion
))
8967 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8970 CODING_ATTR_PLIST (attrs
)
8971 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
8976 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
8977 Sdefine_coding_system_alias
, 2, 2, 0,
8978 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
8979 (alias
, coding_system
)
8980 Lisp_Object alias
, coding_system
;
8982 Lisp_Object spec
, aliases
, eol_type
;
8984 CHECK_SYMBOL (alias
);
8985 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8986 aliases
= AREF (spec
, 1);
8987 /* ALISES should be a list of length more than zero, and the first
8988 element is a base coding system. Append ALIAS at the tail of the
8990 while (!NILP (XCDR (aliases
)))
8991 aliases
= XCDR (aliases
);
8992 XSETCDR (aliases
, Fcons (alias
, Qnil
));
8994 eol_type
= AREF (spec
, 2);
8995 if (VECTORP (eol_type
))
8997 Lisp_Object subsidiaries
;
9000 subsidiaries
= make_subsidiaries (alias
);
9001 for (i
= 0; i
< 3; i
++)
9002 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
9003 AREF (eol_type
, i
));
9006 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
9007 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
9008 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
9009 Vcoding_system_alist
);
9014 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
9016 doc
: /* Return the base of CODING-SYSTEM.
9017 Any alias or subsidiary coding system is not a base coding system. */)
9019 Lisp_Object coding_system
;
9021 Lisp_Object spec
, attrs
;
9023 if (NILP (coding_system
))
9024 return (Qno_conversion
);
9025 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9026 attrs
= AREF (spec
, 0);
9027 return CODING_ATTR_BASE_NAME (attrs
);
9030 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
9032 doc
: "Return the property list of CODING-SYSTEM.")
9034 Lisp_Object coding_system
;
9036 Lisp_Object spec
, attrs
;
9038 if (NILP (coding_system
))
9039 coding_system
= Qno_conversion
;
9040 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9041 attrs
= AREF (spec
, 0);
9042 return CODING_ATTR_PLIST (attrs
);
9046 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
9048 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
9050 Lisp_Object coding_system
;
9054 if (NILP (coding_system
))
9055 coding_system
= Qno_conversion
;
9056 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9057 return AREF (spec
, 1);
9060 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
9061 Scoding_system_eol_type
, 1, 1, 0,
9062 doc
: /* Return eol-type of CODING-SYSTEM.
9063 An eol-type is integer 0, 1, 2, or a vector of coding systems.
9065 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9066 and CR respectively.
9068 A vector value indicates that a format of end-of-line should be
9069 detected automatically. Nth element of the vector is the subsidiary
9070 coding system whose eol-type is N. */)
9072 Lisp_Object coding_system
;
9074 Lisp_Object spec
, eol_type
;
9077 if (NILP (coding_system
))
9078 coding_system
= Qno_conversion
;
9079 if (! CODING_SYSTEM_P (coding_system
))
9081 spec
= CODING_SYSTEM_SPEC (coding_system
);
9082 eol_type
= AREF (spec
, 2);
9083 if (VECTORP (eol_type
))
9084 return Fcopy_sequence (eol_type
);
9085 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
9086 return make_number (n
);
9092 /*** 9. Post-amble ***/
9099 for (i
= 0; i
< coding_category_max
; i
++)
9101 coding_categories
[i
].id
= -1;
9102 coding_priorities
[i
] = i
;
9105 /* ISO2022 specific initialize routine. */
9106 for (i
= 0; i
< 0x20; i
++)
9107 iso_code_class
[i
] = ISO_control_0
;
9108 for (i
= 0x21; i
< 0x7F; i
++)
9109 iso_code_class
[i
] = ISO_graphic_plane_0
;
9110 for (i
= 0x80; i
< 0xA0; i
++)
9111 iso_code_class
[i
] = ISO_control_1
;
9112 for (i
= 0xA1; i
< 0xFF; i
++)
9113 iso_code_class
[i
] = ISO_graphic_plane_1
;
9114 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
9115 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
9116 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
9117 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
9118 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
9119 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
9120 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
9121 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
9122 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
9124 for (i
= 0; i
< 256; i
++)
9126 emacs_mule_bytes
[i
] = 1;
9128 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
9129 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
9130 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
9131 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
9139 staticpro (&Vcoding_system_hash_table
);
9141 Lisp_Object args
[2];
9144 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
9147 staticpro (&Vsjis_coding_system
);
9148 Vsjis_coding_system
= Qnil
;
9150 staticpro (&Vbig5_coding_system
);
9151 Vbig5_coding_system
= Qnil
;
9153 staticpro (&Vcode_conversion_reused_workbuf
);
9154 Vcode_conversion_reused_workbuf
= Qnil
;
9156 staticpro (&Vcode_conversion_workbuf_name
);
9157 Vcode_conversion_workbuf_name
= build_string (" *code-conversion-work*");
9159 reused_workbuf_in_use
= 0;
9161 DEFSYM (Qcharset
, "charset");
9162 DEFSYM (Qtarget_idx
, "target-idx");
9163 DEFSYM (Qcoding_system_history
, "coding-system-history");
9164 Fset (Qcoding_system_history
, Qnil
);
9166 /* Target FILENAME is the first argument. */
9167 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
9168 /* Target FILENAME is the third argument. */
9169 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
9171 DEFSYM (Qcall_process
, "call-process");
9172 /* Target PROGRAM is the first argument. */
9173 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
9175 DEFSYM (Qcall_process_region
, "call-process-region");
9176 /* Target PROGRAM is the third argument. */
9177 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
9179 DEFSYM (Qstart_process
, "start-process");
9180 /* Target PROGRAM is the third argument. */
9181 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
9183 DEFSYM (Qopen_network_stream
, "open-network-stream");
9184 /* Target SERVICE is the fourth argument. */
9185 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
9187 DEFSYM (Qcoding_system
, "coding-system");
9188 DEFSYM (Qcoding_aliases
, "coding-aliases");
9190 DEFSYM (Qeol_type
, "eol-type");
9191 DEFSYM (Qunix
, "unix");
9192 DEFSYM (Qdos
, "dos");
9194 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
9195 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
9196 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
9197 DEFSYM (Qdefault_char
, "default-char");
9198 DEFSYM (Qundecided
, "undecided");
9199 DEFSYM (Qno_conversion
, "no-conversion");
9200 DEFSYM (Qraw_text
, "raw-text");
9202 DEFSYM (Qiso_2022
, "iso-2022");
9204 DEFSYM (Qutf_8
, "utf-8");
9205 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
9207 DEFSYM (Qutf_16
, "utf-16");
9208 DEFSYM (Qbig
, "big");
9209 DEFSYM (Qlittle
, "little");
9211 DEFSYM (Qshift_jis
, "shift-jis");
9212 DEFSYM (Qbig5
, "big5");
9214 DEFSYM (Qcoding_system_p
, "coding-system-p");
9216 DEFSYM (Qcoding_system_error
, "coding-system-error");
9217 Fput (Qcoding_system_error
, Qerror_conditions
,
9218 Fcons (Qcoding_system_error
, Fcons (Qerror
, Qnil
)));
9219 Fput (Qcoding_system_error
, Qerror_message
,
9220 build_string ("Invalid coding system"));
9222 /* Intern this now in case it isn't already done.
9223 Setting this variable twice is harmless.
9224 But don't staticpro it here--that is done in alloc.c. */
9225 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
9227 DEFSYM (Qtranslation_table
, "translation-table");
9228 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
9229 DEFSYM (Qtranslation_table_id
, "translation-table-id");
9230 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
9231 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
9233 DEFSYM (Qvalid_codes
, "valid-codes");
9235 DEFSYM (Qemacs_mule
, "emacs-mule");
9237 DEFSYM (QCcategory
, ":category");
9238 DEFSYM (QCmnemonic
, ":mnemonic");
9239 DEFSYM (QCdefalut_char
, ":default-char");
9240 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
9241 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
9242 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
9243 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
9245 Vcoding_category_table
9246 = Fmake_vector (make_number (coding_category_max
), Qnil
);
9247 staticpro (&Vcoding_category_table
);
9248 /* Followings are target of code detection. */
9249 ASET (Vcoding_category_table
, coding_category_iso_7
,
9250 intern ("coding-category-iso-7"));
9251 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
9252 intern ("coding-category-iso-7-tight"));
9253 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
9254 intern ("coding-category-iso-8-1"));
9255 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
9256 intern ("coding-category-iso-8-2"));
9257 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
9258 intern ("coding-category-iso-7-else"));
9259 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
9260 intern ("coding-category-iso-8-else"));
9261 ASET (Vcoding_category_table
, coding_category_utf_8
,
9262 intern ("coding-category-utf-8"));
9263 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
9264 intern ("coding-category-utf-16-be"));
9265 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
9266 intern ("coding-category-utf-16-auto"));
9267 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
9268 intern ("coding-category-utf-16-le"));
9269 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
9270 intern ("coding-category-utf-16-be-nosig"));
9271 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
9272 intern ("coding-category-utf-16-le-nosig"));
9273 ASET (Vcoding_category_table
, coding_category_charset
,
9274 intern ("coding-category-charset"));
9275 ASET (Vcoding_category_table
, coding_category_sjis
,
9276 intern ("coding-category-sjis"));
9277 ASET (Vcoding_category_table
, coding_category_big5
,
9278 intern ("coding-category-big5"));
9279 ASET (Vcoding_category_table
, coding_category_ccl
,
9280 intern ("coding-category-ccl"));
9281 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
9282 intern ("coding-category-emacs-mule"));
9283 /* Followings are NOT target of code detection. */
9284 ASET (Vcoding_category_table
, coding_category_raw_text
,
9285 intern ("coding-category-raw-text"));
9286 ASET (Vcoding_category_table
, coding_category_undecided
,
9287 intern ("coding-category-undecided"));
9289 DEFSYM (Qinsufficient_source
, "insufficient-source");
9290 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
9291 DEFSYM (Qinvalid_source
, "invalid-source");
9292 DEFSYM (Qinterrupted
, "interrupted");
9293 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
9295 defsubr (&Scoding_system_p
);
9296 defsubr (&Sread_coding_system
);
9297 defsubr (&Sread_non_nil_coding_system
);
9298 defsubr (&Scheck_coding_system
);
9299 defsubr (&Sdetect_coding_region
);
9300 defsubr (&Sdetect_coding_string
);
9301 defsubr (&Sfind_coding_systems_region_internal
);
9302 defsubr (&Sunencodable_char_position
);
9303 defsubr (&Scheck_coding_systems_region
);
9304 defsubr (&Sdecode_coding_region
);
9305 defsubr (&Sencode_coding_region
);
9306 defsubr (&Sdecode_coding_string
);
9307 defsubr (&Sencode_coding_string
);
9308 defsubr (&Sdecode_sjis_char
);
9309 defsubr (&Sencode_sjis_char
);
9310 defsubr (&Sdecode_big5_char
);
9311 defsubr (&Sencode_big5_char
);
9312 defsubr (&Sset_terminal_coding_system_internal
);
9313 defsubr (&Sset_safe_terminal_coding_system_internal
);
9314 defsubr (&Sterminal_coding_system
);
9315 defsubr (&Sset_keyboard_coding_system_internal
);
9316 defsubr (&Skeyboard_coding_system
);
9317 defsubr (&Sfind_operation_coding_system
);
9318 defsubr (&Sset_coding_system_priority
);
9319 defsubr (&Sdefine_coding_system_internal
);
9320 defsubr (&Sdefine_coding_system_alias
);
9321 defsubr (&Scoding_system_put
);
9322 defsubr (&Scoding_system_base
);
9323 defsubr (&Scoding_system_plist
);
9324 defsubr (&Scoding_system_aliases
);
9325 defsubr (&Scoding_system_eol_type
);
9326 defsubr (&Scoding_system_priority_list
);
9328 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list
,
9329 doc
: /* List of coding systems.
9331 Do not alter the value of this variable manually. This variable should be
9332 updated by the functions `define-coding-system' and
9333 `define-coding-system-alias'. */);
9334 Vcoding_system_list
= Qnil
;
9336 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist
,
9337 doc
: /* Alist of coding system names.
9338 Each element is one element list of coding system name.
9339 This variable is given to `completing-read' as TABLE argument.
9341 Do not alter the value of this variable manually. This variable should be
9342 updated by the functions `make-coding-system' and
9343 `define-coding-system-alias'. */);
9344 Vcoding_system_alist
= Qnil
;
9346 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list
,
9347 doc
: /* List of coding-categories (symbols) ordered by priority.
9349 On detecting a coding system, Emacs tries code detection algorithms
9350 associated with each coding-category one by one in this order. When
9351 one algorithm agrees with a byte sequence of source text, the coding
9352 system bound to the corresponding coding-category is selected.
9354 When you modify this variable, `update-coding-systems-internal' must
9359 Vcoding_category_list
= Qnil
;
9360 for (i
= coding_category_max
- 1; i
>= 0; i
--)
9361 Vcoding_category_list
9362 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
9363 Vcoding_category_list
);
9366 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read
,
9367 doc
: /* Specify the coding system for read operations.
9368 It is useful to bind this variable with `let', but do not set it globally.
9369 If the value is a coding system, it is used for decoding on read operation.
9370 If not, an appropriate element is used from one of the coding system alists:
9371 There are three such tables, `file-coding-system-alist',
9372 `process-coding-system-alist', and `network-coding-system-alist'. */);
9373 Vcoding_system_for_read
= Qnil
;
9375 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write
,
9376 doc
: /* Specify the coding system for write operations.
9377 Programs bind this variable with `let', but you should not set it globally.
9378 If the value is a coding system, it is used for encoding of output,
9379 when writing it to a file and when sending it to a file or subprocess.
9381 If this does not specify a coding system, an appropriate element
9382 is used from one of the coding system alists:
9383 There are three such tables, `file-coding-system-alist',
9384 `process-coding-system-alist', and `network-coding-system-alist'.
9385 For output to files, if the above procedure does not specify a coding system,
9386 the value of `buffer-file-coding-system' is used. */);
9387 Vcoding_system_for_write
= Qnil
;
9389 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used
,
9391 Coding system used in the latest file or process I/O. */);
9392 Vlast_coding_system_used
= Qnil
;
9394 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error
,
9396 Error status of the last code conversion.
9398 When an error was detected in the last code conversion, this variable
9399 is set to one of the following symbols.
9400 `insufficient-source'
9404 `insufficient-memory'
9405 When no error was detected, the value doesn't change. So, to check
9406 the error status of a code conversion by this variable, you must
9407 explicitly set this variable to nil before performing code
9409 Vlast_code_conversion_error
= Qnil
;
9411 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion
,
9413 *Non-nil means always inhibit code conversion of end-of-line format.
9414 See info node `Coding Systems' and info node `Text and Binary' concerning
9415 such conversion. */);
9416 inhibit_eol_conversion
= 0;
9418 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system
,
9420 Non-nil means process buffer inherits coding system of process output.
9421 Bind it to t if the process output is to be treated as if it were a file
9422 read from some filesystem. */);
9423 inherit_process_coding_system
= 0;
9425 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist
,
9427 Alist to decide a coding system to use for a file I/O operation.
9428 The format is ((PATTERN . VAL) ...),
9429 where PATTERN is a regular expression matching a file name,
9430 VAL is a coding system, a cons of coding systems, or a function symbol.
9431 If VAL is a coding system, it is used for both decoding and encoding
9433 If VAL is a cons of coding systems, the car part is used for decoding,
9434 and the cdr part is used for encoding.
9435 If VAL is a function symbol, the function must return a coding system
9436 or a cons of coding systems which are used as above. The function gets
9437 the arguments with which `find-operation-coding-systems' was called.
9439 See also the function `find-operation-coding-system'
9440 and the variable `auto-coding-alist'. */);
9441 Vfile_coding_system_alist
= Qnil
;
9443 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist
,
9445 Alist to decide a coding system to use for a process I/O operation.
9446 The format is ((PATTERN . VAL) ...),
9447 where PATTERN is a regular expression matching a program name,
9448 VAL is a coding system, a cons of coding systems, or a function symbol.
9449 If VAL is a coding system, it is used for both decoding what received
9450 from the program and encoding what sent to the program.
9451 If VAL is a cons of coding systems, the car part is used for decoding,
9452 and the cdr part is used for encoding.
9453 If VAL is a function symbol, the function must return a coding system
9454 or a cons of coding systems which are used as above.
9456 See also the function `find-operation-coding-system'. */);
9457 Vprocess_coding_system_alist
= Qnil
;
9459 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist
,
9461 Alist to decide a coding system to use for a network I/O operation.
9462 The format is ((PATTERN . VAL) ...),
9463 where PATTERN is a regular expression matching a network service name
9464 or is a port number to connect to,
9465 VAL is a coding system, a cons of coding systems, or a function symbol.
9466 If VAL is a coding system, it is used for both decoding what received
9467 from the network stream and encoding what sent to the network stream.
9468 If VAL is a cons of coding systems, the car part is used for decoding,
9469 and the cdr part is used for encoding.
9470 If VAL is a function symbol, the function must return a coding system
9471 or a cons of coding systems which are used as above.
9473 See also the function `find-operation-coding-system'. */);
9474 Vnetwork_coding_system_alist
= Qnil
;
9476 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system
,
9477 doc
: /* Coding system to use with system messages.
9478 Also used for decoding keyboard input on X Window system. */);
9479 Vlocale_coding_system
= Qnil
;
9481 /* The eol mnemonics are reset in startup.el system-dependently. */
9482 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix
,
9484 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
9485 eol_mnemonic_unix
= build_string (":");
9487 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos
,
9489 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
9490 eol_mnemonic_dos
= build_string ("\\");
9492 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac
,
9494 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
9495 eol_mnemonic_mac
= build_string ("/");
9497 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided
,
9499 *String displayed in mode line when end-of-line format is not yet determined. */);
9500 eol_mnemonic_undecided
= build_string (":");
9502 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation
,
9504 *Non-nil enables character translation while encoding and decoding. */);
9505 Venable_character_translation
= Qt
;
9507 DEFVAR_LISP ("standard-translation-table-for-decode",
9508 &Vstandard_translation_table_for_decode
,
9509 doc
: /* Table for translating characters while decoding. */);
9510 Vstandard_translation_table_for_decode
= Qnil
;
9512 DEFVAR_LISP ("standard-translation-table-for-encode",
9513 &Vstandard_translation_table_for_encode
,
9514 doc
: /* Table for translating characters while encoding. */);
9515 Vstandard_translation_table_for_encode
= Qnil
;
9517 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table
,
9518 doc
: /* Alist of charsets vs revision numbers.
9519 While encoding, if a charset (car part of an element) is found,
9520 designate it with the escape sequence identifying revision (cdr part
9521 of the element). */);
9522 Vcharset_revision_table
= Qnil
;
9524 DEFVAR_LISP ("default-process-coding-system",
9525 &Vdefault_process_coding_system
,
9526 doc
: /* Cons of coding systems used for process I/O by default.
9527 The car part is used for decoding a process output,
9528 the cdr part is used for encoding a text to be sent to a process. */);
9529 Vdefault_process_coding_system
= Qnil
;
9531 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table
,
9533 Table of extra Latin codes in the range 128..159 (inclusive).
9534 This is a vector of length 256.
9535 If Nth element is non-nil, the existence of code N in a file
9536 \(or output of subprocess) doesn't prevent it to be detected as
9537 a coding system of ISO 2022 variant which has a flag
9538 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
9539 or reading output of a subprocess.
9540 Only 128th through 159th elements has a meaning. */);
9541 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
9543 DEFVAR_LISP ("select-safe-coding-system-function",
9544 &Vselect_safe_coding_system_function
,
9546 Function to call to select safe coding system for encoding a text.
9548 If set, this function is called to force a user to select a proper
9549 coding system which can encode the text in the case that a default
9550 coding system used in each operation can't encode the text.
9552 The default value is `select-safe-coding-system' (which see). */);
9553 Vselect_safe_coding_system_function
= Qnil
;
9555 DEFVAR_BOOL ("coding-system-require-warning",
9556 &coding_system_require_warning
,
9557 doc
: /* Internal use only.
9558 If non-nil, on writing a file, `select-safe-coding-system-function' is
9559 called even if `coding-system-for-write' is non-nil. The command
9560 `universal-coding-system-argument' binds this variable to t temporarily. */);
9561 coding_system_require_warning
= 0;
9564 DEFVAR_BOOL ("inhibit-iso-escape-detection",
9565 &inhibit_iso_escape_detection
,
9567 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
9569 By default, on reading a file, Emacs tries to detect how the text is
9570 encoded. This code detection is sensitive to escape sequences. If
9571 the sequence is valid as ISO2022, the code is determined as one of
9572 the ISO2022 encodings, and the file is decoded by the corresponding
9573 coding system (e.g. `iso-2022-7bit').
9575 However, there may be a case that you want to read escape sequences in
9576 a file as is. In such a case, you can set this variable to non-nil.
9577 Then, as the code detection ignores any escape sequences, no file is
9578 detected as encoded in some ISO2022 encoding. The result is that all
9579 escape sequences become visible in a buffer.
9581 The default value is nil, and it is strongly recommended not to change
9582 it. That is because many Emacs Lisp source files that contain
9583 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
9584 in Emacs's distribution, and they won't be decoded correctly on
9585 reading if you suppress escape sequence detection.
9587 The other way to read escape sequences in a file without decoding is
9588 to explicitly specify some coding system that doesn't use ISO2022's
9589 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
9590 inhibit_iso_escape_detection
= 0;
9592 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input
,
9593 doc
: /* Char table for translating self-inserting characters.
9594 This is applied to the result of input methods, not their input. See also
9595 `keyboard-translate-table'. */);
9596 Vtranslation_table_for_input
= Qnil
;
9599 Lisp_Object args
[coding_arg_max
];
9600 Lisp_Object plist
[16];
9603 for (i
= 0; i
< coding_arg_max
; i
++)
9606 plist
[0] = intern (":name");
9607 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
9608 plist
[2] = intern (":mnemonic");
9609 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
9610 plist
[4] = intern (":coding-type");
9611 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
9612 plist
[6] = intern (":ascii-compatible-p");
9613 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
9614 plist
[8] = intern (":default-char");
9615 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
9616 plist
[10] = intern (":for-unibyte");
9617 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
9618 plist
[12] = intern (":docstring");
9619 plist
[13] = build_string ("Do no conversion.\n\
9621 When you visit a file with this coding, the file is read into a\n\
9622 unibyte buffer as is, thus each byte of a file is treated as a\n\
9624 plist
[14] = intern (":eol-type");
9625 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
9626 args
[coding_arg_plist
] = Flist (16, plist
);
9627 Fdefine_coding_system_internal (coding_arg_max
, args
);
9629 plist
[1] = args
[coding_arg_name
] = Qundecided
;
9630 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
9631 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
9632 /* This is already set.
9633 /*plist[7] = args[coding_arg_ascii_compatible_p] = Qt;*/
9634 plist
[8] = intern (":charset-list");
9635 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
9636 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
9637 plist
[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
9638 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
9639 args
[coding_arg_plist
] = Flist (16, plist
);
9640 Fdefine_coding_system_internal (coding_arg_max
, args
);
9643 setup_coding_system (Qno_conversion
, &keyboard_coding
);
9644 setup_coding_system (Qundecided
, &terminal_coding
);
9645 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
9650 for (i
= 0; i
< coding_category_max
; i
++)
9651 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
9656 emacs_strerror (error_number
)
9661 synchronize_system_messages_locale ();
9662 str
= strerror (error_number
);
9664 if (! NILP (Vlocale_coding_system
))
9666 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
9667 Vlocale_coding_system
,
9669 str
= (char *) SDATA (dec
);
9677 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
9678 (do not change this comment) */