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 unsigned char *src
= coding
->source
;
161 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 unsigned char *src
= coding
->source
+ coding
->consumed
;
209 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 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 dst
+= CHAR_STRING (c
, dst
);
1356 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1357 coding
->produced_char
+= produced_chars
;
1358 coding
->produced
= dst
- coding
->destination
;
1363 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1364 Check if a text is encoded in one of UTF-16 based coding systems.
1365 If it is, return 1, else return 0. */
1367 #define UTF_16_HIGH_SURROGATE_P(val) \
1368 (((val) & 0xFC00) == 0xD800)
1370 #define UTF_16_LOW_SURROGATE_P(val) \
1371 (((val) & 0xFC00) == 0xDC00)
1373 #define UTF_16_INVALID_P(val) \
1374 (((val) == 0xFFFE) \
1375 || ((val) == 0xFFFF) \
1376 || UTF_16_LOW_SURROGATE_P (val))
1380 detect_coding_utf_16 (coding
, detect_info
)
1381 struct coding_system
*coding
;
1382 struct coding_detection_info
*detect_info
;
1384 const unsigned char *src
= coding
->source
, *src_base
= src
;
1385 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1386 int multibytep
= coding
->src_multibyte
;
1387 int consumed_chars
= 0;
1390 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1391 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1392 && (coding
->src_chars
& 1))
1394 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1400 if ((c1
== 0xFF) && (c2
== 0xFE))
1402 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1403 | CATEGORY_MASK_UTF_16_AUTO
);
1404 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1405 | CATEGORY_MASK_UTF_16_BE_NOSIG
1406 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1408 else if ((c1
== 0xFE) && (c2
== 0xFF))
1410 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1411 | CATEGORY_MASK_UTF_16_AUTO
);
1412 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1413 | CATEGORY_MASK_UTF_16_BE_NOSIG
1414 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1416 else if (c1
>= 0 && c2
>= 0)
1418 unsigned char b1
[256], b2
[256];
1419 int b1_variants
= 1, b2_variants
= 1;
1422 bzero (b1
, 256), bzero (b2
, 256);
1424 for (n
= 0; n
< 256 && src
< src_end
; n
++)
1429 if (c1
< 0 || c2
< 0)
1431 if (! b1
[c1
++]) b1_variants
++;
1432 if (! b2
[c2
++]) b2_variants
++;
1434 if (b1_variants
< b2_variants
)
1435 detect_info
->found
|= CATEGORY_MASK_UTF_16_BE_NOSIG
;
1437 detect_info
->found
|= CATEGORY_MASK_UTF_16_LE_NOSIG
;
1438 detect_info
->rejected
1439 |= (CATEGORY_MASK_UTF_16_BE
| CATEGORY_MASK_UTF_16_LE
);
1446 decode_coding_utf_16 (coding
)
1447 struct coding_system
*coding
;
1449 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1450 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1451 const unsigned char *src_base
;
1452 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1453 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1454 int consumed_chars
= 0, consumed_chars_base
;
1455 int multibytep
= coding
->src_multibyte
;
1456 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1457 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1458 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1459 Lisp_Object attr
, charset_list
;
1461 CODING_GET_INFO (coding
, attr
, charset_list
);
1463 if (bom
== utf_16_with_bom
)
1472 if (endian
== utf_16_big_endian
1473 ? c
!= 0xFEFF : c
!= 0xFFFE)
1475 /* The first two bytes are not BOM. Treat them as bytes
1476 for a normal character. */
1480 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1482 else if (bom
== utf_16_detect_bom
)
1484 /* We have already tried to detect BOM and failed in
1486 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1494 consumed_chars_base
= consumed_chars
;
1496 if (charbuf
+ 2 >= charbuf_end
)
1508 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1512 c
= (endian
== utf_16_big_endian
1513 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1516 if (! UTF_16_LOW_SURROGATE_P (c
))
1518 if (endian
== utf_16_big_endian
)
1519 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1521 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1525 if (UTF_16_HIGH_SURROGATE_P (c
))
1526 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1532 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1533 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1534 *charbuf
++ = 0x10000 + c
;
1539 if (UTF_16_HIGH_SURROGATE_P (c
))
1540 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1547 coding
->consumed_char
+= consumed_chars_base
;
1548 coding
->consumed
= src_base
- coding
->source
;
1549 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1553 encode_coding_utf_16 (coding
)
1554 struct coding_system
*coding
;
1556 int multibytep
= coding
->dst_multibyte
;
1557 int *charbuf
= coding
->charbuf
;
1558 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1559 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1560 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1562 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1563 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1564 int produced_chars
= 0;
1565 Lisp_Object attrs
, charset_list
;
1568 CODING_GET_INFO (coding
, attrs
, charset_list
);
1570 if (bom
!= utf_16_without_bom
)
1572 ASSURE_DESTINATION (safe_room
);
1574 EMIT_TWO_BYTES (0xFE, 0xFF);
1576 EMIT_TWO_BYTES (0xFF, 0xFE);
1577 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1580 while (charbuf
< charbuf_end
)
1582 ASSURE_DESTINATION (safe_room
);
1584 if (c
>= MAX_UNICODE_CHAR
)
1585 c
= coding
->default_char
;
1590 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1592 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1599 c1
= (c
>> 10) + 0xD800;
1600 c2
= (c
& 0x3FF) + 0xDC00;
1602 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1604 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1607 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1608 coding
->produced
= dst
- coding
->destination
;
1609 coding
->produced_char
+= produced_chars
;
1614 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1616 /* Emacs' internal format for representation of multiple character
1617 sets is a kind of multi-byte encoding, i.e. characters are
1618 represented by variable-length sequences of one-byte codes.
1620 ASCII characters and control characters (e.g. `tab', `newline') are
1621 represented by one-byte sequences which are their ASCII codes, in
1622 the range 0x00 through 0x7F.
1624 8-bit characters of the range 0x80..0x9F are represented by
1625 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1628 8-bit characters of the range 0xA0..0xFF are represented by
1629 one-byte sequences which are their 8-bit code.
1631 The other characters are represented by a sequence of `base
1632 leading-code', optional `extended leading-code', and one or two
1633 `position-code's. The length of the sequence is determined by the
1634 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1635 whereas extended leading-code and position-code take the range 0xA0
1636 through 0xFF. See `charset.h' for more details about leading-code
1639 --- CODE RANGE of Emacs' internal format ---
1643 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1644 eight-bit-graphic 0xA0..0xBF
1645 ELSE 0x81..0x9D + [0xA0..0xFF]+
1646 ---------------------------------------------
1648 As this is the internal character representation, the format is
1649 usually not used externally (i.e. in a file or in a data sent to a
1650 process). But, it is possible to have a text externally in this
1651 format (i.e. by encoding by the coding system `emacs-mule').
1653 In that case, a sequence of one-byte codes has a slightly different
1656 At first, all characters in eight-bit-control are represented by
1657 one-byte sequences which are their 8-bit code.
1659 Next, character composition data are represented by the byte
1660 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1662 METHOD is 0xF0 plus one of composition method (enum
1663 composition_method),
1665 BYTES is 0xA0 plus a byte length of this composition data,
1667 CHARS is 0x20 plus a number of characters composed by this
1670 COMPONENTs are characters of multibye form or composition
1671 rules encoded by two-byte of ASCII codes.
1673 In addition, for backward compatibility, the following formats are
1674 also recognized as composition data on decoding.
1677 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1680 MSEQ is a multibyte form but in these special format:
1681 ASCII: 0xA0 ASCII_CODE+0x80,
1682 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1683 RULE is a one byte code of the range 0xA0..0xF0 that
1684 represents a composition rule.
1687 char emacs_mule_bytes
[256];
1690 emacs_mule_char (coding
, src
, nbytes
, nchars
, id
)
1691 struct coding_system
*coding
;
1692 const unsigned char *src
;
1693 int *nbytes
, *nchars
, *id
;
1695 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1696 const unsigned char *src_base
= src
;
1697 int multibytep
= coding
->src_multibyte
;
1698 struct charset
*charset
;
1701 int consumed_chars
= 0;
1707 charset
= emacs_mule_charset
[0];
1711 switch (emacs_mule_bytes
[c
])
1714 if (! (charset
= emacs_mule_charset
[c
]))
1723 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1724 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1727 if (c
< 0xA0 || ! (charset
= emacs_mule_charset
[c
]))
1736 if (! (charset
= emacs_mule_charset
[c
]))
1741 code
= (c
& 0x7F) << 8;
1751 if (c
< 0 || ! (charset
= emacs_mule_charset
[c
]))
1756 code
= (c
& 0x7F) << 8;
1765 charset
= CHARSET_FROM_ID (ASCII_BYTE_P (code
)
1766 ? charset_ascii
: charset_eight_bit
);
1772 c
= DECODE_CHAR (charset
, code
);
1776 *nbytes
= src
- src_base
;
1777 *nchars
= consumed_chars
;
1790 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1791 Check if a text is encoded in `emacs-mule'. If it is, return 1,
1795 detect_coding_emacs_mule (coding
, detect_info
)
1796 struct coding_system
*coding
;
1797 struct coding_detection_info
*detect_info
;
1799 const unsigned char *src
= coding
->source
, *src_base
;
1800 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1801 int multibytep
= coding
->src_multibyte
;
1802 int consumed_chars
= 0;
1806 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1807 /* A coding system of this category is always ASCII compatible. */
1808 src
+= coding
->head_ascii
;
1818 /* Perhaps the start of composite character. We simple skip
1819 it because analyzing it is too heavy for detecting. But,
1820 at least, we check that the composite character
1821 constitues of more than 4 bytes. */
1822 const unsigned char *src_base
;
1832 if (src
- src_base
<= 4)
1834 found
= CATEGORY_MASK_EMACS_MULE
;
1842 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1847 int more_bytes
= emacs_mule_bytes
[*src_base
] - 1;
1849 while (more_bytes
> 0)
1854 src
--; /* Unread the last byte. */
1859 if (more_bytes
!= 0)
1861 found
= CATEGORY_MASK_EMACS_MULE
;
1864 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1868 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1870 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1873 detect_info
->found
|= found
;
1878 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
1880 /* Decode a character represented as a component of composition
1881 sequence of Emacs 20/21 style at SRC. Set C to that character and
1882 update SRC to the head of next character (or an encoded composition
1883 rule). If SRC doesn't points a composition component, set C to -1.
1884 If SRC points an invalid byte sequence, global exit by a return
1887 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
1891 int nbytes, nchars; \
1893 if (src == src_end) \
1895 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
1900 goto invalid_code; \
1904 consumed_chars += nchars; \
1909 /* Decode a composition rule represented as a component of composition
1910 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
1911 and increment BUF. If SRC points an invalid byte sequence, set C
1914 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
1916 int c, gref, nref; \
1918 if (src >= src_end) \
1919 goto invalid_code; \
1920 ONE_MORE_BYTE_NO_CHECK (c); \
1922 if (c < 0 || c >= 81) \
1923 goto invalid_code; \
1925 gref = c / 9, nref = c % 9; \
1926 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1930 /* Decode a composition rule represented as a component of composition
1931 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
1932 and increment BUF. If SRC points an invalid byte sequence, set C
1935 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
1939 if (src + 1>= src_end) \
1940 goto invalid_code; \
1941 ONE_MORE_BYTE_NO_CHECK (gref); \
1943 ONE_MORE_BYTE_NO_CHECK (nref); \
1945 if (gref < 0 || gref >= 81 \
1946 || nref < 0 || nref >= 81) \
1947 goto invalid_code; \
1948 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1952 #define DECODE_EMACS_MULE_21_COMPOSITION(c) \
1954 /* Emacs 21 style format. The first three bytes at SRC are \
1955 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
1956 the byte length of this composition information, CHARS is the \
1957 number of characters composed by this composition. */ \
1958 enum composition_method method = c - 0xF2; \
1959 int *charbuf_base = charbuf; \
1960 int consumed_chars_limit; \
1961 int nbytes, nchars; \
1963 ONE_MORE_BYTE (c); \
1965 goto invalid_code; \
1966 nbytes = c - 0xA0; \
1968 goto invalid_code; \
1969 ONE_MORE_BYTE (c); \
1971 goto invalid_code; \
1972 nchars = c - 0xA0; \
1973 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
1974 consumed_chars_limit = consumed_chars_base + nbytes; \
1975 if (method != COMPOSITION_RELATIVE) \
1978 while (consumed_chars < consumed_chars_limit) \
1980 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
1981 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
1983 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
1986 if (consumed_chars < consumed_chars_limit) \
1987 goto invalid_code; \
1988 charbuf_base[0] -= i; \
1993 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
1995 /* Emacs 20 style format for relative composition. */ \
1996 /* Store multibyte form of characters to be composed. */ \
1997 enum composition_method method = COMPOSITION_RELATIVE; \
1998 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
1999 int *buf = components; \
2003 ONE_MORE_BYTE (c); /* skip 0x80 */ \
2004 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
2005 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2007 goto invalid_code; \
2008 ADD_COMPOSITION_DATA (charbuf, i, method); \
2009 for (j = 0; j < i; j++) \
2010 *charbuf++ = components[j]; \
2014 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
2016 /* Emacs 20 style format for rule-base composition. */ \
2017 /* Store multibyte form of characters to be composed. */ \
2018 enum composition_method method = COMPOSITION_WITH_RULE; \
2019 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2020 int *buf = components; \
2023 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2024 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
2026 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
2027 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2029 if (i < 1 || (buf - components) % 2 == 0) \
2030 goto invalid_code; \
2031 if (charbuf + i + (i / 2) + 1 < charbuf_end) \
2032 goto no_more_source; \
2033 ADD_COMPOSITION_DATA (buf, i, method); \
2034 for (j = 0; j < i; j++) \
2035 *charbuf++ = components[j]; \
2036 for (j = 0; j < i; j += 2) \
2037 *charbuf++ = components[j]; \
2042 decode_coding_emacs_mule (coding
)
2043 struct coding_system
*coding
;
2045 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2046 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2047 const unsigned char *src_base
;
2048 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2050 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
2051 int consumed_chars
= 0, consumed_chars_base
;
2052 int multibytep
= coding
->src_multibyte
;
2053 Lisp_Object attrs
, charset_list
;
2054 int char_offset
= coding
->produced_char
;
2055 int last_offset
= char_offset
;
2056 int last_id
= charset_ascii
;
2058 CODING_GET_INFO (coding
, attrs
, charset_list
);
2065 consumed_chars_base
= consumed_chars
;
2067 if (charbuf
>= charbuf_end
)
2086 if (c
- 0xF2 >= COMPOSITION_RELATIVE
2087 && c
- 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS
)
2088 DECODE_EMACS_MULE_21_COMPOSITION (c
);
2090 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c
);
2092 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c
);
2096 else if (c
< 0xA0 && emacs_mule_bytes
[c
] > 1)
2102 consumed_chars
= consumed_chars_base
;
2103 c
= emacs_mule_char (coding
, src
, &nbytes
, &nchars
, &id
);
2112 if (last_id
!= charset_ascii
)
2113 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2115 last_offset
= char_offset
;
2119 consumed_chars
+= nchars
;
2126 consumed_chars
= consumed_chars_base
;
2128 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2134 if (last_id
!= charset_ascii
)
2135 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2136 coding
->consumed_char
+= consumed_chars_base
;
2137 coding
->consumed
= src_base
- coding
->source
;
2138 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2142 #define EMACS_MULE_LEADING_CODES(id, codes) \
2145 codes[0] = id, codes[1] = 0; \
2146 else if (id < 0xE0) \
2147 codes[0] = 0x9A, codes[1] = id; \
2148 else if (id < 0xF0) \
2149 codes[0] = 0x9B, codes[1] = id; \
2150 else if (id < 0xF5) \
2151 codes[0] = 0x9C, codes[1] = id; \
2153 codes[0] = 0x9D, codes[1] = id; \
2158 encode_coding_emacs_mule (coding
)
2159 struct coding_system
*coding
;
2161 int multibytep
= coding
->dst_multibyte
;
2162 int *charbuf
= coding
->charbuf
;
2163 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2164 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2165 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2167 int produced_chars
= 0;
2168 Lisp_Object attrs
, charset_list
;
2170 int preferred_charset_id
= -1;
2172 CODING_GET_INFO (coding
, attrs
, charset_list
);
2173 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2175 CODING_ATTR_CHARSET_LIST (attrs
)
2176 = charset_list
= Vemacs_mule_charset_list
;
2179 while (charbuf
< charbuf_end
)
2181 ASSURE_DESTINATION (safe_room
);
2186 /* Handle an annotation. */
2189 case CODING_ANNOTATE_COMPOSITION_MASK
:
2190 /* Not yet implemented. */
2192 case CODING_ANNOTATE_CHARSET_MASK
:
2193 preferred_charset_id
= charbuf
[3];
2194 if (preferred_charset_id
>= 0
2195 && NILP (Fmemq (make_number (preferred_charset_id
),
2197 preferred_charset_id
= -1;
2206 if (ASCII_CHAR_P (c
))
2207 EMIT_ONE_ASCII_BYTE (c
);
2208 else if (CHAR_BYTE8_P (c
))
2210 c
= CHAR_TO_BYTE8 (c
);
2215 struct charset
*charset
;
2219 unsigned char leading_codes
[2];
2221 if (preferred_charset_id
>= 0)
2223 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2224 if (! CHAR_CHARSET_P (c
, charset
))
2225 charset
= char_charset (c
, charset_list
, NULL
);
2228 charset
= char_charset (c
, charset_list
, &code
);
2231 c
= coding
->default_char
;
2232 if (ASCII_CHAR_P (c
))
2234 EMIT_ONE_ASCII_BYTE (c
);
2237 charset
= char_charset (c
, charset_list
, &code
);
2239 dimension
= CHARSET_DIMENSION (charset
);
2240 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2241 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2242 EMIT_ONE_BYTE (leading_codes
[0]);
2243 if (leading_codes
[1])
2244 EMIT_ONE_BYTE (leading_codes
[1]);
2246 EMIT_ONE_BYTE (code
| 0x80);
2250 EMIT_ONE_BYTE (code
>> 8);
2251 EMIT_ONE_BYTE (code
& 0xFF);
2255 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2256 coding
->produced_char
+= produced_chars
;
2257 coding
->produced
= dst
- coding
->destination
;
2262 /*** 7. ISO2022 handlers ***/
2264 /* The following note describes the coding system ISO2022 briefly.
2265 Since the intention of this note is to help understand the
2266 functions in this file, some parts are NOT ACCURATE or are OVERLY
2267 SIMPLIFIED. For thorough understanding, please refer to the
2268 original document of ISO2022. This is equivalent to the standard
2269 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2271 ISO2022 provides many mechanisms to encode several character sets
2272 in 7-bit and 8-bit environments. For 7-bit environments, all text
2273 is encoded using bytes less than 128. This may make the encoded
2274 text a little bit longer, but the text passes more easily through
2275 several types of gateway, some of which strip off the MSB (Most
2278 There are two kinds of character sets: control character sets and
2279 graphic character sets. The former contain control characters such
2280 as `newline' and `escape' to provide control functions (control
2281 functions are also provided by escape sequences). The latter
2282 contain graphic characters such as 'A' and '-'. Emacs recognizes
2283 two control character sets and many graphic character sets.
2285 Graphic character sets are classified into one of the following
2286 four classes, according to the number of bytes (DIMENSION) and
2287 number of characters in one dimension (CHARS) of the set:
2288 - DIMENSION1_CHARS94
2289 - DIMENSION1_CHARS96
2290 - DIMENSION2_CHARS94
2291 - DIMENSION2_CHARS96
2293 In addition, each character set is assigned an identification tag,
2294 unique for each set, called the "final character" (denoted as <F>
2295 hereafter). The <F> of each character set is decided by ECMA(*)
2296 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2297 (0x30..0x3F are for private use only).
2299 Note (*): ECMA = European Computer Manufacturers Association
2301 Here are examples of graphic character sets [NAME(<F>)]:
2302 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2303 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2304 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2305 o DIMENSION2_CHARS96 -- none for the moment
2307 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2308 C0 [0x00..0x1F] -- control character plane 0
2309 GL [0x20..0x7F] -- graphic character plane 0
2310 C1 [0x80..0x9F] -- control character plane 1
2311 GR [0xA0..0xFF] -- graphic character plane 1
2313 A control character set is directly designated and invoked to C0 or
2314 C1 by an escape sequence. The most common case is that:
2315 - ISO646's control character set is designated/invoked to C0, and
2316 - ISO6429's control character set is designated/invoked to C1,
2317 and usually these designations/invocations are omitted in encoded
2318 text. In a 7-bit environment, only C0 can be used, and a control
2319 character for C1 is encoded by an appropriate escape sequence to
2320 fit into the environment. All control characters for C1 are
2321 defined to have corresponding escape sequences.
2323 A graphic character set is at first designated to one of four
2324 graphic registers (G0 through G3), then these graphic registers are
2325 invoked to GL or GR. These designations and invocations can be
2326 done independently. The most common case is that G0 is invoked to
2327 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2328 these invocations and designations are omitted in encoded text.
2329 In a 7-bit environment, only GL can be used.
2331 When a graphic character set of CHARS94 is invoked to GL, codes
2332 0x20 and 0x7F of the GL area work as control characters SPACE and
2333 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2336 There are two ways of invocation: locking-shift and single-shift.
2337 With locking-shift, the invocation lasts until the next different
2338 invocation, whereas with single-shift, the invocation affects the
2339 following character only and doesn't affect the locking-shift
2340 state. Invocations are done by the following control characters or
2343 ----------------------------------------------------------------------
2344 abbrev function cntrl escape seq description
2345 ----------------------------------------------------------------------
2346 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2347 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2348 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2349 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2350 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2351 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2352 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2353 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2354 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2355 ----------------------------------------------------------------------
2356 (*) These are not used by any known coding system.
2358 Control characters for these functions are defined by macros
2359 ISO_CODE_XXX in `coding.h'.
2361 Designations are done by the following escape sequences:
2362 ----------------------------------------------------------------------
2363 escape sequence description
2364 ----------------------------------------------------------------------
2365 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2366 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2367 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2368 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2369 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2370 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2371 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2372 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2373 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2374 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2375 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2376 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2377 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2378 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2379 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2380 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2381 ----------------------------------------------------------------------
2383 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2384 of dimension 1, chars 94, and final character <F>, etc...
2386 Note (*): Although these designations are not allowed in ISO2022,
2387 Emacs accepts them on decoding, and produces them on encoding
2388 CHARS96 character sets in a coding system which is characterized as
2389 7-bit environment, non-locking-shift, and non-single-shift.
2391 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2392 '(' must be omitted. We refer to this as "short-form" hereafter.
2394 Now you may notice that there are a lot of ways of encoding the
2395 same multilingual text in ISO2022. Actually, there exist many
2396 coding systems such as Compound Text (used in X11's inter client
2397 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2398 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2399 localized platforms), and all of these are variants of ISO2022.
2401 In addition to the above, Emacs handles two more kinds of escape
2402 sequences: ISO6429's direction specification and Emacs' private
2403 sequence for specifying character composition.
2405 ISO6429's direction specification takes the following form:
2406 o CSI ']' -- end of the current direction
2407 o CSI '0' ']' -- end of the current direction
2408 o CSI '1' ']' -- start of left-to-right text
2409 o CSI '2' ']' -- start of right-to-left text
2410 The control character CSI (0x9B: control sequence introducer) is
2411 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2413 Character composition specification takes the following form:
2414 o ESC '0' -- start relative composition
2415 o ESC '1' -- end composition
2416 o ESC '2' -- start rule-base composition (*)
2417 o ESC '3' -- start relative composition with alternate chars (**)
2418 o ESC '4' -- start rule-base composition with alternate chars (**)
2419 Since these are not standard escape sequences of any ISO standard,
2420 the use of them with these meanings is restricted to Emacs only.
2422 (*) This form is used only in Emacs 20.7 and older versions,
2423 but newer versions can safely decode it.
2424 (**) This form is used only in Emacs 21.1 and newer versions,
2425 and older versions can't decode it.
2427 Here's a list of example usages of these composition escape
2428 sequences (categorized by `enum composition_method').
2430 COMPOSITION_RELATIVE:
2431 ESC 0 CHAR [ CHAR ] ESC 1
2432 COMPOSITION_WITH_RULE:
2433 ESC 2 CHAR [ RULE CHAR ] ESC 1
2434 COMPOSITION_WITH_ALTCHARS:
2435 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2436 COMPOSITION_WITH_RULE_ALTCHARS:
2437 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2439 enum iso_code_class_type iso_code_class
[256];
2441 #define SAFE_CHARSET_P(coding, id) \
2442 ((id) <= (coding)->max_charset_id \
2443 && (coding)->safe_charsets[id] >= 0)
2446 #define SHIFT_OUT_OK(category) \
2447 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2450 setup_iso_safe_charsets (attrs
)
2453 Lisp_Object charset_list
, safe_charsets
;
2454 Lisp_Object request
;
2455 Lisp_Object reg_usage
;
2458 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2461 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2462 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2463 && ! EQ (charset_list
, Viso_2022_charset_list
))
2465 CODING_ATTR_CHARSET_LIST (attrs
)
2466 = charset_list
= Viso_2022_charset_list
;
2467 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2470 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2474 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2476 int id
= XINT (XCAR (tail
));
2477 if (max_charset_id
< id
)
2478 max_charset_id
= id
;
2481 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
2483 request
= AREF (attrs
, coding_attr_iso_request
);
2484 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2485 reg94
= XINT (XCAR (reg_usage
));
2486 reg96
= XINT (XCDR (reg_usage
));
2488 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2492 struct charset
*charset
;
2495 charset
= CHARSET_FROM_ID (XINT (id
));
2496 reg
= Fcdr (Fassq (id
, request
));
2498 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2499 else if (charset
->iso_chars_96
)
2502 SSET (safe_charsets
, XINT (id
), reg96
);
2507 SSET (safe_charsets
, XINT (id
), reg94
);
2510 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2514 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2515 Check if a text is encoded in one of ISO-2022 based codig systems.
2516 If it is, return 1, else return 0. */
2519 detect_coding_iso_2022 (coding
, detect_info
)
2520 struct coding_system
*coding
;
2521 struct coding_detection_info
*detect_info
;
2523 const unsigned char *src
= coding
->source
, *src_base
= src
;
2524 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2525 int multibytep
= coding
->src_multibyte
;
2526 int single_shifting
= 0;
2529 int consumed_chars
= 0;
2534 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2536 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2538 struct coding_system
*this = &(coding_categories
[i
]);
2539 Lisp_Object attrs
, val
;
2541 attrs
= CODING_ID_ATTRS (this->id
);
2542 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2543 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs
), Viso_2022_charset_list
))
2544 setup_iso_safe_charsets (attrs
);
2545 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2546 this->max_charset_id
= SCHARS (val
) - 1;
2547 this->safe_charsets
= (char *) SDATA (val
);
2550 /* A coding system of this category is always ASCII compatible. */
2551 src
+= coding
->head_ascii
;
2553 while (rejected
!= CATEGORY_MASK_ISO
)
2560 if (inhibit_iso_escape_detection
)
2562 single_shifting
= 0;
2564 if (c
>= '(' && c
<= '/')
2566 /* Designation sequence for a charset of dimension 1. */
2568 if (c1
< ' ' || c1
>= 0x80
2569 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2570 /* Invalid designation sequence. Just ignore. */
2575 /* Designation sequence for a charset of dimension 2. */
2577 if (c
>= '@' && c
<= 'B')
2578 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2579 id
= iso_charset_table
[1][0][c
];
2580 else if (c
>= '(' && c
<= '/')
2583 if (c1
< ' ' || c1
>= 0x80
2584 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2585 /* Invalid designation sequence. Just ignore. */
2589 /* Invalid designation sequence. Just ignore it. */
2592 else if (c
== 'N' || c
== 'O')
2594 /* ESC <Fe> for SS2 or SS3. */
2595 single_shifting
= 1;
2596 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2599 else if (c
>= '0' && c
<= '4')
2601 /* ESC <Fp> for start/end composition. */
2602 found
|= CATEGORY_MASK_ISO
;
2607 /* Invalid escape sequence. Just ignore it. */
2611 /* We found a valid designation sequence for CHARSET. */
2612 rejected
|= CATEGORY_MASK_ISO_8BIT
;
2613 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
2615 found
|= CATEGORY_MASK_ISO_7
;
2617 rejected
|= CATEGORY_MASK_ISO_7
;
2618 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
2620 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
2622 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
2623 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
2625 found
|= CATEGORY_MASK_ISO_7_ELSE
;
2627 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
2628 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
2630 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2632 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
2637 /* Locking shift out/in. */
2638 if (inhibit_iso_escape_detection
)
2640 single_shifting
= 0;
2641 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2642 found
|= CATEGORY_MASK_ISO_ELSE
;
2646 /* Control sequence introducer. */
2647 single_shifting
= 0;
2648 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2649 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2650 goto check_extra_latin
;
2655 if (inhibit_iso_escape_detection
)
2657 single_shifting
= 0;
2658 rejected
|= CATEGORY_MASK_ISO_7BIT
;
2659 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2660 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2661 found
|= CATEGORY_MASK_ISO_8_1
, single_shifting
= 1;
2662 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
2663 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2664 found
|= CATEGORY_MASK_ISO_8_2
, single_shifting
= 1;
2665 if (single_shifting
)
2667 goto check_extra_latin
;
2674 single_shifting
= 0;
2679 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2680 found
|= CATEGORY_MASK_ISO_8_1
;
2681 /* Check the length of succeeding codes of the range
2682 0xA0..0FF. If the byte length is even, we include
2683 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2684 only when we are not single shifting. */
2685 if (! single_shifting
2686 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
2689 while (src
< src_end
)
2697 if (i
& 1 && src
< src_end
)
2698 rejected
|= CATEGORY_MASK_ISO_8_2
;
2700 found
|= CATEGORY_MASK_ISO_8_2
;
2705 single_shifting
= 0;
2706 if (! VECTORP (Vlatin_extra_code_table
)
2707 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
2709 rejected
= CATEGORY_MASK_ISO
;
2712 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2713 & CODING_ISO_FLAG_LATIN_EXTRA
)
2714 found
|= CATEGORY_MASK_ISO_8_1
;
2716 rejected
|= CATEGORY_MASK_ISO_8_1
;
2717 rejected
|= CATEGORY_MASK_ISO_8_2
;
2720 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
2724 detect_info
->rejected
|= rejected
;
2725 detect_info
->found
|= (found
& ~rejected
);
2730 /* Set designation state into CODING. Set CHARS_96 to -1 if the
2731 escape sequence should be kept. */
2732 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
2736 if (final < '0' || final >= 128 \
2737 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
2738 || !SAFE_CHARSET_P (coding, id)) \
2740 CODING_ISO_DESIGNATION (coding, reg) = -2; \
2744 prev = CODING_ISO_DESIGNATION (coding, reg); \
2745 if (id == charset_jisx0201_roman) \
2747 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
2748 id = charset_ascii; \
2750 else if (id == charset_jisx0208_1978) \
2752 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
2753 id = charset_jisx0208; \
2755 CODING_ISO_DESIGNATION (coding, reg) = id; \
2756 /* If there was an invalid designation to REG previously, and this \
2757 designation is ASCII to REG, we should keep this designation \
2759 if (prev == -2 && id == charset_ascii) \
2764 #define MAYBE_FINISH_COMPOSITION() \
2767 if (composition_state == COMPOSING_NO) \
2769 /* It is assured that we have enough room for producing \
2770 characters stored in the table `components'. */ \
2771 if (charbuf + component_idx > charbuf_end) \
2772 goto no_more_source; \
2773 composition_state = COMPOSING_NO; \
2774 if (method == COMPOSITION_RELATIVE \
2775 || method == COMPOSITION_WITH_ALTCHARS) \
2777 for (i = 0; i < component_idx; i++) \
2778 *charbuf++ = components[i]; \
2779 char_offset += component_idx; \
2783 for (i = 0; i < component_idx; i += 2) \
2784 *charbuf++ = components[i]; \
2785 char_offset += (component_idx / 2) + 1; \
2790 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
2791 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
2792 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
2793 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
2794 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
2797 #define DECODE_COMPOSITION_START(c1) \
2800 && composition_state == COMPOSING_COMPONENT_RULE) \
2802 component_len = component_idx; \
2803 composition_state = COMPOSING_CHAR; \
2807 const unsigned char *p; \
2809 MAYBE_FINISH_COMPOSITION (); \
2810 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
2811 goto no_more_source; \
2812 for (p = src; p < src_end - 1; p++) \
2813 if (*p == ISO_CODE_ESC && p[1] == '1') \
2815 if (p == src_end - 1) \
2817 if (coding->mode & CODING_MODE_LAST_BLOCK) \
2818 goto invalid_code; \
2819 goto no_more_source; \
2822 /* This is surely the start of a composition. */ \
2823 method = (c1 == '0' ? COMPOSITION_RELATIVE \
2824 : c1 == '2' ? COMPOSITION_WITH_RULE \
2825 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
2826 : COMPOSITION_WITH_RULE_ALTCHARS); \
2827 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
2828 : COMPOSING_COMPONENT_CHAR); \
2829 component_idx = component_len = 0; \
2834 /* Handle compositoin end sequence ESC 1. */
2836 #define DECODE_COMPOSITION_END() \
2838 int nchars = (component_len > 0 ? component_idx - component_len \
2839 : method == COMPOSITION_RELATIVE ? component_idx \
2840 : (component_idx + 1) / 2); \
2842 int *saved_charbuf = charbuf; \
2844 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
2845 if (method != COMPOSITION_RELATIVE) \
2847 if (component_len == 0) \
2848 for (i = 0; i < component_idx; i++) \
2849 *charbuf++ = components[i]; \
2851 for (i = 0; i < component_len; i++) \
2852 *charbuf++ = components[i]; \
2853 *saved_charbuf = saved_charbuf - charbuf; \
2855 if (method == COMPOSITION_WITH_RULE) \
2856 for (i = 0; i < component_idx; i += 2, char_offset++) \
2857 *charbuf++ = components[i]; \
2859 for (i = component_len; i < component_idx; i++, char_offset++) \
2860 *charbuf++ = components[i]; \
2861 coding->annotated = 1; \
2862 composition_state = COMPOSING_NO; \
2866 /* Decode a composition rule from the byte C1 (and maybe one more byte
2867 from SRC) and store one encoded composition rule in
2868 coding->cmp_data. */
2870 #define DECODE_COMPOSITION_RULE(c1) \
2873 if (c1 < 81) /* old format (before ver.21) */ \
2875 int gref = (c1) / 9; \
2876 int nref = (c1) % 9; \
2877 if (gref == 4) gref = 10; \
2878 if (nref == 4) nref = 10; \
2879 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
2881 else if (c1 < 93) /* new format (after ver.21) */ \
2883 ONE_MORE_BYTE (c2); \
2884 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
2891 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2894 decode_coding_iso_2022 (coding
)
2895 struct coding_system
*coding
;
2897 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2898 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2899 const unsigned char *src_base
;
2900 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2902 = coding
->charbuf
+ coding
->charbuf_size
- 4 - MAX_ANNOTATION_LENGTH
;
2903 int consumed_chars
= 0, consumed_chars_base
;
2904 int multibytep
= coding
->src_multibyte
;
2905 /* Charsets invoked to graphic plane 0 and 1 respectively. */
2906 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
2907 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
2908 int charset_id_2
, charset_id_3
;
2909 struct charset
*charset
;
2911 /* For handling composition sequence. */
2912 #define COMPOSING_NO 0
2913 #define COMPOSING_CHAR 1
2914 #define COMPOSING_RULE 2
2915 #define COMPOSING_COMPONENT_CHAR 3
2916 #define COMPOSING_COMPONENT_RULE 4
2918 int composition_state
= COMPOSING_NO
;
2919 enum composition_method method
;
2920 int components
[MAX_COMPOSITION_COMPONENTS
* 2 + 1];
2923 Lisp_Object attrs
, charset_list
;
2924 int char_offset
= coding
->produced_char
;
2925 int last_offset
= char_offset
;
2926 int last_id
= charset_ascii
;
2928 CODING_GET_INFO (coding
, attrs
, charset_list
);
2929 setup_iso_safe_charsets (attrs
);
2936 consumed_chars_base
= consumed_chars
;
2938 if (charbuf
>= charbuf_end
)
2945 /* We produce at most one character. */
2946 switch (iso_code_class
[c1
])
2948 case ISO_0x20_or_0x7F
:
2949 if (composition_state
!= COMPOSING_NO
)
2951 if (composition_state
== COMPOSING_RULE
2952 || composition_state
== COMPOSING_COMPONENT_RULE
)
2954 DECODE_COMPOSITION_RULE (c1
);
2955 components
[component_idx
++] = c1
;
2956 composition_state
--;
2960 if (charset_id_0
< 0
2961 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
2962 /* This is SPACE or DEL. */
2963 charset
= CHARSET_FROM_ID (charset_ascii
);
2965 charset
= CHARSET_FROM_ID (charset_id_0
);
2968 case ISO_graphic_plane_0
:
2969 if (composition_state
!= COMPOSING_NO
)
2971 if (composition_state
== COMPOSING_RULE
2972 || composition_state
== COMPOSING_COMPONENT_RULE
)
2974 DECODE_COMPOSITION_RULE (c1
);
2975 components
[component_idx
++] = c1
;
2976 composition_state
--;
2980 if (charset_id_0
< 0)
2981 charset
= CHARSET_FROM_ID (charset_ascii
);
2983 charset
= CHARSET_FROM_ID (charset_id_0
);
2986 case ISO_0xA0_or_0xFF
:
2987 if (charset_id_1
< 0
2988 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
2989 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
2991 /* This is a graphic character, we fall down ... */
2993 case ISO_graphic_plane_1
:
2994 if (charset_id_1
< 0)
2996 charset
= CHARSET_FROM_ID (charset_id_1
);
3000 MAYBE_FINISH_COMPOSITION ();
3001 charset
= CHARSET_FROM_ID (charset_ascii
);
3005 MAYBE_FINISH_COMPOSITION ();
3009 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3010 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3012 CODING_ISO_INVOCATION (coding
, 0) = 1;
3013 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3017 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3019 CODING_ISO_INVOCATION (coding
, 0) = 0;
3020 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3023 case ISO_single_shift_2_7
:
3024 case ISO_single_shift_2
:
3025 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3027 /* SS2 is handled as an escape sequence of ESC 'N' */
3029 goto label_escape_sequence
;
3031 case ISO_single_shift_3
:
3032 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3034 /* SS2 is handled as an escape sequence of ESC 'O' */
3036 goto label_escape_sequence
;
3038 case ISO_control_sequence_introducer
:
3039 /* CSI is handled as an escape sequence of ESC '[' ... */
3041 goto label_escape_sequence
;
3045 label_escape_sequence
:
3046 /* Escape sequences handled here are invocation,
3047 designation, direction specification, and character
3048 composition specification. */
3051 case '&': /* revision of following character set */
3053 if (!(c1
>= '@' && c1
<= '~'))
3056 if (c1
!= ISO_CODE_ESC
)
3059 goto label_escape_sequence
;
3061 case '$': /* designation of 2-byte character set */
3062 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3068 if (c1
>= '@' && c1
<= 'B')
3069 { /* designation of JISX0208.1978, GB2312.1980,
3071 reg
= 0, chars96
= 0;
3073 else if (c1
>= 0x28 && c1
<= 0x2B)
3074 { /* designation of DIMENSION2_CHARS94 character set */
3075 reg
= c1
- 0x28, chars96
= 0;
3078 else if (c1
>= 0x2C && c1
<= 0x2F)
3079 { /* designation of DIMENSION2_CHARS96 character set */
3080 reg
= c1
- 0x2C, chars96
= 1;
3085 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3086 /* We must update these variables now. */
3088 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3090 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3096 case 'n': /* invocation of locking-shift-2 */
3097 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3098 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3100 CODING_ISO_INVOCATION (coding
, 0) = 2;
3101 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3104 case 'o': /* invocation of locking-shift-3 */
3105 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3106 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3108 CODING_ISO_INVOCATION (coding
, 0) = 3;
3109 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3112 case 'N': /* invocation of single-shift-2 */
3113 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3114 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3116 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3117 if (charset_id_2
< 0)
3118 charset
= CHARSET_FROM_ID (charset_ascii
);
3120 charset
= CHARSET_FROM_ID (charset_id_2
);
3122 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3126 case 'O': /* invocation of single-shift-3 */
3127 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3128 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3130 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3131 if (charset_id_3
< 0)
3132 charset
= CHARSET_FROM_ID (charset_ascii
);
3134 charset
= CHARSET_FROM_ID (charset_id_3
);
3136 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3140 case '0': case '2': case '3': case '4': /* start composition */
3141 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3143 DECODE_COMPOSITION_START (c1
);
3146 case '1': /* end composition */
3147 if (composition_state
== COMPOSING_NO
)
3149 DECODE_COMPOSITION_END ();
3152 case '[': /* specification of direction */
3153 if (! CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
)
3155 /* For the moment, nested direction is not supported.
3156 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3157 left-to-right, and nozero means right-to-left. */
3161 case ']': /* end of the current direction */
3162 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3164 case '0': /* end of the current direction */
3165 case '1': /* start of left-to-right direction */
3168 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3173 case '2': /* start of right-to-left direction */
3176 coding
->mode
|= CODING_MODE_DIRECTION
;
3190 /* CTEXT extended segment:
3191 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3192 We keep these bytes as is for the moment.
3193 They may be decoded by post-read-conversion. */
3197 ONE_MORE_BYTE (dim
);
3200 size
= ((M
- 128) * 128) + (L
- 128);
3201 if (charbuf
+ 8 + size
> charbuf_end
)
3203 *charbuf
++ = ISO_CODE_ESC
;
3207 *charbuf
++ = BYTE8_TO_CHAR (M
);
3208 *charbuf
++ = BYTE8_TO_CHAR (L
);
3212 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3217 /* XFree86 extension for embedding UTF-8 in CTEXT:
3218 ESC % G --UTF-8-BYTES-- ESC % @
3219 We keep these bytes as is for the moment.
3220 They may be decoded by post-read-conversion. */
3223 if (p
+ 6 > charbuf_end
)
3225 *p
++ = ISO_CODE_ESC
;
3228 while (p
< charbuf_end
)
3231 if (c1
== ISO_CODE_ESC
3232 && src
+ 1 < src_end
3239 *p
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3241 if (p
+ 3 > charbuf_end
)
3243 *p
++ = ISO_CODE_ESC
;
3254 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3259 if (c1
>= 0x28 && c1
<= 0x2B)
3260 { /* designation of DIMENSION1_CHARS94 character set */
3261 reg
= c1
- 0x28, chars96
= 0;
3264 else if (c1
>= 0x2C && c1
<= 0x2F)
3265 { /* designation of DIMENSION1_CHARS96 character set */
3266 reg
= c1
- 0x2C, chars96
= 1;
3271 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3272 /* We must update these variables now. */
3274 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3276 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3284 if (charset
->id
!= charset_ascii
3285 && last_id
!= charset
->id
)
3287 if (last_id
!= charset_ascii
)
3288 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3289 last_id
= charset
->id
;
3290 last_offset
= char_offset
;
3293 /* Now we know CHARSET and 1st position code C1 of a character.
3294 Produce a decoded character while getting 2nd position code
3297 if (CHARSET_DIMENSION (charset
) > 1)
3300 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3301 /* C2 is not in a valid range. */
3303 c1
= (c1
<< 8) | (c2
& 0x7F);
3304 if (CHARSET_DIMENSION (charset
) > 2)
3307 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3308 /* C2 is not in a valid range. */
3310 c1
= (c1
<< 8) | (c2
& 0x7F);
3314 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3317 MAYBE_FINISH_COMPOSITION ();
3318 for (; src_base
< src
; src_base
++, char_offset
++)
3320 if (ASCII_BYTE_P (*src_base
))
3321 *charbuf
++ = *src_base
;
3323 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3326 else if (composition_state
== COMPOSING_NO
)
3333 components
[component_idx
++] = c
;
3334 if (method
== COMPOSITION_WITH_RULE
3335 || (method
== COMPOSITION_WITH_RULE_ALTCHARS
3336 && composition_state
== COMPOSING_COMPONENT_CHAR
))
3337 composition_state
++;
3342 MAYBE_FINISH_COMPOSITION ();
3344 consumed_chars
= consumed_chars_base
;
3346 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3356 if (last_id
!= charset_ascii
)
3357 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3358 coding
->consumed_char
+= consumed_chars_base
;
3359 coding
->consumed
= src_base
- coding
->source
;
3360 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3364 /* ISO2022 encoding stuff. */
3367 It is not enough to say just "ISO2022" on encoding, we have to
3368 specify more details. In Emacs, each coding system of ISO2022
3369 variant has the following specifications:
3370 1. Initial designation to G0 thru G3.
3371 2. Allows short-form designation?
3372 3. ASCII should be designated to G0 before control characters?
3373 4. ASCII should be designated to G0 at end of line?
3374 5. 7-bit environment or 8-bit environment?
3375 6. Use locking-shift?
3376 7. Use Single-shift?
3377 And the following two are only for Japanese:
3378 8. Use ASCII in place of JIS0201-1976-Roman?
3379 9. Use JISX0208-1983 in place of JISX0208-1978?
3380 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3381 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3385 /* Produce codes (escape sequence) for designating CHARSET to graphic
3386 register REG at DST, and increment DST. If <final-char> of CHARSET is
3387 '@', 'A', or 'B' and the coding system CODING allows, produce
3388 designation sequence of short-form. */
3390 #define ENCODE_DESIGNATION(charset, reg, coding) \
3392 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3393 char *intermediate_char_94 = "()*+"; \
3394 char *intermediate_char_96 = ",-./"; \
3395 int revision = -1; \
3398 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3399 revision = CHARSET_ISO_REVISION (charset); \
3401 if (revision >= 0) \
3403 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3404 EMIT_ONE_BYTE ('@' + revision); \
3406 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3407 if (CHARSET_DIMENSION (charset) == 1) \
3409 if (! CHARSET_ISO_CHARS_96 (charset)) \
3410 c = intermediate_char_94[reg]; \
3412 c = intermediate_char_96[reg]; \
3413 EMIT_ONE_ASCII_BYTE (c); \
3417 EMIT_ONE_ASCII_BYTE ('$'); \
3418 if (! CHARSET_ISO_CHARS_96 (charset)) \
3420 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3422 || final_char < '@' || final_char > 'B') \
3423 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3426 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3428 EMIT_ONE_ASCII_BYTE (final_char); \
3430 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3434 /* The following two macros produce codes (control character or escape
3435 sequence) for ISO2022 single-shift functions (single-shift-2 and
3438 #define ENCODE_SINGLE_SHIFT_2 \
3440 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3441 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3443 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3444 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3448 #define ENCODE_SINGLE_SHIFT_3 \
3450 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3451 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3453 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3454 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3458 /* The following four macros produce codes (control character or
3459 escape sequence) for ISO2022 locking-shift functions (shift-in,
3460 shift-out, locking-shift-2, and locking-shift-3). */
3462 #define ENCODE_SHIFT_IN \
3464 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3465 CODING_ISO_INVOCATION (coding, 0) = 0; \
3469 #define ENCODE_SHIFT_OUT \
3471 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3472 CODING_ISO_INVOCATION (coding, 0) = 1; \
3476 #define ENCODE_LOCKING_SHIFT_2 \
3478 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3479 CODING_ISO_INVOCATION (coding, 0) = 2; \
3483 #define ENCODE_LOCKING_SHIFT_3 \
3485 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3486 CODING_ISO_INVOCATION (coding, 0) = 3; \
3490 /* Produce codes for a DIMENSION1 character whose character set is
3491 CHARSET and whose position-code is C1. Designation and invocation
3492 sequences are also produced in advance if necessary. */
3494 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3496 int id = CHARSET_ID (charset); \
3498 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3499 && id == charset_ascii) \
3501 id = charset_jisx0201_roman; \
3502 charset = CHARSET_FROM_ID (id); \
3505 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3507 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3508 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3510 EMIT_ONE_BYTE (c1 | 0x80); \
3511 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3514 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3516 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3519 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3521 EMIT_ONE_BYTE (c1 | 0x80); \
3525 /* Since CHARSET is not yet invoked to any graphic planes, we \
3526 must invoke it, or, at first, designate it to some graphic \
3527 register. Then repeat the loop to actually produce the \
3529 dst = encode_invocation_designation (charset, coding, dst, \
3534 /* Produce codes for a DIMENSION2 character whose character set is
3535 CHARSET and whose position-codes are C1 and C2. Designation and
3536 invocation codes are also produced in advance if necessary. */
3538 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3540 int id = CHARSET_ID (charset); \
3542 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3543 && id == charset_jisx0208) \
3545 id = charset_jisx0208_1978; \
3546 charset = CHARSET_FROM_ID (id); \
3549 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3551 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3552 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3554 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3555 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3558 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3560 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3563 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3565 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3569 /* Since CHARSET is not yet invoked to any graphic planes, we \
3570 must invoke it, or, at first, designate it to some graphic \
3571 register. Then repeat the loop to actually produce the \
3573 dst = encode_invocation_designation (charset, coding, dst, \
3578 #define ENCODE_ISO_CHARACTER(charset, c) \
3580 int code = ENCODE_CHAR ((charset),(c)); \
3582 if (CHARSET_DIMENSION (charset) == 1) \
3583 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3585 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
3589 /* Produce designation and invocation codes at a place pointed by DST
3590 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
3594 encode_invocation_designation (charset
, coding
, dst
, p_nchars
)
3595 struct charset
*charset
;
3596 struct coding_system
*coding
;
3600 int multibytep
= coding
->dst_multibyte
;
3601 int produced_chars
= *p_nchars
;
3602 int reg
; /* graphic register number */
3603 int id
= CHARSET_ID (charset
);
3605 /* At first, check designations. */
3606 for (reg
= 0; reg
< 4; reg
++)
3607 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
3612 /* CHARSET is not yet designated to any graphic registers. */
3613 /* At first check the requested designation. */
3614 reg
= CODING_ISO_REQUEST (coding
, id
);
3616 /* Since CHARSET requests no special designation, designate it
3617 to graphic register 0. */
3620 ENCODE_DESIGNATION (charset
, reg
, coding
);
3623 if (CODING_ISO_INVOCATION (coding
, 0) != reg
3624 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
3626 /* Since the graphic register REG is not invoked to any graphic
3627 planes, invoke it to graphic plane 0. */
3630 case 0: /* graphic register 0 */
3634 case 1: /* graphic register 1 */
3638 case 2: /* graphic register 2 */
3639 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3640 ENCODE_SINGLE_SHIFT_2
;
3642 ENCODE_LOCKING_SHIFT_2
;
3645 case 3: /* graphic register 3 */
3646 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3647 ENCODE_SINGLE_SHIFT_3
;
3649 ENCODE_LOCKING_SHIFT_3
;
3654 *p_nchars
= produced_chars
;
3658 /* The following three macros produce codes for indicating direction
3660 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
3662 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
3663 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
3665 EMIT_ONE_BYTE (ISO_CODE_CSI); \
3669 #define ENCODE_DIRECTION_R2L() \
3671 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3672 EMIT_TWO_ASCII_BYTES ('2', ']'); \
3676 #define ENCODE_DIRECTION_L2R() \
3678 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3679 EMIT_TWO_ASCII_BYTES ('0', ']'); \
3683 /* Produce codes for designation and invocation to reset the graphic
3684 planes and registers to initial state. */
3685 #define ENCODE_RESET_PLANE_AND_REGISTER() \
3688 struct charset *charset; \
3690 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
3692 for (reg = 0; reg < 4; reg++) \
3693 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
3694 && (CODING_ISO_DESIGNATION (coding, reg) \
3695 != CODING_ISO_INITIAL (coding, reg))) \
3697 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
3698 ENCODE_DESIGNATION (charset, reg, coding); \
3703 /* Produce designation sequences of charsets in the line started from
3704 SRC to a place pointed by DST, and return updated DST.
3706 If the current block ends before any end-of-line, we may fail to
3707 find all the necessary designations. */
3709 static unsigned char *
3710 encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
)
3711 struct coding_system
*coding
;
3712 int *charbuf
, *charbuf_end
;
3715 struct charset
*charset
;
3716 /* Table of charsets to be designated to each graphic register. */
3718 int c
, found
= 0, reg
;
3719 int produced_chars
= 0;
3720 int multibytep
= coding
->dst_multibyte
;
3722 Lisp_Object charset_list
;
3724 attrs
= CODING_ID_ATTRS (coding
->id
);
3725 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3726 if (EQ (charset_list
, Qiso_2022
))
3727 charset_list
= Viso_2022_charset_list
;
3729 for (reg
= 0; reg
< 4; reg
++)
3739 charset
= char_charset (c
, charset_list
, NULL
);
3740 id
= CHARSET_ID (charset
);
3741 reg
= CODING_ISO_REQUEST (coding
, id
);
3742 if (reg
>= 0 && r
[reg
] < 0)
3751 for (reg
= 0; reg
< 4; reg
++)
3753 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
3754 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
3760 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
3763 encode_coding_iso_2022 (coding
)
3764 struct coding_system
*coding
;
3766 int multibytep
= coding
->dst_multibyte
;
3767 int *charbuf
= coding
->charbuf
;
3768 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
3769 unsigned char *dst
= coding
->destination
+ coding
->produced
;
3770 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
3773 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
3774 && CODING_ISO_BOL (coding
));
3775 int produced_chars
= 0;
3776 Lisp_Object attrs
, eol_type
, charset_list
;
3777 int ascii_compatible
;
3779 int preferred_charset_id
= -1;
3781 CODING_GET_INFO (coding
, attrs
, charset_list
);
3782 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
3783 if (VECTORP (eol_type
))
3786 setup_iso_safe_charsets (attrs
);
3787 /* Charset list may have been changed. */
3788 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
); \
3789 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
3791 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
3793 while (charbuf
< charbuf_end
)
3795 ASSURE_DESTINATION (safe_room
);
3797 if (bol_designation
)
3799 unsigned char *dst_prev
= dst
;
3801 /* We have to produce designation sequences if any now. */
3802 dst
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
);
3803 bol_designation
= 0;
3804 /* We are sure that designation sequences are all ASCII bytes. */
3805 produced_chars
+= dst
- dst_prev
;
3812 /* Handle an annotation. */
3815 case CODING_ANNOTATE_COMPOSITION_MASK
:
3816 /* Not yet implemented. */
3818 case CODING_ANNOTATE_CHARSET_MASK
:
3819 preferred_charset_id
= charbuf
[3];
3820 if (preferred_charset_id
>= 0
3821 && NILP (Fmemq (make_number (preferred_charset_id
),
3823 preferred_charset_id
= -1;
3832 /* Now encode the character C. */
3833 if (c
< 0x20 || c
== 0x7F)
3836 || (c
== '\r' && EQ (eol_type
, Qmac
)))
3838 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3839 ENCODE_RESET_PLANE_AND_REGISTER ();
3840 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
3844 for (i
= 0; i
< 4; i
++)
3845 CODING_ISO_DESIGNATION (coding
, i
)
3846 = CODING_ISO_INITIAL (coding
, i
);
3849 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
3851 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
3852 ENCODE_RESET_PLANE_AND_REGISTER ();
3853 EMIT_ONE_ASCII_BYTE (c
);
3855 else if (ASCII_CHAR_P (c
))
3857 if (ascii_compatible
)
3858 EMIT_ONE_ASCII_BYTE (c
);
3861 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
3862 ENCODE_ISO_CHARACTER (charset
, c
);
3865 else if (CHAR_BYTE8_P (c
))
3867 c
= CHAR_TO_BYTE8 (c
);
3872 struct charset
*charset
;
3874 if (preferred_charset_id
>= 0)
3876 charset
= CHARSET_FROM_ID (preferred_charset_id
);
3877 if (! CHAR_CHARSET_P (c
, charset
))
3878 charset
= char_charset (c
, charset_list
, NULL
);
3881 charset
= char_charset (c
, charset_list
, NULL
);
3884 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
3886 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
3887 charset
= CHARSET_FROM_ID (charset_ascii
);
3891 c
= coding
->default_char
;
3892 charset
= char_charset (c
, charset_list
, NULL
);
3895 ENCODE_ISO_CHARACTER (charset
, c
);
3899 if (coding
->mode
& CODING_MODE_LAST_BLOCK
3900 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3902 ASSURE_DESTINATION (safe_room
);
3903 ENCODE_RESET_PLANE_AND_REGISTER ();
3905 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
3906 CODING_ISO_BOL (coding
) = bol_designation
;
3907 coding
->produced_char
+= produced_chars
;
3908 coding
->produced
= dst
- coding
->destination
;
3913 /*** 8,9. SJIS and BIG5 handlers ***/
3915 /* Although SJIS and BIG5 are not ISO's coding system, they are used
3916 quite widely. So, for the moment, Emacs supports them in the bare
3917 C code. But, in the future, they may be supported only by CCL. */
3919 /* SJIS is a coding system encoding three character sets: ASCII, right
3920 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
3921 as is. A character of charset katakana-jisx0201 is encoded by
3922 "position-code + 0x80". A character of charset japanese-jisx0208
3923 is encoded in 2-byte but two position-codes are divided and shifted
3924 so that it fit in the range below.
3926 --- CODE RANGE of SJIS ---
3927 (character set) (range)
3929 KATAKANA-JISX0201 0xA0 .. 0xDF
3930 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
3931 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
3932 -------------------------------
3936 /* BIG5 is a coding system encoding two character sets: ASCII and
3937 Big5. An ASCII character is encoded as is. Big5 is a two-byte
3938 character set and is encoded in two-byte.
3940 --- CODE RANGE of BIG5 ---
3941 (character set) (range)
3943 Big5 (1st byte) 0xA1 .. 0xFE
3944 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
3945 --------------------------
3949 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3950 Check if a text is encoded in SJIS. If it is, return
3951 CATEGORY_MASK_SJIS, else return 0. */
3954 detect_coding_sjis (coding
, detect_info
)
3955 struct coding_system
*coding
;
3956 struct coding_detection_info
*detect_info
;
3958 const unsigned char *src
= coding
->source
, *src_base
;
3959 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3960 int multibytep
= coding
->src_multibyte
;
3961 int consumed_chars
= 0;
3965 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
3966 /* A coding system of this category is always ASCII compatible. */
3967 src
+= coding
->head_ascii
;
3975 if ((c
>= 0x81 && c
<= 0x9F) || (c
>= 0xE0 && c
<= 0xEF))
3978 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
3980 found
= CATEGORY_MASK_SJIS
;
3982 else if (c
>= 0xA0 && c
< 0xE0)
3983 found
= CATEGORY_MASK_SJIS
;
3987 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3991 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
3993 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3996 detect_info
->found
|= found
;
4000 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4001 Check if a text is encoded in BIG5. If it is, return
4002 CATEGORY_MASK_BIG5, else return 0. */
4005 detect_coding_big5 (coding
, detect_info
)
4006 struct coding_system
*coding
;
4007 struct coding_detection_info
*detect_info
;
4009 const unsigned char *src
= coding
->source
, *src_base
;
4010 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4011 int multibytep
= coding
->src_multibyte
;
4012 int consumed_chars
= 0;
4016 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4017 /* A coding system of this category is always ASCII compatible. */
4018 src
+= coding
->head_ascii
;
4029 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4031 found
= CATEGORY_MASK_BIG5
;
4036 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4040 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4042 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4045 detect_info
->found
|= found
;
4049 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4050 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4053 decode_coding_sjis (coding
)
4054 struct coding_system
*coding
;
4056 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4057 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4058 const unsigned char *src_base
;
4059 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4061 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4062 int consumed_chars
= 0, consumed_chars_base
;
4063 int multibytep
= coding
->src_multibyte
;
4064 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4065 struct charset
*charset_kanji2
;
4066 Lisp_Object attrs
, charset_list
, val
;
4067 int char_offset
= coding
->produced_char
;
4068 int last_offset
= char_offset
;
4069 int last_id
= charset_ascii
;
4071 CODING_GET_INFO (coding
, attrs
, charset_list
);
4074 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4075 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4076 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4077 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4082 struct charset
*charset
;
4085 consumed_chars_base
= consumed_chars
;
4087 if (charbuf
>= charbuf_end
)
4094 charset
= charset_roman
;
4095 else if (c
== 0x80 || c
== 0xA0)
4097 else if (c
>= 0xA1 && c
<= 0xDF)
4099 /* SJIS -> JISX0201-Kana */
4101 charset
= charset_kana
;
4105 /* SJIS -> JISX0208 */
4107 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4111 charset
= charset_kanji
;
4113 else if (c
<= 0xFC && charset_kanji2
)
4115 /* SJIS -> JISX0213-2 */
4117 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4121 charset
= charset_kanji2
;
4125 if (charset
->id
!= charset_ascii
4126 && last_id
!= charset
->id
)
4128 if (last_id
!= charset_ascii
)
4129 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4130 last_id
= charset
->id
;
4131 last_offset
= char_offset
;
4133 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4140 consumed_chars
= consumed_chars_base
;
4142 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4148 if (last_id
!= charset_ascii
)
4149 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4150 coding
->consumed_char
+= consumed_chars_base
;
4151 coding
->consumed
= src_base
- coding
->source
;
4152 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4156 decode_coding_big5 (coding
)
4157 struct coding_system
*coding
;
4159 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4160 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4161 const unsigned char *src_base
;
4162 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4164 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4165 int consumed_chars
= 0, consumed_chars_base
;
4166 int multibytep
= coding
->src_multibyte
;
4167 struct charset
*charset_roman
, *charset_big5
;
4168 Lisp_Object attrs
, charset_list
, val
;
4169 int char_offset
= coding
->produced_char
;
4170 int last_offset
= char_offset
;
4171 int last_id
= charset_ascii
;
4173 CODING_GET_INFO (coding
, attrs
, charset_list
);
4175 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4176 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4181 struct charset
*charset
;
4184 consumed_chars_base
= consumed_chars
;
4186 if (charbuf
>= charbuf_end
)
4194 charset
= charset_roman
;
4198 if (c
< 0xA1 || c
> 0xFE)
4201 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4204 charset
= charset_big5
;
4206 if (charset
->id
!= charset_ascii
4207 && last_id
!= charset
->id
)
4209 if (last_id
!= charset_ascii
)
4210 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4211 last_id
= charset
->id
;
4212 last_offset
= char_offset
;
4214 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4221 consumed_chars
= consumed_chars_base
;
4223 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4229 if (last_id
!= charset_ascii
)
4230 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4231 coding
->consumed_char
+= consumed_chars_base
;
4232 coding
->consumed
= src_base
- coding
->source
;
4233 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4236 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4237 This function can encode charsets `ascii', `katakana-jisx0201',
4238 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4239 are sure that all these charsets are registered as official charset
4240 (i.e. do not have extended leading-codes). Characters of other
4241 charsets are produced without any encoding. If SJIS_P is 1, encode
4242 SJIS text, else encode BIG5 text. */
4245 encode_coding_sjis (coding
)
4246 struct coding_system
*coding
;
4248 int multibytep
= coding
->dst_multibyte
;
4249 int *charbuf
= coding
->charbuf
;
4250 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4251 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4252 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4254 int produced_chars
= 0;
4255 Lisp_Object attrs
, charset_list
, val
;
4256 int ascii_compatible
;
4257 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4258 struct charset
*charset_kanji2
;
4261 CODING_GET_INFO (coding
, attrs
, charset_list
);
4263 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4264 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4265 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4266 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4268 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4270 while (charbuf
< charbuf_end
)
4272 ASSURE_DESTINATION (safe_room
);
4274 /* Now encode the character C. */
4275 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4276 EMIT_ONE_ASCII_BYTE (c
);
4277 else if (CHAR_BYTE8_P (c
))
4279 c
= CHAR_TO_BYTE8 (c
);
4285 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4289 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4291 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4292 charset
= CHARSET_FROM_ID (charset_ascii
);
4296 c
= coding
->default_char
;
4297 charset
= char_charset (c
, charset_list
, &code
);
4300 if (code
== CHARSET_INVALID_CODE (charset
))
4302 if (charset
== charset_kanji
)
4306 c1
= code
>> 8, c2
= code
& 0xFF;
4307 EMIT_TWO_BYTES (c1
, c2
);
4309 else if (charset
== charset_kana
)
4310 EMIT_ONE_BYTE (code
| 0x80);
4311 else if (charset_kanji2
&& charset
== charset_kanji2
)
4316 if (c1
== 0x21 || (c1
>= 0x23 && c1
< 0x25)
4317 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4319 JIS_TO_SJIS2 (code
);
4320 c1
= code
>> 8, c2
= code
& 0xFF;
4321 EMIT_TWO_BYTES (c1
, c2
);
4324 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4327 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4330 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4331 coding
->produced_char
+= produced_chars
;
4332 coding
->produced
= dst
- coding
->destination
;
4337 encode_coding_big5 (coding
)
4338 struct coding_system
*coding
;
4340 int multibytep
= coding
->dst_multibyte
;
4341 int *charbuf
= coding
->charbuf
;
4342 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4343 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4344 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4346 int produced_chars
= 0;
4347 Lisp_Object attrs
, charset_list
, val
;
4348 int ascii_compatible
;
4349 struct charset
*charset_roman
, *charset_big5
;
4352 CODING_GET_INFO (coding
, attrs
, charset_list
);
4354 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4355 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4356 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4358 while (charbuf
< charbuf_end
)
4360 ASSURE_DESTINATION (safe_room
);
4362 /* Now encode the character C. */
4363 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4364 EMIT_ONE_ASCII_BYTE (c
);
4365 else if (CHAR_BYTE8_P (c
))
4367 c
= CHAR_TO_BYTE8 (c
);
4373 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4377 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4379 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4380 charset
= CHARSET_FROM_ID (charset_ascii
);
4384 c
= coding
->default_char
;
4385 charset
= char_charset (c
, charset_list
, &code
);
4388 if (code
== CHARSET_INVALID_CODE (charset
))
4390 if (charset
== charset_big5
)
4394 c1
= code
>> 8, c2
= code
& 0xFF;
4395 EMIT_TWO_BYTES (c1
, c2
);
4398 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4401 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4402 coding
->produced_char
+= produced_chars
;
4403 coding
->produced
= dst
- coding
->destination
;
4408 /*** 10. CCL handlers ***/
4410 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4411 Check if a text is encoded in a coding system of which
4412 encoder/decoder are written in CCL program. If it is, return
4413 CATEGORY_MASK_CCL, else return 0. */
4416 detect_coding_ccl (coding
, detect_info
)
4417 struct coding_system
*coding
;
4418 struct coding_detection_info
*detect_info
;
4420 const unsigned char *src
= coding
->source
, *src_base
;
4421 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4422 int multibytep
= coding
->src_multibyte
;
4423 int consumed_chars
= 0;
4425 unsigned char *valids
;
4426 int head_ascii
= coding
->head_ascii
;
4429 detect_info
->checked
|= CATEGORY_MASK_CCL
;
4431 coding
= &coding_categories
[coding_category_ccl
];
4432 valids
= CODING_CCL_VALIDS (coding
);
4433 attrs
= CODING_ID_ATTRS (coding
->id
);
4434 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4443 if (c
< 0 || ! valids
[c
])
4445 if ((valids
[c
] > 1))
4446 found
= CATEGORY_MASK_CCL
;
4448 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
4452 detect_info
->found
|= found
;
4457 decode_coding_ccl (coding
)
4458 struct coding_system
*coding
;
4460 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4461 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4462 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4463 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
4464 int consumed_chars
= 0;
4465 int multibytep
= coding
->src_multibyte
;
4466 struct ccl_program ccl
;
4467 int source_charbuf
[1024];
4468 int source_byteidx
[1024];
4469 Lisp_Object attrs
, charset_list
;
4471 CODING_GET_INFO (coding
, attrs
, charset_list
);
4472 setup_ccl_program (&ccl
, CODING_CCL_DECODER (coding
));
4474 while (src
< src_end
)
4476 const unsigned char *p
= src
;
4477 int *source
, *source_end
;
4481 while (i
< 1024 && p
< src_end
)
4483 source_byteidx
[i
] = p
- src
;
4484 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
4487 while (i
< 1024 && p
< src_end
)
4488 source_charbuf
[i
++] = *p
++;
4490 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4493 source
= source_charbuf
;
4494 source_end
= source
+ i
;
4495 while (source
< source_end
)
4497 ccl_driver (&ccl
, source
, charbuf
,
4498 source_end
- source
, charbuf_end
- charbuf
,
4500 source
+= ccl
.consumed
;
4501 charbuf
+= ccl
.produced
;
4502 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_DST
)
4505 if (source
< source_end
)
4506 src
+= source_byteidx
[source
- source_charbuf
];
4509 consumed_chars
+= source
- source_charbuf
;
4511 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_SRC
4512 && ccl
.status
!= CODING_RESULT_INSUFFICIENT_SRC
)
4518 case CCL_STAT_SUSPEND_BY_SRC
:
4519 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4521 case CCL_STAT_SUSPEND_BY_DST
:
4524 case CCL_STAT_INVALID_CMD
:
4525 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4528 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4531 coding
->consumed_char
+= consumed_chars
;
4532 coding
->consumed
= src
- coding
->source
;
4533 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4537 encode_coding_ccl (coding
)
4538 struct coding_system
*coding
;
4540 struct ccl_program ccl
;
4541 int multibytep
= coding
->dst_multibyte
;
4542 int *charbuf
= coding
->charbuf
;
4543 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4544 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4545 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4546 unsigned char *adjusted_dst_end
= dst_end
- 1;
4547 int destination_charbuf
[1024];
4548 int i
, produced_chars
= 0;
4549 Lisp_Object attrs
, charset_list
;
4551 CODING_GET_INFO (coding
, attrs
, charset_list
);
4552 setup_ccl_program (&ccl
, CODING_CCL_ENCODER (coding
));
4554 ccl
.last_block
= coding
->mode
& CODING_MODE_LAST_BLOCK
;
4555 ccl
.dst_multibyte
= coding
->dst_multibyte
;
4557 while (charbuf
< charbuf_end
&& dst
< adjusted_dst_end
)
4559 int dst_bytes
= dst_end
- dst
;
4560 if (dst_bytes
> 1024)
4563 ccl_driver (&ccl
, charbuf
, destination_charbuf
,
4564 charbuf_end
- charbuf
, dst_bytes
, charset_list
);
4565 charbuf
+= ccl
.consumed
;
4567 for (i
= 0; i
< ccl
.produced
; i
++)
4568 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
4571 for (i
= 0; i
< ccl
.produced
; i
++)
4572 *dst
++ = destination_charbuf
[i
] & 0xFF;
4573 produced_chars
+= ccl
.produced
;
4579 case CCL_STAT_SUSPEND_BY_SRC
:
4580 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4582 case CCL_STAT_SUSPEND_BY_DST
:
4583 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
4586 case CCL_STAT_INVALID_CMD
:
4587 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4590 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4594 coding
->produced_char
+= produced_chars
;
4595 coding
->produced
= dst
- coding
->destination
;
4601 /*** 10, 11. no-conversion handlers ***/
4603 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4606 decode_coding_raw_text (coding
)
4607 struct coding_system
*coding
;
4609 coding
->chars_at_source
= 1;
4610 coding
->consumed_char
= 0;
4611 coding
->consumed
= 0;
4612 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4616 encode_coding_raw_text (coding
)
4617 struct coding_system
*coding
;
4619 int multibytep
= coding
->dst_multibyte
;
4620 int *charbuf
= coding
->charbuf
;
4621 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
4622 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4623 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4624 int produced_chars
= 0;
4629 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
4631 if (coding
->src_multibyte
)
4632 while (charbuf
< charbuf_end
)
4634 ASSURE_DESTINATION (safe_room
);
4636 if (ASCII_CHAR_P (c
))
4637 EMIT_ONE_ASCII_BYTE (c
);
4638 else if (CHAR_BYTE8_P (c
))
4640 c
= CHAR_TO_BYTE8 (c
);
4645 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
4647 CHAR_STRING_ADVANCE (c
, p1
);
4650 EMIT_ONE_BYTE (*p0
);
4656 while (charbuf
< charbuf_end
)
4658 ASSURE_DESTINATION (safe_room
);
4665 if (coding
->src_multibyte
)
4667 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4669 while (charbuf
< charbuf_end
)
4671 ASSURE_DESTINATION (safe_room
);
4673 if (ASCII_CHAR_P (c
))
4675 else if (CHAR_BYTE8_P (c
))
4676 *dst
++ = CHAR_TO_BYTE8 (c
);
4678 CHAR_STRING_ADVANCE (c
, dst
);
4684 ASSURE_DESTINATION (charbuf_end
- charbuf
);
4685 while (charbuf
< charbuf_end
&& dst
< dst_end
)
4686 *dst
++ = *charbuf
++;
4687 produced_chars
= dst
- (coding
->destination
+ coding
->dst_bytes
);
4690 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4691 coding
->produced_char
+= produced_chars
;
4692 coding
->produced
= dst
- coding
->destination
;
4696 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4697 Check if a text is encoded in a charset-based coding system. If it
4698 is, return 1, else return 0. */
4701 detect_coding_charset (coding
, detect_info
)
4702 struct coding_system
*coding
;
4703 struct coding_detection_info
*detect_info
;
4705 const unsigned char *src
= coding
->source
, *src_base
;
4706 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4707 int multibytep
= coding
->src_multibyte
;
4708 int consumed_chars
= 0;
4709 Lisp_Object attrs
, valids
;
4712 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
4714 coding
= &coding_categories
[coding_category_charset
];
4715 attrs
= CODING_ID_ATTRS (coding
->id
);
4716 valids
= AREF (attrs
, coding_attr_charset_valids
);
4718 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4719 src
+= coding
->head_ascii
;
4729 if (NILP (AREF (valids
, c
)))
4732 found
= CATEGORY_MASK_CHARSET
;
4734 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
4738 detect_info
->found
|= found
;
4743 decode_coding_charset (coding
)
4744 struct coding_system
*coding
;
4746 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4747 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4748 const unsigned char *src_base
;
4749 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4751 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4752 int consumed_chars
= 0, consumed_chars_base
;
4753 int multibytep
= coding
->src_multibyte
;
4754 Lisp_Object attrs
, charset_list
, valids
;
4755 int char_offset
= coding
->produced_char
;
4756 int last_offset
= char_offset
;
4757 int last_id
= charset_ascii
;
4759 CODING_GET_INFO (coding
, attrs
, charset_list
);
4760 valids
= AREF (attrs
, coding_attr_charset_valids
);
4766 struct charset
*charset
;
4772 consumed_chars_base
= consumed_chars
;
4774 if (charbuf
>= charbuf_end
)
4782 val
= AREF (valids
, c
);
4787 charset
= CHARSET_FROM_ID (XFASTINT (val
));
4788 dim
= CHARSET_DIMENSION (charset
);
4792 code
= (code
<< 8) | c
;
4795 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
4800 /* VAL is a list of charset IDs. It is assured that the
4801 list is sorted by charset dimensions (smaller one
4805 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
4806 dim
= CHARSET_DIMENSION (charset
);
4810 code
= (code
<< 8) | c
;
4813 CODING_DECODE_CHAR (coding
, src
, src_base
,
4814 src_end
, charset
, code
, c
);
4822 if (charset
->id
!= charset_ascii
4823 && last_id
!= charset
->id
)
4825 if (last_id
!= charset_ascii
)
4826 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4827 last_id
= charset
->id
;
4828 last_offset
= char_offset
;
4837 consumed_chars
= consumed_chars_base
;
4839 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
4845 if (last_id
!= charset_ascii
)
4846 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4847 coding
->consumed_char
+= consumed_chars_base
;
4848 coding
->consumed
= src_base
- coding
->source
;
4849 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4853 encode_coding_charset (coding
)
4854 struct coding_system
*coding
;
4856 int multibytep
= coding
->dst_multibyte
;
4857 int *charbuf
= coding
->charbuf
;
4858 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4859 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4860 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4861 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4862 int produced_chars
= 0;
4863 Lisp_Object attrs
, charset_list
;
4864 int ascii_compatible
;
4867 CODING_GET_INFO (coding
, attrs
, charset_list
);
4868 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4870 while (charbuf
< charbuf_end
)
4872 struct charset
*charset
;
4875 ASSURE_DESTINATION (safe_room
);
4877 if (ascii_compatible
&& ASCII_CHAR_P (c
))
4878 EMIT_ONE_ASCII_BYTE (c
);
4879 else if (CHAR_BYTE8_P (c
))
4881 c
= CHAR_TO_BYTE8 (c
);
4886 charset
= char_charset (c
, charset_list
, &code
);
4889 if (CHARSET_DIMENSION (charset
) == 1)
4890 EMIT_ONE_BYTE (code
);
4891 else if (CHARSET_DIMENSION (charset
) == 2)
4892 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
4893 else if (CHARSET_DIMENSION (charset
) == 3)
4894 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
4896 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
4897 (code
>> 8) & 0xFF, code
& 0xFF);
4901 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4902 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4904 c
= coding
->default_char
;
4910 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4911 coding
->produced_char
+= produced_chars
;
4912 coding
->produced
= dst
- coding
->destination
;
4917 /*** 7. C library functions ***/
4919 /* Setup coding context CODING from information about CODING_SYSTEM.
4920 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
4921 CODING_SYSTEM is invalid, signal an error. */
4924 setup_coding_system (coding_system
, coding
)
4925 Lisp_Object coding_system
;
4926 struct coding_system
*coding
;
4929 Lisp_Object eol_type
;
4930 Lisp_Object coding_type
;
4933 if (NILP (coding_system
))
4934 coding_system
= Qno_conversion
;
4936 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
4938 attrs
= CODING_ID_ATTRS (coding
->id
);
4939 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
4942 coding
->head_ascii
= -1;
4943 coding
->common_flags
4944 = (VECTORP (eol_type
) ? CODING_REQUIRE_DETECTION_MASK
: 0);
4945 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
4946 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
4947 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
4948 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
4949 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
4950 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
4952 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4953 coding
->max_charset_id
= SCHARS (val
) - 1;
4954 coding
->safe_charsets
= (char *) SDATA (val
);
4955 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
4957 coding_type
= CODING_ATTR_TYPE (attrs
);
4958 if (EQ (coding_type
, Qundecided
))
4960 coding
->detector
= NULL
;
4961 coding
->decoder
= decode_coding_raw_text
;
4962 coding
->encoder
= encode_coding_raw_text
;
4963 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
4965 else if (EQ (coding_type
, Qiso_2022
))
4968 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
4970 /* Invoke graphic register 0 to plane 0. */
4971 CODING_ISO_INVOCATION (coding
, 0) = 0;
4972 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
4973 CODING_ISO_INVOCATION (coding
, 1)
4974 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
4975 /* Setup the initial status of designation. */
4976 for (i
= 0; i
< 4; i
++)
4977 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
4978 /* Not single shifting initially. */
4979 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
4980 /* Beginning of buffer should also be regarded as bol. */
4981 CODING_ISO_BOL (coding
) = 1;
4982 coding
->detector
= detect_coding_iso_2022
;
4983 coding
->decoder
= decode_coding_iso_2022
;
4984 coding
->encoder
= encode_coding_iso_2022
;
4985 if (flags
& CODING_ISO_FLAG_SAFE
)
4986 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
4987 coding
->common_flags
4988 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
4989 | CODING_REQUIRE_FLUSHING_MASK
);
4990 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
4991 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
4992 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
4993 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
4994 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
4996 setup_iso_safe_charsets (attrs
);
4997 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4998 coding
->max_charset_id
= SCHARS (val
) - 1;
4999 coding
->safe_charsets
= (char *) SDATA (val
);
5001 CODING_ISO_FLAGS (coding
) = flags
;
5003 else if (EQ (coding_type
, Qcharset
))
5005 coding
->detector
= detect_coding_charset
;
5006 coding
->decoder
= decode_coding_charset
;
5007 coding
->encoder
= encode_coding_charset
;
5008 coding
->common_flags
5009 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5011 else if (EQ (coding_type
, Qutf_8
))
5013 coding
->detector
= detect_coding_utf_8
;
5014 coding
->decoder
= decode_coding_utf_8
;
5015 coding
->encoder
= encode_coding_utf_8
;
5016 coding
->common_flags
5017 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5019 else if (EQ (coding_type
, Qutf_16
))
5021 val
= AREF (attrs
, coding_attr_utf_16_bom
);
5022 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_16_detect_bom
5023 : EQ (val
, Qt
) ? utf_16_with_bom
5024 : utf_16_without_bom
);
5025 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5026 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5027 : utf_16_little_endian
);
5028 CODING_UTF_16_SURROGATE (coding
) = 0;
5029 coding
->detector
= detect_coding_utf_16
;
5030 coding
->decoder
= decode_coding_utf_16
;
5031 coding
->encoder
= encode_coding_utf_16
;
5032 coding
->common_flags
5033 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5034 if (CODING_UTF_16_BOM (coding
) == utf_16_detect_bom
)
5035 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5037 else if (EQ (coding_type
, Qccl
))
5039 coding
->detector
= detect_coding_ccl
;
5040 coding
->decoder
= decode_coding_ccl
;
5041 coding
->encoder
= encode_coding_ccl
;
5042 coding
->common_flags
5043 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5044 | CODING_REQUIRE_FLUSHING_MASK
);
5046 else if (EQ (coding_type
, Qemacs_mule
))
5048 coding
->detector
= detect_coding_emacs_mule
;
5049 coding
->decoder
= decode_coding_emacs_mule
;
5050 coding
->encoder
= encode_coding_emacs_mule
;
5051 coding
->common_flags
5052 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5053 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5054 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5056 Lisp_Object tail
, safe_charsets
;
5057 int max_charset_id
= 0;
5059 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5061 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5062 max_charset_id
= XFASTINT (XCAR (tail
));
5063 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
5065 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5067 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5068 coding
->max_charset_id
= max_charset_id
;
5069 coding
->safe_charsets
= (char *) SDATA (safe_charsets
);
5072 else if (EQ (coding_type
, Qshift_jis
))
5074 coding
->detector
= detect_coding_sjis
;
5075 coding
->decoder
= decode_coding_sjis
;
5076 coding
->encoder
= encode_coding_sjis
;
5077 coding
->common_flags
5078 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5080 else if (EQ (coding_type
, Qbig5
))
5082 coding
->detector
= detect_coding_big5
;
5083 coding
->decoder
= decode_coding_big5
;
5084 coding
->encoder
= encode_coding_big5
;
5085 coding
->common_flags
5086 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5088 else /* EQ (coding_type, Qraw_text) */
5090 coding
->detector
= NULL
;
5091 coding
->decoder
= decode_coding_raw_text
;
5092 coding
->encoder
= encode_coding_raw_text
;
5098 /* Return raw-text or one of its subsidiaries that has the same
5099 eol_type as CODING-SYSTEM. */
5102 raw_text_coding_system (coding_system
)
5103 Lisp_Object coding_system
;
5105 Lisp_Object spec
, attrs
;
5106 Lisp_Object eol_type
, raw_text_eol_type
;
5108 if (NILP (coding_system
))
5110 spec
= CODING_SYSTEM_SPEC (coding_system
);
5111 attrs
= AREF (spec
, 0);
5113 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5114 return coding_system
;
5116 eol_type
= AREF (spec
, 2);
5117 if (VECTORP (eol_type
))
5119 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5120 raw_text_eol_type
= AREF (spec
, 2);
5121 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5122 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5123 : AREF (raw_text_eol_type
, 2));
5127 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5128 does, return one of the subsidiary that has the same eol-spec as
5129 PARENT. Otherwise, return CODING_SYSTEM. */
5132 coding_inherit_eol_type (coding_system
, parent
)
5133 Lisp_Object coding_system
, parent
;
5135 Lisp_Object spec
, eol_type
;
5137 if (NILP (coding_system
))
5138 coding_system
= Qraw_text
;
5139 spec
= CODING_SYSTEM_SPEC (coding_system
);
5140 eol_type
= AREF (spec
, 2);
5141 if (VECTORP (eol_type
)
5144 Lisp_Object parent_spec
;
5145 Lisp_Object parent_eol_type
;
5148 = CODING_SYSTEM_SPEC (buffer_defaults
.buffer_file_coding_system
);
5149 parent_eol_type
= AREF (parent_spec
, 2);
5150 if (EQ (parent_eol_type
, Qunix
))
5151 coding_system
= AREF (eol_type
, 0);
5152 else if (EQ (parent_eol_type
, Qdos
))
5153 coding_system
= AREF (eol_type
, 1);
5154 else if (EQ (parent_eol_type
, Qmac
))
5155 coding_system
= AREF (eol_type
, 2);
5157 return coding_system
;
5160 /* Emacs has a mechanism to automatically detect a coding system if it
5161 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5162 it's impossible to distinguish some coding systems accurately
5163 because they use the same range of codes. So, at first, coding
5164 systems are categorized into 7, those are:
5166 o coding-category-emacs-mule
5168 The category for a coding system which has the same code range
5169 as Emacs' internal format. Assigned the coding-system (Lisp
5170 symbol) `emacs-mule' by default.
5172 o coding-category-sjis
5174 The category for a coding system which has the same code range
5175 as SJIS. Assigned the coding-system (Lisp
5176 symbol) `japanese-shift-jis' by default.
5178 o coding-category-iso-7
5180 The category for a coding system which has the same code range
5181 as ISO2022 of 7-bit environment. This doesn't use any locking
5182 shift and single shift functions. This can encode/decode all
5183 charsets. Assigned the coding-system (Lisp symbol)
5184 `iso-2022-7bit' by default.
5186 o coding-category-iso-7-tight
5188 Same as coding-category-iso-7 except that this can
5189 encode/decode only the specified charsets.
5191 o coding-category-iso-8-1
5193 The category for a coding system which has the same code range
5194 as ISO2022 of 8-bit environment and graphic plane 1 used only
5195 for DIMENSION1 charset. This doesn't use any locking shift
5196 and single shift functions. Assigned the coding-system (Lisp
5197 symbol) `iso-latin-1' by default.
5199 o coding-category-iso-8-2
5201 The category for a coding system which has the same code range
5202 as ISO2022 of 8-bit environment and graphic plane 1 used only
5203 for DIMENSION2 charset. This doesn't use any locking shift
5204 and single shift functions. Assigned the coding-system (Lisp
5205 symbol) `japanese-iso-8bit' by default.
5207 o coding-category-iso-7-else
5209 The category for a coding system which has the same code range
5210 as ISO2022 of 7-bit environemnt but uses locking shift or
5211 single shift functions. Assigned the coding-system (Lisp
5212 symbol) `iso-2022-7bit-lock' by default.
5214 o coding-category-iso-8-else
5216 The category for a coding system which has the same code range
5217 as ISO2022 of 8-bit environemnt but uses locking shift or
5218 single shift functions. Assigned the coding-system (Lisp
5219 symbol) `iso-2022-8bit-ss2' by default.
5221 o coding-category-big5
5223 The category for a coding system which has the same code range
5224 as BIG5. Assigned the coding-system (Lisp symbol)
5225 `cn-big5' by default.
5227 o coding-category-utf-8
5229 The category for a coding system which has the same code range
5230 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
5231 symbol) `utf-8' by default.
5233 o coding-category-utf-16-be
5235 The category for a coding system in which a text has an
5236 Unicode signature (cf. Unicode Standard) in the order of BIG
5237 endian at the head. Assigned the coding-system (Lisp symbol)
5238 `utf-16-be' by default.
5240 o coding-category-utf-16-le
5242 The category for a coding system in which a text has an
5243 Unicode signature (cf. Unicode Standard) in the order of
5244 LITTLE endian at the head. Assigned the coding-system (Lisp
5245 symbol) `utf-16-le' by default.
5247 o coding-category-ccl
5249 The category for a coding system of which encoder/decoder is
5250 written in CCL programs. The default value is nil, i.e., no
5251 coding system is assigned.
5253 o coding-category-binary
5255 The category for a coding system not categorized in any of the
5256 above. Assigned the coding-system (Lisp symbol)
5257 `no-conversion' by default.
5259 Each of them is a Lisp symbol and the value is an actual
5260 `coding-system's (this is also a Lisp symbol) assigned by a user.
5261 What Emacs does actually is to detect a category of coding system.
5262 Then, it uses a `coding-system' assigned to it. If Emacs can't
5263 decide only one possible category, it selects a category of the
5264 highest priority. Priorities of categories are also specified by a
5265 user in a Lisp variable `coding-category-list'.
5269 #define EOL_SEEN_NONE 0
5270 #define EOL_SEEN_LF 1
5271 #define EOL_SEEN_CR 2
5272 #define EOL_SEEN_CRLF 4
5274 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
5275 SOURCE is encoded. If CATEGORY is one of
5276 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5277 two-byte, else they are encoded by one-byte.
5279 Return one of EOL_SEEN_XXX. */
5281 #define MAX_EOL_CHECK_COUNT 3
5284 detect_eol (source
, src_bytes
, category
)
5285 const unsigned char *source
;
5286 EMACS_INT src_bytes
;
5287 enum coding_category category
;
5289 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
5292 int eol_seen
= EOL_SEEN_NONE
;
5294 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
5298 msb
= category
== (coding_category_utf_16_le
5299 | coding_category_utf_16_le_nosig
);
5302 while (src
+ 1 < src_end
)
5305 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
5310 this_eol
= EOL_SEEN_LF
;
5311 else if (src
+ 3 >= src_end
5312 || src
[msb
+ 2] != 0
5313 || src
[lsb
+ 2] != '\n')
5314 this_eol
= EOL_SEEN_CR
;
5316 this_eol
= EOL_SEEN_CRLF
;
5318 if (eol_seen
== EOL_SEEN_NONE
)
5319 /* This is the first end-of-line. */
5320 eol_seen
= this_eol
;
5321 else if (eol_seen
!= this_eol
)
5323 /* The found type is different from what found before. */
5324 eol_seen
= EOL_SEEN_LF
;
5327 if (++total
== MAX_EOL_CHECK_COUNT
)
5335 while (src
< src_end
)
5338 if (c
== '\n' || c
== '\r')
5343 this_eol
= EOL_SEEN_LF
;
5344 else if (src
>= src_end
|| *src
!= '\n')
5345 this_eol
= EOL_SEEN_CR
;
5347 this_eol
= EOL_SEEN_CRLF
, src
++;
5349 if (eol_seen
== EOL_SEEN_NONE
)
5350 /* This is the first end-of-line. */
5351 eol_seen
= this_eol
;
5352 else if (eol_seen
!= this_eol
)
5354 /* The found type is different from what found before. */
5355 eol_seen
= EOL_SEEN_LF
;
5358 if (++total
== MAX_EOL_CHECK_COUNT
)
5368 adjust_coding_eol_type (coding
, eol_seen
)
5369 struct coding_system
*coding
;
5372 Lisp_Object eol_type
;
5374 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5375 if (eol_seen
& EOL_SEEN_LF
)
5377 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
5380 else if (eol_seen
& EOL_SEEN_CRLF
)
5382 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
5385 else if (eol_seen
& EOL_SEEN_CR
)
5387 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
5393 /* Detect how a text specified in CODING is encoded. If a coding
5394 system is detected, update fields of CODING by the detected coding
5398 detect_coding (coding
)
5399 struct coding_system
*coding
;
5401 const unsigned char *src
, *src_end
;
5402 Lisp_Object attrs
, coding_type
;
5404 coding
->consumed
= coding
->consumed_char
= 0;
5405 coding
->produced
= coding
->produced_char
= 0;
5406 coding_set_source (coding
);
5408 src_end
= coding
->source
+ coding
->src_bytes
;
5410 /* If we have not yet decided the text encoding type, detect it
5412 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
5416 for (i
= 0, src
= coding
->source
; src
< src_end
; i
++, src
++)
5419 if (c
& 0x80 || (c
< 0x20 && (c
== ISO_CODE_ESC
5421 || c
== ISO_CODE_SO
)))
5424 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5426 if (coding
->head_ascii
< coding
->src_bytes
)
5428 struct coding_detection_info detect_info
;
5429 enum coding_category category
;
5430 struct coding_system
*this;
5432 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
5433 for (i
= 0; i
< coding_category_raw_text
; i
++)
5435 category
= coding_priorities
[i
];
5436 this = coding_categories
+ category
;
5439 /* No coding system of this category is defined. */
5440 detect_info
.rejected
|= (1 << category
);
5442 else if (category
>= coding_category_raw_text
)
5444 else if (detect_info
.checked
& (1 << category
))
5446 if (detect_info
.found
& (1 << category
))
5449 else if ((*(this->detector
)) (coding
, &detect_info
)
5450 && detect_info
.found
& (1 << category
))
5452 if (category
== coding_category_utf_16_auto
)
5454 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5455 category
= coding_category_utf_16_le
;
5457 category
= coding_category_utf_16_be
;
5462 if (i
< coding_category_raw_text
)
5463 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5464 else if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
5465 setup_coding_system (Qraw_text
, coding
);
5466 else if (detect_info
.rejected
)
5467 for (i
= 0; i
< coding_category_raw_text
; i
++)
5468 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
5470 this = coding_categories
+ coding_priorities
[i
];
5471 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5476 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
5477 == coding_category_utf_16_auto
)
5479 Lisp_Object coding_systems
;
5480 struct coding_detection_info detect_info
;
5483 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_16_bom
);
5484 detect_info
.found
= detect_info
.rejected
= 0;
5485 if (CONSP (coding_systems
)
5486 && detect_coding_utf_16 (coding
, &detect_info
))
5488 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5489 setup_coding_system (XCAR (coding_systems
), coding
);
5490 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
5491 setup_coding_system (XCDR (coding_systems
), coding
);
5499 struct coding_system
*coding
;
5501 Lisp_Object eol_type
;
5502 unsigned char *p
, *pbeg
, *pend
;
5504 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5505 if (EQ (eol_type
, Qunix
))
5508 if (NILP (coding
->dst_object
))
5509 pbeg
= coding
->destination
;
5511 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
5512 pend
= pbeg
+ coding
->produced
;
5514 if (VECTORP (eol_type
))
5516 int eol_seen
= EOL_SEEN_NONE
;
5518 for (p
= pbeg
; p
< pend
; p
++)
5521 eol_seen
|= EOL_SEEN_LF
;
5522 else if (*p
== '\r')
5524 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
5526 eol_seen
|= EOL_SEEN_CRLF
;
5530 eol_seen
|= EOL_SEEN_CR
;
5533 if (eol_seen
!= EOL_SEEN_NONE
5534 && eol_seen
!= EOL_SEEN_LF
5535 && eol_seen
!= EOL_SEEN_CRLF
5536 && eol_seen
!= EOL_SEEN_CR
)
5537 eol_seen
= EOL_SEEN_LF
;
5538 if (eol_seen
!= EOL_SEEN_NONE
)
5539 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
5542 if (EQ (eol_type
, Qmac
))
5544 for (p
= pbeg
; p
< pend
; p
++)
5548 else if (EQ (eol_type
, Qdos
))
5552 if (NILP (coding
->dst_object
))
5554 for (p
= pend
- 2; p
>= pbeg
; p
--)
5557 safe_bcopy ((char *) (p
+ 1), (char *) p
, pend
-- - p
- 1);
5563 for (p
= pend
- 2; p
>= pbeg
; p
--)
5566 int pos_byte
= coding
->dst_pos_byte
+ (p
- pbeg
);
5567 int pos
= BYTE_TO_CHAR (pos_byte
);
5569 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
5573 coding
->produced
-= n
;
5574 coding
->produced_char
-= n
;
5579 /* Return a translation table (or list of them) from coding system
5580 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
5581 decoding (ENCODEP is zero). */
5584 get_translation_table (attrs
, encodep
, max_lookup
)
5586 int encodep
, *max_lookup
;
5588 Lisp_Object standard
, translation_table
;
5592 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
5593 standard
= Vstandard_translation_table_for_encode
;
5595 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
5596 standard
= Vstandard_translation_table_for_decode
;
5597 if (NILP (translation_table
))
5598 translation_table
= standard
;
5601 if (SYMBOLP (translation_table
))
5602 translation_table
= Fget (translation_table
, Qtranslation_table
);
5603 else if (CONSP (translation_table
))
5605 translation_table
= Fcopy_sequence (translation_table
);
5606 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
5607 if (SYMBOLP (XCAR (val
)))
5608 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
5610 if (CHAR_TABLE_P (standard
))
5612 if (CONSP (translation_table
))
5613 translation_table
= nconc2 (translation_table
,
5614 Fcons (standard
, Qnil
));
5616 translation_table
= Fcons (translation_table
,
5617 Fcons (standard
, Qnil
));
5624 if (CHAR_TABLE_P (translation_table
)
5625 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
5627 val
= XCHAR_TABLE (translation_table
)->extras
[1];
5628 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5629 *max_lookup
= XFASTINT (val
);
5631 else if (CONSP (translation_table
))
5633 Lisp_Object tail
, val
;
5635 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
5636 if (CHAR_TABLE_P (XCAR (tail
))
5637 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
5639 val
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
5640 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5641 *max_lookup
= XFASTINT (val
);
5645 return translation_table
;
5648 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
5651 if (CHAR_TABLE_P (table)) \
5653 trans = CHAR_TABLE_REF (table, c); \
5654 if (CHARACTERP (trans)) \
5655 c = XFASTINT (trans), trans = Qnil; \
5657 else if (CONSP (table)) \
5661 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
5662 if (CHAR_TABLE_P (XCAR (tail))) \
5664 trans = CHAR_TABLE_REF (XCAR (tail), c); \
5665 if (CHARACTERP (trans)) \
5666 c = XFASTINT (trans), trans = Qnil; \
5667 else if (! NILP (trans)) \
5675 get_translation (val
, buf
, buf_end
, last_block
, from_nchars
, to_nchars
)
5679 int *from_nchars
, *to_nchars
;
5681 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
5685 Lisp_Object from
, tail
;
5688 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
5693 for (i
= 0; i
< len
; i
++)
5695 if (buf
+ i
== buf_end
)
5701 if (XINT (AREF (from
, i
)) != buf
[i
])
5715 *buf
= XINT (AREF (val
, 0)), *to_nchars
= ASIZE (val
);
5723 produce_chars (coding
, translation_table
, last_block
)
5724 struct coding_system
*coding
;
5725 Lisp_Object translation_table
;
5728 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5729 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5731 int produced_chars
= 0;
5734 if (! coding
->chars_at_source
)
5736 /* Characters are in coding->charbuf. */
5737 int *buf
= coding
->charbuf
;
5738 int *buf_end
= buf
+ coding
->charbuf_used
;
5740 if (BUFFERP (coding
->src_object
)
5741 && EQ (coding
->src_object
, coding
->dst_object
))
5742 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
5744 while (buf
< buf_end
)
5750 int from_nchars
= 1, to_nchars
= 1;
5751 Lisp_Object trans
= Qnil
;
5753 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
5756 trans
= get_translation (trans
, buf
, buf_end
, last_block
,
5757 &from_nchars
, &to_nchars
);
5763 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
5765 dst
= alloc_destination (coding
,
5767 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
5769 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5772 for (i
= 0; i
< to_nchars
; i
++)
5775 c
= XINT (AREF (trans
, i
));
5776 if (coding
->dst_multibyte
5777 || ! CHAR_BYTE8_P (c
))
5778 CHAR_STRING_ADVANCE (c
, dst
);
5780 *dst
++ = CHAR_TO_BYTE8 (c
);
5782 produced_chars
+= to_nchars
;
5784 while (--from_nchars
> 0)
5788 /* This is an annotation datum. (-C) is the length. */
5791 carryover
= buf_end
- buf
;
5795 const unsigned char *src
= coding
->source
;
5796 const unsigned char *src_end
= src
+ coding
->src_bytes
;
5797 Lisp_Object eol_type
;
5799 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5801 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
5803 if (coding
->src_multibyte
)
5810 const unsigned char *src_base
= src
;
5816 if (EQ (eol_type
, Qdos
))
5820 record_conversion_result
5821 (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5822 goto no_more_source
;
5827 else if (EQ (eol_type
, Qmac
))
5832 coding
->consumed
= src
- coding
->source
;
5834 if (EQ (coding
->src_object
, coding
->dst_object
))
5835 dst_end
= (unsigned char *) src
;
5838 dst
= alloc_destination (coding
, src_end
- src
+ 1,
5840 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5841 coding_set_source (coding
);
5842 src
= coding
->source
+ coding
->consumed
;
5843 src_end
= coding
->source
+ coding
->src_bytes
;
5853 while (src
< src_end
)
5860 if (EQ (eol_type
, Qdos
))
5866 else if (EQ (eol_type
, Qmac
))
5869 if (dst
>= dst_end
- 1)
5871 coding
->consumed
= src
- coding
->source
;
5873 if (EQ (coding
->src_object
, coding
->dst_object
))
5874 dst_end
= (unsigned char *) src
;
5875 if (dst
>= dst_end
- 1)
5877 dst
= alloc_destination (coding
, src_end
- src
+ 2,
5879 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5880 coding_set_source (coding
);
5881 src
= coding
->source
+ coding
->consumed
;
5882 src_end
= coding
->source
+ coding
->src_bytes
;
5890 if (!EQ (coding
->src_object
, coding
->dst_object
))
5892 int require
= coding
->src_bytes
- coding
->dst_bytes
;
5896 EMACS_INT offset
= src
- coding
->source
;
5898 dst
= alloc_destination (coding
, require
, dst
);
5899 coding_set_source (coding
);
5900 src
= coding
->source
+ offset
;
5901 src_end
= coding
->source
+ coding
->src_bytes
;
5904 produced_chars
= coding
->src_chars
;
5905 while (src
< src_end
)
5911 if (EQ (eol_type
, Qdos
))
5918 else if (EQ (eol_type
, Qmac
))
5924 coding
->consumed
= coding
->src_bytes
;
5925 coding
->consumed_char
= coding
->src_chars
;
5928 produced
= dst
- (coding
->destination
+ coding
->produced
);
5929 if (BUFFERP (coding
->dst_object
))
5930 insert_from_gap (produced_chars
, produced
);
5931 coding
->produced
+= produced
;
5932 coding
->produced_char
+= produced_chars
;
5936 /* Compose text in CODING->object according to the annotation data at
5937 CHARBUF. CHARBUF is an array:
5938 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
5942 produce_composition (coding
, charbuf
, pos
)
5943 struct coding_system
*coding
;
5949 enum composition_method method
;
5950 Lisp_Object components
;
5953 to
= pos
+ charbuf
[2];
5956 method
= (enum composition_method
) (charbuf
[3]);
5958 if (method
== COMPOSITION_RELATIVE
)
5960 else if (method
>= COMPOSITION_WITH_RULE
5961 && method
<= COMPOSITION_WITH_RULE_ALTCHARS
)
5963 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
5968 for (i
= 0; i
< len
; i
++)
5970 args
[i
] = make_number (charbuf
[i
]);
5974 components
= (method
== COMPOSITION_WITH_ALTCHARS
5975 ? Fstring (len
, args
) : Fvector (len
, args
));
5979 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
5983 /* Put `charset' property on text in CODING->object according to
5984 the annotation data at CHARBUF. CHARBUF is an array:
5985 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
5989 produce_charset (coding
, charbuf
, pos
)
5990 struct coding_system
*coding
;
5994 EMACS_INT from
= pos
- charbuf
[2];
5995 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
5997 Fput_text_property (make_number (from
), make_number (pos
),
5998 Qcharset
, CHARSET_NAME (charset
),
5999 coding
->dst_object
);
6003 #define CHARBUF_SIZE 0x4000
6005 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6007 int size = CHARBUF_SIZE;; \
6009 coding->charbuf = NULL; \
6010 while (size > 1024) \
6012 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6013 if (coding->charbuf) \
6017 if (! coding->charbuf) \
6019 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6020 return coding->result; \
6022 coding->charbuf_size = size; \
6027 produce_annotation (coding
, pos
)
6028 struct coding_system
*coding
;
6031 int *charbuf
= coding
->charbuf
;
6032 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6034 if (NILP (coding
->dst_object
))
6037 while (charbuf
< charbuf_end
)
6043 int len
= -*charbuf
;
6046 case CODING_ANNOTATE_COMPOSITION_MASK
:
6047 produce_composition (coding
, charbuf
, pos
);
6049 case CODING_ANNOTATE_CHARSET_MASK
:
6050 produce_charset (coding
, charbuf
, pos
);
6060 /* Decode the data at CODING->src_object into CODING->dst_object.
6061 CODING->src_object is a buffer, a string, or nil.
6062 CODING->dst_object is a buffer.
6064 If CODING->src_object is a buffer, it must be the current buffer.
6065 In this case, if CODING->src_pos is positive, it is a position of
6066 the source text in the buffer, otherwise, the source text is in the
6067 gap area of the buffer, and CODING->src_pos specifies the offset of
6068 the text from GPT (which must be the same as PT). If this is the
6069 same buffer as CODING->dst_object, CODING->src_pos must be
6072 If CODING->src_object is a string, CODING->src_pos in an index to
6075 If CODING->src_object is nil, CODING->source must already point to
6076 the non-relocatable memory area. In this case, CODING->src_pos is
6077 an offset from CODING->source.
6079 The decoded data is inserted at the current point of the buffer
6084 decode_coding (coding
)
6085 struct coding_system
*coding
;
6088 Lisp_Object undo_list
;
6089 Lisp_Object translation_table
;
6093 if (BUFFERP (coding
->src_object
)
6094 && coding
->src_pos
> 0
6095 && coding
->src_pos
< GPT
6096 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6097 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6100 if (BUFFERP (coding
->dst_object
))
6102 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6103 set_buffer_internal (XBUFFER (coding
->dst_object
));
6105 move_gap_both (PT
, PT_BYTE
);
6106 undo_list
= current_buffer
->undo_list
;
6107 current_buffer
->undo_list
= Qt
;
6110 coding
->consumed
= coding
->consumed_char
= 0;
6111 coding
->produced
= coding
->produced_char
= 0;
6112 coding
->chars_at_source
= 0;
6113 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6116 ALLOC_CONVERSION_WORK_AREA (coding
);
6118 attrs
= CODING_ID_ATTRS (coding
->id
);
6119 translation_table
= get_translation_table (attrs
, 0, NULL
);
6124 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
6126 coding_set_source (coding
);
6127 coding
->annotated
= 0;
6128 coding
->charbuf_used
= carryover
;
6129 (*(coding
->decoder
)) (coding
);
6130 coding_set_destination (coding
);
6131 carryover
= produce_chars (coding
, translation_table
, 0);
6132 if (coding
->annotated
)
6133 produce_annotation (coding
, pos
);
6134 for (i
= 0; i
< carryover
; i
++)
6136 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
6138 while (coding
->consumed
< coding
->src_bytes
6139 && ! coding
->result
);
6143 coding_set_destination (coding
);
6144 coding
->charbuf_used
= carryover
;
6145 produce_chars (coding
, translation_table
, 1);
6148 coding
->carryover_bytes
= 0;
6149 if (coding
->consumed
< coding
->src_bytes
)
6151 int nbytes
= coding
->src_bytes
- coding
->consumed
;
6152 const unsigned char *src
;
6154 coding_set_source (coding
);
6155 coding_set_destination (coding
);
6156 src
= coding
->source
+ coding
->consumed
;
6158 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
6160 /* Flush out unprocessed data as binary chars. We are sure
6161 that the number of data is less than the size of
6163 coding
->charbuf_used
= 0;
6164 while (nbytes
-- > 0)
6168 coding
->charbuf
[coding
->charbuf_used
++] = (c
& 0x80 ? - c
: c
);
6170 produce_chars (coding
, Qnil
, 1);
6174 /* Record unprocessed bytes in coding->carryover. We are
6175 sure that the number of data is less than the size of
6176 coding->carryover. */
6177 unsigned char *p
= coding
->carryover
;
6179 coding
->carryover_bytes
= nbytes
;
6180 while (nbytes
-- > 0)
6183 coding
->consumed
= coding
->src_bytes
;
6186 if (BUFFERP (coding
->dst_object
))
6188 current_buffer
->undo_list
= undo_list
;
6189 record_insert (coding
->dst_pos
, coding
->produced_char
);
6191 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
))
6192 decode_eol (coding
);
6193 return coding
->result
;
6197 /* Extract an annotation datum from a composition starting at POS and
6198 ending before LIMIT of CODING->src_object (buffer or string), store
6199 the data in BUF, set *STOP to a starting position of the next
6200 composition (if any) or to LIMIT, and return the address of the
6201 next element of BUF.
6203 If such an annotation is not found, set *STOP to a starting
6204 position of a composition after POS (if any) or to LIMIT, and
6208 handle_composition_annotation (pos
, limit
, coding
, buf
, stop
)
6209 EMACS_INT pos
, limit
;
6210 struct coding_system
*coding
;
6214 EMACS_INT start
, end
;
6217 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
6220 else if (start
> pos
)
6226 /* We found a composition. Store the corresponding
6227 annotation data in BUF. */
6229 enum composition_method method
= COMPOSITION_METHOD (prop
);
6230 int nchars
= COMPOSITION_LENGTH (prop
);
6232 ADD_COMPOSITION_DATA (buf
, nchars
, method
);
6233 if (method
!= COMPOSITION_RELATIVE
)
6235 Lisp_Object components
;
6238 components
= COMPOSITION_COMPONENTS (prop
);
6239 if (VECTORP (components
))
6241 len
= XVECTOR (components
)->size
;
6242 for (i
= 0; i
< len
; i
++)
6243 *buf
++ = XINT (AREF (components
, i
));
6245 else if (STRINGP (components
))
6247 len
= SCHARS (components
);
6251 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
6255 else if (INTEGERP (components
))
6258 *buf
++ = XINT (components
);
6260 else if (CONSP (components
))
6262 for (len
= 0; CONSP (components
);
6263 len
++, components
= XCDR (components
))
6264 *buf
++ = XINT (XCAR (components
));
6272 if (find_composition (end
, limit
, &start
, &end
, &prop
,
6283 /* Extract an annotation datum from a text property `charset' at POS of
6284 CODING->src_object (buffer of string), store the data in BUF, set
6285 *STOP to the position where the value of `charset' property changes
6286 (limiting by LIMIT), and return the address of the next element of
6289 If the property value is nil, set *STOP to the position where the
6290 property value is non-nil (limiting by LIMIT), and return BUF. */
6293 handle_charset_annotation (pos
, limit
, coding
, buf
, stop
)
6294 EMACS_INT pos
, limit
;
6295 struct coding_system
*coding
;
6299 Lisp_Object val
, next
;
6302 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
6303 if (! NILP (val
) && CHARSETP (val
))
6304 id
= XINT (CHARSET_SYMBOL_ID (val
));
6307 ADD_CHARSET_DATA (buf
, 0, id
);
6308 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
6310 make_number (limit
));
6311 *stop
= XINT (next
);
6317 consume_chars (coding
, translation_table
, max_lookup
)
6318 struct coding_system
*coding
;
6319 Lisp_Object translation_table
;
6322 int *buf
= coding
->charbuf
;
6323 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
6324 const unsigned char *src
= coding
->source
+ coding
->consumed
;
6325 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
6326 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
6327 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
6328 int multibytep
= coding
->src_multibyte
;
6329 Lisp_Object eol_type
;
6331 EMACS_INT stop
, stop_composition
, stop_charset
;
6332 int *lookup_buf
= NULL
;
6334 if (! NILP (translation_table
))
6335 lookup_buf
= alloca (sizeof (int) * max_lookup
);
6337 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6338 if (VECTORP (eol_type
))
6341 /* Note: composition handling is not yet implemented. */
6342 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
6344 if (NILP (coding
->src_object
))
6345 stop
= stop_composition
= stop_charset
= end_pos
;
6348 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
6349 stop
= stop_composition
= pos
;
6351 stop
= stop_composition
= end_pos
;
6352 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
6353 stop
= stop_charset
= pos
;
6355 stop_charset
= end_pos
;
6358 /* Compensate for CRLF and conversion. */
6359 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
6360 while (buf
< buf_end
)
6368 if (pos
== stop_composition
)
6369 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
6370 buf
, &stop_composition
);
6371 if (pos
== stop_charset
)
6372 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
6373 buf
, &stop_charset
);
6374 stop
= (stop_composition
< stop_charset
6375 ? stop_composition
: stop_charset
);
6382 if (! CODING_FOR_UNIBYTE (coding
)
6383 && (bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
6384 c
= STRING_CHAR_ADVANCE (src
), pos
+= bytes
;
6389 c
= STRING_CHAR_ADVANCE (src
), pos
++;
6390 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
6392 if (! EQ (eol_type
, Qunix
))
6396 if (EQ (eol_type
, Qdos
))
6404 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6409 int from_nchars
= 1, to_nchars
= 1;
6410 int *lookup_buf_end
;
6411 const unsigned char *p
= src
;
6415 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
6416 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
6417 lookup_buf_end
= lookup_buf
+ i
;
6418 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
, 1,
6419 &from_nchars
, &to_nchars
);
6421 || buf
+ to_nchars
> buf_end
)
6423 *buf
++ = *lookup_buf
;
6424 for (i
= 1; i
< to_nchars
; i
++)
6425 *buf
++ = XINT (AREF (trans
, i
));
6426 for (i
= 1; i
< from_nchars
; i
++, pos
++)
6427 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
6431 coding
->consumed
= src
- coding
->source
;
6432 coding
->consumed_char
= pos
- coding
->src_pos
;
6433 coding
->charbuf_used
= buf
- coding
->charbuf
;
6434 coding
->chars_at_source
= 0;
6438 /* Encode the text at CODING->src_object into CODING->dst_object.
6439 CODING->src_object is a buffer or a string.
6440 CODING->dst_object is a buffer or nil.
6442 If CODING->src_object is a buffer, it must be the current buffer.
6443 In this case, if CODING->src_pos is positive, it is a position of
6444 the source text in the buffer, otherwise. the source text is in the
6445 gap area of the buffer, and coding->src_pos specifies the offset of
6446 the text from GPT (which must be the same as PT). If this is the
6447 same buffer as CODING->dst_object, CODING->src_pos must be
6448 negative and CODING should not have `pre-write-conversion'.
6450 If CODING->src_object is a string, CODING should not have
6451 `pre-write-conversion'.
6453 If CODING->dst_object is a buffer, the encoded data is inserted at
6454 the current point of that buffer.
6456 If CODING->dst_object is nil, the encoded data is placed at the
6457 memory area specified by CODING->destination. */
6460 encode_coding (coding
)
6461 struct coding_system
*coding
;
6464 Lisp_Object translation_table
;
6467 attrs
= CODING_ID_ATTRS (coding
->id
);
6468 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
6470 if (BUFFERP (coding
->dst_object
))
6472 set_buffer_internal (XBUFFER (coding
->dst_object
));
6473 coding
->dst_multibyte
6474 = ! NILP (current_buffer
->enable_multibyte_characters
);
6477 coding
->consumed
= coding
->consumed_char
= 0;
6478 coding
->produced
= coding
->produced_char
= 0;
6479 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6482 ALLOC_CONVERSION_WORK_AREA (coding
);
6485 coding_set_source (coding
);
6486 consume_chars (coding
, translation_table
, max_lookup
);
6487 coding_set_destination (coding
);
6488 (*(coding
->encoder
)) (coding
);
6489 } while (coding
->consumed_char
< coding
->src_chars
);
6491 if (BUFFERP (coding
->dst_object
))
6492 insert_from_gap (coding
->produced_char
, coding
->produced
);
6494 return (coding
->result
);
6498 /* Name (or base name) of work buffer for code conversion. */
6499 static Lisp_Object Vcode_conversion_workbuf_name
;
6501 /* A working buffer used by the top level conversion. Once it is
6502 created, it is never destroyed. It has the name
6503 Vcode_conversion_workbuf_name. The other working buffers are
6504 destroyed after the use is finished, and their names are modified
6505 versions of Vcode_conversion_workbuf_name. */
6506 static Lisp_Object Vcode_conversion_reused_workbuf
;
6508 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
6509 static int reused_workbuf_in_use
;
6512 /* Return a working buffer of code convesion. MULTIBYTE specifies the
6513 multibyteness of returning buffer. */
6516 make_conversion_work_buffer (multibyte
)
6519 Lisp_Object name
, workbuf
;
6520 struct buffer
*current
;
6522 if (reused_workbuf_in_use
++)
6524 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
6525 workbuf
= Fget_buffer_create (name
);
6529 name
= Vcode_conversion_workbuf_name
;
6530 workbuf
= Fget_buffer_create (name
);
6531 if (NILP (Vcode_conversion_reused_workbuf
))
6532 Vcode_conversion_reused_workbuf
= workbuf
;
6534 current
= current_buffer
;
6535 set_buffer_internal (XBUFFER (workbuf
));
6537 current_buffer
->undo_list
= Qt
;
6538 current_buffer
->enable_multibyte_characters
= multibyte
? Qt
: Qnil
;
6539 set_buffer_internal (current
);
6545 code_conversion_restore (arg
)
6548 Lisp_Object current
, workbuf
;
6550 current
= XCAR (arg
);
6551 workbuf
= XCDR (arg
);
6552 if (! NILP (workbuf
))
6554 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
6555 reused_workbuf_in_use
= 0;
6556 else if (! NILP (Fbuffer_live_p (workbuf
)))
6557 Fkill_buffer (workbuf
);
6559 set_buffer_internal (XBUFFER (current
));
6564 code_conversion_save (with_work_buf
, multibyte
)
6565 int with_work_buf
, multibyte
;
6567 Lisp_Object workbuf
= Qnil
;
6570 workbuf
= make_conversion_work_buffer (multibyte
);
6571 record_unwind_protect (code_conversion_restore
,
6572 Fcons (Fcurrent_buffer (), workbuf
));
6577 decode_coding_gap (coding
, chars
, bytes
)
6578 struct coding_system
*coding
;
6579 EMACS_INT chars
, bytes
;
6581 int count
= specpdl_ptr
- specpdl
;
6584 code_conversion_save (0, 0);
6586 coding
->src_object
= Fcurrent_buffer ();
6587 coding
->src_chars
= chars
;
6588 coding
->src_bytes
= bytes
;
6589 coding
->src_pos
= -chars
;
6590 coding
->src_pos_byte
= -bytes
;
6591 coding
->src_multibyte
= chars
< bytes
;
6592 coding
->dst_object
= coding
->src_object
;
6593 coding
->dst_pos
= PT
;
6594 coding
->dst_pos_byte
= PT_BYTE
;
6595 coding
->dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
6596 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6598 if (CODING_REQUIRE_DETECTION (coding
))
6599 detect_coding (coding
);
6601 decode_coding (coding
);
6603 attrs
= CODING_ID_ATTRS (coding
->id
);
6604 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6606 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6609 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6610 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6611 make_number (coding
->produced_char
));
6613 coding
->produced_char
+= Z
- prev_Z
;
6614 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6617 unbind_to (count
, Qnil
);
6618 return coding
->result
;
6622 encode_coding_gap (coding
, chars
, bytes
)
6623 struct coding_system
*coding
;
6624 EMACS_INT chars
, bytes
;
6626 int count
= specpdl_ptr
- specpdl
;
6628 code_conversion_save (0, 0);
6630 coding
->src_object
= Fcurrent_buffer ();
6631 coding
->src_chars
= chars
;
6632 coding
->src_bytes
= bytes
;
6633 coding
->src_pos
= -chars
;
6634 coding
->src_pos_byte
= -bytes
;
6635 coding
->src_multibyte
= chars
< bytes
;
6636 coding
->dst_object
= coding
->src_object
;
6637 coding
->dst_pos
= PT
;
6638 coding
->dst_pos_byte
= PT_BYTE
;
6640 encode_coding (coding
);
6642 unbind_to (count
, Qnil
);
6643 return coding
->result
;
6647 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
6648 SRC_OBJECT into DST_OBJECT by coding context CODING.
6650 SRC_OBJECT is a buffer, a string, or Qnil.
6652 If it is a buffer, the text is at point of the buffer. FROM and TO
6653 are positions in the buffer.
6655 If it is a string, the text is at the beginning of the string.
6656 FROM and TO are indices to the string.
6658 If it is nil, the text is at coding->source. FROM and TO are
6659 indices to coding->source.
6661 DST_OBJECT is a buffer, Qt, or Qnil.
6663 If it is a buffer, the decoded text is inserted at point of the
6664 buffer. If the buffer is the same as SRC_OBJECT, the source text
6667 If it is Qt, a string is made from the decoded text, and
6668 set in CODING->dst_object.
6670 If it is Qnil, the decoded text is stored at CODING->destination.
6671 The caller must allocate CODING->dst_bytes bytes at
6672 CODING->destination by xmalloc. If the decoded text is longer than
6673 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
6677 decode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6679 struct coding_system
*coding
;
6680 Lisp_Object src_object
;
6681 EMACS_INT from
, from_byte
, to
, to_byte
;
6682 Lisp_Object dst_object
;
6684 int count
= specpdl_ptr
- specpdl
;
6685 unsigned char *destination
;
6686 EMACS_INT dst_bytes
;
6687 EMACS_INT chars
= to
- from
;
6688 EMACS_INT bytes
= to_byte
- from_byte
;
6691 int saved_pt
= -1, saved_pt_byte
;
6693 buffer
= Fcurrent_buffer ();
6695 if (NILP (dst_object
))
6697 destination
= coding
->destination
;
6698 dst_bytes
= coding
->dst_bytes
;
6701 coding
->src_object
= src_object
;
6702 coding
->src_chars
= chars
;
6703 coding
->src_bytes
= bytes
;
6704 coding
->src_multibyte
= chars
< bytes
;
6706 if (STRINGP (src_object
))
6708 coding
->src_pos
= from
;
6709 coding
->src_pos_byte
= from_byte
;
6711 else if (BUFFERP (src_object
))
6713 set_buffer_internal (XBUFFER (src_object
));
6715 move_gap_both (from
, from_byte
);
6716 if (EQ (src_object
, dst_object
))
6718 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6719 TEMP_SET_PT_BOTH (from
, from_byte
);
6720 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6721 coding
->src_pos
= -chars
;
6722 coding
->src_pos_byte
= -bytes
;
6726 coding
->src_pos
= from
;
6727 coding
->src_pos_byte
= from_byte
;
6731 if (CODING_REQUIRE_DETECTION (coding
))
6732 detect_coding (coding
);
6733 attrs
= CODING_ID_ATTRS (coding
->id
);
6735 if (EQ (dst_object
, Qt
)
6736 || (! NILP (CODING_ATTR_POST_READ (attrs
))
6737 && NILP (dst_object
)))
6739 coding
->dst_object
= code_conversion_save (1, 1);
6740 coding
->dst_pos
= BEG
;
6741 coding
->dst_pos_byte
= BEG_BYTE
;
6742 coding
->dst_multibyte
= 1;
6744 else if (BUFFERP (dst_object
))
6746 code_conversion_save (0, 0);
6747 coding
->dst_object
= dst_object
;
6748 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6749 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6750 coding
->dst_multibyte
6751 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6755 code_conversion_save (0, 0);
6756 coding
->dst_object
= Qnil
;
6757 coding
->dst_multibyte
= 1;
6760 decode_coding (coding
);
6762 if (BUFFERP (coding
->dst_object
))
6763 set_buffer_internal (XBUFFER (coding
->dst_object
));
6765 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6767 struct gcpro gcpro1
, gcpro2
;
6768 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6771 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6772 GCPRO2 (coding
->src_object
, coding
->dst_object
);
6773 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6774 make_number (coding
->produced_char
));
6777 coding
->produced_char
+= Z
- prev_Z
;
6778 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6781 if (EQ (dst_object
, Qt
))
6783 coding
->dst_object
= Fbuffer_string ();
6785 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
6787 set_buffer_internal (XBUFFER (coding
->dst_object
));
6788 if (dst_bytes
< coding
->produced
)
6791 = (unsigned char *) xrealloc (destination
, coding
->produced
);
6794 record_conversion_result (coding
,
6795 CODING_RESULT_INSUFFICIENT_DST
);
6796 unbind_to (count
, Qnil
);
6799 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
6800 move_gap_both (BEGV
, BEGV_BYTE
);
6801 bcopy (BEGV_ADDR
, destination
, coding
->produced
);
6802 coding
->destination
= destination
;
6808 /* This is the case of:
6809 (BUFFERP (src_object) && EQ (src_object, dst_object))
6810 As we have moved PT while replacing the original buffer
6811 contents, we must recover it now. */
6812 set_buffer_internal (XBUFFER (src_object
));
6813 if (saved_pt
< from
)
6814 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
6815 else if (saved_pt
< from
+ chars
)
6816 TEMP_SET_PT_BOTH (from
, from_byte
);
6817 else if (! NILP (current_buffer
->enable_multibyte_characters
))
6818 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
6819 saved_pt_byte
+ (coding
->produced
- bytes
));
6821 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
6822 saved_pt_byte
+ (coding
->produced
- bytes
));
6825 unbind_to (count
, coding
->dst_object
);
6830 encode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6832 struct coding_system
*coding
;
6833 Lisp_Object src_object
;
6834 EMACS_INT from
, from_byte
, to
, to_byte
;
6835 Lisp_Object dst_object
;
6837 int count
= specpdl_ptr
- specpdl
;
6838 EMACS_INT chars
= to
- from
;
6839 EMACS_INT bytes
= to_byte
- from_byte
;
6842 int saved_pt
= -1, saved_pt_byte
;
6844 buffer
= Fcurrent_buffer ();
6846 coding
->src_object
= src_object
;
6847 coding
->src_chars
= chars
;
6848 coding
->src_bytes
= bytes
;
6849 coding
->src_multibyte
= chars
< bytes
;
6851 attrs
= CODING_ID_ATTRS (coding
->id
);
6853 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
6855 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
6856 set_buffer_internal (XBUFFER (coding
->src_object
));
6857 if (STRINGP (src_object
))
6858 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
6859 else if (BUFFERP (src_object
))
6860 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
6862 insert_1_both (coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
6864 if (EQ (src_object
, dst_object
))
6866 set_buffer_internal (XBUFFER (src_object
));
6867 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6868 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6869 set_buffer_internal (XBUFFER (coding
->src_object
));
6872 call2 (CODING_ATTR_PRE_WRITE (attrs
),
6873 make_number (BEG
), make_number (Z
));
6874 coding
->src_object
= Fcurrent_buffer ();
6876 move_gap_both (BEG
, BEG_BYTE
);
6877 coding
->src_chars
= Z
- BEG
;
6878 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
6879 coding
->src_pos
= BEG
;
6880 coding
->src_pos_byte
= BEG_BYTE
;
6881 coding
->src_multibyte
= Z
< Z_BYTE
;
6883 else if (STRINGP (src_object
))
6885 code_conversion_save (0, 0);
6886 coding
->src_pos
= from
;
6887 coding
->src_pos_byte
= from_byte
;
6889 else if (BUFFERP (src_object
))
6891 code_conversion_save (0, 0);
6892 set_buffer_internal (XBUFFER (src_object
));
6893 if (EQ (src_object
, dst_object
))
6895 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6896 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
6897 coding
->src_pos
= 0;
6898 coding
->src_pos_byte
= 0;
6902 if (from
< GPT
&& to
>= GPT
)
6903 move_gap_both (from
, from_byte
);
6904 coding
->src_pos
= from
;
6905 coding
->src_pos_byte
= from_byte
;
6909 code_conversion_save (0, 0);
6911 if (BUFFERP (dst_object
))
6913 coding
->dst_object
= dst_object
;
6914 if (EQ (src_object
, dst_object
))
6916 coding
->dst_pos
= from
;
6917 coding
->dst_pos_byte
= from_byte
;
6921 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6922 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6924 coding
->dst_multibyte
6925 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6927 else if (EQ (dst_object
, Qt
))
6929 coding
->dst_object
= Qnil
;
6930 coding
->dst_bytes
= coding
->src_chars
;
6931 if (coding
->dst_bytes
== 0)
6932 coding
->dst_bytes
= 1;
6933 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
6934 coding
->dst_multibyte
= 0;
6938 coding
->dst_object
= Qnil
;
6939 coding
->dst_multibyte
= 0;
6942 encode_coding (coding
);
6944 if (EQ (dst_object
, Qt
))
6946 if (BUFFERP (coding
->dst_object
))
6947 coding
->dst_object
= Fbuffer_string ();
6951 = make_unibyte_string ((char *) coding
->destination
,
6953 xfree (coding
->destination
);
6959 /* This is the case of:
6960 (BUFFERP (src_object) && EQ (src_object, dst_object))
6961 As we have moved PT while replacing the original buffer
6962 contents, we must recover it now. */
6963 set_buffer_internal (XBUFFER (src_object
));
6964 if (saved_pt
< from
)
6965 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
6966 else if (saved_pt
< from
+ chars
)
6967 TEMP_SET_PT_BOTH (from
, from_byte
);
6968 else if (! NILP (current_buffer
->enable_multibyte_characters
))
6969 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
6970 saved_pt_byte
+ (coding
->produced
- bytes
));
6972 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
6973 saved_pt_byte
+ (coding
->produced
- bytes
));
6976 unbind_to (count
, Qnil
);
6981 preferred_coding_system ()
6983 int id
= coding_categories
[coding_priorities
[0]].id
;
6985 return CODING_ID_NAME (id
);
6990 /*** 8. Emacs Lisp library functions ***/
6992 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
6993 doc
: /* Return t if OBJECT is nil or a coding-system.
6994 See the documentation of `define-coding-system' for information
6995 about coding-system objects. */)
6999 return ((NILP (obj
) || CODING_SYSTEM_P (obj
)) ? Qt
: Qnil
);
7002 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7003 Sread_non_nil_coding_system
, 1, 1, 0,
7004 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7011 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7012 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
7014 while (SCHARS (val
) == 0);
7015 return (Fintern (val
, Qnil
));
7018 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
7019 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
7020 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM. */)
7021 (prompt
, default_coding_system
)
7022 Lisp_Object prompt
, default_coding_system
;
7025 if (SYMBOLP (default_coding_system
))
7026 XSETSTRING (default_coding_system
, XPNTR (SYMBOL_NAME (default_coding_system
)));
7027 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7028 Qt
, Qnil
, Qcoding_system_history
,
7029 default_coding_system
, Qnil
);
7030 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
7033 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
7035 doc
: /* Check validity of CODING-SYSTEM.
7036 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7037 It is valid if it is nil or a symbol defined as a coding system by the
7038 function `define-coding-system'. */)
7040 Lisp_Object coding_system
;
7042 CHECK_SYMBOL (coding_system
);
7043 if (!NILP (Fcoding_system_p (coding_system
)))
7044 return coding_system
;
7046 Fsignal (Qcoding_system_error
, Fcons (coding_system
, Qnil
));
7050 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7051 HIGHEST is nonzero, return the coding system of the highest
7052 priority among the detected coding systems. Otherwize return a
7053 list of detected coding systems sorted by their priorities. If
7054 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7055 multibyte form but contains only ASCII and eight-bit chars.
7056 Otherwise, the bytes are raw bytes.
7058 CODING-SYSTEM controls the detection as below:
7060 If it is nil, detect both text-format and eol-format. If the
7061 text-format part of CODING-SYSTEM is already specified
7062 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7063 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7064 detect only text-format. */
7067 detect_coding_system (src
, src_chars
, src_bytes
, highest
, multibytep
,
7069 const unsigned char *src
;
7070 int src_chars
, src_bytes
, highest
;
7072 Lisp_Object coding_system
;
7074 const unsigned char *src_end
= src
+ src_bytes
;
7075 Lisp_Object attrs
, eol_type
;
7077 struct coding_system coding
;
7079 struct coding_detection_info detect_info
;
7080 enum coding_category base_category
;
7082 if (NILP (coding_system
))
7083 coding_system
= Qundecided
;
7084 setup_coding_system (coding_system
, &coding
);
7085 attrs
= CODING_ID_ATTRS (coding
.id
);
7086 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
7087 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
7089 coding
.source
= src
;
7090 coding
.src_chars
= src_chars
;
7091 coding
.src_bytes
= src_bytes
;
7092 coding
.src_multibyte
= multibytep
;
7093 coding
.consumed
= 0;
7094 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7096 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
7098 /* At first, detect text-format if necessary. */
7099 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7100 if (base_category
== coding_category_undecided
)
7102 enum coding_category category
;
7103 struct coding_system
*this;
7106 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7107 for (i
= 0; src
< src_end
; i
++, src
++)
7110 if (c
& 0x80 || (c
< 0x20 && (c
== ISO_CODE_ESC
7112 || c
== ISO_CODE_SO
)))
7115 coding
.head_ascii
= src
- coding
.source
;
7118 for (i
= 0; i
< coding_category_raw_text
; i
++)
7120 category
= coding_priorities
[i
];
7121 this = coding_categories
+ category
;
7125 /* No coding system of this category is defined. */
7126 detect_info
.rejected
|= (1 << category
);
7128 else if (category
>= coding_category_raw_text
)
7130 else if (detect_info
.checked
& (1 << category
))
7133 && (detect_info
.found
& (1 << category
)))
7138 if ((*(this->detector
)) (&coding
, &detect_info
)
7140 && (detect_info
.found
& (1 << category
)))
7142 if (category
== coding_category_utf_16_auto
)
7144 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7145 category
= coding_category_utf_16_le
;
7147 category
= coding_category_utf_16_be
;
7154 if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
7156 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
7157 id
= coding_categories
[coding_category_raw_text
].id
;
7158 val
= Fcons (make_number (id
), Qnil
);
7160 else if (! detect_info
.rejected
&& ! detect_info
.found
)
7162 detect_info
.found
= CATEGORY_MASK_ANY
;
7163 id
= coding_categories
[coding_category_undecided
].id
;
7164 val
= Fcons (make_number (id
), Qnil
);
7168 if (detect_info
.found
)
7170 detect_info
.found
= 1 << category
;
7171 val
= Fcons (make_number (this->id
), Qnil
);
7174 for (i
= 0; i
< coding_category_raw_text
; i
++)
7175 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
7177 detect_info
.found
= 1 << coding_priorities
[i
];
7178 id
= coding_categories
[coding_priorities
[i
]].id
;
7179 val
= Fcons (make_number (id
), Qnil
);
7185 int mask
= detect_info
.rejected
| detect_info
.found
;
7189 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7191 category
= coding_priorities
[i
];
7192 if (! (mask
& (1 << category
)))
7194 found
|= 1 << category
;
7195 id
= coding_categories
[category
].id
;
7196 val
= Fcons (make_number (id
), val
);
7199 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7201 category
= coding_priorities
[i
];
7202 if (detect_info
.found
& (1 << category
))
7204 id
= coding_categories
[category
].id
;
7205 val
= Fcons (make_number (id
), val
);
7208 detect_info
.found
|= found
;
7211 else if (base_category
== coding_category_utf_16_auto
)
7213 if (detect_coding_utf_16 (&coding
, &detect_info
))
7215 enum coding_category category
;
7216 struct coding_system
*this;
7218 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7219 this = coding_categories
+ coding_category_utf_16_le
;
7220 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
7221 this = coding_categories
+ coding_category_utf_16_be
;
7222 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
7223 this = coding_categories
+ coding_category_utf_16_be_nosig
;
7225 this = coding_categories
+ coding_category_utf_16_le_nosig
;
7226 val
= Fcons (make_number (this->id
), Qnil
);
7231 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
7232 val
= Fcons (make_number (coding
.id
), Qnil
);
7235 /* Then, detect eol-format if necessary. */
7237 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
;
7240 if (VECTORP (eol_type
))
7242 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
7243 normal_eol
= detect_eol (coding
.source
, src_bytes
,
7244 coding_category_raw_text
);
7245 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
7246 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
7247 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
7248 coding_category_utf_16_be
);
7249 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
7250 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
7251 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
7252 coding_category_utf_16_le
);
7256 if (EQ (eol_type
, Qunix
))
7257 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
7258 else if (EQ (eol_type
, Qdos
))
7259 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
7261 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
7264 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
7266 enum coding_category category
;
7269 id
= XINT (XCAR (tail
));
7270 attrs
= CODING_ID_ATTRS (id
);
7271 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7272 eol_type
= CODING_ID_EOL_TYPE (id
);
7273 if (VECTORP (eol_type
))
7275 if (category
== coding_category_utf_16_be
7276 || category
== coding_category_utf_16_be_nosig
)
7277 this_eol
= utf_16_be_eol
;
7278 else if (category
== coding_category_utf_16_le
7279 || category
== coding_category_utf_16_le_nosig
)
7280 this_eol
= utf_16_le_eol
;
7282 this_eol
= normal_eol
;
7284 if (this_eol
== EOL_SEEN_LF
)
7285 XSETCAR (tail
, AREF (eol_type
, 0));
7286 else if (this_eol
== EOL_SEEN_CRLF
)
7287 XSETCAR (tail
, AREF (eol_type
, 1));
7288 else if (this_eol
== EOL_SEEN_CR
)
7289 XSETCAR (tail
, AREF (eol_type
, 2));
7291 XSETCAR (tail
, CODING_ID_NAME (id
));
7294 XSETCAR (tail
, CODING_ID_NAME (id
));
7298 return (highest
? XCAR (val
) : val
);
7302 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
7304 doc
: /* Detect coding system of the text in the region between START and END.
7305 Return a list of possible coding systems ordered by priority.
7307 If only ASCII characters are found, it returns a list of single element
7308 `undecided' or its subsidiary coding system according to a detected
7311 If optional argument HIGHEST is non-nil, return the coding system of
7312 highest priority. */)
7313 (start
, end
, highest
)
7314 Lisp_Object start
, end
, highest
;
7317 int from_byte
, to_byte
;
7319 CHECK_NUMBER_COERCE_MARKER (start
);
7320 CHECK_NUMBER_COERCE_MARKER (end
);
7322 validate_region (&start
, &end
);
7323 from
= XINT (start
), to
= XINT (end
);
7324 from_byte
= CHAR_TO_BYTE (from
);
7325 to_byte
= CHAR_TO_BYTE (to
);
7327 if (from
< GPT
&& to
>= GPT
)
7328 move_gap_both (to
, to_byte
);
7330 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
7331 to
- from
, to_byte
- from_byte
,
7333 !NILP (current_buffer
7334 ->enable_multibyte_characters
),
7338 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
7340 doc
: /* Detect coding system of the text in STRING.
7341 Return a list of possible coding systems ordered by priority.
7343 If only ASCII characters are found, it returns a list of single element
7344 `undecided' or its subsidiary coding system according to a detected
7347 If optional argument HIGHEST is non-nil, return the coding system of
7348 highest priority. */)
7350 Lisp_Object string
, highest
;
7352 CHECK_STRING (string
);
7354 return detect_coding_system (SDATA (string
),
7355 SCHARS (string
), SBYTES (string
),
7356 !NILP (highest
), STRING_MULTIBYTE (string
),
7362 char_encodable_p (c
, attrs
)
7367 struct charset
*charset
;
7368 Lisp_Object translation_table
;
7370 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
7371 if (! NILP (translation_table
))
7372 c
= translate_char (translation_table
, c
);
7373 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
7374 CONSP (tail
); tail
= XCDR (tail
))
7376 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
7377 if (CHAR_CHARSET_P (c
, charset
))
7380 return (! NILP (tail
));
7384 /* Return a list of coding systems that safely encode the text between
7385 START and END. If EXCLUDE is non-nil, it is a list of coding
7386 systems not to check. The returned list doesn't contain any such
7387 coding systems. In any case, if the text contains only ASCII or is
7388 unibyte, return t. */
7390 DEFUN ("find-coding-systems-region-internal",
7391 Ffind_coding_systems_region_internal
,
7392 Sfind_coding_systems_region_internal
, 2, 3, 0,
7393 doc
: /* Internal use only. */)
7394 (start
, end
, exclude
)
7395 Lisp_Object start
, end
, exclude
;
7397 Lisp_Object coding_attrs_list
, safe_codings
;
7398 EMACS_INT start_byte
, end_byte
;
7399 const unsigned char *p
, *pbeg
, *pend
;
7401 Lisp_Object tail
, elt
;
7403 if (STRINGP (start
))
7405 if (!STRING_MULTIBYTE (start
)
7406 || SCHARS (start
) == SBYTES (start
))
7409 end_byte
= SBYTES (start
);
7413 CHECK_NUMBER_COERCE_MARKER (start
);
7414 CHECK_NUMBER_COERCE_MARKER (end
);
7415 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7416 args_out_of_range (start
, end
);
7417 if (NILP (current_buffer
->enable_multibyte_characters
))
7419 start_byte
= CHAR_TO_BYTE (XINT (start
));
7420 end_byte
= CHAR_TO_BYTE (XINT (end
));
7421 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7424 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7426 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7427 move_gap_both (XINT (start
), start_byte
);
7429 move_gap_both (XINT (end
), end_byte
);
7433 coding_attrs_list
= Qnil
;
7434 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7436 || NILP (Fmemq (XCAR (tail
), exclude
)))
7440 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
7441 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
7442 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
7444 ASET (attrs
, coding_attr_trans_tbl
,
7445 get_translation_table (attrs
, 1, NULL
));
7446 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
7450 if (STRINGP (start
))
7451 p
= pbeg
= SDATA (start
);
7453 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7454 pend
= p
+ (end_byte
- start_byte
);
7456 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
7457 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7461 if (ASCII_BYTE_P (*p
))
7465 c
= STRING_CHAR_ADVANCE (p
);
7467 charset_map_loaded
= 0;
7468 for (tail
= coding_attrs_list
; CONSP (tail
);)
7473 else if (char_encodable_p (c
, elt
))
7475 else if (CONSP (XCDR (tail
)))
7477 XSETCAR (tail
, XCAR (XCDR (tail
)));
7478 XSETCDR (tail
, XCDR (XCDR (tail
)));
7482 XSETCAR (tail
, Qnil
);
7486 if (charset_map_loaded
)
7488 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7490 if (STRINGP (start
))
7491 pbeg
= SDATA (start
);
7493 pbeg
= BYTE_POS_ADDR (start_byte
);
7494 p
= pbeg
+ p_offset
;
7495 pend
= pbeg
+ pend_offset
;
7500 safe_codings
= Qnil
;
7501 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
7502 if (! NILP (XCAR (tail
)))
7503 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
7505 return safe_codings
;
7509 DEFUN ("unencodable-char-position", Funencodable_char_position
,
7510 Sunencodable_char_position
, 3, 5, 0,
7512 Return position of first un-encodable character in a region.
7513 START and END specfiy the region and CODING-SYSTEM specifies the
7514 encoding to check. Return nil if CODING-SYSTEM does encode the region.
7516 If optional 4th argument COUNT is non-nil, it specifies at most how
7517 many un-encodable characters to search. In this case, the value is a
7520 If optional 5th argument STRING is non-nil, it is a string to search
7521 for un-encodable characters. In that case, START and END are indexes
7523 (start
, end
, coding_system
, count
, string
)
7524 Lisp_Object start
, end
, coding_system
, count
, string
;
7527 struct coding_system coding
;
7528 Lisp_Object attrs
, charset_list
, translation_table
;
7529 Lisp_Object positions
;
7531 const unsigned char *p
, *stop
, *pend
;
7532 int ascii_compatible
;
7534 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
7535 attrs
= CODING_ID_ATTRS (coding
.id
);
7536 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
7538 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
7539 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
7540 translation_table
= get_translation_table (attrs
, 1, NULL
);
7544 validate_region (&start
, &end
);
7545 from
= XINT (start
);
7547 if (NILP (current_buffer
->enable_multibyte_characters
)
7548 || (ascii_compatible
7549 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
7551 p
= CHAR_POS_ADDR (from
);
7552 pend
= CHAR_POS_ADDR (to
);
7553 if (from
< GPT
&& to
>= GPT
)
7560 CHECK_STRING (string
);
7561 CHECK_NATNUM (start
);
7563 from
= XINT (start
);
7566 || to
> SCHARS (string
))
7567 args_out_of_range_3 (string
, start
, end
);
7568 if (! STRING_MULTIBYTE (string
))
7570 p
= SDATA (string
) + string_char_to_byte (string
, from
);
7571 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
7572 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
7580 CHECK_NATNUM (count
);
7589 if (ascii_compatible
)
7590 while (p
< stop
&& ASCII_BYTE_P (*p
))
7600 c
= STRING_CHAR_ADVANCE (p
);
7601 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
7602 && ! char_charset (translate_char (translation_table
, c
),
7603 charset_list
, NULL
))
7605 positions
= Fcons (make_number (from
), positions
);
7614 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
7618 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
7619 Scheck_coding_systems_region
, 3, 3, 0,
7620 doc
: /* Check if the region is encodable by coding systems.
7622 START and END are buffer positions specifying the region.
7623 CODING-SYSTEM-LIST is a list of coding systems to check.
7625 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
7626 CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
7627 whole region, POS0, POS1, ... are buffer positions where non-encodable
7628 characters are found.
7630 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
7633 START may be a string. In that case, check if the string is
7634 encodable, and the value contains indices to the string instead of
7635 buffer positions. END is ignored. */)
7636 (start
, end
, coding_system_list
)
7637 Lisp_Object start
, end
, coding_system_list
;
7640 EMACS_INT start_byte
, end_byte
;
7642 const unsigned char *p
, *pbeg
, *pend
;
7644 Lisp_Object tail
, elt
, attrs
;
7646 if (STRINGP (start
))
7648 if (!STRING_MULTIBYTE (start
)
7649 && SCHARS (start
) != SBYTES (start
))
7652 end_byte
= SBYTES (start
);
7657 CHECK_NUMBER_COERCE_MARKER (start
);
7658 CHECK_NUMBER_COERCE_MARKER (end
);
7659 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7660 args_out_of_range (start
, end
);
7661 if (NILP (current_buffer
->enable_multibyte_characters
))
7663 start_byte
= CHAR_TO_BYTE (XINT (start
));
7664 end_byte
= CHAR_TO_BYTE (XINT (end
));
7665 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7668 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7670 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7671 move_gap_both (XINT (start
), start_byte
);
7673 move_gap_both (XINT (end
), end_byte
);
7679 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7682 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
7683 ASET (attrs
, coding_attr_trans_tbl
,
7684 get_translation_table (attrs
, 1, NULL
));
7685 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
7688 if (STRINGP (start
))
7689 p
= pbeg
= SDATA (start
);
7691 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7692 pend
= p
+ (end_byte
- start_byte
);
7694 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
7695 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7699 if (ASCII_BYTE_P (*p
))
7703 c
= STRING_CHAR_ADVANCE (p
);
7705 charset_map_loaded
= 0;
7706 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
7708 elt
= XCDR (XCAR (tail
));
7709 if (! char_encodable_p (c
, XCAR (elt
)))
7710 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
7712 if (charset_map_loaded
)
7714 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7716 if (STRINGP (start
))
7717 pbeg
= SDATA (start
);
7719 pbeg
= BYTE_POS_ADDR (start_byte
);
7720 p
= pbeg
+ p_offset
;
7721 pend
= pbeg
+ pend_offset
;
7729 for (; CONSP (tail
); tail
= XCDR (tail
))
7732 if (CONSP (XCDR (XCDR (elt
))))
7733 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
7742 code_convert_region (start
, end
, coding_system
, dst_object
, encodep
, norecord
)
7743 Lisp_Object start
, end
, coding_system
, dst_object
;
7744 int encodep
, norecord
;
7746 struct coding_system coding
;
7747 EMACS_INT from
, from_byte
, to
, to_byte
;
7748 Lisp_Object src_object
;
7750 CHECK_NUMBER_COERCE_MARKER (start
);
7751 CHECK_NUMBER_COERCE_MARKER (end
);
7752 if (NILP (coding_system
))
7753 coding_system
= Qno_conversion
;
7755 CHECK_CODING_SYSTEM (coding_system
);
7756 src_object
= Fcurrent_buffer ();
7757 if (NILP (dst_object
))
7758 dst_object
= src_object
;
7759 else if (! EQ (dst_object
, Qt
))
7760 CHECK_BUFFER (dst_object
);
7762 validate_region (&start
, &end
);
7763 from
= XFASTINT (start
);
7764 from_byte
= CHAR_TO_BYTE (from
);
7765 to
= XFASTINT (end
);
7766 to_byte
= CHAR_TO_BYTE (to
);
7768 setup_coding_system (coding_system
, &coding
);
7769 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7772 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7775 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7778 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7780 return (BUFFERP (dst_object
)
7781 ? make_number (coding
.produced_char
)
7782 : coding
.dst_object
);
7786 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
7787 3, 4, "r\nzCoding system: ",
7788 doc
: /* Decode the current region from the specified coding system.
7789 When called from a program, takes four arguments:
7790 START, END, CODING-SYSTEM, and DESTINATION.
7791 START and END are buffer positions.
7793 Optional 4th arguments DESTINATION specifies where the decoded text goes.
7794 If nil, the region between START and END is replace by the decoded text.
7795 If buffer, the decoded text is inserted in the buffer.
7796 If t, the decoded text is returned.
7798 This function sets `last-coding-system-used' to the precise coding system
7799 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7800 not fully specified.)
7801 It returns the length of the decoded text. */)
7802 (start
, end
, coding_system
, destination
)
7803 Lisp_Object start
, end
, coding_system
, destination
;
7805 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
7808 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
7809 3, 4, "r\nzCoding system: ",
7810 doc
: /* Encode the current region by specified coding system.
7811 When called from a program, takes three arguments:
7812 START, END, and CODING-SYSTEM. START and END are buffer positions.
7814 Optional 4th arguments DESTINATION specifies where the encoded text goes.
7815 If nil, the region between START and END is replace by the encoded text.
7816 If buffer, the encoded text is inserted in the buffer.
7817 If t, the encoded text is returned.
7819 This function sets `last-coding-system-used' to the precise coding system
7820 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7821 not fully specified.)
7822 It returns the length of the encoded text. */)
7823 (start
, end
, coding_system
, destination
)
7824 Lisp_Object start
, end
, coding_system
, destination
;
7826 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
7830 code_convert_string (string
, coding_system
, dst_object
,
7831 encodep
, nocopy
, norecord
)
7832 Lisp_Object string
, coding_system
, dst_object
;
7833 int encodep
, nocopy
, norecord
;
7835 struct coding_system coding
;
7836 EMACS_INT chars
, bytes
;
7838 CHECK_STRING (string
);
7839 if (NILP (coding_system
))
7842 Vlast_coding_system_used
= Qno_conversion
;
7843 if (NILP (dst_object
))
7844 return (nocopy
? Fcopy_sequence (string
) : string
);
7847 if (NILP (coding_system
))
7848 coding_system
= Qno_conversion
;
7850 CHECK_CODING_SYSTEM (coding_system
);
7851 if (NILP (dst_object
))
7853 else if (! EQ (dst_object
, Qt
))
7854 CHECK_BUFFER (dst_object
);
7856 setup_coding_system (coding_system
, &coding
);
7857 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7858 chars
= SCHARS (string
);
7859 bytes
= SBYTES (string
);
7861 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7863 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7865 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7867 return (BUFFERP (dst_object
)
7868 ? make_number (coding
.produced_char
)
7869 : coding
.dst_object
);
7873 /* Encode or decode STRING according to CODING_SYSTEM.
7874 Do not set Vlast_coding_system_used.
7876 This function is called only from macros DECODE_FILE and
7877 ENCODE_FILE, thus we ignore character composition. */
7880 code_convert_string_norecord (string
, coding_system
, encodep
)
7881 Lisp_Object string
, coding_system
;
7884 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
7888 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
7890 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
7892 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
7893 if the decoding operation is trivial.
7895 Optional fourth arg BUFFER non-nil meant that the decoded text is
7896 inserted in BUFFER instead of returned as a string. In this case,
7897 the return value is BUFFER.
7899 This function sets `last-coding-system-used' to the precise coding system
7900 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7901 not fully specified. */)
7902 (string
, coding_system
, nocopy
, buffer
)
7903 Lisp_Object string
, coding_system
, nocopy
, buffer
;
7905 return code_convert_string (string
, coding_system
, buffer
,
7906 0, ! NILP (nocopy
), 0);
7909 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
7911 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
7913 Optional third arg NOCOPY non-nil means it is OK to return STRING
7914 itself if the encoding operation is trivial.
7916 Optional fourth arg BUFFER non-nil meant that the encoded text is
7917 inserted in BUFFER instead of returned as a string. In this case,
7918 the return value is BUFFER.
7920 This function sets `last-coding-system-used' to the precise coding system
7921 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7922 not fully specified.) */)
7923 (string
, coding_system
, nocopy
, buffer
)
7924 Lisp_Object string
, coding_system
, nocopy
, buffer
;
7926 return code_convert_string (string
, coding_system
, buffer
,
7927 1, ! NILP (nocopy
), 1);
7931 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
7932 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
7933 Return the corresponding character. */)
7937 Lisp_Object spec
, attrs
, val
;
7938 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
7941 CHECK_NATNUM (code
);
7942 c
= XFASTINT (code
);
7943 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
7944 attrs
= AREF (spec
, 0);
7946 if (ASCII_BYTE_P (c
)
7947 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
7950 val
= CODING_ATTR_CHARSET_LIST (attrs
);
7951 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
7952 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
7953 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
7956 charset
= charset_roman
;
7957 else if (c
>= 0xA0 && c
< 0xDF)
7959 charset
= charset_kana
;
7964 int s1
= c
>> 8, s2
= c
& 0xFF;
7966 if (s1
< 0x81 || (s1
> 0x9F && s1
< 0xE0) || s1
> 0xEF
7967 || s2
< 0x40 || s2
== 0x7F || s2
> 0xFC)
7968 error ("Invalid code: %d", code
);
7970 charset
= charset_kanji
;
7972 c
= DECODE_CHAR (charset
, c
);
7974 error ("Invalid code: %d", code
);
7975 return make_number (c
);
7979 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
7980 doc
: /* Encode a Japanese character CHAR to shift_jis encoding.
7981 Return the corresponding code in SJIS. */)
7985 Lisp_Object spec
, attrs
, charset_list
;
7987 struct charset
*charset
;
7990 CHECK_CHARACTER (ch
);
7992 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
7993 attrs
= AREF (spec
, 0);
7995 if (ASCII_CHAR_P (c
)
7996 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
7999 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8000 charset
= char_charset (c
, charset_list
, &code
);
8001 if (code
== CHARSET_INVALID_CODE (charset
))
8002 error ("Can't encode by shift_jis encoding: %d", c
);
8005 return make_number (code
);
8008 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
8009 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
8010 Return the corresponding character. */)
8014 Lisp_Object spec
, attrs
, val
;
8015 struct charset
*charset_roman
, *charset_big5
, *charset
;
8018 CHECK_NATNUM (code
);
8019 c
= XFASTINT (code
);
8020 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8021 attrs
= AREF (spec
, 0);
8023 if (ASCII_BYTE_P (c
)
8024 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8027 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8028 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8029 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8032 charset
= charset_roman
;
8035 int b1
= c
>> 8, b2
= c
& 0x7F;
8036 if (b1
< 0xA1 || b1
> 0xFE
8037 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
8038 error ("Invalid code: %d", code
);
8039 charset
= charset_big5
;
8041 c
= DECODE_CHAR (charset
, (unsigned )c
);
8043 error ("Invalid code: %d", code
);
8044 return make_number (c
);
8047 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
8048 doc
: /* Encode the Big5 character CHAR to BIG5 coding system.
8049 Return the corresponding character code in Big5. */)
8053 Lisp_Object spec
, attrs
, charset_list
;
8054 struct charset
*charset
;
8058 CHECK_CHARACTER (ch
);
8060 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8061 attrs
= AREF (spec
, 0);
8062 if (ASCII_CHAR_P (c
)
8063 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8066 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8067 charset
= char_charset (c
, charset_list
, &code
);
8068 if (code
== CHARSET_INVALID_CODE (charset
))
8069 error ("Can't encode by Big5 encoding: %d", c
);
8071 return make_number (code
);
8075 DEFUN ("set-terminal-coding-system-internal",
8076 Fset_terminal_coding_system_internal
,
8077 Sset_terminal_coding_system_internal
, 1, 1, 0,
8078 doc
: /* Internal use only. */)
8080 Lisp_Object coding_system
;
8082 CHECK_SYMBOL (coding_system
);
8083 setup_coding_system (Fcheck_coding_system (coding_system
),
8086 /* We had better not send unsafe characters to terminal. */
8087 terminal_coding
.mode
|= CODING_MODE_SAFE_ENCODING
;
8088 /* Characer composition should be disabled. */
8089 terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8090 terminal_coding
.src_multibyte
= 1;
8091 terminal_coding
.dst_multibyte
= 0;
8095 DEFUN ("set-safe-terminal-coding-system-internal",
8096 Fset_safe_terminal_coding_system_internal
,
8097 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
8098 doc
: /* Internal use only. */)
8100 Lisp_Object coding_system
;
8102 CHECK_SYMBOL (coding_system
);
8103 setup_coding_system (Fcheck_coding_system (coding_system
),
8104 &safe_terminal_coding
);
8105 /* Characer composition should be disabled. */
8106 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8107 safe_terminal_coding
.src_multibyte
= 1;
8108 safe_terminal_coding
.dst_multibyte
= 0;
8112 DEFUN ("terminal-coding-system",
8113 Fterminal_coding_system
, Sterminal_coding_system
, 0, 0, 0,
8114 doc
: /* Return coding system specified for terminal output. */)
8117 return CODING_ID_NAME (terminal_coding
.id
);
8120 DEFUN ("set-keyboard-coding-system-internal",
8121 Fset_keyboard_coding_system_internal
,
8122 Sset_keyboard_coding_system_internal
, 1, 1, 0,
8123 doc
: /* Internal use only. */)
8125 Lisp_Object coding_system
;
8127 CHECK_SYMBOL (coding_system
);
8128 setup_coding_system (Fcheck_coding_system (coding_system
),
8130 /* Characer composition should be disabled. */
8131 keyboard_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8135 DEFUN ("keyboard-coding-system",
8136 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 0, 0,
8137 doc
: /* Return coding system specified for decoding keyboard input. */)
8140 return CODING_ID_NAME (keyboard_coding
.id
);
8144 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
8145 Sfind_operation_coding_system
, 1, MANY
, 0,
8146 doc
: /* Choose a coding system for an operation based on the target name.
8147 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8148 DECODING-SYSTEM is the coding system to use for decoding
8149 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8150 for encoding (in case OPERATION does encoding).
8152 The first argument OPERATION specifies an I/O primitive:
8153 For file I/O, `insert-file-contents' or `write-region'.
8154 For process I/O, `call-process', `call-process-region', or `start-process'.
8155 For network I/O, `open-network-stream'.
8157 The remaining arguments should be the same arguments that were passed
8158 to the primitive. Depending on which primitive, one of those arguments
8159 is selected as the TARGET. For example, if OPERATION does file I/O,
8160 whichever argument specifies the file name is TARGET.
8162 TARGET has a meaning which depends on OPERATION:
8163 For file I/O, TARGET is a file name.
8164 For process I/O, TARGET is a process name.
8165 For network I/O, TARGET is a service name or a port number
8167 This function looks up what specified for TARGET in,
8168 `file-coding-system-alist', `process-coding-system-alist',
8169 or `network-coding-system-alist' depending on OPERATION.
8170 They may specify a coding system, a cons of coding systems,
8171 or a function symbol to call.
8172 In the last case, we call the function with one argument,
8173 which is a list of all the arguments given to this function.
8175 usage: (find-operation-coding-system OPERATION ARGUMENTS ...) */)
8180 Lisp_Object operation
, target_idx
, target
, val
;
8181 register Lisp_Object chain
;
8184 error ("Too few arguments");
8185 operation
= args
[0];
8186 if (!SYMBOLP (operation
)
8187 || !INTEGERP (target_idx
= Fget (operation
, Qtarget_idx
)))
8188 error ("Invalid first arguement");
8189 if (nargs
< 1 + XINT (target_idx
))
8190 error ("Too few arguments for operation: %s",
8191 SDATA (SYMBOL_NAME (operation
)));
8192 target
= args
[XINT (target_idx
) + 1];
8193 if (!(STRINGP (target
)
8194 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
8195 error ("Invalid %dth argument", XINT (target_idx
) + 1);
8197 chain
= ((EQ (operation
, Qinsert_file_contents
)
8198 || EQ (operation
, Qwrite_region
))
8199 ? Vfile_coding_system_alist
8200 : (EQ (operation
, Qopen_network_stream
)
8201 ? Vnetwork_coding_system_alist
8202 : Vprocess_coding_system_alist
));
8206 for (; CONSP (chain
); chain
= XCDR (chain
))
8212 && ((STRINGP (target
)
8213 && STRINGP (XCAR (elt
))
8214 && fast_string_match (XCAR (elt
), target
) >= 0)
8215 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
8218 /* Here, if VAL is both a valid coding system and a valid
8219 function symbol, we return VAL as a coding system. */
8222 if (! SYMBOLP (val
))
8224 if (! NILP (Fcoding_system_p (val
)))
8225 return Fcons (val
, val
);
8226 if (! NILP (Ffboundp (val
)))
8228 val
= call1 (val
, Flist (nargs
, args
));
8231 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
8232 return Fcons (val
, val
);
8240 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
8241 Sset_coding_system_priority
, 0, MANY
, 0,
8242 doc
: /* Assign higher priority to the coding systems given as arguments.
8243 If multiple coding systems belongs to the same category,
8244 all but the first one are ignored.
8246 usage: (set-coding-system-priority ...) */)
8252 int changed
[coding_category_max
];
8253 enum coding_category priorities
[coding_category_max
];
8255 bzero (changed
, sizeof changed
);
8257 for (i
= j
= 0; i
< nargs
; i
++)
8259 enum coding_category category
;
8260 Lisp_Object spec
, attrs
;
8262 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
8263 attrs
= AREF (spec
, 0);
8264 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8265 if (changed
[category
])
8266 /* Ignore this coding system because a coding system of the
8267 same category already had a higher priority. */
8269 changed
[category
] = 1;
8270 priorities
[j
++] = category
;
8271 if (coding_categories
[category
].id
>= 0
8272 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
8273 setup_coding_system (args
[i
], &coding_categories
[category
]);
8274 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
8277 /* Now we have decided top J priorities. Reflect the order of the
8278 original priorities to the remaining priorities. */
8280 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
8282 while (j
< coding_category_max
8283 && changed
[coding_priorities
[j
]])
8285 if (j
== coding_category_max
)
8287 priorities
[i
] = coding_priorities
[j
];
8290 bcopy (priorities
, coding_priorities
, sizeof priorities
);
8292 /* Update `coding-category-list'. */
8293 Vcoding_category_list
= Qnil
;
8294 for (i
= coding_category_max
- 1; i
>= 0; i
--)
8295 Vcoding_category_list
8296 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
8297 Vcoding_category_list
);
8302 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
8303 Scoding_system_priority_list
, 0, 1, 0,
8304 doc
: /* Return a list of coding systems ordered by their priorities.
8305 HIGHESTP non-nil means just return the highest priority one. */)
8307 Lisp_Object highestp
;
8312 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
8314 enum coding_category category
= coding_priorities
[i
];
8315 int id
= coding_categories
[category
].id
;
8320 attrs
= CODING_ID_ATTRS (id
);
8321 if (! NILP (highestp
))
8322 return CODING_ATTR_BASE_NAME (attrs
);
8323 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
8325 return Fnreverse (val
);
8328 static char *suffixes
[] = { "-unix", "-dos", "-mac" };
8331 make_subsidiaries (base
)
8334 Lisp_Object subsidiaries
;
8335 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
8336 char *buf
= (char *) alloca (base_name_len
+ 6);
8339 bcopy (SDATA (SYMBOL_NAME (base
)), buf
, base_name_len
);
8340 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
8341 for (i
= 0; i
< 3; i
++)
8343 bcopy (suffixes
[i
], buf
+ base_name_len
, strlen (suffixes
[i
]) + 1);
8344 ASET (subsidiaries
, i
, intern (buf
));
8346 return subsidiaries
;
8350 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
8351 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
8352 doc
: /* For internal use only.
8353 usage: (define-coding-system-internal ...) */)
8359 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
8360 Lisp_Object attrs
; /* Vector of attributes. */
8361 Lisp_Object eol_type
;
8362 Lisp_Object aliases
;
8363 Lisp_Object coding_type
, charset_list
, safe_charsets
;
8364 enum coding_category category
;
8365 Lisp_Object tail
, val
;
8366 int max_charset_id
= 0;
8369 if (nargs
< coding_arg_max
)
8372 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
8374 name
= args
[coding_arg_name
];
8375 CHECK_SYMBOL (name
);
8376 CODING_ATTR_BASE_NAME (attrs
) = name
;
8378 val
= args
[coding_arg_mnemonic
];
8379 if (! STRINGP (val
))
8380 CHECK_CHARACTER (val
);
8381 CODING_ATTR_MNEMONIC (attrs
) = val
;
8383 coding_type
= args
[coding_arg_coding_type
];
8384 CHECK_SYMBOL (coding_type
);
8385 CODING_ATTR_TYPE (attrs
) = coding_type
;
8387 charset_list
= args
[coding_arg_charset_list
];
8388 if (SYMBOLP (charset_list
))
8390 if (EQ (charset_list
, Qiso_2022
))
8392 if (! EQ (coding_type
, Qiso_2022
))
8393 error ("Invalid charset-list");
8394 charset_list
= Viso_2022_charset_list
;
8396 else if (EQ (charset_list
, Qemacs_mule
))
8398 if (! EQ (coding_type
, Qemacs_mule
))
8399 error ("Invalid charset-list");
8400 charset_list
= Vemacs_mule_charset_list
;
8402 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8403 if (max_charset_id
< XFASTINT (XCAR (tail
)))
8404 max_charset_id
= XFASTINT (XCAR (tail
));
8408 charset_list
= Fcopy_sequence (charset_list
);
8409 for (tail
= charset_list
; !NILP (tail
); tail
= Fcdr (tail
))
8411 struct charset
*charset
;
8414 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8415 if (EQ (coding_type
, Qiso_2022
)
8416 ? CHARSET_ISO_FINAL (charset
) < 0
8417 : EQ (coding_type
, Qemacs_mule
)
8418 ? CHARSET_EMACS_MULE_ID (charset
) < 0
8420 error ("Can't handle charset `%s'",
8421 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8423 XSETCAR (tail
, make_number (charset
->id
));
8424 if (max_charset_id
< charset
->id
)
8425 max_charset_id
= charset
->id
;
8428 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
8430 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
8432 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8433 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
8434 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
8436 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
8438 val
= args
[coding_arg_decode_translation_table
];
8439 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8441 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8443 val
= args
[coding_arg_encode_translation_table
];
8444 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8446 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8448 val
= args
[coding_arg_post_read_conversion
];
8450 CODING_ATTR_POST_READ (attrs
) = val
;
8452 val
= args
[coding_arg_pre_write_conversion
];
8454 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8456 val
= args
[coding_arg_default_char
];
8458 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
8461 CHECK_CHARACTER (val
);
8462 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8465 val
= args
[coding_arg_for_unibyte
];
8466 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
8468 val
= args
[coding_arg_plist
];
8470 CODING_ATTR_PLIST (attrs
) = val
;
8472 if (EQ (coding_type
, Qcharset
))
8474 /* Generate a lisp vector of 256 elements. Each element is nil,
8475 integer, or a list of charset IDs.
8477 If Nth element is nil, the byte code N is invalid in this
8480 If Nth element is a number NUM, N is the first byte of a
8481 charset whose ID is NUM.
8483 If Nth element is a list of charset IDs, N is the first byte
8484 of one of them. The list is sorted by dimensions of the
8485 charsets. A charset of smaller dimension comes firtst. */
8486 val
= Fmake_vector (make_number (256), Qnil
);
8488 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8490 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
8491 int dim
= CHARSET_DIMENSION (charset
);
8492 int idx
= (dim
- 1) * 4;
8494 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8495 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8497 for (i
= charset
->code_space
[idx
];
8498 i
<= charset
->code_space
[idx
+ 1]; i
++)
8500 Lisp_Object tmp
, tmp2
;
8503 tmp
= AREF (val
, i
);
8506 else if (NUMBERP (tmp
))
8508 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
8510 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
8512 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
8516 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
8518 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
8523 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
8526 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
8527 XSETCAR (tmp2
, XCAR (tail
));
8533 ASET (attrs
, coding_attr_charset_valids
, val
);
8534 category
= coding_category_charset
;
8536 else if (EQ (coding_type
, Qccl
))
8540 if (nargs
< coding_arg_ccl_max
)
8543 val
= args
[coding_arg_ccl_decoder
];
8544 CHECK_CCL_PROGRAM (val
);
8546 val
= Fcopy_sequence (val
);
8547 ASET (attrs
, coding_attr_ccl_decoder
, val
);
8549 val
= args
[coding_arg_ccl_encoder
];
8550 CHECK_CCL_PROGRAM (val
);
8552 val
= Fcopy_sequence (val
);
8553 ASET (attrs
, coding_attr_ccl_encoder
, val
);
8555 val
= args
[coding_arg_ccl_valids
];
8556 valids
= Fmake_string (make_number (256), make_number (0));
8557 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
8564 from
= to
= XINT (val
);
8565 if (from
< 0 || from
> 255)
8566 args_out_of_range_3 (val
, make_number (0), make_number (255));
8571 CHECK_NATNUM_CAR (val
);
8572 CHECK_NATNUM_CDR (val
);
8573 from
= XINT (XCAR (val
));
8575 args_out_of_range_3 (XCAR (val
),
8576 make_number (0), make_number (255));
8577 to
= XINT (XCDR (val
));
8578 if (to
< from
|| to
> 255)
8579 args_out_of_range_3 (XCDR (val
),
8580 XCAR (val
), make_number (255));
8582 for (i
= from
; i
<= to
; i
++)
8583 SSET (valids
, i
, 1);
8585 ASET (attrs
, coding_attr_ccl_valids
, valids
);
8587 category
= coding_category_ccl
;
8589 else if (EQ (coding_type
, Qutf_16
))
8591 Lisp_Object bom
, endian
;
8593 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8595 if (nargs
< coding_arg_utf16_max
)
8598 bom
= args
[coding_arg_utf16_bom
];
8599 if (! NILP (bom
) && ! EQ (bom
, Qt
))
8603 CHECK_CODING_SYSTEM (val
);
8605 CHECK_CODING_SYSTEM (val
);
8607 ASET (attrs
, coding_attr_utf_16_bom
, bom
);
8609 endian
= args
[coding_arg_utf16_endian
];
8610 CHECK_SYMBOL (endian
);
8613 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
8614 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
8615 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
8617 category
= (CONSP (bom
)
8618 ? coding_category_utf_16_auto
8620 ? (EQ (endian
, Qbig
)
8621 ? coding_category_utf_16_be_nosig
8622 : coding_category_utf_16_le_nosig
)
8623 : (EQ (endian
, Qbig
)
8624 ? coding_category_utf_16_be
8625 : coding_category_utf_16_le
));
8627 else if (EQ (coding_type
, Qiso_2022
))
8629 Lisp_Object initial
, reg_usage
, request
, flags
;
8632 if (nargs
< coding_arg_iso2022_max
)
8635 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
8636 CHECK_VECTOR (initial
);
8637 for (i
= 0; i
< 4; i
++)
8639 val
= Faref (initial
, make_number (i
));
8642 struct charset
*charset
;
8644 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8645 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
8646 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
8647 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8650 ASET (initial
, i
, make_number (-1));
8653 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
8654 CHECK_CONS (reg_usage
);
8655 CHECK_NUMBER_CAR (reg_usage
);
8656 CHECK_NUMBER_CDR (reg_usage
);
8658 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
8659 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
8667 CHECK_CHARSET_GET_ID (tmp
, id
);
8668 CHECK_NATNUM_CDR (val
);
8669 if (XINT (XCDR (val
)) >= 4)
8670 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
8671 XSETCAR (val
, make_number (id
));
8674 flags
= args
[coding_arg_iso2022_flags
];
8675 CHECK_NATNUM (flags
);
8677 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
8678 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
8680 ASET (attrs
, coding_attr_iso_initial
, initial
);
8681 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
8682 ASET (attrs
, coding_attr_iso_request
, request
);
8683 ASET (attrs
, coding_attr_iso_flags
, flags
);
8684 setup_iso_safe_charsets (attrs
);
8686 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
8687 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
8688 | CODING_ISO_FLAG_SINGLE_SHIFT
))
8689 ? coding_category_iso_7_else
8690 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8691 ? coding_category_iso_7
8692 : coding_category_iso_7_tight
);
8695 int id
= XINT (AREF (initial
, 1));
8697 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
8698 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8700 ? coding_category_iso_8_else
8701 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
8702 ? coding_category_iso_8_1
8703 : coding_category_iso_8_2
);
8705 if (category
!= coding_category_iso_8_1
8706 && category
!= coding_category_iso_8_2
)
8707 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8709 else if (EQ (coding_type
, Qemacs_mule
))
8711 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
8712 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
8713 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8714 category
= coding_category_emacs_mule
;
8716 else if (EQ (coding_type
, Qshift_jis
))
8719 struct charset
*charset
;
8721 if (XINT (Flength (charset_list
)) != 3
8722 && XINT (Flength (charset_list
)) != 4)
8723 error ("There should be three or four charsets");
8725 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8726 if (CHARSET_DIMENSION (charset
) != 1)
8727 error ("Dimension of charset %s is not one",
8728 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8729 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8730 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8732 charset_list
= XCDR (charset_list
);
8733 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8734 if (CHARSET_DIMENSION (charset
) != 1)
8735 error ("Dimension of charset %s is not one",
8736 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8738 charset_list
= XCDR (charset_list
);
8739 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8740 if (CHARSET_DIMENSION (charset
) != 2)
8741 error ("Dimension of charset %s is not two",
8742 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8744 charset_list
= XCDR (charset_list
);
8745 if (! NILP (charset_list
))
8747 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8748 if (CHARSET_DIMENSION (charset
) != 2)
8749 error ("Dimension of charset %s is not two",
8750 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8753 category
= coding_category_sjis
;
8754 Vsjis_coding_system
= name
;
8756 else if (EQ (coding_type
, Qbig5
))
8758 struct charset
*charset
;
8760 if (XINT (Flength (charset_list
)) != 2)
8761 error ("There should be just two charsets");
8763 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8764 if (CHARSET_DIMENSION (charset
) != 1)
8765 error ("Dimension of charset %s is not one",
8766 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8767 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8768 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8770 charset_list
= XCDR (charset_list
);
8771 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8772 if (CHARSET_DIMENSION (charset
) != 2)
8773 error ("Dimension of charset %s is not two",
8774 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8776 category
= coding_category_big5
;
8777 Vbig5_coding_system
= name
;
8779 else if (EQ (coding_type
, Qraw_text
))
8781 category
= coding_category_raw_text
;
8782 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8784 else if (EQ (coding_type
, Qutf_8
))
8786 category
= coding_category_utf_8
;
8787 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8789 else if (EQ (coding_type
, Qundecided
))
8790 category
= coding_category_undecided
;
8792 error ("Invalid coding system type: %s",
8793 SDATA (SYMBOL_NAME (coding_type
)));
8795 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
8796 CODING_ATTR_PLIST (attrs
)
8797 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
8798 CODING_ATTR_PLIST (attrs
)));
8800 eol_type
= args
[coding_arg_eol_type
];
8801 if (! NILP (eol_type
)
8802 && ! EQ (eol_type
, Qunix
)
8803 && ! EQ (eol_type
, Qdos
)
8804 && ! EQ (eol_type
, Qmac
))
8805 error ("Invalid eol-type");
8807 aliases
= Fcons (name
, Qnil
);
8809 if (NILP (eol_type
))
8811 eol_type
= make_subsidiaries (name
);
8812 for (i
= 0; i
< 3; i
++)
8814 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
8816 this_name
= AREF (eol_type
, i
);
8817 this_aliases
= Fcons (this_name
, Qnil
);
8818 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
8819 this_spec
= Fmake_vector (make_number (3), attrs
);
8820 ASET (this_spec
, 1, this_aliases
);
8821 ASET (this_spec
, 2, this_eol_type
);
8822 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
8823 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
8824 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
8825 Vcoding_system_alist
);
8829 spec_vec
= Fmake_vector (make_number (3), attrs
);
8830 ASET (spec_vec
, 1, aliases
);
8831 ASET (spec_vec
, 2, eol_type
);
8833 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
8834 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
8835 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
8836 Vcoding_system_alist
);
8839 int id
= coding_categories
[category
].id
;
8841 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
8842 setup_coding_system (name
, &coding_categories
[category
]);
8848 return Fsignal (Qwrong_number_of_arguments
,
8849 Fcons (intern ("define-coding-system-internal"),
8850 make_number (nargs
)));
8854 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
8856 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
8857 (coding_system
, prop
, val
)
8858 Lisp_Object coding_system
, prop
, val
;
8860 Lisp_Object spec
, attrs
, plist
;
8862 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8863 attrs
= AREF (spec
, 0);
8864 if (EQ (prop
, QCmnemonic
))
8866 if (! STRINGP (val
))
8867 CHECK_CHARACTER (val
);
8868 CODING_ATTR_MNEMONIC (attrs
) = val
;
8870 else if (EQ (prop
, QCdefalut_char
))
8873 val
= make_number (' ');
8875 CHECK_CHARACTER (val
);
8876 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8878 else if (EQ (prop
, QCdecode_translation_table
))
8880 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8882 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8884 else if (EQ (prop
, QCencode_translation_table
))
8886 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8888 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8890 else if (EQ (prop
, QCpost_read_conversion
))
8893 CODING_ATTR_POST_READ (attrs
) = val
;
8895 else if (EQ (prop
, QCpre_write_conversion
))
8898 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8901 CODING_ATTR_PLIST (attrs
)
8902 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
8907 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
8908 Sdefine_coding_system_alias
, 2, 2, 0,
8909 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
8910 (alias
, coding_system
)
8911 Lisp_Object alias
, coding_system
;
8913 Lisp_Object spec
, aliases
, eol_type
;
8915 CHECK_SYMBOL (alias
);
8916 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8917 aliases
= AREF (spec
, 1);
8918 /* ALISES should be a list of length more than zero, and the first
8919 element is a base coding system. Append ALIAS at the tail of the
8921 while (!NILP (XCDR (aliases
)))
8922 aliases
= XCDR (aliases
);
8923 XSETCDR (aliases
, Fcons (alias
, Qnil
));
8925 eol_type
= AREF (spec
, 2);
8926 if (VECTORP (eol_type
))
8928 Lisp_Object subsidiaries
;
8931 subsidiaries
= make_subsidiaries (alias
);
8932 for (i
= 0; i
< 3; i
++)
8933 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
8934 AREF (eol_type
, i
));
8937 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
8938 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
8939 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
8940 Vcoding_system_alist
);
8945 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
8947 doc
: /* Return the base of CODING-SYSTEM.
8948 Any alias or subsidiary coding system is not a base coding system. */)
8950 Lisp_Object coding_system
;
8952 Lisp_Object spec
, attrs
;
8954 if (NILP (coding_system
))
8955 return (Qno_conversion
);
8956 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8957 attrs
= AREF (spec
, 0);
8958 return CODING_ATTR_BASE_NAME (attrs
);
8961 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
8963 doc
: "Return the property list of CODING-SYSTEM.")
8965 Lisp_Object coding_system
;
8967 Lisp_Object spec
, attrs
;
8969 if (NILP (coding_system
))
8970 coding_system
= Qno_conversion
;
8971 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8972 attrs
= AREF (spec
, 0);
8973 return CODING_ATTR_PLIST (attrs
);
8977 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
8979 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
8981 Lisp_Object coding_system
;
8985 if (NILP (coding_system
))
8986 coding_system
= Qno_conversion
;
8987 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8988 return AREF (spec
, 1);
8991 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
8992 Scoding_system_eol_type
, 1, 1, 0,
8993 doc
: /* Return eol-type of CODING-SYSTEM.
8994 An eol-type is integer 0, 1, 2, or a vector of coding systems.
8996 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
8997 and CR respectively.
8999 A vector value indicates that a format of end-of-line should be
9000 detected automatically. Nth element of the vector is the subsidiary
9001 coding system whose eol-type is N. */)
9003 Lisp_Object coding_system
;
9005 Lisp_Object spec
, eol_type
;
9008 if (NILP (coding_system
))
9009 coding_system
= Qno_conversion
;
9010 if (! CODING_SYSTEM_P (coding_system
))
9012 spec
= CODING_SYSTEM_SPEC (coding_system
);
9013 eol_type
= AREF (spec
, 2);
9014 if (VECTORP (eol_type
))
9015 return Fcopy_sequence (eol_type
);
9016 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
9017 return make_number (n
);
9023 /*** 9. Post-amble ***/
9030 for (i
= 0; i
< coding_category_max
; i
++)
9032 coding_categories
[i
].id
= -1;
9033 coding_priorities
[i
] = i
;
9036 /* ISO2022 specific initialize routine. */
9037 for (i
= 0; i
< 0x20; i
++)
9038 iso_code_class
[i
] = ISO_control_0
;
9039 for (i
= 0x21; i
< 0x7F; i
++)
9040 iso_code_class
[i
] = ISO_graphic_plane_0
;
9041 for (i
= 0x80; i
< 0xA0; i
++)
9042 iso_code_class
[i
] = ISO_control_1
;
9043 for (i
= 0xA1; i
< 0xFF; i
++)
9044 iso_code_class
[i
] = ISO_graphic_plane_1
;
9045 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
9046 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
9047 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
9048 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
9049 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
9050 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
9051 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
9052 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
9053 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
9055 for (i
= 0; i
< 256; i
++)
9057 emacs_mule_bytes
[i
] = 1;
9059 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
9060 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
9061 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
9062 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
9070 staticpro (&Vcoding_system_hash_table
);
9072 Lisp_Object args
[2];
9075 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
9078 staticpro (&Vsjis_coding_system
);
9079 Vsjis_coding_system
= Qnil
;
9081 staticpro (&Vbig5_coding_system
);
9082 Vbig5_coding_system
= Qnil
;
9084 staticpro (&Vcode_conversion_reused_workbuf
);
9085 Vcode_conversion_reused_workbuf
= Qnil
;
9087 staticpro (&Vcode_conversion_workbuf_name
);
9088 Vcode_conversion_workbuf_name
= build_string (" *code-conversion-work*");
9090 reused_workbuf_in_use
= 0;
9092 DEFSYM (Qcharset
, "charset");
9093 DEFSYM (Qtarget_idx
, "target-idx");
9094 DEFSYM (Qcoding_system_history
, "coding-system-history");
9095 Fset (Qcoding_system_history
, Qnil
);
9097 /* Target FILENAME is the first argument. */
9098 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
9099 /* Target FILENAME is the third argument. */
9100 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
9102 DEFSYM (Qcall_process
, "call-process");
9103 /* Target PROGRAM is the first argument. */
9104 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
9106 DEFSYM (Qcall_process_region
, "call-process-region");
9107 /* Target PROGRAM is the third argument. */
9108 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
9110 DEFSYM (Qstart_process
, "start-process");
9111 /* Target PROGRAM is the third argument. */
9112 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
9114 DEFSYM (Qopen_network_stream
, "open-network-stream");
9115 /* Target SERVICE is the fourth argument. */
9116 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
9118 DEFSYM (Qcoding_system
, "coding-system");
9119 DEFSYM (Qcoding_aliases
, "coding-aliases");
9121 DEFSYM (Qeol_type
, "eol-type");
9122 DEFSYM (Qunix
, "unix");
9123 DEFSYM (Qdos
, "dos");
9125 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
9126 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
9127 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
9128 DEFSYM (Qdefault_char
, "default-char");
9129 DEFSYM (Qundecided
, "undecided");
9130 DEFSYM (Qno_conversion
, "no-conversion");
9131 DEFSYM (Qraw_text
, "raw-text");
9133 DEFSYM (Qiso_2022
, "iso-2022");
9135 DEFSYM (Qutf_8
, "utf-8");
9136 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
9138 DEFSYM (Qutf_16
, "utf-16");
9139 DEFSYM (Qbig
, "big");
9140 DEFSYM (Qlittle
, "little");
9142 DEFSYM (Qshift_jis
, "shift-jis");
9143 DEFSYM (Qbig5
, "big5");
9145 DEFSYM (Qcoding_system_p
, "coding-system-p");
9147 DEFSYM (Qcoding_system_error
, "coding-system-error");
9148 Fput (Qcoding_system_error
, Qerror_conditions
,
9149 Fcons (Qcoding_system_error
, Fcons (Qerror
, Qnil
)));
9150 Fput (Qcoding_system_error
, Qerror_message
,
9151 build_string ("Invalid coding system"));
9153 /* Intern this now in case it isn't already done.
9154 Setting this variable twice is harmless.
9155 But don't staticpro it here--that is done in alloc.c. */
9156 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
9158 DEFSYM (Qtranslation_table
, "translation-table");
9159 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
9160 DEFSYM (Qtranslation_table_id
, "translation-table-id");
9161 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
9162 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
9164 DEFSYM (Qvalid_codes
, "valid-codes");
9166 DEFSYM (Qemacs_mule
, "emacs-mule");
9168 DEFSYM (QCcategory
, ":category");
9169 DEFSYM (QCmnemonic
, ":mnemonic");
9170 DEFSYM (QCdefalut_char
, ":default-char");
9171 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
9172 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
9173 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
9174 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
9176 Vcoding_category_table
9177 = Fmake_vector (make_number (coding_category_max
), Qnil
);
9178 staticpro (&Vcoding_category_table
);
9179 /* Followings are target of code detection. */
9180 ASET (Vcoding_category_table
, coding_category_iso_7
,
9181 intern ("coding-category-iso-7"));
9182 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
9183 intern ("coding-category-iso-7-tight"));
9184 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
9185 intern ("coding-category-iso-8-1"));
9186 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
9187 intern ("coding-category-iso-8-2"));
9188 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
9189 intern ("coding-category-iso-7-else"));
9190 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
9191 intern ("coding-category-iso-8-else"));
9192 ASET (Vcoding_category_table
, coding_category_utf_8
,
9193 intern ("coding-category-utf-8"));
9194 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
9195 intern ("coding-category-utf-16-be"));
9196 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
9197 intern ("coding-category-utf-16-auto"));
9198 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
9199 intern ("coding-category-utf-16-le"));
9200 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
9201 intern ("coding-category-utf-16-be-nosig"));
9202 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
9203 intern ("coding-category-utf-16-le-nosig"));
9204 ASET (Vcoding_category_table
, coding_category_charset
,
9205 intern ("coding-category-charset"));
9206 ASET (Vcoding_category_table
, coding_category_sjis
,
9207 intern ("coding-category-sjis"));
9208 ASET (Vcoding_category_table
, coding_category_big5
,
9209 intern ("coding-category-big5"));
9210 ASET (Vcoding_category_table
, coding_category_ccl
,
9211 intern ("coding-category-ccl"));
9212 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
9213 intern ("coding-category-emacs-mule"));
9214 /* Followings are NOT target of code detection. */
9215 ASET (Vcoding_category_table
, coding_category_raw_text
,
9216 intern ("coding-category-raw-text"));
9217 ASET (Vcoding_category_table
, coding_category_undecided
,
9218 intern ("coding-category-undecided"));
9220 DEFSYM (Qinsufficient_source
, "insufficient-source");
9221 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
9222 DEFSYM (Qinvalid_source
, "invalid-source");
9223 DEFSYM (Qinterrupted
, "interrupted");
9224 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
9226 defsubr (&Scoding_system_p
);
9227 defsubr (&Sread_coding_system
);
9228 defsubr (&Sread_non_nil_coding_system
);
9229 defsubr (&Scheck_coding_system
);
9230 defsubr (&Sdetect_coding_region
);
9231 defsubr (&Sdetect_coding_string
);
9232 defsubr (&Sfind_coding_systems_region_internal
);
9233 defsubr (&Sunencodable_char_position
);
9234 defsubr (&Scheck_coding_systems_region
);
9235 defsubr (&Sdecode_coding_region
);
9236 defsubr (&Sencode_coding_region
);
9237 defsubr (&Sdecode_coding_string
);
9238 defsubr (&Sencode_coding_string
);
9239 defsubr (&Sdecode_sjis_char
);
9240 defsubr (&Sencode_sjis_char
);
9241 defsubr (&Sdecode_big5_char
);
9242 defsubr (&Sencode_big5_char
);
9243 defsubr (&Sset_terminal_coding_system_internal
);
9244 defsubr (&Sset_safe_terminal_coding_system_internal
);
9245 defsubr (&Sterminal_coding_system
);
9246 defsubr (&Sset_keyboard_coding_system_internal
);
9247 defsubr (&Skeyboard_coding_system
);
9248 defsubr (&Sfind_operation_coding_system
);
9249 defsubr (&Sset_coding_system_priority
);
9250 defsubr (&Sdefine_coding_system_internal
);
9251 defsubr (&Sdefine_coding_system_alias
);
9252 defsubr (&Scoding_system_put
);
9253 defsubr (&Scoding_system_base
);
9254 defsubr (&Scoding_system_plist
);
9255 defsubr (&Scoding_system_aliases
);
9256 defsubr (&Scoding_system_eol_type
);
9257 defsubr (&Scoding_system_priority_list
);
9259 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list
,
9260 doc
: /* List of coding systems.
9262 Do not alter the value of this variable manually. This variable should be
9263 updated by the functions `define-coding-system' and
9264 `define-coding-system-alias'. */);
9265 Vcoding_system_list
= Qnil
;
9267 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist
,
9268 doc
: /* Alist of coding system names.
9269 Each element is one element list of coding system name.
9270 This variable is given to `completing-read' as TABLE argument.
9272 Do not alter the value of this variable manually. This variable should be
9273 updated by the functions `make-coding-system' and
9274 `define-coding-system-alias'. */);
9275 Vcoding_system_alist
= Qnil
;
9277 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list
,
9278 doc
: /* List of coding-categories (symbols) ordered by priority.
9280 On detecting a coding system, Emacs tries code detection algorithms
9281 associated with each coding-category one by one in this order. When
9282 one algorithm agrees with a byte sequence of source text, the coding
9283 system bound to the corresponding coding-category is selected. */);
9287 Vcoding_category_list
= Qnil
;
9288 for (i
= coding_category_max
- 1; i
>= 0; i
--)
9289 Vcoding_category_list
9290 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
9291 Vcoding_category_list
);
9294 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read
,
9295 doc
: /* Specify the coding system for read operations.
9296 It is useful to bind this variable with `let', but do not set it globally.
9297 If the value is a coding system, it is used for decoding on read operation.
9298 If not, an appropriate element is used from one of the coding system alists:
9299 There are three such tables, `file-coding-system-alist',
9300 `process-coding-system-alist', and `network-coding-system-alist'. */);
9301 Vcoding_system_for_read
= Qnil
;
9303 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write
,
9304 doc
: /* Specify the coding system for write operations.
9305 Programs bind this variable with `let', but you should not set it globally.
9306 If the value is a coding system, it is used for encoding of output,
9307 when writing it to a file and when sending it to a file or subprocess.
9309 If this does not specify a coding system, an appropriate element
9310 is used from one of the coding system alists:
9311 There are three such tables, `file-coding-system-alist',
9312 `process-coding-system-alist', and `network-coding-system-alist'.
9313 For output to files, if the above procedure does not specify a coding system,
9314 the value of `buffer-file-coding-system' is used. */);
9315 Vcoding_system_for_write
= Qnil
;
9317 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used
,
9319 Coding system used in the latest file or process I/O. */);
9320 Vlast_coding_system_used
= Qnil
;
9322 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error
,
9324 Error status of the last code conversion.
9326 When an error was detected in the last code conversion, this variable
9327 is set to one of the following symbols.
9328 `insufficient-source'
9332 `insufficient-memory'
9333 When no error was detected, the value doesn't change. So, to check
9334 the error status of a code conversion by this variable, you must
9335 explicitly set this variable to nil before performing code
9337 Vlast_code_conversion_error
= Qnil
;
9339 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion
,
9341 *Non-nil means always inhibit code conversion of end-of-line format.
9342 See info node `Coding Systems' and info node `Text and Binary' concerning
9343 such conversion. */);
9344 inhibit_eol_conversion
= 0;
9346 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system
,
9348 Non-nil means process buffer inherits coding system of process output.
9349 Bind it to t if the process output is to be treated as if it were a file
9350 read from some filesystem. */);
9351 inherit_process_coding_system
= 0;
9353 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist
,
9355 Alist to decide a coding system to use for a file I/O operation.
9356 The format is ((PATTERN . VAL) ...),
9357 where PATTERN is a regular expression matching a file name,
9358 VAL is a coding system, a cons of coding systems, or a function symbol.
9359 If VAL is a coding system, it is used for both decoding and encoding
9361 If VAL is a cons of coding systems, the car part is used for decoding,
9362 and the cdr part is used for encoding.
9363 If VAL is a function symbol, the function must return a coding system
9364 or a cons of coding systems which are used as above. The function gets
9365 the arguments with which `find-operation-coding-systems' was called.
9367 See also the function `find-operation-coding-system'
9368 and the variable `auto-coding-alist'. */);
9369 Vfile_coding_system_alist
= Qnil
;
9371 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist
,
9373 Alist to decide a coding system to use for a process I/O operation.
9374 The format is ((PATTERN . VAL) ...),
9375 where PATTERN is a regular expression matching a program name,
9376 VAL is a coding system, a cons of coding systems, or a function symbol.
9377 If VAL is a coding system, it is used for both decoding what received
9378 from the program and encoding what sent to the program.
9379 If VAL is a cons of coding systems, the car part is used for decoding,
9380 and the cdr part is used for encoding.
9381 If VAL is a function symbol, the function must return a coding system
9382 or a cons of coding systems which are used as above.
9384 See also the function `find-operation-coding-system'. */);
9385 Vprocess_coding_system_alist
= Qnil
;
9387 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist
,
9389 Alist to decide a coding system to use for a network I/O operation.
9390 The format is ((PATTERN . VAL) ...),
9391 where PATTERN is a regular expression matching a network service name
9392 or is a port number to connect to,
9393 VAL is a coding system, a cons of coding systems, or a function symbol.
9394 If VAL is a coding system, it is used for both decoding what received
9395 from the network stream and encoding what sent to the network stream.
9396 If VAL is a cons of coding systems, the car part is used for decoding,
9397 and the cdr part is used for encoding.
9398 If VAL is a function symbol, the function must return a coding system
9399 or a cons of coding systems which are used as above.
9401 See also the function `find-operation-coding-system'. */);
9402 Vnetwork_coding_system_alist
= Qnil
;
9404 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system
,
9405 doc
: /* Coding system to use with system messages.
9406 Also used for decoding keyboard input on X Window system. */);
9407 Vlocale_coding_system
= Qnil
;
9409 /* The eol mnemonics are reset in startup.el system-dependently. */
9410 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix
,
9412 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
9413 eol_mnemonic_unix
= build_string (":");
9415 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos
,
9417 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
9418 eol_mnemonic_dos
= build_string ("\\");
9420 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac
,
9422 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
9423 eol_mnemonic_mac
= build_string ("/");
9425 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided
,
9427 *String displayed in mode line when end-of-line format is not yet determined. */);
9428 eol_mnemonic_undecided
= build_string (":");
9430 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation
,
9432 *Non-nil enables character translation while encoding and decoding. */);
9433 Venable_character_translation
= Qt
;
9435 DEFVAR_LISP ("standard-translation-table-for-decode",
9436 &Vstandard_translation_table_for_decode
,
9437 doc
: /* Table for translating characters while decoding. */);
9438 Vstandard_translation_table_for_decode
= Qnil
;
9440 DEFVAR_LISP ("standard-translation-table-for-encode",
9441 &Vstandard_translation_table_for_encode
,
9442 doc
: /* Table for translating characters while encoding. */);
9443 Vstandard_translation_table_for_encode
= Qnil
;
9445 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table
,
9446 doc
: /* Alist of charsets vs revision numbers.
9447 While encoding, if a charset (car part of an element) is found,
9448 designate it with the escape sequence identifying revision (cdr part
9449 of the element). */);
9450 Vcharset_revision_table
= Qnil
;
9452 DEFVAR_LISP ("default-process-coding-system",
9453 &Vdefault_process_coding_system
,
9454 doc
: /* Cons of coding systems used for process I/O by default.
9455 The car part is used for decoding a process output,
9456 the cdr part is used for encoding a text to be sent to a process. */);
9457 Vdefault_process_coding_system
= Qnil
;
9459 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table
,
9461 Table of extra Latin codes in the range 128..159 (inclusive).
9462 This is a vector of length 256.
9463 If Nth element is non-nil, the existence of code N in a file
9464 \(or output of subprocess) doesn't prevent it to be detected as
9465 a coding system of ISO 2022 variant which has a flag
9466 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
9467 or reading output of a subprocess.
9468 Only 128th through 159th elements has a meaning. */);
9469 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
9471 DEFVAR_LISP ("select-safe-coding-system-function",
9472 &Vselect_safe_coding_system_function
,
9474 Function to call to select safe coding system for encoding a text.
9476 If set, this function is called to force a user to select a proper
9477 coding system which can encode the text in the case that a default
9478 coding system used in each operation can't encode the text.
9480 The default value is `select-safe-coding-system' (which see). */);
9481 Vselect_safe_coding_system_function
= Qnil
;
9483 DEFVAR_BOOL ("coding-system-require-warning",
9484 &coding_system_require_warning
,
9485 doc
: /* Internal use only.
9486 If non-nil, on writing a file, `select-safe-coding-system-function' is
9487 called even if `coding-system-for-write' is non-nil. The command
9488 `universal-coding-system-argument' binds this variable to t temporarily. */);
9489 coding_system_require_warning
= 0;
9492 DEFVAR_BOOL ("inhibit-iso-escape-detection",
9493 &inhibit_iso_escape_detection
,
9495 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
9497 By default, on reading a file, Emacs tries to detect how the text is
9498 encoded. This code detection is sensitive to escape sequences. If
9499 the sequence is valid as ISO2022, the code is determined as one of
9500 the ISO2022 encodings, and the file is decoded by the corresponding
9501 coding system (e.g. `iso-2022-7bit').
9503 However, there may be a case that you want to read escape sequences in
9504 a file as is. In such a case, you can set this variable to non-nil.
9505 Then, as the code detection ignores any escape sequences, no file is
9506 detected as encoded in some ISO2022 encoding. The result is that all
9507 escape sequences become visible in a buffer.
9509 The default value is nil, and it is strongly recommended not to change
9510 it. That is because many Emacs Lisp source files that contain
9511 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
9512 in Emacs's distribution, and they won't be decoded correctly on
9513 reading if you suppress escape sequence detection.
9515 The other way to read escape sequences in a file without decoding is
9516 to explicitly specify some coding system that doesn't use ISO2022's
9517 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
9518 inhibit_iso_escape_detection
= 0;
9520 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input
,
9521 doc
: /* Char table for translating self-inserting characters.
9522 This is applied to the result of input methods, not their input. See also
9523 `keyboard-translate-table'. */);
9524 Vtranslation_table_for_input
= Qnil
;
9527 Lisp_Object args
[coding_arg_max
];
9528 Lisp_Object plist
[16];
9531 for (i
= 0; i
< coding_arg_max
; i
++)
9534 plist
[0] = intern (":name");
9535 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
9536 plist
[2] = intern (":mnemonic");
9537 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
9538 plist
[4] = intern (":coding-type");
9539 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
9540 plist
[6] = intern (":ascii-compatible-p");
9541 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
9542 plist
[8] = intern (":default-char");
9543 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
9544 plist
[10] = intern (":for-unibyte");
9545 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
9546 plist
[12] = intern (":docstring");
9547 plist
[13] = build_string ("Do no conversion.\n\
9549 When you visit a file with this coding, the file is read into a\n\
9550 unibyte buffer as is, thus each byte of a file is treated as a\n\
9552 plist
[14] = intern (":eol-type");
9553 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
9554 args
[coding_arg_plist
] = Flist (16, plist
);
9555 Fdefine_coding_system_internal (coding_arg_max
, args
);
9558 setup_coding_system (Qno_conversion
, &keyboard_coding
);
9559 setup_coding_system (Qno_conversion
, &terminal_coding
);
9560 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
9565 for (i
= 0; i
< coding_category_max
; i
++)
9566 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
9571 emacs_strerror (error_number
)
9576 synchronize_system_messages_locale ();
9577 str
= strerror (error_number
);
9579 if (! NILP (Vlocale_coding_system
))
9581 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
9582 Vlocale_coding_system
,
9584 str
= (char *) SDATA (dec
);
9592 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
9593 (do not change this comment) */